activeagent 0.6.3 → 1.0.0

data/lib/active_agent/action_prompt/message.rb

@@ -1,126 +0,0 @@
-module ActiveAgent
-  module ActionPrompt
-    class Message
-      class << self
-        def from_messages(messages)
-          return messages if messages.empty? || messages.first.is_a?(Message)
-
-          messages.map do |message|
-            if message.is_a?(Hash)
-              new(message)
-            elsif message.is_a?(Message)
-              message
-            else
-              raise ArgumentError, "Messages must be Hash or Message objects"
-            end
-          end
-        end
-      end
-      VALID_ROLES = %w[system assistant user tool].freeze
-
-      attr_accessor :action_id, :action_name, :raw_actions, :generation_id, :content, :raw_content, :role, :action_requested, :requested_actions, :content_type, :charset, :metadata
-
-      def initialize(attributes = {})
-        @action_id = attributes[:action_id]
-        @action_name = attributes[:action_name]
-        @generation_id = attributes[:generation_id]
-        @metadata = attributes[:metadata] || {}
-        @charset = attributes[:charset] || "UTF-8"
-        @raw_content = attributes[:content] || ""
-        @content_type = detect_content_type(attributes)
-        @content = parse_content(@raw_content, @content_type)
-        @role = attributes[:role] || :user
-        @raw_actions = attributes[:raw_actions]
-        @requested_actions = attributes[:requested_actions] || []
-        @action_requested = @requested_actions.any?
-        validate_role
-      end
-
-      def to_s
-        @content.to_s
-      end
-
-      def to_h
-        hash = {
-          role: role,
-          action_id: action_id,
-          name: action_name,
-          generation_id: generation_id,
-          content: content,
-          type: content_type,
-          charset: charset
-        }
-
-        hash[:action_requested] = requested_actions.any?
-        hash[:requested_actions] = requested_actions if requested_actions.any?
-        hash
-      end
-
-      def embed
-        @agent_class.embed(@content)
-      end
-
-      def inspect
-        truncated_content = if @content.is_a?(String) && @content.length > 256
-          @content[0, 256] + "..."
-        elsif @content.is_a?(Array)
-          @content.map do |item|
-            if item.is_a?(String) && item.length > 256
-              item[0, 256] + "..."
-            else
-              item
-            end
-          end
-        else
-          @content
-        end
-
-        "#<#{self.class}:0x#{object_id.to_s(16)}\n" +
-        "    @action_id=#{@action_id.inspect},\n" +
-        "    @action_name=#{@action_name.inspect},\n" +
-        "    @action_requested=#{@action_requested.inspect},\n" +
-        "    @charset=#{@charset.inspect},\n" +
-        "    @content=#{truncated_content.inspect},\n" +
-        "    @role=#{@role.inspect}>"
-      end
-
-      private
-
-      def parse_content(content, content_type)
-        # Auto-parse JSON content if content_type indicates JSON
-        if content_type&.match?(/json/i) && content.is_a?(String) && !content.empty?
-          begin
-            JSON.parse(content)
-          rescue JSON::ParserError
-            # If parsing fails, return the raw content
-            content
-          end
-        else
-          content
-        end
-      end
-
-      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(", ")}"
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/action_prompt/prompt.rb

@@ -1,136 +0,0 @@
-require_relative "message"
-
-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, :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, "")
-        @body = attributes.fetch(:body, "")
-        @content_type = attributes.fetch(:content_type, "text/plain")
-        @message = attributes.fetch(:message, nil)
-        @messages = attributes.fetch(:messages, [])
-        @params = attributes.fetch(:params, {})
-        @mime_version = attributes.fetch(:mime_version, "1.0")
-        @charset = attributes.fetch(:charset, "UTF-8")
-        @context = attributes.fetch(:context, [])
-        @context_id = attributes.fetch(:context_id, nil)
-        @headers = attributes.fetch(:headers, {})
-        @parts = attributes.fetch(:parts, [])
-        @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
-        # Ensure we have a system message with instructions at the start
-        if @messages.empty? || @messages[0].role != :system
-          @messages.unshift(instructions_message)
-        elsif @instructions.present?
-          @messages[0] = instructions_message
-        end
-      end
-
-      def multimodal?
-        @multimodal ||= @message&.content.is_a?(Array) || @messages.any? { |m| m&.content.is_a?(Array) }
-      end
-
-      def messages=(messages)
-        @messages = messages
-        # Only add system message if we have instructions and don't already have a system message
-        if @instructions.present? && (@messages.empty? || @messages.first&.role != :system)
-          set_messages
-        end
-      end
-
-      def instructions=(instructions)
-        # Store the instructions even if blank (will use empty string)
-        @instructions = instructions || ""
-
-        # Update or add the system message
-        if @messages[0].present? && @messages[0].role == :system
-          @messages[0] = instructions_message
-        elsif @messages.empty? || @messages[0].role != :system
-          # Only add system message if we don't have one at the start
-          @messages.unshift(instructions_message)
-        end
-      end
-
-      # Generate the prompt as a string (for debugging or sending to the provider)
-      def to_s
-        @message.to_s
-      end
-
-      def add_part(message)
-        @message = message
-        set_message
-
-        @parts << message
-      end
-
-      def multipart?
-        @parts.any?
-      end
-
-      def to_h
-        {
-          actions: @actions,
-          action: @action_choice,
-          instructions: @instructions,
-          message: @message.to_h,
-          messages: @messages.map(&:to_h),
-          headers: @headers,
-          context: @context
-        }
-      end
-
-      def inspect
-        "#<#{self.class}:0x#{object_id.to_s(16)}\n" +
-          "  @options=#{ActiveAgent.sanitize_credentials(@options.inspect)}\n" +
-          "  @actions=#{@actions.inspect}\n" +
-          "  @action_choice=#{@action_choice.inspect}\n" +
-          "  @instructions=#{@instructions.inspect}\n" +
-          "  @message=#{@message.inspect}\n" +
-          "  @output_schema=#{@output_schema}\n" +
-          "  @headers=#{@headers.inspect}\n" +
-          "  @context=#{@context.inspect}\n" +
-          "  @messages=#{@messages.inspect}\n" +
-          ">"
-      end
-
-      def headers(headers = {})
-        @headers.merge!(headers)
-      end
-
-      private
-
-      def instructions_message
-        Message.new(content: @instructions, role: :system)
-      end
-
-      def set_messages
-        @messages = [ instructions_message ] + @messages
-        # if @message.nil? || @message.content.blank?
-        #   @message = @messages.last
-        # end
-      end
-
-      def set_message
-        if @message.is_a? String
-          @message = Message.new(content: @message, role: :user)
-        elsif @body.is_a?(String) && @message.content.blank?
-          @message = Message.new(content: @body, role: :user)
-        end
-
-        @messages = @messages + [ @message ]
-      end
-    end
-  end
-end

