ruby_llm 1.12.1 → 1.13.0

data/lib/ruby_llm/models.rb

@@ -266,8 +266,8 @@ module RubyLLM
       end
 
       def index_by_key(models)
-        models.each_with_object({}) do |model, hash|
-          hash["#{model.provider}:#{model.id}"] = model
+        models.to_h do |model|
+          ["#{model.provider}:#{model.id}", model]
         end
       end
 
@@ -312,12 +312,14 @@ module RubyLLM
         modalities = normalize_models_dev_modalities(model_data[:modalities])
         capabilities = models_dev_capabilities(model_data, modalities)
 
+        created_date = model_data[:release_date] || model_data[:last_updated]
+
         data = {
           id: model_data[:id],
           name: model_data[:name] || model_data[:id],
           provider: provider_slug,
           family: model_data[:family],
-          created_at: model_data[:release_date] || model_data[:last_updated],
+          created_at: "#{created_date} 00:00:00 UTC",
           context_window: model_data.dig(:limit, :context),
           max_output_tokens: model_data.dig(:limit, :output),
           knowledge_cutoff: normalize_models_dev_knowledge(model_data[:knowledge]),

data/lib/ruby_llm/provider.rb

@@ -37,13 +37,16 @@ module RubyLLM
       self.class.configuration_requirements
     end
 
-    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil, &) # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable Metrics/ParameterLists
+    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil,
+                 tool_prefs: nil, &)
       normalized_temperature = maybe_normalize_temperature(temperature, model)
 
       payload = Utils.deep_merge(
         render_payload(
           messages,
           tools: tools,
+          tool_prefs: tool_prefs,
           temperature: normalized_temperature,
           model: model,
           stream: block_given?,
@@ -59,6 +62,7 @@ module RubyLLM
         sync_response @connection, payload, headers
       end
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def list_models
       response = @connection.get models_url

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

@@ -31,11 +31,28 @@ module RubyLLM
         end
 
         def supports_functions?(model_id)
-          model_id.match?(/claude-3/)
+          !model_id.match?(/claude-[12]/)
+        end
+
+        def supports_tool_choice?(_model_id)
+          true
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          true
         end
 
         def supports_json_mode?(model_id)
-          model_id.match?(/claude-3/)
+          !model_id.match?(/claude-[12]/)
+        end
+
+        def supports_structured_output?(model_id)
+          match = model_id.match(/claude-(?:sonnet|opus|haiku)-(\d+)-(\d+)/)
+          return false unless match
+
+          major = match[1].to_i
+          minor = match[2].to_i
+          major > 4 || (major == 4 && minor >= 5)
         end
 
         def supports_extended_thinking?(model_id)
@@ -92,12 +109,13 @@ module RubyLLM
         def capabilities_for(model_id)
           capabilities = ['streaming']
 
-          if model_id.match?(/claude-3/)
+          unless model_id.match?(/claude-[12]/)
             capabilities << 'function_calling'
             capabilities << 'batch'
           end
 
-          capabilities << 'reasoning' if model_id.match?(/claude-3-7|-4/)
+          capabilities << 'structured_output' if supports_structured_output?(model_id)
+          capabilities << 'reasoning' if model_id.match?(/claude-3-7-sonnet|claude-(?:sonnet|opus|haiku)-4/)
           capabilities << 'citations' if model_id.match?(/claude-3\.5|claude-3-7/)
           capabilities
         end

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

@@ -8,17 +8,21 @@ module RubyLLM
         module_function
 
         def completion_url
-          '/v1/messages'
+          'v1/messages'
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/ParameterLists
+        def render_payload(messages, tools:, temperature:, model:, stream: false,
+                           schema: nil, thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
           system_messages, chat_messages = separate_messages(messages)
           system_content = build_system_content(system_messages)
 
           build_base_payload(chat_messages, model, stream, thinking).tap do |payload|
-            add_optional_fields(payload, system_content:, tools:, temperature:)
+            add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema:)
           end
         end
+        # rubocop:enable Metrics/ParameterLists
 
         def separate_messages(messages)
           messages.partition { |msg| msg.role == :system }
@@ -59,10 +63,23 @@ module RubyLLM
           payload
         end
 
-        def add_optional_fields(payload, system_content:, tools:, temperature:)
-          payload[:tools] = tools.values.map { |t| Tools.function_for(t) } if tools.any?
+        def add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema: nil) # rubocop:disable Metrics/ParameterLists
+          if tools.any?
+            payload[:tools] = tools.values.map { |t| Tools.function_for(t) }
+            unless tool_prefs[:choice].nil? && tool_prefs[:calls].nil?
+              payload[:tool_choice] = Tools.build_tool_choice(tool_prefs)
+            end
+          end
           payload[:system] = system_content unless system_content.empty?
           payload[:temperature] = temperature unless temperature.nil?
+          payload[:output_config] = build_output_config(schema) if schema
+        end
+
+        def build_output_config(schema)
+          normalized = RubyLLM::Utils.deep_dup(schema[:schema])
+          normalized.delete(:strict)
+          normalized.delete('strict')
+          { format: { type: 'json_schema', schema: normalized } }
         end
 
         def parse_completion_response(response)

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

@@ -8,7 +8,7 @@ module RubyLLM
         module_function
 
         def models_url
-          '/v1/models'
+          'v1/models'
         end
 
         def parse_list_models_response(response, slug, capabilities)

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

@@ -103,6 +103,26 @@ module RubyLLM
             'strict' => true
           }
         end
