activeagent 0.5.0rc3 → 0.6.0rc1

data/lib/active_agent/generation_provider/log_subscriber.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module ActiveAgent
+  module GenerationProvider
+    # = Generation Provider \\LogSubscriber
+    #
+    # Implements the ActiveSupport::LogSubscriber for logging notifications when
+    # generation providers make API calls and handle responses.
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      # A generation request was made
+      def generate(event)
+        info do
+          provider = event.payload[:provider]
+          model = event.payload[:model]
+
+          if exception = event.payload[:exception_object]
+            "Failed generation with #{provider} model=#{model} error_class=#{exception.class} error_message=#{exception.message.inspect}"
+          else
+            "Generated response with #{provider} model=#{model} (#{event.duration.round(1)}ms)"
+          end
+        end
+
+        debug { event.payload[:prompt] } if event.payload[:prompt]
+      end
+      subscribe_log_level :generate, :debug
+
+      # Streaming chunk received
+      def stream_chunk(event)
+        debug do
+          provider = event.payload[:provider]
+          chunk_size = event.payload[:chunk_size]
+          "#{provider}: received stream chunk (#{chunk_size} bytes)"
+        end
+      end
+      subscribe_log_level :stream_chunk, :debug
+
+      # Tool/function call executed
+      def tool_call(event)
+        info do
+          tool_name = event.payload[:tool_name]
+          tool_id = event.payload[:tool_id]
+
+          if exception = event.payload[:exception_object]
+            "Failed tool call #{tool_name} id=#{tool_id} error=#{exception.class}"
+          else
+            "Executed tool call #{tool_name} id=#{tool_id} (#{event.duration.round(1)}ms)"
+          end
+        end
+      end
+      subscribe_log_level :tool_call, :debug
+
+      # Retry attempt
+      def retry(event)
+        warn do
+          provider = event.payload[:provider]
+          attempt = event.payload[:attempt]
+          max_attempts = event.payload[:max_attempts]
+          error_class = event.payload[:error_class]
+
+          "#{provider}: Retry attempt #{attempt}/#{max_attempts} after #{error_class}"
+        end
+      end
+      subscribe_log_level :retry, :warn
+
+      # Error occurred
+      def error(event)
+        error do
+          provider = event.payload[:provider]
+          error_class = event.payload[:error_class]
+          error_message = event.payload[:error_message]
+
+          "#{provider}: Error #{error_class} - #{error_message}"
+        end
+      end
+      subscribe_log_level :error, :error
+
+      # Use the logger configured for ActiveAgent::Base if available
+      def logger
+        if defined?(ActiveAgent::Base) && ActiveAgent::Base.respond_to?(:logger)
+          ActiveAgent::Base.logger
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+# Attach to active_agent.generation_provider namespace
+ActiveAgent::GenerationProvider::LogSubscriber.attach_to :"active_agent.generation_provider"

data/lib/active_agent/generation_provider/message_formatting.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    module MessageFormatting
+      extend ActiveSupport::Concern
+
+      def provider_messages(messages)
+        messages.map do |message|
+          format_message(message)
+        end
+      end
+
+      protected
+
+      def format_message(message)
+        base_message = {
+          role: convert_role(message.role),
+          content: format_content(message)
+        }
+
+        add_tool_fields(base_message, message)
+        add_metadata_fields(base_message, message)
+
+        base_message.compact
+      end
+
+      def convert_role(role)
+        # Default role conversion - override in provider for specific mappings
+        role.to_s
+      end
+
+      def format_content(message)
+        # Handle multimodal content
+        case message.content_type
+        when "image_url"
+          format_image_content(message)
+        when "multipart/mixed", "array"
+          format_multimodal_content(message)
+        else
+          message.content
+        end
+      end
+
+      def format_image_content(message)
+        # Default implementation - override in provider
+        message.content
+      end
+
+      def format_multimodal_content(message)
+        # Default implementation for multimodal content
+        if message.content.is_a?(Array)
+          message.content.map do |item|
+            format_content_item(item)
+          end
+        else
+          message.content
+        end
+      end
+
+      def format_content_item(item)
+        # Format individual content items in multimodal messages
+        # Override in provider for specific formatting
+        item
+      end
+
+      def add_tool_fields(base_message, message)
+        # Add tool-specific fields based on role
+        case message.role.to_s
+        when "assistant"
+          if message.action_requested && message.requested_actions.any?
+            base_message[:tool_calls] = format_tool_calls(message.requested_actions)
+          elsif message.raw_actions.present? && message.raw_actions.is_a?(Array)
+            base_message[:tool_calls] = message.raw_actions
+          end
+        when "tool"
+          base_message[:tool_call_id] = message.action_id if message.action_id
+          base_message[:name] = message.action_name if message.action_name
+        end
+      end
+
+      def add_metadata_fields(base_message, message)
+        # Override to add provider-specific metadata
+        # For example: message IDs, timestamps, etc.
+      end
+
+      def format_tool_calls(actions)
+        # Default implementation - override in provider for specific format
+        actions.map do |action|
+          format_single_tool_call(action)
+        end
+      end
+
+      def format_single_tool_call(action)
+        # Default tool call format (OpenAI style)
+        {
+          type: "function",
+          function: {
+            name: action.name,
+            arguments: action.params.is_a?(String) ? action.params : action.params.to_json
+          },
+          id: action.id
+        }
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -1,5 +1,5 @@
 begin
