llm_cost_tracker 0.14.2 → 0.15.0

data/lib/llm_cost_tracker/providers/openai/stream_parser.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+
+require_relative "response_parser"
+require_relative "service_charges"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module StreamParser
+        RETAINED_RESPONSE_FIELDS = %w[id model service_tier background usage].freeze
+
+        def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
+          return nil unless response_status == 200
+
+          request = safe_json_parse(request_body)
+          usage = stream_usage(events)
+          attributes = stream_attributes(events, request: request, request_url: request_url, usage: usage)
+          background = find_event_value(events) { |data| data.dig("response", "background") }
+          if usage
+            event = ResponseParser.usage_event(
+              usage, stream: true, usage_source: Usage::Source::STREAM_FINAL, **attributes
+            )
+            return background ? event.keyed_by_response_id : event
+          end
+
+          warn_missing_stream_usage(request_url: request_url, request: request)
+          attributes[:service_line_items] = [] if background
+          build_unknown_stream_usage(**attributes)
+        end
+
+        def streaming_request?(request_url, request_parsed)
+          super || request_parsed["stream_format"] == "sse"
+        end
+
+        def auto_enable_stream_usage?(request_url, _request_parsed)
+          openai_chat_completions_url?(request_url)
+        end
+
+        def retain_stream_event?(data)
+          data.is_a?(Hash) && (data["item"].is_a?(Hash) || data["response"].is_a?(Hash))
+        end
+
+        def trim_stream_event(data)
+          return data unless data.is_a?(Hash)
+
+          item, response = data.values_at("item", "response")
+          data = data.merge("item" => ServiceCharges.billing_fields(item)) if item
+          return data unless response.is_a?(Hash)
+
+          output = Array(response["output"]).filter_map { |output_item| ServiceCharges.billing_fields(output_item) }
+          data.merge("response" => response.slice(*RETAINED_RESPONSE_FIELDS).merge("output" => output))
+        end
+
+        private
+
+        def stream_attributes(events, request:, request_url:, usage:)
+          provider = provider_for(request_url)
+          model = stream_value(events, "model", reverse: true) || request["model"]
+          service_tier = stream_value(events, "service_tier", reverse: true) || usage&.dig(:service_tier) ||
+                         request["service_tier"]
+          {
+            provider: provider,
+            model: model,
+            provider_response_id: stream_value(events, "id"),
+            pricing_mode: ResponseParser.combined_pricing_mode(
+              provider: provider, host: parsed_uri(request_url)&.host, model: model, service_tier: service_tier
+            ),
+            service_line_items: ServiceCharges.service_line_items_for(streamed_response(events), request:, model:) +
+              ServiceCharges.speech_line_items(request)
+          }
+        end
+
+        def stream_value(events, key, reverse: false)
+          find_event_value(events, reverse: reverse) { |data| envelope_value(data, key) }
+        end
+
+        def envelope_value(data, key)
+          data[key] || data.dig("response", key) || data.dig("chunk", key)
+        end
+
+        def stream_usage(events)
+          usage = find_event_value(events, reverse: true) do |data|
+            found = envelope_value(data, "usage") || data.dig("x_groq", "usage") || data.dig("chunk", "x_groq", "usage")
+            next unless found.is_a?(Hash)
+
+            audio = { "output_tokens_details" => { "audio_tokens" => found["output_tokens"] } }
+            data["type"] == "speech.audio.done" ? found.merge(audio) : found
+          end
+          usage&.deep_symbolize_keys
+        end
+
+        def streamed_response(events)
+          response = { "output" => [] }
+          each_event_data(events) do |data|
+            response["output"].concat(Array(data.dig("response", "output")))
+            response["output"] << data["item"] if data["item"]
+            chunk = data["chunk"] || data
+            next unless chunk["choices"].is_a?(Array)
+
+            response["id"] ||= chunk["id"]
+            response["choices"] ||= chunk["choices"]
+          end
+          response
+        end
+
+        def warn_missing_stream_usage(request_url:, request:)
+          return unless request_url.nil? || request["stream"]
+          return unless request_url ? openai_chat_completions_url?(request_url) : request["messages"]
+          return if request.dig("stream_options", "include_usage")
+
+          Logging.warn(
+            "OpenAI-compatible chat-completions stream finished without a final usage chunk. " \
+            "Set `stream_options: { include_usage: true }` in your request body so the gem can " \
+            "record token counts. This call was stored with usage_source=#{Usage::Source::UNKNOWN}."
+          )
+        end
+
+        def openai_chat_completions_url?(request_url)
+          uri = parsed_uri(request_url)
+          uri && uri.path.to_s.end_with?("/chat/completions")
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/openai/usage_extractor.rb

