ruby_llm 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42dd9dfdb910f8e5df4eb6114ed59586a13e4a51797173d3f3bdb13b6d59c28b
-  data.tar.gz: fa4e0aa374c915ab5e97146bcacb438fc2c3fca0c029ed51c1aea6c934769da8
+  metadata.gz: 8000141c827d6b8f899bcf2ec5a23153ecf83f8196fcd35cee7af8de2f9e58e4
+  data.tar.gz: '069b322ad8df77cd46ee2dd9b72ec02578281ff9e6c96b349e46aff911ee85b8'
 SHA512:
-  metadata.gz: 3e5489b6fdd071de5c4281c9cc8eff9d345dd10876cb6773144873d2e58c3ec400109d208706d4c04c12d93328f5864f839907521fd751accc29aa9a5a753602
-  data.tar.gz: 19c33af936f0626262ad3e469c955b98aee8599b15fe088ba745e31584f91ebbf166cabc981bef4bef526f6e6c96800aebe07dc133ca732313ca58598aa6273f
+  metadata.gz: 6d651244192242fc5f06cf8126932659b46dec1228ed97e3a9876dd7ee581f8972d42fbaca209698b1c42e1704ebb766ca07b450cfd7651d9192f8d46d3f8c42
+  data.tar.gz: 9511e7a1c10a8b73cebbefb59a26be1fd7dcec10c369f57d60b7a348d180a8037700826400d9da41b630d190b940aa73ba7c5cbdb7fbd0f4b6cffbcbe563d732

data/README.md

@@ -9,7 +9,7 @@
 
 <p>RubyLLM is the Ruby-native AI framework. Work with models, tools, and agents through one consistent API, in plain Ruby or Rails.</p>
 
