active_harness 0.2.29 → 0.2.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7146a492cd9454703ab47eb1c6222962587b4fe5585aaef2a5390349da394a1a
-  data.tar.gz: 476ee4d22259b10fa7d58cd25208ea5c900e6523991b1f17e288f7c3104cfd92
+  metadata.gz: d6d0a8c421353c670b4f0ba80cab409a05c97a1505382fd35a0822b39d66691a
+  data.tar.gz: a312b8db19958a621d26aee139d9bbe284f269690991b02008a2e6716fb08d7b
 SHA512:
-  metadata.gz: d211c987a80244262c35fbc83202491b61807ee98f092808ca801cfcc57eb1ad58e4f48ccf8e364078b99a267e14816e8551b55c5b2a3de2fe8e6828321bc2b6
-  data.tar.gz: 71244082f0e0c81d9fe7d0271e05dd53ebf0e5a727ced5554d637e84aed8a58b6a014e8b0537ff2dcc10cc501385905b78c5aae8f328c1d774a874fc30d3c7b3
+  metadata.gz: bc0be024611a21164721a379741f48cf2547ebb4b5bd64f15bb3cdf5bae41e8bdbbe7f0d576c41ddd24a5167488bd2db2729cb659d699f3aceffda2791664998
+  data.tar.gz: 329d8648ae84605f6ecbd2ee9112a9a0abf39a4d3f4a2fb98ee6814b79e7bd8167a1fd807e1a994dc5d299475b02b603e48d65a4270fa01b9082ca5ecf499900

data/lib/active_harness/agent/cost.rb

@@ -2,25 +2,23 @@ module ActiveHarness
   class Agent
     private
 
-    # Calculates the monetary cost of a single request based on token usage
-    # and pricing data from ActiveHarness::Costs.
+    # Builds a CostBreakdown for a single request from token usage and
+    # pricing data from ActiveHarness::Costs.
     #
-    # Returns a hash { input_cost:, output_cost:, total_cost: } in USD,
+    # Returns CostBreakdown (input, output, total in USD),
     # or nil if usage is absent or the model is not found in the pricing registry.
-    def calculate_cost(model_id, usage)
-      return nil if model_id.nil? || usage.nil?
+    def calculate_cost(pricing, tokens)
+      return nil unless pricing && tokens
+      return nil unless pricing.input_per_million && pricing.output_per_million
 
-      pricing = ActiveHarness::Costs.find(model_id.to_s)
-      return nil unless pricing&.input_per_million && pricing&.output_per_million
+      input_cost  = (tokens.input.to_f  / 1_000_000) * pricing.input_per_million
+      output_cost = (tokens.output.to_f / 1_000_000) * pricing.output_per_million
 
-      input_cost  = (usage[:input_tokens].to_f  / 1_000_000) * pricing.input_per_million
-      output_cost = (usage[:output_tokens].to_f / 1_000_000) * pricing.output_per_million
-
-      {
-        input_cost:  input_cost.round(8),
-        output_cost: output_cost.round(8),
-        total_cost:  (input_cost + output_cost).round(8)
-      }
+      CostBreakdown.new(
+        input:  input_cost.round(8),
+        output: output_cost.round(8),
+        total:  (input_cost + output_cost).round(8)
+      )
     rescue StandardError
       nil
     end

data/lib/active_harness/agent/prompt.rb

@@ -57,7 +57,13 @@ module ActiveHarness
       obj.instance_variable_set(:@params,         @params)
       obj.instance_variable_set(:@config,         @config)
       obj.instance_variable_set(:@memory,         @memory)
-      obj.instance_variable_set(:@context_window, @context_window)
+      obj.instance_variable_set(:@context_window, context_window_for_prompt)
+    end
+
+    def context_window_for_prompt
+      Costs.find(model_list.to_a.first&.dig(:model).to_s)&.context_window
+    rescue StandardError
+      nil
     end
   end
 end

data/lib/active_harness/agent.rb

@@ -54,7 +54,6 @@ module ActiveHarness
                   :params,
                   :memory
     attr_reader   :result,
-                  :context_window,
                   :token_stream,
                   :event_stream
 
@@ -77,9 +76,8 @@ module ActiveHarness
       @context         = context
       @params          = params
       @memory          = memory
-      @models_override  = Array(models) if models
-      @context_window   = lookup_context_window(self.models.to_a.first)
-      @token_stream     = streams[:token]
+      @models_override = Array(models) if models
+      @token_stream    = streams[:token]
       @event_stream     = streams[:agent]
       fire(:setup)
     end
