ruby_llm 1.4.0 → 1.5.0

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Mistral
+      # Determines capabilities for Mistral models
+      module Capabilities
+        module_function
+
+        def supports_streaming?(_model_id)
+          true
+        end
+
+        def supports_tools?(_model_id)
+          true
+        end
+
+        def supports_vision?(model_id)
+          model_id.include?('pixtral')
+        end
+
+        def supports_json_mode?(_model_id)
+          true
+        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: ['embedding']
+            }
+          else
+            {
+              input: ['text'],
+              output: ['text']
+            }
+          end
+        end
+
+        def capabilities_for(model_id)
+          case model_id
+          when /embed/ then { embeddings: true }
+          when /moderation/ then { moderation: true }
+          else
+            {
+              chat: true,
+              streaming: supports_streaming?(model_id),
+              tools: supports_tools?(model_id),
+              vision: supports_vision?(model_id),
+              json_mode: supports_json_mode?(model_id)
+            }
+          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

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Perplexity
+      # Models methods of the Perplexity API integration
+      module Models
+        def list_models(**)
+          slug = 'perplexity'
+          capabilities = Perplexity::Capabilities
+          parse_list_models_response(nil, slug, capabilities)
+        end
+
+        def parse_list_models_response(_response, slug, capabilities)
+          [
+            create_model_info('sonar', slug, capabilities),
+            create_model_info('sonar-pro', slug, capabilities),
+            create_model_info('sonar-reasoning', slug, capabilities),
+            create_model_info('sonar-reasoning-pro', slug, capabilities),
+            create_model_info('sonar-deep-research', slug, capabilities)
+          ]
+        end
+
+        def create_model_info(id, slug, capabilities)
+          Model::Info.new(
+            id: id,
+            name: capabilities.format_display_name(id),
+            provider: slug,
+            family: capabilities.model_family(id).to_s,
+            created_at: Time.now,
+            context_window: capabilities.context_window_for(id),
+            max_output_tokens: capabilities.max_tokens_for(id),
+            modalities: capabilities.modalities_for(id),
+            capabilities: capabilities.capabilities_for(id),
+            pricing: capabilities.pricing_for(id),
+            metadata: {}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/perplexity.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Perplexity API integration.
+    module Perplexity
+      extend OpenAI
+      extend Perplexity::Chat
+      extend Perplexity::Models
+
+      module_function
+
+      def api_base(_config)
+        'https://api.perplexity.ai'
+      end
+
+      def headers(config)
+        {
+          'Authorization' => "Bearer #{config.perplexity_api_key}",
+          'Content-Type' => 'application/json'
+        }
+      end
+
+      def capabilities
+        Perplexity::Capabilities
+      end
+
+      def slug
+        'perplexity'
+      end
+
+      def configuration_requirements
+        %i[perplexity_api_key]
+      end
+
+      def parse_error(response)
+        body = response.body
+        return if body.empty?
+
+        # If response is HTML (Perplexity returns HTML for auth errors)
+        if body.include?('<html>') && body.include?('<title>')
+          # Extract title content
+          title_match = body.match(%r{<title>(.+?)</title>})
+          if title_match
+            # Clean up the title - remove status code if present
+            message = title_match[1]
+            message = message.sub(/^\d+\s+/, '') # Remove leading digits and space
+            return message
+          end
+        end
+
+        # Fall back to parent's implementation
+        super
+      end
+    end
+  end
+end

data/lib/ruby_llm/version.rb

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

data/lib/ruby_llm.rb

@@ -16,9 +16,11 @@ loader.inflector.inflect(
   'openai' => 'OpenAI',
   'api' => 'API',
   'deepseek' => 'DeepSeek',
+  'perplexity' => 'Perplexity',
   'bedrock' => 'Bedrock',
   'openrouter' => 'OpenRouter',
   'gpustack' => 'GPUStack',
+  'mistral' => 'Mistral',
   'pdf' => 'PDF'
 )
 loader.ignore("#{__dir__}/tasks")
@@ -78,14 +80,16 @@ module RubyLLM
   end
 end
 
-RubyLLM::Provider.register :openai, RubyLLM::Providers::OpenAI
 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
+RubyLLM::Provider.register :deepseek, RubyLLM::Providers::DeepSeek
+RubyLLM::Provider.register :gemini, RubyLLM::Providers::Gemini
 RubyLLM::Provider.register :gpustack, RubyLLM::Providers::GPUStack
+RubyLLM::Provider.register :mistral, RubyLLM::Providers::Mistral
+RubyLLM::Provider.register :ollama, RubyLLM::Providers::Ollama
+RubyLLM::Provider.register :openai, RubyLLM::Providers::OpenAI
+RubyLLM::Provider.register :openrouter, RubyLLM::Providers::OpenRouter
+RubyLLM::Provider.register :perplexity, RubyLLM::Providers::Perplexity
 
 if defined?(Rails::Railtie)
   require 'ruby_llm/railtie'

data/lib/tasks/models_docs.rake

@@ -6,14 +6,14 @@ require 'fileutils'
 namespace :models do
   desc 'Generate available models documentation'
   task :docs do
-    FileUtils.mkdir_p('docs/guides') # ensure output directory exists
+    FileUtils.mkdir_p('docs') # ensure output directory exists
 
     # Generate markdown content
     output = generate_models_markdown
 
     # Write the output
-    File.write('docs/guides/available-models.md', output)
-    puts 'Generated docs/guides/available-models.md'
+    File.write('docs/available-models.md', output)
+    puts 'Generated docs/available-models.md'
   end
 end
 
@@ -22,9 +22,8 @@ def generate_models_markdown
     ---
     layout: default
     title: Available Models
-    parent: Guides
-    nav_order: 11
-    permalink: /guides/available-models
+    nav_order: 5
+    permalink: /available-models
     description: Browse hundreds of AI models from every major provider. Always up-to-date, automatically generated.
     ---
 

data/lib/tasks/models_update.rake

@@ -22,7 +22,9 @@ def configure_from_env
     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