active_harness 0.2.13 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c5339e68dc9f7de87fc67a4e986cd1858e86f52e95ee277ee0f12563eedf428
-  data.tar.gz: d563d7088e6b29c2119160a9eb0e0a39eb550d12e1bf828937a7d20fddcf7ad4
+  metadata.gz: cc551806a5848e9157c21ee668ee38c139a55c46fb7e8c2a6a2e8022200c90cb
+  data.tar.gz: f6110846af88ce73b7fe7a30221d18960a58e80adeaf01e2b19b5e14fac0640d
 SHA512:
-  metadata.gz: 9d710fedd64ae1bd1ee40616aacb884e698491ec223895651c1ad28a307121575f5078df54074e3218ade227cf376f20a881af15ecef640e63f74887cd5a9115
-  data.tar.gz: '075778aea6ae0b53624b18fd64835cdaaec6e0381ff7616faab86c2b9813d5ae80830bdcf59ce71b255a13930ad6d35f99b1953bde11e58c7a8bda03c36732df'
+  metadata.gz: d8884d36a5da2581707584068acc7315a00d417bd88a7776d1702c375e05470257c21cedb6c323fec5aa75562e6f118d635ae1b1a2053d3e7d60b48b0aca8d3f
+  data.tar.gz: 02fa25dca8678816e76b2c2b2fad6131e26a7aa8b5a97cb78a5bcee84d7a9923507eb5981d0508663ecced5a6eb85c5f92799a00d80b59098252dc08438ff22f

data/lib/active_harness/tribunal/dsl.rb

@@ -0,0 +1,54 @@
+module ActiveHarness
+  class Tribunal
+    class << self
+      # Declare agents at the class level.
+      #
+      #   agents PolitenessAgent, ConstructivenessAgent
+      #   agents [PolitenessAgent, ConstructivenessAgent]
+      def agents(*list)
+        tribunal_config[:agents] = list.flatten
+      end
+
+      # Class-level process block — defines how to compute the verdict from all results.
+      # Receives the full results array; return value becomes #verdict.
+      # Takes priority over +verdict+ strategy if both are declared.
+      #
+      #   process { |results| results.all? { |r| r.parsed["result"] == true } }
+      def process(&block)
+        tribunal_config[:process] = block
+      end
+
+      # Declarative verdict — built-in aggregation strategy with a per-result evaluator.
+      #
+      # Strategies:
+      #   :unanimous  — verdict true when every successful result evaluates to true
+      #   :majority   — verdict true when more than half of successful results evaluate to true
+      #
+      # Options:
+      #   may_fail: N — tolerate up to N agent errors before raising AllAgentsFailed
+      #                 (default: nil — raise only when all agents fail, preserving legacy behavior)
+      #
+      # The block receives a single Result and must return a truthy/falsy value.
+      #
+      #   verdict :unanimous do |result|
+      #     result.parsed["result"] == true
+      #   end
+      #
+      #   verdict :majority, may_fail: 1 do |result|
+      #     result.parsed["result"] == true
+      #   end
+      VALID_STRATEGIES = %i[unanimous majority].freeze
+
+      def verdict(strategy, may_fail: nil, &block)
+        unless VALID_STRATEGIES.include?(strategy)
+          raise ArgumentError,
+            "Unknown verdict strategy :#{strategy}. Valid strategies: #{VALID_STRATEGIES.map { |s| ":#{s}" }.join(", ")}"
+        end
+
+        tribunal_config[:strategy]       = strategy
+        tribunal_config[:may_fail]       = may_fail
+        tribunal_config[:evaluate_block] = block
+      end
+    end
+  end
+end

data/lib/active_harness/tribunal/hooks.rb

