ruby_llm 2.1.1 → 2.2.0

data/lib/ruby_llm/provider.rb

@@ -82,7 +82,7 @@ module RubyLLM
     # retrying a rate-limited request, or +nil+ when the response carries
     # no timing information. The retry middleware already honors the
     # standard <tt>Retry-After</tt> header; override this to read
-    # provider-specific rate-limit headers.
+    # provider-specific rate-limit headers or the error body.
     #
     #   def retry_delay(response)
     #     response.response_headers['x-acme-ratelimit-reset']&.to_f
@@ -111,6 +111,10 @@ module RubyLLM
       self.class.configuration_requirements
     end
 
+    def same_credentials?(other) # :nodoc:
+      settings == other.settings
+    end
+
     def original_image_detail? # :nodoc:
       false
     end
@@ -135,9 +139,10 @@ module RubyLLM
 
     def complete(messages, tools:, temperature:, model:, provider_options: {}, headers: {}, schema: nil, # :nodoc:
                  max_output_tokens: nil, thinking: nil, citations: false, caching: nil, tool_prefs: nil,
-                 protocol: nil, before_request: [], usage_recorder: nil, provider_tools: [],
-                 compaction: nil, end_user: nil, &)
-      protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:)
+                 protocol: nil, before_request: [], usage_recorder: nil, progress_recorder: nil,
+                 provider_tools: [], compaction: nil, end_user: nil, &)
+      protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:,
+                                                         provider_tools:, messages:)
       protocol_class.new(self, model).complete(
         messages,
         tools: tools,
@@ -155,12 +160,21 @@ module RubyLLM
         end_user: end_user,
         before_request: before_request,
         usage_recorder: usage_recorder,
+        progress_recorder: progress_recorder,
         &
       )
     end
 
-    def tool_approval_response(tool_call, approved:, model:, protocol: nil) # :nodoc:
-      resolve_protocol(protocol, model).new(self, model).tool_approval_response(tool_call, approved:)
+    def tool_search?(model, protocol: nil) # :nodoc:
+      preprocessing_protocol(protocol, model).tool_search?
+    end
+
+    def skipped_tool_call_error(tool_call, model:, protocol: nil) # :nodoc:
+      resolve_protocol(protocol, model).new(self, model).skipped_tool_call_error(tool_call)
+    end
+
+    def tool_approval_response(tool_call, approved:, model:, protocol: nil, note: nil) # :nodoc:
+      resolve_protocol(protocol, model).new(self, model).tool_approval_response(tool_call, approved:, note:)
     end
 
     def compact(messages, model:, protocol: nil, headers: {}, before_request: [], usage_recorder: nil) # :nodoc:
@@ -172,7 +186,8 @@ module RubyLLM
     def render(messages, tools:, temperature:, model:, provider_options: {}, schema: nil, thinking: nil, # :nodoc:
                max_output_tokens: nil, citations: false, caching: nil, tool_prefs: nil, protocol: nil,
                before_request: [], provider_tools: [], compaction: nil, end_user: nil)
-      protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:)
+      protocol_class = resolve_protocol(protocol, model, tools:, schema:, thinking:, tool_prefs:, citations:,
+                                                         provider_tools:, messages:)
       protocol_class.new(self, model).render(
         messages,
         tools: tools,
@@ -205,6 +220,14 @@ module RubyLLM
       )
     end
 
+    def fallback_caching(caching, model:, protocol: nil) # :nodoc:
+      preprocessing_protocol(protocol, model).fallback_caching(caching)
+    end
+
+    def cache_key?(model:, protocol: nil) # :nodoc:
+      preprocessing_protocol(protocol, model).cache_key?
+    end
+
     def preprocess_messages(messages, model:, protocol: nil, unsupported_attachment: nil) # :nodoc:
       preprocessor = preprocessing_protocol(protocol, model)
       messages.map { |message| preprocessor.preprocess_message(message, unsupported_attachment:) }
@@ -251,7 +274,7 @@ module RubyLLM
 
     def batch_cost(tokens, model:, category: :text_tokens) # :nodoc:
       standard = Cost.new(tokens:, model:, category:)
-      return standard if tokens.reported_cost
+      return standard if tokens.reported_cost || model.nil?
 
       pricing = model.pricing.public_send(category)
       batch_tier = pricing.batch unless long_context_pricing?(pricing, tokens)
