activeagent 0.3.3 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 065b41c8228d87f1c49d6099813e4d67fc8c853f2985bcdff01e8af23d0561d3
-  data.tar.gz: 820580bb35c3596adfdaee4edb9dc7f54044328f32d92a767d6134a3460875f2
+  metadata.gz: c93bac60dcbdb44bfc6461435f84e79499682db83a93ea07526a5b546c2a1b63
+  data.tar.gz: c3a7a995862ef152661b1ede6c012e17747c190853cdc501e0a0f99445c7fe40
 SHA512:
-  metadata.gz: 46752438d8e2ec5772e6c6a134906410de7363c366c187ce771bc6f13c7c748d23975ea7716e98ff22a76e8bfa46be43513cc6ce97cf504788ea612ac68caaeb
-  data.tar.gz: 1e8f480da2ac8107114ee9503aa9db582cbd7719e1ceceb809a741a8b0a81b67a038c46ecb75bff31e5ef9b77ce3197c6cc8bfbcb19c9c3779e097d8b3d53411
+  metadata.gz: 5e2836e13ca5d353d221a33643c7c101320e2615982dceccf4dfdf25c9e9fe9bbdeb48503aa70d1a21ed1dd8cfdab0ec76348342dbbd29dc5cfb59f9306266f9
+  data.tar.gz: edaddc4339c00242935f0ba70fdc95f98547c12ccd6d4b4da9cd4081dd051e3521c6b4bdb5745fe6e7a382e462024b0dc0aec12eacd730b2ebc5f12a81315d35

data/lib/active_agent/action_prompt/base.rb

