ruby_llm 1.2.0 → 1.3.0

data/lib/ruby_llm.rb

@@ -16,7 +16,9 @@ loader.inflector.inflect(
   'openai' => 'OpenAI',
   'api' => 'API',
   'deepseek' => 'DeepSeek',
-  'bedrock' => 'Bedrock'
+  'bedrock' => 'Bedrock',
+  'openrouter' => 'OpenRouter',
+  'pdf' => 'PDF'
 )
 loader.ignore("#{__dir__}/tasks")
 loader.ignore("#{__dir__}/ruby_llm/railtie")
@@ -30,8 +32,14 @@ module RubyLLM
   class Error < StandardError; end
 
   class << self
-    def chat(model: nil, provider: nil, assume_model_exists: false)
-      Chat.new(model:, provider:, assume_model_exists:)
+    def context
+      context_config = config.dup
+      yield context_config if block_given?
+      Context.new(context_config)
+    end
+
+    def chat(...)
+      Chat.new(...)
     end
 
     def embed(...)
@@ -60,9 +68,9 @@ module RubyLLM
 
     def logger
       @logger ||= Logger.new(
-        $stdout,
+        config.log_file,
         progname: 'RubyLLM',
-        level: ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
+        level: config.log_level
       )
     end
   end
@@ -73,6 +81,8 @@ RubyLLM::Provider.register :anthropic, RubyLLM::Providers::Anthropic
 RubyLLM::Provider.register :gemini, RubyLLM::Providers::Gemini
 RubyLLM::Provider.register :deepseek, RubyLLM::Providers::DeepSeek
 RubyLLM::Provider.register :bedrock, RubyLLM::Providers::Bedrock
+RubyLLM::Provider.register :openrouter, RubyLLM::Providers::OpenRouter
+RubyLLM::Provider.register :ollama, RubyLLM::Providers::Ollama
 
 if defined?(Rails::Railtie)
   require 'ruby_llm/railtie'

data/lib/tasks/aliases.rake

