llm_cost_tracker 0.3.2 → 0.4.0

data/lib/llm_cost_tracker/event_metadata.rb

@@ -3,32 +3,31 @@
 module LlmCostTracker
   module EventMetadata
     INTERNAL_TAG_KEYS = %w[
-      cache_creation_input_tokens
-      cache_creation_tokens
       cache_read_input_tokens
-      cache_read_tokens
-      cached_input_tokens
+      cache_write_input_tokens
+      hidden_output_tokens
       input_tokens
       output_tokens
+      pricing_mode
       provider_response_id
-      reasoning_tokens
       total_tokens
     ].freeze
 
     class << self
       def usage_data(input_tokens, output_tokens, metadata)
         metadata = metadata.to_h.symbolize_keys
-        cache_read = first_integer(metadata, :cache_read_input_tokens, :cache_read_tokens)
-        cache_creation = first_integer(metadata, :cache_creation_input_tokens, :cache_creation_tokens)
-
-        {
-          input_tokens: input_tokens.to_i,
-          output_tokens: output_tokens.to_i,
-          cached_input_tokens: metadata[:cached_input_tokens].to_i,
+        cache_read = first_integer(metadata, :cache_read_input_tokens)
+        cache_write = first_integer(metadata, :cache_write_input_tokens)
+        hidden_output = first_integer(metadata, :hidden_output_tokens)
+        breakdown = UsageBreakdown.build(
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
           cache_read_input_tokens: cache_read,
-          cache_creation_input_tokens: cache_creation,
-          total_tokens: input_tokens.to_i + output_tokens.to_i + cache_read + cache_creation
-        }
+          cache_write_input_tokens: cache_write,
+          hidden_output_tokens: hidden_output
+        )
+
+        breakdown.to_h.merge(pricing_mode: normalized_pricing_mode(metadata[:pricing_mode])).compact
       end
 
       def tags(metadata)
@@ -41,6 +40,13 @@ module LlmCostTracker
         keys.each { |key| return metadata[key].to_i unless metadata[key].nil? }
         0
       end
+
+      def normalized_pricing_mode(value)
+        return nil if value.nil?
+
+        mode = value.to_s.strip
+        mode.empty? || mode == "standard" ? nil : mode
+      end
     end
   end
 end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_period_totals_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class AddPeriodTotalsGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a migration to add llm_cost_tracker_period_totals"