@@ -0,0 +1,470 @@
+require "active_agent/collector"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/module/anonymous"
+
+# require "active_agent/log_subscriber"
+require "active_agent/rescuable"
+module ActiveAgent
+  module ActionPrompt
+    class Base < AbstractController::Base
+      include Callbacks
+      include GenerationMethods
+      include GenerationProvider
+      include QueuedGeneration
+      include Rescuable
+      include Parameterized
+      include Previews
+      # include FormBuilder
+
+      abstract!
+
+      include AbstractController::Rendering
+
+      include AbstractController::Logger
+      include AbstractController::Helpers
+      include AbstractController::Translation
+      include AbstractController::AssetPaths
+      include AbstractController::Callbacks
+      include AbstractController::Caching
+
+      include ActionView::Layouts
+
+      PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [ :@_action_has_layout ]
+
+      helper ActiveAgent::PromptHelper
+
+      class_attribute :options
+
+      class_attribute :default_params, default: {
+        mime_version: "1.0",
+        charset: "UTF-8",
+        content_type: "text/plain",
+        parts_order: [ "text/plain", "text/enriched", "text/html" ]
+      }.freeze
+
+      class << self
+        # Register one or more Observers which will be notified when prompt is generated.
+        def register_observers(*observers)
+          observers.flatten.compact.each { |observer| register_observer(observer) }
+        end
+
+        # Unregister one or more previously registered Observers.
+        def unregister_observers(*observers)
+          observers.flatten.compact.each { |observer| unregister_observer(observer) }
+        end
+
+        # Register one or more Interceptors which will be called before prompt is sent.
+        def register_interceptors(*interceptors)
+          interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) }
+        end
+
+        # Unregister one or more previously registered Interceptors.
+        def unregister_interceptors(*interceptors)
+          interceptors.flatten.compact.each { |interceptor| unregister_interceptor(interceptor) }
+        end
+
+        # Register an Observer which will be notified when prompt is generated.
+        # Either a class, string, or symbol can be passed in as the Observer.
+        # If a string or symbol is passed in it will be camelized and constantized.
+        def register_observer(observer)
+          Prompt.register_observer(observer_class_for(observer))
+        end
+
+        # Unregister a previously registered Observer.
+        # Either a class, string, or symbol can be passed in as the Observer.
+        # If a string or symbol is passed in it will be camelized and constantized.
+        def unregister_observer(observer)
+          Prompt.unregister_observer(observer_class_for(observer))
+        end
+
+        # Register an Interceptor which will be called before prompt is sent.
+        # Either a class, string, or symbol can be passed in as the Interceptor.
+        # If a string or symbol is passed in it will be camelized and constantized.
+        def register_interceptor(interceptor)
+          Prompt.register_interceptor(observer_class_for(interceptor))
+        end
+
+        # Unregister a previously registered Interceptor.
+        # Either a class, string, or symbol can be passed in as the Interceptor.
+        # If a string or symbol is passed in it will be camelized and constantized.
+        def unregister_interceptor(interceptor)
+          Prompt.unregister_interceptor(observer_class_for(interceptor))
+        end
+
+        def observer_class_for(value) # :nodoc:
+          case value
+          when String, Symbol
+            value.to_s.camelize.constantize
+          else
+            value
+          end
+        end
+        private :observer_class_for
+
+        # Define how the agent should generate content
+        def generate_with(provider, **options)
+          self.generation_provider = provider
+          self.options = (options || {}).merge(options)
+          self.options[:stream] = new.agent_stream if self.options[:stream]
+          generation_provider.config.merge!(self.options)
+        end
+
+        def stream_with(&stream)
+          self.options = (options || {}).merge(stream: stream)
+        end
+
+        # Returns the name of the current agent. This method is also being used as a path for a view lookup.
+        # If this is an anonymous agent, this method will return +anonymous+ instead.
+        def agent_name
+          @agent_name ||= anonymous? ? "anonymous" : name.underscore
+        end
+        # Allows to set the name of current agent.
+        attr_writer :agent_name
+        alias_method :controller_path, :agent_name
+
+        # Sets the defaults through app configuration:
+        #
+        #     config.action_agent.default(from: "no-reply@example.org")
+        #
+        # Aliased by ::default_options=
+        def default(value = nil)
+          self.default_params = default_params.merge(value).freeze if value
+          default_params
+        end
+        # Allows to set defaults through app configuration:
+        #
+        #    config.action_agent.default_options = { from: "no-reply@example.org" }
+        alias_method :default_options=, :default
+
+        # Wraps a prompt generation inside of ActiveSupport::Notifications instrumentation.
+        #
+        # This method is actually called by the +ActionPrompt::Prompt+ object itself
+        # through a callback when you call <tt>:generate_prompt</tt> on the +ActionPrompt::Prompt+,
+        # calling +generate_prompt+ directly and passing an +ActionPrompt::Prompt+ will do
+        # nothing except tell the logger you generated the prompt.
+        def generate_prompt(prompt) # :nodoc:
+          ActiveSupport::Notifications.instrument("deliver.active_agent") do |payload|
+            set_payload_for_prompt(payload, prompt)
+            yield # Let Prompt do the generation actions
+          end
+        end
+
+        private
+
+        def set_payload_for_prompt(payload, prompt)
+          payload[:prompt] = prompt.encoded
+          payload[:agent] = agent_name
+          payload[:message_id] = prompt.message_id
+          payload[:date] = prompt.date
+          payload[:perform_generations] = prompt.perform_generations
+        end
+
+        def method_missing(method_name, ...)
+          if action_methods.include?(method_name.name)
+            Generation.new(self, method_name, ...)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method, include_all = false)
+          action_methods.include?(method.name) || super
+        end
+      end
+
+      attr_internal :context
+
+      def agent_stream
+        proc do |message, delta, stop|
+          run_stream_callbacks(message, delta, stop) do |message, delta, stop|
+            yield message, delta, stop if block_given?
+          end
+        end
+      end
+
+      def embed
+        context.options.merge(options)
+        generation_provider.embed(context) if context && generation_provider
+        handle_response(generation_provider.response)
+      end
+
+      # Add embedding capability to Message class
+      ActiveAgent::ActionPrompt::Message.class_eval do
+        def embed
+          agent_class = ActiveAgent::Base.descendants.first
+          agent = agent_class.new
+          agent.context = ActiveAgent::ActionPrompt::Prompt.new(message: self)
+          agent.embed
+          self
+        end
+      end
+
+      # Make context accessible for chaining
+      # attr_accessor :context
+
+      def perform_generation
+        context.options.merge(options)
+        if (action_methods - ActiveAgent::Base.descendants.first.action_methods).include? action_name
+          context.message = context.messages.last
+          context.actions = []
+        end
+        generation_provider.generate(context) if context && generation_provider
+        handle_response(generation_provider.response)
+      end
+
+      def handle_response(response)
+        return response unless response.message.requested_actions.present?
+        perform_actions(requested_actions: response.message.requested_actions)
+        update_context(response)
+      end
+
+      def update_context(response)
+        context.message = context.messages.last
+        ActiveAgent::GenerationProvider::Response.new(prompt: context)
+      end
+
+      def perform_actions(requested_actions:)
+        requested_actions.each do |action|
+          perform_action(action)
+        end
+      end
+
+      def perform_action(action)
+        current_context = context.clone
+        process(action.name, *action.params)
+        context.messages.last.role = :tool
+        context.messages.last.action_id = action.id
+        context.messages.last.action_name = action.name
+        context.messages.last.generation_id = action.id
+        current_context.messages << context.messages.last
+        self.context = current_context
+      end
+
+      def initialize
+        super
+        @_prompt_was_called = false
+        @_context = ActiveAgent::ActionPrompt::Prompt.new(instructions: options[:instructions], options: options)
+      end
+
+      def process(method_name, *args) # :nodoc:
+        payload = {
+          agent: self.class.name,
+          action: method_name,
+          args: args
+        }
+
+        ActiveSupport::Notifications.instrument("process.active_agent", payload) do
+          super
+          @_context = ActiveAgent::ActionPrompt::Prompt.new unless @_prompt_was_called
+        end
+      end
+      ruby2_keywords(:process)
+
+      class NullPrompt # :nodoc:
+        def message
+          ""
+        end
+
+        def header
+          {}
+        end
+
+        def respond_to?(string, include_all = false)
+          true
+        end
+
+        def method_missing(...)
+          nil
+        end
+      end
+
+      # Returns the name of the agent object.
+      def agent_name
+        self.class.agent_name
+      end
+
+      def headers(args = nil)
+        if args
+          @_context.headers(args)
+        else
+          @_context
+        end
+      end
+
+      def prompt_with(*)
+        context.update_context(*)
+      end
+
+      def prompt(headers = {}, &block)
+        return context if @_prompt_was_called && headers.blank? && !block
+        content_type = headers[:content_type]
+        headers = apply_defaults(headers)
+        context.messages = headers[:messages] || []
+        context.context_id = headers[:context_id]
+
+        context.charset = charset = headers[:charset]
+
+        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?(String)
+          headers[:body] = headers[:message]
+          headers[:role] = :user
+        end
+
+        # wrap_generation_behavior!(headers[:generation_method], headers[:generation_method_options])
+        # assign_headers_to_context(context, headers)
+        responses = collect_responses(headers, &block)
+
+        @_prompt_was_called = true
+
+        create_parts_from_responses(context, responses)
+
+        context.content_type = set_content_type(context, content_type, headers[:content_type])
+        context.charset = charset
+        context.actions = headers[:actions] || action_schemas
+
+        context
+      end
+
+      def action_methods
+        super - ActiveAgent::Base.public_instance_methods(false).map(&:to_s)
+      end
+
+      def action_schemas
+        action_methods.map do |action|
+          JSON.parse render_to_string(locals: { action_name: action }, action: action, formats: :json)
+        end.compact
+      end
+
+      private
+
+      def set_content_type(m, user_content_type, class_default) # :doc:
+        if user_content_type.present?
+          user_content_type
+        else
+          context.content_type || class_default
+        end
+      end
+
+      # Translates the +subject+ using \Rails I18n class under <tt>[agent_scope, action_name]</tt> scope.
+      # If it does not find a translation for the +subject+ under the specified scope it will default to a
+      # humanized version of the <tt>action_name</tt>.
+      # If the subject has interpolations, you can pass them through the +interpolations+ parameter.
+      def default_i18n_subject(interpolations = {}) # :doc:
+        agent_scope = self.class.agent_name.tr("/", ".")
+        I18n.t(:subject, **interpolations.merge(scope: [ agent_scope, action_name ], default: action_name.humanize))
+      end
+
+      def apply_defaults(headers)
+        default_values = self.class.default.except(*headers.keys).transform_values do |value|
+          compute_default(value)
+        end
+
+        headers.reverse_merge(default_values)
+      end
+
+      def compute_default(value)
+        return value unless value.is_a?(Proc)
+
+        if value.arity == 1
+          instance_exec(self, &value)
+        else
+          instance_exec(&value)
+        end
+      end
+
+      def assign_headers_to_context(context, headers)
+        assignable = headers.except(:parts_order, :content_type, :body, :role, :template_name,
+          :template_path, :delivery_method, :delivery_method_options)
+
+        assignable.each { |k, v| context.send(k, v) if context.respond_to?(k) }
+      end
+
+      def collect_responses(headers, &)
+        if block_given?
+          collect_responses_from_block(headers, &)
+        elsif headers[:body]
+          collect_responses_from_text(headers)
+        else
+          collect_responses_from_templates(headers)
+        end
+      end
+
+      def collect_responses_from_block(headers)
+        templates_name = headers[:template_name] || action_name
+        collector = ActiveAgent::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.agent_name
+        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.compact
+      end
+
+      def each_template(paths, name, &)
+        templates = lookup_context.find_all(name, paths)
+        if templates.empty?
+          raise ActionView::MissingTemplate.new(paths, name, paths, false, "agent")
+        else
+          templates.uniq(&:format).each(&)
+        end
+      end
+
+      def create_parts_from_responses(context, responses)
+        if responses.size > 1
+          # prompt_container = ActiveAgent::ActionPrompt::Prompt.new
+          # prompt_container.content_type = "multipart/alternative"
+          responses.each { |r| insert_part(context, r, context.charset) }
+          # context.add_part(prompt_container)
+        else
+          responses.each { |r| insert_part(context, r, context.charset) }
+        end
+      end
+
+      def insert_part(context, response, charset)
+        message = ActiveAgent::ActionPrompt::Message.new(
+          content: response[:body],
+          content_type: response[:content_type],
+          charset: charset
+        )
+        context.add_part(message)
+      end
+
+      # This and #instrument_name is for caching instrument
+      def instrument_payload(key)
+        {
+          agent: agent_name,
+          key: key
+        }
+      end
+
+      def instrument_name
+        "active_agent"
+      end
+
+      def _protected_ivars
+        PROTECTED_IVARS
+      end
+
+      ActiveSupport.run_load_hooks(:active_agent, self)
+    end
+  end
+end

