active_harness 0.2.19 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9562f506c8c0b6a219b085fc33a123a39538f368d5fa0255400cc5632b3395f2
-  data.tar.gz: c23b9fddc6356c71b37495fce0654d1777314d96ca43001b41c1e97f3b59c8d8
+  metadata.gz: de49ac66334a5feb91a5d5f0314ab2b9b3460a5d3a549f08b77538677eae619b
+  data.tar.gz: 0bffb6e77d1b8def25121b144dbc956c2c1b0c684826910e3dd0a66ab595a73e
 SHA512:
-  metadata.gz: 6def9d9a139113f948c7da6acd1ed0f99e88257c273b3434d236829b700d156e6feeda60ac7fbadef183840ca76e9e12b08b70f40b9d2bdb634f14a4cee19ce7
-  data.tar.gz: 76e1a91a7cbd321e56900562b9c471d7313a0553d2a72764000768e7e7c4fcdd0ecc09d321ebb95f3cc43335f66ad81d11d7d354fdc8204bab48d404a969710c
+  metadata.gz: e51c5ab8c3911d2597f6269f695c2f4992f960d771b4284fdd27121939aca14dfea53e568ecbfc069af26b405725106c18b3beebf0232e751ed8144b3134cea7
+  data.tar.gz: ea95a9f48993b4dc930addeee4260e6056815ec48d3c2534a6bf6f5001168cad2104fcd988c98e442f940f32faa4161f9b59a4692bc6fa3adf7655a221d5d56b

data/lib/active_harness/agent/hooks.rb

@@ -71,5 +71,15 @@ module ActiveHarness
         instance_eval(&hooks[event])
       end
     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)
+      @event_stream&.call(event, *args)
+      result
+    rescue IOError, ActionController::Live::ClientDisconnected
+      result
+    end
   end
 end

data/lib/active_harness/agent/output_parser.rb

@@ -49,7 +49,7 @@ module ActiveHarness
         #     puts "Parse failed: #{error.message}"
         #     { "result" => nil, "reason" => "parse error" }   # fallback
         #   end
-        fallback = run_hook(:parse_error, raw, e)
+        fallback = fire(:parse_error, raw, e)
         fallback.nil? ? raise : fallback
       end
     end

data/lib/active_harness/agent/prompt.rb

@@ -22,7 +22,7 @@ module ActiveHarness
     public :system_prompt
 
     def resolve_system_prompt
-      run_hook(:before_system_prompt)
+      fire(:before_system_prompt)
 
       sp = @config[:system_prompt]
 
@@ -45,7 +45,7 @@ module ActiveHarness
         end
       end
 
-      run_hook(:after_system_prompt, prompt)
+      fire(:after_system_prompt, prompt)
       prompt
     end
 

data/lib/active_harness/agent.rb

@@ -11,8 +11,8 @@ 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, stream: nil, token_stream: nil, event_stream: nil)
-        new(input: input, context: context, models: models, memory: memory, stream: stream, token_stream: token_stream, event_stream: event_stream).call
+      def call(input: nil, context: {}, models: nil, memory: nil, streams: {})
+        new(input: input, context: context, models: models, memory: memory, streams: streams).call
       end
 
       # Each subclass gets its own isolated config hash.
@@ -36,8 +36,8 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_accessor :input, :context, :stream, :token_stream, :event_stream
-    attr_reader :result
+    attr_accessor :input, :context
+    attr_reader   :result, :token_stream, :event_stream
 
     def models=(list)
       @models_override = Array(list)
@@ -48,18 +48,17 @@ module ActiveHarness
       @memory = obj
     end
 
-    def initialize(input: nil, context: {}, models: nil, memory: nil, stream: nil, token_stream: nil, event_stream: nil)
+    def initialize(input: nil, context: {}, models: nil, memory: nil, streams: {})
       @input           = input
       @config          = self.class.agent_config
       normalize_input!
       @context         = context
       @models_override = Array(models) if models
-      @stream          = stream
-      @token_stream    = token_stream
-      @event_stream    = event_stream
+      @token_stream    = streams[:token]
+      @event_stream    = streams[:agent]
       # memory: can be passed directly or via context[:memory]
       @memory = memory || @context[:memory]
-      run_hook(:setup)
+      fire(:setup)
     end
 
     # Attempts each model in order, returns the first successful Result.
