activeagent 1.0.0.rc1 → 1.0.0

data/lib/active_agent/providers/log_subscriber.rb

@@ -4,100 +4,88 @@ require "active_support/log_subscriber"
 
 module ActiveAgent
   module Providers
-    # Log subscriber for ActiveAgent provider operations.
+    # Logs provider operations via ActiveSupport::Notifications events.
     #
-    # This subscriber listens to ActiveSupport::Notifications events published
-    # during provider operations and logs them in a consistent, configurable format.
-    #
-    # Events are automatically instrumented in the providers and can be customized
-    # or disabled through log level configuration.
+    # Subscribes to instrumented provider events and formats them consistently.
+    # Customize by subclassing and attaching your subscriber, or adjust log levels.
     #
     # @example Custom log formatting
-    #   class MyLogSubscriber < ActiveAgent::LogSubscriber
-    #     def prompt_start(event)
-    #       info "🚀 Starting prompt: #{event.payload[:provider]}"
+    #   class MyLogSubscriber < ActiveAgent::Providers::LogSubscriber
+    #     def prompt(event)
+    #       info "🚀 #{event.payload[:provider_module]}: #{event.duration}ms"
     #     end
     #   end
     #
-    #   ActiveAgent::LogSubscriber.detach_from :active_agent_provider
-    #   MyLogSubscriber.attach_to :active_agent_provider
+    #   ActiveAgent::Providers::LogSubscriber.detach_from :active_agent
+    #   MyLogSubscriber.attach_to :active_agent
     class LogSubscriber < ActiveSupport::LogSubscriber
       # self.namespace = "active_agent" # Rails 8.1
 
-      # Logs the start of a prompt request
+      # Logs completed prompt with model, message count, token usage, and duration.
       #
       # @param event [ActiveSupport::Notifications::Event]