@@ -12,78 +12,88 @@ module LlmCostTracker
           audio_tokens: "audio_cache_read_input", image_tokens: "image_cache_read_input"
         }.freeze
 
-        def self.token_usage(usage, model: nil)
-          input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
-          output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
-          reasoning = hidden_output_tokens(usage)
-          output_tokens += reasoning if usage[:total_tokens].to_i == input_tokens + output_tokens + reasoning
-          cache_read = cache_read_input_tokens(usage)
-          cache_write = cache_write_input_tokens(usage)
-          uncached_input = [input_tokens - cache_read - cache_write, 0].max
-          image_input = uncached_input_tokens(usage, :image_tokens).clamp(0, uncached_input)
-          audio_input = uncached_input_tokens(usage, :audio_tokens).clamp(0, uncached_input - image_input)
-          audio_output = audio_output_tokens(usage)
-          image_output, regular_output = split_output(
-            output_tokens: output_tokens,
-            image_output_details: image_output_tokens(usage),
-            text_output_details: text_output_tokens(usage),
-            audio_output: audio_output,
-            default_to_image: ModelFamilies.image_output?(model)
-          )
+        class << self
+          def token_usage(usage, model: nil, default_to_image: ModelFamilies.image_output?(model))
+            cache_read = cache_read_input_tokens(usage)
+            cache_write = cache_write_input_tokens(usage)
+            Usage::TokenUsage.build(
+              **input_counts(usage, cached: cache_read + cache_write),
+              **output_counts(usage, default_to_image: default_to_image),
+              total_tokens: usage[:total_tokens],
+              cache_read_input_tokens: cache_read,
+              cache_write_input_tokens: cache_write,
+              hidden_output_tokens: hidden_output_tokens(usage)
+            )
+          end
 
-          Usage::TokenUsage.build(
-            input_tokens: uncached_input - audio_input - image_input,
-            output_tokens: regular_output,
-            total_tokens: usage[:total_tokens],
-            cache_read_input_tokens: cache_read,
-            cache_write_input_tokens: cache_write,
-            audio_input_tokens: audio_input,
-            audio_output_tokens: audio_output,
-            image_input_tokens: image_input,
-            image_output_tokens: image_output,
-            hidden_output_tokens: reasoning
-          )
-        end
+          def cache_read_line_items(usage)
+            CACHED_MODALITY_DIMENSIONS.filter_map do |detail_key, dimension_key|
+              quantity = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, detail_key)
+              Charges::LineItem.build(dimension_key: dimension_key, quantity: quantity) if quantity.positive?
+            end
+          end
 
-        def self.cache_read_line_items(usage)
-          CACHED_MODALITY_DIMENSIONS.filter_map do |detail_key, dimension_key|
-            quantity = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, detail_key)
-            Charges::LineItem.build(dimension_key: dimension_key, quantity: quantity) if quantity.positive?
+          def split_output(output_tokens:,
+                           image_output_details:,
+                           text_output_details:,
+                           audio_output:,
+                           default_to_image: false)
+            if image_output_details.zero? && text_output_details.zero?
+              remainder = [output_tokens - audio_output, 0].max
+              return default_to_image ? [remainder, 0] : [0, remainder]
+            end
+
+            [image_output_details, [output_tokens - image_output_details - audio_output, 0].max]
           end
-        end
 
-        def self.split_output(output_tokens:,
-                              image_output_details:,
-                              text_output_details:,
-                              audio_output:,
-                              default_to_image: false)
-          if image_output_details.zero? && text_output_details.zero?
-            remainder = [output_tokens - audio_output, 0].max
-            return default_to_image ? [remainder, 0] : [0, remainder]
+          def cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
+          def cache_write_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cache_write_tokens)
+          def hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
+          def audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
+          def audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)
+          def image_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :image_tokens)
+          def image_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :image_tokens)
+          def text_output_tokens(usage)      = detail(usage, OUTPUT_DETAIL_KEYS, :text_tokens)
+
+          def uncached_input_tokens(usage, key)
+            detail(usage, INPUT_DETAIL_KEYS, key) - detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, key)
           end
 
