activeagent 0.5.1 → 0.6.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae6f20cf300442f42f9bc00eefea0b8b987dd7e3852e410c685b1f51ba5dcdc2
-  data.tar.gz: aaabea49a2e71c68c4b8a9b8769fd541b2fad12e1fc16d90aad2219cd0775522
+  metadata.gz: 01b5ef5633bece3cdce9d9dba58e499b48c57d80c3a461ceda58adbff738e36a
+  data.tar.gz: 9cc9065b10e9bbf0f8fdeba420fe7b9518b7e97f2d32e3bf11af55babd697009
 SHA512:
-  metadata.gz: 454f25de89fd2ba05d31e8a39304d0d6a25e6cf7ad3694464ee9013e0f946ca3794500a889d75e77da3d0c1433a084557caf70765b471eb3a6e9324ef78d8853
-  data.tar.gz: 72075033b38ac50b840e6d6a944922ae2402ab1fdb608f458b9e274883b1ff65286a7eec0530d0a4327c77bf2f1d01f3d471bc18ac986eaee7f9c1ad463816f7
+  metadata.gz: 6849b7f94803261d8049ed092aaa8176003b85d5353202aa1a96160860bb07dd98fc9171308c5ed4ea3c9644b6aa68cf09c9c5c827ec7a45300eb14b44e9f1e0
+  data.tar.gz: db67a92dd9f9344fd50234caae1641bb70d57ca61200bbea98a177a175c791de886ee3ac42bc807e0e824d95c94adb6e7765908fec3f50cfc4f73aeb66e21c4f

data/lib/active_agent/action_prompt/base.rb

@@ -199,9 +199,9 @@ module ActiveAgent
       # Add embedding capability to Message class
       ActiveAgent::ActionPrompt::Message.class_eval do
         def embed
-          agent_class = ActiveAgent::Base.descendants.first
+          agent_class = ApplicationAgent
           agent = agent_class.new
-          agent.context = ActiveAgent::ActionPrompt::Prompt.new(message: self)
+          agent.context = ActiveAgent::ActionPrompt::Prompt.new(message: self, agent_instance: agent)
           agent.embed
           self
         end
@@ -217,8 +217,18 @@ module ActiveAgent
 
       def handle_response(response)
         return response unless response.message.requested_actions.present?
+
+        # Perform the requested actions
         perform_actions(requested_actions: response.message.requested_actions)
-        update_context(response)
+
+        # Continue generation with updated context
+        continue_generation
+      end
+
+      def continue_generation
+        # Continue generating with the updated context that includes tool results
+        generation_provider.generate(context) if context && generation_provider
+        handle_response(generation_provider.response)
       end
 
       def update_context(response)
@@ -233,9 +243,12 @@ module ActiveAgent
 
       def perform_action(action)
         current_context = context.clone
-        # Set params from the action for controller access
+        # Merge action params with original params to preserve context
+        original_params = current_context.params || {}
         if action.params.is_a?(Hash)
-          self.params = action.params
+          self.params = original_params.merge(action.params)
+        else
+          self.params = original_params
         end
         process(action.name)
         context.message.role = :tool
@@ -250,7 +263,7 @@ module ActiveAgent
       def initialize # :nodoc:
         super
         @_prompt_was_called = false
-        @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options || {})
+        @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options || {}, agent_instance: self)
       end
 
       def process(method_name, *args) # :nodoc:
@@ -262,7 +275,7 @@ module ActiveAgent
 
         ActiveSupport::Notifications.instrument("process.active_agent", payload) do
           super
-          @_context = ActiveAgent::ActionPrompt::Prompt.new unless @_prompt_was_called
+          @_context = ActiveAgent::ActionPrompt::Prompt.new(agent_instance: self) unless @_prompt_was_called
         end
       end
       ruby2_keywords(:process)
@@ -317,11 +330,12 @@ module ActiveAgent
 
         headers = apply_defaults(headers)
         context.messages = headers[:messages] || []
+        context.mcp_servers = headers[:mcp_servers] || []
         context.context_id = headers[:context_id]
         context.params = params
         context.action_name = action_name
 
-        context.output_schema = load_schema(headers[:output_schema], set_prefixes(headers[:output_schema], lookup_context.prefixes))
+        context.output_schema = render_schema(headers[:output_schema], set_prefixes(headers[:output_schema], lookup_context.prefixes))
 
         context.charset = charset = headers[:charset]
 
@@ -350,7 +364,7 @@ module ActiveAgent
         prefixes = set_prefixes(action_name, lookup_context.prefixes)
 
         action_methods.map do |action|
-          load_schema(action, prefixes)
+          render_schema(action, prefixes)
         end.compact
       end
 
@@ -388,10 +402,14 @@ module ActiveAgent
         prefixes = lookup_context.prefixes | [ self.class.agent_name ]
       end
 
-      def load_schema(action_name, prefixes)
-        return unless lookup_context.template_exists?(action_name, prefixes, false, formats: [ :json ])
+      def render_schema(schema_or_action, prefixes)
+        # If it's already a hash (direct schema), return it
+        return schema_or_action if schema_or_action.is_a?(Hash)
+
+        # Otherwise try to load from template
+        return unless lookup_context.template_exists?(schema_or_action, prefixes, false, formats: [ :json ])
 
-        JSON.parse render_to_string(locals: { action_name: action_name }, action: action_name, formats: :json)
+        JSON.parse render_to_string(locals: { action_name: schema_or_action }, action: schema_or_action, formats: :json)
       end
 
       def merge_options(prompt_options)
@@ -403,7 +421,7 @@ module ActiveAgent
         # Extract runtime options from prompt_options (exclude instructions as it has special template logic)
         runtime_options = prompt_options.slice(
           :model, :temperature, :max_tokens, :stream, :top_p, :frequency_penalty,
-          :presence_penalty, :response_format, :seed, :stop, :tools_choice
+          :presence_penalty, :response_format, :seed, :stop, :tools_choice, :data_collection
         )
         # Handle explicit options parameter
         explicit_options = prompt_options[:options] || {}

data/lib/active_agent/action_prompt/prompt.rb

@@ -4,12 +4,13 @@ module ActiveAgent
   module ActionPrompt
     class Prompt
       attr_reader :messages, :instructions
-      attr_accessor :actions, :body, :content_type, :context_id, :message, :options, :mime_version, :charset, :context, :parts, :params, :action_choice, :agent_class, :output_schema, :action_name
+      attr_accessor :actions, :body, :content_type, :context_id, :message, :options, :mime_version, :charset, :context, :parts, :params, :action_choice, :agent_class, :output_schema, :action_name, :agent_instance, :mcp_servers
 
       def initialize(attributes = {})
         @options = attributes.fetch(:options, {})
         @multimodal = attributes.fetch(:multimodal, false)
         @agent_class = attributes.fetch(:agent_class, ApplicationAgent)
+        @agent_instance = attributes.fetch(:agent_instance, nil)
         @actions = attributes.fetch(:actions, [])
         @action_choice = attributes.fetch(:action_choice, "")
         @instructions = attributes.fetch(:instructions, "")
@@ -27,6 +28,7 @@ module ActiveAgent
         @output_schema = attributes.fetch(:output_schema, nil)
         @messages = Message.from_messages(@messages)
         @action_name = attributes.fetch(:action_name, nil)
+        @mcp_servers = attributes.fetch(:mcp_servers, [])
         set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message&.content
         set_messages if @instructions.present?
       end
@@ -81,7 +83,7 @@ module ActiveAgent
 
       def inspect
         "#<#{self.class}:0x#{object_id.to_s(16)}\n" +
-          "  @options=#{@options.inspect.gsub(Rails.application.credentials.dig(:openai, :api_key), '<OPENAI_API_KEY>')}\n" +
+          "  @options=#{ActiveAgent.sanitize_credentials(@options.inspect)}\n" +
           "  @actions=#{@actions.inspect}\n" +
           "  @action_choice=#{@action_choice.inspect}\n" +
           "  @instructions=#{@instructions.inspect}\n" +

data/lib/active_agent/base.rb

@@ -37,7 +37,8 @@ module ActiveAgent
           messages: params[:messages],
           message: params[:message],
           context_id: params[:context_id],
-          options: params[:options]
+          options: params[:options],
+          mcp_servers: params[:mcp_servers]
         }.merge(additional_options)
       )
     end

data/lib/active_agent/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  class Configuration
+    attr_accessor :verbose_generation_errors
+    attr_accessor :generation_retry_errors
+    attr_accessor :generation_max_retries
+    attr_accessor :generation_provider_logger
+
+    def initialize
+      @verbose_generation_errors = false
+      @generation_retry_errors = []
+      @generation_max_retries = 3
+      @generation_provider_logger = nil
+    end
+
+    def verbose_generation_errors?
+      @verbose_generation_errors
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration if block_given?
+      configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -10,23 +10,29 @@ end
 require "active_agent/action_prompt/action"
 require_relative "base"
 require_relative "response"
+require_relative "stream_processing"
+require_relative "message_formatting"
+require_relative "tool_management"
 
 module ActiveAgent
   module GenerationProvider
     class AnthropicProvider < Base
+      include StreamProcessing
+      include MessageFormatting
+      include ToolManagement
       def initialize(config)
         super
         @access_token ||= config["api_key"] || config["access_token"] || Anthropic.configuration.access_token || ENV["ANTHROPIC_ACCESS_TOKEN"]
-        @client = Anthropic::Client.new(access_token: @access_token)
+        @extra_headers = config["extra_headers"] || {}
+        @client = Anthropic::Client.new(access_token: @access_token, extra_headers: @extra_headers)
       end
 
       def generate(prompt)
         @prompt = prompt
 
-        chat_prompt(parameters: prompt_parameters)
-      rescue => e
-        error_message = e.respond_to?(:message) ? e.message : e.to_s
-        raise GenerationProviderError, error_message
+        with_error_handling do
+          chat_prompt(parameters: prompt_parameters)
+        end
       end
 
       def chat_prompt(parameters: prompt_parameters)
@@ -35,75 +41,75 @@ module ActiveAgent
         chat_response(@client.messages(parameters: parameters))
       end
 
-      private
+      protected
 
-      def provider_stream
-        agent_stream = prompt.options[:stream]
-        message = ActiveAgent::ActionPrompt::Message.new(content: "", role: :assistant)
-        @response = ActiveAgent::GenerationProvider::Response.new(prompt: prompt, message:)
+      # Override from StreamProcessing module for Anthropic-specific streaming
+      def process_stream_chunk(chunk, message, agent_stream)
+        if new_content = chunk.dig(:delta, :text)
+          message.content += new_content
+          agent_stream&.call(message, new_content, false, prompt.action_name)
+        end
 
-        proc do |chunk|
-          if new_content = chunk.dig(:delta, :text)
-            message.content += new_content
-            agent_stream.call(message, nil, false, prompt.action_name) if agent_stream.respond_to?(:call)
-          end
+        if chunk[:type] == "message_stop"
+          finalize_stream(message, agent_stream)
         end
       end
 
-      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions)
-        # fix for new Anthropic API that requires messages to be in a specific format without system role
-        messages = messages.reject { |m| m.role == :system }
+      # Override from ParameterBuilder to handle Anthropic-specific requirements
+      def build_provider_parameters
+        # Anthropic requires system message separately and no system role in messages
+        filtered_messages = @prompt.messages.reject { |m| m.role == :system }
+        system_message = @prompt.messages.find { |m| m.role == :system }
+
         params = {
-          model: model,
-          system: @prompt.options[:instructions],
-          messages: provider_messages(messages),
-          temperature: temperature,
-          max_tokens: @prompt.options[:max_tokens] || @config["max_tokens"] || 4096
+          system: system_message&.content || @prompt.options[:instructions]
         }
 
-        if tools&.present?
-          params[:tools] = format_tools(tools)
-        end
+        # Override messages to use filtered version
+        @filtered_messages = filtered_messages
 
         params
       end
 
-      def format_tools(tools)
-        tools.map do |tool|
-          {
-            name: tool["name"] || tool["function"]["name"],
-            description: tool["description"] || tool["function"]["description"],
-            input_schema: tool["parameters"]  || tool["function"]["parameters"]
-          }
+      def build_base_parameters
+        super.tap do |params|
+          # Use filtered messages if available (set by build_provider_parameters)
+          params[:messages] = provider_messages(@filtered_messages || @prompt.messages)
+          # Anthropic requires max_tokens
+          params[:max_tokens] ||= 4096
         end
       end
 
-      def provider_messages(messages)
-        messages.map do |message|
-          provider_message = {
-            role: convert_role(message.role),
-            content: []
-          }
+      # Override from ToolManagement for Anthropic-specific tool format
+      def format_single_tool(tool)
+        {
+          name: tool["name"] || tool.dig("function", "name") || tool[:name] || tool.dig(:function, :name),
+          description: tool["description"] || tool.dig("function", "description") || tool[:description] || tool.dig(:function, :description),
+          input_schema: tool["parameters"] || tool.dig("function", "parameters") || tool[:parameters] || tool.dig(:function, :parameters)
+        }
+      end
 
-          provider_message[:content] << if message.content_type == "image_url"
-            {
-              type: "image",
-              source: {
-                type: "url",
-                url: message.content
-              }
-            }
-          else
-            {
-              type: "text",
-              text: message.content
-            }
-          end
-
-          provider_message
+      # Override from MessageFormatting for Anthropic-specific message format
+      def format_content(message)
+        # Anthropic requires content as an array
+        if message.content_type == "image_url"
+          [ format_image_content(message).first ]
+        else
+          [ { type: "text", text: message.content } ]
         end
       end
 
+      def format_image_content(message)
+        [ {
+          type: "image",
+          source: {
+            type: "url",
+            url: message.content
+          }
+        } ]
+      end
+
+      # Override from MessageFormatting for Anthropic role mapping
       def convert_role(role)
         case role.to_s
         when "system" then "system"
@@ -123,7 +129,7 @@ module ActiveAgent
           content: content,
           role: "assistant",
           action_requested: response["stop_reason"] == "tool_use",
-          requested_actions: handle_actions(response["tool_use"])
+          requested_actions: handle_actions(response["content"].map { |c| c if c["type"] == "tool_use" }.reject { |m| m.blank? }.to_a),
         )
 
         update_context(prompt: prompt, message: message, response: response)
@@ -135,17 +141,18 @@ module ActiveAgent
         )
       end
 
-      def handle_actions(tool_uses)
-        return unless tool_uses&.present?
+      # Override from ToolManagement for Anthropic-specific tool parsing
+      def parse_tool_call(tool_use)
+        return nil unless tool_use
 
-        tool_uses.map do |tool_use|
-          ActiveAgent::ActionPrompt::Action.new(
-            id: tool_use[:id],
-            name: tool_use[:name],
-            params: tool_use[:input]
-          )
-        end
+        ActiveAgent::ActionPrompt::Action.new(
+          id: tool_use[:id],
+          name: tool_use[:name],
+          params: tool_use[:input]
+        )
       end
+
+      private
     end
   end
 end

data/lib/active_agent/generation_provider/base.rb

@@ -1,8 +1,14 @@
 # lib/active_agent/generation_provider/base.rb
 
+require_relative "error_handling"
+require_relative "parameter_builder"
+
 module ActiveAgent
   module GenerationProvider
     class Base
+      include ErrorHandling
+      include ParameterBuilder
+
       class GenerationProviderError < StandardError; end
       attr_reader :client, :config, :prompt, :response, :access_token, :model_name
 
@@ -10,12 +16,18 @@ module ActiveAgent
         @config = config
         @prompt = nil
         @response = nil
+        @model_name = config["model"] if config
       end
 
       def generate(prompt)
         raise NotImplementedError, "Subclasses must implement the 'generate' method"
       end
 
+      def embed(prompt)
+        # Optional embedding support - override in providers that support it
+        raise NotImplementedError, "#{self.class.name} does not support embeddings"
+      end
+
       private
 
       def handle_response(response)
@@ -30,11 +42,12 @@ module ActiveAgent
 
       protected
 
-      def prompt_parameters
-        {
-          messages: @prompt.messages,
-          temperature: @config["temperature"] || 0.7
-        }
+      # This method is now provided by ParameterBuilder module
+      # but can still be overridden if needed
+      def build_provider_parameters
+        # Base implementation returns empty hash
+        # Providers override this to add their specific parameters
+        {}
       end
     end
   end

