llm_cost_tracker 0.11.0 → 0.13.0

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "../pricing"
-require_relative "../billing/cost_status"
-require_relative "../billing/line_item"
+require_relative "../charges/line_item"
 require_relative "../ledger/rollups"
-require_relative "../token_usage"
+require_relative "../usage/token_usage"
 
 module LlmCostTracker
   module Pricing
-    class Backfill
+    module Backfill
       Result = Data.define(:examined, :recomputed, :still_unknown)
       RollupEvent = Data.define(:provider, :tracked_at, :pricing_snapshot, :total_cost)
 
@@ -24,14 +23,14 @@ module LlmCostTracker
             LlmCostTracker::Call.transaction do
               batch.each do |call|
                 examined += 1
-                outcome = recompute_for(call)
-                next unless outcome
+                calculation = recompute_for(call)
+                next unless calculation
 
-                persist!(call, outcome)
-                rollup_events << rollup_event_for(call, outcome)
+                persist!(call, calculation)
+                rollup_events << rollup_event_for(call, calculation)
                 recomputed += 1
               end
-              Ledger::Rollups.increment_many!(rollup_events) if rollup_events.any?
+              Ledger::Rollups.increment!(rollup_events) if rollup_events.any?
             end
           end
 
@@ -45,93 +44,66 @@ module LlmCostTracker
         private
 
         def recompute_for(call)
