ruby_llm 1.3.2beta1 → 1.5.0

data/lib/ruby_llm/provider.rb

@@ -10,14 +10,20 @@ module RubyLLM
     module Methods
       extend Streaming
 
-      def complete(messages, tools:, temperature:, model:, connection:, &)
+      def complete(messages, tools:, temperature:, model:, connection:, params: {}, schema: nil, &) # rubocop:disable Metrics/ParameterLists
         normalized_temperature = maybe_normalize_temperature(temperature, model)
 
-        payload = render_payload(messages,
-                                 tools: tools,
-                                 temperature: normalized_temperature,
-                                 model: model,
-                                 stream: block_given?)
+        payload = Utils.deep_merge(
+          params,
+          render_payload(
+            messages,
+            tools: tools,
+            temperature: normalized_temperature,
+            model: model,
+            stream: block_given?,
+            schema: schema
+          )
+        )
 
         if block_given?
           stream_response connection, payload, &

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

@@ -11,12 +11,12 @@ module RubyLLM
           '/v1/messages'
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false)
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
           system_messages, chat_messages = separate_messages(messages)
           system_content = build_system_content(system_messages)
 
-          build_base_payload(chat_messages, temperature, model, stream).tap do |payload|
-            add_optional_fields(payload, system_content:, tools:)
+          build_base_payload(chat_messages, model, stream).tap do |payload|
+            add_optional_fields(payload, system_content:, tools:, temperature:)
           end
         end
 
@@ -32,22 +32,22 @@ module RubyLLM
             )
           end
 
-          system_messages.map { |msg| format_message(msg)[:content] }.join("\n\n")
+          system_messages.map(&:content).join("\n\n")
         end
 
-        def build_base_payload(chat_messages, temperature, model, stream)
+        def build_base_payload(chat_messages, model, stream)
           {
             model: model,
             messages: chat_messages.map { |msg| format_message(msg) },
-            temperature: temperature,
             stream: stream,
             max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
           }
         end
 
-        def add_optional_fields(payload, system_content:, tools:)
+        def add_optional_fields(payload, system_content:, tools:, temperature:)
           payload[:tools] = tools.values.map { |t| Tools.function_for(t) } if tools.any?
           payload[:system] = system_content unless system_content.empty?
+          payload[:temperature] = temperature unless temperature.nil?
         end
 
         def parse_completion_response(response)
@@ -55,9 +55,9 @@ module RubyLLM
           content_blocks = data['content'] || []
 
           text_content = extract_text_content(content_blocks)
-          tool_use = Tools.find_tool_use(content_blocks)
+          tool_use_blocks = Tools.find_tool_uses(content_blocks)
 
-          build_message(data, text_content, tool_use)
+          build_message(data, text_content, tool_use_blocks, response)
         end
 
         def extract_text_content(blocks)
@@ -65,14 +65,15 @@ module RubyLLM
           text_blocks.map { |c| c['text'] }.join
         end
 
-        def build_message(data, content, tool_use)
+        def build_message(data, content, tool_use_blocks, response)
           Message.new(
             role: :assistant,
             content: content,
-            tool_calls: Tools.parse_tool_calls(tool_use),
+            tool_calls: Tools.parse_tool_calls(tool_use_blocks),
             input_tokens: data.dig('usage', 'input_tokens'),
             output_tokens: data.dig('usage', 'output_tokens'),
-            model_id: data['model']
+            model_id: data['model'],
+            raw: response
           )
         end
 

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

@@ -8,6 +8,8 @@ module RubyLLM
         module_function
 
         def format_content(content)
+          # Convert Hash/Array back to JSON string for API
+          return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [format_text(content)] unless content.is_a?(Content)
 
           parts = []

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

@@ -7,16 +7,18 @@ module RubyLLM
       module Tools
         module_function
 
-        def find_tool_use(blocks)
-          blocks.find { |c| c['type'] == 'tool_use' }
+        def find_tool_uses(blocks)
+          blocks.select { |c| c['type'] == 'tool_use' }
         end
 
         def format_tool_call(msg)
-          tool_call = msg.tool_calls.values.first
-
           content = []
+
           content << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
