activeagent 0.1.1 → 0.2.6.9

data/lib/active_agent/base.rb

@@ -67,11 +67,7 @@ module ActiveAgent
     }.freeze
 
     class << self
-      def prompt(...)
-        new.prompt(...)
-      end
-
-      # Register one or more Observers which will be notified when mail is delivered.
+      # 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
@@ -81,7 +77,7 @@ module ActiveAgent
         observers.flatten.compact.each { |observer| unregister_observer(observer) }
       end
 
-      # Register one or more Interceptors which will be called before mail is sent.
+      # 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
@@ -91,32 +87,32 @@ module ActiveAgent
         interceptors.flatten.compact.each { |interceptor| unregister_interceptor(interceptor) }
       end
 
-      # Register an Observer which will be notified when mail is delivered.
+      # 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)
-        Mail.register_observer(observer_class_for(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)
-        Mail.unregister_observer(observer_class_for(observer))
+        Prompt.unregister_observer(observer_class_for(observer))
       end
 
-      # Register an Interceptor which will be called before mail is sent.
+      # 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)
-        Mail.register_interceptor(observer_class_for(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)
-        Mail.unregister_interceptor(observer_class_for(interceptor))
+        Prompt.unregister_interceptor(observer_class_for(interceptor))
       end
 
       def observer_class_for(value) # :nodoc:
@@ -133,6 +129,8 @@ module ActiveAgent
       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)
@@ -179,13 +177,8 @@ module ActiveAgent
 
       def set_payload_for_prompt(payload, prompt)
         payload[:prompt] = prompt.encoded
-        payload[:agent] = name
+        payload[:agent] = agent_name
         payload[:message_id] = prompt.message_id
-        payload[:subject] = prompt.subject
-        payload[:to] = prompt.to
-        payload[:from] = prompt.from
-        payload[:bcc] = prompt.bcc if prompt.bcc.present?
-        payload[:cc] = prompt.cc if prompt.cc.present?
         payload[:date] = prompt.date
         payload[:perform_generations] = prompt.perform_generations
       end
@@ -203,17 +196,56 @@ module ActiveAgent
       end
     end
 
-    attr_internal :context
+    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
 
     def perform_generation
-      context.options.merge(options)
-      generation_provider.generate(context) if context && generation_provider
+      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)
+      perform_actions(requested_actions: response.message.requested_actions) if response.message.requested_actions.present?
+
+      update_prompt_context(response)
+    end
+
+    def update_prompt_context(response)
+      # response.prompt = prompt_context
+      # response.message = response.messages.last
+      response
+    end
+
+    def perform_actions(requested_actions:)
+      requested_actions.each do |action|
+        perform_action(action)
+      end
+    end
+
+    def perform_action(action)
+      process(action.name, *action.params)
+      prompt_context.messages.last.role = :tool
+      prompt_context.messages.last.action_id = action.id
     end
 
     def initialize
       super
       @_prompt_was_called = false
-      @_context = ActiveAgent::ActionPrompt::Prompt.new(instructions: options[:instructions])
+      @_prompt_context = ActiveAgent::ActionPrompt::Prompt.new(instructions: options[:instructions], options: options)
     end
 
     def process(method_name, *args) # :nodoc:
@@ -225,7 +257,7 @@ module ActiveAgent
 
       ActiveSupport::Notifications.instrument("process.active_agent", payload) do
         super
-        @_context = ActiveAgent::ActionPrompt::Prompt.new unless @_prompt_was_called
+        @_prompt_context = ActiveAgent::ActionPrompt::Prompt.new unless @_prompt_was_called
       end
     end
     ruby2_keywords(:process)
@@ -255,20 +287,12 @@ module ActiveAgent
 
     def headers(args = nil)
       if args
-        @_context.headers(args)
+        @_prompt_context.headers(args)
       else
-        @_context
+        @_prompt_context
       end
     end
 
-    # def attachments
-    #   if @_prompt_was_called
-    #     LateAttachmentsProxy.new(@_context.attachments)
-    #   else
-    #     @_context.attachments
-    #   end
-    # end
-
     class LateAttachmentsProxy < SimpleDelegator
       def inline
         self
@@ -286,31 +310,39 @@ module ActiveAgent
       end
     end
 
+    def prompt_with(*)
+      prompt_context.update_prompt_context(*)
+    end
+
     def prompt(headers = {}, &block)
-      return context if @_prompt_was_called && headers.blank? && !block
+      return prompt_context if @_prompt_was_called && headers.blank? && !block
 
       content_type = headers[:content_type]
 
       headers = apply_defaults(headers)
 
-      context.charset = charset = headers[:charset]
+      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(context, responses)
+      create_parts_from_responses(prompt_context, responses)
 
-      context.content_type = set_content_type(context, content_type, headers[:content_type])
-      context.charset = charset
-      context.actions = headers[:actions] || action_schemas
-      binding.irb
-      context
+      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|
-        JSON.parse render_to_string(locals: {action_name: action}, action: action, formats: :json)
-      end
+        if action != "text_prompt"
+          JSON.parse render_to_string(locals: {action_name: action}, action: action, formats: :json)
+        end
+      end.compact
     end
 
     private