-[Website](https://rubyllm.com/) · [Getting Started](https://rubyllm.com/getting-started/) · [What's New in 2.0](https://rubyllm.com/whats-new-in-2-0/)
+[Website](https://rubyllm.com/) · [Getting Started](https://rubyllm.com/getting-started/) · [What's New in 2.1](https://rubyllm.com/whats-new-in-2-1/)
 
 Battle tested at [<picture><source media="(prefers-color-scheme: dark)" srcset="https://chatwithwork.com/logotype-dark.svg"><img src="https://chatwithwork.com/logotype.svg" alt="Chat with Work" height="30" align="absmiddle"></picture>](https://chatwithwork.com) - *Fully private work AI*
 
@@ -21,12 +21,14 @@ Battle tested at [<picture><source media="(prefers-color-scheme: dark)" srcset="
 <a href="https://trendshift.io/repositories/13640" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13640" alt="crmne%2Fruby_llm | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </div>
 
+https://github.com/user-attachments/assets/519fcb20-ab8c-4af3-9185-0953b3ba7b81
+
 > [!NOTE]
 > Using RubyLLM? [Share your story](https://tally.so/r/3Na02p)! Takes 5 minutes.
 
 ---
 
-## 17 providers. One Ruby API.
+## 19 providers. One Ruby API.
 
 Build with the models you want. Move between hosted and local providers without rewriting your application, or connect an OpenAI-compatible endpoint.
 
@@ -34,7 +36,7 @@ Build with the models you want. Move between hosted and local providers without
 
 ## Start with one line. Add files, tools, and agents
 
-These examples use **2.0.0**. Follow [Getting Started](https://rubyllm.com/getting-started/) to install it and configure the providers you want to try. For 1.x, use the [1.x docs](https://rubyllm.com/v1/).
+These examples use **2.1.1**. Follow [Getting Started](https://rubyllm.com/getting-started/) to install it and configure the providers you want to try. For 1.x, use the [1.x docs](https://rubyllm.com/v1/).
 
 ```ruby
 # Just ask
@@ -111,6 +113,15 @@ puts document.markdown
 RubyLLM.moderate("Some user-generated content").flagged?
 ```
 
+```ruby
+# Ask a typed question about your data
+class Urgency < RubyLLM::Judge
+  probability :urgent, "Does this need attention today?"
+end
+
+Urgency.judge("Please refund my duplicate charge today.").urgent.probability
+```
+
 ```ruby
 # Let AI use your code
 class Weather < RubyLLM::Tool
@@ -150,9 +161,55 @@ response = chat.with_schema(ProductSchema).ask "Analyze this product", with: "pr
 response.parsed
 ```
 
+## Evaluate your agents
+
+Keep questions and expected answers in a dataset. RubyLLM checks correctness by default. Run the same evaluation from Ruby, RSpec, Minitest, or Rake.
+
+Evaluations are available on `main`. Follow the [development installation guide](https://rubyllm.com/next/getting-started/) to try them.
+
+`app/agents/support_agent.rb`
+
+```ruby
+class SupportAgent < RubyLLM::Agent
+  instructions "Accept returns of unopened items within 30 days."
+end
+```
+
+`app/evals/support_evaluation.rb`
+
+```ruby
+class SupportEvaluation < RubyLLM::Evaluation
+  def perform(input)
+    SupportAgent.new.ask(input)
+  end
+end
+```
+
+`app/evals/support_evaluation.yml`
+
+```yaml
+cases:
+  - name: within_return_window
+    inputs: Can I return an unopened item after 14 days?
+    expected_output: Yes, unopened items can be returned within 30 days.
+  - name: past_return_window
+    inputs: Can I return an unopened item after 45 days?
+    expected_output: No, the 30-day return window has passed.
+```
+
+Run the evaluation:
+
+```ruby
+report = SupportEvaluation.run
+report.passed?
+report.cost.total
+```
+
+The model evaluator checks meaning, so answers can use different wording. Declare your own criteria, add Ruby assertions, or choose a configured evaluator agent or judgment model. [Read the evaluation guides](https://rubyllm.com/next/evaluations/).
+
 ## A complete AI framework for Ruby
 
-Agents, workflows, RAG, images, audio, and video. Built in, with usage tracking and Rails integration to bring them into your app.
+Agents, evaluations, workflows, RAG, images, audio, and video. Built in, with usage tracking and Rails integration to bring them into your app.
 
 * **Chat:** Conversational AI with `RubyLLM.chat`
 * **Vision:** Analyze images and videos
@@ -164,11 +221,13 @@ Agents, workflows, RAG, images, audio, and video. Built in, with usage tracking
 * **Embeddings:** Generate embeddings with `RubyLLM.embed`
 * **Reranking:** Order retrieval candidates by relevance with `RubyLLM.rerank`
 * **Moderation:** Content flags, categories, and scores with `RubyLLM.moderate`
+* **Judgments:** Probabilities, choices, and scores with `RubyLLM::Judge` and `RubyLLM.judge`
 * **Tools:** Let AI call your Ruby methods
 * **Tool approval:** Park a run until a human approves with `requires_approval`
 * **The agentic loop:** Drive it yourself with `ask_later`, `step`, and `complete?`
 * **Provider tools:** Web search, code execution, and MCP connectors with `with_provider_tools`
 * **Agents:** Reusable assistants with `RubyLLM::Agent`
+* **Evaluations (main):** Reusable datasets, model criteria, and Ruby assertions with [`RubyLLM::Evaluation`](https://rubyllm.com/next/evaluations/)
 * **Prompt templates:** ERB prompts in `app/prompts`, rendered with `RubyLLM.render_prompt`
 * **Workflows:** Correlate multi-agent runs in your telemetry with `RubyLLM.workflow`
 * **Structured output:** Define a Ruby schema and read the result with `response.parsed`
@@ -185,14 +244,14 @@ Agents, workflows, RAG, images, audio, and video. Built in, with usage tracking
 * **Batches:** Provider-side batch processing with provider-specific discounts via `RubyLLM.batch`
 * **Compaction:** Let providers condense long conversations with `with_compaction`
 * **Token counting:** Count a request before you send it with `count_tokens`
-* **Providers:** OpenAI, Azure, xAI, Anthropic, Gemini, VertexAI, Bedrock, Cohere, DeepSeek, Mistral, Ollama, Ollama Cloud, OpenRouter, Perplexity, GPUStack, ElevenLabs, Deepgram, and any OpenAI-compatible API
+* **Providers:** OpenAI, Azure, xAI, Anthropic, Gemini, VertexAI, Bedrock, Cohere, DeepSeek, Hetzner, Mistral, Ollama, Ollama Cloud, OpenRouter, Perplexity, GPUStack, ElevenLabs, Deepgram, TypeSafe, and any OpenAI-compatible API
 
 ## Installation
 
-Install RubyLLM 2.0:
+Install RubyLLM 2.1:
 
 ```bash
-bundle add ruby_llm --version 2.0.0
+bundle add ruby_llm --version 2.1.1
 ```
 
 Configure a provider in your script, or in `config/initializers/ruby_llm.rb` in Rails:
@@ -205,7 +264,7 @@ RubyLLM.configure do |config|
 end
 ```
 
-Configure the other providers used by the examples as needed: Gemini for files, xAI for video, Mistral for OCR, and Cohere for reranking. [Getting Started](https://rubyllm.com/getting-started/) shows each setup beside its example. If your app uses 1.16, follow the [upgrade guide](https://rubyllm.com/upgrading/) before deploying 2.0.
+Configure the other providers used by the examples as needed: Gemini for files, xAI for video, Mistral for OCR, and Cohere for reranking. [Getting Started](https://rubyllm.com/getting-started/) shows each setup beside its example. Upgrading an existing app? Follow the [upgrade guide](https://rubyllm.com/upgrading/).
 
 ## Feels at home in Rails
 

data/lib/generators/ruby_llm/generator_helpers.rb

@@ -149,15 +149,11 @@ module RubyLLM
       end
 
       def postgresql?
-        ::ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
-      rescue StandardError
-        false
+        adapter_built_on?('ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
       end
 
       def mysql?
-        ::ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
-      rescue StandardError
-        false
+        adapter_built_on?('ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter')
       end
 
       def table_exists?(table_name)
@@ -202,8 +198,74 @@ module RubyLLM
         end
       end
 
+      module ClassMethods # :nodoc:
+        def start(given_args = ARGV, config = {})
+          super(GeneratorHelpers.reorder_arguments(given_args, class_options), config)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def self.reorder_arguments(args, options)
+        mappings = []
+        switches = []
+        index = 0
+
+        while index < args.length
+          argument = args[index]
+          return mappings + switches + args[index..] if argument == '--'
+
+          unless argument.is_a?(String) && argument.start_with?('-')
+            mappings << argument
+            index += 1
+            next
+          end
+
+          switches << argument
+          index += 1
+          next if argument.include?('=')
+
+          value = args[index]
+          next unless takes_value?(options, argument, value)
+
+          switches << value
+          index += 1
+        end
+
+        mappings + switches
+      end
+
+      def self.takes_value?(options, argument, value)
+        return false if value.nil? || value.to_s.start_with?('-')
+
+        option = option_for(options, argument)
+        return false unless option
+        return %w[true TRUE t T false FALSE f F].include?(value) if option.type == :boolean
+
+        !argument.tr('_', '-').match?(/\A--(?:no|skip)-/)
+      end
+
+      def self.option_for(options, argument)
+        return option_for(options, "-#{argument[-1]}") if argument.match?(/\A-[a-z]{2,}\z/i)
+
+        name = argument.sub(/\A--?/, '').tr('-', '_')
+        options[name.to_sym] || options[name] ||
+          options.values.find { |candidate| candidate.aliases.include?(argument) } ||
+          options[name.sub(/\A(?:no|skip)_/, '').to_sym] || options[name.sub(/\A(?:no|skip)_/, '')]
+      end
+
       private
 
+      # Compares class names because referencing an adapter constant loads
+      # its database driver, which the application may not have installed.
+      def adapter_built_on?(adapter_class_name)
+        ::ActiveRecord::Base.connection.class.ancestors.any? { |ancestor| ancestor.name == adapter_class_name }
+      rescue StandardError
+        false
+      end
+
       def add_association_params(params, default_assoc, table_name, model_name,
                                  owner_table:, owner_model_name:, plural: false)
         assoc = plural ? table_name.to_sym : table_name.singularize.to_sym

data/lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -5,6 +5,7 @@ class <%= create_migration_class_name(message_table_name) %> < ActiveRecord::Mig
       t.string :role, null: false
       t.text :content
       t.boolean :cache_until_here, null: false, default: false
+      t.string :cache_ttl
       t.text :thinking_text
       t.text :thinking_signature
 <% if postgresql? %>

data/lib/generators/ruby_llm/install/templates/create_ruby_llm_records_migration.rb.tt

@@ -47,10 +47,16 @@ class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Mig
       t.boolean :remote, default: false, null: false
 <% if postgresql? %>
       t.jsonb :arguments, default: {}
+      t.jsonb :mcp_state
+      t.jsonb :mcp_result
 <% elsif mysql? %>
       t.json :arguments
+      t.json :mcp_state
+      t.json :mcp_result
 <% else %>
       t.json :arguments, default: {}
+      t.json :mcp_state
+      t.json :mcp_result
 <% end %>
       t.timestamps
 
@@ -60,9 +66,19 @@ class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Mig
       t.index :name
     end
 
+    create_table :ruby_llm_mcp_credentials, id: :<%= reference_type %> do |t|
+      t.references :owner, polymorphic: true, type: :<%= reference_type %>
+      t.string :key, null: false
+      t.text :data
+      t.timestamps
+
+      t.index :key, unique: true
+    end
+
     create_table :ruby_llm_usages, id: :<%= reference_type %> do |t|
-      t.references :chat, polymorphic: true, null: false, type: :<%= reference_type %>, index: false
+      t.references :chat, polymorphic: true, type: :<%= reference_type %>, index: false
       t.references :message, polymorphic: true, type: :<%= reference_type %>, index: false
+      t.references :owner, polymorphic: true, type: :<%= reference_type %>, index: false
       t.string :operation, null: false
       t.string :provider, null: false
       t.string :model, null: false
@@ -72,6 +88,11 @@ class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Mig
       t.integer :cache_read_tokens
       t.integer :cache_write_tokens
       t.integer :thinking_tokens
+<% if postgresql? %>
+      t.jsonb :server_tool_use
+<% else %>
+      t.json :server_tool_use
+<% end %>
       t.decimal :input_cost, precision: 16, scale: 10
       t.decimal :output_cost, precision: 16, scale: 10
       t.decimal :cache_read_cost, precision: 16, scale: 10
@@ -82,9 +103,10 @@ class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Mig
 
       t.index [ :chat_type, :chat_id ]
       t.index [ :message_type, :message_id ]
+      t.index [ :owner_type, :owner_id ]
       t.index :status
-      t.check_constraint "operation IN (<%= usage_operations_sql %>)"
-      t.check_constraint "status IN (<%= usage_statuses_sql %>)"
+      t.check_constraint "operation<%= '::text' if postgresql? %> IN (<%= usage_operations_sql %>)"
+      t.check_constraint "status<%= '::text' if postgresql? %> IN (<%= usage_statuses_sql %>)"
     end
 
     create_table :ruby_llm_batches, id: :<%= reference_type %> do |t|
@@ -113,5 +135,16 @@ class <%= create_migration_class_name('ruby_llm_records') %> < ActiveRecord::Mig
       t.index [ :provider, :provider_batch_id ], unique: true
       t.index :status
     end
+
+    create_table :ruby_llm_provider_files, id: :<%= reference_type %> do |t|
+      t.string :blob_key, null: false
+      t.string :provider, null: false
+      t.string :account, null: false
+      t.text :file_id, null: false
+      t.datetime :expires_at
+      t.timestamps
+
+      t.index [ :blob_key, :provider, :account ], unique: true, name: "index_ruby_llm_provider_files_uniqueness"
+    end
   end
 end

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

@@ -11,6 +11,9 @@ module RubyLLM
       # Generates first-party providers and standalone provider gems.
       class Scaffold # :nodoc: all
         SUPPORTED_MODES = %w[core gem].freeze
+        HASH_ENTRY_LINE = /^\s+'[^']+' => '[^']+',?$/
+        ENV_LINE = /^#?\s*[A-Z][A-Z0-9_]*=/
+        SPEC_CONFIG_LINE = /^ {6}config\.[a-z0-9_]+ = /
         SUPPORTED_DIALECTS = %w[chat_completions responses anthropic gemini converse ollama].freeze
         TEMPLATE_ROOT = File.expand_path('templates', __dir__)
 
@@ -157,7 +160,7 @@ module RubyLLM
           path = file_path('lib/ruby_llm.rb')
           return unless File.exist?(path)
 
-          insert_sorted_line(path, "  '#{slug}' => '#{class_name}',", /^\s+'[^']+' => '[^']+',?$/)
+          insert_sorted_entry(path, "  '#{slug}' => '#{class_name}'")
           insert_sorted_line(
             path,
             "RubyLLM::Provider.register :#{slug}, RubyLLM::Providers::#{class_name}",
@@ -169,8 +172,8 @@ module RubyLLM
           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}")
+          insert_sorted_line(path, "#{api_key_env}=$(op read \"op://RubyLLM/#{class_name}/credential\")", ENV_LINE)
+          insert_sorted_line(path, "#{api_base_env}=#{api_base}", ENV_LINE)
         end
 
         def update_core_spec_configuration
@@ -178,9 +181,9 @@ module RubyLLM
           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 =/)
+                             SPEC_CONFIG_LINE)
           insert_sorted_line(path, "      config.#{api_key_config} = ENV.fetch('#{api_key_env}', 'test')",
-                             /^\s+config\.[a-z0-9_]+_api_key =/)
+                             SPEC_CONFIG_LINE)
         end
 
         def update_core_vcr_configuration
@@ -196,7 +199,7 @@ module RubyLLM
           path = file_path('lib/ruby_llm/models.rb')
           return unless File.exist?(path)
 
-          insert_before_first(path, "      '#{models_dev_provider}' => '#{slug}',", /^    \}\.freeze$/)
+          insert_sorted_entry(path, "      '#{models_dev_provider}' => '#{slug}'")
         end
 
         def write_template(template, relative_path, executable: false)
@@ -218,38 +221,45 @@ module RubyLLM
           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")
+          lines.insert(sorted_line_index(lines, line, matcher), "#{line}\n")
           File.write(path, lines.join)
           record(:updated, relative_path(path))
         end
 
-        def insert_before_first(path, line, matcher)
+        # Lands after the last smaller line, above any comment that describes the next one.
+        def sorted_line_index(lines, line, matcher)
+          indexes = lines.each_index.select { |index| lines[index].match?(matcher) }
+          index = indexes.find { |candidate| line < lines[candidate].chomp } || indexes.last&.+(1) || lines.length
+          index -= 1 while index.positive? && lines[index - 1].strip.start_with?('#')
+          index
+        end
+
+        # Inserts a `'key' => 'value'` entry into the first multiline hash literal of
+        # such entries, keeping it sorted and every entry but the last comma-terminated.
+        def insert_sorted_entry(path, entry)
           content = File.read(path)
-          return record(:skipped, relative_path(path)) if content.include?(line)
+          return record(:skipped, relative_path(path)) if content.match?(/^#{Regexp.escape(entry)},?$/)
 
           lines = content.lines
-          insert_at = lines.index { |candidate| candidate.match?(matcher) } || lines.length
-          lines.insert(insert_at, "#{line}\n")
+          block = hash_entry_block(lines)
+          insert_at = block.find { |index| entry < lines[index].chomp.delete_suffix(',') } || (block.last + 1)
+          lines.insert(insert_at, "#{entry}\n")
+          hash_entry_block(lines)[0...-1].each { |index| lines[index] = "#{lines[index].chomp.delete_suffix(',')},\n" }
           File.write(path, lines.join)
           record(:updated, relative_path(path))
         end
 
+        def hash_entry_block(lines)
+          first = lines.index { |line| line.match?(HASH_ENTRY_LINE) }
+          last = (first...lines.length).take_while { |index| lines[index].match?(HASH_ENTRY_LINE) }.last
+          (first..last).to_a
+        end
+
         def record(action, path)
           @result.public_send(action) << path
           @result.actions << [action, path]

data/lib/generators/ruby_llm/provider/templates/gem/ci.yml.erb

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ["3.1", "3.2", "3.3", "3.4", "4.0"]
+        ruby-version: ["3.2", "3.3", "3.4", "4.0"]
     steps:
       - uses: actions/checkout@v6
 
@@ -26,7 +26,3 @@ jobs:
           bundler-cache: true
 
       - run: bundle exec rake
-        if: matrix.ruby-version != '3.1'
-
-      - run: bundle exec rake rubocop flay spec
-        if: matrix.ruby-version == '3.1'

data/lib/generators/ruby_llm/provider/templates/gem/gemfile.erb

@@ -5,7 +5,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
-  gem 'archspec' if RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.2')
+  gem 'archspec' if RUBY_ENGINE == 'ruby'
   gem 'bundler', '>= 2.0'
   gem 'dotenv'
   gem 'flay'

data/lib/generators/ruby_llm/provider/templates/gem/gemspec.erb

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description = 'Adds <%= class_name %> provider support to RubyLLM.'
   spec.homepage = 'https://github.com/<%= github_owner %>/<%= gem_name %>'
   spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.1'
+  spec.required_ruby_version = '>= 3.2'
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage

data/lib/generators/ruby_llm/provider/templates/gem/rubocop.yml.erb

@@ -5,7 +5,7 @@ plugins:
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.2
   Exclude:
     - Archspec.rb
     - vendor/**/*

data/lib/generators/ruby_llm/upgrade/templates/upgrade_ruby_llm_to_2_1.rb.tt

@@ -0,0 +1,78 @@
+class <%= 'upgrade_ruby_llm_to_2_1'.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    unless table_exists?(:ruby_llm_mcp_credentials)
+      create_table :ruby_llm_mcp_credentials, id: :<%= reference_type %> do |t|
+        t.references :owner, polymorphic: true, type: :<%= reference_type %>
+        t.string :key, null: false
+        t.text :data
+        t.timestamps
+
+        t.index :key, unique: true
+      end
+    end
+
+    unless column_exists?(:ruby_llm_tool_calls, :mcp_state)
+      if column_exists?(:ruby_llm_tool_calls, :pending_input)
+        rename_column :ruby_llm_tool_calls, :pending_input, :mcp_state
+      else
+<% if postgresql? -%>
+        add_column :ruby_llm_tool_calls, :mcp_state, :jsonb
+<% else -%>
+        add_column :ruby_llm_tool_calls, :mcp_state, :json
+<% end -%>
+      end
+    end
+
+    unless column_exists?(:ruby_llm_tool_calls, :mcp_result)
+<% if postgresql? -%>
+      add_column :ruby_llm_tool_calls, :mcp_result, :jsonb
+<% else -%>
+      add_column :ruby_llm_tool_calls, :mcp_result, :json
+<% end -%>
+    end
+
+    unless column_exists?(:ruby_llm_usages, :server_tool_use)
+<% if postgresql? -%>
+      add_column :ruby_llm_usages, :server_tool_use, :jsonb
+<% else -%>
+      add_column :ruby_llm_usages, :server_tool_use, :json
+<% end -%>
+    end
+
+    if columns(:ruby_llm_usages).any? { |column| column.name == "chat_id" && !column.null }
+      change_column_null :ruby_llm_usages, :chat_type, true
+      change_column_null :ruby_llm_usages, :chat_id, true
+    end
+
+    unless column_exists?(:ruby_llm_usages, :owner_id)
+      add_reference :ruby_llm_usages, :owner, polymorphic: true, type: :<%= reference_type %>, index: true
+    end
+
+    reversible do |direction|
+      direction.up do
+        operations = check_constraints(:ruby_llm_usages).find { |constraint| constraint.expression.include?("operation") }
+        if operations && [<%= usage_operations_sql %>].any? { |operation| !operations.expression.include?("'#{operation}'") }
+          remove_check_constraint :ruby_llm_usages, name: operations.name
+          add_check_constraint :ruby_llm_usages, "operation<%= '::text' if postgresql? %> IN (<%= usage_operations_sql %>)"
+        end
+      end
+    end
+
+    unless column_exists?(:<%= message_table_name %>, :cache_ttl)
+      add_column :<%= message_table_name %>, :cache_ttl, :string
+    end
+
+    unless table_exists?(:ruby_llm_provider_files)
+      create_table :ruby_llm_provider_files, id: :<%= reference_type %> do |t|
+        t.string :blob_key, null: false
+        t.string :provider, null: false
+        t.string :account, null: false
+        t.text :file_id, null: false
+        t.datetime :expires_at
+        t.timestamps
+
+        t.index [ :blob_key, :provider, :account ], unique: true, name: "index_ruby_llm_provider_files_uniqueness"
+      end
+    end
+  end
+end