@@ -0,0 +1,235 @@
+# 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 models - group by base name and find latest
+    anthropic_latest = group_anthropic_models_by_base_name(models['anthropic'])
+
+    anthropic_latest.each do |base_name, latest_model|
+      # Check OpenRouter naming patterns for the BASE NAME (not the full dated 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) }
+
+      # Find corresponding Bedrock model
+      bedrock_model = find_best_bedrock_model(latest_model, models['bedrock'])
+
+      # Create alias if we have any match (OpenRouter OR Bedrock) OR if it's Anthropic-only
+      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
+
+    # Also check if Bedrock has models that Anthropic doesn't
+    models['bedrock'].each do |bedrock_model|
+      next unless bedrock_model.start_with?('anthropic.')
+
+      # Extract the Claude model name
+      next unless bedrock_model =~ /anthropic\.(claude-[\d\.]+-[a-z]+)/
+
+      base_name = Regexp.last_match(1)
+      # Normalize to Anthropic naming convention
+      anthropic_name = base_name.gsub('.', '-')
+
+      # Skip if we already have an alias for this
+      next if aliases[anthropic_name]
+
+      # Check if this model exists in OpenRouter
+      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
+
+    # Gemini models
+    models['gemini'].each do |model|
+      # OpenRouter uses "google/" prefix and sometimes different naming
+      openrouter_variants = [
+        "google/#{model}",
+        "google/#{model.gsub('gemini-', 'gemini-').gsub('.', '-')}",
+        "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
+
+    # DeepSeek models
+    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
+
+    # Write the result
+    sorted_aliases = aliases.sort.to_h
+    File.write('lib/ruby_llm/aliases.json', 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
+
+    # Find the latest model for each base name
+    latest_models = {}
+    grouped.each do |base_name, model_list|
+      if model_list.size == 1
+        latest_models[base_name] = model_list.first
+      else
+        # Sort by date and take the latest
+        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
+    # Remove date suffix (YYYYMMDD) from model name
+    if model =~ /^(.+)-(\d{8})$/
+      Regexp.last_match(1)
+    else
+      # Models without date suffix (like claude-2.0, claude-2.1)
+      model
+    end
+  end
+
+  def extract_date_from_model(model) # rubocop:disable Rake/MethodDefinitionInTask
+    # Extract date for comparison, return '00000000' for models without dates
+    if model =~ /-(\d{8})$/
+      Regexp.last_match(1)
+    else
+      '00000000' # Ensures models without dates sort before dated ones
+    end
+  end
+
+  def find_best_bedrock_model(anthropic_model, bedrock_models) # rubocop:disable Metrics/PerceivedComplexity,Rake/MethodDefinitionInTask
+    # Special mapping for Claude 2.x models
+    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
+                     # For Claude 3+ models, extract base name
+                     extract_base_name(anthropic_model)
+                   end
+
+    # Find all matching Bedrock models by stripping provider prefix and comparing base name
+    matching_models = bedrock_models.select do |bedrock_model|
+      # Strip any provider prefix (anthropic. or us.anthropic.)
+      model_without_prefix = bedrock_model.sub(/^(?:us\.)?anthropic\./, '')
+      model_without_prefix.start_with?(base_pattern)
+    end
+
+    return nil if matching_models.empty?
+
+    # Get model info to check context window
+    begin
+      model_info = RubyLLM.models.find(anthropic_model)
+      target_context = model_info.context_window
+    rescue StandardError
+      target_context = nil
+    end
+
+    # If we have context window info, try to match it
+    if target_context
+      # Convert to k format (200000 -> 200k)
+      target_k = target_context / 1000
+
+      # Find models with this specific context window
+      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
+
+    # Otherwise, pick the one with the highest context window or latest version
+    matching_models.min_by do |model|
+      # Extract context window if specified
+      context_priority = if model =~ /:(?:\d+:)?(\d+)k/
+                           -Regexp.last_match(1).to_i # Negative for descending sort
+                         else
+                           0 # No context specified
+                         end
+
+      # Extract version if present
+      version_priority = if model =~ /-v(\d+):/
+                           -Regexp.last_match(1).to_i # Negative for descending sort (latest version first)
+                         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,168 +1,211 @@
 # frozen_string_literal: true
 
-require 'ruby_llm'
+require 'dotenv/load'
 require 'fileutils'
 
-MODEL_KEYS_TO_DISPLAY = %i[
-  id
-  type
-  display_name
-  provider
-  context_window
-  max_tokens
-  family
-  input_price_per_million
-  output_price_per_million
-].freeze
-
-def to_markdown_table(models) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-  to_display_hash = ->(model) { model.to_h.slice(*MODEL_KEYS_TO_DISPLAY) }
-  model_hashes = Array(models).map { |model| to_display_hash.call(model) }
-
-  # Create abbreviated headers
-  headers = {
-    id: 'ID',
-    type: 'Type',
-    display_name: 'Name',
-    provider: 'Provider',
-    context_window: 'Context',
-    max_tokens: 'MaxTok',
-    family: 'Family',
-    input_price_per_million: 'In$/M',
-    output_price_per_million: 'Out$/M'
-  }
+namespace :models do
+  desc 'Generate available models documentation'
+  task :docs do
+    FileUtils.mkdir_p('docs/guides') # ensure output directory exists
 
-  # Create header row with alignment markers
-  # Right-align numbers, left-align text
-  alignments = {
-    id: ':--',
-    type: ':--',
-    display_name: ':--',
-    provider: ':--',
-    context_window: '--:',
-    max_tokens: '--:',
-    family: ':--',
-    input_price_per_million: '--:',
-    output_price_per_million: '--:'
-  }
+    # Generate markdown content
+    output = generate_models_markdown
 
-  # Build the table
-  lines = []
+    # Write the output
+    File.write('docs/guides/available-models.md', output)
+    puts 'Generated docs/guides/available-models.md'
+  end
+end
 
-  # Header row
-  lines << "| #{MODEL_KEYS_TO_DISPLAY.map { |key| headers[key] }.join(' | ')} |"
+def generate_models_markdown
+  <<~MARKDOWN
+    ---
+    layout: default
+    title: Available Models
+    parent: Guides
+    nav_order: 10
+    permalink: /guides/available-models
+    ---
 
-  # Alignment row
-  lines << "| #{MODEL_KEYS_TO_DISPLAY.map { |key| alignments[key] }.join(' | ')} |"
+    # Available Models
+    {: .no_toc }
 
-  # Data rows
-  model_hashes.each do |model_hash|
-    values = MODEL_KEYS_TO_DISPLAY.map do |key|
-      if model_hash[key].is_a?(Float)
-        format('%.2f', model_hash[key])
-      else
-        model_hash[key]
-      end
-    end
+    This guide lists all models available in RubyLLM, automatically generated from the current model registry.
+    {: .fs-6 .fw-300 }
 
-    lines << "| #{values.join(' | ')} |"
-  end
+    ## Table of contents
+    {: .no_toc .text-delta }
+
+    1. TOC
+    {:toc}
+
+    ---
+
+    ## Contributing
+
+    The model list is automatically generated from the model registry. To add or update models:
+
+    1. Edit the appropriate `capabilities.rb` file in `lib/ruby_llm/providers/<provider>/`
+    2. Run `rake models:update` to refresh the model registry
+    3. Submit a pull request with the updated `models.json`
+
+    See [Contributing Guide](/CONTRIBUTING.md) for more 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
 
-  lines.join("\n")
+    #{generate_capability_sections}
+
+    ## Models by Modality
+
+    #{generate_modality_sections}
+  MARKDOWN
 end
 
-namespace :models do # rubocop:disable Metrics/BlockLength
-  desc 'Generate available models documentation'
-  task :docs do # rubocop:disable Metrics/BlockLength
-    FileUtils.mkdir_p('docs/guides') # ensure output directory exists
+def generate_provider_sections
+  RubyLLM::Provider.providers.keys.map do |provider|
+    models = RubyLLM.models.by_provider(provider)
+    next if models.none?
+
+    <<~PROVIDER
+      ### #{provider.to_s.capitalize} (#{models.count})
 
-    output = <<~MARKDOWN
-      ---
-      layout: default
-      title: Available Models
-      parent: Guides
-      nav_order: 10
-      permalink: /guides/available-models
-      ---
+      #{models_table(models)}
+    PROVIDER
+  end.compact.join("\n\n")
+end
 
-      # Available Models
-      {: .no_toc }
+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') }
+  }
 
-      This guide lists all models available in RubyLLM, automatically generated from the current model registry.
-      {: .fs-6 .fw-300 }
+  capabilities.map do |capability, models|
+    next if models.none?
 
-      ## Table of contents
-      {: .no_toc .text-delta }
+    <<~CAPABILITY
+      ### #{capability} (#{models.count})
 
-      1. TOC
-      {:toc}
+      #{models_table(models)}
+    CAPABILITY
+  end.compact.join("\n\n")
+end
 
-      ---
+def generate_modality_sections # rubocop:disable Metrics/PerceivedComplexity
+  sections = []
 
-      ## Contributing
+  # Models that support vision/images
+  vision_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('image') }
+  if vision_models.any?
+    sections << <<~SECTION
+      ### Vision Models (#{vision_models.count})
 
