llm_cost_tracker 0.3.3 → 0.4.1

data/lib/llm_cost_tracker/price_sync/sources/litellm.rb

@@ -65,9 +65,8 @@ module LlmCostTracker
             provider: provider,
             input: price_per_million(entry["input_cost_per_token"]),
             output: price_per_million(entry["output_cost_per_token"]),
-            cached_input: provider == "anthropic" ? nil : cache_read,
-            cache_read_input: provider == "anthropic" ? cache_read : nil,
-            cache_creation_input: provider == "anthropic" ? cache_write : nil,
+            cache_read_input: cache_read,
+            cache_write_input: cache_write,
             source: name,
             source_version: response_version(response),
             fetched_at: response.fetched_at

data/lib/llm_cost_tracker/price_sync/sources/open_router.rb

@@ -68,9 +68,8 @@ module LlmCostTracker
             provider: provider,
             input: price_per_million(pricing["prompt"]),
             output: price_per_million(pricing["completion"]),
-            cached_input: provider == "anthropic" ? nil : cache_read,
-            cache_read_input: provider == "anthropic" ? cache_read : nil,
-            cache_creation_input: provider == "anthropic" ? cache_write : nil,
+            cache_read_input: cache_read,
+            cache_write_input: cache_write,
             source: name,
             source_version: response_version(response),
             fetched_at: response.fetched_at

data/lib/llm_cost_tracker/prices.json