@@ -68,15 +67,18 @@ module ActiveHarness
     # Optionally accepts input and stream callback inline:
     #   agent.call("What is the capital of Japan?")
     #   agent.call("...", stream: ->(token) { print token })
-    def call(input = nil, token_stream: nil)
+    def call(input = nil, streams: nil)
       if input
         @input = input
         normalize_input!
       end
-      @token_stream = token_stream if token_stream
+      if streams
+        @token_stream = streams[:token] if streams.key?(:token)
+        @event_stream = streams[:agent] if streams.key?(:agent)
+      end
       @memory&.load
       @system_prompt = resolve_system_prompt
-      run_hook(:before_call)
+      fire(:before_call)
       attempts = []
 
       cfg = ActiveHarness.config
@@ -91,22 +93,22 @@ module ActiveHarness
         elapsed  = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round(3)
         result   = build_result(response, entry, attempts, elapsed)
         save_to_memory(result)
-        run_hook(:after_call, result)
+        fire(:after_call, result)
         @result = result
         return self
       rescue *RETRYABLE_ERRORS => e
         elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round(3)
         attempts << attempt_entry(entry, e, elapsed)
-        run_hook(:retry, entry, e)
+        fire(:retry, entry, e)
         next
       rescue *STOP_ERRORS => e
         elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0).round(3)
         attempts << attempt_entry(entry, e, elapsed)
-        run_hook(:retry, entry, e)
+        fire(:retry, entry, e)
         raise
       end
 
-      run_hook(:failure, attempts)
+      fire(:failure, attempts)
       raise Errors::AllModelsFailed, "All models failed. Attempts: #{attempts.inspect}"
     end
 

data/lib/active_harness/pipeline/hooks.rb

@@ -0,0 +1,77 @@
+module ActiveHarness
+  class Pipeline
+    VALID_HOOKS      = %i[before_step after_step stopped complete].freeze
+    VALID_STEP_HOOKS = %i[before_step after_step].freeze
+
+    class << self
+      # Register a global or per-step hook.
+      #
+      # Global hooks fire on every step:
+      #   on :before_step do |step_name, payload| ... end
+      #   on :after_step  do |step_name, result|  ... end
+      #   on :stopped     do |step_name, result|  ... end
+      #   on :complete    do |last_result|         ... end
+      #
+      # Per-step hooks fire only for the named step (no step_name passed):
+      #   on :before_step, :translate do |payload| ... end
+      #   on :after_step,  :translate do |result|  ... end
+      def on(event, step_name = nil, &block)
+        if step_name
+          unless VALID_STEP_HOOKS.include?(event)
+            raise ArgumentError,
+              "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
+        else
+          unless VALID_HOOKS.include?(event)
+            raise ArgumentError,
+              "Unknown Pipeline hook :#{event}. Valid: #{VALID_HOOKS.join(", ")}"
+          end
+          pipeline_config[:hooks][event] = block
+        end
+      end
+
+      # Rails-style aliases for +on+:
+      #
+      # Global:
+      #   before :step                          do |name, payload| end  # → on :before_step
+      #   after  :step                          do |name, result|  end  # → on :after_step
+      #   callback :stopped                     do |name, result|  end  # → on :stopped
+      #   callback :complete                    do |result|        end  # → on :complete
+      #
+      # Per-step:
+      #   after  :step, :translate              do |result| end
+      #   before :step, :translate              do |payload| end
+      def before(event, step_name = nil, &block)
+        on(:"before_#{event}", step_name, &block)
+      end
+
+      def after(event, step_name = nil, &block)
+        on(:"after_#{event}", step_name, &block)
+      end
+
+      def callback(event, &block)
+        on(event, &block)
+      end
+    end
+
+    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
+      @pipeline_event_stream&.call(event, step_name, data)
+    rescue IOError, ActionController::Live::ClientDisconnected
+      nil
+    end
+
+    # 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
+    end
+  end
+end

data/lib/active_harness/pipeline.rb

@@ -32,9 +32,6 @@ module ActiveHarness
   #   pipeline.step_results # => { translate: <Result>, ... }
   #
   class Pipeline
-    VALID_HOOKS      = %i[before_step after_step stopped complete].freeze
-    VALID_STEP_HOOKS = %i[before_step after_step].freeze
-
     # -------------------------------------------------------------------------
     # Class-level DSL
     # -------------------------------------------------------------------------
@@ -53,57 +50,6 @@ module ActiveHarness
         pipeline_config[:steps] << Pipeline::Step.new(name, agent_class, &block)
       end
 
-      # Register a global or per-step hook.
-      #
-      # Global hooks fire on every step:
-      #   on :before_step do |step_name, payload| ... end
-      #   on :after_step  do |step_name, result|  ... end
-      #   on :stopped     do |step_name, result|  ... end
-      #   on :complete    do |last_result|         ... end
-      #
-      # Per-step hooks fire only for the named step (no step_name passed):
-      #   on :before_step, :translate do |payload| ... end
-      #   on :after_step,  :translate do |result|  ... end
-      def on(event, step_name = nil, &block)
-        if step_name
-          unless VALID_STEP_HOOKS.include?(event)
-            raise ArgumentError,
-              "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
-        else
-          unless VALID_HOOKS.include?(event)
-            raise ArgumentError,
-              "Unknown Pipeline hook :#{event}. Valid: #{VALID_HOOKS.join(", ")}"
-          end
-          pipeline_config[:hooks][event] = block
-        end
-      end
-
-      # Rails-style aliases for +on+:
-      #
-      # Global:
-      #   before :step                          do |name, payload| end  # → on :before_step
-      #   after  :step                          do |name, result|  end  # → on :after_step
-      #   callback :stopped                     do |name, result|  end  # → on :stopped
-      #   callback :complete                    do |result|        end  # → on :complete
-      #
-      # Per-step:
-      #   after  :step, :translate              do |result| end
-      #   before :step, :translate              do |payload| end
-      def before(event, step_name = nil, &block)
-        on(:"before_#{event}", step_name, &block)
-      end
-
-      def after(event, step_name = nil, &block)
-        on(:"after_#{event}", step_name, &block)
-      end
-
-      def callback(event, &block)
-        on(event, &block)
-      end
-
       def pipeline_config
         @pipeline_config ||= { steps: [], hooks: {}, step_hooks: {} }
       end
@@ -129,23 +75,21 @@ module ActiveHarness
       @payload        = value
     end
 
-    def initialize(input:, context: {}, memory: nil,
-                   stream: nil, agent_event_stream: nil,
-                   tribunal_event_stream: nil, pipeline_event_stream: nil)
-      @original_input           = input
-      @payload                  = input
-      @context                  = context.dup
-      @memory                   = memory
-      @stream                   = stream
-      @agent_event_stream       = agent_event_stream
-      @tribunal_event_stream    = tribunal_event_stream
-      @pipeline_event_stream    = pipeline_event_stream
-      @step_results             = {}
-      @stopped                  = false
-      @stopped_at               = nil
-      @stop_reason              = nil
-      @execution_time           = nil
-      @output                   = nil
+    def initialize(input:, context: {}, memory: nil, streams: {})
+      @original_input        = input
+      @payload               = input
+      @context               = context.dup
+      @memory                = memory
+      @token_stream          = streams[:token]
+      @agent_event_stream    = streams[:agent]
+      @tribunal_event_stream = streams[:tribunal]
+      @pipeline_event_stream = streams[:pipeline]
+      @step_results          = {}
+      @stopped               = false
+      @stopped_at            = nil
+      @stop_reason           = nil
+      @execution_time        = nil
+      @output                = nil
     end
 
     def stopped?
@@ -160,7 +104,7 @@ module ActiveHarness
       @memory&.load
 
       config[:steps].each do |step|
-        fire_global(:before_step, step.name, @payload, config)
+        fire(:before_step, step.name, @payload, config)
         fire_step(:before_step, step.name, @payload, config)
 
         result = execute_step(step)
@@ -169,7 +113,7 @@ module ActiveHarness
         @context[step.name]      = result
         @payload                 = result.output if step.transform?
 
-        fire_global(:after_step, step.name, result, config)
+        fire(:after_step, step.name, result, config)
         fire_step(:after_step, step.name, result, config)
 
         if step.stop_if && step.stop_if.call(result)
@@ -178,6 +122,7 @@ module ActiveHarness
           @stop_reason = result
           blk = config[:hooks][:stopped]
           instance_exec(step.name, result, &blk) if blk
+          @pipeline_event_stream&.call(:stopped, step.name, result)
           break
         end
       end
@@ -195,6 +140,7 @@ module ActiveHarness
         last_result = @step_results[@step_results.keys.last]
         blk = config[:hooks][:complete]
         instance_exec(last_result, &blk) if blk
+        @pipeline_event_stream&.call(:complete, last_result)
       end
 
       self
@@ -204,37 +150,23 @@ module ActiveHarness
 
     def execute_step(step)
       if step.tribunal?
-        agent = step.agent_class.new(
-          input:                 @payload,
-          context:               @context.dup,
-          stream:                @stream,
-          agent_event_stream:    @agent_event_stream,
-          tribunal_event_stream: @tribunal_event_stream
-        )
-        agent.call
+        agent_streams = { token: @token_stream, agent: @agent_event_stream, tribunal: @tribunal_event_stream }.compact
+        step.agent_class.new(
+          input:    @payload,
+          context:  @context.dup,
+          streams:  agent_streams
+        ).call
       else
-        agent = step.agent_class.new(
-          input:        @payload,
-          context:      @context.dup,
-          stream:       @stream,
-          event_stream: @agent_event_stream
-        )
-        agent.call.result
+        agent_streams = { token: @token_stream, agent: @agent_event_stream }.compact
+        step.agent_class.new(
+          input:    @payload,
+          context:  @context.dup,
+          streams:  agent_streams
+        ).call.result
       end
     end
-
-    # Global hook: receives (step_name, data)
-    def fire_global(event, step_name, data, config)
-      blk = config[:hooks][event]
-      instance_exec(step_name, data, &blk) if blk
-    end
-
-    # Per-step hook: receives (data) only
-    def fire_step(event, step_name, data, config)
-      blk = config[:step_hooks][step_name]&.dig(event)
-      instance_exec(data, &blk) if blk
-    end
   end
 end
 
+require_relative "pipeline/hooks"
 require_relative "pipeline/step"

data/lib/active_harness/tribunal.rb

@@ -46,11 +46,12 @@ module ActiveHarness
     # -------------------------------------------------------------------------
     # Instance API
     # -------------------------------------------------------------------------
-    attr_accessor :input, :context, :stream, :agent_event_stream, :tribunal_event_stream
-    attr_reader :results, :errors, :verdict, :execution_time, :agent_execution_times
+    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,
-                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil,
+                   streams: {},
                    may_fail: :_unset)
       config = self.class.tribunal_config
 
@@ -63,9 +64,9 @@ module ActiveHarness
       @evaluate_block        = config[:evaluate_block]
       @may_fail              = may_fail == :_unset ? config[:may_fail] : may_fail
       @hooks                 = config[:hooks].dup
-      @stream                = stream
-      @agent_event_stream    = agent_event_stream
-      @tribunal_event_stream = tribunal_event_stream
+      @token_stream          = streams[:token]
+      @agent_event_stream    = streams[:agent]
+      @tribunal_event_stream = streams[:tribunal]
       @results               = []
       @errors                = []
       @verdict               = nil
@@ -151,18 +152,14 @@ module ActiveHarness
     end
 
     def resolve_agents
+      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,
-            stream:       @stream,
-            event_stream: @agent_event_stream
-          )
+          agent.new(input: @input, context: @context.dup, streams: agent_streams)
         else
-          agent.input        = @input if @input
-          agent.stream       = @stream if @stream
-          agent.event_stream = @agent_event_stream if @agent_event_stream
+          agent.input = @input if @input
+          agent.instance_variable_set(:@token_stream, @token_stream) if @token_stream
+          agent.instance_variable_set(:@event_stream, @agent_event_stream) if @agent_event_stream
           agent
         end
       end

data/lib/active_harness.rb

@@ -29,7 +29,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.2.19"
+  VERSION = "0.2.21"
 
   class << self
     # Configure ActiveHarness.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.2.21
 platform: ruby
 authors:
 - the-teacher
@@ -51,6 +51,7 @@ files:
 - lib/active_harness/memory/adapter/base.rb
 - lib/active_harness/memory/adapter/file.rb
 - lib/active_harness/pipeline.rb
+- lib/active_harness/pipeline/hooks.rb
 - lib/active_harness/pipeline/step.rb
 - lib/active_harness/providers/PROVIDER_CONTRACT.md
 - lib/active_harness/providers/anthropic.rb