-      The model list is automatically generated from the model registry. To add or update models:
+      Models that can process images:
 
-      1. Edit the appropriate `capabilities.rb` file in `lib/ruby_llm/providers/<provider>/`
-      2. Run `rake models:update` to refresh the model registry
-      3. Submit a pull request with the updated `models.json`
+      #{models_table(vision_models)}
+    SECTION
+  end
 
-      See [Contributing Guide](/CONTRIBUTING.md) for more details.
+  # Models that support audio
+  audio_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('audio') }
+  if audio_models.any?
+    sections << <<~SECTION
+      ### Audio Input Models (#{audio_models.count})
 
-      ## Additional Model Information
+      Models that can process audio:
 
-      The tables below show basic model information including context windows, token limits, and pricing. Models also have additional capabilities not shown in the tables:
+      #{models_table(audio_models)}
+    SECTION
+  end
 
-      - **Vision Support**: Whether the model can process images
-      - **Function Calling**: Whether the model supports function calling
-      - **JSON Mode**: Whether the model can be constrained to output valid JSON
-      - **Structured Output**: Whether the model supports structured output formats
+  # Models that support PDFs
+  pdf_models = RubyLLM.models.select { |m| (m.modalities.input || []).include?('pdf') }
+  if pdf_models.any?
+    sections << <<~SECTION
+      ### PDF Models (#{pdf_models.count})
 
