active_harness 0.2.21 → 0.2.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de49ac66334a5feb91a5d5f0314ab2b9b3460a5d3a549f08b77538677eae619b
-  data.tar.gz: 0bffb6e77d1b8def25121b144dbc956c2c1b0c684826910e3dd0a66ab595a73e
+  metadata.gz: 0bf8ac57d79582b07a2d82b29be4541fcaf10b3ee8492d362d6ac10f2843537d
+  data.tar.gz: cabffcc74dd594c5222a8e0233aa9d5f7276d65cfa06848d3e2684e19efe393e
 SHA512:
-  metadata.gz: e51c5ab8c3911d2597f6269f695c2f4992f960d771b4284fdd27121939aca14dfea53e568ecbfc069af26b405725106c18b3beebf0232e751ed8144b3134cea7
-  data.tar.gz: ea95a9f48993b4dc930addeee4260e6056815ec48d3c2534a6bf6f5001168cad2104fcd988c98e442f940f32faa4161f9b59a4692bc6fa3adf7655a221d5d56b
+  metadata.gz: '018677f5498399d22c2a1b497649e4676023eae7b2578b8b0c13962b1c443970f20e2af5e7ca15051f75d2903287ed9f12012407cf9a671ad1d5d688d8def153'
+  data.tar.gz: 5219e6c2a208ff1a2215a71d924c24ade46b6abebc94e9a21c7a36d931d9e32919e7ddc5b054ff7bb616b46057761138aa1a01ce21e66ef6978bb5802304cabe

data/lib/active_harness/agent/hooks.rb

@@ -32,7 +32,7 @@ module ActiveHarness
         end
 
         agent_config[:hooks] ||= {}
-        agent_config[:hooks][event] = block
+        (agent_config[:hooks][event] ||= []) << block
       end
 
       # Rails-style aliases for +on+:
@@ -59,27 +59,20 @@ module ActiveHarness
       end
     end
 
+    include Core::HookRunner
+
     private
 
     def run_hook(event, *args)
-      hooks = @config[:hooks] || {}
-      return unless hooks[event]
-
-      if args.any?
-        instance_exec(*args, &hooks[event])
-      else
-        instance_eval(&hooks[event])
-      end
+      run_hooks(@config[:hooks] || {}, event, *args)
     end
 
     # Unified internal method: fires the DSL hook AND the external event_stream lambda.
     # Consistent with Tribunal#fire and Pipeline#fire.
     def fire(event, *args)
-      result = run_hook(event, *args)
+      run_hook(event, *args)
       @event_stream&.call(event, *args)
-      result
     rescue IOError, ActionController::Live::ClientDisconnected
-      result
     end
   end
 end

data/lib/active_harness/agent.rb

@@ -10,9 +10,20 @@ module ActiveHarness
       #
       #   SupportAgent.call(input: "Hi")
       #   SupportAgent.call(input: "Hi", context: { user_id: 42 })
-      #   SupportAgent.call(input: "Hi", memory: memory)
-      def call(input: nil, context: {}, models: nil, memory: nil, streams: {})
-        new(input: input, context: context, models: models, memory: memory, streams: streams).call
+      def call(
+        input:   nil,
+        context: {},
+        params:  {},
+        models:  nil,
+        streams: {}
+      )
+        new(
+          input:   input,
+          context: context,
+          params:  params,
+          models:  models,
+          streams: streams
+        ).call
       end
 
       # Each subclass gets its own isolated config hash.
@@ -36,28 +47,33 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_accessor :input, :context
-    attr_reader   :result, :token_stream, :event_stream
+    attr_accessor :input,
+                  :context,
+                  :params
+    attr_reader   :result,
+                  :token_stream,
+                  :event_stream
 
     def models=(list)
       @models_override = Array(list)
       @model_list_proxy = nil
     end
 
-    def memory=(obj)
-      @memory = obj
-    end
-
-    def initialize(input: nil, context: {}, models: nil, memory: nil, streams: {})
+    def initialize(
+      input:   nil,
+      context: {},
+      params:  {},
+      models:  nil,
+      streams: {}
+    )
       @input           = input
       @config          = self.class.agent_config
       normalize_input!
       @context         = context
+      @params          = params
       @models_override = Array(models) if models
       @token_stream    = streams[:token]
       @event_stream    = streams[:agent]
-      # memory: can be passed directly or via context[:memory]
-      @memory = memory || @context[:memory]
       fire(:setup)
     end
 
@@ -76,9 +92,8 @@ module ActiveHarness
         @token_stream = streams[:token] if streams.key?(:token)
         @event_stream = streams[:agent] if streams.key?(:agent)
       end
-      @memory&.load
-      @system_prompt = resolve_system_prompt
       fire(:before_call)
+      @system_prompt = resolve_system_prompt
       attempts = []
 
       cfg = ActiveHarness.config
@@ -92,7 +107,6 @@ module ActiveHarness
         response = retry_policy.run { attempt_model(entry, @system_prompt) }
         elapsed  = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round(3)
         result   = build_result(response, entry, attempts, elapsed)
-        save_to_memory(result)
         fire(:after_call, result)
         @result = result
         return self
@@ -145,21 +159,6 @@ module ActiveHarness
       )
     end
 
-    # Auto-save to memory if no manual record was done in after_call hook.
-    # Hooks fire after this method — if a hook calls memory.record manually,
-    # the automatic save here is still the first save (hook overrides are additive).
-    # To suppress auto-save, set @memory_auto_saved in the hook.
-    def save_to_memory(result)
-      return unless @memory
-
-      @memory.record(
-        request:  @input,
-        response: result.output,
-        agent:    self.class.name,
-        model:    result.model
-      )
-    end
-
     def normalize_input!
       return if @config.fetch(:normalize_input, true) == false
       @input = @input&.strip&.gsub(/\s+/, " ")

data/lib/active_harness/core/hooks.rb

@@ -0,0 +1,26 @@
+module ActiveHarness
+  module Core
+    # Shared hook execution logic included by Agent, Tribunal, and Pipeline.
+    #
+    # Hooks are stored in arrays so multiple +on+/+before+/+after+/+callback+
+    # calls with the same event name accumulate — later registrations append
+    # rather than overwrite. This lets modules register default hooks without
+    # blocking user-defined hooks on the same event.
+    #
+    #   class MyAgent < ActiveHarness::Agent
+    #     include SomeTracingConcern   # registers before(:call) internally
+    #     before(:call) { ... }        # appends — both hooks run in order
+    #   end
+    module HookRunner
+      private
+
+      # Execute every block registered for +event+, passing +args+ to each.
+      # Blocks run in the receiver's instance context (instance_exec / instance_eval).
+      def run_hooks(hooks_hash, event, *args)
+        Array(hooks_hash[event]).each do |blk|
+          args.any? ? instance_exec(*args, &blk) : instance_eval(&blk)
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/pipeline/hooks.rb

@@ -22,13 +22,13 @@ module ActiveHarness
               "Per-step hooks support: #{VALID_STEP_HOOKS.join(", ")}. Got :#{event}"
           end
           pipeline_config[:step_hooks][step_name] ||= {}
-          pipeline_config[:step_hooks][step_name][event] = block
+          (pipeline_config[:step_hooks][step_name][event] ||= []) << block
         else
           unless VALID_HOOKS.include?(event)
             raise ArgumentError,
               "Unknown Pipeline hook :#{event}. Valid: #{VALID_HOOKS.join(", ")}"
           end
-          pipeline_config[:hooks][event] = block
+          (pipeline_config[:hooks][event] ||= []) << block
         end
       end
 
@@ -56,12 +56,13 @@ module ActiveHarness
       end
     end
 
+    include Core::HookRunner
+
     private
 
     # Fires global hook AND pipeline_event_stream. Consistent with Agent#fire and Tribunal#fire.
     def fire(event, step_name, data, config)
-      blk = config[:hooks][event]
-      instance_exec(step_name, data, &blk) if blk
+      run_hooks(config[:hooks], event, step_name, data)
       @pipeline_event_stream&.call(event, step_name, data)
     rescue IOError, ActionController::Live::ClientDisconnected
       nil
@@ -70,8 +71,7 @@ module ActiveHarness
     # Per-step hook: receives (data) only — not forwarded to pipeline_event_stream
     # (global fire already covers the step event with step_name context).
     def fire_step(event, step_name, data, config)
-      blk = config[:step_hooks][step_name]&.dig(event)
-      instance_exec(data, &blk) if blk
+      run_hooks(config[:step_hooks][step_name] || {}, event, data)
     end
   end
 end

data/lib/active_harness/pipeline.rb

@@ -51,39 +51,83 @@ module ActiveHarness
       end
 
       def pipeline_config
-        @pipeline_config ||= { steps: [], hooks: {}, step_hooks: {} }
+        @pipeline_config ||= { steps: [], hooks: {}, step_hooks: {}, streams: {} }
       end
 
       # Each subclass gets its own isolated config.
       def inherited(subclass)
         subclass.instance_variable_set(
           :@pipeline_config,
-          { steps: [], hooks: {}, step_hooks: {} }
+          { steps: [], hooks: {}, step_hooks: {}, streams: {} }
         )
       end
