llm_cost_tracker 0.3.2 → 0.4.0

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,9 +3,11 @@
 module LlmCostTracker
   class Railtie < Rails::Railtie
     generators do
+      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,122 @@
+# 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?
+
+          PERIODS.each_key { |period| increment_period_total(period, event) }
+        end
+
+        def monthly_total(time: Time.now.utc)
+          period_total(:monthly, time)
+        end
+
+        def daily_total(time: Time.now.utc)
+          period_total(:daily, time)
+        end
+
+        private
+
+        def period_total(period, time)
+          if period_totals_enabled?
+            period_total_model
+              .where(period: PERIODS.fetch(period), period_start: bucket_for(period, time))
+              .pick(:total_cost)
+              .to_f
+          else
+            LlmCostTracker::LlmApiCall
+              .where(tracked_at: range_start_for(period, time)..time)
+              .sum(:total_cost)
+              .to_f
+          end
+        end
+
+        def increment_period_total(period, event)
+          model = period_total_model
+          model.upsert_all(
+            [
+              {
+                period: PERIODS.fetch(period),
+                period_start: bucket_for(period, event.tracked_at),
+                total_cost: event.cost.total_cost
+              }
+            ],
+            on_duplicate: total_upsert_sql(model),
+            record_timestamps: true,
+            unique_by: unique_by(model, %i[period period_start])
+          )
+        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,11 +1,19 @@
 # frozen_string_literal: true
 
+require_relative "active_record_rollups"
+
 module LlmCostTracker
   module Storage
     class ActiveRecordStore
       class << self
+        def reset!
+          ActiveRecordRollups.reset!
+        end
+
         def save(event)
           tags = stringify_tags(event.tags || {})
+          model = LlmCostTracker::LlmApiCall
+          columns = model.columns_hash
 
           attributes = {
             provider:      event.provider,
@@ -16,24 +24,30 @@ 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
+          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")
 
-          LlmCostTracker::LlmApiCall.create!(attributes)
+          model.transaction do
+            call = model.create!(attributes)
+            ActiveRecordRollups.increment!(event)
+            call
+          end
         end
 
         def monthly_total(time: Time.now.utc)
-          LlmCostTracker::LlmApiCall
-            .where(tracked_at: time.beginning_of_month..time)
-            .sum(:total_cost)
-            .to_f
+          ActiveRecordRollups.monthly_total(time: time)
+        end
+
+        def daily_total(time: Time.now.utc)
+          ActiveRecordRollups.daily_total(time: time)
         end
 
         private
@@ -42,8 +56,19 @@ module LlmCostTracker
           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
@@ -69,11 +70,12 @@ module LlmCostTracker
 
         @finished = true
         {
-          events: ValueHelpers.deep_dup(@events),
+          events: @events.dup,
           explicit_usage: ValueHelpers.deep_dup(@explicit_usage),
           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

data/lib/llm_cost_tracker/tags_column.rb

@@ -36,5 +36,24 @@ module LlmCostTracker
     def provider_response_id_column?
       columns_hash.key?("provider_response_id")
     end
+
+    def pricing_mode_column?
+      columns_hash.key?("pricing_mode")
+    end
+
+    def usage_breakdown_columns?
+      %w[
+        cache_read_input_tokens
+        cache_write_input_tokens
+        hidden_output_tokens
+      ].all? { |column| columns_hash.key?(column) }
+    end
+
+    def usage_breakdown_cost_columns?
+      %w[
+        cache_read_input_cost
+        cache_write_input_cost
+      ].all? { |column| columns_hash.key?(column) }
+    end
   end
 end

data/lib/llm_cost_tracker/tracker.rb

@@ -10,30 +10,76 @@ module LlmCostTracker
 
     class << self
       def enforce_budget!
+        return unless LlmCostTracker.configuration.enabled
+
         Budget.enforce!
       end
 
       def record(provider:, model:, input_tokens:, output_tokens:, latency_ms: nil, stream: false,
-                 usage_source: nil, provider_response_id: nil, metadata: {})
-        usage = EventMetadata.usage_data(input_tokens, output_tokens, metadata)
+                 usage_source: nil, provider_response_id: nil, pricing_mode: nil, metadata: {})
+        return unless LlmCostTracker.configuration.enabled
+
+        usage = usage_data(input_tokens, output_tokens, metadata, pricing_mode)
+        cost_data = cost_for_usage(provider, model, usage)
+
+        UnknownPricing.handle!(model) unless cost_data
+
+        event = build_event(
+          provider: provider,
+          model: model,
+          usage: usage,
+          cost_data: cost_data,
+          metadata: metadata,
+          latency_ms: latency_ms,
+          stream: stream,
+          usage_source: usage_source,
+          provider_response_id: provider_response_id
+        )
+
+        ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
+
+        stored = store(event)
+        Budget.check!(event) unless stored == false
+
+        event
+      end
+
+      private
+
+      def usage_data(input_tokens, output_tokens, metadata, pricing_mode)
+        metadata = metadata.merge(pricing_mode: pricing_mode) unless pricing_mode.nil?
+
+        EventMetadata.usage_data(
+          input_tokens,
+          output_tokens,
+          metadata
+        )
+      end
 
-        cost_data = Pricing.cost_for(
+      def cost_for_usage(provider, model, usage)
+        Pricing.cost_for(
+          provider: provider,
           model: model,
           input_tokens: usage[:input_tokens],
           output_tokens: usage[:output_tokens],
-          cached_input_tokens: usage[:cached_input_tokens],
           cache_read_input_tokens: usage[:cache_read_input_tokens],
-          cache_creation_input_tokens: usage[:cache_creation_input_tokens]
+          cache_write_input_tokens: usage[:cache_write_input_tokens],
+          pricing_mode: usage[:pricing_mode]
         )
+      end
 
-        UnknownPricing.handle!(model) unless cost_data
-
-        event = Event.new(
+      def build_event(provider:, model:, usage:, cost_data:, metadata:, latency_ms:, stream:, usage_source:,
+                      provider_response_id:)
+        Event.new(
           provider: provider,
           model: model,
           input_tokens: usage[:input_tokens],
           output_tokens: usage[:output_tokens],
           total_tokens: usage[:total_tokens],
+          cache_read_input_tokens: usage[:cache_read_input_tokens],
+          cache_write_input_tokens: usage[:cache_write_input_tokens],
+          hidden_output_tokens: usage[:hidden_output_tokens],
+          pricing_mode: usage[:pricing_mode],
           cost: cost_data,
           tags: LlmCostTracker.configuration.default_tags.merge(EventMetadata.tags(metadata)).freeze,
           latency_ms: normalized_latency_ms(latency_ms),
@@ -42,17 +88,8 @@ module LlmCostTracker
           provider_response_id: normalized_provider_response_id(provider_response_id),
           tracked_at: Time.now.utc
         )
-
-        ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
-
-        stored = store(event)
-        Budget.check!(event) unless stored == false
-
-        event
       end
 
-      private
-
       def store(event)
         config = LlmCostTracker.configuration
         case config.storage_backend
@@ -69,7 +106,7 @@ module LlmCostTracker
 
       def log_event(event, config)
         message = "#{event.provider}/#{event.model} " \
-                  "tokens=#{event.input_tokens}+#{event.output_tokens} " \
+                  "tokens=#{event.total_tokens} " \
                   "cost=#{log_cost_label(event)}"
         message += " latency=#{event.latency_ms}ms" if event.latency_ms
         message += " stream=#{event.stream}" if event.stream
@@ -80,9 +117,7 @@ module LlmCostTracker
         event
       end
 
-      def log_cost_label(event)
-        event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
-      end
+      def log_cost_label(event) = event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
 
       def active_record_save(event)
         require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
@@ -111,11 +146,7 @@ module LlmCostTracker
         end
       end
 
-      def normalized_latency_ms(latency_ms)
-        return nil if latency_ms.nil?
-
-        [latency_ms.to_i, 0].max
-      end
+      def normalized_latency_ms(latency_ms) = latency_ms.nil? ? nil : [latency_ms.to_i, 0].max
 
       def normalized_usage_source(value)
         return nil if value.nil?
@@ -124,12 +155,7 @@ module LlmCostTracker
         USAGE_SOURCES.include?(symbol) ? symbol.to_s : nil
       end
 
-      def normalized_provider_response_id(value)
-        return nil if value.nil?
-
-        string = value.to_s
-        string.empty? ? nil : string
-      end
+      def normalized_provider_response_id(value) = value.nil? || value.to_s.empty? ? nil : value.to_s
     end
   end
 end