@@ -320,10 +343,9 @@ module RubyLLM
     end
 
     def embed(text, model:, dimensions:, task_type: nil, title: nil, with: nil, provider_options: {}) # :nodoc:
-      protocol = resolve_protocol(nil, model, operation: :embed)
-      protocol.new(self, model).embed(
-        text, model: model_id_for(model), dimensions:, task_type:, title:, with:, provider_options:
-      )
+      protocol = resolve_protocol(nil, model, operation: :embed).new(self, model)
+      protocol.reject_options(:embed, task_type:, title:)
+      protocol.embed(text, model: model_id_for(model), dimensions:, task_type:, title:, with:, provider_options:)
     end
 
     def render_embedding(text, model:, dimensions: nil) # :nodoc:
@@ -347,10 +369,9 @@ module RubyLLM
     end
 
     def paint(prompt, model:, size:, count: nil, with: nil, mask: nil, provider_options: {}) # :nodoc:
-      protocol = resolve_protocol(nil, model, operation: :paint)
-      protocol.new(self, model).paint(
-        prompt, model: model_id_for(model), size:, count:, with:, mask:, provider_options:
-      )
+      protocol = resolve_protocol(nil, model, operation: :paint).new(self, model)
+      protocol.reject_options(:paint, count: (count if count.to_i > 1))
+      protocol.paint(prompt, model: model_id_for(model), size:, count:, with:, mask:, provider_options:)
     end
 
     def animate_later(prompt, model:, with: nil, extend: nil, provider_options: {}) # :nodoc:
@@ -360,6 +381,11 @@ module RubyLLM
       )
     end
 