+
+      # Class-level event stream handlers — fired for every matching event from
+      # any agent or tribunal executed within this pipeline (including agents
+      # running inside tribunals). Multiple blocks can be registered; all fire.
+      #
+      # The handler receives the same (event, *args) signature that the runtime
+      # streams: { agent: lambda } would receive.
+      #
+      #   on_agent_event do |event, result|
+      #     Rails.logger.info "[Agent #{event}] #{result.model}" if event == :after_call
+      #   end
+      #
+      #   on_tribunal_event do |event, verdict|
+      #     Rails.logger.info "[Tribunal #{event}] verdict=#{verdict}" if event == :after_verdict
+      #   end
+      #
+      #   on_pipeline_event do |event, step_name, _data|
+      #     Rails.logger.info "[Pipeline #{event}] step=#{step_name}"
+      #   end
+      def on_agent_event(&block)
+        (pipeline_config[:streams][:agent] ||= []) << block
+      end
+
+      def on_tribunal_event(&block)
+        (pipeline_config[:streams][:tribunal] ||= []) << block
+      end
+
+      def on_pipeline_event(&block)
+        (pipeline_config[:streams][:pipeline] ||= []) << block
+      end
     end
 
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_reader :original_input, :output, :stopped_at, :stop_reason,
-                :execution_time, :step_results, :context
-    attr_writer :context
+    attr_reader   :original_input,
+                  :output,
+                  :stopped_at,
+                  :stop_reason,
+                  :execution_time,
+                  :step_results,
+                  :context
+    attr_writer   :context
+    attr_accessor :params
 
     def input=(value)
       @original_input = value
       @payload        = value
     end
 
-    def initialize(input:, context: {}, memory: nil, streams: {})
+    def initialize(
+      input:,
+      context: {},
+      params:  {},
+      memory:  nil,
+      streams: {}
+    )
       @original_input        = input
       @payload               = input
       @context               = context.dup
+      @params                = params
       @memory                = memory
       @token_stream          = streams[:token]
-      @agent_event_stream    = streams[:agent]
-      @tribunal_event_stream = streams[:tribunal]
-      @pipeline_event_stream = streams[:pipeline]
+      class_streams          = self.class.pipeline_config[:streams] || {}
+      @agent_event_stream    = merge_stream(streams[:agent],    class_streams[:agent])
+      @tribunal_event_stream = merge_stream(streams[:tribunal], class_streams[:tribunal])
+      @pipeline_event_stream = merge_stream(streams[:pipeline], class_streams[:pipeline])
       @step_results          = {}
       @stopped               = false
       @stopped_at            = nil
@@ -120,8 +164,7 @@ module ActiveHarness
           @stopped     = true
           @stopped_at  = step.name
           @stop_reason = result
-          blk = config[:hooks][:stopped]
-          instance_exec(step.name, result, &blk) if blk
+          run_hooks(config[:hooks], :stopped, step.name, result)
           @pipeline_event_stream&.call(:stopped, step.name, result)
           break
         end
@@ -138,8 +181,7 @@ module ActiveHarness
         )
 
         last_result = @step_results[@step_results.keys.last]
-        blk = config[:hooks][:complete]
-        instance_exec(last_result, &blk) if blk
+        run_hooks(config[:hooks], :complete, last_result)
         @pipeline_event_stream&.call(:complete, last_result)
       end
 
@@ -148,12 +190,32 @@ module ActiveHarness
 
     private
 
+    # Combines a runtime-passed stream lambda with zero or more class-level handler
+    # blocks registered via on_agent_event / on_tribunal_event / on_pipeline_event.
+    # Returns nil when there are no handlers at all, preserving the existing
+    # "no stream" fast path in agents and tribunals.
+    #
+    # Each class-level handler is evaluated via instance_exec so that blocks
+    # written in the pipeline class body can access pipeline instance variables
+    # (e.g. @otel_pipeline_span, @params) and call pipeline instance methods.
+    def merge_stream(passed_in, class_handlers)
+      class_handlers = Array(class_handlers).compact
+      return passed_in if class_handlers.empty?
+
+      pipeline_instance = self
+      ->(event, *args) {
+        class_handlers.each { |h| pipeline_instance.instance_exec(event, *args, &h) }
+        passed_in&.call(event, *args)
+      }
+    end
+
     def execute_step(step)
       if step.tribunal?
         agent_streams = { token: @token_stream, agent: @agent_event_stream, tribunal: @tribunal_event_stream }.compact
         step.agent_class.new(
           input:    @payload,
           context:  @context.dup,
+          params:   @params,
           streams:  agent_streams
         ).call
       else
@@ -161,6 +223,7 @@ module ActiveHarness
         step.agent_class.new(
           input:    @payload,
           context:  @context.dup,
+          params:   @params,
           streams:  agent_streams
         ).call.result
       end

data/lib/active_harness/tribunal/hooks.rb

@@ -26,7 +26,7 @@ module ActiveHarness
             "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.map { |h| ":#{h}" }.join(", ")}"
         end
 
-        tribunal_config[:hooks][event] = block
+        (tribunal_config[:hooks][event] ||= []) << block
       end
 
       # Rails-style aliases for +on+:
@@ -51,7 +51,7 @@ module ActiveHarness
       end
     end
 
-    # Instance-level hook registration — overrides class-level hooks for this instance.
+    # Instance-level hook registration — appends to class-level hooks for this event.
     # :before_verdict is a transform hook: its return value replaces the results array
     # passed to the process block.
     def on(event, &block)
@@ -60,20 +60,16 @@ module ActiveHarness
           "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.map { |h| ":#{h}" }.join(", ")}"
       end
 
-      @hooks[event] = block
+      (@hooks[event] ||= []) << block
       self
     end
 
+    include Core::HookRunner
+
     private
 
     def run_hook(event, *args)
-      return unless @hooks[event]
-
-      if args.any?
-        instance_exec(*args, &@hooks[event])
-      else
-        instance_eval(&@hooks[event])
-      end
+      run_hooks(@hooks, event, *args)
     end
 
     # Fire the DSL-registered hook AND the external tribunal_event_stream lambda (if set).
@@ -84,12 +80,10 @@ module ActiveHarness
       nil
     end
 
-    # Like run_hook but uses the return value to replace the passed value.
+    # Like run_hook but chains all blocks, passing each return value to the next.
     # Used by :before_verdict to allow results transformation before verdict computation.
     def transform_hook(event, value)
-      return value unless @hooks[event]
-
-      instance_exec(value, &@hooks[event])
+      Array(@hooks[event]).reduce(value) { |val, blk| instance_exec(val, &blk) }
     end
   end
 end

data/lib/active_harness/tribunal.rb

@@ -46,24 +46,39 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_accessor :input, :context
-    attr_reader :results, :errors, :verdict, :execution_time, :agent_execution_times,
-                :token_stream, :agent_event_stream, :tribunal_event_stream
-
-    def initialize(input: nil, context: {}, agents: nil, timeout: 7,
-                   streams: {},
-                   may_fail: :_unset)
+    attr_accessor :input,
+                  :context,
+                  :params
+    attr_reader   :results,
+                  :errors,
+                  :verdict,
+                  :execution_time,
+                  :agent_execution_times,
+                  :token_stream,
+                  :agent_event_stream,
+                  :tribunal_event_stream
+
+    def initialize(
+      input:    nil,
+      context:  {},
+      params:   {},
+      agents:   nil,
+      timeout:  7,
+      streams:  {},
+      may_fail: :_unset
+    )
       config = self.class.tribunal_config
 
       @input                 = input
       @context               = context
+      @params                = params
       @agents                = agents || config[:agents]
       @timeout               = timeout
       @process_block         = config[:process]
       @strategy              = config[:strategy]
       @evaluate_block        = config[:evaluate_block]
       @may_fail              = may_fail == :_unset ? config[:may_fail] : may_fail
-      @hooks                 = config[:hooks].dup
+      @hooks                 = config[:hooks].transform_values { |v| Array(v).dup }
       @token_stream          = streams[:token]
       @agent_event_stream    = streams[:agent]
       @tribunal_event_stream = streams[:tribunal]
@@ -155,7 +170,7 @@ module ActiveHarness
       agent_streams = { token: @token_stream, agent: @agent_event_stream }.compact
       @agents.map do |agent|
         if agent.is_a?(Class)
-          agent.new(input: @input, context: @context.dup, streams: agent_streams)
+          agent.new(input: @input, context: @context.dup, params: @params, streams: agent_streams)
         else
           agent.input = @input if @input
           agent.instance_variable_set(:@token_stream, @token_stream) if @token_stream

data/lib/active_harness.rb

@@ -1,5 +1,6 @@
 require_relative "active_harness/configuration"
 require_relative "active_harness/core/errors"
+require_relative "active_harness/core/hooks"
 require_relative "active_harness/result"
 require_relative "active_harness/http/client"
 require_relative "active_harness/http/streaming_client"
@@ -29,7 +30,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.2.21"
+  VERSION = "0.2.23"
 
   class << self
     # Configure ActiveHarness.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.23
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -42,6 +42,7 @@ files:
 - lib/active_harness/agent/providers.rb
 - lib/active_harness/configuration.rb
 - lib/active_harness/core/errors.rb
+- lib/active_harness/core/hooks.rb
 - lib/active_harness/costs.rb
 - lib/active_harness/data/models.json
 - lib/active_harness/http/client.rb