llm_cost_tracker 0.14.1 → 0.14.2

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -13,9 +13,12 @@ module LlmCostTracker
       RollupEvent = Data.define(:provider, :tracked_at, :pricing_snapshot, :total_cost)
 
       DEFAULT_BATCH_SIZE = 500
+      REGISTRY_SOURCES = %w[pricing_overrides prices_file bundled].freeze
+      RATE_FIELDS = %i[rate_amount rate_quantity cost cost_status price_key price_source price_source_version].freeze
+      private_constant :REGISTRY_SOURCES, :RATE_FIELDS
 
       class << self
-        def call(scope: default_scope, batch_size: DEFAULT_BATCH_SIZE)
+        def call(scope: default_scope, batch_size: DEFAULT_BATCH_SIZE, reprice: false)
           examined = 0
           recomputed = 0
 
@@ -24,11 +27,11 @@ module LlmCostTracker
             LlmCostTracker::Call.transaction do
               batch.each do |call|
                 examined += 1
-                calculation = recompute_for(call)
+                calculation = recompute_for(call, reprice: reprice)
                 next unless calculation
 
-                persist!(call, calculation)
                 rollup_events << rollup_event_for(call, calculation)
+                persist!(call, calculation)
                 recomputed += 1
               end
               Ledger::Rollups.increment!(rollup_events)
@@ -39,21 +42,46 @@ module LlmCostTracker
         end
 
         def default_scope
-          LlmCostTracker::Call.where(total_cost: nil)
+          with_known_usage(LlmCostTracker::Call.unknown_pricing)
+        end
+
+        def reprice_scope(range)
+          with_known_usage(LlmCostTracker::Call.where(tracked_at: range))
         end
 
         private
 
-        def recompute_for(call)
+        def with_known_usage(calls)
+          calls.where(usage_source: nil).or(calls.where.not(usage_source: Usage::Source::UNKNOWN))
+        end
+
+        def recompute_for(call, reprice:)
           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
+            line_items: line_items_from(call, reprice: reprice),
+            pricing_mode: call.pricing_mode || bedrock_pricing_mode(call),
+            usage_source: call.usage_source,
+            at: call.tracked_at
           )
-          calculation if calculation.token_cost
+          return unless calculation.token_cost || provider_billed?(calculation)
+          return if [calculation.cost.total, calculation.cost_status] == [call.total_cost, call.cost_status]
+          return calculation if reprice
+
+          rates = calculation.priced_line_items.to_h { |item| [dimension_key(item), item.rate_amount] }
+          recorded = call.line_items.select { |record| record.unit == "token" && record.rate_amount }
+          calculation if recorded.all? { |record| record.rate_amount == rates[dimension_key(record)] }
+        end
+
+        def provider_billed?(calculation)
+          calculation.priced_line_items.any? { |item| item.kind == "billed_request" && item.priced? }
+        end
+
+        def bedrock_pricing_mode(call)
+          return unless call.provider == "bedrock"
+
+          Providers::Anthropic::UsageExtractor.pricing_mode(request: { model: call.model }, usage: {})
         end
 
         def persist!(call, calculation)
@@ -103,7 +131,7 @@ module LlmCostTracker
             provider: call.provider,
             tracked_at: call.tracked_at,
             pricing_snapshot: calculation.snapshot,
-            total_cost: calculation.cost.total
+            total_cost: calculation.cost.total - call.total_cost.to_d
           )
         end
 
@@ -111,11 +139,16 @@ module LlmCostTracker
           Usage::TokenUsage.build(**call.attributes.transform_keys(&:to_sym).slice(*Usage::TokenUsage.members))
         end
 
-        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))
+        def line_items_from(call, reprice:)
+          call.line_items.sort_by(&:position).map do |record|
+            attributes = record.attributes.transform_keys(&:to_sym).slice(*Charges::LineItem.members)
+            Charges::LineItem.build(reprice ? at_current_rates(record, attributes) : attributes)
           end
         end
+
+        def at_current_rates(record, attributes)
+          REGISTRY_SOURCES.include?(record.price_source) ? attributes.except(*RATE_FIELDS) : attributes
+        end
       end
     end
   end

data/lib/llm_cost_tracker/pricing/calculation.rb

@@ -11,24 +11,27 @@ module LlmCostTracker
     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