-      def prompt_start(event)
+      # @return [void]
+      def prompt(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
+        model           = event.payload[:model]
+        message_count   = event.payload[:message_count]
+        stream          = event.payload[:stream]
+        usage           = event.payload[:usage]
+        finish_reason   = event.payload[:finish_reason]
+        duration        = event.duration.round(1)
 
         debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Starting prompt request"
-        end
-      end
-      # event_log_level :prompt_start, :debug # Rails 8.1
+          parts = [ "[#{trace_id}]", "[ActiveAgent]", "[#{provider_module}]" ]
+          parts << "Prompt completed:"
+          parts << "model=#{model}" if model
+          parts << "messages=#{message_count}"
+          parts << "stream=#{stream}"
 
-      # Logs the start of an embedding request
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def embed_start(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Starting embed request"
-        end
-      end
-      # event_log_level :embed_start, :debug # Rails 8.1
+          if usage
+            tokens = "tokens=#{usage[:input_tokens]}/#{usage[:output_tokens]}"
+            tokens += " (cached: #{usage[:cached_tokens]})" if usage[:cached_tokens]&.positive?
+            tokens += " (reasoning: #{usage[:reasoning_tokens]})" if usage[:reasoning_tokens]&.positive?
+            parts << tokens
+          end
 
-      # Logs request preparation details
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def request_prepared(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        message_count  = event.payload[:message_count]
+          parts << "finish=#{finish_reason}" if finish_reason
+          parts << "#{duration}ms"
 
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Prepared request with #{message_count} message(s)"
+          parts.join(" ")
         end
       end
-      # event_log_level :request_prepared, :debug # Rails 8.1
+      # event_log_level :prompt, :debug # Rails 8.1
 
-      # Logs API call execution
+      # Logs completed embedding with model, input size, and token usage.
       #
       # @param event [ActiveSupport::Notifications::Event]
-      def api_call(event)
-        return unless logger.debug?
-
+      # @return [void]
+      def embed(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
-        streaming       = event.payload[:streaming]
+        model           = event.payload[:model]
+        input_size      = event.payload[:input_size]
+        embedding_count = event.payload[:embedding_count]
+        usage           = event.payload[:usage]
         duration        = event.duration.round(1)
 
         debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] API call completed in #{duration}ms (streaming: #{streaming})"
-        end
-      end
-      # event_log_level :api_call, :debug # Rails 8.1
+          parts = [ "[#{trace_id}]", "[ActiveAgent]", "[#{provider_module}]" ]
+          parts << "Embed completed:"
+          parts << "model=#{model}" if model
+          parts << "inputs=#{input_size}" if input_size
+          parts << "embeddings=#{embedding_count}" if embedding_count
+          parts << "tokens=#{usage[:input_tokens]}" if usage
+          parts << "#{duration}ms"
 
-      # Logs embed API call execution
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def embed_call(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        duration        = event.duration.round(1)
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Embed API call completed in #{duration}ms"
+          parts.join(" ")
         end
       end
-      # event_log_level :embed_call, :debug # Rails 8.1
+      # event_log_level :embed, :debug # Rails 8.1
 
-      # Logs stream opening
-      #
       # @param event [ActiveSupport::Notifications::Event]
+      # @return [void]
       def stream_open(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
@@ -108,9 +96,8 @@ module ActiveAgent
       end
       # event_log_level :stream_open, :debug # Rails 8.1
 
-      # Logs stream closing
-      #
       # @param event [ActiveSupport::Notifications::Event]
+      # @return [void]
       def stream_close(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
@@ -121,210 +108,41 @@ module ActiveAgent
       end
       # event_log_level :stream_close, :debug # Rails 8.1
 
-      # Logs message extraction from API response
-      #
       # @param event [ActiveSupport::Notifications::Event]
-      def messages_extracted(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        message_count   = event.payload[:message_count]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Extracted #{message_count} message(s) from API response"
-        end
-      end
-      # event_log_level :messages_extracted, :debug # Rails 8.1
-
-      # Logs tool/function call processing
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def tool_calls_processing(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        tool_count      = event.payload[:tool_count]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Processing #{tool_count} tool call(s)"
-        end
-      end
-      # event_log_level :tool_calls_processing, :debug # Rails 8.1
-
-      # Logs multi-turn conversation continuation
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def multi_turn_continue(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Continuing multi-turn conversation after tool execution"
-        end
-      end
-      # event_log_level :multi_turn_continue, :debug # Rails 8.1
-
-      # Logs prompt completion
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def prompt_complete(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        message_count   = event.payload[:message_count]
-        duration        = event.duration.round(1)
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Prompt completed with #{message_count} message(s) in stack (total: #{duration}ms)"
-        end
-      end
-      # event_log_level :prompt_complete, :debug # Rails 8.1
-
-      # Logs retry attempts
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def retry_attempt(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        attempt         = event.payload[:attempt]
-        max_retries     = event.payload[:max_retries]
-        exception       = event.payload[:exception]
-        backoff_time    = event.payload[:backoff_time]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}:Retries] Attempt #{attempt}/#{max_retries} failed with #{exception}, retrying in #{backoff_time}s"
-        end
-      end
-      # event_log_level :retry_attempt, :debug # Rails 8.1
-
-      # Logs when max retries are exceeded
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def retry_exhausted(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        max_retries     = event.payload[:max_retries]
-        exception       = event.payload[:exception]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}:Retries] Max retries (#{max_retries}) exceeded for #{exception}"
-        end
-      end
-      # event_log_level :retry_exhausted, :debug # Rails 8.1
-
-      # Logs tool execution
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def tool_execution(event)
+      # @return [void]
+      def tool_call(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
         tool_name       = event.payload[:tool_name]
+        duration        = event.duration.round(1)
 
         debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Executing tool: #{tool_name}"
-        end
-      end
-      # event_log_level :tool_execution, :debug # Rails 8.1
-
-      # Logs tool choice removal
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def tool_choice_removed(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Removing tool_choice constraint after tool execution"
-        end
-      end
-      # event_log_level :tool_choice_removed, :debug # Rails 8.1
-
-      # Logs API request
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def api_request(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        model           = event.payload[:model]
-        streaming       = event.payload[:streaming]
-
-
-        debug do
-          if streaming.nil?
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Executing request to #{model}"
-          else
-            mode = streaming ? "streaming" : "non-streaming"
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Executing #{mode} request to #{model}"
-          end
+          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Tool call: #{tool_name} (#{duration}ms)"
         end
       end
-      # event_log_level :api_request, :debug # Rails 8.1
+      # event_log_level :tool_call, :debug # Rails 8.1
 
-      # Logs stream chunk processing
-      #
       # @param event [ActiveSupport::Notifications::Event]
-      def stream_chunk_processing(event)
+      # @return [void]
+      def stream_chunk(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
         chunk_type      = event.payload[:chunk_type]
 
         debug do
           if chunk_type
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Processing stream chunk: #{chunk_type}"
+            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Stream chunk: #{chunk_type}"
           else
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Processing stream chunk"
+            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Stream chunk"
           end
         end
       end
-      # event_log_level :stream_chunk_processing, :debug # Rails 8.1
+      # event_log_level :stream_chunk, :debug # Rails 8.1
 
-      # Logs stream finished
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def stream_finished(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        finish_reason   = event.payload[:finish_reason]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Stream finished with reason: #{finish_reason}"
-        end
-      end
-      # event_log_level :stream_finished, :debug # Rails 8.1
-
-      # Logs API routing decisions
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def api_routing(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-        api_type        = event.payload[:api_type]
-        api_version     = event.payload[:api_version]
-        has_audio       = event.payload[:has_audio]
-
-        debug do
-          if has_audio
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Routing to #{api_type.to_s.capitalize} API (api_version: #{api_version}, audio: #{has_audio})"
-          else
-            "[#{trace_id}] [ActiveAgent] [#{provider_module}] Routing to #{api_type.to_s.capitalize} API (api_version: #{api_version})"
-          end
-        end
-      end
-      # event_log_level :api_routing, :debug # Rails 8.1
-
-      # Logs embeddings requests
-      #
-      # @param event [ActiveSupport::Notifications::Event]
-      def embeddings_request(event)
-        trace_id        = event.payload[:trace_id]
-        provider_module = event.payload[:provider_module]
-
-        debug do
-          "[#{trace_id}] [ActiveAgent] [#{provider_module}] Executing embeddings request"
-        end
-      end
-      # event_log_level :embeddings_request, :debug # Rails 8.1
-
-      # Logs connection errors
+      # Logs connection failures with service URI and error details.
       #
       # @param event [ActiveSupport::Notifications::Event]
+      # @return [void]
       def connection_error(event)
         trace_id        = event.payload[:trace_id]
         provider_module = event.payload[:provider_module]
@@ -340,8 +158,6 @@ module ActiveAgent
 
       private
 
-      # Use the logger configured for ActiveAgent::Base
-      #
       # @return [Logger]
       def logger
         ActiveAgent::Base.logger
@@ -351,6 +167,8 @@ module ActiveAgent
 end
 
 # region log_subscriber_attach
+# Subscribe to both top-level (.active_agent) and provider-level (.provider.active_agent) events
+ActiveAgent::Providers::LogSubscriber.attach_to :active_agent
 ActiveAgent::Providers::LogSubscriber.attach_to :"provider.active_agent"
 # endregion log_subscriber_attach
 

data/lib/active_agent/providers/mock_provider.rb

@@ -56,20 +56,20 @@ module ActiveAgent
         else
           # Return a complete response
           {
-            id: "mock-#{SecureRandom.hex(8)}",
-            type: "message",
-            role: "assistant",
-            content: [
+            "id" => "mock-#{SecureRandom.hex(8)}",
+            "type" => "message",
+            "role" => "assistant",
+            "content" => [
               {
-                type: "text",
-                text: pig_latin_content
+                "type" => "text",
+                "text" => pig_latin_content
               }
             ],
-            model: parameters[:model] || "mock-model",
-            stop_reason: "end_turn",
-            usage: {
-              input_tokens: content.length,
-              output_tokens: pig_latin_content.length
+            "model" => parameters[:model] || "mock-model",
+            "stop_reason" => "end_turn",
+            "usage" => {
+              "input_tokens" => content.length,
+              "output_tokens" => pig_latin_content.length
             }
           }
         end
@@ -80,27 +80,27 @@ module ActiveAgent
       # Returns random embedding vectors for testing purposes.
       #
       # @param parameters [Hash] The embedding request parameters
-      # @return [Hash] A mock embedding response structure
+      # @return [Hash] A mock embedding response structure with symbol keys
       def api_embed_execute(parameters)
         input = parameters[:input]
         inputs = input.is_a?(Array) ? input : [ input ]
         dimensions = parameters[:dimensions] || 1536
 
         {
-          object: "list",
-          data: inputs.map.with_index do |text, index|
+          "object" => "list",
+          "data" => inputs.map.with_index do |text, index|
             {
-              object: "embedding",
-              index: index,
-              embedding: generate_random_embedding(dimensions)
+              "object" => "embedding",
+              "index" => index,
+              "embedding" => generate_random_embedding(dimensions)
             }
           end,
-          model: parameters[:model] || "mock-embedding-model",
-          usage: {
-            prompt_tokens: inputs.sum { |text| text.to_s.length },
-            total_tokens: inputs.sum { |text| text.to_s.length }
+          "model" => parameters[:model] || "mock-embedding-model",
+          "usage" => {
+            "prompt_tokens" => inputs.sum { |text| text.to_s.length },
+            "total_tokens" => inputs.sum { |text| text.to_s.length }
           }
-        }
+        }.deep_symbolize_keys
       end
 
       # Processes streaming response chunks.
@@ -112,7 +112,7 @@ module ActiveAgent
       def process_stream_chunk(api_response_chunk)
         chunk_type = api_response_chunk[:type]&.to_sym
 
-        instrument("stream_chunk_processing.provider.active_agent", chunk_type: chunk_type)
+        instrument("stream_chunk.active_agent", chunk_type: chunk_type)
 
         broadcast_stream_open