activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/generation_provider/error_handling.rb

@@ -1,167 +0,0 @@
-# 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
-          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

@@ -1,92 +0,0 @@
-# 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

@@ -1,107 +0,0 @@
-# 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)
-        {
-          id: action.id,
-          type: "function",
-          function: {
-            name: action.name,
-            arguments: action.params.is_a?(String) ? action.params : action.params.to_json
-          }
-        }
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/ollama_provider.rb

@@ -1,66 +0,0 @@
-require "openai"
-require_relative "open_ai_provider"
-
-module ActiveAgent
-  module GenerationProvider
-    class OllamaProvider < OpenAIProvider
-      def initialize(config)
-        @config = config
-        @access_token ||= config["api_key"] || config["access_token"] || ENV["OLLAMA_API_KEY"] || ENV["OLLAMA_ACCESS_TOKEN"]
-        @model_name = config["model"]
-        @host = config["host"] || "http://localhost:11434"
-        @api_version = config["api_version"] || "v1"
-        @api_type = config["api_type"] || nil
-        @client = OpenAI::Client.new(uri_base: @host, access_token: @access_token, log_errors: Rails.env.development?, api_version: @api_version, api_type: @api_type)
-      end
-
-      protected
-
-      def format_error_message(error)
-        # Check for various connection-related errors
-        connection_errors = [
-          Errno::ECONNREFUSED,
-          Errno::EADDRNOTAVAIL,
-          Errno::EHOSTUNREACH,
-          Net::OpenTimeout,
-          Net::ReadTimeout,
-          SocketError,
-          Faraday::ConnectionFailed
-        ]
-
-        if connection_errors.any? { |klass| error.is_a?(klass) } ||
-            (error.message&.include?("Failed to open TCP connection") ||
-             error.message&.include?("Connection refused"))
-          "Unable to connect to Ollama at #{@host}. Please ensure Ollama is running on the configured host and port.\n" \
-          "You can start Ollama with: `ollama serve`\n" \
-          "Or update your configuration to point to the correct host."
-        else
-          super
-        end
-      end
-
-      def embeddings_parameters(input: prompt.message.content, model: "nomic-embed-text")
-        {
-          model: @config["embedding_model"] || model,
-          input: input
-        }
-      end
-
-      def embeddings_response(response, request_params = nil)
-        # Ollama can return either format:
-        # 1. OpenAI-compatible: { "data": [{ "embedding": [...] }] }
-        # 2. Native Ollama: { "embedding": [...] }
-        embedding = response.dig("data", 0, "embedding") || response.dig("embedding")
-
-        message = ActiveAgent::ActionPrompt::Message.new(content: embedding, role: "assistant")
-
-        @response = ActiveAgent::GenerationProvider::Response.new(
-          prompt: prompt,
-          message: message,
-          raw_response: response,
-          raw_request: request_params
-        )
-      end
-    end
-  end
-end