active_harness 0.2.30 → 0.2.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5f759449bd21052f986bc092a621f2ce39cb4faa630ba1bc759419bc27aac37
-  data.tar.gz: 94e8abc9d0a0ca7ef877ea0f1e66ac68899236d7d33f10ac754f3541b3a29d1b
+  metadata.gz: d6d0a8c421353c670b4f0ba80cab409a05c97a1505382fd35a0822b39d66691a
+  data.tar.gz: a312b8db19958a621d26aee139d9bbe284f269690991b02008a2e6716fb08d7b
 SHA512:
-  metadata.gz: 8a9529f9391337660a325993adf7db17bd2f470f6b2e69cab256a1ac907616d0c76a5c5b4c56f9850399fbfb8d886b3f2d2c2241c6ceb66ea0d83cb0e2d4c724
-  data.tar.gz: e1ae97b30a763b761ae28d20b957670d5b8a774d249456cfd84da09830ce6ebc8661c2d19790a69ff2889ff585ce7af307beb13b5d46886708db041fd1c33d73
+  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/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.30"
+  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.30
+  version: 0.2.31
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-11 00:00:00.000000000 Z
+date: 2026-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby