ruby_llm 1.6.3 → 1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e454eaf845f9c4b9a03f6e5a12567e59d5621d1ff6db3e866be50e836de65c2
-  data.tar.gz: 8e49e339287432cc9feee74ee9b0b49abffcc282bb6387fc9d2cdd6889f9c39c
+  metadata.gz: 36ae61f8e11926aa9a761d4e8ab644eab587edb9091322596ab1ed7e32d65ee4
+  data.tar.gz: b5818edd28a449035ed62f58a79465b8705460be012194525930716d5457d458
 SHA512:
-  metadata.gz: 06e7fc0118d88631e1c41a9b4b0738b6f55b965ee4569643759489e81191317dfe4cba5e55dcf89d386ef68379b013a4a0a6c9b9b71f3dd3115f7f46186545f4
-  data.tar.gz: 047a575afaa0cf37934e395bd49460edab5a07e29a8c7f085139c331c94d44bdc226c9c2b8781183d05a7ce6b81b08af943b86c9c3ee76f19188a491585d971b
+  metadata.gz: 35fbc3892899c17e12e239d3688542bdc032aee12d6f30d81fff8373f116eab53722cc4871654ebfe65cdd97806ec81f9903919e4a36076b2a18938d68942be0
+  data.tar.gz: cf38979b2cf7ea03fc7d4944130fc3023d4536635d28a41f41956ea6445fc21064554fd41e917e8a3694ee798bb7a90dd10f8761c4ba326e79afd38db589e473

data/README.md

@@ -9,10 +9,10 @@
 
 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=5)](https://badge.fury.io/rb/ruby_llm)
+[![Gem Version](https://badge.fury.io/rb/ruby_llm.svg?a=6)](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)](https://codecov.io/gh/crmne/ruby_llm)
+[![codecov](https://codecov.io/gh/crmne/ruby_llm/branch/main/graph/badge.svg?a=1)](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>

data/lib/ruby_llm/active_record/acts_as.rb

@@ -232,14 +232,21 @@ module RubyLLM
         @message = messages.create!(role: :assistant, content: '')
       end
 
-      def persist_message_completion(message)
+      def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
         return unless message
 
         tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
           content = message.content
-          content = content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+          attachments_to_persist = nil
+
+          if content.is_a?(RubyLLM::Content)
+            attachments_to_persist = content.attachments if content.attachments.any?
+            content = content.text
+          elsif content.is_a?(Hash) || content.is_a?(Array)
+            content = content.to_json
+          end
 
           @message.update!(
             role: message.role,
@@ -250,6 +257,8 @@ module RubyLLM
           )
           @message.write_attribute(@message.class.tool_call_foreign_key, tool_call_id) if tool_call_id
           @message.save!
+
+          persist_content(@message, attachments_to_persist) if attachments_to_persist
           persist_tool_calls(message.tool_calls) if message.tool_calls.present?
         end
       end
@@ -291,7 +300,7 @@ module RubyLLM
       def convert_to_active_storage_format(source)
         return if source.blank?
 
-        attachment = RubyLLM::Attachment.new(source)
+        attachment = source.is_a?(RubyLLM::Attachment) ? source : RubyLLM::Attachment.new(source)
 
         {
           io: StringIO.new(attachment.content),

data/lib/ruby_llm/aliases.json

@@ -150,6 +150,10 @@
     "openai": "gpt-4o-2024-11-20",
     "openrouter": "openai/gpt-4o-2024-11-20"
   },
+  "gpt-4o-audio-preview": {
+    "openai": "gpt-4o-audio-preview",
+    "openrouter": "openai/gpt-4o-audio-preview"
+  },
   "gpt-4o-mini": {
     "openai": "gpt-4o-mini",
     "openrouter": "openai/gpt-4o-mini"

data/lib/ruby_llm/chat.rb

@@ -181,7 +181,7 @@ module RubyLLM
       end
     end
 
-    def handle_tool_calls(response, &)
+    def handle_tool_calls(response, &) # rubocop:disable Metrics/PerceivedComplexity
       halt_result = nil
 
       response.tool_calls.each_value do |tool_call|
@@ -189,7 +189,8 @@ module RubyLLM
         @on[:tool_call]&.call(tool_call)
         result = execute_tool tool_call
         @on[:tool_result]&.call(result)
-        message = add_message role: :tool, content: result.to_s, tool_call_id: tool_call.id
+        content = result.is_a?(Content) ? result : result.to_s
+        message = add_message role: :tool, content:, tool_call_id: tool_call.id
         @on[:end_message]&.call(message)
 
         halt_result = result if result.is_a?(Tool::Halt)

data/lib/ruby_llm/providers/anthropic/tools.rb

@@ -46,7 +46,7 @@ module RubyLLM
           {
             type: 'tool_result',
             tool_use_id: msg.tool_call_id,
-            content: msg.content
+            content: Media.format_content(msg.content)
           }
         end
 

data/lib/ruby_llm/providers/gemini/chat.rb

@@ -62,7 +62,7 @@ module RubyLLM
                 name: msg.tool_call_id,
                 response: {
                   name: msg.tool_call_id,
-                  content: msg.content
+                  content: Media.format_content(msg.content)
                 }
               }
             }]
@@ -86,31 +86,12 @@ module RubyLLM
           )
         end
 
-        def convert_schema_to_gemini(schema) # rubocop:disable Metrics/PerceivedComplexity
+        def convert_schema_to_gemini(schema)
           return nil unless schema
 
-          case schema[:type]
-          when 'object'
-            {
-              type: 'OBJECT',
-              properties: schema[:properties]&.transform_values { |prop| convert_schema_to_gemini(prop) } || {},
-              required: schema[:required] || []
-            }
-          when 'array'
-            {
-              type: 'ARRAY',
-              items: schema[:items] ? convert_schema_to_gemini(schema[:items]) : { type: 'STRING' }
-            }
-          when 'string'
-            result = { type: 'STRING' }
-            result[:enum] = schema[:enum] if schema[:enum]
-            result
-          when 'number', 'integer'
-            { type: 'NUMBER' }
-          when 'boolean'
-            { type: 'BOOLEAN' }
-          else
-            { type: 'STRING' }
+          build_base_schema(schema).tap do |result|
+            result[:description] = schema[:description] if schema[:description]
+            apply_type_specific_attributes(result, schema)
           end
         end
 
@@ -137,6 +118,53 @@ module RubyLLM
           thoughts = data.dig('usageMetadata', 'thoughtsTokenCount') || 0
           candidates + thoughts
         end
+
+        def build_base_schema(schema)
+          case schema[:type]
+          when 'object'
+            build_object_schema(schema)
+          when 'array'
+            { type: 'ARRAY', items: schema[:items] ? convert_schema_to_gemini(schema[:items]) : { type: 'STRING' } }
+          when 'number'
+            { type: 'NUMBER' }
+          when 'integer'
+            { type: 'INTEGER' }
+          when 'boolean'
+            { type: 'BOOLEAN' }
+          else
+            { type: 'STRING' }
+          end
+        end
+
+        def build_object_schema(schema)
+          {
+            type: 'OBJECT',
+            properties: (schema[:properties] || {}).transform_values { |prop| convert_schema_to_gemini(prop) },
+            required: schema[:required] || []
+          }.tap do |object|
+            object[:propertyOrdering] = schema[:propertyOrdering] if schema[:propertyOrdering]
+            object[:nullable] = schema[:nullable] if schema.key?(:nullable)
+          end
+        end
+
+        def apply_type_specific_attributes(result, schema)
+          case schema[:type]
+          when 'string'
+            copy_attributes(result, schema, :enum, :format, :nullable)
+          when 'number', 'integer'
+            copy_attributes(result, schema, :format, :minimum, :maximum, :enum, :nullable)
+          when 'array'
+            copy_attributes(result, schema, :minItems, :maxItems, :nullable)
+          when 'boolean'
+            copy_attributes(result, schema, :nullable)
+          end
+        end
+
+        def copy_attributes(target, source, *attributes)
+          attributes.each do |attr|
+            target[attr] = source[attr] if attr == :nullable ? source.key?(attr) : source[attr]
+          end
+        end
       end
     end
   end

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '1.6.3'
+  VERSION = '1.6.4'
 end

data/lib/tasks/models.rake

@@ -0,0 +1,514 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+require 'ruby_llm'
+require 'json'
+require 'json-schema'
+require 'fileutils'
+
+desc 'Update models, docs, and aliases'
+task models: ['models:update', 'models:docs', 'models:aliases']
+
+namespace :models do
+  desc 'Update available models from providers (API keys needed)'
+  task :update do
+    puts 'Configuring RubyLLM...'
+    configure_from_env
+    refresh_models
+    display_model_stats
+  end
+
+  desc 'Generate available models documentation'
+  task :docs do
+    FileUtils.mkdir_p('docs/_reference')
+    output = generate_models_markdown
+    File.write('docs/_reference/available-models.md', output)
+    puts 'Generated docs/_reference/available-models.md'
+  end
+
+  desc 'Generate model aliases from registry'
+  task :aliases do
+    generate_aliases
+  end
+end
+
+# Keep aliases:generate for backwards compatibility
+namespace :aliases do
+  task generate: ['models:aliases']
+end
+
+def configure_from_env
+  RubyLLM.configure do |config|
+    config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+    config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
+    config.gemini_api_key = ENV.fetch('GEMINI_API_KEY', nil)
+    config.deepseek_api_key = ENV.fetch('DEEPSEEK_API_KEY', nil)
+    config.perplexity_api_key = ENV.fetch('PERPLEXITY_API_KEY', nil)
+    config.openrouter_api_key = ENV.fetch('OPENROUTER_API_KEY', nil)
+    config.mistral_api_key = ENV.fetch('MISTRAL_API_KEY', nil)
+    configure_bedrock(config)
+    config.request_timeout = 30
+  end
+end
+
+def configure_bedrock(config)
+  config.bedrock_api_key = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
+  config.bedrock_secret_key = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
+  config.bedrock_region = ENV.fetch('AWS_REGION', nil)
+  config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
+end
+
+def refresh_models
+  initial_count = RubyLLM.models.all.size
+  puts "Refreshing models (#{initial_count} cached)..."
+
+  models = RubyLLM.models.refresh!
+
+  if models.all.empty? && initial_count.zero?
+    puts 'Error: Failed to fetch models.'
+    exit(1)
+  elsif models.all.size == initial_count && initial_count.positive?
+    puts 'Warning: Model list unchanged.'
+  else
+    puts 'Validating models...'
+    validate_models!(models)
+
+    puts "Saving models.json (#{models.all.size} models)"
+    models.save_models
+  end
+
+  @models = models
+end
+
+def validate_models!(models)
+  schema_path = RubyLLM::Models.schema_file
+  models_data = models.all.map(&:to_h)
+
+  validation_errors = JSON::Validator.fully_validate(schema_path, models_data)
+
+  unless validation_errors.empty?
+    # Save failed models for inspection
+    failed_path = File.expand_path('../ruby_llm/models.failed.json', __dir__)
+    File.write(failed_path, JSON.pretty_generate(models_data))
+
+    puts 'ERROR: Models validation failed:'
+    puts "\nValidation errors:"
+    validation_errors.first(10).each { |error| puts "  - #{error}" }
+    puts "  ... and #{validation_errors.size - 10} more errors" if validation_errors.size > 10
+    puts "-> Failed models saved to: #{failed_path}"
+    exit(1)
+  end
+
+  puts '✓ Models validation passed'
+end
+
+def display_model_stats
+  puts "\nModel count:"
+  provider_counts = @models.all.group_by(&:provider).transform_values(&:count)
+
+  RubyLLM::Provider.providers.each do |sym, provider_class|
+    name = provider_class.name
+    count = provider_counts[sym.to_s] || 0
+    status = status(sym)
+    puts "  #{name}: #{count} models #{status}"
+  end
+
+  puts 'Refresh complete.'
+end
+
+def status(provider_sym)
+  provider_class = RubyLLM::Provider.providers[provider_sym]
+  if provider_class.local?
+    ' (LOCAL - SKIP)'
+  elsif provider_class.configured?(RubyLLM.config)
+    ' (OK)'
+  else
+    ' (NOT CONFIGURED)'
+  end
+end
+
+def generate_models_markdown
+  <<~MARKDOWN
+    ---
+    layout: default
+    title: Available Models
+    nav_order: 1
+    description: Browse hundreds of AI models from every major provider. Always up-to-date, automatically generated.
+    redirect_from:
+      - /guides/available-models
+    ---
+
+    # {{ page.title }}
+    {: .no_toc }
+
+    {{ page.description }}
+    {: .fs-6 .fw-300 }
+
+    ## Table of contents
+    {: .no_toc .text-delta }
+
+    1. TOC
+    {:toc}
+
+    ---
+
+    After reading this guide, you will know:
+
+    * How RubyLLM's model registry works and where data comes from
+    * How to find models by provider, capability, or purpose
+    * What information is available for each model
+    * How to use model aliases for simpler configuration
+
+    ## How Model Data Works
+
+    RubyLLM's model registry combines data from multiple sources:
+
+    - **OpenAI, Anthropic, DeepSeek, Gemini**: Data from [Parsera](https://api.parsera.org/v1/llm-specs)
+    - **OpenRouter**: Direct from OpenRouter's API
+    - **Other providers**: Defined in `capabilities.rb` files
+
+    ## Contributing Model Updates
+
+    **For major providers** (OpenAI, Anthropic, DeepSeek, Gemini): File issues with [Parsera](https://github.com/parsera-labs/api-llm-specs/issues) for public model data corrections.
+
+    **For other providers**: Edit `lib/ruby_llm/providers/<provider>/capabilities.rb` then run `rake models:update`.
+
+    See the [Contributing Guide](https://github.com/crmne/ruby_llm/blob/main/CONTRIBUTING.md) for details.
+
+    ## Last Updated
+    {: .d-inline-block }
+
+    #{Time.now.utc.strftime('%Y-%m-%d')}
+    {: .label .label-green }
+
+    ## Models by Provider
+
+    #{generate_provider_sections}
+
+    ## Models by Capability
+
+    #{generate_capability_sections}
+
+    ## Models by Modality
+
+    #{generate_modality_sections}
+  MARKDOWN
+end
+
+def generate_provider_sections
+  RubyLLM::Provider.providers.filter_map do |provider, provider_class|
+    models = RubyLLM.models.by_provider(provider)
+    next if models.none?
+
+    <<~PROVIDER
+      ### #{provider_class.name} (#{models.count})
+
+      #{models_table(models)}
+    PROVIDER
+  end.join("\n\n")
+end
+
+def generate_capability_sections
+  capabilities = {
+    'Function Calling' => RubyLLM.models.select(&:function_calling?),
+    'Structured Output' => RubyLLM.models.select(&:structured_output?),
+    'Streaming' => RubyLLM.models.select { |m| m.capabilities.include?('streaming') },
+    'Batch Processing' => RubyLLM.models.select { |m| m.capabilities.include?('batch') }
+  }
+
+  capabilities.filter_map do |capability, models|
+    next if models.none?
+
+    <<~CAPABILITY
+      ### #{capability} (#{models.count})
+
+      #{models_table(models)}
+    CAPABILITY
+  end.join("\n\n")
+end
+
+def generate_modality_sections # rubocop:disable Metrics/PerceivedComplexity
+  sections = []
+
+  vision_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('image') }
+  if vision_models.any?
+    sections << <<~SECTION
+      ### Vision Models (#{vision_models.count})
+
+      Models that can process images:
+
+      #{models_table(vision_models)}
+    SECTION
+  end
+
+  audio_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('audio') }
+  if audio_models.any?
+    sections << <<~SECTION
+      ### Audio Input Models (#{audio_models.count})
+
+      Models that can process audio:
+
+      #{models_table(audio_models)}
+    SECTION
+  end
+
+  pdf_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('pdf') }
+  if pdf_models.any?
+    sections << <<~SECTION
+      ### PDF Models (#{pdf_models.count})
+
+      Models that can process PDF documents:
+
+      #{models_table(pdf_models)}
+    SECTION
+  end
+
+  embedding_models = RubyLLM.models.select { |m| (m.modalities.output || []).include?('embeddings') }
+  if embedding_models.any?
+    sections << <<~SECTION
+      ### Embedding Models (#{embedding_models.count})
+
+      Models that generate embeddings:
+
+      #{models_table(embedding_models)}
+    SECTION
+  end
+
+  sections.join("\n\n")
+end
+
+def models_table(models)
+  return '*No models found*' if models.none?
+
+  headers = ['Model', 'Provider', 'Context', 'Max Output', 'Standard Pricing (per 1M tokens)']
+  alignment = [':--', ':--', '--:', '--:', ':--']
+
+  rows = models.sort_by { |m| [m.provider, m.name] }.map do |model|
+    pricing = standard_pricing_display(model)
+
+    [
+      model.id,
+      model.provider,
+      model.context_window || '-',
+      model.max_output_tokens || '-',
+      pricing
+    ]
+  end
+
+  table = []
+  table << "| #{headers.join(' | ')} |"
+  table << "| #{alignment.join(' | ')} |"
+
+  rows.each do |row|
+    table << "| #{row.join(' | ')} |"
+  end
+
+  table.join("\n")
+end
+
+def standard_pricing_display(model)
+  pricing_data = model.pricing.to_h[:text_tokens]&.dig(:standard) || {}
+
+  if pricing_data.any?
+    parts = []
+
+    parts << "In: $#{format('%.2f', pricing_data[:input_per_million])}" if pricing_data[:input_per_million]
+
+    parts << "Out: $#{format('%.2f', pricing_data[:output_per_million])}" if pricing_data[:output_per_million]
+
+    if pricing_data[:cached_input_per_million]
+      parts << "Cache: $#{format('%.2f', pricing_data[:cached_input_per_million])}"
+    end
+
+    return parts.join(', ') if parts.any?
+  end
+
+  '-'
+end
+
+def generate_aliases # rubocop:disable Metrics/PerceivedComplexity
+  models = Hash.new { |h, k| h[k] = [] }
+
+  RubyLLM.models.all.each do |model|
+    models[model.provider] << model.id
+  end
+
+  aliases = {}
+
+  # OpenAI models
+  models['openai'].each do |model|
+    openrouter_model = "openai/#{model}"
+    next unless models['openrouter'].include?(openrouter_model)
+
+    alias_key = model.gsub('-latest', '')
+    aliases[alias_key] = {
+      'openai' => model,
+      'openrouter' => openrouter_model
+    }
+  end
+
+  anthropic_latest = group_anthropic_models_by_base_name(models['anthropic'])
+
+  anthropic_latest.each do |base_name, latest_model|
+    openrouter_variants = [
+      "anthropic/#{base_name}",
+      "anthropic/#{base_name.gsub(/-(\d)/, '.\1')}",
+      "anthropic/#{base_name.gsub(/claude-(\d+)-(\d+)/, 'claude-\1.\2')}",
+      "anthropic/#{base_name.gsub(/(\d+)-(\d+)/, '\1.\2')}"
+    ]
+
+    openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
+    bedrock_model = find_best_bedrock_model(latest_model, models['bedrock'])
+
+    next unless openrouter_model || bedrock_model || models['anthropic'].include?(latest_model)
+
+    aliases[base_name] = { 'anthropic' => latest_model }
+    aliases[base_name]['openrouter'] = openrouter_model if openrouter_model
+    aliases[base_name]['bedrock'] = bedrock_model if bedrock_model
+  end
+
+  models['bedrock'].each do |bedrock_model|
+    next unless bedrock_model.start_with?('anthropic.')
+    next unless bedrock_model =~ /anthropic\.(claude-[\d\.]+-[a-z]+)/
+
+    base_name = Regexp.last_match(1)
+    anthropic_name = base_name.tr('.', '-')
+
+    next if aliases[anthropic_name]
+
+    openrouter_variants = [
+      "anthropic/#{anthropic_name}",
+      "anthropic/#{base_name}"
+    ]
+
+    openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
+
+    aliases[anthropic_name] = { 'bedrock' => bedrock_model }
+    aliases[anthropic_name]['anthropic'] = anthropic_name if models['anthropic'].include?(anthropic_name)
+    aliases[anthropic_name]['openrouter'] = openrouter_model if openrouter_model
+  end
+
+  models['gemini'].each do |model|
+    openrouter_variants = [
+      "google/#{model}",
+      "google/#{model.gsub('gemini-', 'gemini-').tr('.', '-')}",
+      "google/#{model.gsub('gemini-', 'gemini-')}"
+    ]
+
+    openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
+    next unless openrouter_model
+
+    alias_key = model.gsub('-latest', '')
+    aliases[alias_key] = {
+      'gemini' => model,
+      'openrouter' => openrouter_model
+    }
+  end
+
+  models['deepseek'].each do |model|
+    openrouter_model = "deepseek/#{model}"
+    next unless models['openrouter'].include?(openrouter_model)
+
+    alias_key = model.gsub('-latest', '')
+    aliases[alias_key] = {
+      'deepseek' => model,
+      'openrouter' => openrouter_model
+    }
+  end
+
+  sorted_aliases = aliases.sort.to_h
+  File.write(RubyLLM::Aliases.aliases_file, JSON.pretty_generate(sorted_aliases))
+
+  puts "Generated #{sorted_aliases.size} aliases"
+end
+
+def group_anthropic_models_by_base_name(anthropic_models)
+  grouped = Hash.new { |h, k| h[k] = [] }
+
+  anthropic_models.each do |model|
+    base_name = extract_base_name(model)
+    grouped[base_name] << model
+  end
+
+  latest_models = {}
+  grouped.each do |base_name, model_list|
+    if model_list.size == 1
+      latest_models[base_name] = model_list.first
+    else
+      latest_model = model_list.max_by { |model| extract_date_from_model(model) }
+      latest_models[base_name] = latest_model
+    end
+  end
+
+  latest_models
+end
+
+def extract_base_name(model)
+  if model =~ /^(.+)-(\d{8})$/
+    Regexp.last_match(1)
+  else
+    model
+  end
+end
+
+def extract_date_from_model(model)
+  if model =~ /-(\d{8})$/
+    Regexp.last_match(1)
+  else
+    '00000000'
+  end
+end
+
+def find_best_bedrock_model(anthropic_model, bedrock_models) # rubocop:disable Metrics/PerceivedComplexity
+  base_pattern = case anthropic_model
+                 when 'claude-2.0', 'claude-2'
+                   'claude-v2'
+                 when 'claude-2.1'
+                   'claude-v2:1'
+                 when 'claude-instant-v1', 'claude-instant'
+                   'claude-instant'
+                 else
+                   extract_base_name(anthropic_model)
+                 end
+
+  matching_models = bedrock_models.select do |bedrock_model|
+    model_without_prefix = bedrock_model.sub(/^(?:us\.)?anthropic\./, '')
+    model_without_prefix.start_with?(base_pattern)
+  end
+
+  return nil if matching_models.empty?
+
+  begin
+    model_info = RubyLLM.models.find(anthropic_model)
+    target_context = model_info.context_window
+  rescue StandardError
+    target_context = nil
+  end
+
+  if target_context
+    target_k = target_context / 1000
+
+    with_context = matching_models.select do |m|
+      m.include?(":#{target_k}k") || m.include?(":0:#{target_k}k")
+    end
+
+    return with_context.first if with_context.any?
+  end
+
+  matching_models.min_by do |model|
+    context_priority = if model =~ /:(?:\d+:)?(\d+)k/
+                         -Regexp.last_match(1).to_i
+                       else
+                         0
+                       end
+
+    version_priority = if model =~ /-v(\d+):/
+                         -Regexp.last_match(1).to_i
+                       else
+                         0
+                       end
+
+    has_context_priority = model.include?('k') ? -1 : 0
+    [has_context_priority, context_priority, version_priority]
+  end
+end

data/lib/tasks/release.rake

@@ -1,6 +1,38 @@
 # frozen_string_literal: true
 
-namespace :release do
+namespace :release do # rubocop:disable Metrics/BlockLength
+  desc 'Prepare for release'
+  task :prepare do
+    Rake::Task['release:refresh_stale_cassettes'].invoke
+    sh 'overcommit --run'
+    Rake::Task['models'].invoke
+  end
+
+  desc 'Remove stale cassettes and re-record them'
+  task :refresh_stale_cassettes do
+    max_age_days = 1
+    cassette_dir = 'spec/fixtures/vcr_cassettes'
+
+    stale_count = 0
+    Dir.glob("#{cassette_dir}/**/*.yml").each do |cassette|
+      age_days = (Time.now - File.mtime(cassette)) / 86_400
+      next unless age_days > max_age_days
+
+      puts "Removing stale cassette: #{File.basename(cassette)} (#{age_days.round(1)} days old)"
+      File.delete(cassette)
+      stale_count += 1
+    end
+
+    if stale_count.positive?
+      puts "\n🗑️  Removed #{stale_count} stale cassettes"
+      puts '🔄 Re-recording cassettes...'
+      system('bundle exec rspec') || exit(1)
+      puts '✅ Cassettes refreshed!'
+    else
+      puts '✅ No stale cassettes found'
+    end
+  end
+
   desc 'Verify cassettes are fresh enough for release'
   task :verify_cassettes do
     max_age_days = 1
@@ -20,10 +52,13 @@ namespace :release do
 
     if stale_cassettes.any?
       puts "\n❌ Found stale cassettes (older than #{max_age_days} days):"
+      stale_files = []
       stale_cassettes.each do |c|
         puts "   - #{c[:file]} (#{c[:age]} days old)"
+        stale_files << File.join(cassette_dir, '**', c[:file])
       end
-      puts "\nRun locally: bundle exec rspec"
+
+      puts "\nRun locally: bundle exec rake release:refresh_stale_cassettes"
       exit 1
     else
       puts "✅ All cassettes are fresh (< #{max_age_days} days old)"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.6.4
 platform: ruby
 authors:
 - Carmine Paolino
@@ -236,9 +236,7 @@ files:
 - lib/ruby_llm/tool_call.rb
 - lib/ruby_llm/utils.rb
 - lib/ruby_llm/version.rb
-- lib/tasks/aliases.rake
-- lib/tasks/models_docs.rake
-- lib/tasks/models_update.rake
+- lib/tasks/models.rake
 - lib/tasks/release.rake
 - lib/tasks/vcr.rake
 homepage: https://rubyllm.com

data/lib/tasks/aliases.rake

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-namespace :aliases do # rubocop:disable Metrics/BlockLength
-  desc 'Generate aliases.json from models in the registry'
-  task :generate do # rubocop:disable Metrics/BlockLength
-    require 'ruby_llm'
-
-    # Group models by provider
-    models = Hash.new { |h, k| h[k] = [] }
-
-    RubyLLM.models.all.each do |model|
-      models[model.provider] << model.id
-    end
-
-    aliases = {}
-
-    # OpenAI models
-    models['openai'].each do |model|
-      openrouter_model = "openai/#{model}"
-      next unless models['openrouter'].include?(openrouter_model)
-
-      alias_key = model.gsub('-latest', '')
-      aliases[alias_key] = {
-        'openai' => model,
-        'openrouter' => openrouter_model
-      }
-    end
-
-    anthropic_latest = group_anthropic_models_by_base_name(models['anthropic'])
-
-    anthropic_latest.each do |base_name, latest_model|
-      openrouter_variants = [
-        "anthropic/#{base_name}", # anthropic/claude-3-5-sonnet
-        "anthropic/#{base_name.gsub(/-(\d)/, '.\1')}", # anthropic/claude-3.5-sonnet
-        "anthropic/#{base_name.gsub(/claude-(\d+)-(\d+)/, 'claude-\1.\2')}", # claude-3-5 -> claude-3.5
-        "anthropic/#{base_name.gsub(/(\d+)-(\d+)/, '\1.\2')}" # any X-Y -> X.Y pattern
-      ]
-
-      openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
-
-      bedrock_model = find_best_bedrock_model(latest_model, models['bedrock'])
-
-      next unless openrouter_model || bedrock_model || models['anthropic'].include?(latest_model)
-
-      aliases[base_name] = {
-        'anthropic' => latest_model
-      }
-
-      aliases[base_name]['openrouter'] = openrouter_model if openrouter_model
-      aliases[base_name]['bedrock'] = bedrock_model if bedrock_model
-    end
-
-    models['bedrock'].each do |bedrock_model|
-      next unless bedrock_model.start_with?('anthropic.')
-
-      next unless bedrock_model =~ /anthropic\.(claude-[\d\.]+-[a-z]+)/
-
-      base_name = Regexp.last_match(1)
-      anthropic_name = base_name.tr('.', '-')
-
-      next if aliases[anthropic_name]
-
-      openrouter_variants = [
-        "anthropic/#{anthropic_name}",
-        "anthropic/#{base_name}" # Keep the dots
-      ]
-
-      openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
-
-      aliases[anthropic_name] = {
-        'bedrock' => bedrock_model
-      }
-
-      aliases[anthropic_name]['anthropic'] = anthropic_name if models['anthropic'].include?(anthropic_name)
-      aliases[anthropic_name]['openrouter'] = openrouter_model if openrouter_model
-    end
-
-    models['gemini'].each do |model|
-      openrouter_variants = [
-        "google/#{model}",
-        "google/#{model.gsub('gemini-', 'gemini-').tr('.', '-')}",
-        "google/#{model.gsub('gemini-', 'gemini-')}"
-      ]
-
-      openrouter_model = openrouter_variants.find { |v| models['openrouter'].include?(v) }
-      next unless openrouter_model
-
-      alias_key = model.gsub('-latest', '')
-      aliases[alias_key] = {
-        'gemini' => model,
-        'openrouter' => openrouter_model
-      }
-    end
-
-    models['deepseek'].each do |model|
-      openrouter_model = "deepseek/#{model}"
-      next unless models['openrouter'].include?(openrouter_model)
-
-      alias_key = model.gsub('-latest', '')
-      aliases[alias_key] = {
-        'deepseek' => model,
-        'openrouter' => openrouter_model
-      }
-    end
-
-    sorted_aliases = aliases.sort.to_h
-    File.write(RubyLLM::Aliases.aliases_file, JSON.pretty_generate(sorted_aliases))
-
-    puts "Generated #{sorted_aliases.size} aliases"
-  end
-
-  def group_anthropic_models_by_base_name(anthropic_models) # rubocop:disable Rake/MethodDefinitionInTask
-    grouped = Hash.new { |h, k| h[k] = [] }
-
-    anthropic_models.each do |model|
-      base_name = extract_base_name(model)
-      grouped[base_name] << model
-    end
-
-    latest_models = {}
-    grouped.each do |base_name, model_list|
-      if model_list.size == 1
-        latest_models[base_name] = model_list.first
-      else
-        latest_model = model_list.max_by { |model| extract_date_from_model(model) }
-        latest_models[base_name] = latest_model
-      end
-    end
-
-    latest_models
-  end
-
-  def extract_base_name(model) # rubocop:disable Rake/MethodDefinitionInTask
-    if model =~ /^(.+)-(\d{8})$/
-      Regexp.last_match(1)
-    else
-      model
-    end
-  end
-
-  def extract_date_from_model(model) # rubocop:disable Rake/MethodDefinitionInTask
-    if model =~ /-(\d{8})$/
-      Regexp.last_match(1)
-    else
-      '00000000'
-    end
-  end
-
-  def find_best_bedrock_model(anthropic_model, bedrock_models) # rubocop:disable Metrics/PerceivedComplexity,Rake/MethodDefinitionInTask
-    base_pattern = case anthropic_model
-                   when 'claude-2.0', 'claude-2'
-                     'claude-v2'
-                   when 'claude-2.1'
-                     'claude-v2:1'
-                   when 'claude-instant-v1', 'claude-instant'
-                     'claude-instant'
-                   else
-                     extract_base_name(anthropic_model)
-                   end
-
-    matching_models = bedrock_models.select do |bedrock_model|
-      model_without_prefix = bedrock_model.sub(/^(?:us\.)?anthropic\./, '')
-      model_without_prefix.start_with?(base_pattern)
-    end
-
-    return nil if matching_models.empty?
-
-    begin
-      model_info = RubyLLM.models.find(anthropic_model)
-      target_context = model_info.context_window
-    rescue StandardError
-      target_context = nil
-    end
-
-    if target_context
-      target_k = target_context / 1000
-
-      with_context = matching_models.select do |m|
-        m.include?(":#{target_k}k") || m.include?(":0:#{target_k}k")
-      end
-
-      return with_context.first if with_context.any?
-    end
-
-    matching_models.min_by do |model|
-      context_priority = if model =~ /:(?:\d+:)?(\d+)k/
-                           -Regexp.last_match(1).to_i
-                         else
-                           0
-                         end
-
-      version_priority = if model =~ /-v(\d+):/
-                           -Regexp.last_match(1).to_i
-                         else
-                           0
-                         end
-
-      # Prefer models with explicit context windows
-      has_context_priority = model.include?('k') ? -1 : 0
-      [has_context_priority, context_priority, version_priority]
-    end
-  end
-end

data/lib/tasks/models_docs.rake

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv/load'
-require 'fileutils'
-
-namespace :models do
-  desc 'Generate available models documentation'
-  task :docs do
-    FileUtils.mkdir_p('docs')
-    output = generate_models_markdown
-    File.write('docs/_reference/available-models.md', output)
-    puts 'Generated docs/_reference/available-models.md'
-  end
-end
-
-def generate_models_markdown
-  <<~MARKDOWN
-    ---
-    layout: default
-    title: Available Models
-    nav_order: 1
-    description: Browse hundreds of AI models from every major provider. Always up-to-date, automatically generated.
-    redirect_from:
-      - /guides/available-models
-    ---
-
-    # {{ page.title }}
-    {: .no_toc }
-
-    {{ page.description }}
-    {: .fs-6 .fw-300 }
-
-    ## Table of contents
-    {: .no_toc .text-delta }
-
-    1. TOC
-    {:toc}
-
-    ---
-
-    After reading this guide, you will know:
-
-    * How RubyLLM's model registry works and where data comes from
-    * How to find models by provider, capability, or purpose
-    * What information is available for each model
-    * How to use model aliases for simpler configuration
-
-    ## How Model Data Works
-
-    RubyLLM's model registry combines data from multiple sources:
-
-    - **OpenAI, Anthropic, DeepSeek, Gemini**: Data from [Parsera](https://api.parsera.org/v1/llm-specs)
-    - **OpenRouter**: Direct from OpenRouter's API
-    - **Other providers**: Defined in `capabilities.rb` files
-
-    ## Contributing Model Updates
-
-    **For major providers** (OpenAI, Anthropic, DeepSeek, Gemini): File issues with [Parsera](https://github.com/parsera-labs/api-llm-specs/issues) for public model data corrections.
-
-    **For other providers**: Edit `lib/ruby_llm/providers/<provider>/capabilities.rb` then run `rake models:update`.
-
-    See the [Contributing Guide](https://github.com/crmne/ruby_llm/blob/main/CONTRIBUTING.md) for details.
-
-    ## Last Updated
-    {: .d-inline-block }
-
-    #{Time.now.utc.strftime('%Y-%m-%d')}
-    {: .label .label-green }
-
-    ## Models by Provider
-
-    #{generate_provider_sections}
-
-    ## Models by Capability
-
-    #{generate_capability_sections}
-
-    ## Models by Modality
-
-    #{generate_modality_sections}
-  MARKDOWN
-end
-
-def generate_provider_sections
-  RubyLLM::Provider.providers.filter_map do |provider, provider_class|
-    models = RubyLLM.models.by_provider(provider)
-    next if models.none?
-
-    <<~PROVIDER
-      ### #{provider_class.name} (#{models.count})
-
-      #{models_table(models)}
-    PROVIDER
-  end.join("\n\n")
-end
-
-def generate_capability_sections
-  capabilities = {
-    'Function Calling' => RubyLLM.models.select(&:function_calling?),
-    'Structured Output' => RubyLLM.models.select(&:structured_output?),
-    'Streaming' => RubyLLM.models.select { |m| m.capabilities.include?('streaming') },
-    # 'Reasoning' => RubyLLM.models.select { |m| m.capabilities.include?('reasoning') },
-    'Batch Processing' => RubyLLM.models.select { |m| m.capabilities.include?('batch') }
-  }
-
-  capabilities.filter_map do |capability, models|
-    next if models.none?
-
-    <<~CAPABILITY
-      ### #{capability} (#{models.count})
-
-      #{models_table(models)}
-    CAPABILITY
-  end.join("\n\n")
-end
-
-def generate_modality_sections # rubocop:disable Metrics/PerceivedComplexity
-  sections = []
-
-  vision_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('image') }
-  if vision_models.any?
-    sections << <<~SECTION
-      ### Vision Models (#{vision_models.count})
-
-      Models that can process images:
-
-      #{models_table(vision_models)}
-    SECTION
-  end
-
-  audio_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('audio') }
-  if audio_models.any?
-    sections << <<~SECTION
-      ### Audio Input Models (#{audio_models.count})
-
-      Models that can process audio:
-
-      #{models_table(audio_models)}
-    SECTION
-  end
-
-  pdf_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('pdf') }
-  if pdf_models.any?
-    sections << <<~SECTION
-      ### PDF Models (#{pdf_models.count})
-
-      Models that can process PDF documents:
-
-      #{models_table(pdf_models)}
-    SECTION
-  end
-
-  embedding_models = RubyLLM.models.select { |m| (m.modalities.output || []).include?('embeddings') }
-  if embedding_models.any?
-    sections << <<~SECTION
-      ### Embedding Models (#{embedding_models.count})
-
-      Models that generate embeddings:
-
-      #{models_table(embedding_models)}
-    SECTION
-  end
-
-  sections.join("\n\n")
-end
-
-def models_table(models)
-  return '*No models found*' if models.none?
-
-  headers = ['Model', 'Provider', 'Context', 'Max Output', 'Standard Pricing (per 1M tokens)']
-  alignment = [':--', ':--', '--:', '--:', ':--']
-
-  rows = models.sort_by { |m| [m.provider, m.name] }.map do |model|
-    pricing = standard_pricing_display(model)
-
-    [
-      model.id,
-      model.provider,
-      model.context_window || '-',
-      model.max_output_tokens || '-',
-      pricing
-    ]
-  end
-
-  table = []
-  table << "| #{headers.join(' | ')} |"
-  table << "| #{alignment.join(' | ')} |"
-
-  rows.each do |row|
-    table << "| #{row.join(' | ')} |"
-  end
-
-  table.join("\n")
-end
-
-def standard_pricing_display(model)
-  pricing_data = model.pricing.to_h[:text_tokens]&.dig(:standard) || {}
-
-  if pricing_data.any?
-    parts = []
-
-    parts << "In: $#{format('%.2f', pricing_data[:input_per_million])}" if pricing_data[:input_per_million]
-
-    parts << "Out: $#{format('%.2f', pricing_data[:output_per_million])}" if pricing_data[:output_per_million]
-
-    if pricing_data[:cached_input_per_million]
-      parts << "Cache: $#{format('%.2f', pricing_data[:cached_input_per_million])}"
-    end
-
-    return parts.join(', ') if parts.any?
-  end
-
-  '-'
-end

data/lib/tasks/models_update.rake

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv/load'
-require 'ruby_llm'
-require 'json-schema'
-
-task default: ['models:update']
-
-namespace :models do
-  desc 'Update available models from providers (API keys needed)'
-  task :update do
-    puts 'Configuring RubyLLM...'
-    configure_from_env
-
-    refresh_models
-    display_model_stats
-  end
-end
-
-def configure_from_env
-  RubyLLM.configure do |config|
-    config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
-    config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
-    config.gemini_api_key = ENV.fetch('GEMINI_API_KEY', nil)
-    config.deepseek_api_key = ENV.fetch('DEEPSEEK_API_KEY', nil)
-    config.perplexity_api_key = ENV.fetch('PERPLEXITY_API_KEY', nil)
-    config.openrouter_api_key = ENV.fetch('OPENROUTER_API_KEY', nil)
-    config.mistral_api_key = ENV.fetch('MISTRAL_API_KEY', nil)
-    configure_bedrock(config)
-    config.request_timeout = 30
-  end
-end
-
-def configure_bedrock(config)
-  config.bedrock_api_key = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
-  config.bedrock_secret_key = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
-  config.bedrock_region = ENV.fetch('AWS_REGION', nil)
-  config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
-end
-
-def refresh_models
-  initial_count = RubyLLM.models.all.size
-  puts "Refreshing models (#{initial_count} cached)..."
-
-  models = RubyLLM.models.refresh!
-
-  if models.all.empty? && initial_count.zero?
-    puts 'Error: Failed to fetch models.'
-    exit(1)
-  elsif models.all.size == initial_count && initial_count.positive?
-    puts 'Warning: Model list unchanged.'
-  else
-    puts 'Validating models...'
-    validate_models!(models)
-
-    puts "Saving models.json (#{models.all.size} models)"
-    models.save_models
-  end
-
-  @models = models
-end
-
-def validate_models!(models)
-  schema_path = RubyLLM::Models.schema_file
-  models_data = models.all.map(&:to_h)
-
-  validation_errors = JSON::Validator.fully_validate(schema_path, models_data)
-
-  unless validation_errors.empty?
-    # Save failed models for inspection
-    failed_path = File.expand_path('../ruby_llm/models.failed.json', __dir__)
-    File.write(failed_path, JSON.pretty_generate(models_data))
-
-    puts 'ERROR: Models validation failed:'
-    puts "\nValidation errors:"
-    validation_errors.first(10).each { |error| puts "  - #{error}" }
-    puts "  ... and #{validation_errors.size - 10} more errors" if validation_errors.size > 10
-    puts "-> Failed models saved to: #{failed_path}"
-    exit(1)
-  end
-
-  puts '✓ Models validation passed'
-end
-
-def display_model_stats
-  puts "\nModel count:"
-  provider_counts = @models.all.group_by(&:provider).transform_values(&:count)
-
-  RubyLLM::Provider.providers.each do |sym, provider_class|
-    name = provider_class.name
-    count = provider_counts[sym.to_s] || 0
-    status = status(sym)
-    puts "  #{name}: #{count} models #{status}"
-  end
-
-  puts 'Refresh complete.'
-end
-
-def status(provider_sym)
-  provider_class = RubyLLM::Provider.providers[provider_sym]
-  if provider_class.local?
-    ' (LOCAL - SKIP)'
-  elsif provider_class.configured?(RubyLLM.config)
-    ' (OK)'
-  else
-    ' (NOT CONFIGURED)'
-  end
-end