activeagent 1.0.1 → 1.0.3

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-5-v1:0"
+    #
+    # @example Agent usage
+    #   class SummaryAgent < ApplicationAgent
+    #     generate_with :bedrock, model: "eu.anthropic.claude-sonnet-5-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

@@ -142,11 +142,15 @@ module ActiveAgent
                   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
-                  tool_info = "[Tool Use: #{block[:name]}]\nID: #{block[:id]}\nInput: #{JSON.pretty_generate(block[:input])}"
+                  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
-                  tool_info = "[MCP Tool Use: #{block[:name]}]\nID: #{block[:id]}\nServer: #{block[:server_name]}\nInput: #{JSON.pretty_generate(block[:input] || {})}"
+                  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

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/gemini/_types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "../open_ai/chat/_types"
+require_relative "../open_ai/embedding/_types"
+
+module ActiveAgent
+  module Providers
+    module Gemini
+      # Reuse OpenAI Chat request type (same API format)
+      RequestType = OpenAI::Chat::RequestType
+
+      # Reuse OpenAI Embedding types (same API format)
+      module Embedding
+        RequestType = OpenAI::Embedding::RequestType
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Gemini
+      # Configuration options for Gemini provider
+      #
+      # Extends OpenAI::Options with Gemini-specific settings including
+      # the default base URL for Gemini's OpenAI-compatible API endpoint.
+      #
+      # @example Basic configuration
+      #   options = Options.new(api_key: 'your-api-key')
+      #
+      # @example With environment variable
+      #   # Set GEMINI_API_KEY or GOOGLE_API_KEY
+      #   options = Options.new({})
+      #
+      # @see https://ai.google.dev/gemini-api/docs/openai
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+
+        attribute :base_url, :string, fallback: GEMINI_BASE_URL
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["GEMINI_API_KEY"] ||
+            ENV["GOOGLE_API_KEY"]
+        end
+
+        # Not used as part of Gemini
+        def resolve_organization_id(kwargs) = nil
+        def resolve_project_id(kwargs)      = nil
+      end
+    end
+  end
+end

data/lib/active_agent/providers/gemini_provider.rb

@@ -0,0 +1,94 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "gemini/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to Google's Gemini API via OpenAI-compatible endpoint.
+    #
+    # Extends OpenAI provider to work with Gemini's OpenAI-compatible API,
+    # enabling access to Gemini models through a familiar interface.
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://ai.google.dev/gemini-api/docs/openai
+    class GeminiProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "Gemini"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        namespace::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        namespace::RequestType.new
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.embed_request_type
+        namespace::Embedding::RequestType.new
+      end
+
+      protected
+
+      # Executes chat completion request with Gemini-specific error handling.
+      #
+      # @see OpenAI::ChatProvider#api_prompt_execute
+      # @param parameters [Hash]
+      # @return [Object, nil] response object or nil for streaming
+      # @raise [OpenAI::Errors::APIConnectionError] when Gemini API unreachable
+      def api_prompt_execute(parameters)
+        super
+
+      rescue ::OpenAI::Errors::APIConnectionError => exception
+        log_connection_error(exception)
+        raise exception
+      end
+
+      # Executes embedding request with Gemini-specific error handling.
+      #
+      # @param parameters [Hash]
+      # @return [Hash] symbolized API response
+      # @raise [OpenAI::Errors::APIConnectionError] when Gemini API unreachable
+      def api_embed_execute(parameters)
+        client.embeddings.create(**parameters).as_json.deep_symbolize_keys
+      rescue ::OpenAI::Errors::APIConnectionError => exception
+        log_connection_error(exception)
+        raise exception
+      end
+
+      # Merges streaming delta into the message with role cleanup.
+      #
+      # Overrides parent to handle Gemini's role copying behavior which duplicates
+      # the role field in every streaming chunk, requiring manual cleanup to prevent
+      # message corruption.
+      #
+      # @see OpenAI::ChatProvider#message_merge_delta
+      # @param message [Hash]
+      # @param delta [Hash]
+      # @return [Hash]
+      def message_merge_delta(message, delta)
+        message[:role] = delta.delete(:role) if delta[:role]
+
+        hash_merge_delta(message, delta)
+      end
+
+      # Logs connection failures with Gemini API details for debugging.
+      #
+      # @param error [Exception]
+      # @return [void]
+      def log_connection_error(error)
+        instrument("connection_error.provider.active_agent",
+                  uri_base: options.base_url,
+                  exception: error.class,
+                  message: error.message)
+      end
+    end
+  end
+end

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