@@ -319,7 +351,7 @@ module ActiveAgent
       if user_content_type.present?
         user_content_type
       else
-        context.content_type || class_default
+        prompt_context.content_type || class_default
       end
     end
 
@@ -350,10 +382,10 @@ module ActiveAgent
       end
     end
 
-    def assign_headers_to_context(context, headers)
+    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| context[k] = v }
+      assignable.each { |k, v| prompt_context[k] = v }
     end
 
     def collect_responses(headers, &)
@@ -385,12 +417,14 @@ module ActiveAgent
       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
+      end.compact
     end
 
     def each_template(paths, name, &)
@@ -402,20 +436,24 @@ module ActiveAgent
       end
     end
 
-    def create_parts_from_responses(context, responses)
-      if responses.size > 1 && false
-        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)
+    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(context, r, context.charset) }
+        responses.each { |r| insert_part(prompt_context, r, prompt_context.charset) }
       end
     end
 
-    def insert_part(container, response, charset)
-      response[:charset] ||= charset
-      container.add_part(response)
+    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

data/lib/active_agent/callbacks.rb

@@ -7,6 +7,7 @@ module ActiveAgent
     included do
       include ActiveSupport::Callbacks
       define_callbacks :generate, skip_after_callbacks_if_terminated: true
+      define_callbacks :stream, skip_after_callbacks_if_terminated: true
     end
 
     module ClassMethods
@@ -26,6 +27,18 @@ module ActiveAgent
       def around_generate(*filters, &)
         set_callback(:generate, :around, *filters, &)
       end
+
+      # Defines a callback for handling streaming responses during generation
+      def on_stream(*filters, &)
+        set_callback(:stream, :before, *filters, &)
+      end
+    end
+
+    # Helper method to run stream callbacks
+    def run_stream_callbacks(message, delta = nil, stop = false)
+      run_callbacks(:stream) do
+        yield(message, delta, stop) if block_given?
+      end
     end
   end
 end

data/lib/active_agent/generation.rb

@@ -11,14 +11,14 @@ module ActiveAgent
     ruby2_keywords(:initialize)
 
     def __getobj__
-      @prompt_context ||= processed_agent.context
+      @prompt_context ||= processed_agent.prompt_context
     end
 
     def __setobj__(prompt_context)
       @prompt_context = prompt_context
     end
 
-    def context
+    def prompt_context
       __getobj__
     end
 
@@ -37,7 +37,7 @@ module ActiveAgent
     def generate_now!
       processed_agent.handle_exceptions do
         processed_agent.run_callbacks(:generate) do
-          processed_agent..perform_generation
+          processed_agent.perform_generation!
         end
       end
     end

data/lib/active_agent/generation_job.rb

@@ -23,7 +23,7 @@ module ActiveAgent
       agent = agent_class.new
       agent.params = params if params
       agent.process(action_name, *args)
-      agent.generate
+      agent.perform_generation
     end
 
     private

data/lib/active_agent/generation_provider/README.md

@@ -1,17 +1,72 @@
 # Active Agent: Generation Provider
 
-This README provides information about the base generation provider class and the generation provider module interfaces in the ActiveAgent library.
+This README provides information about the generation provider interfaces and implementations in the ActiveAgent library.
 
 ## Main Components
 
-Base class - for creating and configuring generation providers.
-Module - for including in your agent classes to provide generation provider functionality.
+- Base class - Abstract class for implementing generation providers
+- OpenAI Provider - Reference implementation using OpenAI's API
+- Response class - Standardized response wrapper
+- Module - For including generation provider functionality in agents
 
-### ActiveAgent::GenerationProvider::Base
+## Core Concepts
 
-The main class for creating and configuring generation providers. It provides the core functionality for creating and managing generation providers.
+### Base Provider Class
 
-#### Core Methods
+The `ActiveAgent::GenerationProvider::Base` class defines the core interface that all providers must implement:
 
