activeagent 1.0.1 → 1.0.2

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_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

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

@@ -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