activeagent 0.3.3 → 0.4.0

data/lib/active_agent/base.rb

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 
 require "active_agent/prompt_helper"
-require "active_agent/action_prompt/prompt"
-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"
+require "active_agent/action_prompt/base"
 
 # The ActiveAgent module provides a framework for creating agents that can generate content
 # and handle various actions. The Base class within this module extends AbstractController::Base
@@ -30,446 +23,14 @@ require "active_agent/rescuable"
 # The class also includes several protected instance variables and defines hooks for loading
 # additional functionality.
 module ActiveAgent
-  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
+  class Base < ActiveAgent::ActionPrompt::Base
+    # This class is the base class for agents in the ActiveAgent framework.
+    # It is built on top of ActionPrompt which provides methods for generating content, handling actions, and managing prompts.
+    # ActiveAgent::Base is designed to be extended by specific agent implementations.
+    # It provides a common set of agent actions for self-contained agents that can determine their own actions using all available actions.
+    # Base actions include: text_prompt, continue, reasoning, reiterate, and conclude
+    def text_prompt
+      prompt(stream: params[:stream], messages: params[:messages], message: params[:message], context_id: params[:context_id])
     end
-
-    attr_internal :prompt_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
-      prompt_context.options.merge(options)
-      generation_provider.embed(prompt_context) if prompt_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.prompt_context = ActiveAgent::ActionPrompt::Prompt.new(message: self)
-        agent.embed
-        self
-      end
-    end
-
-    # Make prompt_context accessible for chaining
-    # attr_accessor :prompt_context
-
-    def perform_generation
-      prompt_context.options.merge(options)
-      generation_provider.generate(prompt_context) if prompt_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_prompt_context(response)
-    end
-
-    def update_prompt_context(response)
-      prompt_context.message = prompt_context.messages.last
-      ActiveAgent::GenerationProvider::Response.new(prompt: prompt_context)
-    end
-
-    def perform_actions(requested_actions:)
-      requested_actions.each do |action|
-        perform_action(action)
-      end
-    end
-
-    def perform_action(action)
-      current_context = prompt_context.clone
-      process(action.name, *action.params)
-      prompt_context.messages.last.role = :tool
-      prompt_context.messages.last.action_id = action.id
-      current_context.messages << prompt_context.messages.last
-      self.prompt_context = current_context
-    end
-
-    def initialize
-      super
-      @_prompt_was_called = false
-      @_prompt_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
-        @_prompt_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
-        @_prompt_context.headers(args)
-      else
-        @_prompt_context
-      end
-    end
-
-    def prompt_with(*)
-      prompt_context.update_prompt_context(*)
-    end
-
-    def prompt(headers = {}, &block)
-      return prompt_context if @_prompt_was_called && headers.blank? && !block
-      content_type = headers[:content_type]
-      headers = apply_defaults(headers)
-      prompt_context.messages = headers[:messages] || []
-      prompt_context.context_id = headers[:context_id]
-
-      prompt_context.charset = charset = headers[:charset]
-
-      responses = collect_responses(headers, &block)
-
-      @_prompt_was_called = true
-
-      create_parts_from_responses(prompt_context, responses)
-
-      prompt_context.content_type = set_content_type(prompt_context, content_type, headers[:content_type])
-      prompt_context.charset = charset
-      prompt_context.actions = headers[:actions] || action_schemas
-
-      prompt_context
-    end
-
-    def action_schemas
-      action_methods.map do |action|
-        if action != "text_prompt"
-          JSON.parse render_to_string(locals: { action_name: action }, action: action, formats: :json)
-        end
-      end.compact
-    end
-
-    private
-
-    def set_content_type(m, user_content_type, class_default) # :doc:
-      if user_content_type.present?
-        user_content_type
-      else
-        prompt_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_prompt_context(prompt_context, headers)
-      assignable = headers.except(:parts_order, :content_type, :body, :template_name,
-        :template_path, :delivery_method, :delivery_method_options)
-      assignable.each { |k, v| prompt_context[k] = v }
-    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 = 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|
-        next if template.format == :json
-
-        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(prompt_context, responses)
-      if responses.size > 1
-        # prompt_container = ActiveAgent::ActionPrompt::Prompt.new
-        # prompt_container.content_type = "multipart/alternative"
-        responses.each { |r| insert_part(prompt_context, r, prompt_context.charset) }
-        # prompt_context.add_part(prompt_container)
-      else
-        responses.each { |r| insert_part(prompt_context, r, prompt_context.charset) }
-      end
-    end
-
-    def insert_part(prompt_context, response, charset)
-      message = ActiveAgent::ActionPrompt::Message.new(
-        content: response[:body],
-        content_type: response[:content_type],
-        charset: charset
-      )
-      prompt_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