-  gem "ruby-openai", "~> 8.1.0"
+  gem "ruby-openai", "~> 8.2.0"
   require "openai"
 rescue LoadError
   raise LoadError, "The 'ruby-openai' gem is required for OpenAIProvider. Please add it to your Gemfile and run `bundle install`."
@@ -9,10 +9,16 @@ require "active_agent/action_prompt/action"
 require_relative "base"
 require_relative "response"
 require_relative "responses_adapter"
+require_relative "stream_processing"
+require_relative "message_formatting"
+require_relative "tool_management"
 
 module ActiveAgent
   module GenerationProvider
     class OpenAIProvider < Base
+      include StreamProcessing
+      include MessageFormatting
+      include ToolManagement
       def initialize(config)
         super
         @host = config["host"] || nil
@@ -27,84 +33,58 @@ module ActiveAgent
       def generate(prompt)
         @prompt = prompt
 
-        if @prompt.multimodal? || @prompt.content_type == "multipart/mixed"
-          responses_prompt(parameters: responses_parameters)
-        else
-          chat_prompt(parameters: prompt_parameters)
+        with_error_handling do
+          if @prompt.multimodal? || @prompt.content_type == "multipart/mixed"
+            responses_prompt(parameters: responses_parameters)
+          else
+            chat_prompt(parameters: prompt_parameters)
+          end
         end
-      rescue => e
-        error_message = e.respond_to?(:message) ? e.message : e.to_s
-        raise GenerationProviderError, error_message
       end
 
       def embed(prompt)
         @prompt = prompt
 
-        embeddings_prompt(parameters: embeddings_parameters)
-      rescue => e
-        error_message = e.respond_to?(:message) ? e.message : e.to_s
-        raise GenerationProviderError, error_message
+        with_error_handling do
+          embeddings_prompt(parameters: embeddings_parameters)
+        end
       end
 
-      private
-
-      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?
-            message.generation_id = chunk.dig("id")
-            message.content += new_content
-
-            agent_stream.call(message, new_content, false, prompt.action_name) 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", "role")
-            message = handle_message(chunk.dig("choices", 0, "delta"))
-            prompt.messages << message
-            @response = ActiveAgent::GenerationProvider::Response.new(prompt:, message:)
-          end
+      protected
+
+      # Override from StreamProcessing module
+      def process_stream_chunk(chunk, message, agent_stream)
+        new_content = chunk.dig("choices", 0, "delta", "content")
+        if new_content && !new_content.blank?
+          message.generation_id = chunk.dig("id")
+          message.content += new_content
+          # Call agent_stream directly without the block to avoid double execution
+          agent_stream&.call(message, new_content, false, prompt.action_name)
+        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:)
+        end
 
-          agent_stream.call(message, nil, true, prompt.action_name) do |message|
-            yield message, nil if block_given?
-          end
+        if chunk.dig("choices", 0, "finish_reason")
+          finalize_stream(message, agent_stream)
         end
       end
 
-      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions)
-        {
-          model: model,
-          messages: provider_messages(messages),
-          temperature: temperature,
-          max_tokens: @prompt.options[:max_tokens] || @config["max_tokens"],
-          tools: tools.presence
-        }.compact
+      # Override from MessageFormatting module to handle OpenAI image format
+      def format_image_content(message)
+        [ {
+          type: "image_url",
+          image_url: { url: message.content }
+        } ]
       end
 
-      def provider_messages(messages)
-        messages.map do |message|
-          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" || message.content[0..4] == "data:"
-            provider_message[:type] = "image_url"
-            provider_message[:image_url] = { url: message.content }
-          end
-          provider_message
-        end
-      end
+      private
+
+      # Now using modules, but we can override build_provider_parameters for OpenAI-specific needs
+      # The prompt_parameters method comes from ParameterBuilder module
+      # The format_tools method comes from ToolManagement module
+      # The provider_messages method comes from MessageFormatting module
 
       def chat_response(response)
         return @response if prompt.options[:stream]
@@ -118,7 +98,7 @@ module ActiveAgent
       end
 
       def responses_response(response)
-        message_json = response.dig("output", 0)
+        message_json = response["output"].find { |output_item| output_item["type"] == "message" }
         message_json["id"] = response.dig("id") if message_json["id"].blank?
 
         message = ActiveAgent::ActionPrompt::Message.new(
@@ -144,20 +124,7 @@ module ActiveAgent
         )
       end
 
-      def handle_actions(tool_calls)
-        return [] if tool_calls.nil? || tool_calls.empty?
-
-        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 })
-
-          ActiveAgent::ActionPrompt::Action.new(
-            id: tool_call["id"],
-            name: tool_call.dig("function", "name"),
-            params: args
-          )
-        end.compact
-      end
+      # handle_actions is now provided by ToolManagement module
 
       def chat_prompt(parameters: prompt_parameters)
         parameters[:stream] = provider_stream if prompt.options[:stream] || config["stream"]