-          token_usage = token_usage_from(call)
-          billing_items = billing_line_items_from(call)
-          cost_data, snapshot, priced = Pricing.calculate(
-            provider: call.provider, model: call.model,
-            tokens: token_usage, line_items: billing_items,
-            pricing_mode: call.pricing_mode
+          calculation = Pricing::Calculation.for(
+            provider: call.provider,
+            model: call.model,
+            tokens: token_usage_from(call),
+            line_items: service_line_items_from(call),
+            pricing_mode: call.pricing_mode,
+            usage_source: call.usage_source
           )
-          return nil unless cost_data
-
-          full_cost = Pricing.combine_with_service_lines(cost_data, priced)
-          total_cost = full_cost[:total_cost]
-          return nil if total_cost.nil?
-
-          {
-            snapshot: snapshot,
-            priced_line_items: priced,
-            total_cost: total_cost,
-            cost_status: Billing::CostStatus.call(
-              token_usage: token_usage,
-              usage_source: call.usage_source&.to_sym,
-              token_cost: cost_data,
-              token_pricing_partial: Pricing.token_pricing_partial?(token_usage, cost_data),
-              service_line_items: priced.reject(&:token?),
-              total_cost: total_cost
-            )
-          }
+          calculation if calculation.token_cost
         end
 
-        def persist!(call, outcome)
+        def persist!(call, calculation)
           call.update!(
-            total_cost: outcome[:total_cost],
-            pricing_snapshot: outcome[:snapshot],
-            cost_status: outcome[:cost_status]
+            total_cost: calculation.cost.total,
+            pricing_snapshot: calculation.snapshot,
+            cost_status: calculation.cost_status
           )
-          call.line_items.to_a.zip(outcome[:priced_line_items]).each do |record, priced|
-            next if priced.nil?
-
-            record.update!(
-              rate_amount: priced.rate_amount,
-              rate_quantity: priced.rate_quantity,
-              cost: priced.cost,
-              currency: priced.currency,
-              cost_status: priced.cost_status,
-              price_key: priced.price_key,
-              price_source: priced.price_source&.to_s,
-              price_source_version: priced.price_source_version
-            )
-          end
+          token_priced = calculation.priced_line_items.select(&:token?).index_by { |item| dimension_key(item) }
+          service_priced = calculation.priced_line_items.reject(&:token?)
+          token_records, service_records = call.line_items.partition { |record| record.unit == "token" }
+
+          token_records.each { |record| apply_rate(record, token_priced[dimension_key(record)]) }
+          service_records.sort_by(&:position).zip(service_priced).each { |record, priced| apply_rate(record, priced) }
         end
 
-        def rollup_event_for(call, outcome)
+        def apply_rate(record, priced)
+          return unless priced
+
+          record.update!(
+            rate_amount: priced.rate_amount,
+            rate_quantity: priced.rate_quantity,
+            cost: priced.cost,
+            currency: priced.currency,
+            cost_status: priced.cost_status,
+            price_key: priced.price_key,
+            price_source: priced.price_source,
+            price_source_version: priced.price_source_version
+          )
+        end
+
+        def dimension_key(item)
+          [item.kind, item.direction, item.modality, item.cache_state]
+        end
+
+        def rollup_event_for(call, calculation)
           RollupEvent.new(
             provider: call.provider,
             tracked_at: call.tracked_at,
-            pricing_snapshot: outcome[:snapshot],
-            total_cost: outcome[:total_cost]
+            pricing_snapshot: calculation.snapshot,
+            total_cost: calculation.cost.total
           )
         end
 
         def token_usage_from(call)
-          TokenUsage.build(
-            input_tokens: call.input_tokens,
-            output_tokens: call.output_tokens,
-            cache_read_input_tokens: call.cache_read_input_tokens,
-            cache_write_input_tokens: call.cache_write_input_tokens,
-            cache_write_extended_input_tokens: call.cache_write_extended_input_tokens,
-            audio_input_tokens: call.audio_input_tokens,
-            audio_output_tokens: call.audio_output_tokens,
-            image_input_tokens: call.image_input_tokens,
-            image_output_tokens: call.image_output_tokens,
-            hidden_output_tokens: call.hidden_output_tokens,
-            total_tokens: call.total_tokens
-          )
+          Usage::TokenUsage.build(**call.attributes.transform_keys(&:to_sym).slice(*Usage::TokenUsage.members))
         end
 
-        def billing_line_items_from(call)
-          call.line_items.map do |record|
-            Billing::LineItem.build(
-              kind: record.kind, direction: record.direction, modality: record.modality,
-              cache_state: record.cache_state, quantity: record.quantity, unit: record.unit,
-              rate_amount: record.rate_amount, rate_quantity: record.rate_quantity,
-              cost: record.cost, currency: record.currency, cost_status: record.cost_status,
-              pricing_basis: record.pricing_basis, price_key: record.price_key,
-              price_source: record.price_source, price_source_version: record.price_source_version,
-              provider_field: record.provider_field, provider_item_id: record.provider_item_id,
-              details: record.details
-            )
+        def service_line_items_from(call)
+          call.line_items.reject { |record| record.unit == "token" }.sort_by(&:position).map do |record|
+            Charges::LineItem.build(record.attributes.transform_keys(&:to_sym).slice(*Charges::LineItem.members))
           end
         end
       end

data/lib/llm_cost_tracker/pricing/calculation.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require "bigdecimal/util"
+
+require_relative "../usage/catalog"
+require_relative "../charges/line_item"
+require_relative "rate"
+
+module LlmCostTracker
+  module Pricing
+    class Calculation
+      RATE_DENOMINATOR_TOKENS = Pricing::RATE_BASIS_QUANTITIES.fetch("per_million_tokens")
+      SNAPSHOT_SCHEMA_VERSION = 1
+      private_constant :RATE_DENOMINATOR_TOKENS, :SNAPSHOT_SCHEMA_VERSION
+
+      def self.for(provider:, model:, tokens:, pricing_mode:, line_items: [], usage_source: nil)
+        new(provider: provider,
+            model: model,
+            token_usage: Usage::TokenUsage.build_from_tokens(tokens),
+            line_items: line_items,
+            mode: Mode.normalize(pricing_mode),
+            usage_source: usage_source)
+      end
+
+      def initialize(provider:, model:, token_usage:, line_items:, mode:, usage_source: nil)
+        @provider = provider
+        @model = model
+        @token_usage = token_usage
+        @line_items = line_items
+        @mode = mode
+        @usage_source = usage_source
+      end
+
+      attr_reader :mode
+
+      def match
+        return @match if defined?(@match)
+
+        @match = Matcher.lookup(provider: @provider, model: @model)
+      end
+
+      def effective
+        return @effective if defined?(@effective)
+
+        @effective = match && EffectivePrices.call(
+          usage: @token_usage, quantities: quantities, prices: match.prices, pricing_mode: @mode
+        )
+      end
+
+      def token_cost
+        return @token_cost if defined?(@token_cost)
+
+        @token_cost = priceable? ? build_token_cost : nil
+      end
+
+      def priced_line_items
+        @priced_line_items ||= unpriced_line_items.map do |line_item|
+          line_item.token? ? price_token(line_item) : price_service(line_item)
+        end
+      end
+
+      def snapshot
+        return @snapshot if defined?(@snapshot)
+
+        @snapshot =
+          if priceable?
+            build_snapshot
+          elsif kept_service_lines.any?
+            build_service_snapshot
+          end
+      end
+
+      def cost
+        return @cost if defined?(@cost)
+
+        @cost = combine_service_lines
+      end
+
+      def cost_status
+        @cost_status ||= Charges::CostStatus.call(
+          token_usage: @token_usage,
+          usage_source: @usage_source,
+          token_cost: token_cost,
+          token_pricing_partial: token_pricing_partial?,
+          service_line_items: priced_line_items.reject(&:token?),
+          total_cost: cost&.total
+        )
+      end
+
+      private
+
+      def quantities
+        @quantities ||= @token_usage.priced_quantities
+      end
+
+      def unpriced_line_items
+        Charges::LineItem.from_token_usage(@token_usage) + @line_items.reject(&:token?)
+      end
+
+      def priceable?
+        !match.nil? && !all_billable_unpriced?
+      end
+
+      def all_billable_unpriced?
+        any_billable = false
+        quantities.each_pair do |key, quantity|
+          next unless quantity.positive?
+          return false if effective[key]
+
+          any_billable = true
+        end
+        any_billable
+      end
+
+      def priced_token_line_items
+        @priced_token_line_items ||= priced_line_items.select(&:token?)
+      end
+
+      def build_token_cost
+        by_dimension = priced_token_line_items.to_h { |line_item| [line_item.dimension, line_item] }
+        components = Usage::Catalog.token_priced.each_with_object({}) do |dimension, result|
+          cost = token_dimension_cost(dimension, by_dimension[dimension])
+          result[dimension.cost_key] = cost.round(8) unless cost.nil?
+        end
+        Charges::Cost.new(
+          components: components.freeze,
+          total: priced_token_line_items.sum(BigDecimal("0")) { |line_item| line_item.cost_value.round(8) },
+          currency: match.source.currency
+        )
+      end
+
+      def token_dimension_cost(dimension, line_item)
+        return BigDecimal("0") if quantities[dimension.key].zero?
+
+        line_item&.cost
+      end
+
+      def build_snapshot
+        {
+          "schema_version" => SNAPSHOT_SCHEMA_VERSION,
+          "source" => match.source.name,
+          "source_key" => match.key,
+          "source_version" => match.source.version,
+          "matched_by" => match.matched_by.to_s,
+          "currency" => match.source.currency,
+          "rates" => service_charge_rates.merge(token_charge_rates)
+        }
+      end
+
+      def build_service_snapshot
+        primary = kept_service_lines.first
+        {
+          "schema_version" => SNAPSHOT_SCHEMA_VERSION,
+          "source" => primary.price_source,
+          "source_version" => primary.price_source_version,
+          "matched_by" => "service_charges",
+          "currency" => cost.currency,
+          "rates" => service_charge_rates
+        }
+      end
+
+      def token_charge_rates
+        priced_token_line_items.each_with_object({}) do |line_item, rates|
+          next if line_item.price_key.nil? || line_item.rate_amount.nil?
+
+          rates[line_item.price_key] ||= rate_entry(line_item.rate_amount, line_item.rate_quantity)
+        end
+      end
+
+      def service_charge_rates
+        kept_service_lines.each_with_object({}) do |line_item, rates|
+          next if line_item.price_key.nil? || line_item.rate_amount.nil?
+
+          rates[line_item.price_key] ||= rate_entry(line_item.rate_amount, line_item.rate_quantity)
+        end
+      end
+
+      def rate_entry(amount, quantity)
+        { "amount" => amount.to_d.to_s("F"), "quantity" => Integer(quantity) }
+      end
+
+      def price_token(line_item)
+        dimension = line_item.dimension
+        return line_item unless dimension
+        return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) unless priceable?
+
+        price = effective[dimension.key]
+        return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) if price.nil?
+
+        line_item.with_rate(token_rate(dimension, price))
+      end
+
+      def token_rate(dimension, price)
+        Pricing::Rate.new(
+          amount: price.to_d,
+          quantity: RATE_DENOMINATOR_TOKENS.to_d,
+          currency: match.source.currency,
+          source: match.source.name,
+          source_key: dimension.key,
+          source_version: match.source.version
+        )
+      end
+
+      def price_service(line_item)
+        return line_item if line_item.priced? || !line_item.billable?
+
+        rate = model_rate(line_item) ||
+               ServiceRates.charge_rate(provider: @provider, dimension: line_item.kind, pricing_mode: @mode)
+        return line_item unless rate
+
+        line_item.with_rate(rate)
+      end
+
+      def model_rate(line_item)
+        return nil unless priceable?
+
+        amount = match.prices[line_item.kind]
+        return nil unless amount.is_a?(Numeric)
+
+        dimension = Usage::Catalog[line_item.kind]
+        Pricing::Rate.new(
+          amount: amount.to_d,
+          quantity: Pricing::RATE_BASIS_QUANTITIES.fetch(dimension.rate_basis).to_d,
+          currency: match.source.currency,
+          source: match.source.name,
+          source_key: "#{match.key}.#{line_item.kind}",
+          source_version: match.source.version
+        )
+      end
+
+      def kept_service_lines
+        return @kept_service_lines if defined?(@kept_service_lines)
+
+        @kept_service_lines = begin
+          priced_services = priced_line_items.reject(&:token?).select(&:priced?)
+          if priced_services.empty?
+            []
+          else
+            base_currency = base_currency_for(token_cost, priced_services)
+            matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
+            warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
+            matching
+          end
+        end
+      end
+
+      def combine_service_lines
+        cost = token_cost
+        return cost if kept_service_lines.empty?
+
+        service_total = kept_service_lines.sum(BigDecimal("0")) { |line| line.cost_value.round(8) }
+        Charges::Cost.new(
+          components: cost ? cost.components : {}.freeze,
+          total: (cost&.total || BigDecimal("0")) + service_total,
+          currency: (cost&.currency || kept_service_lines.first.currency).to_s
+        )
+      end
+
+      def base_currency_for(cost, priced_services)
+        cost&.currency || priced_services.first.currency || LlmCostTracker::DEFAULT_CURRENCY
+      end
+
+      def warn_currency_mismatch(lines, base_currency)
+        currencies = lines.map { |line| line.currency.to_s }.uniq.sort
+        Logging.warn(
+          "Service line currency mismatch: header is #{base_currency}, dropping " \
+          "#{lines.size} priced line(s) in #{currencies.join(', ')} from header total. " \
+          "Per-line costs are still recorded; header total reflects #{base_currency} only."
+        )
+      end
+
+      def token_pricing_partial?
+        return false unless token_cost
+
+        priced_token_line_items.any?(&:unpriced?)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../billing/components"
+require "bigdecimal/util"
+
 require_relative "mode"