+      CACHE_INPUT_KEYS = %w[cache_read_input cache_write_input].freeze
+      private_constant :RATE_DENOMINATOR_TOKENS, :SNAPSHOT_SCHEMA_VERSION, :CACHE_INPUT_KEYS
 
-      def self.for(provider:, model:, tokens:, pricing_mode:, line_items: [], usage_source: nil)
+      def self.for(provider:, model:, tokens:, pricing_mode:, line_items: [], usage_source: nil, at: Time.now)
         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)
+            usage_source: usage_source,
+            at: at)
       end
 
-      def initialize(provider:, model:, token_usage:, line_items:, mode:, usage_source: nil)
+      def initialize(provider:, model:, token_usage:, line_items:, mode:, usage_source: nil, at: Time.now)
         @provider = provider
         @model = model
         @token_usage = token_usage
         @line_items = line_items
         @mode = mode
         @usage_source = usage_source
+        @at = at
       end
 
       attr_reader :mode
@@ -36,21 +39,26 @@ module LlmCostTracker
       def match
         return @match if defined?(@match)
 
-        @match = Matcher.lookup(provider: @provider, model: @model)
+        @match = Matcher.lookup(provider: @provider, model: @model, at: @at)
       end
 
       def effective
         return @effective if defined?(@effective)
 
         @effective = match && EffectivePrices.call(
-          usage: @token_usage, quantities: quantities, prices: match.prices, pricing_mode: @mode
+          usage: @token_usage,
+          quantities: quantities,
+          prices: match.prices,
+          pricing_mode: @mode,
+          cache_at_input_rate: cache_keys_at_input_rate
         )
       end
 
       def token_cost
         return @token_cost if defined?(@token_cost)
 
-        @token_cost = priceable? ? build_token_cost : nil
+        known = priceable? && @usage_source != Usage::Source::UNKNOWN && !only_unpriced_lines?
+        @token_cost = known ? build_token_cost : nil
       end
 
       def priced_line_items
@@ -77,39 +85,73 @@ module LlmCostTracker
       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
-        )
+        @cost_status ||= begin
+          status = billed_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
+          )
+          @partial_iteration && status != Charges::CostStatus::UNKNOWN ? Charges::CostStatus::PARTIAL : status
+        end
       end
 
       private
 
+      def cache_keys_at_input_rate
+        return [] if match.source.name == "pricing_overrides" || !match.key.start_with?("openai/")
+
+        listed = Registry.builtin_prices[match.key] || (match.prices unless manual_file_entry?)
+        listed ? CACHE_INPUT_KEYS - listed.keys : []
+      end
+
+      def manual_file_entry?
+        entry = Registry.raw_file_registry(LlmCostTracker.configuration.pricing.file).dig("models", match.key)
+        entry.is_a?(Hash) && entry["_source"].to_s == "manual"
+      end
+
       def quantities
-        @quantities ||= @token_usage.priced_quantities
+        @quantities ||= @line_items.each_with_object(@token_usage.priced_quantities) do |line_item, result|
+          dimension = line_item.dimension
+          next unless dimension&.parent
+
+          quantity = [line_item.quantity.to_i, result.fetch(dimension.parent)].min
+          result[dimension.parent] -= quantity
+          result[dimension.key] = result.fetch(dimension.key, 0) + quantity
+        end
       end
 
       def unpriced_line_items
-        Charges::LineItem.from_token_usage(@token_usage) + @line_items.reject(&:token?)
+        Charges::LineItem.from_quantities(quantities) + @line_items.reject(&:token?)
       end
 
       def priceable?
-        !match.nil? && !all_billable_unpriced?
+        !match.nil? && billed_line.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]
+      def billed_line
+        @line_items.find { |line_item| line_item.kind == "billed_request" }
+      end
 
-          any_billable = true
-        end
-        any_billable
+      def billed_status
+        return unless billed_line
+
+        unpriced_attempt = priced_line_items.any? { |item| item.kind == "model_iteration" && item.unpriced? }
+        return Charges::CostStatus::PARTIAL if unpriced_attempt
+
+        billed_line.priced? && cost.total.positive? ? Charges::CostStatus::COMPLETE : billed_line.cost_status
+      end
+
+      def only_unpriced_lines?
+        billable = priced_line_items.select(&:billable?)
+        billable.any? && billable.none?(&:priced?)
+      end
+
+      def all_billable_unpriced?
+        billable = quantities.select { |_key, quantity| quantity.positive? }.keys
+        billable.any? && billable.none? { |key| effective[key] }
       end
 
       def priced_token_line_items
