activeagent 1.0.1 → 1.0.3

data/lib/active_agent/providers/_base_provider.rb

@@ -9,7 +9,8 @@ require_relative "concerns/tool_choice_clearing"
 # @private
 GEM_LOADERS = {
   anthropic: [ "anthropic", "~> 1.12", "anthropic" ],
-  openai:    [ "openai",    "~> 0.34", "openai" ]
+  openai:    [ "openai",    "~> 0.34", "openai" ],
+  ruby_llm:  [ "ruby_llm",  ">= 1.0",  "ruby_llm" ]
 }
 
 # Requires a provider's gem dependency.

data/lib/active_agent/providers/anthropic/request.rb

@@ -71,7 +71,9 @@ module ActiveAgent
         # @raise [ArgumentError] when gem model validation fails
         def initialize(**params)
           # Step 1: Extract custom fields that gem doesn't support
-          @response_format = params.delete(:response_format)
+          # Read response_format without deleting - normalize_params will delete and convert it
+          # to output_config for json_schema, or drop it for other types.
+          @response_format = params[:response_format]
           @stream = params.delete(:stream)
           anthropic_beta = params.delete(:anthropic_beta)
 

data/lib/active_agent/providers/anthropic/transforms.rb

@@ -31,6 +31,12 @@ module ActiveAgent
             params[:tools] = normalize_tools(params[:tools]) if params[:tools]
             params[:tool_choice] = normalize_tool_choice(params[:tool_choice]) if params[:tool_choice]
 
+            # Normalize json_schema response_format → output_config (Anthropic's native structured output field)
+            if params[:response_format]
+              output_config = normalize_response_format(params.delete(:response_format))
+              params[:output_config] = output_config if output_config
+            end
+
             # Handle mcps parameter (common format) -> transforms to mcp_servers (provider format)
             if params[:mcps]
               params[:mcp_servers] = normalize_mcp_servers(params.delete(:mcps))
@@ -159,6 +165,87 @@ module ActiveAgent
             end
           end
 
+          # Normalizes response_format to Anthropic output_config structure.
+          #
+          # Supported (ActiveAgent common format):
+          #   { type: "json_schema", json_schema: { name: "...", schema: {...}, strict: true } }
+          # → { format: { type: "json_schema", schema: {...} } }
+          #
+          # Notes:
+          # - Anthropic requires `additionalProperties: false` on all object schemas.
+          #   This is auto-injected into any object schemas that don't have it set.
+          # - Anthropic does not use OpenAI's `name` or `strict` fields in output_config.format.
+          # - json_object is not handled here; it remains prompt-emulated.
+          # - text is not handled here; Anthropic returns plain text by default.
+          #
+          # @param format [Hash, Symbol, String] ActiveAgent common response_format
+          # @return [Hash] Anthropic output_config hash, or nil if not applicable
+          def normalize_response_format(format)
+            case format
+            when Hash
+              format_hash = format.deep_symbolize_keys
+
+              if format_hash[:type].to_s == "json_schema"
+                schema = format_hash[:json_schema]&.dig(:schema)
+                if schema
+                  schema = inject_additional_properties(schema.deep_dup)
+                end
+                {
+                  format: {
+                    type: "json_schema",
+                    schema: schema
+                  }.compact
+                }
+              elsif format_hash[:type].to_s == "json_object"
+                # json_object is not handled here; it remains prompt-emulated.
+                nil
+              elsif format_hash[:type].to_s == "text"
+                # text is not handled here; it remains prompt-emulated.
+                nil
+              else
+                # Pass through (already properly structured or Anthropic native format)
+                format_hash
+              end
+            when Symbol, String
+              # Bare :json_schema without a schema cannot use native output_config.
+              # Anthropic requires a valid JSON Schema — return nil to fall back.
+              nil
+            else
+              format
+            end
+          end
+
+          # Recursively injects `additionalProperties: false` into all object schemas.
+          #
+          # Anthropic's structured output API requires this field on all object types.
+          # Only inserts when not already explicitly set by the user.
+          #
+          # @param schema [Hash] JSON Schema hash
+          # @return [Hash] schema with additionalProperties injected
+          def inject_additional_properties(schema)
+            return schema unless schema.is_a?(Hash)
+
+            if schema[:type] == "object" && !schema.key?(:additionalProperties)
+              schema[:additionalProperties] = false
+            end
+
+            # Recurse into nested schemas
+            schema[:properties]&.each_value { |prop| inject_additional_properties(prop) }
+            schema[:items]&.then { |items| inject_additional_properties(items) }
+            schema[:anyOf]&.each { |s| inject_additional_properties(s) }
+            schema[:oneOf]&.each { |s| inject_additional_properties(s) }
+            schema[:allOf]&.each { |s| inject_additional_properties(s) }
+
+            if schema[:definitions]
+              schema[:definitions].each_value { |defn| inject_additional_properties(defn) }
+            end
+            if schema[:"$defs"]
+              schema[:"$defs"].each_value { |defn| inject_additional_properties(defn) }
+            end
+
+            schema
+          end
+
           # Merges consecutive same-role messages into single messages with multiple content blocks.
           #
           # Required by Anthropic API - consecutive messages with the same role must be combined.