+require_relative "price_key"
 
 module LlmCostTracker
   module Pricing
@@ -9,7 +11,7 @@ module LlmCostTracker
       class << self
         def call(usage:, quantities:, prices:, pricing_mode:)
           context_tier = context_tier?(usage: usage, prices: prices)
-          orderings = pricing_mode && Mode.parse(pricing_mode).permutations
+          orderings = pricing_mode && Mode.permutations_for(pricing_mode)
 
           quantities.to_h do |price_key, tokens|
             price = if tokens.positive?
@@ -20,7 +22,7 @@ module LlmCostTracker
                         context_tier: context_tier
                       )
                     else
-                      0.0
+                      BigDecimal("0")
                     end
             [price_key, price]
           end
@@ -29,45 +31,42 @@ module LlmCostTracker
         private
 
         def price_for(prices:, key:, orderings:, context_tier:)
-          return contextual_price(prices: prices, key: key, context_tier: context_tier) unless orderings
+          return prices[PriceKey.build(key, above_context: context_tier)] unless orderings
 
           orderings.each do |mode|
-            direct = contextual_price(prices: prices, key: :"#{mode}_#{key}", context_tier: context_tier)
+            direct = prices[PriceKey.build(key, mode: mode, above_context: context_tier)]
             return direct if direct
           end
