ruby_llm 1.16.0 → 2.0.0.rc2

data/lib/generators/ruby_llm/provider/cli.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'open3'
+require 'stringio'
+require 'generators/ruby_llm/provider/scaffold'
+
+module RubyLLM
+  module Generators
+    module Provider # :nodoc: all
+      # Command-line interface for public provider gem generation.
+      class CLI # :nodoc: all
+        ACTION_LABELS = { written: 'create', updated: 'update', skipped: 'skip' }.freeze
+
+        class HelpRequested < StandardError; end
+
+        def self.run(argv, out: $stdout, err: $stderr)
+          new(argv, out:, err:).run
+        end
+
+        def self.parse_options(argv, mode:)
+          new(argv, out: StringIO.new, err: StringIO.new).parse_provider_options(mode:)
+        end
+
+        def initialize(argv, out:, err:)
+          @argv = argv.dup
+          @out = out
+          @err = err
+        end
+
+        def run
+          command = @argv.shift
+
+          case command
+          when 'provider-gem'
+            generate_provider_gem
+          when nil, 'help', '-h', '--help'
+            @out.puts help
+            0
+          else
+            @err.puts "Unknown command: #{command}"
+            @err.puts
+            @err.puts help
+            1
+          end
+        rescue HelpRequested => e
+          @out.puts e.message
+          0
+        rescue ArgumentError, OptionParser::ParseError => e
+          @err.puts e.message
+          1
+        end
+
+        def parse_provider_options(mode:)
+          options = { mode: mode }
+          options[:destination] = Dir.pwd if mode == 'core'
+          parser = OptionParser.new
+          parser.banner = "Usage: #{command_for(mode)} [options]"
+          parser.on('--destination PATH', 'Exact directory to write into') { |value| options[:destination] = value }
+          parser.on('--api-base URL', 'Provider API base URL') { |value| options[:api_base] = value }
+          parser.on('--api-key-env NAME', 'Environment variable for the provider API key') do |value|
+            options[:api_key_env] = value
+          end
+          parser.on('--api-base-env NAME', 'Environment variable for the provider API base') do |value|
+            options[:api_base_env] = value
+          end
+          parser.on('--dialect NAME', "Wire dialect: #{Scaffold::SUPPORTED_DIALECTS.join(', ')}") do |value|
+            options[:dialect] = value
+          end
+          if mode == 'core'
+            parser.on('--models-dev-provider NAME', 'models.dev provider key for first-party core providers') do |value|
+              options[:models_dev_provider] = value
+            end
+          end
+          parser.on('--[no-]dynamic-models', 'Allow model ids that are not in the registry') do |value|
+            options[:dynamic_models] = value
+          end
+          if mode == 'gem'
+            parser.on('--gem-name NAME', 'RubyGems package name') { |value| options[:gem_name] = value }
+            parser.on('--github-owner OWNER', 'GitHub owner or organization for generated metadata') do |value|
+              options[:github_owner] = value
+            end
+            parser.on('--skip-bundle', 'Do not run bundle install') { options[:skip_bundle] = true }
+          end
+          parser.on('--force', 'Overwrite existing generated files') { options[:force] = true }
+          parser.on('-h', '--help', 'Print help') { raise HelpRequested, parser.to_s }
+
+          parser.parse!(@argv)
+          name = @argv.shift
+          raise ArgumentError, parser.to_s unless name
+          raise ArgumentError, "Unexpected arguments: #{@argv.join(' ')}" if @argv.any?
+
+          [name, options]
+        end
+
+        private
+
+        def generate_provider_gem
+          name, options = parse_provider_options(mode: 'gem')
+          skip_bundle = options.delete(:skip_bundle)
+          scaffold = Scaffold.new(name, **options)
+          destination_existed = Dir.exist?(scaffold.destination)
+          result = scaffold.generate
+
+          report_file_actions(result, scaffold.destination, destination_existed:)
+          return 1 unless initialize_git_repository(scaffold.destination)
+          return 1 unless skip_bundle || install_dependencies(scaffold.destination)
+
+          0
+        end
+
+        def report_file_actions(result, destination, destination_existed:)
+          report_action(destination_existed ? 'exist' : 'create', destination)
+          result.actions.each do |action, path|
+            report_action(ACTION_LABELS.fetch(action), path)
+          end
+        end
+
+        def report_action(action, path)
+          @out.puts format('%<action>12s  %<path>s', action:, path:)
+        end
+
+        def initialize_git_repository(destination)
+          command = git_init_command
+          report_action('run', command.join(' '))
+          stdout, stderr, status = Open3.capture3(*command, chdir: destination)
+          @out.print(stdout)
+          @err.print(stderr)
+          @err.puts 'Git repository initialization failed.' unless status.success?
+          status.success?
+        rescue Errno::ENOENT => e
+          @err.puts "Git repository initialization failed: #{e.message}"
+          false
+        end
+
+        def install_dependencies(destination)
+          command = %w[bundle install]
+          report_action('run', command.join(' '))
+          stdout, stderr, status = Open3.capture3(*command, chdir: destination)
+          @out.print(stdout)
+          @err.print(stderr)
+          @err.puts 'Bundle install failed.' unless status.success?
+          status.success?
+        rescue Errno::ENOENT => e
+          @err.puts "Bundle install failed: #{e.message}"
+          false
+        end
+
+        def git_init_command
+          _output, status = Open3.capture2e('git', 'config', '--get', 'init.defaultBranch')
+          status.success? ? %w[git init] : %w[git init -b main]
+        rescue Errno::ENOENT
+          %w[git init]
+        end
+
+        def help
+          <<~HELP
+            Usage:
+              ruby_llm provider-gem NAME [options]
+
+            Generates a standalone RubyLLM provider gem with provider code, specs,
+            CI, release workflow, ArchSpec, Flay, RuboCop, and live VCR specs.
+            Creates ruby_llm-providers-NAME in the current directory by default;
+            --destination selects an exact directory. Initializes the target as a
+            Git repository and runs bundle install.
+          HELP
+        end
+
+        def command_for(mode)
+          mode == 'core' ? 'script/generate-provider NAME' : 'ruby_llm provider-gem NAME'
+        end
+      end
+    end
+  end
+end