@@ -146,31 +144,59 @@ module ActiveHarness
     end
 
     def build_result(response, entry, attempts, elapsed)
-      raw       = response[:content]
-      processed = parse_output(raw)
-      usage     = response[:usage]
-      cw        = lookup_context_window(entry)
+      raw        = response[:content]
+      processed  = parse_output(raw)
+      raw_usage  = response[:usage]
+      model_cost = lookup_model_cost(entry)
 
       Result.new(
         input:          @input,
         output:         raw,
         processed:      processed,
         system_prompt:  @system_prompt,
-        provider:       entry[:provider],
-        model:          entry[:model],
-        temperature:    entry[:temperature],
+        model:          build_model_info(entry, model_cost),
         model_list:     model_list,
         attempts:       attempts,
         execution_time: elapsed,
-        usage:          usage,
-        cost:           calculate_cost(entry[:model], usage),
-        context_window: cw
+        usage:          build_usage(raw_usage, model_cost)
+      )
+    end
+
+    def build_model_info(entry, model_cost)
+      pricing = if model_cost&.input_per_million && model_cost&.output_per_million
+        ModelPricing.new(
+          input:  (model_cost.input_per_million  / 1_000_000.0).round(10),
+          output: (model_cost.output_per_million / 1_000_000.0).round(10)
+        )
+      end
+
+      ModelInfo.new(
+        name:           entry[:model],
+        provider:       entry[:provider],
+        temperature:    entry[:temperature],
+        context_window: model_cost&.context_window,
+        pricing:        pricing
+      )
+    end
+
+    def build_usage(raw_usage, model_cost)
+      return nil if raw_usage.nil?
+
+      tokens = TokenCounts.new(
+        input:  raw_usage[:input_tokens],
+        output: raw_usage[:output_tokens],
+        total:  raw_usage[:total_tokens]
+      )
+
+      UsageInfo.new(
+        tokens: tokens,
+        cost:   calculate_cost(model_cost, tokens)
       )
     end
 
-    def lookup_context_window(entry)
+    def lookup_model_cost(entry)
       return nil unless entry
-      Costs.find(entry[:model])&.context_window
+      Costs.find(entry[:model].to_s)
     rescue StandardError
       nil
     end

data/lib/active_harness/pipeline/step.rb

@@ -21,15 +21,37 @@ module ActiveHarness
         lam ? @stop_if = lam : @stop_if
       end
 
+      # DSL: define how to extract the new payload from a result.
+      # When provided, the step always updates the payload — even if stop_if is also set.
+      # The block receives the Result and must return the new payload value.
+      #
+      #   step :laundry do
+      #     use PromptLaundryPipeline
+      #     transform { |result| result.output }
+      #     stop_if   ->(result) { result.processed["stopped"] == true }
+      #   end
+      def transform(&block)
+        @transform_block = block if block
+        @transform_block
+      end
+
       # True if agent_class is a Tribunal subclass — tribunal steps do not update payload.
       def tribunal?
         @agent_class.is_a?(Class) && @agent_class <= ActiveHarness::Tribunal
       end
 
-      # Transform steps update payload to result.output after execution.
-      # Guard steps (stop_if present) and tribunal steps leave payload unchanged.
+      # Returns true when this step should update the pipeline payload after execution.
+      # A step transforms when:
+      #   - an explicit transform block is defined (overrides default), OR
+      #   - no stop_if and not a tribunal (legacy default)
       def transform?
-        !tribunal? && @stop_if.nil?
+        @transform_block ? true : (!tribunal? && @stop_if.nil?)
+      end
+
+      # Extract the new payload value from result.
+      # Uses the user-defined transform block when present; falls back to result.output.
+      def extract_payload(result)
+        @transform_block ? @transform_block.call(result) : result.output
       end
     end
   end

data/lib/active_harness/pipeline.rb

@@ -140,6 +140,20 @@ module ActiveHarness
       @stopped
     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.
+    #
+    # output    — final payload (nil when stopped)
+    # processed — { "stopped" => bool, "stopped_at" => step_name_string_or_nil }
+    def result
+      Result.new(
+        input:          @original_input,
+        output:         @output,
+        processed:      { "stopped" => @stopped, "stopped_at" => @stopped_at&.to_s },
+        execution_time: @execution_time
+      )
+    end
+
     # Execute all steps sequentially. Returns self for chaining.
     def call
       config = self.class.pipeline_config