@@ -117,10 +159,12 @@ module LlmCostTracker
       end
 
       def build_token_cost
-        by_dimension = priced_token_line_items.to_h { |line_item| [line_item.dimension, line_item] }
+        by_component = priced_token_line_items.group_by { |item| item.dimension.parent || item.dimension.key }
         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?
+          line_items = by_component.fetch(dimension.key, [])
+          next if line_items.any?(&:unpriced?)
+
+          result[dimension.cost_key] = line_items.sum(BigDecimal("0")) { |line_item| line_item.cost_value.round(8) }
         end
         Charges::Cost.new(
           components: components.freeze,
@@ -129,12 +173,6 @@ module LlmCostTracker
         )
       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,
@@ -143,7 +181,7 @@ module LlmCostTracker
           "source_version" => match.source.version,
           "matched_by" => match.matched_by.to_s,
           "currency" => match.source.currency,
-          "rates" => service_charge_rates.merge(token_charge_rates)
+          "rates" => charge_rates(kept_service_lines).merge(charge_rates(priced_token_line_items))
         }
       end
 
@@ -155,20 +193,12 @@ module LlmCostTracker
           "source_version" => primary.price_source_version,
           "matched_by" => "service_charges",
           "currency" => cost.currency,
-          "rates" => service_charge_rates
+          "rates" => charge_rates(kept_service_lines)
         }
       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|
+      def charge_rates(line_items)
+        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)
@@ -180,14 +210,8 @@ module LlmCostTracker
       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(price))
+        price = priceable? && effective[line_item.dimension.key]
+        price ? line_item.with_rate(token_rate(price)) : line_item
       end
 
       def token_rate(price)
@@ -202,7 +226,8 @@ module LlmCostTracker
       end
 
       def price_service(line_item)
-        return line_item if line_item.priced? || !line_item.billable?
+        return price_iteration(line_item) if line_item.kind == "model_iteration"
+        return line_item if line_item.priced? || !line_item.billable? || billed_line
 
         rate = model_rate(line_item) ||
                ServiceRates.charge_rate(provider: @provider, dimension: line_item.kind, pricing_mode: @mode)
@@ -211,19 +236,45 @@ module LlmCostTracker
         line_item.with_rate(rate)
       end
 
+      def price_iteration(line_item)
+        details = line_item.details.to_h.transform_keys(&:to_sym)
+        model = details[:model].to_s
+        calculation = Calculation.for(
+          provider: @provider,
+          model: model,
+          tokens: details.slice(*Usage::TokenUsage.members),
+          pricing_mode: iteration_mode(model),
+          at: @at
+        )
+        cost = calculation.token_cost
+        return line_item unless cost
+
+        @partial_iteration ||= calculation.cost_status == Charges::CostStatus::PARTIAL
+        status = cost.total.zero? ? Charges::CostStatus::FREE : Charges::CostStatus::COMPLETE
+        line_item.with(rate_amount: cost.total, cost: cost.total, currency: cost.currency, cost_status: status)
+      end
+
+      def iteration_mode(model)
+        return @mode if Matcher.modifier_priced?(provider: @provider, model: model, modifier: "fast")
+
+        Mode.compose(Mode.tokenize(@mode) - ["fast"])
+      end
+
       def model_rate(line_item)
         return nil unless priceable?
 
-        amount = match.prices[line_item.kind]
-        return nil unless amount.is_a?(Numeric)
+        modes = @mode ? Mode.permutations_for(@mode) : []
+        key = [*modes.map { |mode| PriceKey.build(line_item.kind, mode: mode) }, line_item.kind]
+              .find { |candidate| match.prices[candidate].is_a?(Numeric) }
+        return nil unless key
 
         dimension = Usage::Catalog[line_item.kind]
         Pricing::Rate.new(
-          amount: amount.to_d,
+          amount: match.prices[key].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_key: "#{match.key}.#{key}",
           source_version: match.source.version
         )
       end
