ruby_llm 1.12.0 → 1.14.1

data/lib/ruby_llm/models.rb

@@ -47,7 +47,8 @@ module RubyLLM
 
       def read_from_json(file = RubyLLM.config.model_registry_file)
         data = File.exist?(file) ? File.read(file) : '[]'
-        JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+        models = JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+        filter_models(models)
       rescue JSON::ParserError
         []
       end
@@ -232,7 +233,13 @@ module RubyLLM
           end
         end
 
-        models.sort_by { |m| [m.provider, m.id] }
+        filter_models(models).sort_by { |m| [m.provider, m.id] }
+      end
+
+      def filter_models(models)
+        models.reject do |model|
+          model.provider.to_s == 'vertexai' && model.id.to_s.include?('/')
+        end
       end
 
       def find_models_dev_model(key, models_dev_by_key)
@@ -266,8 +273,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 +319,15 @@ 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]]
+                       .find { |value| !value.to_s.strip.empty? }
+
         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 ? "#{created_date} 00:00:00 UTC" : nil,
           context_window: model_data.dig(:limit, :context),
           max_output_tokens: model_data.dig(:limit, :output),
           knowledge_cutoff: normalize_models_dev_knowledge(model_data[:knowledge]),
@@ -398,7 +408,7 @@ module RubyLLM
     end
 
     def initialize(models = nil)
-      @models = models || self.class.load_models
+      @models = self.class.filter_models(models || self.class.load_models)
     end
 
     def load_from_json!(file = RubyLLM.config.model_registry_file)

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
@@ -160,6 +164,10 @@ module RubyLLM
         []
       end
 
+      def configuration_options
+        []
+      end
+
       def local?
         false
       end
@@ -178,6 +186,7 @@ module RubyLLM
 
       def register(name, provider_class)
         providers[name.to_sym] = provider_class
+        RubyLLM::Configuration.register_provider_options(provider_class.configuration_options)
       end
 
       def resolve(name)

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

@@ -3,130 +3,16 @@
 module RubyLLM
   module Providers
     class Anthropic
-      # Determines capabilities and pricing for Anthropic models
+      # Provider-level capability checks used outside the model registry.
       module Capabilities
         module_function
 
-        def determine_context_window(_model_id)
-          200_000
+        def supports_tool_choice?(_model_id)
+          true
         end
 
-        def determine_max_tokens(model_id)
-          case model_id
-          when /claude-3-7-sonnet/, /claude-3-5/ then 8_192
-          else 4_096
-          end
-        end
-
-        def get_input_price(model_id)
-          PRICES.dig(model_family(model_id), :input) || default_input_price
-        end
-
-        def get_output_price(model_id)
-          PRICES.dig(model_family(model_id), :output) || default_output_price
-        end
-
-        def supports_vision?(model_id)
-          !model_id.match?(/claude-[12]/)
-        end
-
-        def supports_functions?(model_id)
-          model_id.match?(/claude-3/)
-        end
-
-        def supports_json_mode?(model_id)
-          model_id.match?(/claude-3/)
-        end
-
-        def supports_extended_thinking?(model_id)
-          model_id.match?(/claude-3-7-sonnet/)
-        end
-
-        def model_family(model_id)
-          case model_id
-          when /claude-3-7-sonnet/  then 'claude-3-7-sonnet'
-          when /claude-3-5-sonnet/  then 'claude-3-5-sonnet'
-          when /claude-3-5-haiku/   then 'claude-3-5-haiku'
-          when /claude-3-opus/      then 'claude-3-opus'
-          when /claude-3-sonnet/    then 'claude-3-sonnet'
-          when /claude-3-haiku/     then 'claude-3-haiku'
-          else 'claude-2'
-          end
-        end
-
-        def model_type(_)
-          'chat'
-        end
-
-        PRICES = {
-          'claude-3-7-sonnet': { input: 3.0, output: 15.0 },
-          'claude-3-5-sonnet': { input: 3.0, output: 15.0 },
-          'claude-3-5-haiku': { input: 0.80, output: 4.0 },
-          'claude-3-opus': { input: 15.0, output: 75.0 },
-          'claude-3-haiku': { input: 0.25, output: 1.25 },
-          'claude-2': { input: 3.0, output: 15.0 }
-        }.freeze
-
-        def default_input_price
-          3.0
-        end
-
-        def default_output_price
-          15.0
-        end
-
-        def modalities_for(model_id)
-          modalities = {
-            input: ['text'],
-            output: ['text']
-          }
-
-          unless model_id.match?(/claude-[12]/)
-            modalities[:input] << 'image'
-            modalities[:input] << 'pdf'
-          end
-
-          modalities
-        end
-
-        def capabilities_for(model_id)
-          capabilities = ['streaming']
-
-          if model_id.match?(/claude-3/)
-            capabilities << 'function_calling'
-            capabilities << 'batch'
-          end
-
-          capabilities << 'reasoning' if model_id.match?(/claude-3-7|-4/)
-          capabilities << 'citations' if model_id.match?(/claude-3\.5|claude-3-7/)
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = model_family(model_id)
-          prices = PRICES.fetch(family.to_sym, { input: default_input_price, output: default_output_price })
-
-          standard_pricing = {
-            input_per_million: prices[:input],
-            output_per_million: prices[:output]
-          }
-
-          batch_pricing = {
-            input_per_million: prices[:input] * 0.5,
-            output_per_million: prices[:output] * 0.5
-          }
-
-          if model_id.match?(/claude-3-7/)
-            standard_pricing[:reasoning_output_per_million] = prices[:output] * 2.5
-            batch_pricing[:reasoning_output_per_million] = prices[:output] * 1.25
-          end
-
-          {
-            text_tokens: {
-              standard: standard_pricing,
-              batch: batch_pricing
-            }
-          }
+        def supports_tool_parallel_control?(_model_id)
+          true
         end
       end
     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,24 +8,18 @@ module RubyLLM
         module_function
 
         def models_url
-          '/v1/models'
+          'v1/models'
         end
 
-        def parse_list_models_response(response, slug, capabilities)
+        def parse_list_models_response(response, slug, _capabilities)
           Array(response.body['data']).map do |model_data|
             model_id = model_data['id']
 
             Model::Info.new(
               id: model_id,
-              name: model_data['display_name'],
+              name: model_data['display_name'] || model_id,
               provider: slug,
-              family: capabilities.model_family(model_id),
               created_at: Time.parse(model_data['created_at']),
-              context_window: capabilities.determine_context_window(model_id),
-              max_output_tokens: capabilities.determine_max_tokens(model_id),
-              modalities: capabilities.modalities_for(model_id),
-              capabilities: capabilities.capabilities_for(model_id),
-              pricing: capabilities.pricing_for(model_id),
               metadata: {}
             )
           end

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
@@ -27,6 +27,10 @@ module RubyLLM
           Anthropic::Capabilities
         end
 
+        def configuration_options
+          %i[anthropic_api_key anthropic_api_base]
+        end
+
         def configuration_requirements
           %i[anthropic_api_key]
         end

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,7 +28,26 @@ 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_options
+          %i[azure_api_base azure_api_key azure_ai_auth_token]
+        end
+
         def configuration_requirements
           %i[azure_api_base]
         end
@@ -51,6 +73,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