@@ -10,40 +10,40 @@
     ]
   },
   "models": {
-    "gpt-5.2": { "input": 1.75, "cached_input": 0.175, "output": 14.0 },
-    "gpt-5.1": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
-    "gpt-5": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
-    "gpt-5-mini": { "input": 0.25, "cached_input": 0.025, "output": 2.0 },
-    "gpt-5-nano": { "input": 0.05, "cached_input": 0.005, "output": 0.4 },
-    "gpt-4.1": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
-    "gpt-4.1-mini": { "input": 0.4, "cached_input": 0.1, "output": 1.6 },
-    "gpt-4.1-nano": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "gpt-5.2": { "input": 1.75, "cache_read_input": 0.175, "output": 14.0 },
+    "gpt-5.1": { "input": 1.25, "cache_read_input": 0.125, "output": 10.0 },
+    "gpt-5": { "input": 1.25, "cache_read_input": 0.125, "output": 10.0 },
+    "gpt-5-mini": { "input": 0.25, "cache_read_input": 0.025, "output": 2.0 },
+    "gpt-5-nano": { "input": 0.05, "cache_read_input": 0.005, "output": 0.4 },
+    "gpt-4.1": { "input": 2.0, "cache_read_input": 0.5, "output": 8.0 },
+    "gpt-4.1-mini": { "input": 0.4, "cache_read_input": 0.1, "output": 1.6 },
+    "gpt-4.1-nano": { "input": 0.1, "cache_read_input": 0.025, "output": 0.4 },
     "gpt-4o-2024-05-13": { "input": 5.0, "output": 15.0 },
-    "gpt-4o": { "input": 2.5, "cached_input": 1.25, "output": 10.0 },
-    "gpt-4o-mini": { "input": 0.15, "cached_input": 0.075, "output": 0.6 },
+    "gpt-4o": { "input": 2.5, "cache_read_input": 1.25, "output": 10.0 },
+    "gpt-4o-mini": { "input": 0.15, "cache_read_input": 0.075, "output": 0.6 },
     "gpt-4-turbo": { "input": 10.0, "output": 30.0 },
     "gpt-4": { "input": 30.0, "output": 60.0 },
     "gpt-3.5-turbo": { "input": 0.5, "output": 1.5 },
-    "o1": { "input": 15.0, "cached_input": 7.5, "output": 60.0 },
-    "o1-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
-    "o3": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
-    "o3-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
-    "o4-mini": { "input": 1.1, "cached_input": 0.275, "output": 4.4 },
-    "claude-sonnet-4-6": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
-    "claude-opus-4-6": { "input": 5.0, "output": 25.0, "cache_read_input": 0.5, "cache_creation_input": 6.25 },
-    "claude-opus-4-1": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
-    "claude-opus-4": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
-    "claude-sonnet-4-5": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
-    "claude-sonnet-4": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
-    "claude-haiku-4-5": { "input": 1.0, "output": 5.0, "cache_read_input": 0.1, "cache_creation_input": 1.25 },
-    "claude-3-7-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
-    "claude-3-5-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
-    "claude-3-5-haiku": { "input": 0.8, "output": 4.0, "cache_read_input": 0.08, "cache_creation_input": 1.0 },
-    "claude-3-opus": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
-    "gemini-2.5-pro": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
-    "gemini-2.5-flash": { "input": 0.3, "cached_input": 0.03, "output": 2.5 },
-    "gemini-2.5-flash-lite": { "input": 0.1, "cached_input": 0.01, "output": 0.4 },
-    "gemini-2.0-flash": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "o1": { "input": 15.0, "cache_read_input": 7.5, "output": 60.0 },
+    "o1-mini": { "input": 1.1, "cache_read_input": 0.55, "output": 4.4 },
+    "o3": { "input": 2.0, "cache_read_input": 0.5, "output": 8.0 },
+    "o3-mini": { "input": 1.1, "cache_read_input": 0.55, "output": 4.4 },
+    "o4-mini": { "input": 1.1, "cache_read_input": 0.275, "output": 4.4 },
+    "claude-sonnet-4-6": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_write_input": 3.75 },
+    "claude-opus-4-6": { "input": 5.0, "output": 25.0, "cache_read_input": 0.5, "cache_write_input": 6.25 },
+    "claude-opus-4-1": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_write_input": 18.75 },
+    "claude-opus-4": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_write_input": 18.75 },
+    "claude-sonnet-4-5": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_write_input": 3.75 },
+    "claude-sonnet-4": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_write_input": 3.75 },
+    "claude-haiku-4-5": { "input": 1.0, "output": 5.0, "cache_read_input": 0.1, "cache_write_input": 1.25 },
+    "claude-3-7-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_write_input": 3.75 },
+    "claude-3-5-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_write_input": 3.75 },
+    "claude-3-5-haiku": { "input": 0.8, "output": 4.0, "cache_read_input": 0.08, "cache_write_input": 1.0 },
+    "claude-3-opus": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_write_input": 18.75 },
+    "gemini-2.5-pro": { "input": 1.25, "cache_read_input": 0.125, "output": 10.0 },
+    "gemini-2.5-flash": { "input": 0.3, "cache_read_input": 0.03, "output": 2.5 },
+    "gemini-2.5-flash-lite": { "input": 0.1, "cache_read_input": 0.01, "output": 0.4 },
+    "gemini-2.0-flash": { "input": 0.1, "cache_read_input": 0.025, "output": 0.4 },
     "gemini-2.0-flash-lite": { "input": 0.075, "output": 0.3 },
     "gemini-1.5-pro": { "input": 1.25, "output": 5.0 },
     "gemini-1.5-flash": { "input": 0.075, "output": 0.3 }

data/lib/llm_cost_tracker/pricing.rb

@@ -8,32 +8,40 @@ module LlmCostTracker
     MUTEX = Monitor.new
 
     class << self
-      def cost_for(model:, input_tokens:, output_tokens:, cached_input_tokens: 0,
-                   cache_read_input_tokens: 0, cache_creation_input_tokens: 0)
-        prices = lookup(model)
+      def cost_for(provider:, model:, input_tokens:, output_tokens:, cache_read_input_tokens: 0,
+                   cache_write_input_tokens: 0, pricing_mode: nil)
+        prices = lookup(provider: provider, model: model)
         return nil unless prices
 