@@ -0,0 +1,87 @@
+module ActiveHarness
+  class Tribunal
+    VALID_HOOKS = %i[
+      before_call
+      before_agent
+      after_agent
+      agent_error
+      after_call
+      before_verdict
+      after_verdict
+    ].freeze
+
+    class << self
+      # Class-level hook registration.
+      #
+      #   on :before_call                  do ... end
+      #   on :before_agent                 do |agent| ... end
+      #   on :after_agent                  do |result| ... end
+      #   on :agent_error                  do |name, error| ... end
+      #   on :after_call                   do |results, errors| ... end
+      #   on :before_verdict               do |results| results end  # transform hook
+      #   on :after_verdict                do |verdict| ... end
+      def on(event, &block)
+        unless VALID_HOOKS.include?(event)
+          raise ArgumentError,
+            "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.map { |h| ":#{h}" }.join(", ")}"
+        end
+
+        tribunal_config[:hooks][event] = block
+      end
+
+      # Rails-style aliases for +on+:
+      #
+      #   before :call                     do ... end       # → on :before_call
+      #   before :agent                    do |agent| end   # → on :before_agent
+      #   before :verdict                  do |results| end # → on :before_verdict (transform)
+      #   after  :call                     do |r, e| end    # → on :after_call
+      #   after  :agent                    do |result| end  # → on :after_agent
+      #   after  :verdict                  do |verdict| end # → on :after_verdict
+      #   callback :agent_error            do |name, e| end # → on :agent_error
+      def before(event, &block)
+        on(:"before_#{event}", &block)
+      end
+
+      def after(event, &block)
+        on(:"after_#{event}", &block)
+      end
+
+      def callback(event, &block)
+        on(event, &block)
+      end
+    end
+
+    # Instance-level hook registration — overrides class-level hooks for this instance.
+    # :before_verdict is a transform hook: its return value replaces the results array
+    # passed to the process block.
+    def on(event, &block)
+      unless VALID_HOOKS.include?(event)
+        raise ArgumentError,
+          "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.map { |h| ":#{h}" }.join(", ")}"
+      end
+
+      @hooks[event] = block
+      self
+    end
+
+    private
+
+    def run_hook(event, *args)
+      return unless @hooks[event]
+
+      if args.any?
+        instance_exec(*args, &@hooks[event])
+      else
+        instance_eval(&@hooks[event])
+      end
+    end
+
+    # Like run_hook but uses the return value to replace the passed value.
+    # 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])
+    end
+  end
+end

data/lib/active_harness/tribunal/processing.rb

@@ -0,0 +1,44 @@
+module ActiveHarness
+  class Tribunal
+    # Instance-level process block — overrides class-level block.
+    #
+    #   tribunal.process { |results| results.count { |r| r.parsed["ok"] } >= 2 }
+    def process(&block)
+      @process_block = block
+      self
+    end
+
+    private
+
+    # Selects and executes the verdict computation in order of priority:
+    #   1. Instance-level process block (set via tribunal.process { ... })
+    #   2. Class-level process block    (set via `process do ... end` in subclass)
+    #   3. Class-level strategy         (set via `verdict :unanimous/:majority`)
+    #   4. nil                          (no verdict computation declared)
+    def compute_verdict(results)
+      if @process_block
+        @process_block.call(results)
+      elsif @strategy
+        apply_strategy(@strategy, results)
+      end
+    end
+
+    # Built-in aggregation strategies.
+    #
+    # Without an evaluate_block every successful result is treated as a positive vote.
+    # With an evaluate_block the block decides whether each result counts as positive.
+    #
+    # :unanimous — all positive votes required
+    # :majority  — more than 50% positive votes required
+    def apply_strategy(strategy, results)
+      evaluate = @evaluate_block || ->(r) { r }
+      votes    = results.map { |r| evaluate.call(r) ? true : false }
+      positive = votes.count(true)
+
+      case strategy
+      when :unanimous then positive == votes.size
+      when :majority  then positive > votes.size / 2.0
+      end
+    end
+  end
+end

data/lib/active_harness/tribunal.rb

@@ -29,62 +29,11 @@ module ActiveHarness
   #   ContentQualityTribunal.new(input: "...").call
   #
   class Tribunal
-    VALID_HOOKS = %i[
-      before_call
-      after_agent
-      agent_error
-      after_call
-      before_verdict
-      after_verdict
-    ].freeze
-
     # -------------------------------------------------------------------------
