activeagent 0.0.1.alpha → 0.1.0

data/lib/active_agent/generation_provider/base.rb

@@ -0,0 +1,36 @@
+# lib/active_agent/generation_provider/base.rb
+
+module ActiveAgent
+  module GenerationProvider
+    class Base
+      class GenerationProviderError < StandardError; end
+      attr_reader :client, :config, :prompt
+
+      def initialize(config)
+        @config = config
+        @prompt = nil
+        @response = nil
+      end
+
+      def generate(prompt)
+        raise NotImplementedError, "Subclasses must implement the 'generate' method"
+      end
+
+      private
+
+      def handle_response(response)
+        ActiveAgent::GenerationProvider::Response.new(message:, raw_response: response)
+        raise NotImplementedError, "Subclasses must implement the 'handle_response' method"
+      end
+
+      protected
+
+      def prompt_parameters
+        {
+          messages: @prompt.messages,
+          temperature: @config["temperature"] || 0.7
+        }
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -0,0 +1,68 @@
+# lib/active_agent/generation_provider/open_ai_provider.rb
+
+require_relative "base"
+require "openai"
+require "active_agent/generation_provider/response"
+
+module ActiveAgent
+  module GenerationProvider
+    class OpenAIProvider < Base
+      def initialize(config)
+        super
+        @api_key = config["api_key"]
+        @model_name = config["model"] || "gpt-4o-mini"
+        @client = OpenAI::Client.new(api_key: @api_key)
+      end
+
+      def generate(prompt)
+        @prompt = prompt
+        parameters = prompt_parameters.merge(model: @model_name)
+
+        # parameters[:instructions] = prompt.instructions.content if prompt.instructions.present?
+
+        parameters[:stream] = provider_stream if prompt.options[:stream] || config["stream"]
+
+        response = @client.chat(parameters: parameters)
+        handle_response(response)
+      rescue => e
+        raise GenerationProviderError, e.message
+      end
+
+      private
+
+      def provider_stream
+        # prompt.config[:stream] will define a proc found in prompt at runtime
+        # config[:stream] will define a proc found in config stream would come from an Agent class's generate_with or stream_with method calls
+        agent_stream = prompt.config[:stream] || config["stream"]
+        proc do |chunk, bytesize|
+          # Provider parsing logic here
+          new_content = chunk.dig("choices", 0, "delta", "content")
+          message = @prompt.messages.find { |message| message.response_number == chunk.dig("choices", 0, "index") }
+          message.update(content: message.content + new_content) if new_content
+
+          # Call the custom stream_proc if provided
+          agent_stream.call(message) if agent_stream.respond_to?(:call)
+        end
+      end
+
+      def prompt_parameters
+        {
+          messages: @prompt.messages,
+          temperature: @config["temperature"] || 0.7,
+          tools: @prompt.actions
+        }
+      end
+
+      def handle_response(response)
+        message_json = response.dig("choices", 0, "message")
+        message = ActiveAgent::ActionPrompt::Message.new(
+          content: message_json["content"],
+          role: message_json["role"],
+          action_reqested: message_json["function_call"],
+          requested_actions: message_json["tool_calls"]
+        )
+        ActiveAgent::GenerationProvider::Response.new(prompt: prompt, message: message, raw_response: response)
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider/response.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    class Response
+      attr_reader :message, :prompt, :raw_response
+
+      def initialize(prompt:, message:, raw_response: nil)
+        @message = message
+        @prompt = prompt
+        @raw_response = raw_response
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_generation_provider_name, instance_accessor: false, instance_predicate: false
+      class_attribute :_generation_provider, instance_accessor: false, instance_predicate: false
+
+      delegate :generation_provider, to: :class
+    end
+
+    module ClassMethods
+      def configuration(provider_name, **options)
+        config = ActiveAgent.config[provider_name.to_s] || ActiveAgent.config[ENV["RAILS_ENV"]][provider_name.to_s]
+
+        raise "Configuration not found for provider: #{provider_name}" unless config
+
+        config.merge!(options)
+        configure_provider(config)
+      end
+
+      def configure_provider(config)
+        require "active_agent/generation_provider/#{config["service"].underscore}_provider"
+        ActiveAgent::GenerationProvider.const_get("#{config["service"].camelize}Provider").new(config)
+      rescue LoadError
+        raise "Missing generation provider for #{config["service"].inspect}"
+      end
+
+      def generation_provider
+        self.generation_provider = :openai if _generation_provider.nil?
+        _generation_provider
+      end
+
+      def generation_provider_name
+        self.generation_provider = :openai if _generation_provider_name.nil?
+        _generation_provider_name
+      end
+
+      def generation_provider=(name_or_provider)
+        case name_or_provider
+        when Symbol, String
+          provider = configuration(name_or_provider)
+          assign_provider(name_or_provider.to_s, provider)
+        else
+          raise ArgumentError
+        end
+      end
+
+      private
+
+      def assign_provider(provider_name, generation_provider)
+        self._generation_provider_name = provider_name
+        self._generation_provider = generation_provider
+      end
+    end
+
+    def generation_provider
+      self.class.generation_provider
+    end
+  end
+end