-        token_counts = normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
-                                               cache_read_input_tokens, cache_creation_input_tokens)
-        costs = calculate_costs(token_counts, prices)
+        usage = UsageBreakdown.build(
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
+          cache_read_input_tokens: cache_read_input_tokens,
+          cache_write_input_tokens: cache_write_input_tokens
+        )
+        costs = calculate_costs(usage, prices, pricing_mode: pricing_mode)
 
         Cost.new(
           input_cost: costs[:input].round(8),
-          cached_input_cost: costs[:cached_input].round(8),
           cache_read_input_cost: costs[:cache_read_input].round(8),
-          cache_creation_input_cost: costs[:cache_creation_input].round(8),
+          cache_write_input_cost: costs[:cache_write_input].round(8),
           output_cost: costs[:output].round(8),
           total_cost: costs.values.sum.round(8),
           currency: "USD"
         )
       end
 
-      def lookup(model)
+      def lookup(provider:, model:)
         table = prices
+        provider_name = provider.to_s
         model_name = model.to_s
+        provider_model = provider_name.empty? ? model_name : "#{provider_name}/#{model_name}"
         normalized_model = normalize_model_name(model_name)
 
-        table[model_name] || table[normalized_model] || fuzzy_match(model_name, normalized_model, table)
+        table[provider_model] ||
+          table[model_name] ||
+          table[normalized_model] ||
+          fuzzy_match(provider_model, normalized_model, table)
       end
 
       def models
@@ -64,36 +72,40 @@ module LlmCostTracker
 
       private
 