data/lib/generators/ruby_llm/provider/scaffold.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+require 'pathname'
+require 'ruby_llm/support/utils'
+
+module RubyLLM
+  module Generators
+    module Provider # :nodoc: all
+      # Generates first-party providers and standalone provider gems.
+      class Scaffold # :nodoc: all
+        SUPPORTED_MODES = %w[core gem].freeze
+        SUPPORTED_DIALECTS = %w[chat_completions responses anthropic gemini converse ollama].freeze
+        TEMPLATE_ROOT = File.expand_path('templates', __dir__)
+
+        Result = Struct.new(:written, :updated, :skipped, :actions, keyword_init: true) do
+          def changed
+            written + updated
+          end
+        end
+
+        attr_reader :name, :mode, :destination, :api_base, :api_key_env, :api_base_env,
+                    :dialect, :models_dev_provider, :gem_name, :github_owner
+
+        def initialize(name, **options)
+          @name = normalize_provider_name(name)
+          @mode = normalize_option(options.fetch(:mode, :core), SUPPORTED_MODES, 'mode')
+          @dialect = normalize_option(options.fetch(:dialect, :chat_completions), SUPPORTED_DIALECTS, 'dialect')
+          @api_base = options[:api_base] || 'https://api.example.com/v1'
+          @api_key_env = options[:api_key_env] || "#{env_prefix}_API_KEY"
+          @api_base_env = options[:api_base_env] || "#{env_prefix}_API_BASE"
+          @models_dev_provider = blank_to_nil(options[:models_dev_provider])
+          @dynamic_models = dynamic_models_option?(options)
+          @gem_name = normalize_gem_name(options[:gem_name] || "ruby_llm-providers-#{slug.tr('_', '-')}")
+          @destination = File.expand_path(options[:destination] || default_destination)
+          @github_owner = options[:github_owner] || 'your-github-org'
+          @force = options.fetch(:force, false)
+          @result = Result.new(written: [], updated: [], skipped: [], actions: [])
+        end
+
+        def generate
+          mode == 'core' ? generate_core_provider : generate_provider_gem
+          @result
+        end
+
+        def class_name
+          @class_name ||= classify(name)
+        end
+
+        def slug
+          @slug ||= RubyLLM::Support::Utils.underscore(class_name).tr('-', '_')
+        end
+
+        def env_prefix
+          slug.upcase
+        end
+
+        def api_key_config
+          "#{slug}_api_key"
+        end
+
+        def api_base_config
+          "#{slug}_api_base"
+        end
+
+        def dynamic_models?
+          !!@dynamic_models
+        end
+
+        def protocol_name
+          dialect == 'ollama' ? 'chat_completions' : dialect
+        end
+
+        def protocol_class_name
+          {
+            'chat_completions' => 'ChatCompletions',
+            'responses' => 'Responses',
+            'anthropic' => 'Anthropic',
+            'gemini' => 'Gemini',
+            'converse' => 'Converse',
+            'ollama' => 'ChatCompletions'
+          }.fetch(dialect)
+        end
+
+        def protocol_superclass
+          {
+            'chat_completions' => 'Protocols::ChatCompletions',
+            'responses' => 'Protocols::Responses',
+            'anthropic' => 'Protocols::Anthropic',
+            'gemini' => 'Protocols::Gemini',
+            'converse' => 'Protocols::Converse',
+            'ollama' => 'Ollama::ChatCompletions'
+          }.fetch(dialect)
+        end
+
+        def provider_description
+          "#{class_name} API integration."
+        end
+
+        def require_path
+          "ruby_llm/providers/#{slug}"
+        end
+
+        private
+
+        def generate_core_provider
+          write_template 'core/provider.rb.erb', "lib/ruby_llm/providers/#{slug}.rb"
+          write_template 'core/provider_spec.rb.erb', "spec/ruby_llm/providers/#{slug}_spec.rb"
+
+          update_core_registration
+          update_core_env_example
+          update_core_spec_configuration
+          update_core_vcr_configuration
+          update_core_models_dev_map if models_dev_provider
+        end
+
+        def generate_provider_gem
+          write_template 'gem/gitignore.erb', '.gitignore'
+          write_template 'gem/rspec.erb', '.rspec'
+          write_template 'gem/rubocop.yml.erb', '.rubocop.yml'
+          write_template 'gem/overcommit.yml.erb', '.overcommit.yml'
+          write_template 'gem/flayignore.erb', '.flayignore'
+          write_template 'gem/env.erb', '.env'
+          write_template 'gem/gemfile.erb', 'Gemfile'
+          write_template 'gem/rakefile.erb', 'Rakefile'
+          write_template 'gem/archspec.rb.erb', 'Archspec.rb'
+          write_template 'gem/readme.md.erb', 'README.md'
+          write_template 'gem/license.erb', 'LICENSE'
+          write_template 'gem/gemspec.erb', "#{gem_name}.gemspec"
+          write_template 'gem/ci.yml.erb', '.github/workflows/ci.yml'
+          write_template 'gem/release.yml.erb', '.github/workflows/release.yml'
+          write_template 'gem/gitleaks.yml.erb', '.github/workflows/gitleaks.yml'
+          write_template 'gem/bin/setup.erb', 'bin/setup', executable: true
+          write_template 'gem/bin/console.erb', 'bin/console', executable: true
+          write_template 'gem/provider.rb.erb', "lib/ruby_llm/providers/#{slug}.rb"
+          write_template 'gem/spec_helper.rb.erb', 'spec/spec_helper.rb'
+          write_template 'gem/rubyllm_configuration.rb.erb', 'spec/support/rubyllm_configuration.rb'
+          write_template 'gem/vcr_configuration.rb.erb', 'spec/support/vcr_configuration.rb'
+          write_template 'gem/models.rb.erb', 'spec/support/models.rb'
+          write_template 'gem/provider_spec.rb.erb', "spec/ruby_llm/providers/#{slug}_spec.rb"
+          write_template 'gem/chat_spec.rb.erb', 'spec/ruby_llm/chat_spec.rb'
+          write_template 'gem/chat_streaming_spec.rb.erb', 'spec/ruby_llm/chat_streaming_spec.rb'
+          write_template 'gem/chat_tools_spec.rb.erb', 'spec/ruby_llm/chat_tools_spec.rb'
+          write_template 'gem/chat_schema_spec.rb.erb', 'spec/ruby_llm/chat_schema_spec.rb'
+          write_template 'gem/embedding_spec.rb.erb', 'spec/ruby_llm/embedding_spec.rb'
+          write_template 'gem/image_spec.rb.erb', 'spec/ruby_llm/image_spec.rb'
+          write_template 'gem/speech_spec.rb.erb', 'spec/ruby_llm/speech_spec.rb'
+          write_template 'gem/video_spec.rb.erb', 'spec/ruby_llm/video_spec.rb'
+          write_template 'gem/moderation_spec.rb.erb', 'spec/ruby_llm/moderation_spec.rb'
+          write_template 'gem/rerank_spec.rb.erb', 'spec/ruby_llm/rerank_spec.rb'
+          write_template 'gem/models_spec.rb.erb', 'spec/ruby_llm/models_spec.rb'
+          write_template 'gem/fixtures_gitkeep.erb', 'spec/fixtures/vcr_cassettes/.gitkeep'
+        end
+
+        def update_core_registration
+          path = file_path('lib/ruby_llm.rb')
+          return unless File.exist?(path)
+
+          insert_sorted_line(path, "  '#{slug}' => '#{class_name}',", /^\s+'[^']+' => '[^']+',?$/)
+          insert_sorted_line(
+            path,
+            "RubyLLM::Provider.register :#{slug}, RubyLLM::Providers::#{class_name}",
+            /^RubyLLM::Provider\.register /
+          )
+        end
+
+        def update_core_env_example
+          path = file_path('.env.example')
+          return unless File.exist?(path)
+
+          append_unique_line(path, "#{api_key_env}=$(op read \"op://RubyLLM/#{class_name}/credential\")")
+          append_unique_line(path, "#{api_base_env}=#{api_base}")
+        end
+
+        def update_core_spec_configuration
+          path = file_path('spec/support/rubyllm_configuration.rb')
+          return unless File.exist?(path)
+
+          insert_sorted_line(path, "      config.#{api_base_config} = ENV.fetch('#{api_base_env}', '#{api_base}')",
+                             /^\s+config\.[a-z0-9_]+_api_base =/)
+          insert_sorted_line(path, "      config.#{api_key_config} = ENV.fetch('#{api_key_env}', 'test')",
+                             /^\s+config\.[a-z0-9_]+_api_key =/)
+        end
+
+        def update_core_vcr_configuration
+          path = file_path('spec/support/vcr_configuration.rb')
+          return unless File.exist?(path)
+
+          line = "  config.filter_sensitive_data('<#{api_key_env}>') { " \
+                 "ENV.fetch('#{api_key_env}', nil) }"
+          insert_sorted_line(path, line, /^\s+config\.filter_sensitive_data\('<[A-Z0-9_]+>'\)/)
+        end
+
+        def update_core_models_dev_map
+          path = file_path('lib/ruby_llm/models.rb')
+          return unless File.exist?(path)
+
+          insert_before_first(path, "      '#{models_dev_provider}' => '#{slug}',", /^    \}\.freeze$/)
+        end
+
+        def write_template(template, relative_path, executable: false)
+          content = ERB.new(File.read(template_path(template)), trim_mode: '-').result(binding)
+          write_file(relative_path, content, executable:)
+        end
+
+        def write_file(relative_path, content, executable: false)
+          path = file_path(relative_path)
+          existed = File.exist?(path)
+          if existed && !@force
+            record(:skipped, relative_path)
+            return
+          end
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, content)
+          FileUtils.chmod('+x', path) if executable
+          record(existed ? :updated : :written, relative_path)
+        end
+
+        def append_unique_line(path, line)
+          content = File.exist?(path) ? File.read(path) : ''
+          return record(:skipped, relative_path(path)) if content.include?(line)
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, "#{content.chomp}\n#{line}\n")
+          record(:updated, relative_path(path))
+        end
+
+        def insert_sorted_line(path, line, matcher)
+          content = File.read(path)
+          return record(:skipped, relative_path(path)) if content.include?(line)
+
+          lines = content.lines
+          indexes = lines.each_index.select { |index| lines[index].match?(matcher) }
+          insert_at = indexes.find { |index| line < lines[index].chomp } || indexes.last&.+(1) || lines.length
+          lines.insert(insert_at, "#{line}\n")
+          File.write(path, lines.join)
+          record(:updated, relative_path(path))
+        end
+
+        def insert_before_first(path, line, matcher)
+          content = File.read(path)
+          return record(:skipped, relative_path(path)) if content.include?(line)
+
+          lines = content.lines
+          insert_at = lines.index { |candidate| candidate.match?(matcher) } || lines.length
+          lines.insert(insert_at, "#{line}\n")
+          File.write(path, lines.join)
+          record(:updated, relative_path(path))
+        end
+
+        def record(action, path)
+          @result.public_send(action) << path
+          @result.actions << [action, path]
+          path
+        end
+
+        def file_path(relative_path)
+          File.join(destination, relative_path)
+        end
+
+        def relative_path(path)
+          Pathname.new(path).relative_path_from(Pathname.new(destination)).to_s
+        end
+
+        def template_path(relative_path)
+          File.join(TEMPLATE_ROOT, relative_path)
+        end
+
+        def default_destination
+          mode == 'gem' ? File.join(Dir.pwd, gem_name) : Dir.pwd
+        end
+
+        def normalize_option(value, allowed, name)
+          normalized = value.to_s.tr('-', '_')
+          return normalized if allowed.include?(normalized)
+
+          raise ArgumentError, "unsupported #{name}: #{value.inspect}. Expected one of: #{allowed.join(', ')}"
+        end
+
+        def normalize_gem_name(value)
+          value = value.to_s
+          return value if value.match?(/\A[A-Za-z0-9][A-Za-z0-9._-]*\z/)
+
+          raise ArgumentError, 'gem name must contain only letters, numbers, ., - or _'
+        end
+
+        def normalize_provider_name(value)
+          value = value.to_s.strip
+          return value if value.match?(/\A[A-Za-z][A-Za-z0-9_-]*\z/)
+
+          raise ArgumentError, 'provider name must start with a letter and contain only letters, numbers, - or _'
+        end
+
+        def classify(value)
+          words = value.to_s.tr('-', '_').split('_').reject(&:empty?)
+          return value if value.match?(/\A[A-Z][A-Za-z0-9]*\z/)
+
+          words.map { |word| word[0].upcase + word[1..] }.join
+        end
+
+        def blank_to_nil(value)
+          value = value.to_s.strip
+          value.empty? ? nil : value
+        end
+
+        def truthy?(value)
+          case value
+          when true, 'true', '1', 1, 'yes', 'on' then true
+          else false
+          end
+        end
+
+        def dynamic_models_option?(options)
+          return truthy?(options[:dynamic_models]) if options.key?(:dynamic_models)
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/generators/ruby_llm/provider/templates/core/provider.rb.erb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # <%= provider_description %>
+    class <%= class_name %> < Provider
+      class <%= protocol_class_name %> < <%= protocol_superclass %>
+      end
+
+      protocol :<%= protocol_name %>, <%= protocol_class_name %>
+
+      def api_base
+        @config.<%= api_base_config %> || '<%= api_base %>'
+      end
+
+      def headers
+        { 'Authorization' => "Bearer #{@config.<%= api_key_config %>}" }
+      end
+
+      class << self
+        def configuration_options
+          %i[<%= api_key_config %> <%= api_base_config %>]
+        end
+
+        def configuration_requirements
+          %i[<%= api_key_config %>]
+        end
+<% if dynamic_models? -%>
+
+        def assume_models_exist?
+          true
+        end
+<% end -%>
+      end
+    end
+  end
+end