-    # Class-level DSL — used when subclassing ActiveHarness::Tribunal
+    # Class-level DSL — core
     # -------------------------------------------------------------------------
     class << self
-      # Declare agents at the class level.
-      #   agents PolitenessAgent, ConstructivenessAgent
-      def agents(*list)
-        tribunal_config[:agents] = list.flatten
-      end
-
-      # Class-level hook registration.
-      #   on(:after_agent) { |result| puts result.model }
-      def on(event, &block)
-        unless VALID_HOOKS.include?(event)
-          raise ArgumentError, "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.join(", ")}"
-        end
-
-        tribunal_config[:hooks][event] = block
-      end
-
-      # Rails-style aliases for +on+:
-      #
-      #   before :call                     do ... end   # → on :before_call
-      #   before :agent                    do ... end   # → on :before_agent (not used yet)
-      #   before :verdict                  do |r| end   # → on :before_verdict
-      #   after  :call                     do ... end   # → on :after_call
-      #   after  :agent                    do |r| end   # → on :after_agent
-      #   after  :verdict                  do |v| end   # → on :after_verdict
-      #   callback :agent_error            do |n,e| end # → on :agent_error
-      def before(event, &block)
-        on(:"before_#{event}", &block)
-      end
-
-      def after(event, &block)
-        on(:"after_#{event}", &block)
-      end
-
-      def callback(event, &block)
-        on(event, &block)
-      end
-
-      # Class-level process block.
-      #   process { |results| results.all? { |r| r.parsed["result"] == true } }
-      def process(&block)
-        tribunal_config[:process] = block
-      end
-
+      # Each subclass gets its own isolated config hash.
       def tribunal_config
         @tribunal_config ||= { agents: [], hooks: {} }
       end
@@ -94,42 +43,36 @@ module ActiveHarness
       end
     end
 
-    attr_accessor :input, :context
+    # -------------------------------------------------------------------------
+    # Instance API
+    # -------------------------------------------------------------------------
+    attr_accessor :input, :context, :stream, :agent_event_stream, :tribunal_event_stream
     attr_reader :results, :errors, :verdict, :execution_time, :agent_execution_times
 
-    def initialize(input: nil, context: {}, agents: nil, timeout: 7)
+    def initialize(input: nil, context: {}, agents: nil, timeout: 7,
+                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil,
+                   may_fail: :_unset)
       config = self.class.tribunal_config
 
-      @input         = input
-      @context       = context
-      @agents        = agents || config[:agents]
-      @timeout       = timeout
-      @process_block = config[:process]
-      @hooks         = config[:hooks].dup
-      @results       = []
-      @errors        = []
-      @verdict       = nil
-      @execution_time       = nil
+      @input                 = input
+      @context               = context
+      @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
+      @stream                = stream
+      @agent_event_stream    = agent_event_stream
+      @tribunal_event_stream = tribunal_event_stream
+      @results               = []
+      @errors                = []
+      @verdict               = nil
+      @execution_time        = nil
       @agent_execution_times = []
     end
 
-    # Instance-level hook registration — overrides class-level hooks.
-    # :before_verdict is a transform hook: its return value replaces the results array.
-    def on(event, &block)
-      unless VALID_HOOKS.include?(event)
-        raise ArgumentError, "Unknown Tribunal hook :#{event}. Valid hooks: #{VALID_HOOKS.join(", ")}"
-      end
-
-      @hooks[event] = block
-      self
-    end
-
-    # Instance-level process block — overrides class-level block.
-    def process(&block)
-      @process_block = block
-      self
-    end
-
     # Run all agents in parallel, then compute the verdict.
     # Returns self so calls can be chained: tribunal.call.verdict
     #
@@ -143,14 +86,15 @@ module ActiveHarness
 
       started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      futures = agents.map do |agent|
+      futures = agents.each_with_index.map do |agent, index|
+        run_hook(:before_agent, agent, index)
         t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         future = Concurrent::Future.execute { agent.call }
         [future, t0]
       end
 