data/lib/active_agent/inline_preview_interceptor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ActiveAgent
+  # = Active Agent \InlinePreviewInterceptor
+  #
+  # Implements a agent preview interceptor that converts image tag src attributes
+  # that use inline cid: style URLs to data: style URLs so that they are visible
+  # when previewing an HTML prompt in a web browser.
+  #
+  # This interceptor is enabled by default. To disable it, delete it from the
+  # <tt>ActiveAgent::Base.preview_interceptors</tt> array:
+  #
+  #   ActiveAgent::Base.preview_interceptors.delete(ActiveAgent::InlinePreviewInterceptor)
+  #
+  class InlinePreviewInterceptor
+    PATTERN = /src=(?:"cid:[^"]+"|'cid:[^']+')/i
+
+    include Base64
+
+    def self.previewing_prompt(context) # :nodoc:
+      new(context).transform!
+    end
+
+    def initialize(context) # :nodoc:
+      @context = context
+    end
+
+    def transform! # :nodoc:
+      return context if html_part.blank?
+
+      html_part.body = html_part.decoded.gsub(PATTERN) do |match|
+        if part = find_part(match[9..-2])
+          %(src="#{data_url(part)}")
+        else
+          match
+        end
+      end
+
+      context
+    end
+
+    private
+
+    attr_reader :context
+
+    def html_part
+      @html_part ||= context.html_part
+    end
+
+    def data_url(part)
+      "data:#{part.mime_type};base64,#{strict_encode64(part.body.raw_source)}"
+    end
+
+    def find_part(cid)
+      context.all_parts.find { |p| p.attachment? && p.cid == cid }
+    end
+  end
+end

data/lib/active_agent/log_subscriber.rb

@@ -0,0 +1,44 @@
+# # frozen_string_literal: true
+
+# require "active_support/log_subscriber"
+
+# module ActiveAgent
+#   # = Active Agent \LogSubscriber
+#   #
+#   # Implements the ActiveSupport::LogSubscriber for logging notifications when
+#   # prompt is generated.
+#   class LogSubscriber < ActiveSupport::LogSubscriber
+#     # A prompt was generated.
+#     def deliver(event)
+#       info do
+#         if exception = event.payload[:exception_object]
+#           "Failed delivery of prompt #{event.payload[:message_id]} error_class=#{exception.class} error_message=#{exception.message.inspect}"
+#         elsif event.payload[:perform_deliveries]
+#           "Generated response for prompt #{event.payload[:message_id]} (#{event.duration.round(1)}ms)"
+#         else
+#           "Skipped generation of prompt #{event.payload[:message_id]} as `perform_generation` is false"
+#         end
+#       end
+
+#       debug { event.payload[:mail] }
+#     end
+#     subscribe_log_level :deliver, :debug
+
+#     # An email was generated.
+#     def process(event)
+#       debug do
+#         agent = event.payload[:agent]
+#         action = event.payload[:action]
+#         "#{agent}##{action}: processed outbound mail in #{event.duration.round(1)}ms"
+#       end
+#     end
+#     subscribe_log_level :process, :debug
+
+#     # Use the logger configured for ActionMailer::Base.
+#     def logger
+#       ActionMailer::Base.logger
+#     end
+#   end
+# end
+
+# ActionMailer::LogSubscriber.attach_to :action_mailer

data/lib/active_agent/operation.rb

@@ -0,0 +1,13 @@
+module ActiveAgent
+  class Operation < AbstractController::Base
+    include AbstractController::Rendering
+    include ActionView::Rendering  # Allows rendering of ERB templates without a view context tied to a request
+    append_view_path 'app/views'  # Ensure the controller knows where to look for view templates
+  
+    def process_tool(tool_name, params)
+      send(tool_name, params)  # Dynamically calls the method corresponding to tool_name
+    rescue NoMethodError
+      "Tool not found: #{tool_name}"
+    end
+  end
+end