data/lib/active_agent/callbacks.rb

@@ -6,31 +6,31 @@ module ActiveAgent
 
     included do
       include ActiveSupport::Callbacks
-      define_callbacks :generate, skip_after_callbacks_if_terminated: true
+      define_callbacks :generation, skip_after_callbacks_if_terminated: true
       define_callbacks :stream, skip_after_callbacks_if_terminated: true
     end
 
     module ClassMethods
       # Defines a callback that will get called right before the
       # prompt is sent to the generation provider method.
-      def before_generate(*filters, &)
-        set_callback(:generate, :before, *filters, &)
+      def before_generation(*filters, &blk)
+        set_callback(:generation, :before, *filters, &blk)
       end
 
       # Defines a callback that will get called right after the
       # prompt's generation method is finished.
-      def after_generate(*filters, &)
-        set_callback(:generate, :after, *filters, &)
+      def after_generation(*filters, &blk)
+        set_callback(:generation, :after, *filters, &blk)
       end
 
       # Defines a callback that will get called around the prompt's generation method.
-      def around_generate(*filters, &)
-        set_callback(:generate, :around, *filters, &)
+      def around_generation(*filters, &blk)
+        set_callback(:generation, :around, *filters, &blk)
       end
 
       # Defines a callback for handling streaming responses during generation
-      def on_stream(*filters, &)
-        set_callback(:stream, :before, *filters, &)
+      def on_stream(*filters, &blk)
+        set_callback(:stream, :before, *filters, &blk)
       end
     end
 

data/lib/active_agent/generation.rb

@@ -36,7 +36,7 @@ module ActiveAgent
 
     def generate_now!
       processed_agent.handle_exceptions do
-        processed_agent.run_callbacks(:generate) do
+        processed_agent.run_callbacks(:generation) do
           processed_agent.perform_generation!
         end
       end
@@ -44,7 +44,7 @@ module ActiveAgent
 
     def generate_now
       processed_agent.handle_exceptions do
-        processed_agent.run_callbacks(:generate) do
+        processed_agent.run_callbacks(:generation) do
           processed_agent.perform_generation
         end
       end
@@ -70,7 +70,7 @@ module ActiveAgent
           "method*, or 3. use a custom Active Job instead of #generate_later."
       else
         @agent_class.generation_job.set(options).perform_later(
-          @agent_class.name, @action.to_s, args: @args
+          @agent_class.name, @action.to_s, generation_method.to_s, args: @args
         )
       end
     end

data/lib/active_agent/generation_job.rb

@@ -18,12 +18,14 @@ module ActiveAgent
 
     rescue_from StandardError, with: :handle_exception_with_agent_class
 
-    def perform(agent_class_name, action_name, args:, params: nil)
-      agent_class = agent_class_name.constantize
-      agent = agent_class.new
-      agent.params = params if params
-      agent.process(action_name, *args)
-      agent.perform_generation
+    def perform(agent, agent_method, generation_method, args:, kwargs: nil, params: nil)
+      agent_class = params ? agent.constantize.with(params) : agent.constantize
+      prompt = if kwargs
+        agent_class.public_send(agent_method, *args, **kwargs)
+      else
+        agent_class.public_send(agent_method, *args)
+      end
+      prompt.send(generation_method)
     end
 
     private

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -10,7 +10,12 @@ module ActiveAgent
         super
         @api_key = config["api_key"]
         @model_name = config["model"] || "gpt-4o-mini"
-        @client = OpenAI::Client.new(access_token: @api_key, log_errors: true)
+
+        @client = if (@host = config["host"])
+          OpenAI::Client.new(uri_base: @host, access_token: @api_key)
+        else
+          OpenAI::Client.new(access_token: @api_key)
+        end
       end
 
       def generate(prompt)
@@ -33,18 +38,20 @@ module ActiveAgent
 
       def provider_stream
         agent_stream = prompt.options[:stream]
+
         message = ActiveAgent::ActionPrompt::Message.new(content: "", role: :assistant)
 
         @response = ActiveAgent::GenerationProvider::Response.new(prompt:, message:)
         proc do |chunk, bytesize|
           new_content = chunk.dig("choices", 0, "delta", "content")