-      @results              = []
-      @errors               = []
+      @results               = []
+      @errors                = []
       @agent_execution_times = []
 
       futures.each_with_index do |(future, t0), index|
@@ -159,19 +103,19 @@ module ActiveHarness
         @agent_execution_times << { agent: agents[index].class.name, time: elapsed }
 
         if future.fulfilled?
-          value = future.value
+          value  = future.value
           result = value.is_a?(ActiveHarness::Agent) ? value.result : value
           @results << result
-          run_hook(:after_agent, result)
+          run_hook(:after_agent, result, index)
         elsif future.incomplete?
           error = Errors::TimeoutError.new(
             "Agent #{agents[index].class.name} timed out after #{@timeout}s"
           )
           @errors << { agent: agents[index].class.name, error: error }
-          run_hook(:agent_error, agents[index].class.name, error)
+          run_hook(:agent_error, agents[index].class.name, error, index)
         else
           @errors << { agent: agents[index].class.name, error: future.reason }
-          run_hook(:agent_error, agents[index].class.name, future.reason)
+          run_hook(:agent_error, agents[index].class.name, future.reason, index)
         end
       end
 
@@ -179,13 +123,13 @@ module ActiveHarness
 
       run_hook(:after_call, @results, @errors)
 
-      if @results.empty?
-        messages = @errors.map { |e| "#{e[:agent]}: #{e[:error].message}" }.join("; ")
-        raise Errors::AllAgentsFailed, "All agents failed — #{messages}"
-      end
+      # If all agents failed, raise an exception.
+      # Otherwise, compute the verdict based on successful results.
+      check_failure_threshold!
 
       verdict_input = transform_hook(:before_verdict, @results)
-      @verdict = @process_block ? @process_block.call(verdict_input) : nil
+      @verdict      = compute_verdict(verdict_input)
+      
       run_hook(:after_verdict, @verdict)
 
       self
@@ -193,26 +137,39 @@ module ActiveHarness
 
     private
 
-    def run_hook(event, *args)
-      @hooks[event]&.call(*args)
+    def check_failure_threshold!
+      if !@may_fail.nil? && @errors.size > @may_fail
+        raise Errors::AllAgentsFailed,
+          "Too many agents failed (#{@errors.size} > may_fail: #{@may_fail}) — #{error_summary}"
+      elsif @results.empty?
+        raise Errors::AllAgentsFailed, "All agents failed — #{error_summary}"
+      end
     end
 
-    # Like run_hook but uses the return value to replace the passed value.
-    def transform_hook(event, value)
-      return value unless @hooks[event]
-
-      @hooks[event].call(value)
+    def error_summary
+      @errors.map { |e| "#{e[:agent]}: #{e[:error].message}" }.join("; ")
     end
 
     def resolve_agents
       @agents.map do |agent|
         if agent.is_a?(Class)
-          agent.new(input: @input, context: @context.dup)
+          agent.new(
+            input:        @input,
+            context:      @context.dup,
+            stream:       @stream,
+            event_stream: @agent_event_stream
+          )
         else
-          agent.input = @input if @input
+          agent.input        = @input if @input
+          agent.stream       = @stream if @stream
+          agent.event_stream = @agent_event_stream if @agent_event_stream
           agent
         end
       end
     end
   end
 end
+
+require_relative "tribunal/hooks"
+require_relative "tribunal/dsl"
+require_relative "tribunal/processing"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.15
 platform: ruby
 authors:
 - the-teacher
@@ -72,6 +72,9 @@ files:
 - lib/active_harness/railtie.rb
 - lib/active_harness/result.rb
 - lib/active_harness/tribunal.rb
+- lib/active_harness/tribunal/dsl.rb
+- lib/active_harness/tribunal/hooks.rb
+- lib/active_harness/tribunal/processing.rb
 - lib/generators/active_harness/agent/agent_generator.rb
 - lib/generators/active_harness/agent/templates/agent.rb.tt
 - lib/generators/active_harness/install/install_generator.rb