active_harness_pricing 0.1.3 → 0.1.4

data/lib/active_harness/pricing/normalizer.rb

@@ -0,0 +1,44 @@
+module ActiveHarness
+  module Pricing
+    # Converts any model identifier or display name to a canonical lookup key.
+    #
+    # Works on both raw provider model IDs and human-readable display names,
+    # producing the same key for the same model regardless of source.
+    #
+    # Examples:
+    #   Normalizer.to_key("Mistral Nemo")                                # => "mistral-nemo"
+    #   Normalizer.to_key("mistralai/mistral-nemo")                      # => "mistral-nemo"
+    #   Normalizer.to_key("GPT-4o")                                      # => "gpt-4o"
+    #   Normalizer.to_key("gpt-4o")                                      # => "gpt-4o"
+    #   Normalizer.to_key("claude-3-5-haiku-20241022")                   # => "claude-3-5-haiku"
+    #   Normalizer.to_key("global.anthropic.claude-haiku-4-5-20251001-v1:0") # => "claude-haiku-4-5"
+    #   Normalizer.to_key("models/gemini-2.5-flash")                     # => "gemini-2-5-flash"
+    module Normalizer
+      def self.to_key(str)
+        s = str.to_s.downcase
+
+        # Strip "author/" prefix  ("mistralai/mistral-nemo" → "mistral-nemo")
+        s = s.split("/").last if s.include?("/")
+
+        # Strip leading "word." segments  ("global.anthropic.claude-..." → "claude-...")
+        s = s.sub(/\A[a-z]+\./, "") while s.match?(/\A[a-z]+\.[a-z]/)
+
+        # Normalize all non-alphanumeric characters to hyphens
+        s = s.gsub(/[^a-z0-9]/, "-")
+
+        # Strip date suffixes and everything that follows
+        s = s.gsub(/-\d{8}.*/, "")             # -YYYYMMDD...
+        s = s.gsub(/-\d{4}-\d{2}-\d{2}.*/, "") # -YYYY-MM-DD...
+        s = s.gsub(/-\d{2}-\d{2}$/, "")        # trailing -MM-DD (Gemini preview dates)
+
+        # Strip version suffixes  ("-v2:0", "-v1-0")
+        s = s.gsub(/-v\d+(-\d+)?$/, "")
+
+        # Strip common qualifiers
+        s = s.gsub(/-(latest|online|free|exp)$/, "")
+
+        s.squeeze("-").gsub(/^-|-$/, "")
+      end
+    end
+  end
+end

data/lib/active_harness/pricing/price_resolver.rb

@@ -0,0 +1,128 @@
+module ActiveHarness
+  module Pricing
+    # Queries all pricing sources for a given model and calculates costs.
+    #
+    # All cost methods accept either an agent/result object OR explicit keyword args:
+    #
+    #   PriceResolver.max_cost(result)          # from ActiveHarness agent result
+    #   PriceResolver.max_cost(agent)           # from ActiveHarness agent instance
+    #   PriceResolver.max_cost(model_id: "gpt-4o", tokens_input: 1000, tokens_output: 500)
+    #
+    # Resolved keys are cached in memory (TTL: 24h) — in production only a handful
+    # of models are used, so the first lookup pays the search cost and every
+    # subsequent call returns instantly from cache.
+    module PriceResolver
+      DATA_DIR  = File.expand_path("../../../data", __dir__)
+      CACHE_TTL = 86_400  # 24 hours
+
+      SOURCES = {
+        pricepertoken: Source.new(File.join(DATA_DIR, "pricepertoken.json"), :pricepertoken),
+        modelsdev:     Source.new(File.join(DATA_DIR, "modelsdev.json"),     :modelsdev),
+        openrouter:    Source.new(File.join(DATA_DIR, "openrouter.json"),    :openrouter)
+      }.freeze
+
+      class << self
+        # Returns { source_name => PricingData } for every source that has this model.
+        # Result is cached by canonical key for CACHE_TTL seconds.
+        def resolve(model_id)
+          key = Normalizer.to_key(model_id)
+
+          cached = resolve_cache[key]
+          return cached unless cached.nil?
+
+          result = SOURCES.each_with_object({}) do |(name, source), h|
+            hit = source.find(key)
+            h[name] = hit if hit&.input_per_1m && hit&.output_per_1m
+          end
+
+          resolve_cache[key] = result
+          result
+        end
+
+        # Returns { source_name => Float (USD) } — calculated cost per source.
+        # Accepts a result/agent object or keyword args.
+        def costs(subject = nil, model_id: nil, tokens_input: 0, tokens_output: 0)
+          args = extract_args(subject, model_id: model_id, tokens_input: tokens_input, tokens_output: tokens_output)
+          tokens_in  = args[:tokens_input].to_i
+          tokens_out = args[:tokens_output].to_i
+          resolve(args[:model_id]).transform_values do |p|
+            (tokens_in  * p.input_per_1m  / 1_000_000.0) +
+            (tokens_out * p.output_per_1m / 1_000_000.0)
+          end
+        end
+
+        # Returns the highest cost estimate across all sources (conservative upper bound).
+        # Accepts a result/agent object or keyword args.
+        # Returns nil when no pricing data found.
+        # Returns { cost: Float, source: Symbol, all: Hash } otherwise.
+        def max_cost(subject = nil, model_id: nil, tokens_input: 0, tokens_output: 0, provider_cost: nil)
+          args = extract_args(subject, model_id: model_id, tokens_input: tokens_input,
+                                       tokens_output: tokens_output, provider_cost: provider_cost)
+
+          return provider_result(args[:provider_cost], args[:model_id]) if args[:provider_cost].to_f > 0
+
+          all = costs(model_id: args[:model_id], tokens_input: args[:tokens_input], tokens_output: args[:tokens_output])
+          return nil if all.empty?
+
+          src, cost = all.max_by { |_, v| v }
+          { cost: cost, source: src, all: all }
+        end
+
+        # Returns the lowest cost estimate across all sources (optimistic lower bound).
+        # Accepts a result/agent object or keyword args.
+        # Returns nil when no pricing data found.
+        # Returns { cost: Float, source: Symbol, all: Hash } otherwise.
+        def min_cost(subject = nil, model_id: nil, tokens_input: 0, tokens_output: 0, provider_cost: nil)
+          args = extract_args(subject, model_id: model_id, tokens_input: tokens_input,
+                                       tokens_output: tokens_output, provider_cost: provider_cost)
+
+          return provider_result(args[:provider_cost], args[:model_id]) if args[:provider_cost].to_f > 0
+
+          all = costs(model_id: args[:model_id], tokens_input: args[:tokens_input], tokens_output: args[:tokens_output])
+          return nil if all.empty?
+
+          src, cost = all.min_by { |_, v| v }
+          { cost: cost, source: src, all: all }
+        end
+
+        # Clears the resolve cache. Useful in tests or after manually refreshing data files.
+        def clear_cache!
+          @resolve_cache  = nil
+          @cache_built_at = nil
+        end
+
+        private
+
+        # Normalizes arguments from either a result/agent object or explicit keyword args.
+        # An agent is any object that responds to :result (ActiveHarness agent instance).
+        # A result is any object with .model.name and .usage.tokens.{input,output}.
+        def extract_args(subject, model_id: nil, tokens_input: 0, tokens_output: 0, provider_cost: nil)
+          return { model_id: model_id, tokens_input: tokens_input,
+                   tokens_output: tokens_output, provider_cost: provider_cost } if subject.nil?
+
+          result = subject.respond_to?(:result) ? subject.result : subject
+
+          {
+            model_id:      result.model&.name.to_s,
+            tokens_input:  result.usage&.tokens&.input.to_i,
+            tokens_output: result.usage&.tokens&.output.to_i,
+            provider_cost: result.usage&.cost&.total
+          }
+        end
+
+        # Cache hash, reset automatically after CACHE_TTL.
+        def resolve_cache
+          if @cache_built_at.nil? || (Time.now - @cache_built_at) >= CACHE_TTL
+            @resolve_cache  = {}
+            @cache_built_at = Time.now
+          end
+          @resolve_cache
+        end
+
+        def provider_result(cost, model_id)
+          { cost: cost.to_f, source: :provider, all: { provider: cost.to_f } }
+        end
+      end
+    end
+  end
+end

data/lib/active_harness/pricing/source.rb

@@ -0,0 +1,110 @@
+require "json"
+
+module ActiveHarness
+  module Pricing
+    # Reads a standardized pricing data file and looks up models by canonical key.
+    # Data is loaded lazily on first access and reloaded automatically after CACHE_TTL.
+    #
+    # Data file format (JSON hash):
+    #   {
+    #     "mistral-nemo": {
+    #       "name":                "Mistral Nemo",
+    #       "input_per_1m":        0.02,
+    #       "output_per_1m":       0.03,
+    #       "context_window":      131072,
+    #       "tokens_per_second":   56.87,   # optional
+    #       "time_to_first_token": 0.99     # optional
+    #     }
+    #   }
+    #
+    # Usage:
+    #   src = Source.new("data/pricepertoken.json", :pricepertoken)
+    #   src.find("mistral-nemo")           # exact
+    #   src.find("mistral-nemo-instruct")  # prefix fallback
+    class Source
+      CACHE_TTL = 86_400  # 24 hours
+
+      PricingData = Struct.new(
+        :key,
+        :name,
+        :source,
+        :input_per_1m,
+        :output_per_1m,
+        :context_window,
+        :tokens_per_second,
+        :time_to_first_token,
+        keyword_init: true
+      ) do
+        def inspect
+          "#<PricingData source=#{source} key=#{key.inspect}" \
+            " in=$#{input_per_1m}/M out=$#{output_per_1m}/M>"
+        end
+      end
+
+      def initialize(data_file, source_name)
+        @data_file   = data_file
+        @source_name = source_name.to_sym
+      end
+
+      # Finds a model by canonical key.
+      # Falls back to prefix match when exact key is not found
+      # (e.g. "mistral-nemo-instruct-2407" → finds "mistral-nemo").
+      def find(canonical_key)
+        key = canonical_key.to_s
+
+        raw = data[key]
+        return build(key, raw) if raw
+
+        # prefix fallback: find the longest stored key that is a prefix of the lookup key
+        match_key, match_raw = data
+          .select { |k, _| key.start_with?(k) && k.length >= 5 }
+          .max_by { |k, _| k.length }
+
+        build(match_key, match_raw) if match_raw
+      end
+
+      def all
+        data.map { |key, raw| build(key, raw) }
+      end
+
+      def reload!
+        @data      = nil
+        @loaded_at = nil
+      end
+
+      private
+
+      def data
+        expire_if_stale
+        @data ||= load_data
+      end
+
+      def expire_if_stale
+        return unless @loaded_at && (Time.now - @loaded_at) >= CACHE_TTL
+        @data      = nil
+        @loaded_at = nil
+      end
+
+      def load_data
+        @loaded_at = Time.now
+        return {} unless File.exist?(@data_file)
+        JSON.parse(File.read(@data_file))
+      rescue StandardError
+        {}
+      end
+
+      def build(key, raw)
+        PricingData.new(
+          key:                 key,
+          name:                raw["name"],
+          source:              @source_name,
+          input_per_1m:        raw["input_per_1m"],
+          output_per_1m:       raw["output_per_1m"],
+          context_window:      raw["context_window"],
+          tokens_per_second:   raw["tokens_per_second"],
+          time_to_first_token: raw["time_to_first_token"]
+        )
+      end
+    end
+  end
+end

data/lib/active_harness_pricing.rb

@@ -1,7 +1,10 @@
 require_relative "active_harness/pricing"
 require_relative "active_harness/pricing/models_dev"
 require_relative "active_harness/pricing/openrouter"
+require_relative "active_harness/pricing/normalizer"
+require_relative "active_harness/pricing/source"
+require_relative "active_harness/pricing/price_resolver"
 
 module ActiveHarnessPricing
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_harness_pricing
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - the-teacher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-14 00:00:00.000000000 Z
+date: 2026-06-16 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -17,9 +17,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- data/README.md
+- data/modelsdev.json
+- data/openrouter.json
+- data/pricepertoken.json
 - lib/active_harness/pricing.rb
 - lib/active_harness/pricing/models_dev.rb
+- lib/active_harness/pricing/normalizer.rb
 - lib/active_harness/pricing/openrouter.rb
+- lib/active_harness/pricing/price_resolver.rb
+- lib/active_harness/pricing/source.rb
 - lib/active_harness_pricing.rb
 homepage: https://github.com/the-teacher/active_harness
 licenses: