ruby_llm 1.4.0 → 1.5.1

data/lib/ruby_llm/models_schema.json

@@ -0,0 +1,168 @@
+{
+  "title": "RubyLLM Models Schema",
+  "description": "Schema for validating the structure of models.json",
+  "type": "array",
+  "items": {
+    "type": "object",
+    "required": ["id", "name", "provider", "context_window", "max_output_tokens"],
+    "properties": {
+      "id": {
+        "type": "string",
+        "description": "Unique identifier for the model"
+      },
+      "name": {
+        "type": "string",
+        "description": "Display name of the model"
+      },
+      "provider": {
+        "type": "string",
+        "description": "Provider of the model (e.g., openai, anthropic, mistral)"
+      },
+      "family": {
+        "type": ["string", "null"],
+        "description": "Model family (e.g., gpt-4, claude-3)"
+      },
+      "created_at": {
+        "type": ["null", {"type": "string", "format": "date-time"}],
+        "description": "Creation date of the model"
+      },
+      "context_window": {
+        "type": ["null", {"type": "integer", "minimum": 0}],
+        "description": "Maximum context window size"
+      },
+      "max_output_tokens": {
+        "type": ["null", {"type": "integer", "minimum": 0}],
+        "description": "Maximum output tokens"
+      },
+      "knowledge_cutoff": {
+        "type": ["null", {"type": "string", "format": "date"}],
+        "description": "Knowledge cutoff date"
+      },
+      "modalities": {
+        "type": "object",
+        "required": ["input", "output"],
+        "properties": {
+          "input": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["text", "image", "audio", "pdf", "video", "file"]
+            },
+            "uniqueItems": true,
+            "description": "Supported input modalities"
+          },
+          "output": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "enum": ["text", "image", "audio", "embeddings", "moderation"]
+            },
+            "uniqueItems": true,
+            "description": "Supported output modalities"
+          }
+        }
+      },
+      "capabilities": {
+        "type": "array",
+        "items": {
+          "type": "string",
+          "enum": [
+            "streaming", "function_calling", "structured_output", "predicted_outputs",
+            "distillation", "fine_tuning", "batch", "realtime", "image_generation",
+            "speech_generation", "transcription", "translation", "citations", "reasoning",
+            "caching", "moderation", "json_mode", "vision"
+          ]
+        },
+        "uniqueItems": true,
+        "description": "Model capabilities"
+      },
+      "pricing": {
+        "type": "object",
+        "properties": {
+          "text_tokens": {
+            "type": "object",
+            "required": ["standard"],
+            "properties": {
+              "standard": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0},
+                  "cached_input_per_million": {"type": "number", "minimum": 0},
+                  "output_per_million": {"type": "number", "minimum": 0},
+                  "reasoning_output_per_million": {"type": "number", "minimum": 0}
+                }
+              },
+              "batch": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0},
+                  "output_per_million": {"type": "number", "minimum": 0}
+                }
+              }
+            }
+          },
+          "images": {
+            "type": "object",
+            "properties": {
+              "standard": {
+                "type": "object",
+                "properties": {
+                  "input": {"type": "number", "minimum": 0},
+                  "output": {"type": "number", "minimum": 0}
+                }
+              },
+              "batch": {
+                "type": "object",
+                "properties": {
+                  "input": {"type": "number", "minimum": 0},
+                  "output": {"type": "number", "minimum": 0}
+                }
+              }
+            }
+          },
+          "audio_tokens": {
+            "type": "object",
+            "properties": {
+              "standard": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0},
+                  "output_per_million": {"type": "number", "minimum": 0}
+                }
+              },
+              "batch": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0},
+                  "output_per_million": {"type": "number", "minimum": 0}
+                }
+              }
+            }
+          },
+          "embeddings": {
+            "type": "object",
+            "properties": {
+              "standard": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0}
+                }
+              },
+              "batch": {
+                "type": "object",
+                "properties": {
+                  "input_per_million": {"type": "number", "minimum": 0}
+                }
+              }
+            }
+          }
+        },
+        "description": "Pricing information for the model"
+      },
+      "metadata": {
+        "type": "object",
+        "description": "Additional metadata about the model"
+      }
+    }
+  }
+}

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

@@ -280,6 +280,9 @@ module RubyLLM
           # Embedding output
           modalities[:output] << 'embeddings' if model_id.match?(/embedding|gemini-embedding/)
 
+          # Image output for imagen models
+          modalities[:output] = ['image'] if model_id.match?(/imagen/)
+
           modalities
         end
 

data/lib/ruby_llm/providers/mistral/capabilities.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Mistral
+      # Determines capabilities for Mistral models
+      module Capabilities
+        module_function
+
+        def supports_streaming?(model_id)
+          # All chat models support streaming, but not embedding/moderation/OCR/transcription
+          !model_id.match?(/embed|moderation|ocr|transcriptions/)
+        end
+
+        def supports_tools?(model_id)
+          # Most chat models support tools except embedding/moderation/OCR/voxtral/transcription
+          !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions|mistral-(tiny|small)-(2312|2402)/)
+        end
+
+        def supports_vision?(model_id)
+          # Models with vision capabilities
+          model_id.match?(/pixtral|mistral-small-(2503|2506)|mistral-medium/)
+        end
+
+        def supports_json_mode?(model_id)
+          # Most chat models support JSON mode (structured output)
+          !model_id.match?(/embed|moderation|ocr|voxtral|transcriptions/) && supports_tools?(model_id)
+        end
+
+        def format_display_name(model_id)
+          case model_id
+          when /mistral-large/ then 'Mistral Large'
+          when /mistral-medium/ then 'Mistral Medium'
+          when /mistral-small/ then 'Mistral Small'
+          when /ministral-3b/ then 'Ministral 3B'
+          when /ministral-8b/ then 'Ministral 8B'
+          when /codestral/ then 'Codestral'
+          when /pixtral-large/ then 'Pixtral Large'
+          when /pixtral-12b/ then 'Pixtral 12B'
+          when /mistral-embed/ then 'Mistral Embed'
+          when /mistral-moderation/ then 'Mistral Moderation'
+          else model_id.split('-').map(&:capitalize).join(' ')
+          end
+        end
+
+        def model_family(model_id)
+          case model_id
+          when /mistral-large/ then 'mistral-large'
+          when /mistral-medium/ then 'mistral-medium'
+          when /mistral-small/ then 'mistral-small'
+          when /ministral/ then 'ministral'
+          when /codestral/ then 'codestral'
+          when /pixtral/ then 'pixtral'
+          when /mistral-embed/ then 'mistral-embed'
+          when /mistral-moderation/ then 'mistral-moderation'
+          else 'mistral'
+          end
+        end
+
+        def context_window_for(_model_id)
+          32_768 # Default for most Mistral models
+        end
+
+        def max_tokens_for(_model_id)
+          8192 # Default for most Mistral models
+        end
+
+        def modalities_for(model_id)
+          case model_id
+          when /pixtral/
+            {
+              input: %w[text image],
+              output: ['text']
+            }
+          when /embed/
+            {
+              input: ['text'],
+              output: ['embeddings']
+            }
+          else
+            {
+              input: ['text'],
+              output: ['text']
+            }
+          end
+        end
+
+        def capabilities_for(model_id) # rubocop:disable Metrics/PerceivedComplexity
+          case model_id
+          when /moderation/ then ['moderation']
+          when /voxtral.*transcribe/ then ['transcription']
+          when /ocr/ then ['vision']
+          else
+            capabilities = []
+            capabilities << 'streaming' if supports_streaming?(model_id)
+            capabilities << 'function_calling' if supports_tools?(model_id)
+            capabilities << 'structured_output' if supports_json_mode?(model_id)
+            capabilities << 'vision' if supports_vision?(model_id)
+
+            # Model-specific capabilities
+            capabilities << 'reasoning' if model_id.match?(/magistral/)
+            capabilities << 'batch' unless model_id.match?(/voxtral|ocr|embed|moderation/)
+            capabilities << 'fine_tuning' if model_id.match?(/mistral-(small|medium|large)|devstral/)
+            capabilities << 'distillation' if model_id.match?(/ministral/)
+            capabilities << 'predicted_outputs' if model_id.match?(/codestral/)
+
+            capabilities.uniq
+          end
+        end
+
+        def pricing_for(_model_id)
+          {
+            input: 0.0,
+            output: 0.0
+          }
+        end
+
+        def release_date_for(model_id)
+          case model_id
+          # 2023 releases
+          when 'open-mistral-7b', 'mistral-tiny' then '2023-09-27'
+          when 'mistral-medium-2312', 'mistral-small-2312', 'mistral-small',
+               'open-mixtral-8x7b', 'mistral-tiny-2312' then '2023-12-11'
+
+          # 2024 releases
+          when 'mistral-embed' then '2024-01-11'
+          when 'mistral-large-2402', 'mistral-small-2402' then '2024-02-26'
+          when 'open-mixtral-8x22b', 'open-mixtral-8x22b-2404' then '2024-04-17'
+          when 'codestral-2405' then '2024-05-22'
+          when 'codestral-mamba-2407', 'codestral-mamba-latest', 'open-codestral-mamba' then '2024-07-16'
+          when 'open-mistral-nemo', 'open-mistral-nemo-2407', 'mistral-tiny-2407',
+               'mistral-tiny-latest' then '2024-07-18'
+          when 'mistral-large-2407' then '2024-07-24'
+          when 'pixtral-12b-2409', 'pixtral-12b-latest', 'pixtral-12b' then '2024-09-17'
+          when 'mistral-small-2409' then '2024-09-18'
+          when 'ministral-3b-2410', 'ministral-3b-latest', 'ministral-8b-2410',
+               'ministral-8b-latest' then '2024-10-16'
+          when 'pixtral-large-2411', 'pixtral-large-latest', 'mistral-large-pixtral-2411' then '2024-11-12'
+          when 'mistral-large-2411', 'mistral-large-latest', 'mistral-large' then '2024-11-20'
+          when 'codestral-2411-rc5', 'mistral-moderation-2411', 'mistral-moderation-latest' then '2024-11-26'
+          when 'codestral-2412' then '2024-12-17'
+
+          # 2025 releases
+          when 'mistral-small-2501' then '2025-01-13'
+          when 'codestral-2501' then '2025-01-14'
+          when 'mistral-saba-2502', 'mistral-saba-latest' then '2025-02-18'
+          when 'mistral-small-2503' then '2025-03-03'
+          when 'mistral-ocr-2503' then '2025-03-21'
+          when 'mistral-medium', 'mistral-medium-latest', 'mistral-medium-2505' then '2025-05-06'
+          when 'codestral-embed', 'codestral-embed-2505' then '2025-05-21'
+          when 'mistral-ocr-2505', 'mistral-ocr-latest' then '2025-05-23'
+          when 'devstral-small-2505' then '2025-05-28'
+          when 'mistral-small-2506', 'mistral-small-latest', 'magistral-medium-2506',
+               'magistral-medium-latest' then '2025-06-10'
+          when 'devstral-small-2507', 'devstral-small-latest', 'devstral-medium-2507',
+               'devstral-medium-latest' then '2025-07-09'
+          when 'codestral-2508', 'codestral-latest' then '2025-08-30'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Mistral
+      # Chat methods for Mistral API
+      module Chat
+        module_function
+
+        def format_role(role)
+          # Mistral doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil)
+          payload = super
+          # Mistral doesn't support stream_options
+          payload.delete(:stream_options)
+          payload
+        end
+        # rubocop:enable Metrics/ParameterLists
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/mistral/embeddings.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Mistral
+      # Embeddings methods for Mistral API
+      module Embeddings
+        module_function
+
+        def embedding_url(...)
+          'embeddings'
+        end
+
+        def render_embedding_payload(text, model:, dimensions:) # rubocop:disable Lint/UnusedMethodArgument
+          # Mistral doesn't support dimensions parameter
+          {
+            model: model,
+            input: text
+          }
+        end
+
+        def parse_embedding_response(response, model:, text:)
+          data = response.body
+          input_tokens = data.dig('usage', 'prompt_tokens') || 0
+          vectors = data['data'].map { |d| d['embedding'] }
+
+          # If we only got one embedding AND the input was a single string (not an array),
+          # return it as a single vector
+          vectors = vectors.first if vectors.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens:)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/mistral/models.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Mistral
+      # Model information for Mistral
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def headers(config)
+          {
+            'Authorization' => "Bearer #{config.mistral_api_key}"
+          }
+        end
+
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['data']).map do |model_data|
+            model_id = model_data['id']
+
+            # Use fixed release date for Mistral models
+            release_date = capabilities.release_date_for(model_id)
+            created_at = release_date ? Time.parse(release_date) : nil
+
+            Model::Info.new(
+              id: model_id,
+              name: capabilities.format_display_name(model_id),
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              created_at: created_at,
+              context_window: capabilities.context_window_for(model_id),
+              max_output_tokens: capabilities.max_tokens_for(model_id),
+              modalities: capabilities.modalities_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
+              metadata: {
+                object: model_data['object'],
+                owned_by: model_data['owned_by']
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/mistral.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Mistral API integration.
+    module Mistral
+      extend OpenAI
+      extend Mistral::Chat
+      extend Mistral::Models
+      extend Mistral::Embeddings
+
+      module_function
+
+      def api_base(_config)
+        'https://api.mistral.ai/v1'
+      end
+
+      def headers(config)
+        {
+          'Authorization' => "Bearer #{config.mistral_api_key}"
+        }
+      end
+
+      def capabilities
+        Mistral::Capabilities
+      end
+
+      def slug
+        'mistral'
+      end
+
+      def configuration_requirements
+        %i[mistral_api_key]
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/perplexity/capabilities.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Perplexity
+      # Determines capabilities and pricing for Perplexity models
+      module Capabilities
+        module_function
+
+        # Returns the context window size for the given model ID
+        # @param model_id [String] the model identifier
+        # @return [Integer] the context window size in tokens
+        def context_window_for(model_id)
+          case model_id
+          when /sonar-pro/ then 200_000
+          else 128_000
+          end
+        end
+
+        # Returns the maximum number of tokens that can be generated
+        # @param model_id [String] the model identifier
+        # @return [Integer] the maximum number of tokens
+        def max_tokens_for(model_id)
+          case model_id
+          when /sonar-(?:pro|reasoning-pro)/ then 8_192
+          else 4_096
+          end
+        end
+
+        # Returns the price per million tokens for input
+        # @param model_id [String] the model identifier
+        # @return [Float] the price per million tokens in USD
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input) || 1.0
+        end
+
+        # Returns the price per million tokens for output
+        # @param model_id [String] the model identifier
+        # @return [Float] the price per million tokens in USD
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || 1.0
+        end
+
+        # Determines if the model supports vision capabilities
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports vision
+        def supports_vision?(model_id)
+          case model_id
+          when /sonar-reasoning-pro/, /sonar-reasoning/, /sonar-pro/, /sonar/ then true
+          else false
+          end
+        end
+
+        # Determines if the model supports function calling
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports functions
+        def supports_functions?(_model_id)
+          false
+        end
+
+        # Determines if the model supports JSON mode
+        def supports_json_mode?(_model_id)
+          true
+        end
+
+        # Formats the model ID into a human-readable display name
+        # @param model_id [String] the model identifier
+        # @return [String] the formatted display name
+        def format_display_name(model_id)
+          case model_id
+          when 'sonar' then 'Sonar'
+          when 'sonar-pro' then 'Sonar Pro'
+          when 'sonar-reasoning' then 'Sonar Reasoning'
+          when 'sonar-reasoning-pro' then 'Sonar Reasoning Pro'
+          when 'sonar-deep-research' then 'Sonar Deep Research'
+          else
+            model_id.split('-')
+                    .map(&:capitalize)
+                    .join(' ')
+          end
+        end
+
+        # Returns the model type
+        # @param model_id [String] the model identifier
+        # @return [String] the model type (e.g., 'chat')
+        def model_type(_model_id)
+          'chat'
+        end
+
+        # Returns the model family
+        # @param model_id [String] the model identifier
+        # @return [Symbol] the model family
+        def model_family(model_id)
+          case model_id
+          when 'sonar' then :sonar
+          when 'sonar-pro' then :sonar_pro
+          when 'sonar-reasoning' then :sonar_reasoning
+          when 'sonar-reasoning-pro' then :sonar_reasoning_pro
+          when 'sonar-deep-research' then :sonar_deep_research
+          else :unknown
+          end
+        end
+
+        def modalities_for(_model_id)
+          {
+            input: ['text'],
+            output: ['text']
+          }
+        end
+
+        def capabilities_for(model_id)
+          capabilities = %w[streaming json_mode]
+          capabilities << 'vision' if supports_vision?(model_id)
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          family = model_family(model_id)
+          prices = PRICES.fetch(family, { input: 1.0, output: 1.0 })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+
+          # Add special pricing if available
+          standard_pricing[:citation_per_million] = prices[:citation] if prices[:citation]
+          standard_pricing[:reasoning_per_million] = prices[:reasoning] if prices[:reasoning]
+          standard_pricing[:search_per_thousand] = prices[:search_queries] if prices[:search_queries]
+
+          {
+            text_tokens: {
+              standard: standard_pricing
+            }
+          }
+        end
+
+        # Pricing information for Perplexity models (USD per 1M tokens)
+        PRICES = {
+          sonar: {
+            input: 1.0,
+            output: 1.0
+          },
+          sonar_pro: {
+            input: 3.0,
+            output: 15.0
+          },
+          sonar_reasoning: {
+            input: 1.0,
+            output: 5.0
+          },
+          sonar_reasoning_pro: {
+            input: 2.0,
+            output: 8.0
+          },
+          sonar_deep_research: {
+            input: 2.0,
+            output: 8.0,
+            citation: 2.0,
+            reasoning: 3.0,
+            search_queries: 5.0
+          }
+        }.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Perplexity
+      # Chat formatting for Perplexity provider
+      module Chat
+        module_function
+
+        def format_role(role)
+          # Perplexity doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+      end
+    end
+  end
+end