@@ -437,6 +524,7 @@ module ActiveAgent
                 msg.delete(:model)
                 msg.delete(:stop_reason)
                 msg.delete(:stop_sequence)
+                msg.delete(:stop_details)
                 msg.delete(:type)
                 msg.delete(:usage)
               end

data/lib/active_agent/providers/anthropic_provider.rb

@@ -189,9 +189,14 @@ module ActiveAgent
         when :ping
           # No-Op Keep Awake
         when :overloaded_error
-          # TODO: https://docs.claude.com/en/docs/build-with-claude/streaming#error-events
+        # TODO: https://docs.claude.com/en/docs/build-with-claude/streaming#error-events
+
+        # Higher-level convenience events from anthropic gem's MessageStream
+        when :text, :input_json, :citation, :thinking, :signature
+          # No-Op; Already handled via :content_block_delta
+
         else
-          # No-Op: Looks like internal tracking from gem wrapper
+          # No-Op; Internal tracking from gem wrapper
           return if api_response_chunk.respond_to?(:snapshot)
           raise "Unexpected chunk type: #{api_response_chunk.type}"
         end
@@ -296,11 +301,16 @@ module ActiveAgent
       def process_prompt_finished_extract_function_calls
         message_stack.pluck(:content).flatten.select { _1 in { type: "tool_use" } }.map do |api_function_call|
           json_buf = api_function_call.delete(:json_buf)
-          api_function_call[:input] = JSON.parse(json_buf, symbolize_names: true) if json_buf
+          api_function_call[:input] = JSON.parse(json_buf, symbolize_names: true) if json_buf.present?
 
           # Handle case where :input is still a JSON string (gem >= 1.14.0)
+          # For tools with no parameters, input may be an empty string
           if api_function_call[:input].is_a?(String)
-            api_function_call[:input] = JSON.parse(api_function_call[:input], symbolize_names: true)
+            if api_function_call[:input].present?
+              api_function_call[:input] = JSON.parse(api_function_call[:input], symbolize_names: true)
+            else
+              api_function_call[:input] = {}
+            end
           end
 
           api_function_call

data/lib/active_agent/providers/azure/_types.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "../open_ai/chat/_types"
+require_relative "../open_ai/embedding/_types"