data/lib/active_agent/parameterized.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Parameterized
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :params
+
+      def params
+        @params ||= {}
+      end
+    end
+
+    module ClassMethods
+      def with(params)
+        ActiveAgent::Parameterized::Agent.new(self, params)
+      end
+    end
+
+    class Agent
+      def initialize(agent, params)
+        @agent = agent
+        @params = params
+      end
+
+      def method_missing(method_name, ...)
+        if @agent.public_instance_methods.include?(method_name)
+          ActiveAgent::Parameterized::Generation.new(@agent, method_name, @params, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        @agent.respond_to?(method, include_all)
+      end
+    end
+
+    class Generation < ActiveAgent::Generation
+      def initialize(agent_class, action, params, ...)
+        super(agent_class, action, ...)
+        @params = params
+      end
+
+      private
+
+      def processed_agent
+        @processed_agent ||= @agent_class.new.tap do |agent|
+          agent.params = @params
+          agent.process @action, *@args
+        end
+      end
+
+      def enqueue_generation(generation_method, options = {})
+        if processed?
+          super
+        else
+          @agent_class.generation_job.set(options).perform_later(
+            @agent_class.name, @action.to_s, params: @params, args: @args
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/preview.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "active_support/descendants_tracker"
+
+module ActiveAgent
+  module Previews # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :preview_paths, instance_writer: false, default: []
+
+      mattr_accessor :show_previews, instance_writer: false
+
+      mattr_accessor :preview_interceptors, instance_writer: false, default: [ActiveAgent::InlinePreviewInterceptor]
+    end
+
+    module ClassMethods
+      # Register one or more Interceptors which will be called before prompt is previewed.
+      def register_preview_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| register_preview_interceptor(interceptor) }
+      end
+
+      # Unregister one or more previously registered Interceptors.
+      def unregister_preview_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| unregister_preview_interceptor(interceptor) }
+      end
+
+      # Register an Interceptor which will be called before prompt is previewed.
+      # Either a class or a string can be passed in as the Interceptor. If a
+      # string is passed in it will be constantized.
+      def register_preview_interceptor(interceptor)
+        preview_interceptor = interceptor_class_for(interceptor)
+
+        unless preview_interceptors.include?(preview_interceptor)
+          preview_interceptors << preview_interceptor
+        end
+      end
+
+      # Unregister a previously registered Interceptor.
+      # Either a class or a string can be passed in as the Interceptor. If a
+      # string is passed in it will be constantized.
+      def unregister_preview_interceptor(interceptor)
+        preview_interceptors.delete(interceptor_class_for(interceptor))
+      end
+
+      private
+
+      def interceptor_class_for(interceptor)
+        case interceptor
+        when String, Symbol
+          interceptor.to_s.camelize.constantize
+        else
+          interceptor
+        end
+      end
+    end
+  end
+
+  class Preview
+    extend ActiveSupport::DescendantsTracker
+
+    attr_reader :params
+
+    def initialize(params = {})
+      @params = params
+    end
+
+    class << self
+      # Returns all agent preview classes.
+      def all
+        load_previews if descendants.empty?
+        descendants.sort_by { |agent| agent.name.titleize }
+      end
+
+      # Returns the prompt object for the given context. The registered preview
+      # interceptors will be informed so that they can transform the message
+      # as they would if the mail was actually being delivered.
+      def call(context, params = {})
+        preview = new(params)
+        prompt = preview.public_send(context)
+        inform_preview_interceptors(prompt)
+        prompt
+      end
+
+      # Returns all of the available prompt previews.
+      def prompts
+        public_instance_methods(false).map(&:to_s).sort
+      end
+
+      # Returns +true+ if the prompt exists.
+      def prompt_exists?(prompt)
+        prompts.include?(prompt)
+      end
+
+      # Returns +true+ if the preview exists.
+      def exists?(preview)
+        all.any? { |p| p.preview_name == preview }
+      end
+
+      # Find a agent preview by its underscored class name.
+      def find(preview)
+        all.find { |p| p.preview_name == preview }
+      end
+
+      # Returns the underscored name of the agent preview without the suffix.
+      def preview_name
+        name.delete_suffix("Preview").underscore
+      end
+
+      private
+
+      def load_previews
+        preview_paths.each do |preview_path|
+          Dir["#{preview_path}/**/*_preview.rb"].sort.each { |file| require file }
+        end
+      end
+
+      def preview_paths
+        Base.preview_paths
+      end
+
+      def show_previews
+        Base.show_previews
+      end
+
+      def inform_preview_interceptors(context)
+        Base.preview_interceptors.each do |interceptor|
+          interceptor.previewing_prompt(context)
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/prompt_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # = Active Agent's Action Prompt \PromptHelper
+  #
+  # Provides helper methods for ActiveAgent::Base that can be used for easily
+  # formatting prompts, accessing agent or prompt instances.
+  module PromptHelper
+    # Access the agent instance.
+    def agent
+      @_controller
+    end
+
+    # Access the prompt instance.
+    def context
+      @_context
+    end
+  end
+end

