llm_cost_tracker 0.14.0 → 0.14.2

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

@@ -27,39 +27,19 @@ module LlmCostTracker
           line_items_from_output(output_items, request: request, model: model)
         end
 
-        CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD = "choices.message.annotations.url_citation"
-        CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD = "request.model"
-
         def chat_completions_web_search_items(response, model: nil)
-          return [] unless response["choices"]
-
-          provider_field = chat_completions_search_provider_field(response["choices"], model)
-          return [] unless provider_field
+          return [] unless response["choices"] && chat_completions_search_model?(model)
 
           [{ "type" => "web_search_call", "id" => response["id"], "action" => { "type" => "search" },
-             "provider_field" => provider_field }]
-        end
-
-        def chat_completions_search_provider_field(choices, model)
-          return CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD if chat_completions_used_web_search?(choices)
-          return CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD if chat_completions_search_model?(model)
-
-          nil
-        end
-
-        def chat_completions_used_web_search?(choices)
-          Array(choices).any? do |choice|
-            Array(choice.dig("message", "annotations")).any? do |annotation|
-              annotation.is_a?(Hash) && annotation["type"].to_s == "url_citation"
-            end
-          end
+             "provider_field" => "request.model" }]
         end
 
         def billable?(item)
           return false unless item.is_a?(Hash)
 
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return false unless dimension
+          return item["status"] == "completed" if dimension == "image_generation_call"
           return true unless dimension == "web_search_request"
 
           action_type = item.dig("action", "type")
@@ -69,11 +49,11 @@ module LlmCostTracker
         def store_output_item(output_items, item)
           return unless item.is_a?(Hash)
 
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return unless dimension
 
-          key = if dimension == "container_session" && item["container_id"]
-                  "#{dimension}:#{item['container_id']}"
+          key = if dimension == "container_session" && container_id(item)
+                  "#{dimension}:#{container_id(item)}"
                 else
                   item["id"] || "#{item['type']}:#{output_items.length}"
                 end
@@ -87,7 +67,7 @@ module LlmCostTracker
           return nil unless dimension_key
 
           provider_item_id = if dimension_key == "container_session"
-                               item["container_id"] || item["id"]
+                               container_id(item) || item["id"]
                              else
                                item["id"]
                              end
@@ -103,13 +83,28 @@ module LlmCostTracker
         end
 
         def dimension_key_for(item, request:, model:)
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return dimension unless dimension == "web_search_request"
           return dimension unless web_search_preview_used?(request) || chat_completions_search_model?(model)
 
           reasoning_model?(model) ? "web_search_preview_request_reasoning" : "web_search_preview_request_non_reasoning"
         end
 
+        def item_dimension(item)
+          return "container_session" if item["type"] == "shell_call" && shell_container_id(item)
+
+          output_dimension(item["type"])
+        end
+
+        def container_id(item)
+          item["container_id"] || shell_container_id(item)
+        end
+
+        def shell_container_id(item)
+          environment = item["environment"]
+          environment["container_id"] if environment.is_a?(Hash) && environment["type"] == "container_reference"
+        end
+
         def output_dimension(type)
           key = RESPONSE_OUTPUT_RENAMES[type] || type
           dimension = Usage::Catalog[key]
@@ -144,19 +139,10 @@ module LlmCostTracker
           {
             status: item["status"],
             action_type: item.dig("action", "type"),
-            container_id: item["container_id"]
+            container_id: container_id(item)
           }.compact
         end
 
-        def openai_stream_service_line_items(events, request: nil, model: nil)
-          output_items = []
-          each_event_data(events) do |data|
-            output_items.concat(Array(data.dig("response", "output")))
-            output_items << data["item"] if data["item"]
-          end
-          line_items_from_output(output_items, request: request, model: model)
-        end
-
         def transcription_line_items(usage)
           return [] unless usage
 
@@ -168,13 +154,44 @@ module LlmCostTracker
 
           [Charges::LineItem.build(
             dimension_key: "transcription_minute",
-            quantity: (seconds / 60.0).ceil,
+            quantity: BigDecimal(seconds.to_s) / 60,
             cost_status: Charges::CostStatus::UNKNOWN,
             pricing_basis: "provider_usage",
             provider_field: "usage.seconds",
             details: { seconds: seconds }
           )]
         end