data/lib/active_agent/providers/azure/options.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Azure
+      # Configuration options for Azure OpenAI Service.
+      #
+      # Azure OpenAI uses a different authentication and endpoint structure than standard OpenAI:
+      # - Endpoint: https://{resource}.openai.azure.com/openai/deployments/{deployment}/
+      # - Authentication: api-key header instead of Authorization: Bearer
+      # - API Version: Required query parameter
+      #
+      # You can configure Azure OpenAI in two ways:
+      #
+      # 1. Using azure_resource and deployment_id (standard Azure OpenAI):
+      #    @example
+      #      options = Azure::Options.new(
+      #        api_key: ENV["AZURE_OPENAI_API_KEY"],
+      #        azure_resource: "mycompany",
+      #        deployment_id: "gpt-4-deployment",
+      #        api_version: "2024-10-21"
+      #      )
+      #
+      # 2. Using a direct host/base_url (for custom domains or Azure AI Foundry):
+      #    @example
+      #      options = Azure::Options.new(
+      #        api_key: ENV["AZURE_OPENAI_API_KEY"],
+      #        host: "https://mycompany.cognitiveservices.azure.com/openai/deployments/gpt-4",
+      #        api_version: "2024-10-21"
+      #      )
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        DEFAULT_API_VERSION = "2024-10-21"
+
+        attribute :azure_resource, :string
+        attribute :deployment_id,  :string
+        attribute :api_version,    :string, fallback: DEFAULT_API_VERSION
+
+        validates :azure_resource, presence: true, unless: :explicit_host_provided?
+        validates :deployment_id, presence: true, unless: :explicit_host_provided?
+
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+          kwargs[:api_version] ||= resolve_api_version(kwargs)
+          # Store explicit host before super processes kwargs
+          # host is aliased to base_url in parent, so check both
+          @explicit_host = kwargs[:host] || kwargs[:base_url]
+          super(kwargs)
+        end
+
+        # Returns Azure-specific headers for authentication.
+        #
+        # Azure uses api-key header instead of Authorization: Bearer.
+        #
+        # @return [Hash] headers including api-key
+        def extra_headers
+          { "api-key" => api_key }
+        end
+
+        # Returns Azure-specific query parameters.
+        #
+        # Azure requires api-version as a query parameter.
+        #
+        # @return [Hash] query parameters including api-version
+        def extra_query
+          { "api-version" => api_version }
+        end
+
+        # Builds the base URL for Azure OpenAI API requests.
+        #
+        # If a direct host/base_url is provided, uses that directly.
+        # Otherwise, constructs the URL from azure_resource and deployment_id.
+        #
+        # @return [String] the Azure OpenAI endpoint URL
+        def base_url
+          if @explicit_host.present?
+            @explicit_host
+          elsif azure_resource.present? && deployment_id.present?
+            "https://#{azure_resource}.openai.azure.com/openai/deployments/#{deployment_id}"
+          else
+            raise ArgumentError, "Either host or azure_resource + deployment_id must be provided"
+          end
+        end
+
+        private
+
+        def explicit_host_provided?
+          @explicit_host.present?
+        end
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["AZURE_OPENAI_API_KEY"] ||
+            ENV["AZURE_OPENAI_ACCESS_TOKEN"]
+        end
+
+        def resolve_api_version(kwargs)
+          kwargs[:api_version] ||
+            ENV["AZURE_OPENAI_API_VERSION"] ||
+            DEFAULT_API_VERSION
+        end
+
+        # Not used as part of Azure OpenAI
+        def resolve_organization_id(_settings) = nil
+        def resolve_project_id(_settings)      = nil
+      end
+    end
+  end
+end

data/lib/active_agent/providers/azure_open_ai_provider.rb

@@ -0,0 +1,2 @@
+# Azure OpenAI, alias for AzureOpenAI service name resolution
+require_relative "azure_provider"

data/lib/active_agent/providers/azure_openai_provider.rb

@@ -0,0 +1,2 @@
+# Azure OpenAI, alias for :azure_openai provider reference
+require_relative "azure_provider"

data/lib/active_agent/providers/azure_provider.rb

@@ -0,0 +1,133 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "azure/_types"
+
+module ActiveAgent
+  module Providers
+    # Provider for Azure OpenAI Service via OpenAI-compatible API.
+    #
+    # Azure OpenAI uses the same API structure as OpenAI but with different
+    # authentication (api-key header) and endpoint configuration (resource + deployment).
+    #
+    # @example Configuration in active_agent.yml
+    #   azure_openai:
+    #     service: "AzureOpenAI"
+    #     api_key: <%= ENV["AZURE_OPENAI_API_KEY"] %>
+    #     azure_resource: "mycompany"
+    #     deployment_id: "gpt-4-deployment"
+    #     api_version: "2024-10-21"
+    #
+    # @see OpenAI::ChatProvider
+    class AzureProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "AzureOpenAI"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        Azure::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        OpenAI::Chat::RequestType.new
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.embed_request_type
+        OpenAI::Embedding::RequestType.new
+      end
+
+      # Returns a configured Azure OpenAI client.
+      #
+      # Uses a custom client subclass that handles Azure-specific authentication
+      # (api-key header instead of Authorization: Bearer).
+      #
+      # @return [AzureClient] the configured Azure client
+      def client
+        @client ||= AzureClient.new(
+          api_key: options.api_key,
+          base_url: options.base_url,
+          api_version: options.api_version,
+          max_retries: options.max_retries,
+          timeout: options.timeout,
+          initial_retry_delay: options.initial_retry_delay,
+          max_retry_delay: options.max_retry_delay
+        )
+      end
+
+      # Custom OpenAI client for Azure OpenAI Service.
+      #
+      # Azure uses different authentication headers (api-key instead of Authorization: Bearer)
+      # and requires api-version as a query parameter on all requests.
+      class AzureClient < ::OpenAI::Client
+        # @return [String]
+        attr_reader :api_version
+
+        # Creates a new Azure OpenAI client.
+        #
+        # @param api_key [String] Azure OpenAI API key
+        # @param base_url [String] Azure endpoint URL
+        # @param api_version [String] API version (e.g., "2024-10-21")
+        # @param max_retries [Integer] Maximum retry attempts
+        # @param timeout [Float] Request timeout in seconds
+        # @param initial_retry_delay [Float] Initial delay between retries
+        # @param max_retry_delay [Float] Maximum delay between retries
+        def initialize(
+          api_key:,
+          base_url:,
+          api_version:,
+          max_retries: self.class::DEFAULT_MAX_RETRIES,
+          timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+          initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+          max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+        )
+          @api_version = api_version
+
+          super(
+            api_key: api_key,
+            base_url: base_url,
+            max_retries: max_retries,
+            timeout: timeout,
+            initial_retry_delay: initial_retry_delay,
+            max_retry_delay: max_retry_delay
+          )
+        end
+
+        private
+
+        # Azure uses api-key header instead of Authorization: Bearer.
+        #
+        # @return [Hash{String=>String}]
+        def auth_headers
+          return {} if @api_key.nil?
+
+          { "api-key" => @api_key }
+        end
+
+        # Builds request with Azure-specific query parameters.
+        #
+        # Injects api-version into extra_query for all requests.
+        #
+        # @param req [Hash] Request parameters
+        # @param opts [Hash] Request options
+        # @return [Hash] Built request
+        def build_request(req, opts)
+          # Inject api-version into extra_query
+          opts = opts.dup
+          opts[:extra_query] = (opts[:extra_query] || {}).merge("api-version" => @api_version)
+
+          super(req, opts)
+        end
+      end
+    end
+
+    # Aliases for provider loading with different service name variations
+    AzureOpenAIProvider = AzureProvider
+    AzureOpenaiProvider = AzureProvider
+  end
+end