-##### initialize(options = {})
-Creates a new generation provider object with the given options.
+```ruby
+def generate(prompt)
+  raise NotImplementedError
+end
+```
+
+### OpenAI Provider Implementation
+
+The OpenAI provider shows how to implement a concrete generation provider:
+
+- Handles authentication and client setup
+- Implements prompt/completion generation
+- Supports streaming responses
+- Handles embeddings generation
+- Manages context updates
+- Processes tool/action calls
+
+### Provider Features
+
+- Configuration - Providers accept config options for API keys, models, etc
+- Streaming - Optional streaming support for realtime responses
+- Action handling - Support for function/tool calling
+- Error handling - Standardized error handling via GenerationProviderError
+- Context management - Tracks conversation context and message history
+
+### Response Handling
+
+The Response class wraps provider responses with a consistent interface:
+
+```ruby
+Response.new(
+  prompt: prompt,    # Original prompt
+  message: message,  # Generated response
+  raw_response: raw  # Provider-specific response
+)
+```
+
+## Usage Example
+
+```ruby
+# Configure provider
+provider = ActiveAgent::GenerationProvider::OpenAIProvider.new(
+  "api_key" => ENV["OPENAI_API_KEY"],
+  "model" => "gpt-4"
+)
+
+# Generate completion
+response = provider.generate(prompt)
+
+# Access response
+response.message.content    # Generated text
+response.raw_response      # Raw provider response
+```
+
+See the OpenAI provider implementation for a complete reference example.

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -0,0 +1,142 @@
+# lib/active_agent/generation_provider/anthropic_provider.rb
+
+require "anthropic"
+require "active_agent/action_prompt/action"
+require_relative "base"
+require_relative "response"
+
+module ActiveAgent
+  module GenerationProvider
+    class AnthropicProvider < Base
+      def initialize(config)
+        super
+        @api_key = config["api_key"]
+        @model_name = config["model"] || "claude-3-5-sonnet-20240620"
+        @client = Anthropic::Client.new(access_token: @api_key)
+      end
+
+      def generate(prompt)
+        @prompt = prompt
+
+        chat_prompt(parameters: prompt_parameters)
+      rescue => e
+        raise GenerationProviderError, e.message
+      end
+
+      def chat_prompt(parameters: prompt_parameters)
+        parameters[:stream] = provider_stream if prompt.options[:stream] || config["stream"]
+
+        chat_response(@client.messages(parameters))
+      end
+
+      private
+
+      def provider_stream
+        agent_stream = prompt.options[:stream]
+        message = ActiveAgent::ActionPrompt::Message.new(content: "", role: :assistant)
+        @response = ActiveAgent::GenerationProvider::Response.new(prompt: prompt, message:)
+
+        proc do |chunk|
+          if new_content = chunk.dig(:delta, :text)
+            message.content += new_content
+            agent_stream.call(message) if agent_stream.respond_to?(:call)
+          end
+        end
+      end
+
+      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @config["temperature"] || 0.7, tools: @prompt.actions)
+        params = {
+          model: model,
+          messages: provider_messages(messages),
+          temperature: temperature,
+          max_tokens: 4096
+        }
+
+        if tools&.present?
+          params[:tools] = format_tools(tools)
+        end
+
+        params
+      end
+
+      def format_tools(tools)
+        tools.map do |tool|
+          {
+            name: tool[:name] || tool[:function][:name],
+            description: tool[:description],
+            input_schema: tool[:parameters]
+          }
+        end
+      end
+
+      def provider_messages(messages)
+        messages.map do |message|
+          provider_message = {
+            role: convert_role(message.role),
+            content: []
+          }
+
+          provider_message[:content] << if message.content_type == "image_url"
+            {
+              type: "image",
+              source: {
+                type: "url",
+                url: message.content
+              }
+            }
+          else
+            {
+              type: "text",
+              text: message.content
+            }
+          end
+
+          provider_message
+        end
+      end
+
+      def convert_role(role)
+        case role.to_s
+        when "system" then "system"
+        when "user" then "user"
+        when "assistant" then "assistant"
+        when "tool", "function" then "assistant"
+        else "user"
+        end
+      end
+
+      def chat_response(response)
+        return @response if prompt.options[:stream]
+
+        content = response.content.first[:text]
+
+        message = ActiveAgent::ActionPrompt::Message.new(
+          content: content,
+          role: "assistant",
+          action_requested: response.stop_reason == "tool_use",
+          requested_actions: handle_actions(response.tool_use)
+        )
+
+        update_context(prompt: prompt, message: message, response: response)
+
+        @response = ActiveAgent::GenerationProvider::Response.new(
+          prompt: prompt,
+          message: message,
+          raw_response: response
+        )
+      end
+
+      def handle_actions(tool_uses)
+        return unless tool_uses&.present?
+
+        tool_uses.map do |tool_use|
+          ActiveAgent::ActionPrompt::Action.new(
+            id: tool_use[:id],
+            name: tool_use[:name],
+            params: tool_use[:input]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider/base.rb

@@ -4,7 +4,7 @@ module ActiveAgent
   module GenerationProvider
     class Base
       class GenerationProviderError < StandardError; end
-      attr_reader :client, :config, :prompt
+      attr_reader :client, :config, :prompt, :response
 
       def initialize(config)
         @config = config
@@ -19,10 +19,15 @@ module ActiveAgent
       private
 
       def handle_response(response)
-        ActiveAgent::GenerationProvider::Response.new(message:, raw_response: response)
+        @response = ActiveAgent::GenerationProvider::Response.new(message:, raw_response: response)
         raise NotImplementedError, "Subclasses must implement the 'handle_response' method"
       end
 
+      def update_context(prompt:, message:, response:)
+        prompt.message = message
+        prompt.messages << message
+      end
+
       protected
 
       def prompt_parameters