@@ -231,17 +282,13 @@ module LlmCostTracker
       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
+        priced_services = priced_line_items.reject(&:token?).select(&:priced?)
+        return @kept_service_lines = [] if priced_services.empty?
+
+        base_currency = token_cost&.currency || priced_services.first.currency || LlmCostTracker::DEFAULT_CURRENCY
+        matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
+        warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
+        @kept_service_lines = matching
       end
 
       def combine_service_lines
@@ -256,10 +303,6 @@ module LlmCostTracker
         )
       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(

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -11,18 +11,14 @@ module LlmCostTracker
       Resolved = Data.define(:amount, :key)
 
       class << self
-        def call(usage:, quantities:, prices:, pricing_mode:)
+        def call(usage:, quantities:, prices:, pricing_mode:, cache_at_input_rate: [])
           context_tier = context_tier?(usage: usage, prices: prices)
           orderings = pricing_mode && Mode.permutations_for(pricing_mode)
+          lookup = { prices: prices, orderings: orderings, context_tier: context_tier }
 
           quantities.to_h do |price_key, tokens|
             resolved = if tokens.positive?
-                         price_for(
-                           prices: prices,
-                           key: price_key,
-                           orderings: orderings,
-                           context_tier: context_tier
-                         )
+                         price_or_fallback(price_key, lookup, cache_at_input_rate)
                        else
                          Resolved.new(amount: BigDecimal("0"), key: price_key)
                        end
@@ -32,6 +28,11 @@ module LlmCostTracker
 
         private
 
+        def price_or_fallback(key, lookup, cache_at_input_rate)
+          fallback = Usage::Catalog.fetch(key).parent || ("input" if cache_at_input_rate.include?(key))
+          price_for(key: key, **lookup) || (fallback && price_or_fallback(fallback, lookup, cache_at_input_rate))
+        end
+
         def price_for(prices:, key:, orderings:, context_tier:)
           unless orderings
             standard = PriceKey.build(key, above_context: context_tier)
@@ -45,8 +46,7 @@ module LlmCostTracker
           end
           return nil if %w[input output].include?(key)
 
-          derived = derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
-          resolve(derived, nil)
+          derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
         end
 
         def resolve(amount, key)
@@ -63,7 +63,8 @@ module LlmCostTracker
             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
+            return resolve(standard_price.to_d * mode_base_price.to_d / base_price.to_d,
+                           PriceKey.build(key, mode: mode, above_context: context_tier))
           end
           nil
         end

data/lib/llm_cost_tracker/pricing/estimator.rb

@@ -22,8 +22,11 @@ module LlmCostTracker
 
       def self.char_count(value)
         case value
-        when String then value.length
-        when Hash then value.values.sum { |nested| char_count(nested) }
+        when String then value.match?(/\Adata:[^,]*;base64,/) ? 0 : value.length
+        when Hash
+          return 0 if value["type"].to_s == "base64"
+
+          value.except("input_audio", "inline_data", "inlineData").values.sum { |nested| char_count(nested) }
         when Array then value.sum { |nested| char_count(nested) }
         else 0
         end

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
+require "date"
 
 require_relative "registry"
 
@@ -10,21 +11,37 @@ module LlmCostTracker
       Match = Data.define(:source, :key, :prices, :matched_by)
 
       CACHE_LIMIT = 2048
-      private_constant :CACHE_LIMIT
+      BEDROCK_ANTHROPIC_ID = /\A(?:[a-z]+\.)?anthropic\.(claude-.+?)(?:-v\d+(?::\d+)?)?\z/
+      private_constant :CACHE_LIMIT, :BEDROCK_ANTHROPIC_ID
 
       class << self
-        def lookup(provider:, model:)
+        def lookup(provider:, model:, at: Time.now)
           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
+          date = at.getutc.to_date.iso8601
+          key = [provider_name, model_name, date].freeze
           return @cache[key] if @cache.key?(key)
 
           @cache.clear if @cache.size >= CACHE_LIMIT
-          @cache[key] = lookup_match(sources, provider_name, model_name)
+          @cache[key] = lookup_match(sources, provider_name, model_name)&.then do |match|
+            match.with(prices: prices_on(match.prices, date))
+          end
+        end
+
+        def prices_on(prices, date)
+          scheduled = prices.keys.grep(PriceKey::SCHEDULED_SUFFIX)
+          return prices if scheduled.empty?
+
+          current = prices.except(*scheduled)
+          scheduled.sort_by { |key| key[PriceKey::SCHEDULED_SUFFIX, 1] }.each do |key|
+            from = key[PriceKey::SCHEDULED_SUFFIX, 1]
+            current[key.delete_suffix("_from_#{from}")] = prices[key] if from <= date
+          end
+          current.freeze
         end
 
         def modifier_priced?(provider:, model:, modifier:)
@@ -45,35 +62,31 @@ module LlmCostTracker
           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
+          live = sources.reject { |source| source.prices.empty? }
+          live.lazy.filter_map { |source| exact_match(source, provider_model, model_name, normalized) }.first ||
+            live.lazy.filter_map { |source| fallback_match(source, normalized) }.first
         end
 
-        def match_in_source(source, provider_model, model_name, normalized)
+        def exact_match(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)
+          dated = native_keys(table).find do |native|
+            snapshot_variant?(provider_model, native) || snapshot_variant?(normalized, native)
           end
+          build_match(source, dated, :dated_snapshot) if dated
+        end
 
-          dated = scan.find do |native|
-            snapshot_variant?(provider_model, native) || snapshot_variant?(normalized, native)
+        def fallback_match(source, normalized)
+          scan = native_keys(source.prices)
+          if (key = unique_in(scan) { |native| normalize_model_name(native) == normalized })
+            return build_match(source, key, :unique_providerless_model)
           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
+          build_match(source, unique_dated, :unique_providerless_dated_snapshot) if unique_dated
         end
 
         def unique_in(keys, &)
@@ -82,7 +95,8 @@ module LlmCostTracker
         end
 
         def normalize_model_name(model)
-          model.to_s.split("/").last
+          name = model.to_s.split("/").last
+          name.match(BEDROCK_ANTHROPIC_ID)&.[](1) || name
         end
 
         def native_keys(table)

data/lib/llm_cost_tracker/pricing/mode.rb

@@ -9,11 +9,8 @@ module LlmCostTracker
       MAX_PERMUTED_MODIFIERS = 6
 
       def self.normalize(value)
-        return nil if value.nil?
-
-        mode = normalize_string(value.to_s)
-        return nil unless mode
-        return nil if STANDARD_MODE_VALUES.include?(mode)
+        mode = value.to_s.strip.downcase.tr("-", "_")
+        return nil if mode.empty? || STANDARD_MODE_VALUES.include?(mode)
 
         warn_unknown_tokens(mode)
         mode
@@ -65,14 +62,6 @@ module LlmCostTracker
         modifiers.permutation.map { |permutation| permutation.join("_") }.uniq
       end
 
-      def self.normalize_string(value)
-        normalized = value.strip
-        return nil if normalized.empty?
-
-        normalized.downcase.tr("-", "_")
-      end
-      private_class_method :normalize_string
-
       def self.warn_unknown_tokens(mode)
         unknown = tokenize(mode) - KNOWN_MODIFIERS - STANDARD_MODE_VALUES
         return if unknown.empty?

data/lib/llm_cost_tracker/pricing/price_key.rb

@@ -7,6 +7,7 @@ module LlmCostTracker
   module Pricing
     module PriceKey
       ABOVE_CONTEXT_PREFIX = "above_context_"
+      SCHEDULED_SUFFIX = /_from_(\d{4}-\d{2}-\d{2})\z/
 
       class << self
         def build(dimension_key, mode: nil, above_context: false)
@@ -16,12 +17,13 @@ module LlmCostTracker
 
         def price_key_for(key)
           key = key.to_s
-          dimension_key = strip_mode_prefix(key.delete_prefix(ABOVE_CONTEXT_PREFIX))
+          base = key.sub(SCHEDULED_SUFFIX, "")
+          dimension_key = strip_mode_prefix(base.delete_prefix(ABOVE_CONTEXT_PREFIX))
           dimension = Usage::Catalog[dimension_key]
           return nil unless dimension
-          return key if key == dimension_key
+          return nil if dimension.token_key.nil? && base.start_with?(ABOVE_CONTEXT_PREFIX)
 
-          dimension.token_key ? key : nil
+          key
         end
 
         def parse_dimension_key(key)