+
+        def build_tool_choice(tool_prefs)
+          tool_choice = tool_prefs[:choice]
+          calls_in_response = tool_prefs[:calls]
+          tool_choice = :auto if tool_choice.nil?
+
+          {
+            type: case tool_choice
+                  when :auto, :none
+                    tool_choice
+                  when :required
+                    :any
+                  else
+                    :tool
+                  end
+          }.tap do |tc|
+            tc[:name] = tool_choice if tc[:type] == :tool
+            tc[:disable_parallel_tool_use] = calls_in_response == :one if tc[:type] != :none && !calls_in_response.nil?
+          end
+        end
       end
     end
   end

data/lib/ruby_llm/providers/anthropic.rb

@@ -12,7 +12,7 @@ module RubyLLM
       include Anthropic::Tools
 
       def api_base
-        'https://api.anthropic.com'
+        @config.anthropic_api_base || 'https://api.anthropic.com'
       end
 
       def headers

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

@@ -6,7 +6,7 @@ module RubyLLM
       # Chat methods of the Azure AI Foundry API integration
       module Chat
         def completion_url
-          'models/chat/completions?api-version=2024-05-01-preview'
+          azure_endpoint(:chat)
         end
 
         def format_messages(messages)

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

@@ -8,7 +8,7 @@ module RubyLLM
         module_function
 
         def embedding_url(...)
-          'openai/v1/embeddings'
+          azure_endpoint(:embeddings)
         end
 
         def render_embedding_payload(text, model:, dimensions:)

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

@@ -6,7 +6,7 @@ module RubyLLM
       # Models methods of the Azure AI Foundry API integration
       module Models
         def models_url
-          'openai/v1/models?api-version=preview'
+          azure_endpoint(:models)
         end
       end
     end

data/lib/ruby_llm/providers/azure.rb

@@ -4,6 +4,9 @@ module RubyLLM
   module Providers
     # Azure AI Foundry / OpenAI-compatible API integration.
     class Azure < OpenAI
+      AZURE_DEFAULT_CHAT_API_VERSION = '2024-05-01-preview'
+      AZURE_DEFAULT_MODELS_API_VERSION = 'preview'
+
       include Azure::Chat
       include Azure::Embeddings
       include Azure::Media
@@ -25,6 +28,21 @@ module RubyLLM
         self.class.configured?(@config)
       end
 
+      def azure_endpoint(kind)
+        parts = azure_base_parts
+
+        case kind
+        when :chat
+          chat_endpoint(parts)
+        when :embeddings
+          embeddings_endpoint(parts)
+        when :models
+          models_endpoint(parts)
+        else
+          raise ArgumentError, "Unknown Azure endpoint kind: #{kind.inspect}"
+        end
+      end
+
       class << self
         def configuration_requirements
           %i[azure_api_base]
@@ -51,6 +69,76 @@ module RubyLLM
         raise ConfigurationError,
               "Missing configuration for Azure: #{missing.join(', ')}"
       end