-          return nil if %i[input output].include?(key)
+          return nil if %w[input output].include?(key)
 
           derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
         end
 
-        def contextual_price(prices:, key:, context_tier:)
-          return prices[key] unless context_tier
-
-          prices[:"above_context_#{key}"]
-        end
-
         def derived_mode_price(prices:, key:, modes:, context_tier:)
-          standard_price = contextual_price(prices: prices, key: key, context_tier: context_tier)
-          base_price = contextual_price(prices: prices, key: :input, context_tier: context_tier)
+          standard_price = prices[PriceKey.build(key, above_context: context_tier)]
+          base_price = prices[PriceKey.build("input", above_context: context_tier)]
           return nil unless standard_price && base_price
           return nil if base_price.zero?
 
           modes.each do |mode|
-            mode_base_price = contextual_price(prices: prices, key: :"#{mode}_input", context_tier: context_tier)
-            return standard_price * (mode_base_price / base_price) if mode_base_price
+            mode_base_price = prices[PriceKey.build("input", mode: mode, above_context: context_tier)]
+            next unless mode_base_price
+
+            return standard_price.to_d * mode_base_price.to_d / base_price.to_d
           end
           nil
         end
 
         def context_tier?(usage:, prices:)
-          threshold = prices[:_context_price_threshold_tokens]
+          threshold = prices[Registry::CONTEXT_THRESHOLD_KEY]
           return false unless threshold
 
           input_tokens = usage.input_tokens +
                          usage.cache_read_input_tokens +
                          usage.cache_write_input_tokens +
                          usage.cache_write_extended_input_tokens +
