activeagent 0.5.0 → 0.6.0rc2

data/lib/active_agent/generation_provider/error_handling.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module GenerationProvider
+    module ErrorHandling
+      extend ActiveSupport::Concern
+      include ActiveSupport::Rescuable
+
+      included do
+        class_attribute :retry_on_errors, default: []
+        class_attribute :max_retries, default: 3
+        class_attribute :verbose_errors_enabled, default: false
+
+        # Use rescue_from for provider-specific error handling
+        rescue_from StandardError, with: :handle_generation_error
+      end
+
+      def with_error_handling
+        retries = 0
+        begin
+          yield
+        rescue => e
+          if should_retry?(e) && retries < max_retries
+            retries += 1
+            log_retry(e, retries) if verbose_errors?
+            sleep(retry_delay(retries))
+            retry
+          else
+            # Use rescue_with_handler from Rescuable
+            rescue_with_handler(e) || raise
+          end
+        end
+      end
+
+      protected
+
+      def should_retry?(error)
+        return false if retry_on_errors.empty?
+        retry_on_errors.any? { |klass| error.is_a?(klass) }
+      end
+
+      def retry_delay(attempt)
+        # Exponential backoff: 1s, 2s, 4s...
+        2 ** (attempt - 1)
+      end
+
+      def handle_generation_error(error)
+        error_message = format_error_message(error)
+        # Create new error with original backtrace preserved
+        new_error = ActiveAgent::GenerationProvider::Base::GenerationProviderError.new(error_message)
+        new_error.set_backtrace(error.backtrace) if error.respond_to?(:backtrace)
+
+        # Log detailed error if verbose mode is enabled
+        log_error_details(error) if verbose_errors?
+
+        # Instrument the error for LogSubscriber
+        instrument_error(error, new_error)
+
+        raise new_error
+      end
+
+      def format_error_message(error)
+        message = if error.respond_to?(:response)
+          error.response[:body]
+        elsif error.respond_to?(:message)
+          error.message
+        elsif error.respond_to?(:to_s)
+          error.to_s
+        else
+          "An unknown error occurred: #{error.class.name}"
+        end
+
+        # Include error class in verbose mode
+        if verbose_errors?
+          "[#{error.class.name}] #{message}"
+        else
+          message
+        end
+      end
+
+      def verbose_errors?
+        # Check multiple sources for verbose setting (in priority order)
+        # 1. Instance config (highest priority)
+        return true if @config&.dig("verbose_errors")
+
+        # 2. Class-level setting
+        return true if self.class.verbose_errors_enabled
+
+        # 3. ActiveAgent global configuration
+        if defined?(ActiveAgent) && ActiveAgent.respond_to?(:configuration)
+          return true if ActiveAgent.configuration.verbose_generation_errors?
+        end
+
+        # 4. Environment variable (lowest priority)
+        ENV["ACTIVE_AGENT_VERBOSE_ERRORS"] == "true"
+      end
+
+      def log_error_details(error)
+        logger = find_logger
+        return unless logger
+
+        logger.error "[ActiveAgent::GenerationProvider] Error: #{error.class.name}: #{error.message}"
+        if logger.respond_to?(:debug) && error.respond_to?(:backtrace)
+          logger.debug "Backtrace:\n  #{error.backtrace&.first(10)&.join("\n  ")}"
+        end
+      end
+
+      def log_retry(error, attempt)
+        logger = find_logger
+        return unless logger
+
+        message = "[ActiveAgent::GenerationProvider] Retry attempt #{attempt}/#{max_retries} after #{error.class.name}"
+        logger.info message
+      end
+
+      def find_logger
+        # Try multiple logger sources (in priority order)
+        # 1. Instance config
+        return @config["logger"] if @config&.dig("logger")
+
+        # 2. ActiveAgent configuration logger
+        if defined?(ActiveAgent) && ActiveAgent.respond_to?(:configuration)
+          config_logger = ActiveAgent.configuration.generation_provider_logger
+          return config_logger if config_logger
+        end
+
+        # 3. Rails logger
+        return Rails.logger if defined?(Rails) && Rails.logger
+
+        # 4. ActiveAgent::Base logger
+        return ActiveAgent::Base.logger if defined?(ActiveAgent::Base) && ActiveAgent::Base.respond_to?(:logger)
+
+        nil
+      end
+
+      def instrument_error(original_error, wrapped_error)
+        if defined?(ActiveSupport::Notifications)
+          ActiveSupport::Notifications.instrument("error.active_agent", {
+            error_class: original_error.class.name,
+            error_message: original_error.message,
+            wrapped_error: wrapped_error,
+            provider: self.class.name
+          })
+        end
+      end
+
+      module ClassMethods
+        def retry_on(*errors, max_attempts: 3, **options)
+          self.retry_on_errors = errors
+          self.max_retries = max_attempts
+
+          # Also register with rescue_from for more complex handling
+          errors.each do |error_class|
+            rescue_from error_class do |error|
+              # This will be caught by with_error_handling for retry logic
+              raise error
+            end
+          end
+        end
+
+        def enable_verbose_errors!
+          self.verbose_errors_enabled = true
+        end
+      end
+    end
+  end
+end

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,17 +9,29 @@ 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
         @access_token ||= config["api_key"] || config["access_token"] || OpenAI.configuration.access_token || ENV["OPENAI_ACCESS_TOKEN"]
         @organization_id = config["organization_id"] || OpenAI.configuration.organization_id || ENV["OPENAI_ORGANIZATION_ID"]
         @admin_token = config["admin_token"] || OpenAI.configuration.admin_token || ENV["OPENAI_ADMIN_TOKEN"]
-        @client = OpenAI::Client.new(access_token: @access_token, uri_base: @host, organization_id: @organization_id)
+        @client = OpenAI::Client.new(
+          access_token: @access_token,
+          uri_base: @host,
+          organization_id: @organization_id,
+          admin_token: @admin_token,
+          log_errors: Rails.env.development?
+          )
 
         @model_name = config["model"] || "gpt-4o-mini"
       end
@@ -27,84 +39,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 +104,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 +130,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"]