-      For complete model information, you can check the `models.json` file in the RubyLLM source code.
+      Models that can process PDF documents:
 
-      For more information about working with models, see the [Working with Models](/guides/models) guide.
+      #{models_table(pdf_models)}
+    SECTION
+  end
 
-      ## Models by Type
-      {: .d-inline-block }
+  # Models for embeddings
+  embedding_models = RubyLLM.models.select { |m| (m.modalities.output || []).include?('embeddings') }
+  if embedding_models.any?
+    sections << <<~SECTION
+      ### Embedding Models (#{embedding_models.count})
 
-      Last updated: #{Time.now.utc.strftime('%Y-%m-%d')}
-      {: .label .label-green }
+      Models that generate embeddings:
 
-      ### Chat Models (#{RubyLLM.models.chat_models.count})
+      #{models_table(embedding_models)}
+    SECTION
+  end
 
-      #{to_markdown_table(RubyLLM.models.chat_models)}
+  sections.join("\n\n")
+end
 
-      ### Image Models (#{RubyLLM.models.image_models.count})
+def models_table(models)
+  return '*No models found*' if models.none?
 
-      #{to_markdown_table(RubyLLM.models.image_models)}
+  headers = ['Model', 'ID', 'Provider', 'Context', 'Max Output', 'Standard Pricing (per 1M tokens)']
+  alignment = [':--', ':--', ':--', '--:', '--:', ':--']
 
-      ### Audio Models (#{RubyLLM.models.audio_models.count})
+  rows = models.sort_by { |m| [m.provider, m.name] }.map do |model|
+    # Format pricing information
+    pricing = standard_pricing_display(model)
 
-      #{to_markdown_table(RubyLLM.models.audio_models)}
+    [
+      model.name,
+      model.id,
+      model.provider,
+      model.context_window || '-',
+      model.max_output_tokens || '-',
+      pricing
+    ]
+  end
 
-      ### Embedding Models (#{RubyLLM.models.embedding_models.count})
+  table = []
+  table << "| #{headers.join(' | ')} |"
+  table << "| #{alignment.join(' | ')} |"
 
-      #{to_markdown_table(RubyLLM.models.embedding_models)}
+  rows.each do |row|
+    table << "| #{row.join(' | ')} |"
+  end
 
-      ### Moderation Models (#{RubyLLM.models.select { |m| m.type == 'moderation' }.count})
+  table.join("\n")
+end
 
-      #{to_markdown_table(RubyLLM.models.select { |m| m.type == 'moderation' })}
+def standard_pricing_display(model)
+  # Access pricing data using to_h to get the raw hash
+  pricing_data = model.pricing.to_h[:text_tokens]&.dig(:standard) || {}
 
-      ## Models by Provider
+  if pricing_data.any?
+    parts = []
 
-      #{RubyLLM::Provider.providers.keys.map do |provider|
-        models = RubyLLM.models.by_provider(provider)
-        next if models.none?
+    parts << "In: $#{format('%.2f', pricing_data[:input_per_million])}" if pricing_data[:input_per_million]
 
-        <<~PROVIDER
-          ### #{provider.to_s.capitalize} Models (#{models.count})
+    parts << "Out: $#{format('%.2f', pricing_data[:output_per_million])}" if pricing_data[:output_per_million]
 
-            #{to_markdown_table(models)}
-        PROVIDER
-      end.compact.join("\n")}
-    MARKDOWN
+    if pricing_data[:cached_input_per_million]
+      parts << "Cache: $#{format('%.2f', pricing_data[:cached_input_per_million])}"
+    end
 
-    File.write('docs/guides/available-models.md', output)
-    puts 'Generated docs/guides/available-models.md'
+    return parts.join(', ') if parts.any?
   end
+
+  '-'
 end