@@ -22,16 +22,13 @@ module ActiveAgent
         attribute :stream, :boolean, default: false
         attribute :tools # Array of tool definitions
         attribute :tool_choice # Tool choice configuration
+        attribute :response_format
 
         # Common Format Compatibility
         def message=(value)
           self.messages ||= []
           self.messages << value
         end
-
-        def response_format
-          { type: "text" }
-        end
       end
     end
   end

data/lib/active_agent/providers/open_ai/chat/transforms.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/keys"
+require "uri"
 
 module ActiveAgent
   module Providers
@@ -124,10 +125,19 @@ module ActiveAgent
                     { type: "text", text: msg_hash[:text] },
                     { type: "image_url", image_url: { url: msg_hash[:image] } }
                   ]
+                elsif msg_hash.key?(:text) && msg_hash.key?(:document)
+                  # Shorthand with both text and document: { text: "...", document: "url" }
+                  [
+                    { type: "text", text: msg_hash[:text] },
+                    build_file_content(msg_hash[:document])
+                  ]
                 elsif msg_hash.key?(:image)
                   # Shorthand with only image: { image: "url" }
                   # Text comes from adjacent prompt arguments
                   [ { type: "image_url", image_url: { url: msg_hash[:image] } } ]
+                elsif msg_hash.key?(:document)
+                  # Shorthand with only document: { document: "url" }
+                  [ build_file_content(msg_hash[:document]) ]
                 elsif msg_hash.key?(:text)
                   # Shorthand: { text: "..." } or { role: "...", text: "..." }
                   msg_hash[:text]
@@ -137,13 +147,39 @@ module ActiveAgent
                 end
 
                 # Create appropriate message param based on role and content
-                extra_params = msg_hash.except(:role, :content, :text, :image)
+                extra_params = msg_hash.except(:role, :content, :text, :image, :document)
                 create_message_param(role, content, extra_params)
               else
                 raise ArgumentError, "Cannot normalize #{message.class} to message"
               end
             end
 
+            # Builds a file content block for the Chat API file type
+            #
+            # Handles both URL and data URI formats:
+            # - URL: "http://example.com/document.pdf" → { type: "file", file: { filename: "...", url: "..." } }
+            # - Data URI: "data:application/pdf;base64,..." → { type: "file", file: { filename: "...", file_data: "..." } }
+            #
+            # @param document [String] URL or data URI
+            # @return [Hash] file content block
+            def build_file_content(document)
+              if document.start_with?("data:")
+                # Data URI - extract or infer filename from media type
+                media_type = document.match(%r{\Adata:([^;,]+)})&.[](1) || "application/octet-stream"
+                extension = media_type.split("/").last&.gsub(/[^a-zA-Z0-9]/, "_") || "bin"
+                filename = "document.#{extension}"
+                { type: "file", file: { filename: filename, file_data: document } }
+              else
+                # Regular URL
+                filename = File.basename(URI.parse(document).path.to_s)
+                filename = "document.pdf" if filename.empty?
+                { type: "file", file: { filename: filename, url: document } }
+              end
+            rescue URI::Error
+              # Fallback for invalid URLs
+              { type: "file", file: { filename: "document.pdf", url: document } }
+            end
+
             # Creates the appropriate gem message param class for the given role
             #
             # @param role [String] message role (developer, system, user, assistant, tool, function)

data/lib/active_agent/providers/open_ai/chat_provider.rb

@@ -95,6 +95,8 @@ module ActiveAgent
         def process_stream_chunk(api_response_event)
           instrument("stream_chunk.active_agent")
 
+          broadcast_stream_open
+
           # Called Multiple Times: [Chunk<T>, T]<Content, ToolsCall>
           case api_response_event.type
           when :chunk
@@ -102,7 +104,7 @@ module ActiveAgent
 
             # If we have a delta, we need to update a message in the stack
             message = find_or_create_message(api_message.index)
-            message = message_merge_delta(message, api_message.delta.as_json.deep_symbolize_keys)
+            message_merge_delta(message, api_message.delta.deep_to_h)
 
             # Stream back content changes as they come in
             if api_message.delta.content
@@ -138,7 +140,7 @@ module ActiveAgent
         def process_function_calls(api_function_calls)
           api_function_calls.each do |api_function_call|
             content = instrument("tool_call.active_agent", tool_name: api_function_call.dig(:function, :name)) do
-              case api_function_call[:type]
+              case api_function_call[:type].to_s
               when "function"
                 process_tool_call_function(api_function_call[:function])
               else
