activeagent 1.0.0 → 1.0.2

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

data/lib/active_agent/providers/bedrock_provider.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "anthropic_provider"
+require_relative "bedrock/_types"
+
+module ActiveAgent
+  module Providers
+    # Provider for Anthropic models hosted on AWS Bedrock.
+    #
+    # Inherits all functionality from AnthropicProvider (streaming, tool use,
+    # multimodal, JSON format emulation) and overrides only the client
+    # construction to use Anthropic::BedrockClient for AWS authentication.
+    #
+    # @example Configuration in active_agent.yml
+    #   bedrock:
+    #     service: "Bedrock"
+    #     aws_region: "eu-west-2"
+    #     model: "eu.anthropic.claude-sonnet-4-5-20250929-v1:0"
+    #
+    # @example Agent usage
+    #   class SummaryAgent < ApplicationAgent
+    #     generate_with :bedrock, model: "eu.anthropic.claude-sonnet-4-5-20250929-v1:0"
+    #
+    #     def summarize
+    #       prompt(message: params[:message])
+    #     end
+    #   end
+    #
+    # @see AnthropicProvider
+    class BedrockProvider < AnthropicProvider
+      # @return [String]
+      def self.service_name
+        "Bedrock"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        Bedrock::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        Anthropic::RequestType.new
+      end
+
+      # Returns a configured Bedrock client.
+      #
+      # When a bearer token is available (via +aws_bearer_token+ option or
+      # +AWS_BEARER_TOKEN_BEDROCK+ env var), uses {Bedrock::BearerClient}
+      # which sends an +Authorization: Bearer+ header.
+      #
+      # Otherwise, falls back to {Anthropic::BedrockClient} which handles
+      # SigV4 signing, credential resolution, and Bedrock URL path rewriting.
+      #
+      # @return [Bedrock::BearerClient, Anthropic::Helpers::Bedrock::Client]
+      def client
+        @client ||= if options.aws_bearer_token.present?
+          Bedrock::BearerClient.new(
+            aws_region:          options.aws_region,
+            bearer_token:        options.aws_bearer_token,
+            base_url:            options.base_url.presence,
+            max_retries:         options.max_retries,
+            timeout:             options.timeout,
+            initial_retry_delay: options.initial_retry_delay,
+            max_retry_delay:     options.max_retry_delay
+          )
+        else
+          ::Anthropic::BedrockClient.new(
+            aws_region:          options.aws_region,
+            aws_access_key:      options.aws_access_key,
+            aws_secret_key:      options.aws_secret_key,
+            aws_session_token:   options.aws_session_token,
+            aws_profile:         options.aws_profile,
+            base_url:            options.base_url.presence,
+            max_retries:         options.max_retries,
+            timeout:             options.timeout,
+            initial_retry_delay: options.initial_retry_delay,
+            max_retry_delay:     options.max_retry_delay
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/common/messages/_types.rb

@@ -37,7 +37,7 @@ module ActiveAgent
                 role = hash[:role]&.to_s
 
                 case role
-                when "system"
+                when "system", "developer"
                   nil # System messages are dropped in common format, replaced by Instructions
                 when "user", nil
                   # Handle both standard format and format with `text` key
@@ -51,12 +51,6 @@ module ActiveAgent
                 when "assistant"
                   # Filter to only known attributes for Assistant
                   filtered_hash = hash.slice(:role, :content, :name)
-
-                  # Compress content array to string if needed (Anthropic format)
-                  if filtered_hash[:content].is_a?(Array)
-                    filtered_hash[:content] = compress_content_array(filtered_hash[:content])
-                  end
-
                   Common::Messages::Assistant.new(**filtered_hash)
                 when "tool"
                   # Filter to only known attributes for Tool
@@ -94,29 +88,6 @@ module ActiveAgent
                   raise ArgumentError, "Cannot serialize #{value.class}"
               end
             end
-
-            # Compresses Anthropic-style content array into a string.
-            #
-            # Anthropic messages can have content as an array of blocks like:
-            # [{type: "text", text: "..."}, {type: "tool_use", ...}]
-            # This extracts and joins text blocks into a single string.
-            #
-            # @param content_array [Array<Hash>]
-            # @return [String]
-            def compress_content_array(content_array)
-              content_array.map do |block|
-                case block[:type]&.to_s
-                when "text"
-                  block[:text]
-                when "tool_use"
-                  # Tool use blocks don't have readable text content
-                  nil
-                else
-                  # Unknown block type, try to extract text if present
-                  block[:text]
-                end
-              end.compact.join("\n")
-            end
           end
 
           # Type for Messages array
@@ -124,7 +95,9 @@ module ActiveAgent
             def cast(value)
               case value
               when Array
-                value.map { |v| message_type.cast(v) }.compact
+                messages = value.map { |v| message_type.cast(v) }.compact
+                # Split messages with array content into separate messages
+                messages.flat_map { |msg| split_content_blocks(msg) }
               when nil
                 []
               else
@@ -152,6 +125,44 @@ module ActiveAgent
             def message_type
               @message_type ||= MessageType.new
             end
+
+            # Splits an assistant message with array content into separate messages
+            # for each content block.
+            #
+            # @param message [Common::Messages::Base]
+            # @return [Array<Common::Messages::Base>]
+            def split_content_blocks(message)
+              # Only split assistant messages with array content
+              return [ message ] unless message.is_a?(Common::Messages::Assistant) && message.content.is_a?(Array)
+
+              message.content.map do |block|
+                case block[:type]&.to_s
+                when "text"
+                  # Create a message for text blocks
+                  Common::Messages::Assistant.new(role: "assistant", content: block[:text], name: message.name)
+                when "tool_use"
+                  # Create a message with tool use info as string representation
+                  input = block[:input]
+                  input_str = input.nil? || input.empty? ? "{}" : JSON.pretty_generate(input)
+                  tool_info = "[Tool Use: #{block[:name]}]\nID: #{block[:id]}\nInput: #{input_str}"
+                  Common::Messages::Assistant.new(role: "assistant", content: tool_info, name: message.name)
+                when "mcp_tool_use"
+                  # Create a message with MCP tool use info
+                  input = block[:input]
+                  input_str = input.nil? || input.empty? ? "{}" : JSON.pretty_generate(input)
+                  tool_info = "[MCP Tool Use: #{block[:name]}]\nID: #{block[:id]}\nServer: #{block[:server_name]}\nInput: #{input_str}"
+                  Common::Messages::Assistant.new(role: "assistant", content: tool_info, name: message.name)
+                when "mcp_tool_result"
+                  # Create a message with MCP tool result
+                  result_info = "[MCP Tool Result]\n#{block[:content]}"
+                  Common::Messages::Assistant.new(role: "assistant", content: result_info, name: message.name)
+                else
+                  # For unknown block types, try to extract text
+                  content = block[:text] || block.to_s
+                  Common::Messages::Assistant.new(role: "assistant", content:, name: message.name)
+                end
+              end.compact
+            end
           end
         end
       end

data/lib/active_agent/providers/common/messages/assistant.rb

@@ -9,7 +9,7 @@ module ActiveAgent
         # Represents messages sent by the AI assistant in a conversation.
         class Assistant < Base
           attribute :role, :string, as: "assistant"
-          attribute :content, :string
+          attribute :content # Accept both string and array (provider-native formats)
           attribute :name, :string
 
           validates :content, presence: true
@@ -24,9 +24,16 @@ module ActiveAgent
           # @param normalize_names [Symbol, nil] key normalization method (e.g., :underscore)
           # @return [Hash, Array, nil] parsed JSON structure or nil if parsing fails
           def parsed_json(symbolize_names: true, normalize_names: :underscore)
-            start_char       = [ content.index("{"),  content.index("[") ].compact.min
-            end_char         = [ content.rindex("}"), content.rindex("]") ].compact.max
-            content_stripped = content[start_char..end_char] if start_char && end_char
+            # Handle array content (from content blocks) by searching through each block
+            content_str = if content.is_a?(Array)
+              content.map { |block| block.is_a?(Hash) ? block[:text] : block.to_s }.join("\n")
+            else
+              content.to_s
+            end
+
+            start_char       = [ content_str.index("{"),  content_str.index("[") ].compact.min
+            end_char         = [ content_str.rindex("}"), content_str.rindex("]") ].compact.max
+            content_stripped = content_str[start_char..end_char] if start_char && end_char
             return unless content_stripped
 
             content_parsed = JSON.parse(content_stripped)
@@ -48,6 +55,15 @@ module ActiveAgent
             nil
           end
 
+          # Returns content as a string, handling both string and array formats
+          def text
+            if content.is_a?(Array)
+              content.map { |block| block.is_a?(Hash) ? block[:text] : block.to_s }.join("\n")
+            else
+              content.to_s
+            end
+          end
+
           alias_method :json_object, :parsed_json
           alias_method :parse_json,  :parsed_json
         end

data/lib/active_agent/providers/concerns/exception_handler.rb

@@ -55,6 +55,7 @@ module ActiveAgent
         yield
       rescue => exception
         rescue_with_handler(exception) || raise
+        nil # Discard handler return value to prevent polluting raw_response
       end
 
       # Bubbles up exceptions to the Agent's rescue_from if a handler is defined.

data/lib/active_agent/providers/concerns/previewable.rb

@@ -86,7 +86,13 @@ module ActiveAgent
         "### Message #{index} (#{role.capitalize})\n#{content}"
       end
 
-      # Renders available tools with descriptions and parameter schemas.
+      # Renders tools section for preview.
+      #
+      # Handles multiple tool formats:
+      # - Common format: {name: "...", description: "...", parameters: {...}}
+      # - Anthropic format: {name: "...", description: "...", input_schema: {...}}
+      # - Chat API format: {type: "function", function: {name: "...", description: "...", parameters: {...}}}
+      # - Responses API format: {type: "function", name: "...", description: "...", parameters: {...}}
       #
       # @param tools [Array<Hash>]
       # @return [String]
@@ -96,17 +102,45 @@ module ActiveAgent
         content = +"## Tools\n\n"
 
         tools.each_with_index do |tool, index|
-          content << "### #{tool[:name] || "Tool #{index + 1}"}\n"
-          content << "**Description:** #{tool[:description] || 'No description'}\n\n"
+          # Extract name and description from different formats
+          tool_name, tool_description, tool_params = extract_tool_details(tool)
+
+          content << "### #{tool_name || "Tool #{index + 1}"}\n"
+          content << "**Description:** #{tool_description || 'No description'}\n\n"
 
-          if tool[:parameters]
-            content << "**Parameters:**\n```json\n#{JSON.pretty_generate(tool[:parameters])}\n```\n\n"
+          if tool_params
+            content << "**Parameters:**\n```json\n#{JSON.pretty_generate(tool_params)}\n```\n\n"
           end
         end
 
         content.chomp
       end
 
+      # Extracts tool details from different formats.
+      #
+      # @param tool [Hash]
+      # @return [Array<String, String, Hash>] [name, description, parameters]
+      def extract_tool_details(tool)
+        tool_hash = tool.is_a?(Hash) ? tool : {}
+
+        # Chat API nested format: {type: "function", function: {...}}
+        if tool_hash[:type] == "function" && tool_hash[:function]
+          func = tool_hash[:function]
+          return [
+            func[:name],
+            func[:description],
+            func[:parameters] || func[:input_schema]
+          ]
+        end
+
+        # Flat formats (common, Anthropic, Responses)
+        [
+          tool_hash[:name],
+          tool_hash[:description],
+          tool_hash[:parameters] || tool_hash[:input_schema]
+        ]
+      end
+
       # Extracts text content from various message formats.
       #
       # Handles string messages, hash messages with :content key, and