@@ -155,7 +169,7 @@ module ActiveHarness
 
         @step_results[step.name] = result
         @context[step.name]      = result
-        @payload                 = result.output if step.transform?
+        @payload                 = step.extract_payload(result) if step.transform?
 
         fire(:after_step, step.name, result, config)
         fire_step(:after_step, step.name, result, config)
@@ -210,7 +224,12 @@ module ActiveHarness
     end
 
     def execute_step(step)
-      streams = { token: @token_stream, agent: @agent_event_stream, tribunal: @tribunal_event_stream }.compact
+      streams = {
+        token:    @token_stream,
+        agent:    @agent_event_stream,
+        tribunal: @tribunal_event_stream,
+        pipeline: @pipeline_event_stream
+      }.compact
       step.agent_class.new(
         input:   @payload,
         context: @context.dup,

data/lib/active_harness/result.rb

@@ -1,24 +1,64 @@
 require "json"
 
 module ActiveHarness
-  # Minimal result wrapper returned by Agent#call.
+  # Value objects for structured result data.
+
+  # Pricing rates for a model (per-token, from Costs registry).
+  # nil when the model is not found in the pricing registry.
+  ModelPricing = Struct.new(:input, :output, keyword_init: true)
+
+  # Static model metadata resolved at call time.
+  ModelInfo = Struct.new(
+    :name,
+    :provider,
+    :temperature,
+    :context_window,
+    :pricing,         # ModelPricing or nil
+    keyword_init: true
+  ) do
+    def to_s; name.to_s; end
+    def inspect
+      parts = ["name=#{name.inspect}", "provider=#{provider.inspect}"]
+      parts << "temperature=#{temperature}" if temperature
+      parts << "context_window=#{context_window}" if context_window
+      parts << "pricing=#{pricing.inspect}" if pricing
+      "#<ModelInfo #{parts.join(' ')}>"
+    end
+  end
+
+  # Token counts for a single call.
+  TokenCounts = Struct.new(:input, :output, :total, keyword_init: true)
+
+  # Monetary cost of a single call in USD.
+  # nil when pricing data is unavailable.
+  CostBreakdown = Struct.new(:input, :output, :total, keyword_init: true)
+
+  # Combined token + cost stats for a single agent call.
+  # tokens is always present (raw provider data).
+  # cost is nil when pricing is unavailable.
+  UsageInfo = Struct.new(:tokens, :cost, keyword_init: true)
+
+  # Result returned by Agent#call (accessible via agent.result).
   #
-  # output — raw string from the provider
-  # processed — for format :json: a Ruby Hash/Array; for format :text: same as output
-  # usage  — token counts: { input_tokens:, output_tokens:, total_tokens: } or nil for streaming
-  # cost   — { input_cost:, output_cost:, total_cost: } in USD, or nil if pricing unavailable
+  #   result.input            — original input string
+  #   result.output           — raw string from the provider
+  #   result.processed        — parsed Hash/Array for :json agents, raw string for :text
+  #   result.system_prompt    — resolved system prompt string
+  #   result.model            — ModelInfo (name, provider, temperature, context_window, pricing)
+  #   result.model_list       — full model chain proxy
+  #   result.attempts         — Array of failed attempt entries before success
+  #   result.execution_time   — wall-clock seconds for the successful call
+  #   result.usage            — UsageInfo (tokens + cost), nil for streaming without usage
   Result = Struct.new(
     :input,
     :output,
     :processed,
     :system_prompt,
-    :provider, :model,
-    :temperature,
+    :model,           # ModelInfo
     :model_list,
     :attempts,
     :execution_time,
-    :usage,
-    :cost,
-    :context_window,
-    keyword_init: true)
+    :usage,           # UsageInfo or nil
+    keyword_init: true
+  )
 end

data/lib/active_harness.rb

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

data/lib/generators/active_harness/install/templates/controllers/ai_controller.rb

@@ -12,7 +12,7 @@ class AiSupportController < ApplicationController
 
     render json: {
       output: result.output,
-      model:  result.model,
+      model:  result.model.name,
       time:   result.execution_time
     }
   end
@@ -30,7 +30,7 @@ class AiSupportController < ApplicationController
 
     render json: {
       output: result.output,
-      model:  result.model,
+      model:  result.model.name,
       time:   result.execution_time,
       turns:  memory.size
     }

metadata

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