active_harness 0.2.14 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a42e03d329e638e3119d0a259a2286f05a0ec1603b8c2c81636e4ac041ebf9d
-  data.tar.gz: 074cf7e1558d9efee20cd17c3405665be00ef29c30574289b54d6e2251ebeacc
+  metadata.gz: 26824b777c1b0a68676671e07725a4ec171bb1491cf306b098aa97c6d4cf5510
+  data.tar.gz: bd0ca2f2fb3fa813eeea21bd48e49435babd989b761e5ea4a6dda194218a27ae
 SHA512:
-  metadata.gz: 3397bd1901b3062030b3a41dc327ed1fd7053ef5d90e8e53d0ebb820375054f112cc80e70e528282703277e90137310318d026c456950f86ae755a09aca4e473
-  data.tar.gz: 7137703c7469a5f1cd8adfb121fd5047231387890756325f7e035955c7a23dab3bd0dfaf22c223343a9fb006279b6b352c01f1cf443da6cfcf60c3e26227cac3
+  metadata.gz: b51494c59af3664360e3a0cdaa650a309499bada4df3a10f46bb1c4f547e577276f27bcdfa2c5ebbe2e88a220245feca1c51aba018ecee495cb15d72c5a076bb
+  data.tar.gz: e770331ab6e5621fc5f55257bd736d24eb972dbcd800075113971665c652e3d553505488ae8dec58d184c1f8cc5fc971146861d7e264cd4e291c4d18ccd694ae

data/lib/active_harness/agent.rb

@@ -23,6 +23,14 @@ module ActiveHarness
       def inherited(subclass)
         subclass.instance_variable_set(:@agent_config, {})
       end
+
+      # Automatically strip and collapse whitespace in @input before each call.
+      # Enabled by default. Disable with:
+      #
+      #   normalize_input false
+      def normalize_input(value = true)
+        agent_config[:normalize_input] = value
+      end
     end
 
     # -------------------------------------------------------------------------
@@ -42,8 +50,9 @@ module ActiveHarness
 
     def initialize(input: nil, context: {}, models: nil, memory: nil, stream: nil, token_stream: nil, event_stream: nil)
       @input           = input
-      @context         = context
       @config          = self.class.agent_config
+      normalize_input!
+      @context         = context
       @models_override = Array(models) if models
       @stream          = stream
       @token_stream    = token_stream
@@ -60,7 +69,10 @@ module ActiveHarness
     #   agent.call("What is the capital of Japan?")
     #   agent.call("...", stream: ->(token) { print token })
     def call(input = nil, token_stream: nil)
-      @input        = input        if input
+      if input
+        @input = input
+        normalize_input!
+      end
       @token_stream = token_stream if token_stream
       @memory&.load
       @system_prompt = resolve_system_prompt
@@ -145,6 +157,11 @@ module ActiveHarness
         model:    result.model
       )
     end
+
+    def normalize_input!
+      return if @config.fetch(:normalize_input, true) == false
+      @input = @input&.strip&.gsub(/\s+/, " ")
+    end
   end
 end
 

data/lib/active_harness/tribunal/dsl.rb

@@ -9,13 +9,46 @@ module ActiveHarness
         tribunal_config[:agents] = list.flatten
       end
 
-      # Class-level process block — defines how to compute the verdict from results.
+      # 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 } }
-      #   process { |results| results.count { |r| r.parsed["result"] == true } >= 2 }
       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/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

@@ -50,7 +50,8 @@ module ActiveHarness
     attr_reader :results, :errors, :verdict, :execution_time, :agent_execution_times
 
     def initialize(input: nil, context: {}, agents: nil, timeout: 7,
-                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil)
+                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil,
+                   may_fail: :_unset)
       config = self.class.tribunal_config
 
       @input                 = input
@@ -58,6 +59,9 @@ module ActiveHarness
       @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
@@ -69,12 +73,6 @@ module ActiveHarness
       @agent_execution_times = []
     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
     #
@@ -125,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
@@ -139,6 +137,19 @@ module ActiveHarness
 
     private
 
+    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
+
+    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)
@@ -161,3 +172,4 @@ 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.14
+  version: 0.2.16
 platform: ruby
 authors:
 - the-teacher
@@ -74,6 +74,7 @@ files:
 - 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