-          if new_content && !new_content.blank
+          if new_content && !new_content.blank?
+            message.generation_id = chunk.dig("id")
             message.content += new_content
 
             agent_stream.call(message, new_content, false) do |message, new_content|
               yield message, new_content if block_given?
             end
-          elsif chunk.dig("choices", 0, "delta", "tool_calls") && !chunk.dig("choices", 0, "delta", "tool_calls").empty?
+          elsif chunk.dig("choices", 0, "delta", "tool_calls") && chunk.dig("choices", 0, "delta", "role")
             message = handle_message(chunk.dig("choices", 0, "delta"))
             prompt.messages << message
             @response = ActiveAgent::GenerationProvider::Response.new(prompt:, message:)
@@ -70,13 +77,17 @@ module ActiveAgent
           provider_message = {
             role: message.role,
             tool_call_id: message.action_id.presence,
+            name: message.action_name.presence,
+            tool_calls: message.raw_actions.present? ? message.raw_actions[:tool_calls] : (message.requested_actions.map { |action| { type: "function", name: action.name, arguments: action.params.to_json } } if message.action_requested),
+            generation_id: message.generation_id,
             content: message.content,
             type: message.content_type,
             charset: message.charset
           }.compact
 
-          if message.content_type == "image_url"
-            provider_message[:image_url] = {url: message.content}
+          if message.content_type == "image_url" || message.content[0..4] == "data:"
+            provider_message[:type] = "image_url"
+            provider_message[:image_url] = { url: message.content }
           end
           provider_message
         end
@@ -84,9 +95,8 @@ module ActiveAgent
 
       def chat_response(response)
         return @response if prompt.options[:stream]
-
         message_json = response.dig("choices", 0, "message")
-
+        message_json["id"] = response.dig("id") if message_json["id"].blank?
         message = handle_message(message_json)
 
         update_context(prompt: prompt, message: message, response: response)
@@ -96,9 +106,11 @@ module ActiveAgent
 
       def handle_message(message_json)
         ActiveAgent::ActionPrompt::Message.new(
+          generation_id: message_json["id"],
           content: message_json["content"],
           role: message_json["role"].intern,
           action_requested: message_json["finish_reason"] == "tool_calls",
+          raw_actions: message_json["tool_calls"] || [],
           requested_actions: handle_actions(message_json["tool_calls"])
         )
       end
@@ -108,7 +120,7 @@ module ActiveAgent
 
         tool_calls.map do |tool_call|
           next if tool_call["function"].nil? || tool_call["function"]["name"].blank?
-          args = tool_call["function"]["arguments"].blank? ? nil : JSON.parse(tool_call["function"]["arguments"], {symbolize_names: true})
+          args = tool_call["function"]["arguments"].blank? ? nil : JSON.parse(tool_call["function"]["arguments"], { symbolize_names: true })
 
           ActiveAgent::ActionPrompt::Action.new(
             id: tool_call["id"],

data/lib/active_agent/parameterized.rb

@@ -57,7 +57,7 @@ module ActiveAgent
           super
         else
           @agent_class.generation_job.set(options).perform_later(
-            @agent_class.name, @action.to_s, params: @params, args: @args
+            @agent_class.name, @action.to_s, generation_method.to_s, params: @params, args: @args
           )
         end
       end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/lib/active_agent.rb

@@ -1,6 +1,5 @@
 require "yaml"
 require "abstract_controller"
-require "active_agent/action_prompt"
 require "active_agent/generation_provider"
 require "active_agent/version"
 require "active_agent/deprecator"
@@ -49,7 +48,7 @@ module ActiveAgent
 
     def load_configuration(file)
       if File.exist?(file)
-        config_file = YAML.load(ERB.new(File.read(file)).result)
+        config_file = YAML.load(ERB.new(File.read(file)).result, aliases: true)
         env = ENV["RAILS_ENV"] || ENV["ENV"] || "development"
         @config = config_file[env] || config_file
       end

data/lib/generators/active_agent/templates/application_agent.rb.tt

@@ -3,9 +3,5 @@ class ApplicationAgent < ActiveAgent::Base
   layout 'agent'
   
   generate_with :openai, model: "gpt-4o-mini", instructions: "You are a helpful assistant."
-  
-  def text_prompt
-    prompt { |format| format.text { render plain: params[:message] } }
-  end
 end
 <% end %>