dify_llm 1.6.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cf640d22ec6e4390de10874e92f3d5386df4a7fb16249fdc3b9e3c685aef24d8
+  data.tar.gz: d3a832819f2300fdbe92fc8123344c862244af1e066a0d3ed4ab99c8e37146be
+SHA512:
+  metadata.gz: 051e1512fb39e9c775fda04aef83e4749cf1eb00140e96d5c7d8e40944300532162971bc75da9c1b93084682fe77fbb81bc631c8a5a8369cee8392cf488fc06f
+  data.tar.gz: 0e63f109548b3a41ec18a64b00c243a27eb793a85f303a9d35fa9516c98d8c029654e7c7b4d9f34bf6e248424435d39f20954c51b26faee48caf033a1e627a96

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Carmine Paolino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+<div align="center">
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="/docs/assets/images/logotype_dark.svg">
+  <img src="/docs/assets/images/logotype.svg" alt="RubyLLM" height="120" width="250">
+</picture>
+
+<strong>One *beautiful* Ruby API for GPT, Claude, Gemini, and more.</strong>
+
+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) — *Claude Code for your documents*
+
+[![Gem Version](https://badge.fury.io/rb/ruby_llm.svg?a=7)](https://badge.fury.io/rb/ruby_llm)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Downloads](https://img.shields.io/gem/dt/ruby_llm)](https://rubygems.org/gems/ruby_llm)
+[![codecov](https://codecov.io/gh/crmne/ruby_llm/branch/main/graph/badge.svg?a=2)](https://codecov.io/gh/crmne/ruby_llm)
+
+<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>
+
+> [!NOTE]
+> Using RubyLLM in production? [Share your story](https://tally.so/r/3Na02p)! Takes 5 minutes.
+
+---
+
+Build chatbots, AI agents, RAG applications. Works with OpenAI, Anthropic, Google, AWS, local models, and any OpenAI-compatible API.
+
+## Why RubyLLM?
+
+Every AI provider ships their own bloated client. Different APIs. Different response formats. Different conventions. It's exhausting.
+
+RubyLLM gives you one beautiful API for all of them. Same interface whether you're using GPT, Claude, or your local Ollama. Just three dependencies: Faraday, Zeitwerk, and Marcel. That's it.
+
+## Show me the code
+
+```ruby
+# Just ask questions
+chat = RubyLLM.chat
+chat.ask "What's the best way to learn Ruby?"
+```
+
+```ruby
+# Analyze any file type
+chat.ask "What's in this image?", with: "ruby_conf.jpg"
+chat.ask "Describe this meeting", with: "meeting.wav"
+chat.ask "Summarize this document", with: "contract.pdf"
+chat.ask "Explain this code", with: "app.rb"
+```
+
+```ruby
+# Multiple files at once
+chat.ask "Analyze these files", with: ["diagram.png", "report.pdf", "notes.txt"]
+```
+
+```ruby
+# Stream responses
+chat.ask "Tell me a story about Ruby" do |chunk|
+  print chunk.content
+end
+```
+
+```ruby
+# Generate images
+RubyLLM.paint "a sunset over mountains in watercolor style"
+```
+
+```ruby
+# Create embeddings
+RubyLLM.embed "Ruby is elegant and expressive"
+```
+
+```ruby
+# Let AI use your code
+class Weather < RubyLLM::Tool
+  description "Get current weather"
+  param :latitude
+  param :longitude
+
+  def execute(latitude:, longitude:)
+    url = "https://api.open-meteo.com/v1/forecast?latitude=#{latitude}&longitude=#{longitude}&current=temperature_2m,wind_speed_10m"
+    JSON.parse(Faraday.get(url).body)
+  end
+end
+
+chat.with_tool(Weather).ask "What's the weather in Berlin?"
+```
+
+```ruby
+# Get structured output
+class ProductSchema < RubyLLM::Schema
+  string :name
+  number :price
+  array :features do
+    string
+  end
+end
+
+response = chat.with_schema(ProductSchema).ask "Analyze this product", with: "product.txt"
+```
+
+## Features
+
+* **Chat:** Conversational AI with `RubyLLM.chat`
+* **Vision:** Analyze images and screenshots
+* **Audio:** Transcribe and understand speech
+* **Documents:** Extract from PDFs, CSVs, JSON, any file type
+* **Image generation:** Create images with `RubyLLM.paint`
+* **Embeddings:** Vector search with `RubyLLM.embed`
+* **Tools:** Let AI call your Ruby methods
+* **Structured output:** JSON schemas that just work
+* **Streaming:** Real-time responses with blocks
+* **Rails:** ActiveRecord integration with `acts_as_chat`
+* **Async:** Fiber-based concurrency
+* **Model registry:** 500+ models with capability detection and pricing
+* **Providers:** OpenAI, Anthropic, Gemini, VertexAI, Bedrock, DeepSeek, Mistral, Ollama, OpenRouter, Perplexity, GPUStack, and any OpenAI-compatible API
+
+## Installation
+
+Add to your Gemfile:
+```ruby
+gem 'ruby_llm'
+```
+Then `bundle install`.
+
+Configure your API keys:
+```ruby
+# config/initializers/ruby_llm.rb
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV['OPENAI_API_KEY']
+end
+```
+
+## Rails
+
+```bash
+rails generate ruby_llm:install
+```
+
+```ruby
+class Chat < ApplicationRecord
+  acts_as_chat
+end
+
+chat = Chat.create! model_id: "claude-sonnet-4"
+chat.ask "What's in this file?", with: "report.pdf"
+```
+
+## Documentation
+
+[rubyllm.com](https://rubyllm.com)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+Released under the MIT License.

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

@@ -0,0 +1,3 @@
+class <%= options[:chat_model_name] %> < ApplicationRecord
+  <%= acts_as_chat_declaration %>
+end

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

@@ -0,0 +1,8 @@
+class Create<%= options[:chat_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:chat_model_name].tableize %> do |t|
+      t.string :model_id
+      t.timestamps
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+class Create<%= options[:chat_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:chat_model_name].tableize %> do |t|
+      t.references :<%= options[:model_model_name].tableize.singularize %>, foreign_key: true
+      t.timestamps
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class Create<%= options[:message_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:message_model_name].tableize %> do |t|
+      t.references :<%= options[:chat_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :role, null: false
+      t.text :content
+      t.string :model_id
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.references :<%= options[:tool_call_model_name].tableize.singularize %>, foreign_key: true
+      t.timestamps
+    end
+
+    add_index :<%= options[:message_model_name].tableize %>, :role
+  end
+end

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

@@ -0,0 +1,16 @@
+class Create<%= options[:message_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:message_model_name].tableize %> do |t|
+      t.references :<%= options[:chat_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :role, null: false
+      t.text :content
+      t.references :<%= options[:model_model_name].tableize.singularize %>, foreign_key: true
+      t.integer :input_tokens
+      t.integer :output_tokens
+      t.references :<%= options[:tool_call_model_name].tableize.singularize %>, foreign_key: true
+      t.timestamps
+    end
+
+    add_index :<%= options[:message_model_name].tableize %>, :role
+  end
+end

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

@@ -0,0 +1,43 @@
+class Create<%= options[:model_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:model_model_name].tableize %> do |t|
+      t.string :model_id, null: false
+      t.string :name, null: false
+      t.string :provider, null: false
+      t.string :family
+      t.datetime :model_created_at
+      t.integer :context_window
+      t.integer :max_output_tokens
+      t.date :knowledge_cutoff
+<% if postgresql? %>
+      t.jsonb :modalities, default: {}
+      t.jsonb :capabilities, default: []
+      t.jsonb :pricing, default: {}
+      t.jsonb :metadata, default: {}
+<% else %>
+      t.json :modalities, default: {}
+      t.json :capabilities, default: []
+      t.json :pricing, default: {}
+      t.json :metadata, default: {}
+<% end %>
+      t.timestamps
+
+      t.index [:provider, :model_id], unique: true
+      t.index :provider
+      t.index :family
+<% if postgresql? %>
+      t.index :capabilities, using: :gin
+      t.index :modalities, using: :gin
+<% end %>
+    end
+
+    # Load models from JSON
+    say_with_time "Loading models from models.json" do
+      RubyLLM.models.load_from_json!
+      model_class = '<%= options[:model_model_name] %>'.constantize
+      model_class.save_to_database
+
+      "Loaded #{model_class.count} models"
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+<%#- # Migration for creating tool_calls table with database-specific JSON handling -%>
+class Create<%= options[:tool_call_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= options[:tool_call_model_name].tableize %> do |t|
+      t.references :<%= options[:message_model_name].tableize.singularize %>, null: false, foreign_key: true
+      t.string :tool_call_id, null: false
+      t.string :name, null: false
+      t.<%= postgresql? ? 'jsonb' : 'json' %> :arguments, default: {}
+      t.timestamps
+    end
+
+    add_index :<%= options[:tool_call_model_name].tableize %>, :tool_call_id, unique: true
+    add_index :<%= options[:tool_call_model_name].tableize %>, :name
+  end
+end

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

@@ -0,0 +1,9 @@
+RubyLLM.configure do |config|
+  config.openai_api_key = Rails.application.credentials.dig(:openai_api_key)
+  # config.default_model = "gpt-4.1-nano"
+
+<% unless skip_model_registry? -%>
+  # DB-backed model registry for rich model metadata
+  config.model_registry_class = "<%= options[:model_model_name] %>"
+<% end -%>
+end

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

@@ -0,0 +1,4 @@
+class <%= options[:message_model_name] %> < ApplicationRecord
+  <%= acts_as_message_declaration %><% unless options[:skip_active_storage] %>
+  has_many_attached :attachments<% end %>
+end

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

@@ -0,0 +1,3 @@
+class <%= options[:model_model_name] %> < ApplicationRecord
+  <%= acts_as_model_declaration %>
+end

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

@@ -0,0 +1,3 @@
+class <%= options[:tool_call_model_name] %> < ApplicationRecord
+  <%= acts_as_tool_call_declaration %>
+end

data/lib/generators/ruby_llm/install_generator.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module RubyLLM
+  # Generator for RubyLLM Rails models and migrations
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    namespace 'ruby_llm:install'
+
+    source_root File.expand_path('install/templates', __dir__)
+
+    class_option :chat_model_name, type: :string, default: 'Chat',
+                                   desc: 'Name of the Chat model class'
+    class_option :message_model_name, type: :string, default: 'Message',
+                                      desc: 'Name of the Message model class'
+    class_option :tool_call_model_name, type: :string, default: 'ToolCall',
+                                        desc: 'Name of the ToolCall model class'
+    class_option :model_model_name, type: :string, default: 'Model',
+                                    desc: 'Name of the Model model class (for model registry)'
+    class_option :skip_model_registry, type: :boolean, default: false,
+                                       desc: 'Skip creating Model registry (uses string fields instead)'
+    class_option :skip_active_storage, type: :boolean, default: false,
+                                       desc: 'Skip ActiveStorage installation and attachment setup'
+
+    desc 'Creates models and migrations for RubyLLM Rails integration with ActiveStorage for file attachments'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+
+    def postgresql?
+      ::ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
+    rescue StandardError
+      false
+    end
+
+    def acts_as_chat_declaration
+      acts_as_chat_params = []
+      if options[:message_model_name] != 'Message'
+        acts_as_chat_params << "message_class: \"#{options[:message_model_name]}\""
+      end
+      if options[:tool_call_model_name] != 'ToolCall'
+        acts_as_chat_params << "tool_call_class: \"#{options[:tool_call_model_name]}\""
+      end
+      if acts_as_chat_params.any?
+        "acts_as_chat #{acts_as_chat_params.join(', ')}"
+      else
+        'acts_as_chat'
+      end
+    end
+
+    def acts_as_message_declaration
+      acts_as_message_params = []
+      acts_as_message_params << "chat_class: \"#{options[:chat_model_name]}\"" if options[:chat_model_name] != 'Chat'
+      if options[:tool_call_model_name] != 'ToolCall'
+        acts_as_message_params << "tool_call_class: \"#{options[:tool_call_model_name]}\""
+      end
+      if acts_as_message_params.any?
+        "acts_as_message #{acts_as_message_params.join(', ')}"
+      else
+        'acts_as_message'
+      end
+    end
+
+    def acts_as_tool_call_declaration
+      acts_as_tool_call_params = []
+      if options[:message_model_name] != 'Message'
+        acts_as_tool_call_params << "message_class: \"#{options[:message_model_name]}\""
+      end
+      if acts_as_tool_call_params.any?
+        "acts_as_tool_call #{acts_as_tool_call_params.join(', ')}"
+      else
+        'acts_as_tool_call'
+      end
+    end
+
+    def acts_as_model_declaration
+      'acts_as_model'
+    end
+
+    def skip_model_registry?
+      options[:skip_model_registry]
+    end
+
+    def create_migration_files
+      # Create migrations with timestamps to ensure proper order
+      # First create chats table
+      template_file = skip_model_registry? ? 'create_chats_legacy_migration.rb.tt' : 'create_chats_migration.rb.tt'
+      migration_template template_file,
+                         "db/migrate/create_#{options[:chat_model_name].tableize}.rb"
+
+      # Then create messages table (must come before tool_calls due to foreign key)
+      sleep 1 # Ensure different timestamp
+      template_file = if skip_model_registry?
+                        'create_messages_legacy_migration.rb.tt'
+                      else
+                        'create_messages_migration.rb.tt'
+                      end
+      migration_template template_file,
+                         "db/migrate/create_#{options[:message_model_name].tableize}.rb"
+
+      # Then create tool_calls table (references messages)
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_tool_calls_migration.rb.tt',
+                         "db/migrate/create_#{options[:tool_call_model_name].tableize}.rb"
+
+      # Create models table unless using legacy or skipping
+      return if skip_model_registry?
+
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_models_migration.rb.tt',
+                         "db/migrate/create_#{options[:model_model_name].tableize}.rb"
+    end
+
+    def create_model_files
+      template 'chat_model.rb.tt', "app/models/#{options[:chat_model_name].underscore}.rb"
+      template 'message_model.rb.tt', "app/models/#{options[:message_model_name].underscore}.rb"
+      template 'tool_call_model.rb.tt', "app/models/#{options[:tool_call_model_name].underscore}.rb"
+
+      # Only create Model class if not using legacy
+      return if skip_model_registry?
+
+      template 'model_model.rb.tt', "app/models/#{options[:model_model_name].underscore}.rb"
+    end
+
+    def create_initializer
+      template 'initializer.rb.tt', 'config/initializers/ruby_llm.rb'
+    end
+
+    def install_active_storage
+      return if options[:skip_active_storage]
+
+      say '  Installing ActiveStorage for file attachments...', :cyan
+      rails_command 'active_storage:install'
+    end
+
+    def show_install_info
+      say "\n  ✅ RubyLLM installed!", :green
+
+      say '  ✅ ActiveStorage configured for file attachments support', :green unless options[:skip_active_storage]
+
+      say "\n  Next steps:", :yellow
+      say '     1. Run: rails db:migrate'
+      say '     2. Set your API keys in config/initializers/ruby_llm.rb'
+
+      if skip_model_registry?
+        say "     3. Start chatting: #{options[:chat_model_name]}.create!(model_id: 'gpt-4.1-nano').ask('Hello!')"
+
+        say "\n  Note: Using string-based model fields", :yellow
+        say '     For rich model metadata, consider adding the model registry:'
+        say '     rails generate ruby_llm:migrate_model_fields'
+      else
+        say "     3. Start chatting: #{options[:chat_model_name]}.create!(model: 'gpt-4.1-nano').ask('Hello!')"
+
+        say "\n  🚀 Model registry is database-backed!", :cyan
+        say '     Models automatically load from the database'
+        say '     Pass model names as strings - RubyLLM handles the rest!'
+      end
+      say "     Specify provider when needed: Chat.create!(model: 'gemini-2.5-flash', provider: 'vertexai')"
+
+      if options[:skip_active_storage]
+        say "\n  📎 Note: ActiveStorage was skipped", :yellow
+        say '     File attachments won\'t work without ActiveStorage.'
+        say '     To enable later:'
+        say '       1. Run: rails active_storage:install && rails db:migrate'
+        say "       2. Add to your #{options[:message_model_name]} model: has_many_attached :attachments"
+      end
+
+      say "\n  📚 Documentation: https://rubyllm.com", :cyan
+
+      say "\n  ❤️  Love RubyLLM?", :magenta
+      say '     • ⭐ Star on GitHub: https://github.com/crmne/ruby_llm'
+      say '     • 🐦 Follow for updates: https://x.com/paolino'
+      say "\n"
+    end
+  end
+end

data/lib/generators/ruby_llm/migrate_model_fields/templates/migration.rb.tt

@@ -0,0 +1,142 @@
+class MigrateToRubyLLMModelReferences < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Ensure Models table exists
+    unless table_exists?(:<%= options[:model_model_name].tableize %>)
+      raise "Models table doesn't exist. Please run 'rails generate ruby_llm:install' with model registry first."
+    end
+
+    model_class = <%= options[:model_model_name] %>
+    chat_class = <%= options[:chat_model_name] %>
+    message_class = <%= options[:message_model_name] %>
+
+    # Then check for any models in existing data that aren't in models.json
+    say_with_time "Checking for additional models in existing data" do
+      collect_and_create_models(chat_class, :<%= options[:chat_model_name].tableize %>, model_class)
+      collect_and_create_models(message_class, :<%= options[:message_model_name].tableize %>, model_class)
+      model_class.count
+    end
+
+    # Migrate foreign keys
+    migrate_foreign_key(:<%= options[:chat_model_name].tableize %>, chat_class, model_class, :<%= options[:model_model_name].underscore %>)
+    migrate_foreign_key(:<%= options[:message_model_name].tableize %>, message_class, model_class, :<%= options[:model_model_name].underscore %>)
+  end
+
+  def down
+    # Remove foreign key references
+    if column_exists?(:<%= options[:message_model_name].tableize %>, :<%= options[:model_model_name].underscore %>_id)
+      remove_reference :<%= options[:message_model_name].tableize %>, :<%= options[:model_model_name].underscore %>, foreign_key: true
+    end
+
+    if column_exists?(:<%= options[:chat_model_name].tableize %>, :<%= options[:model_model_name].underscore %>_id)
+      remove_reference :<%= options[:chat_model_name].tableize %>, :<%= options[:model_model_name].underscore %>, foreign_key: true
+    end
+
+    # Restore original model_id string columns
+    if column_exists?(:<%= options[:message_model_name].tableize %>, :model_id_string)
+      rename_column :<%= options[:message_model_name].tableize %>, :model_id_string, :model_id
+    end
+
+    if column_exists?(:<%= options[:chat_model_name].tableize %>, :model_id_string)
+      rename_column :<%= options[:chat_model_name].tableize %>, :model_id_string, :model_id
+    end
+  end
+
+  private
+
+  def collect_and_create_models(record_class, table_name, model_class)
+    return unless column_exists?(table_name, :model_id)
+
+    has_provider = column_exists?(table_name, :provider)
+
+    # Collect unique model/provider combinations using read_attribute to bypass overrides
+    models_set = Set.new
+
+    record_class.find_each do |record|
+      model_id = record.read_attribute(:model_id)
+      next if model_id.blank?
+
+      provider = has_provider ? record.read_attribute(:provider) : nil
+      models_set.add([ model_id, provider ])
+    end
+
+    models_set.each do |model_id, provider|
+      find_or_create_model(model_id, provider, model_class)
+    end
+  end
+
+  def find_or_create_model(model_id, provider, model_class)
+    return if model_id.blank?
+
+    begin
+      model_info, _provider = RubyLLM.models.resolve(model_id, provider: provider)
+
+      model_class.find_or_create_by!(
+        model_id: model_info.id,
+        provider: model_info.provider
+      ) do |m|
+        m.name = model_info.name || model_info.id
+        m.family = model_info.family
+        m.model_created_at = model_info.created_at
+        m.context_window = model_info.context_window
+        m.max_output_tokens = model_info.max_output_tokens
+        m.knowledge_cutoff = model_info.knowledge_cutoff
+        m.modalities = model_info.modalities.to_h
+        m.capabilities = model_info.capabilities
+        m.pricing = model_info.pricing.to_h
+        m.metadata = model_info.metadata
+      end
+    rescue => e
+      # Skip models that can't be resolved - they'll need manual fixing
+      Rails.logger.warn "Skipping unresolvable model: #{model_id} - will need manual update"
+      nil
+    end
+  end
+
+
+  def migrate_foreign_key(table_name, record_class, model_class, foreign_key_name)
+    return unless column_exists?(table_name, :model_id)
+
+    # Check if we need to rename the string column to avoid collision
+    if column_exists?(table_name, :model_id) && !foreign_key_exists?(table_name, :models)
+      # Temporarily rename the string column
+      rename_column table_name, :model_id, :model_id_string
+    end
+
+    # Add the foreign key reference
+    unless column_exists?(table_name, "#{foreign_key_name}_id")
+      add_reference table_name, foreign_key_name, foreign_key: true
+    end
+
+    say_with_time "Migrating #{table_name} model references" do
+      record_class.reset_column_information
+      has_provider = column_exists?(table_name, :provider)
+
+      # Determine which column to read from (renamed or original)
+      model_id_column = column_exists?(table_name, :model_id_string) ? :model_id_string : :model_id
+
+      record_class.find_each do |record|
+        model_id = record.read_attribute(model_id_column)
+        next if model_id.blank?
+
+        provider = has_provider ? record.read_attribute(:provider) : nil
+
+        model = if has_provider && provider.present?
+          model_class.find_by(model_id: model_id, provider: provider)
+        else
+          find_model_for_record(model_id, model_class)
+        end
+
+        record.update_column("#{foreign_key_name}_id", model.id) if model
+      end
+    end
+  end
+
+  def find_model_for_record(model_id, model_class)
+    begin
+      model_info, _provider = RubyLLM.models.resolve(model_id)
+      model_class.find_by(model_id: model_info.id, provider: model_info.provider)
+    rescue => e
+      model_class.find_by(model_id: model_id)
+    end
+  end
+end