data/lib/active_agent/action_prompt.rb

@@ -1,19 +0,0 @@
-require "abstract_controller"
-require "active_support/core_ext/string/inflections"
-
-module ActiveAgent
-  module ActionPrompt
-    extend ::ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Collector
-      autoload :Message
-      autoload :Prompt
-      autoload :PromptHelper
-    end
-
-    autoload :Base
-
-    extend ActiveSupport::Concern
-  end
-end

data/lib/active_agent/callbacks.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    included do
-      include ActiveSupport::Callbacks
-      define_callbacks :generation, skip_after_callbacks_if_terminated: true
-      define_callbacks :embedding, skip_after_callbacks_if_terminated: true
-    end
-
-    module ClassMethods
-      # # Defines a callback that will get called right before/after/around the
-      # # generation provider method.
-      [ :before, :after, :around ].each do |callback|
-        define_method "#{callback}_generation" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:generation, callback, name, options)
-          end
-        end
-
-        # # Defines a callback that will get called right before/after/around the
-        # # embedding provider method.
-        define_method "#{callback}_embedding" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:embedding, callback, name, options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -1,163 +0,0 @@
-# lib/active_agent/generation_provider/anthropic_provider.rb
-
-begin
-  gem "ruby-anthropic", "~> 0.4.2"
-  require "anthropic"
-rescue LoadError
-  raise LoadError, "The 'ruby-anthropic ~> 0.4.2' gem is required for AnthropicProvider. Please add it to your Gemfile and run `bundle install`."
-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"]
-        @extra_headers = config["extra_headers"] || {}
-        @client = Anthropic::Client.new(access_token: @access_token, extra_headers: @extra_headers)
-      end
-
-      def generate(prompt)
-        @prompt = prompt
-
-        with_error_handling do
-          chat_prompt(parameters: prompt_parameters)
-        end
-      end
-
-      def chat_prompt(parameters: prompt_parameters)
-        if prompt.options[:stream] || config["stream"]
-          parameters[:stream] = provider_stream
-          @streaming_request_params = parameters
-        end
-
-        chat_response(@client.messages(parameters: parameters), parameters)
-      end
-
-      protected
-
-      # 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
-
-        if chunk[:type] == "message_stop"
-          finalize_stream(message, agent_stream)
-        end
-      end
-
-      # 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 = {
-          system: system_message&.content || @prompt.options[:instructions]
-        }
-
-        # Override messages to use filtered version
-        @filtered_messages = filtered_messages
-
-        params
-      end
-
-      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
-
-      # 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
-
-      # 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"
-        when "user" then "user"
-        when "assistant" then "assistant"
-        when "tool", "function" then "assistant"
-        else "user"
-        end
-      end
-
-      def chat_response(response, request_params = nil)
-        return @response if prompt.options[:stream]
-
-        content = response["content"].first["text"]
-
-        message = ActiveAgent::ActionPrompt::Message.new(
-          content: content,
-          content_type: prompt.output_schema.present? ? "application/json" : "text/plain",
-          role: "assistant",
-          action_requested: response["stop_reason"] == "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)
-
-        @response = ActiveAgent::GenerationProvider::Response.new(
-          prompt: prompt,
-          message: message,
-          raw_response: response,
-          raw_request: request_params
-        )
-      end
-
-      # Override from ToolManagement for Anthropic-specific tool parsing
-      def parse_tool_call(tool_use)
-        return nil unless tool_use
-
-        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,55 +0,0 @@
-# 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)
-        @response = ActiveAgent::GenerationProvider::Response.new(message:, raw_response: response)
-        raise NotImplementedError, "Subclasses must implement the 'handle_response' method"
-      end
-
-      def update_context(prompt:, message:, response:)
-        prompt.message = message
-        prompt.messages << message
-      end
-
-      protected
-
-      # 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
-end

data/lib/active_agent/generation_provider/base_adapter.rb

@@ -1,19 +0,0 @@
-module ActiveAgent
-  module GenerationProvider
-    class BaseAdapter
-      attr_reader :prompt
-
-      def initialize(prompt)
-        @prompt = prompt
-      end
-
-      def input
-        raise NotImplementedError, "Subclasses must implement the 'input' method"
-      end
-
-      def response
-        raise NotImplementedError, "Subclasses must implement the 'response' method"
-      end
-    end
-  end
-end