+
+      private
+
+      def azure_base_parts
+        @azure_base_parts ||= begin
+          raw_base = api_base.to_s.sub(%r{/+\z}, '')
+          version = raw_base[/[?&]api-version=([^&]+)/i, 1]
+          path_base = raw_base.sub(/\?.*\z/, '')
+
+          mode = if path_base.include?('/chat/completions')
+                   :chat_endpoint
+                 elsif path_base.include?('/openai/deployments/')
+                   :deployment_base
+                 elsif path_base.include?('/openai/v1')
+                   :openai_v1_base
+                 else
+                   :resource_base
+                 end
+
+          {
+            raw_base: raw_base,
+            path_base: path_base,
+            root: azure_host_root(path_base),
+            mode: mode,
+            version: version
+          }
+        end
+      end
+
+      def chat_endpoint(parts)
+        case parts[:mode]
+        when :chat_endpoint
+          ''
+        when :deployment_base
+          with_api_version('chat/completions', parts[:version] || AZURE_DEFAULT_CHAT_API_VERSION)
+        when :openai_v1_base
+          with_api_version('chat/completions', parts[:version])
+        else
+          with_api_version('models/chat/completions', parts[:version] || AZURE_DEFAULT_CHAT_API_VERSION)
+        end
+      end
+
+      def embeddings_endpoint(parts)
+        case parts[:mode]
+        when :deployment_base, :openai_v1_base
+          with_api_version('embeddings', parts[:version])
+        else
+          "#{parts[:root]}/openai/v1/embeddings"
+        end
+      end
+
+      def models_endpoint(parts)
+        case parts[:mode]
+        when :openai_v1_base
+          with_api_version('models', parts[:version] || AZURE_DEFAULT_MODELS_API_VERSION)
+        else
+          "#{parts[:root]}/openai/v1/models?api-version=#{parts[:version] || AZURE_DEFAULT_MODELS_API_VERSION}"
+        end
+      end
+
+      def with_api_version(path, version)
+        return path unless version
+
+        separator = path.include?('?') ? '&' : '?'
+        "#{path}#{separator}api-version=#{version}"
+      end
+
+      def azure_host_root(base_without_query)
+        base_without_query.sub(%r{/(models|openai)/.*\z}, '').sub(%r{/+\z}, '')
+      end
     end
   end
 end

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

@@ -11,11 +11,13 @@ module RubyLLM
           "/model/#{@model.id}/converse"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false,
+                           schema: nil, thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
           @model = model
           @used_document_names = {}
           system_messages, chat_messages = messages.partition { |msg| msg.role == :system }
-
           payload = {
             messages: render_messages(chat_messages)
           }
@@ -25,7 +27,7 @@ module RubyLLM
 
           payload[:inferenceConfig] = render_inference_config(model, temperature)
 
-          tool_config = render_tool_config(tools)
+          tool_config = render_tool_config(tools, tool_prefs)
           if tool_config
             payload[:toolConfig] = tool_config
             payload[:tools] = tool_config[:tools] # Internal mirror for shared payload inspections in specs.
@@ -34,8 +36,12 @@ module RubyLLM
           additional_fields = render_additional_model_request_fields(thinking)
           payload[:additionalModelRequestFields] = additional_fields if additional_fields
 
+          output_config = build_output_config(schema)
+          payload[:outputConfig] = output_config if output_config
+
           payload
         end
+        # rubocop:enable Metrics/ParameterLists,Lint/UnusedMethodArgument
 
         def parse_completion_response(response)
           data = response.body
@@ -203,12 +209,31 @@ module RubyLLM
           config
         end
 
-        def render_tool_config(tools)
+        def render_tool_config(tools, tool_prefs)
           return nil if tools.empty?
 