-                         usage.audio_input_tokens
+                         usage.audio_input_tokens +
+                         usage.image_input_tokens
           input_tokens > threshold
         end
       end

data/lib/llm_cost_tracker/pricing/estimator.rb

@@ -15,9 +15,9 @@ module LlmCostTracker
         cost_data = Pricing.cost_for(
           provider: provider,
           model: model,
-          tokens: { input: estimated_tokens }
+          tokens: { input_tokens: estimated_tokens }
         )
-        cost_data && BigDecimal(cost_data[:total_cost].to_s)
+        cost_data&.total
       end
 
       def self.char_count(value)

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+require_relative "registry"
+
+module LlmCostTracker
+  module Pricing
+    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?
+
+          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 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)
+
+          sources.each do |source|
+            match = match_in_source(source, provider_model, model_name, normalized)
+            return match if match
+          end
+          nil
+        end
+
+        def match_in_source(source, provider_model, model_name, normalized)
+          table = source.prices
+          return nil if table.empty?
+
+          [[provider_model, :provider_model], [model_name, :model], [normalized, :normalized_model]].each do |key, by|
+            return build_match(source, key, by) if table.key?(key)
+          end
+
+          scan = native_keys(table)
+          if (key = unique_in(scan) { |native| normalize_model_name(native) == normalized })
+            return build_match(source, key, :unique_providerless_model)
+          end
+
+          dated = scan.find do |native|
+            snapshot_variant?(provider_model, native) || snapshot_variant?(normalized, native)
+          end
+          return build_match(source, dated, :dated_snapshot) if dated
+
+          unique_dated = unique_in(scan) { |native| snapshot_variant?(normalized, normalize_model_name(native)) }
+          return build_match(source, unique_dated, :unique_providerless_dated_snapshot) if unique_dated
+
+          nil
+        end
+
+        def unique_in(keys, &)
+          matches = keys.select(&)
+          matches.first if matches.one?
+        end
+
+        def normalize_model_name(model)
+          model.to_s.split("/").last
+        end
+
+        def native_keys(table)
+          Registry.sorted_price_keys(table).reject { |key| key.count("/") > 1 }
+        end
+
+        def build_match(source, key, matched_by)
+          Match.new(source: source, key: key, prices: source.prices[key], matched_by: matched_by)
+        end
+
+        def snapshot_variant?(model, key)
+          suffix = model.delete_prefix("#{key}-")
+          return false if suffix == model
+
+          suffix.match?(/\A(?:\d{4}-\d{2}-\d{2}|\d{8}|(?:preview|exp)-\d{2}-(?:\d{2}|\d{4}))\z/)
+        end
+      end
+    end
+  end
+end