data/lib/active_agent/generation_provider/error_handling.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    module ErrorHandling
+      extend ActiveSupport::Concern
+      include ActiveSupport::Rescuable
+
+      included do
+        class_attribute :retry_on_errors, default: []
+        class_attribute :max_retries, default: 3
+        class_attribute :verbose_errors_enabled, default: false
+
+        # Use rescue_from for provider-specific error handling
+        rescue_from StandardError, with: :handle_generation_error
+      end
+
+      def with_error_handling
+        retries = 0
+        begin
+          yield
+        rescue => e
+          if should_retry?(e) && retries < max_retries
+            retries += 1
+            log_retry(e, retries) if verbose_errors?
+            sleep(retry_delay(retries))
+            retry
+          else
+            # Use rescue_with_handler from Rescuable
+            rescue_with_handler(e) || raise
+          end
+        end
+      end
+
+      protected
+
+      def should_retry?(error)
+        return false if retry_on_errors.empty?
+        retry_on_errors.any? { |klass| error.is_a?(klass) }
+      end
+
+      def retry_delay(attempt)
+        # Exponential backoff: 1s, 2s, 4s...
+        2 ** (attempt - 1)
+      end
+
+      def handle_generation_error(error)
+        error_message = format_error_message(error)
+
+        # Create new error with original backtrace preserved
+        new_error = ActiveAgent::GenerationProvider::Base::GenerationProviderError.new(error_message)
+        new_error.set_backtrace(error.backtrace) if error.respond_to?(:backtrace)
+
+        # Log detailed error if verbose mode is enabled
+        log_error_details(error) if verbose_errors?
+
+        # Instrument the error for LogSubscriber
+        instrument_error(error, new_error)
+
+        raise new_error
+      end
+
+      def format_error_message(error)
+        message = if error.respond_to?(:message)
+          error.message
+        elsif error.respond_to?(:to_s)
+          error.to_s
+        else
+          "An unknown error occurred: #{error.class.name}"
+        end
+
+        # Include error class in verbose mode
+        if verbose_errors?
+          "[#{error.class.name}] #{message}"
+        else
+          message
+        end
+      end
+
+      def verbose_errors?
+        # Check multiple sources for verbose setting (in priority order)
+        # 1. Instance config (highest priority)
+        return true if @config&.dig("verbose_errors")
+
+        # 2. Class-level setting
+        return true if self.class.verbose_errors_enabled
+
+        # 3. ActiveAgent global configuration
+        if defined?(ActiveAgent) && ActiveAgent.respond_to?(:configuration)
+          return true if ActiveAgent.configuration.verbose_generation_errors?
+        end
+
+        # 4. Environment variable (lowest priority)
+        ENV["ACTIVE_AGENT_VERBOSE_ERRORS"] == "true"
+      end
+
+      def log_error_details(error)
+        logger = find_logger
+        return unless logger
+
+        logger.error "[ActiveAgent::GenerationProvider] Error: #{error.class.name}: #{error.message}"
+        if logger.respond_to?(:debug) && error.respond_to?(:backtrace)
+          logger.debug "Backtrace:\n  #{error.backtrace&.first(10)&.join("\n  ")}"
+        end
+      end
+
+      def log_retry(error, attempt)
+        logger = find_logger
+        return unless logger
+
+        message = "[ActiveAgent::GenerationProvider] Retry attempt #{attempt}/#{max_retries} after #{error.class.name}"
+        logger.info message
+      end
+
+      def find_logger
+        # Try multiple logger sources (in priority order)
+        # 1. Instance config
+        return @config["logger"] if @config&.dig("logger")
+
+        # 2. ActiveAgent configuration logger
+        if defined?(ActiveAgent) && ActiveAgent.respond_to?(:configuration)
+          config_logger = ActiveAgent.configuration.generation_provider_logger
+          return config_logger if config_logger
+        end
+
+        # 3. Rails logger
+        return Rails.logger if defined?(Rails) && Rails.logger
+
+        # 4. ActiveAgent::Base logger
+        return ActiveAgent::Base.logger if defined?(ActiveAgent::Base) && ActiveAgent::Base.respond_to?(:logger)
+
+        nil
+      end
+
+      def instrument_error(original_error, wrapped_error)
+        if defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.instrument("error.active_agent", {
+            error_class: original_error.class.name,
+            error_message: original_error.message,
+            wrapped_error: wrapped_error,
+            provider: self.class.name
+          })
+        end
+      end
+
+      module ClassMethods
+        def retry_on(*errors, max_attempts: 3, **options)
+          self.retry_on_errors = errors
+          self.max_retries = max_attempts
+
+          # Also register with rescue_from for more complex handling
+          errors.each do |error_class|
+            rescue_from error_class do |error|
+              # This will be caught by with_error_handling for retry logic
+              raise error
+            end
+          end
+        end
+
+        def enable_verbose_errors!
+          self.verbose_errors_enabled = true
+        end
+      end
+    end
+  end
+end