+
+        def speech_line_items(request)
+          input = request["input"]
+          return [] unless input.is_a?(String) && ModelFamilies.character_billed_tts?(request["model"])
+
+          [Charges::LineItem.build(
+            dimension_key: "text_to_speech_character",
+            quantity: input.length,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: "request.input"
+          )]
+        end
+
+        # OpenRouter bills BYOK inference to the user's own provider key and puts only its fee in usage.cost.
+        def billed_line_items(usage)
+          amounts = [usage[:cost]]
+          amounts << usage.dig(:cost_details, :upstream_inference_cost) if usage[:is_byok]
+          return [] unless amounts.all?(Numeric)
+
+          amount = amounts.sum { |value| BigDecimal(value.to_s) }
+          [Charges::LineItem.build(
+            dimension_key: "billed_request",
+            quantity: 1,
+            rate_amount: amount,
+            cost: amount,
+            pricing_basis: "provider_usage",
+            price_source: "provider_response",
+            provider_field: "usage.cost"
+          )]
+        end
       end
     end
   end

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

@@ -8,14 +8,21 @@ module LlmCostTracker
       module UsageExtractor
         INPUT_DETAIL_KEYS = %i[input_tokens_details input_token_details prompt_tokens_details].freeze
         OUTPUT_DETAIL_KEYS = %i[output_tokens_details output_token_details completion_tokens_details].freeze
+        CACHED_MODALITY_DIMENSIONS = {
+          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)
-          audio_input = audio_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_input = image_input_tokens(usage)
           image_output, regular_output = split_output(
             output_tokens: output_tokens,
             image_output_details: image_output_tokens(usage),
@@ -25,7 +32,7 @@ module LlmCostTracker
           )
 
           Usage::TokenUsage.build(
-            input_tokens: [input_tokens - cache_read - cache_write - audio_input - image_input, 0].max,
+            input_tokens: uncached_input - audio_input - image_input,
             output_tokens: regular_output,
             total_tokens: usage[:total_tokens],
             cache_read_input_tokens: cache_read,
@@ -34,10 +41,17 @@ module LlmCostTracker
             audio_output_tokens: audio_output,
             image_input_tokens: image_input,
             image_output_tokens: image_output,
-            hidden_output_tokens: hidden_output_tokens(usage)
+            hidden_output_tokens: reasoning
           )
         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?
+          end
+        end
+
         def self.split_output(output_tokens:,
                               image_output_details:,
                               text_output_details:,
@@ -60,9 +74,13 @@ module LlmCostTracker
         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)
 
-        def self.detail(usage, containers, key)
+        def self.uncached_input_tokens(usage, key)
+          detail(usage, INPUT_DETAIL_KEYS, key) - detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, key)
+        end
+
+        def self.detail(usage, containers, *path)
           containers.each do |container|
-            value = usage.dig(container, key)
+            value = usage.dig(container, *path)
             return value.to_i if value
           end
           0

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

@@ -10,7 +10,9 @@ module LlmCostTracker
 
         class << self
           def match?(url)
-            match_uri?(url, path_suffixes: TRACKED_PATH_SUFFIXES) { |uri| provider_for_uri(uri) }
+            uri_matches?(url) do |uri|
+              TRACKED_PATH_SUFFIXES.any? { |suffix| uri.path.to_s.end_with?(suffix) } && !provider_for_uri(uri).nil?
+            end
           end
 
           def provider_names
@@ -30,6 +32,10 @@ module LlmCostTracker
         def provider_for(request_url)
           self.class.provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
         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)
+        end
       end
     end
   end