-      def normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
-                                  cache_read_input_tokens, cache_creation_input_tokens)
-        cached_input_tokens = cached_input_tokens.to_i
-
+      def calculate_costs(usage, prices, pricing_mode:)
         {
-          input: [input_tokens.to_i - cached_input_tokens, 0].max,
-          cached_input: cached_input_tokens,
-          cache_read_input: cache_read_input_tokens.to_i,
-          cache_creation_input: cache_creation_input_tokens.to_i,
-          output: output_tokens.to_i
-        }
-      end
-
-      def calculate_costs(token_counts, prices)
-        {
-          input: token_cost(token_counts[:input], prices[:input]),
-          cached_input: token_cost(token_counts[:cached_input], prices[:cached_input] || prices[:input]),
+          input: token_cost(usage.input_tokens, price_for(prices, :input, pricing_mode)),
           cache_read_input: token_cost(
-            token_counts[:cache_read_input],
-            prices[:cache_read_input] || prices[:cached_input] || prices[:input]
+            usage.cache_read_input_tokens,
+            price_for(prices, :cache_read_input, pricing_mode) || price_for(prices, :input, pricing_mode)
           ),
-          cache_creation_input: token_cost(
-            token_counts[:cache_creation_input],
-            prices[:cache_creation_input] || prices[:input]
+          cache_write_input: token_cost(
+            usage.cache_write_input_tokens,
+            price_for(prices, :cache_write_input, pricing_mode) || price_for(prices, :input, pricing_mode)
           ),
-          output: token_cost(token_counts[:output], prices[:output])
+          output: token_cost(usage.output_tokens, price_for(prices, :output, pricing_mode))
         }
       end
 
+      def price_for(prices, key, pricing_mode)
+        mode = normalized_pricing_mode(pricing_mode)
+        return prices[key] unless mode
+
+        prices[:"#{mode}_#{key}"] || prices[key]
+      end
+
+      def normalized_pricing_mode(value)
+        return nil if value.nil?
+
+        mode = value.to_s.strip
+        return nil if mode.empty? || mode == "standard"
+
+        mode
+      end
+
       def token_cost(tokens, per_million_price)
+        return 0.0 if tokens.to_i.zero?
+
         (tokens.to_f / 1_000_000) * per_million_price
       end
 

data/lib/llm_cost_tracker/railtie.rb

@@ -3,10 +3,11 @@
 module LlmCostTracker
   class Railtie < Rails::Railtie
     generators do
-      require_relative "generators/llm_cost_tracker/add_monthly_totals_generator"
+      require_relative "generators/llm_cost_tracker/add_period_totals_generator"
       require_relative "generators/llm_cost_tracker/add_latency_ms_generator"
       require_relative "generators/llm_cost_tracker/add_provider_response_id_generator"
       require_relative "generators/llm_cost_tracker/add_streaming_generator"
+      require_relative "generators/llm_cost_tracker/add_usage_breakdown_generator"
       require_relative "generators/llm_cost_tracker/install_generator"
       require_relative "generators/llm_cost_tracker/prices_generator"
       require_relative "generators/llm_cost_tracker/upgrade_cost_precision_generator"

data/lib/llm_cost_tracker/storage/active_record_rollups.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Storage
+    class ActiveRecordRollups
+      PERIODS = {
+        monthly: "month",
+        daily:   "day"
+      }.freeze
+
+      class << self
+        def reset!
+          remove_instance_variable(:@period_totals_enabled) if instance_variable_defined?(:@period_totals_enabled)
+        end
+
+        def increment!(event)
+          return unless event.cost&.total_cost
+          return unless period_totals_enabled?
+
+          model = period_total_model
+          model.upsert_all(
+            period_rows(event),
+            on_duplicate: total_upsert_sql(model),
+            record_timestamps: true,
+            unique_by: unique_by(model, %i[period period_start])
+          )
+        end
+
+        def monthly_total(time: Time.now.utc)
+          period_totals(%i[monthly], time: time).fetch(:monthly)
+        end
+
+        def daily_total(time: Time.now.utc)
+          period_totals(%i[daily], time: time).fetch(:daily)
+        end
+
+        def period_totals(periods, time: Time.now.utc)
+          periods = periods.map(&:to_sym).select { |period| PERIODS.key?(period) }
+          return {} if periods.empty?
+
+          if period_totals_enabled?
+            rollup_period_totals(periods, time)
+          else
+            periods.to_h { |period| [period, fallback_period_total(period, time)] }
+          end
+        end
+
+        private
+
+        def period_rows(event)
+          PERIODS.map do |period, name|
+            {
+              period: name,
+              period_start: bucket_for(period, event.tracked_at),
+              total_cost: event.cost.total_cost
+            }
+          end
+        end
+
+        def rollup_period_totals(periods, time)
+          buckets = periods.to_h { |period| [period, bucket_for(period, time)] }
+          index = buckets.to_h { |period, bucket| [[PERIODS.fetch(period), bucket], period] }
+          totals = periods.to_h { |period| [period, 0.0] }
+
+          period_total_model
+            .where(period: periods.map { |period| PERIODS.fetch(period) }, period_start: buckets.values)
+            .pluck(:period, :period_start, :total_cost)
+            .each do |name, start, total|
+              period = index[[name, start.to_date]]
+              totals[period] = total.to_f if period
+            end
+
+          totals
+        end
+
+        def fallback_period_total(period, time)
+          LlmCostTracker::LlmApiCall
+            .where(tracked_at: range_start_for(period, time)..time)
+            .sum(:total_cost)
+            .to_f
+        end
+
+        def period_totals_enabled?
+          return @period_totals_enabled unless @period_totals_enabled.nil?
+
+          @period_totals_enabled =
+            LlmCostTracker::LlmApiCall.connection.data_source_exists?("llm_cost_tracker_period_totals")
+        end
+
+        def period_total_model
+          require_relative "../period_total" unless defined?(LlmCostTracker::PeriodTotal)
+
+          LlmCostTracker::PeriodTotal
+        end
+
+        def range_start_for(period, time)
+          utc_time = time.to_time.utc
+
+          case period
+          when :monthly then utc_time.beginning_of_month
+          when :daily   then utc_time.beginning_of_day
+          end
+        end
+
+        def bucket_for(period, time)
+          utc_time = time.to_time.utc
+
+          case period
+          when :monthly then utc_time.beginning_of_month.to_date
+          when :daily   then utc_time.to_date
+          end
+        end
+
+        def unique_by(model, column)
+          return unless model.connection.supports_insert_conflict_target?
+
+          column
+        end
+
+        def total_upsert_sql(model)
+          Arel.sql(case model.connection.adapter_name
+                   when /mysql/i
+                     mysql_upsert_sql(model)
+                   else
+                     "total_cost = total_cost + excluded.total_cost, updated_at = excluded.updated_at"
+                   end)
+        end
+
+        def mysql_upsert_sql(model)
+          connection = model.connection
+          if connection.respond_to?(:supports_insert_raw_alias_syntax?, true) &&
+             connection.send(:supports_insert_raw_alias_syntax?)
+            values_reference = connection.quote_table_name("#{model.table_name}_values")
+            "total_cost = total_cost + #{values_reference}.total_cost, updated_at = #{values_reference}.updated_at"
+          else
+            "total_cost = total_cost + VALUES(total_cost), updated_at = VALUES(updated_at)"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "active_record_rollups"
+
 module LlmCostTracker
   module Storage
     class ActiveRecordStore
       class << self
         def reset!
-          remove_instance_variable(:@monthly_totals_enabled) if instance_variable_defined?(:@monthly_totals_enabled)
+          ActiveRecordRollups.reset!
         end
 
         def save(event)
           tags = stringify_tags(event.tags || {})
+          model = LlmCostTracker::LlmApiCall
+          columns = model.columns_hash
 
           attributes = {
             provider:      event.provider,
@@ -20,102 +24,55 @@ module LlmCostTracker
             input_cost:    event.cost&.input_cost,
             output_cost:   event.cost&.output_cost,
             total_cost:    event.cost&.total_cost,
-            tags:          tags_for_storage(tags),
+            tags:          tags_for_storage(tags, model),
             tracked_at:    event.tracked_at
           }
-          attributes[:latency_ms] = event.latency_ms if LlmCostTracker::LlmApiCall.latency_column?
-          attributes[:stream] = event.stream if LlmCostTracker::LlmApiCall.stream_column?
-          attributes[:usage_source] = event.usage_source if LlmCostTracker::LlmApiCall.usage_source_column?
-          if LlmCostTracker::LlmApiCall.provider_response_id_column?
-            attributes[:provider_response_id] = event.provider_response_id
+          optional_attributes(event).each do |name, value|
+            attributes[name] = value if columns.key?(name.to_s)
           end
-
-          LlmCostTracker::LlmApiCall.transaction do
-            call = LlmCostTracker::LlmApiCall.create!(attributes)
-            increment_monthly_total(event)
+          attributes[:latency_ms] = event.latency_ms if columns.key?("latency_ms")
+          attributes[:stream] = event.stream if columns.key?("stream")
+          attributes[:usage_source] = event.usage_source if columns.key?("usage_source")
+          attributes[:provider_response_id] = event.provider_response_id if columns.key?("provider_response_id")
+
+          model.transaction do
+            call = model.create!(attributes)
+            ActiveRecordRollups.increment!(event)
             call
           end
         end
 
         def monthly_total(time: Time.now.utc)
-          if monthly_totals_enabled?
-            monthly_total_model.where(month_start: month_start_for(time)).pick(:total_cost).to_f
-          else
-            LlmCostTracker::LlmApiCall
-              .where(tracked_at: time.beginning_of_month..time)
-              .sum(:total_cost)
-              .to_f
-          end
-        end
-
-        private
-
-        def increment_monthly_total(event)
-          return unless monthly_totals_enabled?
-          return unless event.cost&.total_cost
-
-          monthly_total_model.upsert_all(
-            [
-              {
-                month_start: month_start_for(event.tracked_at),
-                total_cost: event.cost.total_cost
-              }
-            ],
-            on_duplicate: monthly_total_upsert_sql,
-            record_timestamps: true,
-            unique_by: monthly_total_unique_by
-          )
-        end
-
-        def monthly_totals_enabled?
-          return @monthly_totals_enabled unless @monthly_totals_enabled.nil?
-
-          @monthly_totals_enabled =
-            LlmCostTracker::LlmApiCall.connection.data_source_exists?("llm_cost_tracker_monthly_totals")
+          ActiveRecordRollups.monthly_total(time: time)
         end
 
-        def monthly_total_model
-          require_relative "../monthly_total" unless defined?(LlmCostTracker::MonthlyTotal)
-
-          LlmCostTracker::MonthlyTotal
+        def daily_total(time: Time.now.utc)
+          ActiveRecordRollups.daily_total(time: time)
         end
 
-        def month_start_for(time)
-          time.to_time.utc.beginning_of_month.to_date
+        def period_totals(periods, time: Time.now.utc)
+          ActiveRecordRollups.period_totals(periods, time: time)
         end
 
-        def monthly_total_unique_by
-          return unless monthly_total_model.connection.supports_insert_conflict_target?
-
-          :month_start
-        end
-
-        def monthly_total_upsert_sql
-          Arel.sql(case monthly_total_model.connection.adapter_name
-                   when /mysql/i
-                     mysql_upsert_sql
-                   else
-                     "total_cost = total_cost + excluded.total_cost, updated_at = excluded.updated_at"
-                   end)
-        end
-
-        def mysql_upsert_sql
-          connection = monthly_total_model.connection
-          if connection.respond_to?(:supports_insert_raw_alias_syntax?, true) &&
-             connection.send(:supports_insert_raw_alias_syntax?)
-            values_reference = connection.quote_table_name("#{monthly_total_model.table_name}_values")
-            "total_cost = total_cost + #{values_reference}.total_cost, updated_at = #{values_reference}.updated_at"
-          else
-            "total_cost = total_cost + VALUES(total_cost), updated_at = VALUES(updated_at)"
-          end
-        end
+        private
 
         def stringify_tags(tags)
           tags.transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
         end
 
-        def tags_for_storage(tags)
-          LlmCostTracker::LlmApiCall.tags_json_column? ? tags : tags.to_json
+        def tags_for_storage(tags, model)
+          model.tags_json_column? ? tags : tags.to_json
+        end
+
+        def optional_attributes(event)
+          {
+            cache_read_input_tokens: event.cache_read_input_tokens,
+            cache_write_input_tokens: event.cache_write_input_tokens,
+            hidden_output_tokens: event.hidden_output_tokens,
+            cache_read_input_cost: event.cost&.cache_read_input_cost,
+            cache_write_input_cost: event.cost&.cache_write_input_cost,
+            pricing_mode: event.pricing_mode
+          }
         end
 
         def stringify_tag_value(value)

data/lib/llm_cost_tracker/stream_collector.rb

@@ -8,11 +8,12 @@ module LlmCostTracker
   class StreamCollector
     attr_reader :provider
 
-    def initialize(provider:, model:, latency_ms: nil, provider_response_id: nil, metadata: {})
+    def initialize(provider:, model:, latency_ms: nil, provider_response_id: nil, pricing_mode: nil, metadata: {})
       @provider = provider.to_s
       @model = model
       @latency_ms = latency_ms
       @provider_response_id = provider_response_id
+      @pricing_mode = pricing_mode
       @metadata = ValueHelpers.deep_dup(metadata || {})
       @events = []
       @explicit_usage = nil
@@ -74,6 +75,7 @@ module LlmCostTracker
           model: @model,
           latency_ms: @latency_ms,
           provider_response_id: @provider_response_id,
+          pricing_mode: @pricing_mode,
           metadata: ValueHelpers.deep_dup(@metadata)
         }
       end
@@ -88,6 +90,7 @@ module LlmCostTracker
         stream: true,
         usage_source: parsed.usage_source,
         provider_response_id: parsed.provider_response_id || snapshot[:provider_response_id],
+        pricing_mode: snapshot[:pricing_mode],
         metadata: error_metadata(errored).merge(snapshot[:metadata]).merge(parsed.metadata)
       )
     end
@@ -136,7 +139,6 @@ module LlmCostTracker
         model: snapshot[:model],
         input_tokens: input,
         output_tokens: output,
-        total_tokens: input + output,
         stream: true,
         usage_source: :manual,
         **extras