@@ -243,7 +245,7 @@ module ActiveAgent
                 end
               end
             when String
-              hash[key] += value
+              hash[key] += value.to_s
             else
               hash[key] = value
             end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/chat/_types"
+require_relative "options"
+
+module ActiveAgent
+  module Providers
+    module Requesty
+      # ActiveModel type for casting and serializing Requesty requests.
+      #
+      # Requesty is OpenAI-compatible, so requests use the same shape as the
+      # OpenAI Chat API. This delegates entirely to OpenAI::Chat::RequestType.
+      RequestType = ActiveAgent::Providers::OpenAI::Chat::RequestType
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Requesty
+      # Configuration options for the Requesty provider.
+      #
+      # Extends OpenAI::Options, overriding the base URL to point at Requesty's
+      # OpenAI-compatible gateway and resolving the API key from REQUESTY_API_KEY.
+      # Requesty does not use organization or project identifiers.
+      #
+      # @example Basic configuration
+      #   options = Options.new(api_key: ENV["REQUESTY_API_KEY"])
+      #
+      # @see https://docs.requesty.ai
+      # @see https://app.requesty.ai/api-keys Requesty API Keys
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        # @!attribute base_url
+        #   @return [String] API endpoint (default: "https://router.requesty.ai/v1")
+        attribute :base_url, :string, as: "https://router.requesty.ai/v1"
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["REQUESTY_API_KEY"] ||
+            ENV["REQUESTY_ACCESS_TOKEN"]
+        end
+
+        # Not used as part of Requesty
+        def resolve_organization_id(kwargs) = nil
+        def resolve_project_id(kwargs)      = nil
+      end
+    end
+  end
+end

data/lib/active_agent/providers/requesty_provider.rb

@@ -0,0 +1,63 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "requesty/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to Requesty's OpenAI-compatible LLM gateway.
+    #
+    # Extends the OpenAI provider to work with Requesty's OpenAI-compatible API,
+    # enabling access to multiple AI models through a single interface using the
+    # +provider/model+ naming convention (e.g. +openai/gpt-4o-mini+).
+    #
+    # Requesty is a plain OpenAI-compatible gateway: requests, responses and
+    # transforms are identical to the OpenAI Chat API, so this provider reuses
+    # OpenAI::Chat::RequestType and OpenAI::Chat::Transforms directly. The only
+    # Requesty-specific configuration is the base URL and API key, which live in
+    # Requesty::Options.
+    #
+    # @example Configuration in active_agent.yml
+    #   requesty:
+    #     service: "Requesty"
+    #     api_key: <%= ENV["REQUESTY_API_KEY"] %>
+    #     model: "openai/gpt-4o-mini"
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://docs.requesty.ai
+    class RequestyProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "Requesty"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        Requesty::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
+
+      protected
+
+      # @see BaseProvider#api_response_normalize
+      # @param api_response [OpenAI::Models::ChatCompletion]
+      # @return [Hash] normalized response hash
+      def api_response_normalize(api_response)
+        return api_response unless api_response
+
+        OpenAI::Chat::Transforms.gem_to_hash(api_response)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "request"
+require_relative "embedding_request"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Type for Request model
+      class RequestType < ActiveModel::Type::Value
+        def cast(value)
+          case value
+          when Request
+            value
+          when Hash
+            Request.new(**value.deep_symbolize_keys)
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot cast #{value.class} to Request"
+          end
+        end
+
+        def serialize(value)
+          case value
+          when Request
+            value.serialize
+          when Hash
+            value
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot serialize #{value.class}"
+          end
+        end
+
+        def deserialize(value)
+          cast(value)
+        end
+      end
+
+      # Type for embedding requests
+      class EmbeddingRequestType < ActiveModel::Type::Value
+        def cast(value)
+          case value
+          when RubyLLM::EmbeddingRequest
+            value
+          when Hash
+            RubyLLM::EmbeddingRequest.new(**value.deep_symbolize_keys)
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot cast #{value.class} to EmbeddingRequest"
+          end
+        end
+
+        def serialize(value)
+          case value
+          when RubyLLM::EmbeddingRequest
+            value.serialize
+          when Hash
+            value
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot serialize #{value.class}"
+          end
+        end
+
+        def deserialize(value)
+          cast(value)
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/embedding_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Embedding request model for RubyLLM provider.
+      class EmbeddingRequest < Common::BaseModel
+        attribute :model, :string
+        attribute :input
+        attribute :dimensions, :integer
+      end
+    end
+  end
+end