active_harness 0.2.37 → 0.2.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fb1f238ea442c93d556e18ef1b899ad8d8e8345c6ed18c8abd0d45370c847e0
-  data.tar.gz: 8c8b0dceb9c779f6432dc86f141fdda65144b365511ee3096957a96954447b4e
+  metadata.gz: 656a10b468592b8e0c53c2c93a8fbf7b8536420f94bd0cb7a61255d432ee78ed
+  data.tar.gz: 29de2c821b23ba363ef1596fb545035fbd1191ca6487161f6b9f30b39fe960db
 SHA512:
-  metadata.gz: fd1da6cb093ea99b414576fe9e1fc2ec0fee4a894eca5bd5291582ea5daabdb1ee621f22a5b7e4460455c03fd47df5b152b5d9598c64df9a408cbaec93ca3371
-  data.tar.gz: 939c5d39b1f172ae0225087f095e8665c84b34f6cc384bf2e8f949e871a0be63c3ecf59253e253a1066c40c6c41528f57c8b09790720dca765c8760175ce36ad
+  metadata.gz: 9d0d4c4114ed028a603a783841c5205163f1f02203e7c010d5c806a8e673644b391cbfb636bbb1c4d77eb40a807907e63380213b087ab3c5515491c1c2c64fcf
+  data.tar.gz: 84b154cb18717e6183337d728a6eb3ec9d34753856d6acc8fbf96c90e06a6e0db799b961b3f8d5bd7dc3984797bed401429a3110573243379eb471fcd84f160b

data/lib/active_harness/agent/cost.rb

@@ -1,12 +1,36 @@
 module ActiveHarness
   class Agent
+    # Providers that have a dedicated pricing source beyond ModelsDev.
+    # Consulted in tier-2 before the general ModelsDev fallback.
+    # Add entries here when a new provider-specific source is available.
+    PROVIDER_PRICING_SOURCES = {
+      openrouter: Pricing::OpenRouter
+    }.freeze
+
     private
 
-    # Builds a CostBreakdown for a single request from token usage and
-    # pricing data from ActiveHarness::Pricing.
-    #
-    # Returns CostBreakdown (input, output, total in USD),
-    # or nil if usage is absent or the model is not found in the pricing registry.
+    # Cost lookup — three-tier fallback:
+    #   1. provider_cost in the API response  (handled in build_usage)
+    #   2. provider-specific source           (e.g. Pricing::OpenRouter for :openrouter)
+    #   3. Pricing::ModelsDev general fallback
+    #   → nil when no data found at any tier
+    def lookup_model_cost(entry)
+      return nil unless entry
+
+      model    = entry[:model].to_s
+      provider = entry[:provider].to_sym
+
+      source = PROVIDER_PRICING_SOURCES[provider]
+      cost   = source&.find(model)
+      return cost if cost
+
+      Pricing::ModelsDev.find(model)
+    rescue StandardError
+      nil
+    end
+
+    # Builds a CostBreakdown from token counts and per-million rates.
+    # Returns nil when pricing or token data is absent.
     def calculate_cost(pricing, tokens)
       return nil unless pricing && tokens
       return nil unless pricing.input_per_million && pricing.output_per_million

data/lib/active_harness/agent.rb

@@ -198,18 +198,6 @@ module ActiveHarness
       UsageInfo.new(tokens: tokens, cost: cost)
     end
 
-    def lookup_model_cost(entry)
-      return nil unless entry
-
-      if entry[:provider].to_sym == :openrouter
-        Pricing::OpenRouter.find(entry[:model].to_s) || Pricing.find(entry[:model].to_s)
-      else
-        Pricing.find(entry[:model].to_s)
-      end
-    rescue StandardError
-      nil
-    end
-
     def normalize_input!
       return if @config.fetch(:normalize_input, true) == false
       @input = @input&.strip&.gsub(/\s+/, " ")

data/lib/active_harness/pipeline/step.rb

@@ -1,18 +1,18 @@
 module ActiveHarness
   class Pipeline
     class Step
-      attr_reader :name, :agent_class
+      attr_reader :name, :executor
 
-      def initialize(name, agent_class = nil, &block)
-        @name        = name
-        @agent_class = agent_class
-        @stop_if     = nil
+      def initialize(name, executor = nil, &block)
+        @name     = name
+        @executor = executor
+        @stop_if  = nil
         instance_eval(&block) if block_given?
       end
 
-      # DSL: use TranslationAgent
+      # DSL: use TranslationAgent / SafetyTribunal / NestedPipeline
       def use(klass)
-        @agent_class = klass
+        @executor = klass
       end
 
       # DSL (inside block): stop_if ->(result) { ... }
@@ -35,9 +35,13 @@ module ActiveHarness
         @transform_block
       end
 
-      # True if agent_class is a Tribunal subclass — tribunal steps do not update payload.
+      def lambda?
+        @executor.is_a?(Proc)
+      end
+
+      # True if the executor is a Tribunal subclass — tribunal steps do not update payload.
       def tribunal?
-        @agent_class.is_a?(Class) && @agent_class <= ActiveHarness::Tribunal
+        @executor.is_a?(Class) && @executor <= ActiveHarness::Tribunal
       end
 
       # Returns true when this step should update the pipeline payload after execution.

data/lib/active_harness/pipeline.rb

@@ -29,7 +29,7 @@ module ActiveHarness
   #   pipeline.call
   #   pipeline.output       # => final payload string (nil if stopped)
   #   pipeline.stopped?     # => false