data/lib/generators/ruby_llm/provider/templates/core/provider_spec.rb.erb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyLLM::Providers::<%= class_name %> do
+  subject(:provider) { described_class.new(config) }
+
+  let(:config) do
+    RubyLLM::Configuration.new.tap do |provider_config|
+      provider_config.<%= api_key_config %> = 'test-key'
+      provider_config.<%= api_base_config %> = 'https://example.test/v1'
+    end
+  end
+
+  it 'registers a default protocol' do
+    expect(described_class.protocols).to include(<%= "#{protocol_name}:" %> described_class::<%= protocol_class_name %>)
+  end
+
+  it 'declares provider configuration' do
+    expect(described_class.configuration_options).to eq(%i[<%= api_key_config %> <%= api_base_config %>])
+    expect(described_class.configuration_requirements).to eq(%i[<%= api_key_config %>])
+  end
+
+  it 'uses configured API base and bearer token' do
+    expect(provider.api_base).to eq('https://example.test/v1')
+    expect(provider.headers).to eq('Authorization' => 'Bearer test-key')
+  end
+<% if dynamic_models? -%>
+
+  it 'allows provider model ids missing from the registry' do
+    expect(described_class.assume_models_exist?).to be(true)
+  end
+<% end -%>
+end

data/lib/generators/ruby_llm/provider/templates/gem/archspec.rb.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source 'lib/**/*.rb'
+
+component :provider,
+          in: %w[
+            lib/ruby_llm/providers/<%= slug %>.rb
+            lib/ruby_llm/providers/<%= slug %>/**/*.rb
+          ],
+          namespace: 'RubyLLM::Providers::<%= class_name %>'
+
+provider.cannot_reference_constants 'RSpec', 'WebMock', 'VCR'
+
+preset :ruby_conventions