-          content << format_tool_use_block(tool_call)
+
+          msg.tool_calls.each_value do |tool_call|
+            content << format_tool_use_block(tool_call)
+          end
 
           {
             role: 'assistant',
@@ -68,16 +70,24 @@ module RubyLLM
           end
         end
 
-        def parse_tool_calls(content_block)
-          return nil unless content_block && content_block['type'] == 'tool_use'
+        def parse_tool_calls(content_blocks)
+          return nil if content_blocks.nil?
 
-          {
-            content_block['id'] => ToolCall.new(
-              id: content_block['id'],
-              name: content_block['name'],
-              arguments: content_block['input']
+          # Handle single content block (backward compatibility)
+          content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
+
+          tool_calls = {}
+          content_blocks.each do |block|
+            next unless block && block['type'] == 'tool_use'
+
+            tool_calls[block['id']] = ToolCall.new(
+              id: block['id'],
+              name: block['name'],
+              arguments: block['input']
             )
-          }
+          end
+
+          tool_calls.empty? ? nil : tool_calls
         end
 
         def clean_parameters(parameters)

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

@@ -39,23 +39,22 @@ module RubyLLM
           "model/#{@model_id}/invoke"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/ParameterLists
           # Hold model_id in instance variable for use in completion_url and stream_url
           @model_id = model
 
           system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
           system_content = Anthropic::Chat.build_system_content(system_messages)
 
-          build_base_payload(chat_messages, temperature, model).tap do |payload|
-            Anthropic::Chat.add_optional_fields(payload, system_content:, tools:)
+          build_base_payload(chat_messages, model).tap do |payload|
+            Anthropic::Chat.add_optional_fields(payload, system_content:, tools:, temperature:)
           end
         end
 
-        def build_base_payload(chat_messages, temperature, model)
+        def build_base_payload(chat_messages, model)
           {
             anthropic_version: 'bedrock-2023-05-31',
             messages: chat_messages.map { |msg| format_message(msg) },
-            temperature: temperature,
             max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
           }
         end

data/lib/ruby_llm/providers/bedrock/media.rb

@@ -11,6 +11,8 @@ module RubyLLM
         module_function
 
         def format_content(content)
+          # Convert Hash/Array back to JSON string for API
+          return [Anthropic::Media.format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [Anthropic::Media.format_text(content)] unless content.is_a?(Content)
 
           parts = []

data/lib/ruby_llm/providers/bedrock/streaming/base.rb

@@ -34,7 +34,7 @@ module RubyLLM
                                                                                          payload:)
             accumulator = StreamAccumulator.new
 
-            connection.post stream_url, payload do |req|
+            response = connection.post stream_url, payload do |req|
               req.headers.merge! build_headers(signature.headers, streaming: block_given?)
               req.options.on_data = handle_stream do |chunk|
                 accumulator.add chunk
@@ -42,7 +42,7 @@ module RubyLLM
               end
             end
 
-            accumulator.to_message
+            accumulator.to_message(response)
           end
 
           def handle_stream(&block)

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

@@ -11,7 +11,7 @@ module RubyLLM
           "models/#{@model}:generateContent"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
           @model = model # Store model for completion_url/stream_url
           payload = {
             contents: format_messages(messages),
@@ -19,6 +19,12 @@ module RubyLLM
               temperature: temperature
             }
           }
+
+          if schema
+            payload[:generationConfig][:responseMimeType] = 'application/json'
+            payload[:generationConfig][:responseSchema] = convert_schema_to_gemini(schema)
+          end
+
           payload[:tools] = format_tools(tools) if tools.any?
           payload
         end
@@ -75,10 +81,39 @@ module RubyLLM
             tool_calls: tool_calls,
             input_tokens: data.dig('usageMetadata', 'promptTokenCount'),
             output_tokens: data.dig('usageMetadata', 'candidatesTokenCount'),
-            model_id: data['modelVersion'] || response.env.url.path.split('/')[3].split(':')[0]
+            model_id: data['modelVersion'] || response.env.url.path.split('/')[3].split(':')[0],
+            raw: response
           )
         end
 
+        def convert_schema_to_gemini(schema) # rubocop:disable Metrics/PerceivedComplexity
+          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' }
+          end
+        end
+
         def extract_content(data)
           candidate = data.dig('candidates', 0)
           return '' unless candidate

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

@@ -8,6 +8,8 @@ module RubyLLM
         module_function
 
         def format_content(content)
+          # Convert Hash/Array back to JSON string for API
+          return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [format_text(content)] unless content.is_a?(Content)
 
           parts = []

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

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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module GPUStack
+      # Models methods of the GPUStack API integration
+      module Models
+        module_function
+
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, _capabilities)
+          items = response.body['items'] || []
+          items.map do |model|
+            Model::Info.new(
+              id: model['name'],
+              created_at: model['created_at'] ? Time.parse(model['created_at']) : nil,
+              display_name: "#{model['source']}/#{model['name']}",
+              provider: slug,
+              type: determine_model_type(model),
+              metadata: {
+                description: model['description'],
+                source: model['source'],
+                huggingface_repo_id: model['huggingface_repo_id'],
+                ollama_library_model_name: model['ollama_library_model_name'],
+                backend: model['backend'],
+                meta: model['meta'],
+                categories: model['categories']
+              },
+              context_window: model.dig('meta', 'n_ctx'),
+              # Using context window as max tokens since it's not explicitly provided
+              max_tokens: model.dig('meta', 'n_ctx'),
+              supports_vision: model.dig('meta', 'support_vision') || false,
+              supports_functions: model.dig('meta', 'support_tool_calls') || false,
+              supports_json_mode: true, # Assuming all models support JSON mode
+              input_price_per_million: 0.0,  # Price information not available in new format
+              output_price_per_million: 0.0  # Price information not available in new format
+            )
+          end
+        end
+
+        private
+
+        def determine_model_type(model)
+          return 'embedding' if model['categories']&.include?('embedding')
+          return 'chat' if model['categories']&.include?('llm')
+
+          'other'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/gpustack.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # GPUStack API integration based on Ollama.
+    module GPUStack
+      extend OpenAI
+      extend GPUStack::Chat
+      extend GPUStack::Models
+
+      module_function
+
+      def api_base(config)
+        config.gpustack_api_base
+      end
+
+      def headers(config)
+        {
+          'Authorization' => "Bearer #{config.gpustack_api_key}"
+        }
+      end
+
+      def slug
+        'gpustack'
+      end
+
+      def local?
+        true
+      end
+
+      def configuration_requirements
+        %i[gpustack_api_base gpustack_api_key]
+      end
+    end
+  end
+end

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