+    def find_video_job(id, model:) # :nodoc:
+      protocol = resolve_protocol(nil, model, operation: :animate)
+      protocol.new(self, model).find_video_job(id, model: model_id_for(model))
+    end
+
     def speak(input, model:, voice:, format:, provider_options: {}, &) # :nodoc:
       protocol = resolve_protocol(nil, model, operation: :speak)
       protocol.new(self, model).speak(
@@ -370,6 +396,8 @@ module RubyLLM
     def transcribe(audio_file, model:, language:, format: nil, timestamps: nil, speaker_names: nil, # :nodoc:
                    speaker_references: nil, provider_options: {}, prompt: nil, temperature: nil, &)
       protocol = resolve_protocol(nil, model, operation: :transcribe).new(self, model)
+      protocol.reject_options(:transcribe, format:, temperature:, prompt:, speaker_names:, speaker_references:,
+                                           named_speakers: (speaker_names unless Array(speaker_names).empty?))
       options = protocol.render_transcription_options(timestamps:, format:, streaming: block_given?)
       provider_options = Support::Utils.deep_merge(options, provider_options)
       protocol.transcribe(
@@ -406,7 +434,9 @@ module RubyLLM
       ensure_files_supported!
       options = { filename:, purpose:, expires_in:, uri:, content_type:, provider_options: }.compact
 
-      protocols.fetch(:files).new(self).upload(file, **options)
+      protocol = protocols.fetch(:files).new(self)
+      protocol.reject_options(:upload, purpose:, expires_in:, uri:)
+      protocol.upload(file, **options)
     end
 
     def cache_content(content, model:, ttl: nil, instructions: nil, with: nil) # :nodoc:
@@ -443,6 +473,10 @@ module RubyLLM
       protocols.fetch(:files).new(self).list_uris(uri)
     end
 
+    def settings # :nodoc:
+      self.class.configuration_options.map { |option| config.public_send(option) }
+    end
+
     def configured? # :nodoc:
       self.class.configured?(@config)
     end
@@ -470,6 +504,28 @@ module RubyLLM
       end
     end
 
+    # Returns the status a response sent as a success really means, for a
+    # provider that reports failures in a 2xx body, or +nil+.
+    def error_status(_response) # :nodoc:
+      nil
+    end
+
+    # Returns the provider's code for an error +response+, such as
+    # <tt>"invalid_request_error"</tt>, from the body's +code+, +status+,
+    # or +type+ under +error+, or its +code+ or +type+, or +nil+. Override
+    # when the provider names its errors elsewhere.
+    def parse_error_code(response) # :nodoc:
+      body = parse_error_body(response)
+      body = body.find { |part| part.is_a?(Hash) } if body.is_a?(Array)
+      return unless body.is_a?(Hash)
+
+      error = body['error']
+      candidates = error.is_a?(Hash) ? error.values_at('code', 'status', 'type') : []
+      candidates << body['code']
+      candidates << body['type'] unless body['type'] == 'error'
+      candidates.find { |candidate| candidate.is_a?(String) && candidate.match?(Error::ERROR_CODE) }
+    end
+
     class << self
       attr_reader :default_protocol # :nodoc:
       attr_writer :slug # :nodoc:
@@ -517,6 +573,18 @@ module RubyLLM
         id
       end
 
+      # The models.dev provider ids whose catalogs list this provider's
+      # models. Empty for a provider models.dev does not list.
+      def models_dev_provider_ids # :nodoc:
+        []
+      end
+
+      # The provider's +gen_ai.provider.name+ in the OpenTelemetry GenAI
+      # conventions. Providers the conventions name differently override this.
+      def open_telemetry_name # :nodoc:
+        slug
+      end
+
       # Returns the configuration keys that must be set before the
       # provider is usable. The base implementation returns an empty
       # array.
@@ -560,7 +628,7 @@ module RubyLLM
 
       # Returns whether +operation+ requires an inference model. Override
       # for endpoints that operate on an explicitly configured resource.
-      def model_required?(**)
+      def model_required?(**) # :nodoc:
         true
       end
 
@@ -584,6 +652,25 @@ module RubyLLM
         @protocols ||= {}
       end
 
+      # Returns the part of +message+ that holds its answer, as read by the
+      # first of the provider's protocols that marks parts of a turn as
+      # intermediate, or +nil+ when none does. Such a protocol defines
+      # +parse_answer_text(message)+ as a class method.
+      def answer_text(message) # :nodoc:
+        protocols.each_value.lazy.filter_map do |protocol|
+          protocol.parse_answer_text(message) if protocol.respond_to?(:parse_answer_text)
+        end.first
+      end
+
+      # Returns the pages hosted web searches used for +message+, as read by
+      # each of the provider's protocols that reports them. Such a protocol
+      # defines +parse_web_sources(message)+ as a class method.
+      def web_sources(message) # :nodoc:
+        protocols.each_value.flat_map do |protocol|
+          protocol.respond_to?(:parse_web_sources) ? protocol.parse_web_sources(message) : []
+        end
+      end
+
       # Registers +provider_class+ under the slug +name+, making it
       # available to RubyLLM.chat and the other top-level helpers.
       # Stamps the class's slug, adds it to ::providers, and defines a
@@ -613,14 +700,14 @@ module RubyLLM
       # Resolves +model_id+ to the id the registry stores it under for this
       # provider. Defaults to the id unchanged; providers whose catalog ids
       # differ from their request ids (Bedrock's region prefixes) override it.
-      def resolve_registry_id(model_id, _models, _config = nil)
+      def resolve_registry_id(model_id, _models, _config = nil) # :nodoc:
         model_id
       end
 
       # Returns the id of the model that the deployment named +model_id+
       # runs, or +nil+ when +model_id+ is not a declared deployment.
       # Providers whose requests name deployments override it.
-      def deployed_model_id(_model_id, _config = nil)
+      def deployed_model_id(_model_id, _config = nil) # :nodoc:
         nil
       end
 
@@ -634,14 +721,6 @@ module RubyLLM
         @model_registry_files ||= {}
       end
 
-      def local_providers # :nodoc:
-        providers.select { |_slug, provider_class| provider_class.local? }
-      end
-
-      def remote_providers # :nodoc:
-        providers.select { |_slug, provider_class| provider_class.remote? }
-      end
-
       def configured_providers(config) # :nodoc:
         providers.select do |_slug, provider_class|
           provider_class.configured?(config)
@@ -711,6 +790,11 @@ module RubyLLM
     end
 
     def fetch_protocol(name)
+      if protocols.empty?
+        raise Error, "#{self.class.display_name} has no protocols. A provider subclass does not inherit its " \
+                     'parent\'s protocols, so declare them with `protocol`.'
+      end
+
       protocols.fetch(name.to_sym) do
         raise Error, "#{name} is not a protocol of #{self.class.display_name}. Available: #{protocols.keys.join(', ')}"
       end
@@ -720,6 +804,19 @@ module RubyLLM
       model.respond_to?(:id) ? model.id : model
     end
 
+    # Returns the base URL +setting+ holds, or +default+, as given. Raises
+    # when it has no http(s) scheme or ends in one of the provider's
+    # +endpoints+, since RubyLLM adds those paths itself.
+    def configured_api_base(setting, default = nil, example: default, endpoints: nil)
+      value = @config.public_send(setting) || default
+      endpoint = value.to_s.sub(/[?#].*/, '').chomp('/')[endpoints] if endpoints
+      return value if value.to_s.match?(%r{\Ahttps?://[^/?#]}i) && !endpoint
+
+      raise ConfigurationError, "#{setting} should look like #{example}" \
+                                "#{endpoint ? " (without #{endpoint})" : ', starting with http:// or https://'}, " \
+                                "got #{value.inspect}"
+    end
+
     def account_digest(*parts)
       Digest::SHA256.hexdigest(parts.join("\0"))
     end
@@ -745,9 +842,9 @@ module RubyLLM
       error = part['error']
       return error if error.is_a?(String)
 
-      nested_message = error['message'] if error.is_a?(Hash)
-      [nested_message, part['message'], part['detail']].find { |message| message.is_a?(String) } ||
-        validation_detail_message(part['detail'])
+      detail = part['detail']
+      messages = [error, part, detail].filter_map { |source| source['message'] if source.is_a?(Hash) }
+      [*messages, detail].find { |message| message.is_a?(String) } || validation_detail_message(detail)
     end
 
     def validation_detail_message(detail)

data/lib/ruby_llm/providers/anthropic.rb

@@ -13,7 +13,7 @@ module RubyLLM
       protocol :files, Protocols::Anthropic::Files
 
       def api_base
-        @config.anthropic_api_base || 'https://api.anthropic.com'
+        configured_api_base(:anthropic_api_base, 'https://api.anthropic.com', endpoints: %r{/v1/messages\z})
       end
 
       def headers
@@ -30,6 +30,10 @@ module RubyLLM
       def batch_cost_multiplier(**) = 0.5
 
       class << self
+        def models_dev_provider_ids # :nodoc:
+          %w[anthropic]
+        end
+
         def capabilities
           Anthropic::Capabilities
         end

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

@@ -13,13 +13,27 @@ module RubyLLM
           Azure::Media.supported_attachment?(attachment)
         end
 
-        def format_content(content, attachments = [])
-          Media.format_content(content, attachments)
+        def render_content(content, attachments = [])
+          Media.render_content(content, attachments)
         end
 
-        def format_role(role)
+        def render_role(role)
           role.to_s
         end
+
+        private
+
+        # Grok on Azure reports cached tokens beside prompt_tokens, not inside
+        # them, so prompt_tokens is the uncached input.
+        def input_tokens(usage)
+          grok? ? usage['prompt_tokens'] : super
+        end
+
+        def grok?
+          return false unless @model
+
+          @model.family == 'grok' || @model.id.start_with?('grok')
+        end
       end
     end
   end

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

@@ -13,6 +13,7 @@ module RubyLLM
         include Azure::Videos
         include Azure::Images
         include Azure::Audio
+        include Azure::Moderation
 
         def azure_endpoint(kind)
           parts = azure_base_parts

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure < Provider
+      # Azure's dialect of OpenAI Decisions, served from the openai/v1 base.
+      # The model field carries the deployment name, as on Responses. The v1
+      # routes accept only the v1 and preview API versions, so the request
+      # names v1 over any dated version the configured base carries.
+      class Decisions < Protocols::OpenAI::Decisions
+        def judgment_url
+          "#{@provider.azure_openai_v1_base.sub(%r{/+\z}, '')}/decisions?api-version=v1"
+        end
+      end
+    end
+  end
+end

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

@@ -11,8 +11,7 @@ module RubyLLM
           azure_endpoint(:embeddings)
         end
 
-        # rubocop:disable-next Lint/UnusedMethodArgument
-        def render_embedding_payload(text, model:, dimensions:, task_type: nil, title: nil, provider_options: {})
+        def render_embedding_payload(text, model:, dimensions:, provider_options: {}, **)
           {
             model: model,
             input: [text].flatten,

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

@@ -11,23 +11,23 @@ module RubyLLM
           %i[image audio text].include?(attachment.type)
         end
 
-        def format_content(content, attachments = [])
-          Protocols::ChatCompletions::Media.format_parts(content, attachments) do |attachment|
+        def render_content(content, attachments = [])
+          Protocols::ChatCompletions::Media.render_parts(content, attachments) do |attachment|
             raise UnsupportedAttachmentError, attachment.mime_type unless supported_attachment?(attachment)
 
             case attachment.type
             when :image
-              Protocols::ChatCompletions::Media.with_image_detail(format_image(attachment), attachment,
+              Protocols::ChatCompletions::Media.with_image_detail(render_image(attachment), attachment,
                                                                   original_detail: true)
             when :audio
-              Protocols::ChatCompletions::Media.format_audio(attachment)
+              Protocols::ChatCompletions::Media.render_audio(attachment)
             when :text
-              Protocols::ChatCompletions::Media.format_text_file(attachment)
+              Protocols::ChatCompletions::Media.render_text_file(attachment)
             end
           end
         end
 
-        def format_image(image)
+        def render_image(image)
           {
             type: 'image_url',
             image_url: {

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure < Provider
+      # Azure's Chat Completions plus Mistral's document models on Foundry,
+      # which read Mistral's OCR request at a route under the resource root.
+      class Mistral < Azure::ChatCompletions
+        include Providers::Mistral::OCR
+
+        def ocr_url
+          "#{@provider.azure_base_parts[:root]}/providers/mistral/azure/ocr"
+        end
+      end
+    end
+  end
+end

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

@@ -10,12 +10,26 @@ module RubyLLM
         end
 
         # Azure reports the same id once per region it is offered in, and keeps
-        # returning models whose inference deprecation date has passed.
+        # returning models whose inference deprecation date has passed. The
+        # listing leaves out Azure AI Speech, so fast transcription is
+        # appended.
         def parse_list_models_response(response, slug)
           Array(response.body['data'])
             .uniq { |model_data| model_data['id'] }
             .reject { |model_data| azure_inference_retired?(model_data) }
-            .map { |model_data| azure_model(model_data, slug) }
+            .map { |model_data| azure_model(model_data, slug) } + [fast_transcription_model(slug)]
+        end
+
+        def fast_transcription_model(slug)
+          Model.new(
+            id: Azure::FAST_TRANSCRIPTION_MODEL,
+            name: 'Fast Transcription',
+            provider: slug,
+            family: 'azure-speech',
+            modalities: { input: ['audio'], output: ['text'] },
+            capabilities: ['transcription'],
+            pricing: {}
+          )
         end
 
         def azure_inference_retired?(model_data)

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Azure
+      # Foundry's REST reference lists /openai/v1/moderations, but resource
+      # and project endpoints answer it with the 404 of an unknown route and
+      # the catalog holds no moderation model.
+      module Moderation
+        def render_moderation_payload(*, **)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -11,12 +11,21 @@ module RubyLLM
         include Azure::Videos
         include Azure::Images
         include Azure::Audio
+        include Azure::Moderation
         include Protocols::Responses::Compaction
 
         def completion_url
           "#{@provider.azure_openai_v1_base}/responses"
         end
 
+        def document_urls?
+          true
+        end
+
+        def web_search_sources?
+          true
+        end
+
         def provider_file_upload_options(_attachment)
           { purpose: 'assistants' }
         end

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

@@ -13,7 +13,7 @@ module RubyLLM
           azure_video_url('video/generations/jobs')
         end
 
-        def render_video_payload(prompt, model:, with: [], provider_options: {}) # rubocop:disable Lint/UnusedMethodArgument
+        def render_video_payload(prompt, model:, provider_options: {}, **)
           { model: model, prompt: prompt }.merge(provider_options)
         end
 
@@ -33,7 +33,7 @@ module RubyLLM
           azure_video_url("video/generations/jobs/#{job.id}")
         end
 
-        def parse_video_job_status(response, job:) # rubocop:disable Lint/UnusedMethodArgument
+        def parse_video_job_status(response, **)
           body = response.body
           case body['status']
           when 'succeeded' then { status: :completed, raw: body }

data/lib/ruby_llm/providers/azure.rb

@@ -7,18 +7,30 @@ module RubyLLM
       DEFAULT_CHAT_API_VERSION = '2024-05-01-preview'
       DEFAULT_EMBEDDINGS_API_VERSION = '2024-05-01-preview'
       DEFAULT_MODELS_API_VERSION = 'preview'
+      SPEECH_API_VERSION = '2025-10-15'
+
+      # Azure AI Speech fast transcription. The endpoint takes no model, so
+      # RubyLLM names it after the API.
+      FAST_TRANSCRIPTION_MODEL = 'fast-transcription'
 
       protocol :chat_completions, Azure::ChatCompletions, batches: Azure::ChatCompletions::Batches
       protocol :responses, Azure::Responses
       protocol :files, Protocols::Azure::Files
       protocol :cohere, Azure::Cohere
+      protocol :mistral, Azure::Mistral
+      protocol :decisions, Azure::Decisions
+      protocol :speech, Protocols::Azure::Speech
 
       def original_image_detail? # :nodoc:
         true
       end
 
+      # A base ending in /models or /openai/v1/responses is the resource or
+      # its openai/v1 base, since RubyLLM adds those paths itself.
       def api_base
-        @config.azure_api_base
+        configured_api_base(:azure_api_base, example: 'https://RESOURCE.openai.azure.com')
+          .sub(%r{\A(https?://[^/?#]+)/models/?(?=\?|\z)}, '\\1')
+          .sub(%r{/openai/v1/responses/?(?=\?|\z)}, '/openai/v1')
       end
 
       # Files belong to the Azure resource, whichever key or Entra ID token
@@ -27,12 +39,19 @@ module RubyLLM
         account_digest(azure_openai_v1_base)
       end
 
+      def resolve_protocol(name, model, operation: nil, **options)
+        name ||= :decisions if operation == :judge
+        name ||= :speech if operation == :transcribe && model&.id == FAST_TRANSCRIPTION_MODEL
+        super
+      end
+
       # Deployments named after gpt-5.4+ and gpt-6+ models need the Responses
       # API for tool use, so they route there automatically. Deployment names often
       # differ from model ids, so the routing stays conservative; an explicit
       # protocol: or the azure_protocol configuration option overrides it.
       def protocol_for(model, operation: nil, **)
         return protocols[:cohere] if operation == :rerank
+        return protocols[:mistral] if operation == :ocr
         if operation == :embed &&
            %w[Cohere-embed-v3-english Cohere-embed-v3-multilingual embed-v-4-0].include?(model.id)
           return protocols[:cohere]
@@ -53,6 +72,21 @@ module RubyLLM
 
       def batch_cost_multiplier(**) = 0.5
 
+      # Azure AI Speech answers on the resource's own host, whichever of its
+      # endpoints the API base names.
+      def azure_speech_transcription_url # :nodoc:
+        uri = URI.parse(api_base)
+        uri.path = '/speechtotext/transcriptions:transcribe'
+        uri.query = "api-version=#{SPEECH_API_VERSION}"
+        uri.to_s
+      end
+
+      # Azure AI Speech takes a resource key in its own header. An Entra ID
+      # token is already sent as a bearer token.
+      def azure_speech_headers # :nodoc:
+        @config.azure_api_key ? { 'Ocp-Apim-Subscription-Key' => @config.azure_api_key } : {}
+      end
+
       def azure_cohere_url(operation) # :nodoc:
         base = azure_base_parts[:path_base]
         base = if base.include?('/providers/cohere')
@@ -113,6 +147,14 @@ module RubyLLM
       end
 
       class << self
+        def open_telemetry_name # :nodoc:
+          'azure.ai.openai'
+        end
+
+        def models_dev_provider_ids # :nodoc:
+          %w[azure]
+        end
+
         def capabilities
           Azure::Capabilities
         end

data/lib/ruby_llm/providers/bedrock/anthropic/batches.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Bedrock
+      class Anthropic
+        # Bedrock Model Invocation Jobs whose records are InvokeModel bodies
+        # in the Anthropic Messages format.
+        module Batches
+          include Protocols::Bedrock::Batches
+
+          private
+
+          def bedrock_invocation_type
+            'InvokeModel'
+          end
+
+          def validate_bedrock_batch_requests!(_requests); end
+
+          def bedrock_model_input(request)
+            payload = batch_payload(request)
+            render_invoke_body(payload, beta_headers(request[:headers].to_h, payload))
+          end
+
+          def parse_bedrock_model_output(body, model:)
+            parse_completion_body(body.merge('model' => model), raw: body)
+          end
+        end
+      end
+    end
+  end
+end