data/lib/active_agent/providers/azureopenai_provider.rb

@@ -0,0 +1,2 @@
+# Azure OpenAI, alternative naming for consistency with other provider aliases
+require_relative "azure_provider"

data/lib/active_agent/providers/bedrock/_types.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "bearer_client"
+require_relative "../anthropic/_types"
+
+# Bedrock uses the same request/response types as Anthropic.
+# The BedrockClient handles all protocol translation internally.

data/lib/active_agent/providers/bedrock/bearer_client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module Bedrock
+      # Client for AWS Bedrock using bearer token (API key) authentication.
+      #
+      # Subclasses Anthropic::Client directly to reuse its built-in bearer
+      # token support via the +auth_token+ parameter, while adding Bedrock-
+      # specific request transformations (URL path rewriting, anthropic_version
+      # injection) copied from Anthropic::BedrockClient.
+      #
+      # This avoids Anthropic::BedrockClient which requires SigV4 credentials
+      # and would fail when only a bearer token is available.
+      #
+      # @see https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-use.html
+      class BearerClient < ::Anthropic::Client
+        BEDROCK_VERSION = "bedrock-2023-05-31"
+
+        # @return [String]
+        attr_reader :aws_region
+
+        # @param aws_region [String] AWS region for the Bedrock endpoint
+        # @param bearer_token [String] AWS Bedrock API key (bearer token)
+        # @param base_url [String, nil] Override the default Bedrock endpoint
+        # @param max_retries [Integer]
+        # @param timeout [Float]
+        # @param initial_retry_delay [Float]
+        # @param max_retry_delay [Float]
+        def initialize(
+          aws_region:,
+          bearer_token:,
+          base_url: nil,
+          max_retries: self.class::DEFAULT_MAX_RETRIES,
+          timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
+          initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
+          max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+        )
+          @aws_region = aws_region
+
+          base_url ||= "https://bedrock-runtime.#{aws_region}.amazonaws.com"
+
+          super(
+            auth_token: bearer_token,
+            api_key: nil,
+            base_url: base_url,
+            max_retries: max_retries,
+            timeout: timeout,
+            initial_retry_delay: initial_retry_delay,
+            max_retry_delay: max_retry_delay
+          )
+
+          @messages = ::Anthropic::Resources::Messages.new(client: self)
+          @completions = ::Anthropic::Resources::Completions.new(client: self)
+          @beta = ::Anthropic::Resources::Beta.new(client: self)
+        end
+
+        private
+
+        # Intercepts request building to apply Bedrock-specific transformations
+        # before the parent class processes the request.
+        def build_request(req, opts)
+          fit_req_to_bedrock_specs!(req)
+          req = super
+          body = req.fetch(:body)
+          req[:body] = StringIO.new(body.to_a.join) if body.is_a?(Enumerator)
+          req
+        end
+
+        # Rewrites Anthropic API paths to Bedrock endpoint paths and injects
+        # the Bedrock anthropic_version field.
+        #
+        # Adapted from Anthropic::Helpers::Bedrock::Client#fit_req_to_bedrock_specs!
+        def fit_req_to_bedrock_specs!(request_components)
+          if (body = request_components[:body]).is_a?(Hash)
+            body[:anthropic_version] ||= BEDROCK_VERSION
+            body.transform_keys!("anthropic-beta": :anthropic_beta)
+          end
+
+          case request_components[:path]
+          in %r{^v1/messages/batches}
+            raise NotImplementedError, "The Batch API is not supported in Bedrock yet"
+          in %r{v1/messages/count_tokens}
+            raise NotImplementedError, "Token counting is not supported in Bedrock yet"
+          in %r{v1/models\?beta=true}
+            raise NotImplementedError,
+                  "Please instead use https://docs.anthropic.com/en/api/claude-on-amazon-bedrock#list-available-models " \
+                  "to list available models on Bedrock."
+          else
+          end
+
+          if %w[
+            v1/complete
+            v1/messages
+            v1/messages?beta=true
+          ].include?(request_components[:path]) && request_components[:method] == :post && body.is_a?(Hash)
+            model = body.delete(:model)
+            model = URI.encode_www_form_component(model.to_s)
+            stream = body.delete(:stream) || false
+            request_components[:path] =
+              stream ? "model/#{model}/invoke-with-response-stream" : "model/#{model}/invoke"
+          end
+
+          request_components
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/bedrock/options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Bedrock
+      # Configuration for AWS Bedrock provider.
+      #
+      # AWS credentials are resolved in order:
+      # 1. Explicit options (aws_access_key, aws_secret_key)
+      # 2. Environment variables (AWS_REGION, AWS_ACCESS_KEY_ID, etc.)
+      # 3. AWS SDK default chain (profiles, IAM roles, instance metadata)
+      #
+      # Unlike the Anthropic provider, no API key is needed — authentication
+      # is handled entirely through AWS credentials.
+      #
+      # @example Minimal config (uses SDK default chain)
+      #   Bedrock::Options.new(aws_region: "eu-west-2")
+      #
+      # @example Explicit credentials
+      #   Bedrock::Options.new(
+      #     aws_region: "eu-west-2",
+      #     aws_access_key: "AKIA...",
+      #     aws_secret_key: "..."
+      #   )
+      #
+      # @example With profile
+      #   Bedrock::Options.new(
+      #     aws_region: "eu-west-2",
+      #     aws_profile: "my-profile"
+      #   )
+      class Options < Common::BaseModel
+        attribute :aws_region,        :string
+        attribute :aws_access_key,    :string
+        attribute :aws_secret_key,    :string
+        attribute :aws_session_token, :string
+        attribute :aws_profile,       :string
+        attribute :aws_bearer_token,  :string
+        attribute :base_url,          :string
+        attribute :anthropic_beta,    :string
+
+        attribute :max_retries,         :integer, default: ::Anthropic::Client::DEFAULT_MAX_RETRIES
+        attribute :timeout,             :float,   default: ::Anthropic::Client::DEFAULT_TIMEOUT_IN_SECONDS
+        attribute :initial_retry_delay, :float,   default: ::Anthropic::Client::DEFAULT_INITIAL_RETRY_DELAY
+        attribute :max_retry_delay,     :float,   default: ::Anthropic::Client::DEFAULT_MAX_RETRY_DELAY
+
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+
+          super(**deep_compact(kwargs.except(:default_url_options).merge(
+            aws_region:        kwargs[:aws_region]        || ENV["AWS_REGION"] || ENV["AWS_DEFAULT_REGION"],
+            aws_access_key:    kwargs[:aws_access_key]    || ENV["AWS_ACCESS_KEY_ID"],
+            aws_secret_key:    kwargs[:aws_secret_key]    || ENV["AWS_SECRET_ACCESS_KEY"],
+            aws_session_token: kwargs[:aws_session_token] || ENV["AWS_SESSION_TOKEN"],
+            aws_profile:       kwargs[:aws_profile]       || ENV["AWS_PROFILE"],
+            aws_bearer_token:  kwargs[:aws_bearer_token]  || ENV["AWS_BEARER_TOKEN_BEDROCK"]
+          )))
+        end
+
+        # Bedrock handles authentication at the client level (SigV4 or bearer token),
+        # so no extra headers are needed in request options.
+        def extra_headers
+          {}
+        end
+
+        # Excludes sensitive AWS credentials from serialized output.
+        # The provider's client() method reads credentials directly from options attributes.
+        def serialize
+          attributes.symbolize_keys.except(
+            :aws_access_key, :aws_secret_key, :aws_session_token, :aws_profile, :aws_bearer_token
+          )
+        end
+      end
+    end
+  end
+end