activeagent 0.0.1.alpha → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5df915a84f0835479481fe92aeca21119898593b7b598817c0be2ff70a78ea
-  data.tar.gz: '085f9480e8f0bca465b47a5c7751b629dd256d413145b8673a734286d9db7714'
+  metadata.gz: 67bb51f0a98d5b2291b53e30b629adae069a3f24e19edfc74702a918bc3c1086
+  data.tar.gz: 04cb6ba122dac00b145c3baf1f54157d5e443470639d16f22d614bfaaba92b49
 SHA512:
-  metadata.gz: 6dc168a515156565906653929fedce429712addf8f454ed5732cc05225c30ad9bae3db7c7c4315440b29447f22b814ad25c49c7f1914c63d2e8f165099fac6f0
-  data.tar.gz: 4115f1c0e0496708cecfecade88975cfff72bdefc2b939e310dcb0c34f6ba46917cff46134c67e1157f545828a08e658341e5665f6c3f58b6785a27b63b8a38f
+  metadata.gz: 9835738ac1bb5570c900dd9a9942591a28c8b17b6ce26afbd622f764d5bb4ee178d0fc1089824a84d924824cc0c9a291680b1a1b1df5e41f5bfff1e91700a382
+  data.tar.gz: 78e3fd95e02a950cd2c47bf52891156d861f926374333efaeee51578fc0c96f65a94a123ec104cd0a5c32c9ea130ac85075a9904478191904936ea80381df714

data/README.md

@@ -0,0 +1,153 @@
+# ActiveAgent
+
+ActiveAgent is a Rails framework for creating and managing AI agents. It provides a structured way to interact with AI services through agents that can generate text, images, speech-to-text, and text-to-speech. It includes modules for defining prompts, actions, and rendering generative UI, as well as scaling with asynchronous jobs and streaming.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_agent'
+```
+
+And then execute:
+
+```sh
+bundle install
+```
+## Getting Started
+
+## Usage
+
+### Generating an Agent
+```
+rails generate agent inventory search
+```
+
+This will generate the following files:
+```
+app/agents/application_agent.rb
+app/agents/inventory_agent.rb
+app/views/inventory_agent/search.text.erb
+app/views/inventory_agent/search.json.jbuilder
+```
+
+### Define Agents
+
+Agents are the core of ActiveAgent. An agent takes prompts and can perform actions to generate content. Agents are defined by a simple Ruby class that inherits from `ActiveAgent::Base` and are located in the `app/agents` directory.
+
+```ruby
+# 
+
+inventory_agent.rb
+
+
+class InventoryAgent < ActiveAgent::Base
+  generate_with :openai, model: 'gpt-4o-mini', temperature: 0.5, instructions: :inventory_operations
+
+  def search
+    @items = Item.search(params[:query])
+  end
+
+  def inventory_operations
+    @organization = Organization.find(params[:account_id])
+    prompt
+  end
+end
+```
+
+### Interact with AI Services
+
+ActiveAgent allows you to interact with various AI services to generate text, images, speech-to-text, and text-to-speech.
+
+```ruby
+class SupportAgent < ActiveAgent::Base
+  generate_with :openai, model: 'gpt-4o-mini', instructions: :instructions
+
+  def perform(content, context)
+    @content = content
+    @context = context
+  end
+
+  def generate_message
+    provider_instance.generate(self)
+  end
+
+  private
+
+  def after_generate
+    broadcast_message
+  end
+
+  def broadcast_message
+    broadcast_append_later_to(
+      broadcast_stream,
+      target: broadcast_target,
+      partial: 'support_agent/message',
+      locals: { message: @message }
+    )
+  end
+
+  def broadcast_stream
+    "#{dom_id(@chat)}_messages"
+  end
+end
+```
+
+### Render Generative UI
+
+ActiveAgent uses Action Prompt both for rendering `instructions` prompt views as well as rendering action views. Prompts are Action Views that provide instructions for the agent to generate content.
+
+```erb
+<!-- 
+
+instructions.text.erb
+
+ -->
+INSTRUCTIONS: You are an inventory manager for <%= @organization.name %>. You can search for inventory or reconcile inventory using <%= assigned_actions %>
+```
+
+### Scale with Asynchronous Jobs and Streaming
+
+ActiveAgent supports asynchronous job processing and streaming for scalable AI interactions.
+
+#### Asynchronous Jobs
+
+Use the `generate_later` method to enqueue a job for later processing.
+
+```ruby
+InventoryAgent.with(query: query).search.generate_later
+```
+
+#### Streaming
+
+Use the `stream_with` method to handle streaming responses.
+
+```ruby
+class InventoryAgent < ActiveAgent::Base
+  generate_with :openai, model: 'gpt-4o-mini', stream: :broadcast_results
+
+  private
+
+  def broadcast_results
+    proc do |chunk, _bytesize|
+      @message.content = @message.content + chunk
+      broadcast_append_to(
+        "#{dom_id(chat)}_messages",
+        partial: "messages/message",
+        locals: { message: @message, scroll_to: true },
+        target: "#{dom_id(chat)}_messages"
+      )
+    end
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/active_agent.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+```

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/active_agent/README.md

@@ -0,0 +1,21 @@
+# Active Agent
+Active Agent is a Rails framework for creating and managing AI agents. It provides a structured way to interact with generation providers through agents with context including prompts, tools, and messages. It includes two core modules, Generation Provider and Action Prompt, along with several support classes to handle different aspects of agent creation and management.
+
+## Core Modules
+
+- Generation Provider - module for configuring and interacting with generation providers through Prompts and Responses.
+- Action Prompt - module for defining prompts, tools, and messages. The Base class implements an AbstractController to render prompts and actions. Prompts are Action Views that provide instructions for the agent to generate content, formatted messages for the agent and users including **streaming generative UI**.
+
+## Main Components
+
+- Base class - for creating and configuring agents.
+- Queued Generation - module for managing queued generation requests and responses. Using the Generation Job class to perform asynchronous generation requests, it  provides a way to **stream generation** requests back to the Job, Agent, or User.
+
+### ActiveAgent::Base
+
+The Base class is used to create agents that interact with generation providers through prompts and messages. It includes methods for configuring and interacting with generation providers using Prompts and Responses. The Base class also provides a structured way to render prompts and actions.
+
+#### Core Methods
+
+- `generate_with(provider, options = {})` - Configures the agent to generate content using the specified generation provider and options.
+- `streams_with(provider, options = {})` - Configures the agent to stream content using the specified generation provider's stream option.

data/lib/active_agent/action_prompt/README.md

@@ -0,0 +1,44 @@
+# 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..
+
+## Main Components
+
+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.
+
+### 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.
+
+
+### ActionPrompt::Tool
+
+### ActionPrompt::Message
+
+Represents a single message within a prompt.
+
+### ActionPrompt::Prompt
+
+Manages the overall structure of a prompt, including multiple messages, actions, and other attributes.
+
+### 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.
+
+## Usage
+
+To use ActionPrompt in your agent, include the module in your agent class:
+
+```ruby
+class MyAgent
+  include ActiveAgent::ActionPrompt
+  
+  # Your agent code here
+end