data/lib/active_agent/action_prompt/message.rb

@@ -1,16 +1,34 @@
 module ActiveAgent
   module ActionPrompt
     class Message
-      VALID_ROLES = %w[system assistant user tool function].freeze
+      class << self
+        def from_messages(messages)
+          return messages if messages.empty? || messages.first.is_a?(Message)
 
-      attr_accessor :action_id, :content, :role, :action_requested, :requested_actions, :content_type, :charset
+          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, :role, :action_requested, :requested_actions, :content_type, :charset
 
       def initialize(attributes = {})
         @action_id = attributes[:action_id]
+        @action_name = attributes[:action_name]
+        @generation_id = attributes[:generation_id]
         @charset = attributes[:charset] || "UTF-8"
         @content = attributes[:content] || ""
         @content_type = attributes[:content_type] || "text/plain"
         @role = attributes[:role] || :user
+        @raw_actions = attributes[:raw_actions]
         @requested_actions = attributes[:requested_actions] || []
         @action_requested = @requested_actions.any?
         validate_role
@@ -24,6 +42,8 @@ module ActiveAgent
         hash = {
           role: role,
           action_id: action_id,
+          name: action_name,
+          generation_id: generation_id,
           content: content,
           type: content_type,
           charset: charset

data/lib/active_agent/action_prompt/prompt.rb

@@ -23,7 +23,7 @@ module ActiveAgent
         @context_id = attributes.fetch(:context_id, nil)
         @headers = attributes.fetch(:headers, {})
         @parts = attributes.fetch(:parts, [])
-
+        @messages = Message.from_messages(@messages)
         set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message&.content
         set_messages
       end
@@ -68,7 +68,7 @@ module ActiveAgent
       private
 
       def set_messages
-        @messages = [ Message.new(content: @instructions, role: :system) ] + @messages if @instructions.present?
+        @messages = [ Message.new(content: @instructions, role: :system) ] + Message.from_messages(@messages) if @instructions.present?
       end
 
       def set_message

data/lib/active_agent/action_prompt.rb

@@ -34,6 +34,90 @@ module ActiveAgent
       # }.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