-  #   pipeline.step_results # => { translate: <Result>, ... }
+  #   pipeline.steps { |name, result| ... }  # iterate over completed steps
   #
   class Pipeline
     # -------------------------------------------------------------------------
@@ -46,8 +46,8 @@ module ActiveHarness
       #     use InjectionGuardAgent
       #     stop_if ->(result) { result.processed["detected"] == true }
       #   end
-      def step(name, agent_class = nil, &block)
-        pipeline_config[:steps] << Pipeline::Step.new(name, agent_class, &block)
+      def step(name, executor = nil, &block)
+        pipeline_config[:steps] << Pipeline::Step.new(name, executor, &block)
       end
 
       def pipeline_config
@@ -100,7 +100,6 @@ module ActiveHarness
                   :stopped_at,
                   :stop_reason,
                   :execution_time,
-                  :step_results,
                   :context
     attr_writer   :context
     attr_accessor :params
@@ -126,6 +125,7 @@ module ActiveHarness
       @token          = token
       class_streams   = self.class.pipeline_config[:streams] || {}
       @stream         = merge_stream(stream, class_streams)
+      @executors      = build_executors
       @step_results   = {}
       @stopped        = false
       @stopped_at     = nil
@@ -134,10 +134,44 @@ module ActiveHarness
       @output         = nil
     end
 
+    # Returns a hash of pre-created executor instances keyed by step name.
+    # Available immediately after new — before call — so instances can be
+    # configured (model lists, params, etc.) before execution begins.
+    #
+    #   pipeline = SupportPipeline.new(input: "...")
+    #   pipeline.executors[:translate].models.prepend(provider: :openai, model: "gpt-4.1")
+    #   pipeline.executors[:guard].params = { strict: true }
+    #   pipeline.call
+    def executors
+      @executors
+    end
+
     def stopped?
       @stopped
     end
 
+    # Iterates over completed steps as (name, executor, result) tuples.
+    # Steps that did not run (pipeline stopped before reaching them) are skipped.
+    # Returns an Enumerator when called without a block.
+    #
+    #   pipeline.steps { |name, executor, result| }
+    #
+    #   name     — step name symbol          (:translate, :guard, …)
+    #   executor — the instance that ran     (TranslationAgent instance, …)
+    #   result   — Result struct             (output, processed, usage, model, …)
+    #
+    #   pipeline.steps.map { |name, executor, result| [name, result.output] }
+    #   pipeline.steps.to_a
+    def steps
+      return enum_for(:steps) unless block_given?
+      self.class.pipeline_config[:steps].each do |step|
+        result = @step_results[step.name]
+        next unless result
+        yield step.name, @executors[step.name], result
+      end
+      self
+    end
+
     # Wraps pipeline outcome into a Result so a pipeline can be used as a step
     # inside another pipeline, matching the same interface as Agent and Tribunal.
     #
@@ -153,7 +187,15 @@ module ActiveHarness
     end
 
     # Execute all steps sequentially. Returns self for chaining.
-    def call
+    # Accepts optional input, token, stream to match the Agent/Tribunal call interface.
+    def call(input = nil, token: nil, stream: nil)
+      if input
+        @original_input = input
+        @payload        = input
+      end
+      @token  = token  if token
+      @stream = stream if stream
+
       config = self.class.pipeline_config
       t0     = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -231,13 +273,40 @@ module ActiveHarness
     end
 
     def execute_step(step)
-      step.agent_class.new(
-        input:   @payload,
-        context: @context.dup,
-        params:  @params,
-        token:   @token,
-        stream:  @stream
-      ).call.result
+      if step.lambda?
+        execute_lambda_step(step)
+      else
+        instance         = @executors[step.name]
+        instance.context = @context.dup
+        instance.call(@payload).result
+      end
+    end
+
+    def execute_lambda_step(step)
+      lam    = step.executor
+      has_kw = lam.parameters.any? { |type, _| [:key, :keyreq, :keyrest].include?(type) }
+      result = has_kw ? lam.call(@payload, context: @context.dup, params: @params) : lam.call(@payload)
+
+      unless result.is_a?(Result)
+        raise ArgumentError,
+          "Lambda step :#{step.name} must return ActiveHarness::Result, got #{result.class}"
+      end
+
+      result
+    end
+
+    def build_executors
+      self.class.pipeline_config[:steps].each_with_object({}) do |step, hash|
+        next if step.lambda?
+
+        hash[step.name] = step.executor.new(
+          input:   @payload,
+          context: @context.dup,
+          params:  @params,
+          token:   @token,
+          stream:  @stream
+        )
+      end
     end
   end
 end

data/lib/active_harness/tribunal.rb

@@ -105,11 +105,17 @@ module ActiveHarness
     # Run all agents in parallel, then compute the verdict.
     # Returns self so calls can be chained: tribunal.call.verdict
     #
+    # Accepts an optional input to update payload before running — matches
+    # the Agent#call(input) interface so tribunals work as pipeline executors.
+    #
     # Behaviour on failure:
     #   - If some agents fail/timeout, their errors are in #errors and
     #     #results contains only successful results.
     #   - If ALL agents fail/timeout, raises Errors::AllAgentsFailed.
-    def call
+    def call(input = nil, token: nil, stream: nil)
+      @input  = input  if input
+      @token  = token  if token
+      @stream = stream if stream
       agents = resolve_agents
       fire(:before_call)
 

data/lib/active_harness.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.37
+  version: 0.2.39
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-14 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby