llm_cost_tracker 0.12.0 → 0.13.0

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -9,22 +9,36 @@ module LlmCostTracker
     module Matcher
       Match = Data.define(:source, :key, :prices, :matched_by)
 
+      CACHE_LIMIT = 2048
+      private_constant :CACHE_LIMIT
+
       class << self
         def lookup(provider:, model:)
           provider_name = provider.to_s.presence
           model_name = model.to_s
           return nil if model_name.empty?
 
-          lookup_match(provider_name: provider_name, model_name: model_name)
+          sources = Registry.sources
+          reset_cache(sources) unless @cache_sources.equal?(sources)
+          key = [provider_name, model_name].freeze
+          return @cache[key] if @cache.key?(key)
+
+          @cache.clear if @cache.size >= CACHE_LIMIT
+          @cache[key] = lookup_match(sources, provider_name, model_name)
         end
 
         private
 
-        def lookup_match(provider_name:, model_name:)
+        def reset_cache(sources)
+          @cache_sources = sources
+          @cache = {}
+        end
+
+        def lookup_match(sources, provider_name, model_name)
           provider_model = provider_name ? "#{provider_name}/#{model_name}" : model_name
           normalized = normalize_model_name(model_name)
 
-          Registry.sources.each do |source|
+          sources.each do |source|
             match = match_in_source(source, provider_model, model_name, normalized)
             return match if match
           end

data/lib/llm_cost_tracker/pricing/mode.rb

@@ -4,8 +4,8 @@ module LlmCostTracker
   module Pricing
     module Mode
       STANDARD_MODE_VALUES = %w[auto default standard standard_only unspecified].freeze
-      COMPOUND_MODIFIERS = %w[data_residency].freeze
       KNOWN_MODIFIERS = %w[batch flex priority scale fast on_demand data_residency].freeze
+      HOST_DERIVED_MODIFIERS = %w[data_residency].freeze
       MAX_PERMUTED_MODIFIERS = 6
 
       def self.normalize(value)
@@ -23,7 +23,7 @@ module LlmCostTracker
         return normalize(request_mode) if provider_mode.to_s.strip.empty?
 
         provider_tokens = tokenize(provider_mode) - STANDARD_MODE_VALUES
-        request_host_tokens = tokenize(request_mode || "") & COMPOUND_MODIFIERS
+        request_host_tokens = tokenize(request_mode || "") & HOST_DERIVED_MODIFIERS
         combined = provider_tokens | request_host_tokens
         return nil if combined.empty?
 
@@ -41,12 +41,12 @@ module LlmCostTracker
         loop do
           break if remaining.empty?
 
-          compound = COMPOUND_MODIFIERS.find do |token|
-            remaining == token || remaining.start_with?("#{token}_")
+          known = KNOWN_MODIFIERS.find do |modifier|
+            remaining == modifier || remaining.start_with?("#{modifier}_")
           end
-          if compound
-            tokens << compound
-            remaining = remaining.delete_prefix(compound).delete_prefix("_")
+          if known
+            tokens << known
+            remaining = remaining.delete_prefix(known).delete_prefix("_")
           else
             first, _, rest = remaining.partition("_")
             tokens << first unless first.empty?

data/lib/llm_cost_tracker/tracker.rb

@@ -13,16 +13,15 @@ module LlmCostTracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
     class << self
-      def record(event:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil, enforce_budget: false)
+      def record(event:, latency_ms: nil, metadata: {}, context_tags: nil, enforce_budget: false)
         return unless LlmCostTracker.configuration.enabled
 
-        pricing_mode ||= event.pricing_mode
         calculation = Pricing::Calculation.for(
           provider: event.provider,
           model: event.model,
           tokens: event.token_usage,
           line_items: event.line_items,
-          pricing_mode: pricing_mode,
+          pricing_mode: event.pricing_mode,
           usage_source: event.usage_source
         )
 

data/lib/llm_cost_tracker/usage/catalog.rb

@@ -31,6 +31,10 @@ module LlmCostTracker
           @token_priced ||= all.select(&:token_key).freeze
         end
 
+        def find_by(kind:, direction:, modality:, cache_state:, unit:)
+          by_attributes[[kind, direction, modality, cache_state, unit]]
+        end
+
         def token_priced_for(kind:, direction:, cache_state:)
           token_priced.find do |dimension|
             dimension.kind == kind && dimension.direction == direction && dimension.cache_state == cache_state
@@ -43,6 +47,13 @@ module LlmCostTracker
           @index ||= all.to_h { |dimension| [dimension.key, dimension] }.freeze
         end
 
+        def by_attributes
+          @by_attributes ||= all.to_h do |dimension|
+            key = [dimension.kind, dimension.direction, dimension.modality, dimension.cache_state, dimension.unit]
+            [key, dimension]
+          end.freeze
+        end
+
         def load_definitions
           Psych.safe_load_file(DEFINITIONS_PATH, permitted_classes: [], symbolize_names: true)
                .map { |attributes| build(attributes) }

data/lib/llm_cost_tracker/usage/dimensions.yml

@@ -140,27 +140,3 @@
   cache_state: none
   unit: minute
   rate_basis: per_minute
-
-- key: image_generation_call
-  kind: image_generation_call
-  direction: output
-  modality: image
-  cache_state: none
-  unit: image
-  rate_basis: per_image
-
-- key: computer_call
-  kind: computer_call
-  direction: neither
-  modality: text
-  cache_state: none
-  unit: request
-  rate_basis: per_request
-
-- key: mcp_call
-  kind: mcp_call
-  direction: neither
-  modality: text
-  cache_state: none
-  unit: request
-  rate_basis: per_request

data/lib/llm_cost_tracker/usage/token_usage.rb

@@ -4,97 +4,42 @@ require_relative "catalog"
 
 module LlmCostTracker
   module Usage
-    KNOWN_TOKEN_KEYS = (
-      Catalog.token_priced.map { |dimension| dimension.token_key.to_s } + %w[total_tokens hidden_output_tokens]
-    ).freeze
-
-    TokenUsage = Data.define(
-      :input_tokens,
-      :cache_read_input_tokens,
-      :cache_write_input_tokens,
-      :cache_write_extended_input_tokens,
-      :audio_input_tokens,
-      :image_input_tokens,
-      :output_tokens,
-      :audio_output_tokens,
-      :image_output_tokens,
-      :total_tokens,
-      :hidden_output_tokens
-    ) do
+    TokenUsage = Data.define(*Catalog.token_priced.map(&:token_key), :total_tokens, :hidden_output_tokens) do
       def priced_quantities
         Catalog.token_priced.to_h { |dimension| [dimension.key, public_send(dimension.token_key)] }
       end
 
+      def self.build(**values)
+        unknown = values.keys - members
+        raise ArgumentError, "unknown token keys: #{unknown.inspect}" if unknown.any?
+
+        priced = Catalog.token_priced.to_h do |dimension|
+          [dimension.token_key, non_negative_int(values[dimension.token_key])]
+        end
+        subtotal = priced.values.sum
+        declared_total = values[:total_tokens]
+        total = declared_total ? [non_negative_int(declared_total), subtotal].max : subtotal
+        new(**priced, total_tokens: total, hidden_output_tokens: non_negative_int(values[:hidden_output_tokens]))
+      end
+
       def self.build_from_tokens(tokens)
         return tokens if tokens.is_a?(self)
         raise ArgumentError, "tokens must be a Hash, got #{tokens.class}" unless tokens.respond_to?(:to_h)
 
         values = tokens.to_h.transform_keys(&:to_s)
-        warn_on_unknown_keys(values)
-        token_attributes = Catalog.token_priced.to_h do |dimension|
-          [dimension.token_key, values.fetch(dimension.token_key.to_s, 0)]
+        known = members.map(&:to_s)
+        unknown = values.keys - known
+        if unknown.any?
+          hint = values.keys.intersect?(known) ? "" : ". Did you pass a raw provider response?"
+          raise ArgumentError, "unknown token keys: #{unknown.inspect}; expected #{known.inspect}#{hint}"
         end
 
-        build(
-          **token_attributes,
-          total_tokens: values["total_tokens"],
-          hidden_output_tokens: values.fetch("hidden_output_tokens", 0)
-        )
-      end
-
-      def self.warn_on_unknown_keys(values)
-        return if values.empty?
-        return if values.keys.intersect?(KNOWN_TOKEN_KEYS)
-
-        Logging.warn(
-          "tokens hash contains no recognized keys (#{values.keys.inspect}); " \
-          "expected one of #{KNOWN_TOKEN_KEYS.inspect}. Did you pass a raw provider response?"
-        )
+        build(**values.transform_keys(&:to_sym))
       end
 
       def self.non_negative_int(value)
         [value.to_i, 0].max
       end
-
-      def self.build(input_tokens:,
-                     output_tokens:,
-                     cache_read_input_tokens: 0,
-                     cache_write_input_tokens: 0,
-                     cache_write_extended_input_tokens: 0,
-                     audio_input_tokens: 0,
-                     audio_output_tokens: 0,
-                     image_input_tokens: 0,
-                     image_output_tokens: 0,
-                     total_tokens: nil,
-                     hidden_output_tokens: 0)
-        input = non_negative_int(input_tokens)
-        output = non_negative_int(output_tokens)
-        cache_read = non_negative_int(cache_read_input_tokens)
-        cache_write = non_negative_int(cache_write_input_tokens)
-        cache_write_extended = non_negative_int(cache_write_extended_input_tokens)
-        audio_input = non_negative_int(audio_input_tokens)
-        audio_output = non_negative_int(audio_output_tokens)
-        image_input = non_negative_int(image_input_tokens)
-        image_output = non_negative_int(image_output_tokens)
-        hidden_output = non_negative_int(hidden_output_tokens)
-        calculated_total = input + cache_read + cache_write + cache_write_extended +
-                           audio_input + image_input + output + audio_output + image_output
-        total = total_tokens ? [non_negative_int(total_tokens), calculated_total].max : calculated_total
-
-        new(
-          input_tokens: input,
-          cache_read_input_tokens: cache_read,
-          cache_write_input_tokens: cache_write,
-          cache_write_extended_input_tokens: cache_write_extended,
-          audio_input_tokens: audio_input,
-          image_input_tokens: image_input,
-          output_tokens: output,
-          audio_output_tokens: audio_output,
-          image_output_tokens: image_output,
-          total_tokens: total,
-          hidden_output_tokens: hidden_output
-        )
-      end
     end
   end
 end

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

data/lib/llm_cost_tracker.rb

@@ -30,7 +30,7 @@ require_relative "llm_cost_tracker/ingestion"
 require_relative "llm_cost_tracker/tracker"
 
 module LlmCostTracker
-  autoload :Engine, "llm_cost_tracker/engine"
+  require_relative "llm_cost_tracker/engine"
   autoload :Doctor, "llm_cost_tracker/doctor"
   autoload :CaptureVerifier, "llm_cost_tracker/capture_verifier"
   autoload :Report, "llm_cost_tracker/report"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Sergii Khomenko