activeagent 0.1.1 → 0.2.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67bb51f0a98d5b2291b53e30b629adae069a3f24e19edfc74702a918bc3c1086
-  data.tar.gz: 04cb6ba122dac00b145c3baf1f54157d5e443470639d16f22d614bfaaba92b49
+  metadata.gz: '08db8e070616e81109c24a4738d29cc5c7b2911a3b7584e90c23cd9a1072a20a'
+  data.tar.gz: 424e66ddfde6018b15b33d440764604db3cb3c1c3bef3f6cc0c0e765cad8d06e
 SHA512:
-  metadata.gz: 9835738ac1bb5570c900dd9a9942591a28c8b17b6ce26afbd622f764d5bb4ee178d0fc1089824a84d924824cc0c9a291680b1a1b1df5e41f5bfff1e91700a382
-  data.tar.gz: 78e3fd95e02a950cd2c47bf52891156d861f926374333efaeee51578fc0c96f65a94a123ec104cd0a5c32c9ea130ac85075a9904478191904936ea80381df714
+  metadata.gz: d6b7d4b86153dfea08db656c6b0620229902d371fd0afccbc4eca30e961875a4982339dfd4cdc77c2349d9ecf7e9085a98de07a406c73c15cf4a25ffc0fe3548
+  data.tar.gz: 4bb01d36f8610e25f0f0220f9b465779e15afa083786dfa8628def00b5a693a2804ff9665f967e484034ef30ea4312e2eafcc813aef1f66fb597ff7dd5bbbe49

data/lib/active_agent/action_prompt/README.md

@@ -1,44 +1,111 @@
 # Active Agent: Action Prompt
 
-ActionPrompt provides a structured way to create and manage prompts and tools for AI interactions. It includes several support classes to handle different aspects of prompt creation and management. The Base class implements an AbstractController to perform actions that render prompts..
+Action Prompt provides a structured way to create and manage prompts for AI interactions. It enables composing messages, handling actions/tools, and managing conversation context through several key components.
 
-## Main Components
+Action Prompt manages the overall prompt structure including:
 
-Module - for including in your agent classes to provide prompt functionality.
-Base class - for creating and managing prompts in ActiveAgent.
-Tool class - for representing the tool object sent to the Agent's generation provider.
-Message - class for representing a single message within a prompt.
-Prompt - class for representing a the context of a prompt, including messages, actions, and other attributes.
+- Messages list with system/user/assistant roles
+- Action/tool definitions
+- Headers and context tracking
+- Content type and encoding 
+- Multipart message handling
 
-### ActionPrompt::Base
-
-The base class is used to create and manage prompts in Active Agent. It provides the core functionality for creating and managing contexts woth prompts, tools, and messages.
-
-#### Core Methods
-`prompt` - Creates a new prompt object with the given attributes.
+```ruby
+prompt = ActionPrompt::Prompt.new(
+  instructions: "System guidance",
+  message: "User input",
+  actions: [tool_definition, action_schema],
+  context: messages
+)
+```
 
+## ActionPrompt::Message 
 
-### ActionPrompt::Tool
+Represents individual messages with:
 
-### ActionPrompt::Message
+### Content and Role
+```ruby
+message = ActionPrompt::Message.new(
+  content: "Search for a hotel",
+  role: :user
+)
+```
 
-Represents a single message within a prompt.
+- Content stores the actual message text
+- Role defines the message sender type (system/user/assistant/function/tool)
+- Messages form interactions between roles in a Context
 
-### ActionPrompt::Prompt
+### Action Requests and Responses
+```ruby
+message = ActionPrompt::Message.new(
+  content: "Search for a hotel",
+  role: :tool,
+  requested_actions: [{name: "search", params: {query: "hotel"}}]
+)
+```
+
+- Tracks if message requests actions/tools
+- Maintains list of requested_actions
+- Action responses include function call results
+- Handles tool execution state
+
+### Content Type and Encoding
+- Default content_type is "text/plain"
+- Supports multiple content types for rich messages
+- Default charset is UTF-8
+- Handles content encoding/decoding
+
+### Role Validation
+- Enforces valid roles via VALID_ROLES constant
+- Validates on message creation
+- Raises ArgumentError for invalid roles
+- Supported roles: system, assistant, user, tool, function
 
-Manages the overall structure of a prompt, including multiple messages, actions, and other attributes.
+```ruby
+message = ActionPrompt::Message.new(
+  content: "Hello",
+  role: :user,
+  content_type: "text/plain",
+  charset: "UTF-8"
+)
+```
 
 ### ActionPrompt::Action
 
-Represents an action that represents the tool object sent to the Agent's generation provider can be associated with a prompt or message.
+Defines callable tools/functions:
 
-## Usage
+- Name and parameters schema
+- Validation and type checking
+- Response handling
+- Action execution
 
-To use ActionPrompt in your agent, include the module in your agent class:
+## Usage with Base Agents
 
 ```ruby
-class MyAgent
-  include ActiveAgent::ActionPrompt
-  
-  # Your agent code here
+class MyAgent < ActiveAgent::Base
+  # Define available actions
+  def action_schemas
+    [
+      {name: "search", params: {query: :string}}
+    ]
+  end
+
+  # Handle action responses
+  def perform_action(action) 
+    case action.name
+    when "search"
+      search_service.query(action.params[:query])
+    end
+  end
 end
+```
+
+The Base agent integrates with ActionPrompt to:
+
+1. Create prompts with context
+2. Register available actions
+3. Process action requests
+4. Handle responses and update context
+5. Manage the conversation flow
+
+See Base.rb for full agent integration details.

data/lib/active_agent/action_prompt/action.rb

@@ -0,0 +1,13 @@
+module ActiveAgent
+  module ActionPrompt
+    class Action
+      attr_accessor :agent_name, :id, :name, :params
+
+      def initialize(attributes = {})
+        @id = attributes.fetch(:id, nil)
+        @name = attributes.fetch(:name, "")
+        @params = attributes.fetch(:params, {})
+      end
+    end
+  end
+end

data/lib/active_agent/action_prompt/base.rb

@@ -0,0 +1,127 @@
+# 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
+
+#     included do
+#       include AbstractController::Rendering
+#       include AbstractController::Layouts
+#       include AbstractController::Helpers
+#       include AbstractController::Translation
+#       include AbstractController::AssetPaths
+#       include AbstractController::Callbacks
+#       include AbstractController::Caching
+
+#       include ActionView::Layouts
+
+#       helper ActiveAgent::PromptHelper
+#       # class_attribute :default_params, default: {
+#       #   content_type: "text/plain",
+#       #   parts_order: ["text/plain", "text/html", "application/json"]
+#       # }.freeze
+#     end
+
+#     # # def self.prompt(headers = {}, &)
+#     # #   new.prompt(headers, &)
+#     # # end
+
+#     # def prompt(headers = {}, &block)
+#     #   return @_message if @_prompt_was_called && headers.blank? && !block
+
+#     #   headers = apply_defaults(headers)
+
+#     #   @_message = ActiveAgent::ActionPrompt::Prompt.new
+
+#     #   assign_headers_to_message(@_message, headers)
+
+#     #   responses = collect_responses(headers, &block)
+
+#     #   @_prompt_was_called = true
+
+#     #   create_parts_from_responses(@_message, responses)
+
+#     #   @_message
+#     # end
+
+#     private
+
+#     def apply_defaults(headers)
+#       headers.reverse_merge(self.class.default_params)
+#     end
+
+#     def assign_headers_to_message(message, headers)
+#       assignable = headers.except(:parts_order, :content_type, :body, :template_name, :template_path)
+#       assignable.each { |k, v| message.send(:"#{k}=", v) }
+#     end
+
+#     def collect_responses(headers, &block)
+#       if block
+#         collect_responses_from_block(headers, &block)
+#       elsif headers[:body]
+#         collect_responses_from_text(headers)
+#       else
+#         collect_responses_from_templates(headers)
+#       end
+#     end
+
+#     def collect_responses_from_block(headers, &block)
+#       templates_name = headers[:template_name] || action_name
+#       collector = ActiveAgent::ActionPrompt::Collector.new(lookup_context) { render(templates_name) }
+#       yield(collector)
+#       collector.responses
+#     end
+
+#     def collect_responses_from_text(headers)
+#       [{
+#         body: headers.delete(:body),
+#         content_type: headers[:content_type] || "text/plain"
+#       }]
+#     end
+
+#     def collect_responses_from_templates(headers)
+#       templates_path = headers[:template_path] || self.class.name.sub(/Agent$/, "").underscore
+#       templates_name = headers[:template_name] || action_name
+#       each_template(Array(templates_path), templates_name).map do |template|
+#         format = template.format || formats.first
+#         {
+#           body: render(template: template, formats: [format]),
+#           content_type: Mime[format].to_s
+#         }
+#       end
+#     end
+
+#     def each_template(paths, name, &)
+#       templates = lookup_context.find_all(name, paths)
+#       if templates.empty?
+#         raise ActionView::MissingTemplate.new(paths, name, paths, false, "prompt")
+#       else
+#         templates.uniq(&:format).each(&)
+#       end
+#     end
+
+#     def create_parts_from_responses(message, responses)
+#       responses.each do |response|
+#         message.add_part(response[:body], content_type: response[:content_type])
+#       end
+#     end
+
+#     class TestAgent
+#       class << self
+#         attr_accessor :generations
+#       end
+#     end
+#   end
+# end

data/lib/active_agent/action_prompt/message.rb

@@ -3,33 +3,35 @@ module ActiveAgent
     class Message
       VALID_ROLES = %w[system assistant user tool function].freeze
 
-      attr_accessor :content, :role, :name, :action_requested, :requested_actions
+      attr_accessor :action_id, :content, :role, :action_requested, :requested_actions, :content_type, :charset
 
       def initialize(attributes = {})
+        @action_id = attributes[:action_id]
+        @charset = attributes[:charset] || "UTF-8"
         @content = attributes[:content] || ""
-        @role = attributes[:role] || "user"
-        @name = attributes[:name]
-        @action_requested = attributes[:function_call]
-        @requested_actions = attributes[:tool_calls] || []
+        @content_type = attributes[:content_type] || "text/plain"
+        @role = attributes[:role] || :user
+        @requested_actions = attributes[:requested_actions] || []
+        @action_requested = @requested_actions.any?
         validate_role
       end
 
       def to_h
-        hash = {role: role, content: content}
-        hash[:name] = name if name
-        hash[:action_requested] = action_requested if action_requested
+        hash = {
+          role: role,
+          action_id: action_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 perform_actions
-        requested_actions.each do |action|
-          action.call(self) if action.respond_to?(:call)
-        end
-      end
-
-      def action_requested?
-        action_requested.present? || requested_actions.any?
+      def embed
+        @agent_class.embed(@content)
       end
 
       private

data/lib/active_agent/action_prompt/prompt.rb

@@ -1,29 +1,30 @@
-# lib/active_agent/action_prompt/prompt.rb
 require_relative "message"
 
 module ActiveAgent
   module ActionPrompt
     class Prompt
-      attr_accessor :actions, :body, :content_type, :instructions, :message, :messages, :options, :mime_version, :charset, :context
+      attr_accessor :actions, :body, :content_type, :context_id, :instructions, :message, :messages, :options, :mime_version, :charset, :context, :parts
 
       def initialize(attributes = {})
         @options = attributes.fetch(:options, {})
+        @agent_class = attributes.fetch(:agent_class, ApplicationAgent)
         @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, Message.new)
+        @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, [])
 
-        set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message.content
-        set_messages if @messages.any? || @instructions.present?
+        set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message&.content
+        set_messages
       end
 
       # Generate the prompt as a string (for debugging or sending to the provider)
@@ -31,13 +32,11 @@ module ActiveAgent
         @message.to_s
       end
 
-      def add_part(part)
-        message = Message.new(content: part[:body], role: :user)
-        prompt_part = self.class.new(message: message, content: message.content, content_type: part[:content_type], chartset: part[:charset])
+      def add_part(message)
+        @message = message
+        set_message if @content_type == message.content_type && @message.content.present?
 
-        set_message if @content_type == part[:content_type] && @message.content
-
-        @parts << prompt_part
+        @parts << context
       end
 
       def multipart?
@@ -67,12 +66,12 @@ module ActiveAgent
       end
 
       def set_message
-        if @body.is_a?(String) && !@message.content
-          @message = Message.new(content: @body, role: :user)
-        elsif @message.is_a? String
+        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 = [@message]
+        @messages << @message
       end
     end
   end