-          {
+          config = {
             tools: tools.values.map { |tool| render_tool(tool) }
           }
+
+          return config if tool_prefs.nil? || tool_prefs[:choice].nil?
+
+          tool_choice = render_tool_choice(tool_prefs[:choice])
+          config[:toolChoice] = tool_choice if tool_choice
+          config
+        end
+
+        def render_tool_choice(choice)
+          case choice
+          when :auto
+            { auto: {} }
+          when :none
+            nil
+          when :required
+            { any: {} }
+          else
+            { tool: { name: choice.to_s } }
+          end
         end
 
         def render_tool(tool)
@@ -238,6 +263,26 @@ module RubyLLM
           fields.empty? ? nil : fields
         end
 
+        def build_output_config(schema)
+          return nil unless schema
+
+          cleaned = RubyLLM::Utils.deep_dup(schema[:schema])
+          cleaned.delete(:strict)
+          cleaned.delete('strict')
+
+          {
+            textFormat: {
+              type: 'json_schema',
+              structure: {
+                jsonSchema: {
+                  schema: JSON.generate(cleaned),
+                  name: schema[:name]
+                }
+              }
+            }
+          }
+        end
+
         def render_reasoning_fields(thinking)
           return nil unless thinking&.enabled?
 

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

@@ -7,7 +7,7 @@ module RubyLLM
       module Models
         module_function
 
-        REGION_PREFIXES = %w[us eu ap sa ca me af il].freeze
+        REGION_PREFIXES = %w[global us eu ap sa ca me af il].freeze
 
         def models_api_base
           "https://bedrock.#{bedrock_region}.amazonaws.com"
@@ -100,10 +100,26 @@ module RubyLLM
           converse = model_data['converse'] || {}
           capabilities << 'function_calling' if converse.is_a?(Hash)
           capabilities << 'reasoning' if converse.dig('reasoningSupported', 'embedded')
+          capabilities << 'structured_output' if supports_structured_output?(model_data['modelId'])
 
           capabilities
         end
 
+        # Structured output supported on Claude 4.5+ and assumed for future major versions.
+        # Bedrock IDs look like: us.anthropic.claude-haiku-4-5-20251001-v1:0
+        # Must handle optional region prefix (us./eu./global.) and anthropic. prefix.
+        def supports_structured_output?(model_id)
+          return false unless model_id
+
+          normalized = model_id.sub(/\A(?:#{REGION_PREFIXES.join('|')})\./, '').delete_prefix('anthropic.')
+          match = normalized.match(/claude-(?:opus|sonnet|haiku)-(\d+)-(\d{1,2})(?:\b|-)/)
+          return false unless match
+
+          major = match[1].to_i
+          minor = match[2].to_i
+          major > 4 || (major == 4 && minor >= 5)
+        end
+
         def reasoning_embedded?(model)
           metadata = RubyLLM::Utils.deep_symbolize_keys(model.metadata || {})
           converse = metadata[:converse] || {}

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

@@ -38,7 +38,7 @@ module RubyLLM
           end
 
           message = accumulator.to_message(response)
-          RubyLLM.logger.debug "Stream completed: #{message.content}"
+          RubyLLM.logger.debug { "Stream completed: #{message.content}" }
           message
         end
 
@@ -56,7 +56,7 @@ module RubyLLM
           error_response = env.merge(body: data)
           ErrorMiddleware.parse_error(provider: self, response: error_response)
         rescue JSON::ParserError
-          RubyLLM.logger.debug "Failed Bedrock stream error chunk: #{chunk}"
+          RubyLLM.logger.debug { "Failed Bedrock stream error chunk: #{chunk}" }
         end
 
         def parse_stream_chunk(decoder, raw_chunk, accumulator)
@@ -100,7 +100,11 @@ module RubyLLM
 
           while message
             event = decode_event_payload(message.payload.read)
-            RubyLLM.logger.debug("Bedrock stream event keys: #{event.keys}") if event && RubyLLM.config.log_stream_debug
+            if event && RubyLLM.config.log_stream_debug
+              RubyLLM.logger.debug do
+                "Bedrock stream event keys: #{event.keys}"
+              end
+            end
             events << event if event
             break if eof
 
@@ -119,7 +123,7 @@ module RubyLLM
             outer
           end
         rescue JSON::ParserError => e
-          RubyLLM.logger.debug "Failed to decode Bedrock stream event payload: #{e.message}"
+          RubyLLM.logger.debug { "Failed to decode Bedrock stream event payload: #{e.message}" }
           nil
         end
 

data/lib/ruby_llm/providers/bedrock.rb

@@ -18,12 +18,15 @@ module RubyLLM
         {}
       end
 
-      def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil, &) # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists
+      def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil,
+                   tool_prefs: nil, &)
         normalized_params = normalize_params(params, model:)
 
         super(
           messages,
           tools: tools,
+          tool_prefs: tool_prefs,
           temperature: temperature,
           model: model,
           params: normalized_params,
@@ -33,6 +36,7 @@ module RubyLLM
           &
         )
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def parse_error(response)
         return if response.body.nil? || response.body.empty?

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

@@ -41,6 +41,14 @@ module RubyLLM
           model_id.match?(/deepseek-chat/)
         end
 
+        def supports_tool_choice?(_model_id)
+          true
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          false
+        end
+
         def supports_json_mode?(_model_id)
           false
         end

data/lib/ruby_llm/providers/deepseek.rb

@@ -7,7 +7,7 @@ module RubyLLM
       include DeepSeek::Chat
 
       def api_base
-        'https://api.deepseek.com'
+        @config.deepseek_api_base || 'https://api.deepseek.com'
       end
 
       def headers

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

@@ -62,6 +62,14 @@ module RubyLLM
           model_id.match?(/gemini|pro|flash/)
         end
 
+        def supports_tool_choice?(_model_id)
+          true
+        end
+
+        def supports_tool_parallel_control?(_model_id)
+          false
+        end
+
         def supports_json_mode?(model_id)
           if model_id.match?(/text-embedding|embedding-001|aqa|imagen|gemini-2\.0-flash-lite|gemini-2\.5-pro-exp-03-25/)
             return false

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

@@ -14,7 +14,10 @@ module RubyLLM
           "models/#{@model}:generateContent"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil,
+                           thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
           @model = model.id
           payload = {
             contents: format_messages(messages),
@@ -26,9 +29,15 @@ module RubyLLM
           payload[:generationConfig].merge!(structured_output_config(schema, model)) if schema
           payload[:generationConfig][:thinkingConfig] = build_thinking_config(model, thinking) if thinking&.enabled?
 
-          payload[:tools] = format_tools(tools) if tools.any?
+          if tools.any?
+            payload[:tools] = format_tools(tools)
+            # Gemini doesn't support controlling parallel tool calls
+            payload[:toolConfig] = build_tool_config(tool_prefs[:choice]) unless tool_prefs[:choice].nil?
+          end
+
           payload
         end
+        # rubocop:enable Metrics/ParameterLists,Lint/UnusedMethodArgument
 
         def build_thinking_config(_model, thinking)
           config = { includeThoughts: true }
@@ -120,6 +129,9 @@ module RubyLLM
         def convert_schema_to_gemini(schema)
           return nil unless schema
 
+          # Extract inner schema if wrapper format (e.g., from RubyLLM::Schema.to_json_schema)
+          schema = schema[:schema] || schema
+
           GeminiSchema.new(schema).to_h
         end
 
@@ -132,7 +144,10 @@ module RubyLLM
           parts = candidate.dig('content', 'parts')
           return '' unless parts&.any?
 
-          build_response_content(parts)
+          non_thought_parts = parts.reject { |part| part['thought'] }
+          return '' unless non_thought_parts.any?
+
+          build_response_content(non_thought_parts)
         end
 
         def extract_text_parts(parts)
@@ -176,7 +191,7 @@ module RubyLLM
         end
 
         def build_json_schema(schema)
-          normalized = RubyLLM::Utils.deep_dup(schema)
+          normalized = RubyLLM::Utils.deep_dup(schema[:schema])
           normalized.delete(:strict)
           normalized.delete('strict')
           RubyLLM::Utils.deep_stringify_keys(normalized)

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

@@ -10,7 +10,7 @@ module RubyLLM
         end
 
         def render_image_payload(prompt, model:, size:)
-          RubyLLM.logger.debug "Ignoring size #{size}. Gemini does not support image size customization."
+          RubyLLM.logger.debug { "Ignoring size #{size}. Gemini does not support image size customization." }
           @model = model
           {
             instances: [

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

@@ -83,7 +83,7 @@ module RubyLLM
           error_data = JSON.parse(data)
           [error_data['error']['code'], error_data['error']['message']]
         rescue JSON::ParserError => e
-          RubyLLM.logger.debug "Failed to parse streaming error: #{e.message}"
+          RubyLLM.logger.debug { "Failed to parse streaming error: #{e.message}" }
           [500, "Failed to parse error: #{data}"]
         end
       end