feat: add support for assuming model existence in chat and with_model methods

Author: crmne

lib/ruby_llm.rb

@@ -30,8 +30,8 @@ module RubyLLM
   class Error < StandardError; end
 
   class << self
-    def chat(model: nil, provider: nil)
-      Chat.new(model: model, provider: provider)
+    def chat(model: nil, provider: nil, assume_model_exists: false)
+      Chat.new(model:, provider:, assume_model_exists:)
     end
 
     def embed(...)

lib/ruby_llm/chat.rb

@@ -8,14 +8,18 @@ module RubyLLM
   #   chat = RubyLLM.chat
   #   chat.ask "What's the best way to learn Ruby?"
   #   chat.ask "Can you elaborate on that?"
-  class Chat
+  class Chat # rubocop:disable Metrics/ClassLength
     include Enumerable
 
     attr_reader :model, :messages, :tools
 
-    def initialize(model: nil, provider: nil)
+    def initialize(model: nil, provider: nil, assume_model_exists: false) # rubocop:disable Metrics/MethodLength
+      if assume_model_exists && !provider
+        raise ArgumentError, 'Provider must be specified if assume_model_exists is true'
+      end
+
       model_id = model || RubyLLM.config.default_model
-      with_model(model_id, provider: provider)
+      with_model(model_id, provider: provider, assume_exists: assume_model_exists)
       @temperature = 0.7
       @messages = []
       @tools = {}
@@ -54,9 +58,18 @@ def with_tools(*tools)
       self
     end
 
-    def with_model(model_id, provider: nil)
-      @model = Models.find model_id, provider
-      @provider = Provider.providers[@model.provider.to_sym] || raise(Error, "Unknown provider: #{@model.provider}")
+    def with_model(model_id, provider: nil, assume_exists: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      if assume_exists
+        raise ArgumentError, 'Provider must be specified if assume_exists is true' unless provider
+
+        @provider = Provider.providers[provider.to_sym] || raise(Error, "Unknown provider: #{provider.to_sym}")
+        @model = Struct.new(:id, :provider, :supports_functions, :supports_vision).new(model_id, provider, true, true)
+        RubyLLM.logger.warn "Assuming model '#{model_id}' exists for provider '#{provider}'. " \
+                            'Capabilities may not be accurately reflected.'
+      else
+        @model = Models.find model_id, provider
+        @provider = Provider.providers[@model.provider.to_sym] || raise(Error, "Unknown provider: #{@model.provider}")
+      end
       self
     end
 

spec/fixtures/vcr_cassettes/chat_assume_model_exists_works_with_models_not_in_registry_but_available_in_api.yml

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyLLM::Chat do
+  include_context 'with configured RubyLLM'
+
+  describe '#assume_model_exists' do
+    let(:real_model) { 'gpt-4.1-nano' }
+    let(:custom_model) { 'my-custom-model' }
+    let(:provider) { :openai }
+    # Keep a reference to the original models for cleanup
+    let!(:original_models) { RubyLLM::Models.instance.all.dup }
+
+    # Clean up the model registry after each test
+    after do
+      RubyLLM::Models.instance.instance_variable_set(:@models, original_models)
+    end
+
+    it 'requires provider when assuming model exists' do
+      expect do
+        described_class.new(model: custom_model, assume_model_exists: true)
+      end.to raise_error(ArgumentError, /Provider must be specified/)
+    end
+
+    it 'skips registry validation when assuming model exists' do # rubocop:disable RSpec/ExampleLength,RSpec/MultipleExpectations
+      expect(RubyLLM::Models).not_to receive(:find) # rubocop:disable RSpec/MessageSpies
+
+      chat = described_class.new(
+        model: custom_model,
+        provider: provider,
+        assume_model_exists: true
+      )
+
+      expect(chat.model.id).to eq(custom_model)
+      expect(chat.model.provider).to eq(provider)
+    end
+
+    it 'works with RubyLLM.chat convenience method' do # rubocop:disable RSpec/ExampleLength
+      chat = RubyLLM.chat(
+        model: custom_model,
+        provider: provider,
+        assume_model_exists: true
+      )
+
+      expect(chat.model.id).to eq(custom_model)
+    end
+
+    it 'works with models not in registry but available in API' do # rubocop:disable RSpec/ExampleLength,RSpec/MultipleExpectations
+      # Simulate model missing from registry
+      filtered_models = original_models.reject { |m| m.id == real_model }
+      RubyLLM::Models.instance.instance_variable_set(:@models, filtered_models)
+
+      # Should raise error when not assuming existence
+      expect do
+        RubyLLM.chat(model: real_model)
+      end.to raise_error(RubyLLM::ModelNotFoundError)
+
+      # Should work when assuming existence
+      chat = RubyLLM.chat(
+        model: real_model,
+        provider: provider,
+        assume_model_exists: true
+      )
+
+      # Should be able to actually use the model (relies on VCR)
+      response = chat.ask('What is 2 + 2?')
+      expect(response.content).to include('4')
+    end
+
+    it 'works with with_model method' do # rubocop:disable RSpec/MultipleExpectations
+      chat = RubyLLM.chat
+
+      chat.with_model(custom_model, provider: provider, assume_exists: true)
+
+      expect(chat.model.id).to eq(custom_model)
+      expect(chat.model.provider).to eq(provider)
+    end
+  end
+end