+
+      def create_migration_file
+        migration_template(
+          "add_period_totals_to_llm_cost_tracker.rb.erb",
+          "db/migrate/add_period_totals_to_llm_cost_tracker.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_usage_breakdown_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class AddUsageBreakdownGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a migration to add usage and cost breakdown columns to llm_api_calls"
+
+      def create_migration_file
+        migration_template(
+          "add_usage_breakdown_to_llm_api_calls.rb.erb",
+          "db/migrate/add_usage_breakdown_to_llm_api_calls.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_period_totals_to_llm_cost_tracker.rb.erb

@@ -0,0 +1,66 @@
+class AddPeriodTotalsToLlmCostTracker < ActiveRecord::Migration<%= migration_version %>
+  def up
+    create_table :llm_cost_tracker_period_totals do |t|
+      t.string :period, null: false
+      t.date :period_start, null: false
+      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
+
+      t.timestamps
+    end unless table_exists?(:llm_cost_tracker_period_totals)
+
+    add_index :llm_cost_tracker_period_totals, [:period, :period_start],
+              unique: true unless index_exists?(:llm_cost_tracker_period_totals, [:period, :period_start])
+
+    backfill_period_totals
+  end
+
+  def down
+    remove_index :llm_cost_tracker_period_totals, [:period, :period_start] if index_exists?(:llm_cost_tracker_period_totals, [:period, :period_start])
+    drop_table :llm_cost_tracker_period_totals if table_exists?(:llm_cost_tracker_period_totals)
+  end
+
+  private
+
+  def backfill_period_totals
+    return unless table_exists?(:llm_api_calls)
+
+    backfill_period_total("day", day_bucket_sql)
+    backfill_period_total("month", month_bucket_sql)
+  end
+
+  def backfill_period_total(period, bucket_sql)
+    execute <<~SQL
+      INSERT INTO llm_cost_tracker_period_totals (period, period_start, total_cost, created_at, updated_at)
+      SELECT #{connection.quote(period)} AS period,
+             #{bucket_sql} AS period_start,
+             SUM(total_cost) AS total_cost,
+             CURRENT_TIMESTAMP,
+             CURRENT_TIMESTAMP
+      FROM llm_api_calls
+      WHERE total_cost IS NOT NULL
+      GROUP BY #{bucket_sql}
+    SQL
+  end
+
+  def day_bucket_sql
+    case connection.adapter_name
+    when /postgres/i
+      "DATE_TRUNC('day', tracked_at)::date"
+    when /mysql/i
+      "DATE(tracked_at)"
+    else
+      "date(tracked_at)"
+    end
+  end
+
+  def month_bucket_sql
+    case connection.adapter_name
+    when /postgres/i
+      "DATE_TRUNC('month', tracked_at)::date"
+    when /mysql/i
+      "DATE_FORMAT(tracked_at, '%Y-%m-01')"
+    else
+      "strftime('%Y-%m-01', tracked_at)"
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_usage_breakdown_to_llm_api_calls.rb.erb

@@ -0,0 +1,29 @@
+class AddUsageBreakdownToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
+  def up
+    unless column_exists?(:llm_api_calls, :cache_read_input_tokens)
+      add_column :llm_api_calls, :cache_read_input_tokens, :integer, null: false, default: 0
+    end
+    unless column_exists?(:llm_api_calls, :cache_write_input_tokens)
+      add_column :llm_api_calls, :cache_write_input_tokens, :integer, null: false, default: 0
+    end
+    unless column_exists?(:llm_api_calls, :hidden_output_tokens)
+      add_column :llm_api_calls, :hidden_output_tokens, :integer, null: false, default: 0
+    end
+    unless column_exists?(:llm_api_calls, :cache_read_input_cost)
+      add_column :llm_api_calls, :cache_read_input_cost, :decimal, precision: 20, scale: 8
+    end
+    unless column_exists?(:llm_api_calls, :cache_write_input_cost)
+      add_column :llm_api_calls, :cache_write_input_cost, :decimal, precision: 20, scale: 8
+    end
+    add_column :llm_api_calls, :pricing_mode, :string unless column_exists?(:llm_api_calls, :pricing_mode)
+  end
+
+  def down
+    remove_column :llm_api_calls, :pricing_mode if column_exists?(:llm_api_calls, :pricing_mode)
+    remove_column :llm_api_calls, :cache_write_input_cost if column_exists?(:llm_api_calls, :cache_write_input_cost)
+    remove_column :llm_api_calls, :cache_read_input_cost if column_exists?(:llm_api_calls, :cache_read_input_cost)
+    remove_column :llm_api_calls, :hidden_output_tokens if column_exists?(:llm_api_calls, :hidden_output_tokens)
+    remove_column :llm_api_calls, :cache_write_input_tokens if column_exists?(:llm_api_calls, :cache_write_input_tokens)
+    remove_column :llm_api_calls, :cache_read_input_tokens if column_exists?(:llm_api_calls, :cache_read_input_tokens)
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_api_calls.rb.erb

@@ -6,13 +6,19 @@ class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
       t.integer :input_tokens,  null: false, default: 0
       t.integer :output_tokens, null: false, default: 0
       t.integer :total_tokens,  null: false, default: 0
+      t.integer :cache_read_input_tokens,  null: false, default: 0
+      t.integer :cache_write_input_tokens, null: false, default: 0
+      t.integer :hidden_output_tokens,     null: false, default: 0
       t.decimal :input_cost,    precision: 20, scale: 8
+      t.decimal :cache_read_input_cost,  precision: 20, scale: 8
+      t.decimal :cache_write_input_cost, precision: 20, scale: 8
       t.decimal :output_cost,   precision: 20, scale: 8
       t.decimal :total_cost,    precision: 20, scale: 8
       t.integer :latency_ms
       t.boolean :stream,        null: false, default: false
       t.string  :usage_source
       t.string  :provider_response_id
+      t.string  :pricing_mode
       if postgresql?
         t.jsonb :tags, null: false, default: {}
       else
@@ -23,6 +29,14 @@ class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
       t.timestamps
     end
 
+    create_table :llm_cost_tracker_period_totals do |t|
+      t.string :period, null: false
+      t.date :period_start, null: false
+      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
+
+      t.timestamps
+    end
+
     add_index :llm_api_calls, :provider
     add_index :llm_api_calls, :model
     add_index :llm_api_calls, :tracked_at
@@ -31,6 +45,7 @@ class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
     add_index :llm_api_calls, :usage_source
     add_index :llm_api_calls, :provider_response_id
     add_index :llm_api_calls, :tags, using: :gin if postgresql?
+    add_index :llm_cost_tracker_period_totals, [:period, :period_start], unique: true
   end
 
   private

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/initializer.rb.erb

@@ -12,6 +12,8 @@ LlmCostTracker.configure do |config|
 
   # Monthly budget in USD. Set to nil to disable budget alerts.
   # config.monthly_budget = 100.00
+  # config.daily_budget = 10.00
+  # config.per_call_budget = 1.00
   # config.budget_exceeded_behavior = :notify # :notify, :raise, or :block_requests
 
   # What to do when storage fails.
@@ -23,7 +25,7 @@ LlmCostTracker.configure do |config|
   # Callback when monthly budget is exceeded.
   # config.on_budget_exceeded = ->(data) {
   #   Rails.logger.warn "[LlmCostTracker] Budget exceeded! " \
-  #     "Monthly total: $#{data[:monthly_total]}, Budget: $#{data[:budget]}"
+  #     "#{data[:budget_type]} total: $#{data[:total]}, Budget: $#{data[:budget]}"
   #   # Or send a Slack notification, email, etc.
   # }
 

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/llm_cost_tracker_prices.yml.erb

@@ -8,9 +8,9 @@
 # Supported price keys:
 # - input
 # - output
-# - cached_input
 # - cache_read_input
-# - cache_creation_input
+# - cache_write_input
+# - mode_input / mode_output / mode_cache_read_input / mode_cache_write_input
 #
 # Optional metadata keys, ignored by cost calculation:
 # - _source
@@ -24,10 +24,18 @@
 # models:
 #   "ft:gpt-4o-mini:my-org":
 #     input: 0.30
-#     cached_input: 0.15
+#     cache_read_input: 0.15
 #     output: 1.20
 #     _notes: "Internal fine-tune rate"
 #
+# Example: alternate pricing mode
+# models:
+#   "batchable-model":
+#     input: 1.00
+#     output: 2.00
+#     batch_input: 0.50
+#     batch_output: 1.00
+#
 # Example: negotiated provider discount
 # models:
 #   "gpt-4o":

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/upgrade_llm_api_call_tags_to_jsonb.rb.erb

@@ -8,6 +8,7 @@ class UpgradeLlmApiCallTagsToJsonb < ActiveRecord::Migration<%= migration_versio
     return if tags_jsonb?
 
     remove_index :llm_api_calls, :tags if index_exists?(:llm_api_calls, :tags)
+    say "Upgrading llm_api_calls.tags to jsonb rewrites the table on PostgreSQL. Run this migration during a maintenance window on large datasets."
 
     change_column(
       :llm_api_calls,

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -8,6 +8,8 @@ require_relative "../logging"
 module LlmCostTracker
   module Middleware
     class Faraday < ::Faraday::Middleware
+      STREAM_CAPTURE_LIMIT_BYTES = 1_048_576
+
       def initialize(app, **options)
         super(app)
         @tags = options.fetch(:tags, {})
@@ -85,15 +87,12 @@ module LlmCostTracker
       end
 
       def parse_stream(parser, request_url, request_body, response_env, stream_buffer)
-        body = stream_buffer&.string
+        body = stream_buffer&.dig(:buffer)&.string
         body = read_body(response_env.body) if body.nil? || body.empty?
 
         if body.nil? || body.empty?
-          Logging.warn(
-            "Unable to capture streaming response for #{request_url}; " \
-            "fall back to LlmCostTracker.track_stream for manual capture."
-          )
-          return nil
+          Logging.warn(capture_warning(request_url, stream_buffer))
+          return parser.parse_stream(request_url, request_body, response_env.status, [])
         end
 
         events = Parsers::SSE.parse(body)
@@ -106,12 +105,21 @@ module LlmCostTracker
         original = request_env.request.on_data
         return nil unless original
 
-        buffer = StringIO.new
+        state = { buffer: StringIO.new, bytes: 0, overflowed: false }
         request_env.request.on_data = proc do |chunk, size, env|
-          buffer << chunk.to_s
+          chunk = chunk.to_s
+          unless state[:overflowed]
+            if state[:bytes] + chunk.bytesize <= STREAM_CAPTURE_LIMIT_BYTES
+              state[:buffer] << chunk
+              state[:bytes] += chunk.bytesize
+            else
+              state[:overflowed] = true
+              state[:buffer] = nil
+            end
+          end
           original.call(chunk, size, env)
         end
-        buffer
+        state
       rescue StandardError => e
         Logging.warn("Unable to install streaming tap: #{e.class}: #{e.message}")
         nil
@@ -145,6 +153,16 @@ module LlmCostTracker
       def elapsed_ms(started_at)
         ((monotonic_time - started_at) * 1000).round
       end
+
+      def capture_warning(request_url, stream_buffer)
+        unless stream_buffer&.dig(:overflowed)
+          return "Unable to capture streaming response for #{request_url}; " \
+                 "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
+        end
+
+        "Streaming response for #{request_url} exceeded #{STREAM_CAPTURE_LIMIT_BYTES} bytes; " \
+          "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -7,10 +7,9 @@ module LlmCostTracker
     :input_tokens,
     :output_tokens,
     :total_tokens,
-    :cached_input_tokens,
     :cache_read_input_tokens,
-    :cache_creation_input_tokens,
-    :reasoning_tokens,
+    :cache_write_input_tokens,
+    :hidden_output_tokens,
     :stream,
     :usage_source,
     :provider_response_id
@@ -34,11 +33,10 @@ module LlmCostTracker
         model: attributes.fetch(:model),
         input_tokens: attributes.fetch(:input_tokens).to_i,
         output_tokens: attributes.fetch(:output_tokens).to_i,
-        total_tokens: attributes.fetch(:total_tokens, 0).to_i,
-        cached_input_tokens: attributes[:cached_input_tokens],
+        total_tokens: attributes.fetch(:total_tokens, usage_breakdown(attributes).total_tokens).to_i,
         cache_read_input_tokens: attributes[:cache_read_input_tokens],
-        cache_creation_input_tokens: attributes[:cache_creation_input_tokens],
-        reasoning_tokens: attributes[:reasoning_tokens],
+        cache_write_input_tokens: attributes[:cache_write_input_tokens],
+        hidden_output_tokens: attributes[:hidden_output_tokens],
         stream: attributes[:stream] || false,
         usage_source: attributes[:usage_source],
         provider_response_id: attributes[:provider_response_id]
@@ -52,5 +50,16 @@ module LlmCostTracker
     def to_h
       super.compact
     end
+
+    def self.usage_breakdown(attributes)
+      UsageBreakdown.build(
+        input_tokens: attributes.fetch(:input_tokens),
+        output_tokens: attributes.fetch(:output_tokens),
+        cache_read_input_tokens: attributes[:cache_read_input_tokens],
+        cache_write_input_tokens: attributes[:cache_write_input_tokens],
+        hidden_output_tokens: attributes[:hidden_output_tokens]
+      )
+    end
+    private_class_method :usage_breakdown
   end
 end

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -28,6 +28,8 @@ module LlmCostTracker
         return nil unless usage
 
         request = safe_json_parse(request_body)
+        cache_read = usage["cache_read_input_tokens"].to_i
+        cache_write = usage["cache_creation_input_tokens"].to_i
 
         ParsedUsage.build(
           provider: "anthropic",
@@ -35,10 +37,9 @@ module LlmCostTracker
           model: response["model"] || request["model"],
           input_tokens: usage["input_tokens"].to_i,
           output_tokens: usage["output_tokens"].to_i,
-          total_tokens: usage["input_tokens"].to_i + usage["output_tokens"].to_i +
-            usage["cache_read_input_tokens"].to_i + usage["cache_creation_input_tokens"].to_i,
+          total_tokens: usage["input_tokens"].to_i + usage["output_tokens"].to_i + cache_read + cache_write,
           cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          cache_write_input_tokens: usage["cache_creation_input_tokens"],
           usage_source: :response
         )
       end
@@ -105,7 +106,7 @@ module LlmCostTracker
         input = usage["input_tokens"].to_i
         output = usage["output_tokens"].to_i
         cache_read = usage["cache_read_input_tokens"].to_i
-        cache_creation = usage["cache_creation_input_tokens"].to_i
+        cache_write = usage["cache_creation_input_tokens"].to_i
 
         ParsedUsage.build(
           provider: "anthropic",
@@ -113,9 +114,9 @@ module LlmCostTracker
           model: model,
           input_tokens: input,
           output_tokens: output,
-          total_tokens: input + output + cache_read + cache_creation,
+          total_tokens: input + output + cache_read + cache_write,
           cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          cache_write_input_tokens: usage["cache_creation_input_tokens"],
           stream: true,
           usage_source: :stream_final
         )

data/lib/llm_cost_tracker/parsers/base.rb

@@ -23,7 +23,8 @@ module LlmCostTracker
         body = request_body.to_s
         return false if body.empty?
 
-        body.include?('"stream":true') || body.include?('"stream": true') || body.include?("stream: true")
+        request = safe_json_parse(body)
+        request.is_a?(Hash) && request["stream"] == true
       end
 
       def parse_stream(_request_url, _request_body, _response_status, _events)

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -74,13 +74,16 @@ module LlmCostTracker
       private
 
       def build_parsed_usage(request_url, usage, usage_source:, stream: false, provider_response_id: nil)
+        cache_read = usage["cachedContentTokenCount"].to_i
+
         ParsedUsage.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
-          input_tokens: usage["promptTokenCount"].to_i,
+          input_tokens: [usage["promptTokenCount"].to_i - cache_read, 0].max,
           output_tokens: output_tokens(usage),
           total_tokens: usage["totalTokenCount"].to_i,
-          cached_input_tokens: usage["cachedContentTokenCount"],
+          cache_read_input_tokens: usage["cachedContentTokenCount"],
+          hidden_output_tokens: usage["thoughtsTokenCount"],
           stream: stream,
           usage_source: usage_source,
           provider_response_id: provider_response_id

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -13,15 +13,17 @@ module LlmCostTracker
         return nil unless usage
 
         request = safe_json_parse(request_body)
+        cache_read = cache_read_input_tokens(usage)
 
         ParsedUsage.build(
           provider: provider_for(request_url),
           provider_response_id: response["id"],
           model: response["model"] || request["model"],
-          input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
+          input_tokens: regular_input_tokens(usage, cache_read),
           output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
           total_tokens: usage["total_tokens"].to_i,
-          cached_input_tokens: cached_input_tokens(usage),
+          cache_read_input_tokens: cache_read,
+          hidden_output_tokens: hidden_output_tokens(usage),
           usage_source: :response
         )
       end
@@ -34,14 +36,16 @@ module LlmCostTracker
         usage = detect_stream_usage(events)
 
         if usage
+          cache_read = cache_read_input_tokens(usage)
           ParsedUsage.build(
             provider: provider_for(request_url),
             provider_response_id: detect_stream_response_id(events),
             model: model,
-            input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
+            input_tokens: regular_input_tokens(usage, cache_read),
             output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
             total_tokens: usage["total_tokens"].to_i,
-            cached_input_tokens: cached_input_tokens(usage),
+            cache_read_input_tokens: cache_read,
+            hidden_output_tokens: hidden_output_tokens(usage),
             stream: true,
             usage_source: :stream_final
           )
@@ -92,10 +96,19 @@ module LlmCostTracker
         nil
       end
 
-      def cached_input_tokens(usage)
+      def regular_input_tokens(usage, cache_read)
+        [(usage["prompt_tokens"] || usage["input_tokens"]).to_i - cache_read.to_i, 0].max
+      end
+
+      def cache_read_input_tokens(usage)
         details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
         details["cached_tokens"]
       end
+
+      def hidden_output_tokens(usage)
+        details = usage["completion_tokens_details"] || usage["output_tokens_details"] || {}
+        details["reasoning_tokens"]
+      end
     end
   end
 end

data/lib/llm_cost_tracker/period_total.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module LlmCostTracker
+  class PeriodTotal < ActiveRecord::Base
+    self.table_name = "llm_cost_tracker_period_totals"
+  end
+end

data/lib/llm_cost_tracker/price_registry.rb

@@ -10,7 +10,7 @@ module LlmCostTracker
   module PriceRegistry
     DEFAULT_PRICES_PATH = File.expand_path("prices.json", __dir__)
     EMPTY_PRICES = {}.freeze
-    PRICE_KEYS = %w[input cached_input output cache_read_input cache_creation_input].freeze
+    PRICE_KEYS = %w[input output cache_read_input cache_write_input].freeze
     METADATA_KEYS = %w[_source _source_version _fetched_at _updated _notes _validator_override].freeze
     MUTEX = Monitor.new
 
@@ -60,7 +60,7 @@ module LlmCostTracker
       def normalize_price_entry(price)
         price.each_with_object({}) do |(key, value), normalized|
           key = key.to_s
-          normalized[key.to_sym] = Float(value) if PRICE_KEYS.include?(key)
+          normalized[key.to_sym] = Float(value) if price_key?(key)
         end
       end
 
@@ -80,15 +80,25 @@ module LlmCostTracker
       end
 
       def warn_unknown_keys(model, price, path)
-        unknown_keys = price.keys.map(&:to_s) - PRICE_KEYS - METADATA_KEYS
+        unknown_keys = price.keys.map(&:to_s).reject do |key|
+          price_key?(key) || METADATA_KEYS.include?(key)
+        end
         return if unknown_keys.empty?
 
         Logging.warn(
           "Unknown price keys #{unknown_keys.inspect} for #{model.inspect} in #{path}; " \
-          "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}"
+          "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}; mode-specific keys use mode_input"
         )
       end
 
+      def price_key?(key)
+        return true if PRICE_KEYS.include?(key)
+
+        PRICE_KEYS.any? do |base_key|
+          key.end_with?("_#{base_key}") && key.delete_suffix("_#{base_key}") != ""
+        end
+      end
+
       def load_price_file(path)
         contents = File.read(path)
         return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)

data/lib/llm_cost_tracker/price_sync/merger.rb

@@ -6,7 +6,7 @@ module LlmCostTracker
       Discrepancy = Data.define(:model, :field, :values)
 
       PRIORITY_ORDER = %i[litellm openrouter].freeze
-      SUPPLEMENTAL_FIELDS = %i[cached_input cache_read_input cache_creation_input].freeze
+      SUPPLEMENTAL_FIELDS = %i[cache_read_input cache_write_input].freeze
 
       def merge(results_by_source)
         prices = collect_prices(results_by_source)

data/lib/llm_cost_tracker/price_sync/raw_price.rb

@@ -7,24 +7,22 @@ module LlmCostTracker
       :provider,
       :input,
       :output,
-      :cached_input,
       :cache_read_input,
-      :cache_creation_input,
+      :cache_write_input,
       :source,
       :source_version,
       :fetched_at
     )
 
     class RawPrice
-      PRICE_FIELDS = %w[input output cached_input cache_read_input cache_creation_input].freeze
+      PRICE_FIELDS = %w[input output cache_read_input cache_write_input].freeze
 
       def to_registry_entry(today:)
         {
           "input" => input,
           "output" => output,
-          "cached_input" => cached_input,
           "cache_read_input" => cache_read_input,
-          "cache_creation_input" => cache_creation_input,
+          "cache_write_input" => cache_write_input,
           "_source" => source.to_s,
           "_source_version" => source_version,
           "_fetched_at" => fetched_at || today.iso8601