data/lib/llm_cost_tracker/redaction.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Redaction
+    REDACTED = "[REDACTED]"
+
+    TOKEN = Regexp.union(
+      /sk-(?:ant-|admin-|proj-|svcacct-|live-|test-)?[A-Za-z0-9_-]{16,}/,
+      /AKIA[0-9A-Z]{16}/,
+      /gh[opsur]_[A-Za-z0-9]{16,}/,
+      /github_pat_[A-Za-z0-9_]{20,}/,
+      /eyj[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/i,
+      /bearer\s+[A-Za-z0-9_.-]{20,}/i,
+      /xox[abprs]-[A-Za-z0-9-]{10,}/,
+      /(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{20,}/,
+      /AIza[0-9A-Za-z_-]{35}/
+    )
+    EMBEDDED_TOKEN = /(?<![A-Za-z0-9_-])(?:#{TOKEN})(?![A-Za-z0-9_-])/
+    PARAM = /(?<![A-Za-z0-9])((?:api)?key|token|secret|password|sig(?:nature)?)=[^&\s"']+/i
+    HEADER = /((?:authorization|api-key)["']?\s*(?:=>|:)\s*["']?)(?:[A-Za-z]+\s+)?[^\s"',;]+/i
+    USERINFO = %r{://[^/\s@?#]+@}
+    private_constant :TOKEN, :EMBEDDED_TOKEN, :PARAM, :HEADER, :USERINFO
+
+    def self.text(value)
+      value.to_s.scrub
+           .gsub(USERINFO, "://#{REDACTED}@")
+           .gsub(HEADER, "\\1#{REDACTED}")
+           .gsub(PARAM, "\\1=#{REDACTED}")
+           .gsub(EMBEDDED_TOKEN, REDACTED)
+    end
+  end
+end

data/lib/llm_cost_tracker/report/data.rb

@@ -34,7 +34,7 @@ module LlmCostTracker
         end
         from = now - days.days
         scope = LlmCostTracker::Call.where(tracked_at: from..now)
-        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys || []
+        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys
         aggregate = totals(scope)
 
         new(

data/lib/llm_cost_tracker/retention.rb

@@ -3,8 +3,6 @@
 module LlmCostTracker
   module Retention
     DEFAULT_BATCH_SIZE = 5_000
-    ROLLUP_COLUMNS = %i[tracked_at total_cost pricing_snapshot provider].freeze
-    private_constant :ROLLUP_COLUMNS
 
     class << self
       def prune(older_than:, batch_size: DEFAULT_BATCH_SIZE, now: Time.now.utc)
@@ -84,7 +82,7 @@ module LlmCostTracker
       def prunable_rows(cutoff, batch_size)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
         columns = [:id]
-        columns += ROLLUP_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
+        columns += LlmCostTracker::Ledger::Rollups::SOURCE_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
         relation.select(*columns).to_a
       end
     end

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -2,23 +2,13 @@
 
 require "active_support/core_ext/string/inflections"
 
+require_relative "../ledger/storable"
+require_relative "../redaction"
+
 module LlmCostTracker
   module Tags
     module Sanitizer
-      REDACTED_VALUE = "[REDACTED]"
-
-      SECRET_VALUE_PATTERNS = [
-        /\Ask-(?:ant-|admin-|proj-|svcacct-|live-|test-)?[A-Za-z0-9_-]{16,}\z/,
-        /\AAKIA[0-9A-Z]{16}\z/,
-        /\Agh[opsur]_[A-Za-z0-9]{16,}\z/,
-        /\Agithub_pat_[A-Za-z0-9_]{20,}\z/,
-        /\Aeyj[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\z/i,
-        /\Abearer\s+[A-Za-z0-9_.-]{20,}\z/i,
-        /\Axox[abprs]-[A-Za-z0-9-]{10,}\z/,
-        /\A(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{20,}\z/,
-        /\AAIza[0-9A-Za-z_-]{35}\z/
-      ].freeze
-      private_constant :SECRET_VALUE_PATTERNS
+      REDACTED_VALUE = Redaction::REDACTED
 
       class << self
         def call(tags, config: LlmCostTracker.configuration)
@@ -58,15 +48,9 @@ module LlmCostTracker
         def sanitized_value(key, value, redacted, limit)
           return REDACTED_VALUE if redacted_key?(key, redacted)
 
-          scrubbed = scrub_secrets(value)
-          return REDACTED_VALUE if scrubbed.equal?(REDACTED_SENTINEL)
-
-          scalar_truncate(scrubbed, limit)
+          scalar_truncate(scrub_secrets(Ledger::Storable.clean(value)), limit)
         end
 
-        REDACTED_SENTINEL = Object.new.freeze
-        private_constant :REDACTED_SENTINEL
-
         def scalar_truncate(value, limit)
           case value
           when Hash
@@ -86,26 +70,16 @@ module LlmCostTracker
         def scrub_secrets(value)
           case value
           when Hash
-            value.each_with_object({}) do |(key, nested), out|
-              scrubbed = scrub_secrets(nested)
-              out[key] = scrubbed.equal?(REDACTED_SENTINEL) ? REDACTED_VALUE : scrubbed
-            end
+            value.transform_values { |nested| scrub_secrets(nested) }
           when Array
-            value.map do |nested|
-              scrubbed = scrub_secrets(nested)
-              scrubbed.equal?(REDACTED_SENTINEL) ? REDACTED_VALUE : scrubbed
-            end
+            value.map { |nested| scrub_secrets(nested) }
           else
-            secret_shaped?(value.to_s) ? REDACTED_SENTINEL : value
+            string = value.to_s
+            scrubbed = Redaction.text(string)
+            scrubbed == string ? value : scrubbed
           end
         end
 
-        def secret_shaped?(string)
-          return false if string.bytesize < 16
-
-          SECRET_VALUE_PATTERNS.any? { |pattern| pattern.match?(string) }
-        end
-
         def redacted_key?(key, redacted)
           return false if redacted.empty?
 

data/lib/llm_cost_tracker/tracker.rb

@@ -27,11 +27,6 @@ module LlmCostTracker
 
         tags = build_tags(context_tags: context_tags, metadata: metadata)
 
-        if calculation.token_cost.nil? && event.token_usage.total_tokens.positive? &&
-           calculation.priced_line_items.none?(&:priced?)
-          Pricing::Unknown.process(event.model, pricing_mode: calculation.mode)
-        end
-
         event = build_event(event: event, calculation: calculation, tags: tags, latency_ms: latency_ms)
 
         if Ingestion.async?
@@ -44,20 +39,32 @@ module LlmCostTracker
         yield if block_given?
         notify_subscribers(event)
         behavior_override = :raise if enforce_budget
-        Budget.check!(event, behavior_override: behavior_override)
-        Budget.check_persisted!([event], behavior_override: behavior_override) unless Ingestion.async?
+        begin
+          signal_unpriced(event, calculation)
+        ensure
+          Budget.check!(event, behavior_override: behavior_override)
+        end
 
         event
       end
 
       def build_tags(context_tags:, metadata:)
         resolved = (context_tags || LlmCostTracker::Tags::Context.tags).to_h
-        sanitized_metadata = LlmCostTracker::Tags::Sanitizer.call(metadata.to_h)
-        LlmCostTracker::Tags::Sanitizer.cap(resolved.merge(sanitized_metadata)).freeze
+        merged = resolved.merge(LlmCostTracker::Tags::Sanitizer.call(metadata.to_h))
+        LlmCostTracker::Tags::Sanitizer.cap(merged.to_a.reverse.uniq { |key, _| key.to_s }.reverse.to_h).freeze
       end
 
       private
 
+      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.each { |model| Pricing::Unknown.process(model, pricing_mode: calculation.mode) }
+      end
+
       def notify_subscribers(event)
         return unless ActiveSupport::Notifications.notifier.listening?(EVENT_NAME)
 
@@ -68,7 +75,7 @@ module LlmCostTracker
 
       def build_event(event:, calculation:, tags:, latency_ms:)
         event.with(
-          event_id: SecureRandom.uuid,
+          event_id: event.event_id || SecureRandom.uuid,
           pricing_mode: calculation.mode,
           cost: calculation.cost,
           tags: tags,

data/lib/llm_cost_tracker/usage/catalog.rb

@@ -27,7 +27,7 @@ module LlmCostTracker
         end
 
         def token_priced
-          @token_priced ||= all.select(&:token_key).freeze
+          @token_priced ||= all.select { |dimension| dimension.token_key && dimension.parent.nil? }.freeze
         end
 
         def find_by(kind:, direction:, modality:, cache_state:, unit:)
@@ -35,8 +35,17 @@ module LlmCostTracker
         end
 
         def token_priced_for(kind:, direction:, cache_state:)
-          token_priced.find do |dimension|
-            dimension.kind == kind && dimension.direction == direction && dimension.cache_state == cache_state
+          dimension = all.find do |candidate|
+            candidate.token? && candidate.kind == kind && candidate.direction == direction &&
+              candidate.cache_state == cache_state
+          end
+          dimension&.parent ? fetch(dimension.parent) : dimension
+        end
+
+        def costs_by_component(rows)
+          rows.each_with_object({}) do |(kind, direction, cache_state, cost), totals|
+            component = token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
+            totals[component.key] = totals.fetch(component.key, 0) + cost if component && cost
           end
         end
 
@@ -60,7 +69,7 @@ module LlmCostTracker
 
         def build(attributes)
           rate_basis = attributes[:rate_basis] || DEFAULT_RATE_BASIS_BY_UNIT.fetch(attributes.fetch(:unit))
-          Dimension.new(**attributes, rate_basis: rate_basis)
+          Dimension.new(parent: nil, **attributes, rate_basis: rate_basis)
         end
       end
     end

data/lib/llm_cost_tracker/usage/dimension.rb

@@ -3,7 +3,7 @@
 module LlmCostTracker
   module Usage
     Dimension = Data.define(
-      :key, :kind, :direction, :modality, :cache_state, :unit, :rate_basis
+      :key, :kind, :direction, :modality, :cache_state, :unit, :rate_basis, :parent
     ) do
       def token?
         unit == "token"

data/lib/llm_cost_tracker/usage/dimensions.yml

@@ -61,6 +61,30 @@
   cache_state: none
   unit: token
 
+- key: audio_cache_read_input
+  kind: audio_token
+  direction: input
+  modality: audio
+  cache_state: read
+  unit: token
+  parent: cache_read_input
+
+- key: image_cache_read_input
+  kind: image_token
+  direction: input
+  modality: image
+  cache_state: read
+  unit: token
+  parent: cache_read_input
+
+- key: video_input
+  kind: video_token
+  direction: input
+  modality: video
+  cache_state: none
+  unit: token
+  parent: input
+
 - key: web_search_request
   kind: web_search_request
   direction: neither
@@ -101,6 +125,13 @@
   unit: request
   rate_basis: per_1k_requests
 
+- key: image_generation_call
+  kind: image_generation_call
+  direction: output
+  modality: image
+  cache_state: none
+  unit: request
+
 - key: container_session
   kind: container_session
   direction: neither
@@ -125,6 +156,22 @@
   unit: request
   rate_basis: per_1k_requests
 
+- key: maps_grounding_request
+  kind: maps_grounding_request
+  direction: neither
+  modality: text
+  cache_state: none
+  unit: request
+  rate_basis: per_1k_requests
+
+- key: cache_storage_token_hour
+  kind: cache_storage_token_hour
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: token_hour
+  rate_basis: per_million_token_hours
+
 - key: text_to_speech_character
   kind: text_to_speech_character
   direction: output
@@ -140,3 +187,17 @@
   cache_state: none
   unit: minute
   rate_basis: per_minute
+
+- key: billed_request
+  kind: billed_request
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: request
+
+- key: model_iteration
+  kind: model_iteration
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: request

data/lib/llm_cost_tracker/version.rb

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

data/lib/llm_cost_tracker.rb

@@ -57,6 +57,7 @@ module LlmCostTracker
       yield(config)
       config.finalize!
       Pricing::Registry.reset!
+      Pricing::Registry.validate_file!(config.pricing.file)
       Integrations.install!
       config
     end
@@ -128,10 +129,11 @@ module LlmCostTracker
         metadata: tags
       )
       yield collector
-      collector.finish!
-    rescue StandardError
+    rescue Exception # rubocop:disable Lint/RescueException -- record the spend and keep the caller's exception
       collector&.finish!(errored: true)
       raise
+    else
+      collector.finish!
     end
   end
 end