-          [image_output_details, [output_tokens - image_output_details - audio_output, 0].max]
-        end
+          def detail(usage, containers, *path)
+            containers.each do |container|
+              value = usage.dig(container, *path)
+              return value.to_i if value
+            end
+            0
+          end
 
-        def self.cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
-        def self.cache_write_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cache_write_tokens)
-        def self.hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
-        def self.audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
-        def self.audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)
-        def self.image_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :image_tokens)
-        def self.image_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :image_tokens)
-        def self.text_output_tokens(usage)      = detail(usage, OUTPUT_DETAIL_KEYS, :text_tokens)
+          private
 
-        def self.uncached_input_tokens(usage, key)
-          detail(usage, INPUT_DETAIL_KEYS, key) - detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, key)
-        end
+          def input_counts(usage, cached:)
+            uncached = [prompt_tokens(usage) - cached, 0].max
+            image = uncached_input_tokens(usage, :image_tokens).clamp(0, uncached)
+            audio = uncached_input_tokens(usage, :audio_tokens).clamp(0, uncached - image)
+            { input_tokens: uncached - audio - image, image_input_tokens: image, audio_input_tokens: audio }
+          end
+
+          def output_counts(usage, default_to_image:)
+            output = (usage[:output_tokens] || usage[:completion_tokens]).to_i
+            reasoning = hidden_output_tokens(usage)
+            output += reasoning if usage[:total_tokens].to_i == prompt_tokens(usage) + output + reasoning
+            audio = audio_output_tokens(usage)
+            image, regular = split_output(
+              output_tokens: output,
+              image_output_details: image_output_tokens(usage),
+              text_output_details: text_output_tokens(usage),
+              audio_output: audio,
+              default_to_image: default_to_image
+            )
+            { output_tokens: regular, image_output_tokens: image, audio_output_tokens: audio }
+          end
 
-        def self.detail(usage, containers, *path)
-          containers.each do |container|
-            value = usage.dig(container, *path)
-            return value.to_i if value
+          def prompt_tokens(usage)
+            (usage[:input_tokens] || usage[:prompt_tokens]).to_i
           end
-          0
         end
       end
     end

data/lib/llm_cost_tracker/providers/openai_compatible/parser.rb

@@ -5,13 +5,24 @@ module LlmCostTracker
     module OpenaiCompatible
       class Parser < LlmCostTracker::Parsers::Base
         include Openai::ResponseParser
-
-        TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
+        include Openai::StreamParser
+
+        TRACKED_PATH_SUFFIXES = %w[
+          /chat/completions /completions /embeddings /responses /images/generations /images/edits /v1/sonar /v1/agent
+          /v1/ocr /audio/transcriptions /audio/translations /audio/speech /moderations
+        ].freeze
+        RETRIEVE_PATH = %r{/(?:responses|agent)/resp_[^/]+\z}
+        STREAM_USAGE_HOSTS = %w[
+          openrouter.ai api.deepseek.com api.groq.com api.x.ai us.api.x.ai
+          api.mistral.ai api.eu.mistral.ai api.us.mistral.ai
+        ].freeze
 
         class << self
           def match?(url)
             uri_matches?(url) do |uri|
-              TRACKED_PATH_SUFFIXES.any? { |suffix| uri.path.to_s.end_with?(suffix) } && !provider_for_uri(uri).nil?
+              path = uri.path.to_s
+              (path.end_with?(*TRACKED_PATH_SUFFIXES) || path.match?(RETRIEVE_PATH)) &&
+                !provider_for_uri(uri).nil?
             end
           end
 
@@ -34,7 +45,7 @@ module LlmCostTracker
         end
 
         def auto_enable_stream_usage?(request_url, request_parsed)
-          super && Configuration::Capture::OPENAI_COMPATIBLE_PROVIDERS.key?(parsed_uri(request_url).host.to_s.downcase)
+          super && STREAM_USAGE_HOSTS.include?(parsed_uri(request_url).host.to_s.downcase)
         end
       end
     end

data/lib/llm_cost_tracker/providers.rb

@@ -14,6 +14,7 @@ module LlmCostTracker
     end
 
     module Gemini
+      autoload :Grounding, "llm_cost_tracker/providers/gemini/grounding"
       autoload :ModelFamilies, "llm_cost_tracker/providers/gemini/model_families"
       autoload :Parser, "llm_cost_tracker/providers/gemini/parser"
       autoload :UsageExtractor, "llm_cost_tracker/providers/gemini/usage_extractor"
@@ -22,8 +23,10 @@ module LlmCostTracker
     module Openai
       autoload :Hosts, "llm_cost_tracker/providers/openai/hosts"
       autoload :ModelFamilies, "llm_cost_tracker/providers/openai/model_families"
+      autoload :OutputItem, "llm_cost_tracker/providers/openai/output_item"
       autoload :Parser, "llm_cost_tracker/providers/openai/parser"
       autoload :ServiceCharges, "llm_cost_tracker/providers/openai/service_charges"
+      autoload :StreamParser, "llm_cost_tracker/providers/openai/stream_parser"
       autoload :UsageExtractor, "llm_cost_tracker/providers/openai/usage_extractor"
       autoload :ResponseParser, "llm_cost_tracker/providers/openai/response_parser"
     end

data/lib/llm_cost_tracker/redaction.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "uri"
+
 module LlmCostTracker
   module Redaction
     REDACTED = "[REDACTED]"
@@ -28,5 +30,16 @@ module LlmCostTracker
            .gsub(PARAM, "\\1=#{REDACTED}")
            .gsub(EMBEDDED_TOKEN, REDACTED)
     end
+
+    def self.url(value)
+      uri = URI.parse(value.to_s)
+      uri.query = nil
+      uri.fragment = nil
+      uri.user = nil
+      uri.password = nil
+      uri.to_s
+    rescue URI::InvalidURIError
+      value.to_s.split("?", 2).first
+    end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -26,46 +26,43 @@ module LlmCostTracker
       TOP_LIMIT = 5
 
       def self.build(days: DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil, breakdown_limit: nil)
-        days = days.to_i
-        days = DEFAULT_DAYS unless days.positive?
-        unless breakdown_limit.nil?
-          breakdown_limit = breakdown_limit.to_i
-          breakdown_limit = nil unless breakdown_limit.positive?
-        end
+        days = positive_integer(days) || DEFAULT_DAYS
+        limit = positive_integer(breakdown_limit)
         from = now - days.days
         scope = LlmCostTracker::Call.where(tracked_at: from..now)
-        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys
-        aggregate = totals(scope)
+        tag_keys = tag_breakdowns || LlmCostTracker.configuration.tags.report_breakdown_keys
 
         new(
           days: days,
           from_time: from,
           to_time: now,
-          total_cost: aggregate.total_cost.to_f,
-          requests_count: aggregate.requests_count.to_i,
-          average_latency_ms: aggregate.average_latency_ms&.to_f,
-          unknown_pricing_count: aggregate.unknown_pricing_count.to_i,
-          cost_by_provider: scope.cost_by_provider(limit: breakdown_limit).to_a,
-          cost_by_model: scope.cost_by_model(limit: breakdown_limit).to_a,
-          cost_by_tags: cost_by_tags(scope, tag_breakdowns, limit: breakdown_limit),
+          **totals(scope),
+          cost_by_provider: scope.cost_by_provider(limit: limit).to_a,
+          cost_by_model: scope.cost_by_model(limit: limit).to_a,
+          cost_by_tags: tag_keys.to_h { |key| [key, scope.cost_by_tag(key, limit: limit).to_a] },
           top_calls: top_calls(scope)
         )
       end
 
-      def self.totals(scope)
-        scope
-          .select(
-            "COALESCE(SUM(#{LlmCostTracker::Call.qualified(:total_cost)}), 0) AS total_cost, " \
-            "COUNT(*) AS requests_count, " \
-            "AVG(latency_ms) AS average_latency_ms, " \
-            "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \
-            "THEN 1 ELSE 0 END), 0) AS unknown_pricing_count"
-          )
-          .take
+      def self.positive_integer(value)
+        integer = value.to_i
+        integer if integer.positive?
       end
 
-      def self.cost_by_tags(scope, keys, limit:)
-        keys.to_h { |key| [key, scope.cost_by_tag(key, limit: limit).to_a] }
+      def self.totals(scope)
+        row = scope.select(
+          "COALESCE(SUM(#{LlmCostTracker::Call.qualified(:total_cost)}), 0) AS total_cost, " \
+          "COUNT(*) AS requests_count, " \
+          "AVG(latency_ms) AS average_latency_ms, " \
+          "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \
+          "THEN 1 ELSE 0 END), 0) AS unknown_pricing_count"
+        ).take
+        {
+          total_cost: row.total_cost.to_f,
+          requests_count: row.requests_count.to_i,
+          average_latency_ms: row.average_latency_ms&.to_f,
+          unknown_pricing_count: row.unknown_pricing_count.to_i
+        }
       end
 
       def self.top_calls(scope)
@@ -76,7 +73,7 @@ module LlmCostTracker
           .to_a
       end
 
-      private_class_method :cost_by_tags, :top_calls, :totals
+      private_class_method :positive_integer, :totals, :top_calls
     end
   end
 end

data/lib/llm_cost_tracker/tags/context.rb

@@ -9,26 +9,41 @@ module LlmCostTracker
 
       class << self
         def with(tags)
-          stack = ActiveSupport::IsolatedExecutionState[KEY] || []
-          ActiveSupport::IsolatedExecutionState[KEY] = stack + [Sanitizer.call((tags || {}).to_h)]
+          stack = Fiber[KEY] || []
+          scope = [Thread.current, Sanitizer.call((tags || {}).to_h)]
+          shared = scope.dup
+          Fiber[KEY] = stack + [scope]
+          ActiveSupport::IsolatedExecutionState[KEY] = shared_scopes + [shared]
           yield
         ensure
-          ActiveSupport::IsolatedExecutionState[KEY] = stack
+          scope&.clear
+          Fiber[KEY] = stack
+          ActiveSupport::IsolatedExecutionState[KEY] = shared_scopes.reject { |entry| entry.equal?(shared) } if shared
         end
 
         def tags
           config = LlmCostTracker.configuration
-          base = config.tags.static_sanitized_default ||
-                 Sanitizer.call(call_default_tags(config.tags.default).to_h)
-          base.merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
+          base = config.tags.static_sanitized_default || Sanitizer.call(call_default_tags(config.tags.default))
+          base.merge(scoped)
+        end
+
+        def scoped
+          current = Thread.current
+          shared = shared_scopes.reject { |owner, _| owner.equal?(current) }
+          own = Array(Fiber[KEY]).select { |owner, _| owner.equal?(current) }
+          (shared + own).each_with_object({}) { |(_, tags), merged| merged.merge!(tags) }
         end
 
         def call_default_tags(proc_or_lambda)
-          proc_or_lambda.call
+          (proc_or_lambda.call || {}).to_h
         rescue StandardError => e
           Logging.warn("LlmCostTracker tags.default proc raised: #{e.class}: #{e.message}; using empty default tags")
           {}
         end
+
+        private
+
+        def shared_scopes = Array(ActiveSupport::IsolatedExecutionState[KEY])
       end
     end
   end

data/lib/llm_cost_tracker/tracker.rb

@@ -16,33 +16,17 @@ module LlmCostTracker
       def record(event:, latency_ms: nil, metadata: {}, context_tags: nil, enforce_budget: false)
         return unless LlmCostTracker.configuration.enabled
 
-        calculation = Pricing::Calculation.for(
-          provider: event.provider,
-          model: event.model,
-          tokens: event.token_usage,
-          line_items: event.line_items,
-          pricing_mode: event.pricing_mode,
-          usage_source: event.usage_source
-        )
-
+        tracked_at = Time.now.utc
+        calculation = price(event, at: tracked_at)
         tags = build_tags(context_tags: context_tags, metadata: metadata)
-
-        event = build_event(event: event, calculation: calculation, tags: tags, latency_ms: latency_ms)
-
-        if Ingestion.async?
-          Ingestion::Inbox.save(event)
-          Ingestion::Worker.ensure_started
-        else
-          Ledger::Store.insert(event)
-        end
-
+        event = build_event(event:, calculation:, tags:, latency_ms:, tracked_at:)
+        persist(event)
         yield if block_given?
         notify_subscribers(event)
-        behavior_override = :raise if enforce_budget
         begin
           signal_unpriced(event, calculation)
         ensure
-          Budget.check!(event, behavior_override: behavior_override)
+          Budget.check!(event, behavior_override: enforce_budget ? :raise : nil)
         end
 
         event
@@ -56,15 +40,37 @@ module LlmCostTracker
 
       private
 
+      def price(event, at:)
+        Pricing::Calculation.for(
+          provider: event.provider,
+          model: event.model,
+          tokens: event.token_usage,
+          line_items: event.line_items,
+          pricing_mode: event.pricing_mode,
+          usage_source: event.usage_source,
+          at: at
+        )
+      end
+
+      def persist(event)
+        return Ledger::Store.insert(event) unless Ingestion.async?
+
+        Ingestion::Inbox.save(event)
+        Ingestion::Worker.ensure_started
+      end
+
       def signal_unpriced(event, calculation)
         iterations, lines = calculation.priced_line_items.partition { |line| line.kind == "model_iteration" }
         models = iterations.select(&:unpriced?).map { |line| line.details[:model] }
-        if calculation.token_cost.nil? && event.token_usage.total_tokens.positive? && lines.none?(&:priced?)
-          models.unshift(event.model)
-        end
+        models.unshift(event.model) if unpriced_tokens?(event, calculation, lines)
         models.each { |model| Pricing::Unknown.process(model, pricing_mode: calculation.mode) }
       end
 
+      def unpriced_tokens?(event, calculation, lines)
+        calculation.token_cost.nil? && event.token_usage.total_tokens.positive? && lines.none?(&:priced?) &&
+          !calculation.unsplit_total?
+      end
+
       def notify_subscribers(event)
         return unless ActiveSupport::Notifications.notifier.listening?(EVENT_NAME)
 
@@ -73,14 +79,14 @@ module LlmCostTracker
         Logging.warn("Subscriber raised on #{EVENT_NAME}: #{e.class}: #{e.message}")
       end
 
-      def build_event(event:, calculation:, tags:, latency_ms:)
+      def build_event(event:, calculation:, tags:, latency_ms:, tracked_at:)
         event.with(
           event_id: event.event_id || SecureRandom.uuid,
           pricing_mode: calculation.mode,
           cost: calculation.cost,
           tags: tags,
           latency_ms: finite_latency_ms(latency_ms),
-          tracked_at: Time.now.utc,
+          tracked_at: tracked_at,
           cost_status: calculation.cost_status,
           pricing_snapshot: calculation.snapshot,
           line_items: calculation.priced_line_items

data/lib/llm_cost_tracker/usage/dimensions.yml

@@ -85,6 +85,14 @@
   unit: token
   parent: input
 
+- key: video_output
+  kind: video_token
+  direction: output
+  modality: video
+  cache_state: none
+  unit: token
+  parent: output
+
 - key: web_search_request
   kind: web_search_request
   direction: neither
@@ -188,6 +196,22 @@
   unit: minute
   rate_basis: per_minute
 
+- key: ocr_page
+  kind: ocr_page
+  direction: input
+  modality: image
+  cache_state: none
+  unit: page
+  rate_basis: per_1k_pages
+
+- key: rerank_search_unit
+  kind: rerank_search_unit
+  direction: input
+  modality: text
+  cache_state: none
+  unit: request
+  rate_basis: per_1k_requests
+
 - key: billed_request
   kind: billed_request
   direction: neither

data/lib/llm_cost_tracker/usage/token_usage.rb

@@ -16,10 +16,9 @@ module LlmCostTracker
         priced = Catalog.token_priced.to_h do |dimension|
           [dimension.token_key, non_negative_int(values[dimension.token_key])]
         end
-        subtotal = priced.values.sum
-        declared_total = values[:total_tokens]
-        total = declared_total ? [non_negative_int(declared_total), subtotal].max : subtotal
-        new(**priced, total_tokens: total, hidden_output_tokens: non_negative_int(values[:hidden_output_tokens]))
+        new(**priced,
+            total_tokens: total(values[:total_tokens], priced.values.sum),
+            hidden_output_tokens: non_negative_int(values[:hidden_output_tokens]))
       end
 
       def self.build_from_tokens(tokens)
@@ -40,6 +39,11 @@ module LlmCostTracker
       def self.non_negative_int(value)
         [value.to_i, 0].max
       end
+
+      def self.total(declared, counted)
+        declared ? [non_negative_int(declared), counted].max : counted
+      end
+      private_class_method :total
     end
   end
 end

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.14.2"
+  VERSION = "0.15.0"
 end