activeagent 0.5.0 → 0.6.0rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a16cb39db946881080e40bdf640106d6e3251cc7a80b8e77a036b7f815b9e9e3
-  data.tar.gz: e41d8b9560fc8dabe3caf5c79c67a094fe5d2196a810e30a5ed58c9428b9e158
+  metadata.gz: a9496edf8536e904969a006a14d65bd69c3257f4db22d80e859a977646a02513
+  data.tar.gz: 0b35eb065fe146ee027d72789826ea3af793e57140d8aefead79d73586548e6e
 SHA512:
-  metadata.gz: dc64e5b15aff61f1504a995c9cd79a9e62203b219c833fac56164ee2e127e6688363a3262b20786edf6ef70a34eff11f3fa9c89986e9428452a8a13ed2cbad28
-  data.tar.gz: 297263095bf29d165bc298edccf20bccd606bf5c8f64107b9bceca91f82eb53b2c31b3707b844830e8aea004402210f903707d106443b4e49b4222eb728a6ffe
+  metadata.gz: 65ce7639ce9106b99e827600b7582776413cdeb69b7de28cf7ed80e0e496ebc1be6ea613ab9f67e944bb7837344458d3709a2065eb2725fc9b7263c08146f08d
+  data.tar.gz: c702c8618b701979dee4871ab200e7fd60d5c09fc2670926a9f77e1c0975ab14e2a5e9b30df2eccce9276440f5e6baf396d16320aabff67a1fbbd332a88b5379

data/lib/active_agent/action_prompt/base.rb

@@ -104,7 +104,6 @@ module ActiveAgent
         # Define how the agent should generate content
         def generate_with(provider, **options)
           self.generation_provider = provider
-
           if options.has_key?(:instructions) || (self.options || {}).empty?
             # Either instructions explicitly provided, or no inherited options exist
             self.options = (self.options || {}).merge(options)
@@ -199,9 +198,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 +216,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,10 +242,15 @@ 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
         context.message.action_id = action.id
@@ -250,7 +264,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 +276,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 +331,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 +365,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
 
@@ -359,6 +374,10 @@ module ActiveAgent
         if headers[:message].present? && headers[:message].is_a?(ActiveAgent::ActionPrompt::Message)
           headers[:body] = headers[:message].content
           headers[:role] = headers[:message].role
+        elsif headers[:message].present? && headers[:message].is_a?(Array)
+          # Handle array of multipart content like [{type: "text", text: "..."}, {type: "file", file: {...}}]
+          headers[:body] = headers[:message]
+          headers[:role] = :user
         elsif headers[:message].present? && headers[:message].is_a?(String)
           headers[:body] = headers[:message]
           headers[:role] = :user
@@ -380,7 +399,6 @@ module ActiveAgent
             ActiveAgent::ActionPrompt::Message.new(content: headers[:body], content_type: "input_text")
           ]
         end
-
         headers
       end
 
@@ -388,10 +406,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 +425,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, :plugins
         )
         # Handle explicit options parameter
         explicit_options = prompt_options[:options] || {}

data/lib/active_agent/action_prompt/message.rb

@@ -27,7 +27,7 @@ module ActiveAgent
         @metadata = attributes[:metadata] || {}
         @charset = attributes[:charset] || "UTF-8"
         @content = attributes[:content] || ""
-        @content_type = attributes[:content_type] || "text/plain"
+        @content_type = detect_content_type(attributes)
         @role = attributes[:role] || :user
         @raw_actions = attributes[:raw_actions]
         @requested_actions = attributes[:requested_actions] || []
@@ -85,6 +85,22 @@ module ActiveAgent
 
       private
 
+      def detect_content_type(attributes)
+        # If content_type is explicitly provided, use it
+        return attributes[:content_type] if attributes[:content_type]
+
+        # If content is an array with multipart/mixed content, set appropriate type
+        if attributes[:content].is_a?(Array)
+          # Check if it contains multimodal content (text, image_url, file, etc.)
+          has_multimodal = attributes[:content].any? do |item|
+            item.is_a?(Hash) && (item[:type] || item["type"])
+          end
+          has_multimodal ? "multipart/mixed" : "array"
+        else
+          "text/plain"
+        end
+      end
+
       def validate_role
         unless VALID_ROLES.include?(role.to_s)
           raise ArgumentError, "Invalid role: #{role}. Valid roles are: #{VALID_ROLES.join(", ")}"

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,12 +28,13 @@ 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
 
       def multimodal?
-        @multimodal ||= @message&.content.is_a?(Array) || @messages.any? { |m| m.content.is_a?(Array) }
+        @multimodal ||= @message&.content.is_a?(Array) || @messages.any? { |m| m&.content.is_a?(Array) }
       end
 
       def messages=(messages)
@@ -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,21 +1,34 @@
 # 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
 
       def initialize(config)
         @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 +43,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