data/lib/generators/ruby_llm/provider/templates/gem/bin/console.erb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'dotenv/load'
+require '<%= require_path %>'
+
+require 'irb'
+
+RubyLLM.configure do |config|
+  config.<%= api_key_config %> = ENV.fetch('<%= api_key_env %>', nil)
+  config.<%= api_base_config %> = ENV.fetch('<%= api_base_env %>', '<%= api_base %>')
+end
+
+IRB.start(__FILE__)

data/lib/generators/ruby_llm/provider/templates/gem/bin/setup.erb

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/lib/generators/ruby_llm/provider/templates/gem/chat_schema_spec.rb.erb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyLLM::Chat, :live do
+  include_context 'with configured RubyLLM'
+
+  let(:person_schema) do
+    {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        age: { type: 'integer' }
+      },
+      required: %w[name age],
+      additionalProperties: false
+    }
+  end
+
+  each_model(STRUCTURED_OUTPUT_MODELS) do |provider, model|
+    it "#{provider}/#{model} returns structured output" do
+      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
+                        .with_schema(person_schema)
+                        .ask('Generate a person named John who is 30 years old')
+
+      expect(response.content).to be_a(String)
+      expect(response.parsed).to include('name' => 'John', 'age' => 30)
+    end
+  end
+end

data/lib/generators/ruby_llm/provider/templates/gem/chat_spec.rb.erb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubyLLM::Chat, :live do
+  include_context 'with configured RubyLLM'
+
+  each_model(CHAT_MODELS) do |provider, model|
+    it "#{provider}/#{model} can have a basic conversation" do
+      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true).ask("What's 2 + 2?")
+
+      expect(response.content).to include('4')
+      expect(response.role).to eq(:assistant)
+      expect(response.tokens.input.to_i).to be_positive
+      expect(response.tokens.output.to_i).to be_positive
+    end
+
+    it "#{provider}/#{model} returns the raw response" do
+      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
+                        .ask('What is the capital of France?')
+
+      expect(response.raw.status).to eq(200)
+      expect(response.raw.headers).not_to be_empty
+      expect(response.raw.body).not_to be_empty
+      expect(response.raw.env.request_body).not_to be_empty
+    end
+
+    it "#{provider}/#{model} can handle a multi-turn conversation" do
+      chat = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
+
+      expect(chat.ask('Who created the programming language Ruby?').content).to match(/Matz|Matsumoto/i)
+      expect(chat.ask('What year was Ruby first released?').content).to include('199')
+    end
+  end
+end