data/lib/active_agent/action_prompt/collector.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "abstract_controller/collector"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/array/extract_options"
+
+module ActiveAgent
+  module ActionPrompt
+    class Collector
+      include AbstractController::Collector
+      attr_reader :responses
+
+      def initialize(context, &block)
+        @context = context
+        @responses = []
+        @default_render = block
+      end
+
+      def any(*args, &block)
+        options = args.extract_options!
+        raise ArgumentError, "You have to supply at least one format" if args.empty?
+        args.each { |type| send(type, options.dup, &block) }
+      end
+      alias_method :all, :any
+
+      def custom(mime, options = {})
+        options.reverse_merge!(content_type: mime.to_s)
+        @context.formats = [mime.to_sym]
+        options[:body] = block_given? ? yield : @default_render.call
+        @responses << options
+      end
+    end
+  end
+end

data/lib/active_agent/action_prompt/message.rb

@@ -0,0 +1,44 @@
+module ActiveAgent
+  module ActionPrompt
+    class Message
+      VALID_ROLES = %w[system assistant user tool function].freeze
+
+      attr_accessor :content, :role, :name, :action_requested, :requested_actions
+
+      def initialize(attributes = {})
+        @content = attributes[:content] || ""
+        @role = attributes[:role] || "user"
+        @name = attributes[:name]
+        @action_requested = attributes[:function_call]
+        @requested_actions = attributes[:tool_calls] || []
+        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[: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?
+      end
+
+      private
+
+      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

@@ -0,0 +1,79 @@
+# 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
+
+      def initialize(attributes = {})
+        @options = attributes.fetch(:options, {})
+        @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)
+        @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, [])
+        @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?
+      end
+
+      # Generate the prompt as a string (for debugging or sending to the provider)
+      def to_s
+        @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])
+
+        set_message if @content_type == part[:content_type] && @message.content
+
+        @parts << prompt_part
+      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 headers(headers = {})
+        @headers.merge!(headers)
+      end
+
+      private
+
+      def set_messages
+        @messages = [Message.new(content: @instructions, role: :system)] + @messages
+      end
+
+      def set_message
+        if @body.is_a?(String) && !@message.content
+          @message = Message.new(content: @body, role: :user)
+        elsif @message.is_a? String
+          @message = Message.new(content: @message, role: :user)
+        end
+        @messages = [@message]
+      end
+    end
+  end
+end

data/lib/active_agent/action_prompt.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