data/lib/active_agent/queued_generation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module QueuedGeneration
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :generation_job, default: ::ActiveAgent::GenerationJob
+      class_attribute :generate_later_queue_name, default: :agents
+    end
+  end
+end

data/lib/active_agent/railtie.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_job/railtie"
+require "active_agent"
+require "active_agent/engine"
+require "rails"
+require "abstract_controller/railties/routes_helpers"
+
+module ActiveAgent
+  class Railtie < Rails::Railtie # :nodoc:
+    config.active_agent = ActiveSupport::OrderedOptions.new
+    config.active_agent.preview_paths = []
+    config.eager_load_namespaces << ::ActiveAgent
+
+    initializer "active_agent.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_agent] = ActiveAgent.deprecator
+    end
+
+    initializer "active_agent.logger" do
+      ActiveSupport.on_load(:active_agent) { self.logger ||= Rails.logger }
+    end
+
+    initializer "active_agent.set_configs" do |app|
+      paths = app.config.paths
+      options = app.config.active_agent
+
+      options.assets_dir ||= paths["public"].first
+      options.javascripts_dir ||= paths["public/javascripts"].first
+      options.stylesheets_dir ||= paths["public/stylesheets"].first
+      options.show_previews = Rails.env.development? if options.show_previews.nil?
+      options.cache_store ||= Rails.cache
+      options.preview_paths |= ["#{Rails.root}/test/agents/previews"]
+
+      # make sure readers methods get compiled
+      options.asset_host ||= app.config.asset_host
+      options.relative_url_root ||= app.config.relative_url_root
+
+      ActiveSupport.on_load(:active_agent) do
+        include AbstractController::UrlFor
+        extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false)
+        include app.routes.mounted_helpers
+
+        register_interceptors(options.delete(:interceptors))
+        register_preview_interceptors(options.delete(:preview_interceptors))
+        register_observers(options.delete(:observers))
+        self.view_paths = ["#{Rails.root}/app/views"]
+        self.preview_paths |= options[:preview_paths]
+
+        if delivery_job = options.delete(:delivery_job)
+          self.delivery_job = delivery_job.constantize
+        end
+
+        if options.smtp_settings
+          self.smtp_settings = options.smtp_settings
+        end
+
+        options.each { |k, v| send(:"#{k}=", v) }
+      end
+
+      ActiveSupport.on_load(:action_dispatch_integration_test) do
+        include ActiveAgent::TestHelper
+        include ActiveAgent::TestCase::ClearTestDeliveries
+      end
+    end
+
+    initializer "active_agent.set_autoload_paths", before: :set_autoload_paths do |app|
+      options = app.config.active_agent
+      # app.config.paths["test/agents/previews"].concat(options.preview_paths)
+    end
+
+    initializer "active_agent.compile_config_methods" do
+      ActiveSupport.on_load(:active_agent) do
+        config.compile_methods! if config.respond_to?(:compile_methods!)
+      end
+    end
+
+    config.after_initialize do |app|
+      options = app.config.active_agent
+
+      if options.show_previews
+        app.routes.prepend do
+          get "/rails/agents" => "rails/agents#index", :internal => true
+          get "/rails/agents/download/*path" => "rails/agents#download", :internal => true
+          get "/rails/agents/*path" => "rails/agents#preview", :internal => true
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/rescuable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveAgent # :nodoc:
+  # = Active Agent \Rescuable
+  #
+  # Provides
+  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]
+  # for agents. Wraps agent action processing, generation job processing, and prompt
+  # generation to handle configured errors.
+  module Rescuable
+    extend ActiveSupport::Concern
+    include ActiveSupport::Rescuable
+
+    class_methods do
+      def handle_exception(exception) # :nodoc:
+        rescue_with_handler(exception) || raise(exception)
+      end
+    end
+
+    def handle_exceptions # :nodoc:
+      yield
+    rescue => exception
+      rescue_with_handler(exception) || raise
+    end
+
+    private
+
+    def process(...)
+      handle_exceptions do
+        super
+      end
+    end
+  end
+end

data/lib/active_agent/service.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  class Service
+    extend ActiveSupport::Autoload
+    autoload :Configurator
+    attr_accessor :name
+
+    class << self
+      def configure(service_name, configurations)
+        Configurator.build(service_name, configurations)
+      end
+
+      def build(configurator:, name:, service: nil, **service_config) # :nodoc:
+        new(**service_config).tap do |service_instance|
+          service_instance.name = name
+        end
+      end
+    end
+
+    def generate(...)
+      raise NotImplementedError
+    end
+  end
+end