llm_cost_tracker 0.13.0 → 0.14.1

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -4,6 +4,7 @@ require_relative "../pricing"
 require_relative "../charges/line_item"
 require_relative "../ledger/rollups"
 require_relative "../usage/token_usage"
+require_relative "../budget/per_tag"
 
 module LlmCostTracker
   module Pricing
@@ -30,7 +31,7 @@ module LlmCostTracker
                 rollup_events << rollup_event_for(call, calculation)
                 recomputed += 1
               end
-              Ledger::Rollups.increment!(rollup_events) if rollup_events.any?
+              Ledger::Rollups.increment!(rollup_events)
             end
           end
 
@@ -61,6 +62,7 @@ module LlmCostTracker
             pricing_snapshot: calculation.snapshot,
             cost_status: calculation.cost_status
           )
+          resync_tag_costs(call, calculation.cost.total)
           token_priced = calculation.priced_line_items.select(&:token?).index_by { |item| dimension_key(item) }
           service_priced = calculation.priced_line_items.reject(&:token?)
           token_records, service_records = call.line_items.partition { |record| record.unit == "token" }
@@ -69,6 +71,14 @@ module LlmCostTracker
           service_records.sort_by(&:position).zip(service_priced).each { |record, priced| apply_rate(record, priced) }
         end
 
+        def resync_tag_costs(call, total_cost)
+          return unless LlmCostTracker::Budget::PerTag.columns?
+
+          LlmCostTracker::CallTag
+            .where(llm_cost_tracker_call_id: call.id)
+            .update_all(total_cost: total_cost)
+        end
+
         def apply_rate(record, priced)
           return unless priced
 

data/lib/llm_cost_tracker/pricing/calculation.rb

@@ -187,16 +187,16 @@ module LlmCostTracker
         price = effective[dimension.key]
         return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) if price.nil?
 
-        line_item.with_rate(token_rate(dimension, price))
+        line_item.with_rate(token_rate(price))
       end
 
-      def token_rate(dimension, price)
+      def token_rate(price)
         Pricing::Rate.new(
-          amount: price.to_d,
+          amount: price.amount.to_d,
           quantity: RATE_DENOMINATOR_TOKENS.to_d,
           currency: match.source.currency,
           source: match.source.name,
-          source_key: dimension.key,
+          source_key: price.key,
           source_version: match.source.version
         )
       end

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -8,38 +8,49 @@ require_relative "price_key"
 module LlmCostTracker
   module Pricing
     module EffectivePrices
+      Resolved = Data.define(:amount, :key)
+
       class << self
         def call(usage:, quantities:, prices:, pricing_mode:)
           context_tier = context_tier?(usage: usage, prices: prices)
           orderings = pricing_mode && Mode.permutations_for(pricing_mode)
 
           quantities.to_h do |price_key, tokens|
-            price = if tokens.positive?
-                      price_for(
-                        prices: prices,
-                        key: price_key,
-                        orderings: orderings,
-                        context_tier: context_tier
-                      )
-                    else
-                      BigDecimal("0")
-                    end
-            [price_key, price]
+            resolved = if tokens.positive?
+                         price_for(
+                           prices: prices,
+                           key: price_key,
+                           orderings: orderings,
+                           context_tier: context_tier
+                         )
+                       else
+                         Resolved.new(amount: BigDecimal("0"), key: price_key)
+                       end
+            [price_key, resolved]
           end
         end
 
         private
 
         def price_for(prices:, key:, orderings:, context_tier:)
-          return prices[PriceKey.build(key, above_context: context_tier)] unless orderings
+          unless orderings
+            standard = PriceKey.build(key, above_context: context_tier)
+            return resolve(prices[standard], standard)
+          end
 
           orderings.each do |mode|
-            direct = prices[PriceKey.build(key, mode: mode, above_context: context_tier)]
-            return direct if direct
+            table_key = PriceKey.build(key, mode: mode, above_context: context_tier)
+            direct = prices[table_key]
+            return resolve(direct, table_key) if direct
           end
           return nil if %w[input output].include?(key)
 
-          derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          derived = derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          resolve(derived, nil)
+        end
+
+        def resolve(amount, key)
+          amount && Resolved.new(amount: amount, key: key)
         end
 
         def derived_mode_price(prices:, key:, modes:, context_tier:)

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -27,6 +27,13 @@ module LlmCostTracker
           @cache[key] = lookup_match(sources, provider_name, model_name)
         end
 
+        def modifier_priced?(provider:, model:, modifier:)
+          prices = lookup(provider: provider, model: model)&.prices
+          return false unless prices
+
+          prices.any? { |key, _| key.to_s.include?(modifier) }
+        end
+
         private
 
         def reset_cache(sources)

data/lib/llm_cost_tracker/pricing/rate.rb

@@ -9,8 +9,7 @@ module LlmCostTracker
       "per_1k_requests" => 1_000,
       "per_session" => 1,
       "per_hour" => 1,
-      "per_minute" => 1,
-      "per_image" => 1
+      "per_minute" => 1
     }.freeze
 
     Rate = Data.define(:amount, :quantity, :currency, :source, :source_key, :source_version)

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -33,6 +33,12 @@ module LlmCostTracker
           @prices_file_mtime_iso = nil
         end
 
+        def validate_file!(path)
+          file_prices(path)
+          file_rates(path)
+          file_metadata(path)
+        end
+
         def builtin_prices
           @builtin_prices ||= normalize_price_entries(
             raw_registry.fetch("models", {}), context: "bundled prices"
@@ -101,7 +107,7 @@ module LlmCostTracker
         end
 
         def prices_file_mtime_iso
-          path = LlmCostTracker.configuration.prices_file
+          path = LlmCostTracker.configuration.pricing.file
           return nil unless path && File.exist?(path)
 
           @prices_file_mtime_iso ||= File.mtime(path).utc.iso8601
@@ -113,16 +119,16 @@ module LlmCostTracker
             [
               Source.new(
                 name: "pricing_overrides",
-                prices: config.pricing_overrides,
+                prices: config.pricing.overrides,
                 rates: {},
                 currency: upcased_currency(nil),
                 version: "configuration"
               ),
               Source.new(
                 name: "prices_file",
-                prices: file_prices(config.prices_file),
-                rates: file_rates(config.prices_file),
-                currency: upcased_currency(file_metadata(config.prices_file)["currency"]),
+                prices: file_prices(config.pricing.file),
+                rates: file_rates(config.pricing.file),
+                currency: upcased_currency(file_metadata(config.pricing.file)["currency"]),
                 version: prices_file_mtime_iso
               ),
               Source.new(
@@ -157,10 +163,15 @@ module LlmCostTracker
         def loading(path)
           yield
         rescue Errno::ENOENT, Psych::Exception, ArgumentError, TypeError => e
-          raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+          raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}; fix or delete it"
         end
 
         def load_raw_file_registry(path)
+          unless File.exist?(path)
+            Logging.warn("pricing.file #{path} does not exist; using bundled prices until prices:refresh creates it")
+            return {}.freeze
+          end
+
           loading(path) { (YAML.safe_load_file(path, aliases: false) || {}).freeze }
         end
 

data/lib/llm_cost_tracker/pricing/sync/change_printer.rb

@@ -4,7 +4,12 @@ module LlmCostTracker
   module Pricing
     module Sync
       module ChangePrinter
-        def self.call(changes, output: $stdout)
+        def self.call(changes, suspicious: [], output: $stdout)
+          if suspicious.any?
+            output.puts "  suspicious changes (refresh writes them only with FORCE=1): #{suspicious.size}"
+            suspicious.each { |finding| output.puts "    - #{finding}" }
+          end
+
           service_changes = changes["service_charges"]
           model_changes = changes.except("service_charges")
 

data/lib/llm_cost_tracker/pricing/sync/snapshot_guard.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../currency"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      module SnapshotGuard
+        class << self
+          def call(current:, remote:, changes:)
+            findings = changes.except("service_charges").flat_map do |model, fields|
+              next [] unless remote["models"].key?(model)
+
+              fields.map { |field, values| finding("#{model} #{field}", field, values) }
+            end
+            changes.fetch("service_charges", {}).each do |provider, components|
+              components.each { |component, values| findings << finding("#{provider}.#{component}", component, values) }
+            end
+            (findings << currency_finding(current, remote)).compact
+          end
+
+          private
+
+          def finding(label, field, values)
+            from, to = values.values_at("from", "to").map { |value| value&.to_f }
+            "#{label}: #{from.inspect} -> #{to.inspect}" if suspicious?(field, from, to)
+          end
+
+          def suspicious?(field, from, to)
+            return %w[input output].include?(field) && from.positive? if to.nil?
+            return false if from.nil?
+            return true if from.zero? || to.zero?
+
+            [to / from, from / to].max >= 100
+          end
+
+          def currency_finding(current, remote)
+            return if current.empty?
+
+            from, to = [current, remote].map { |registry| registry.dig("metadata", "currency") || DEFAULT_CURRENCY }
+            "currency: #{from} -> #{to}" unless from.upcase == to.upcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -9,6 +9,7 @@ require_relative "registry"
 require_relative "sync/fetcher"
 require_relative "sync/registry_diff"
 require_relative "sync/registry_writer"
+require_relative "sync/snapshot_guard"
 
 module LlmCostTracker
   module Pricing
@@ -18,15 +19,15 @@ module LlmCostTracker
         "https://raw.githubusercontent.com/sergey-homenko/llm_cost_tracker/main/lib/llm_cost_tracker/prices.json"
       SUPPORTED_SCHEMA_VERSION = 1
 
-      RefreshResult = Data.define(:path, :source_url, :source_version, :changes, :written, :not_modified)
-      CheckResult = Data.define(:path, :source_url, :source_version, :changes, :up_to_date)
+      RefreshResult = Data.define(:path, :source_url, :source_version, :changes, :suspicious, :written, :not_modified)
+      CheckResult = Data.define(:path, :source_url, :source_version, :changes, :suspicious, :up_to_date)
 
       class << self
         def configured_output_path(env: ENV, config: LlmCostTracker.configuration)
           output = env["OUTPUT"].to_s.strip.presence
           return output if output
 
-          prices_file = config.prices_file
+          prices_file = config.pricing.file
           return prices_file.to_s if prices_file
 
           Rails.root.join(DEFAULT_OUTPUT_PATH).to_s
@@ -39,6 +40,7 @@ module LlmCostTracker
         def refresh(path: DEFAULT_OUTPUT_PATH,
                     url: DEFAULT_REMOTE_URL,
                     preview: false,
+                    force: false,
                     fetcher: Fetcher.new,
                     today: Date.today)
           current = load_registry(path)
@@ -49,15 +51,18 @@ module LlmCostTracker
               path: path,
               url: url,
               response: response,
-              current: current,
-              remote: current,
+              changes: registry_changes(current, current),
+              suspicious: [],
               written: false,
               not_modified: true
             )
           end
 
           remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+          changes = registry_changes(current, remote)
+          suspicious = SnapshotGuard.call(current: current, remote: remote, changes: changes)
           unless preview
+            refuse_suspicious_snapshot!(path, suspicious) unless force || suspicious.empty?
             RegistryWriter.new.call(path: path, registry: remote)
             Pricing::Registry.reset!
           end
@@ -65,8 +70,8 @@ module LlmCostTracker
             path: path,
             url: url,
             response: response,
-            current: current,
-            remote: remote,
+            changes: changes,
+            suspicious: suspicious,
             written: !preview,
             not_modified: false
           )
@@ -79,22 +84,25 @@ module LlmCostTracker
           if response.not_modified
             return CheckResult.new(
               path: path,
-              source_url: url,
+              source_url: Redaction.text(url),
               source_version: response.source_version,
               changes: {},
+              suspicious: [],
               up_to_date: true
             )
           end
 
           remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
           changes = registry_changes(current, remote)
+          suspicious = SnapshotGuard.call(current: current, remote: remote, changes: changes)
 
           CheckResult.new(
             path: path,
-            source_url: url,
+            source_url: Redaction.text(url),
             source_version: response.source_version,
             changes: changes,
-            up_to_date: changes.empty?
+            suspicious: suspicious,
+            up_to_date: changes.empty? && suspicious.empty?
           )
         end
 
@@ -128,7 +136,7 @@ module LlmCostTracker
             "metadata" => metadata.merge(
               "schema_version" => schema_version,
               "updated_at" => metadata["updated_at"] || today.iso8601,
-              "source_url" => url,
+              "source_url" => Redaction.text(url),
               "source_version" => response.source_version
             ),
             "models" => models
@@ -156,17 +164,26 @@ module LlmCostTracker
           raise Error, "Unable to parse remote pricing snapshot: #{e.message}"
         end
 
-        def refresh_result(path:, url:, response:, current:, remote:, written:, not_modified:)
+        def refresh_result(path:, url:, response:, changes:, suspicious:, written:, not_modified:)
           RefreshResult.new(
             path: path,
-            source_url: url,
+            source_url: Redaction.text(url),
             source_version: response.source_version,
-            changes: registry_changes(current, remote),
+            changes: changes,
+            suspicious: suspicious,
             written: written,
             not_modified: not_modified
           )
         end
 
+        def refuse_suspicious_snapshot!(path, suspicious)
+          listed = suspicious.first(20).map { |finding| "\n  - #{finding}" }.join
+          raise Error,
+                "Refusing to write pricing file #{path}: the remote snapshot has #{suspicious.size} " \
+                "suspicious price change(s):#{listed}\n" \
+                "Review them with PREVIEW=1, then refresh with FORCE=1 (force: true) to accept them."
+        end
+
         def registry_changes(current, remote)
           model_changes = RegistryDiff.call(current.fetch("models", {}), remote.fetch("models", {}))
           charge_changes = service_charges_diff(

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -9,14 +9,14 @@ module LlmCostTracker
       WARN_CACHE_LIMIT = 1024
 
       class << self
-        def process(model)
+        def process(model, pricing_mode: nil)
           model = model.to_s.presence || Event::UNKNOWN_MODEL
 
-          case LlmCostTracker.configuration.unknown_pricing_behavior
+          case LlmCostTracker.configuration.pricing.unknown_model_behavior
           when :ignore
             nil
           when :warn
-            warn_missing(model)
+            warn_missing(model, pricing_mode.to_s.presence)
           when :raise
             raise UnknownPricingError.new(model: model)
           end
@@ -24,19 +24,22 @@ module LlmCostTracker
 
         private
 
-        def warn_missing(model)
+        def warn_missing(model, pricing_mode)
+          key = [model, pricing_mode].freeze
           should_warn = MUTEX.synchronize do
             @warned_models ||= Set.new
-            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(model)
+            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(key)
 
-            @warned_models.add?(model)
+            @warned_models.add?(key)
           end
           return unless should_warn
 
+          subject = "model #{model.inspect}"
+          subject += " at pricing_mode #{pricing_mode.inspect}" if pricing_mode
           Logging.warn(
-            "No pricing configured for model #{model.inspect}. " \
+            "No pricing configured for #{subject}. " \
             "Cost and budget guardrails will be skipped for this event. " \
-            "Add a pricing_overrides entry or set unknown_pricing_behavior."
+            "Add a pricing.overrides entry or set pricing.unknown_model_behavior."
           )
         end
       end

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

@@ -22,12 +22,13 @@ module LlmCostTracker
             output_tokens: output,
             cache_read_input_tokens: cache_read,
             cache_write_input_tokens: cache_write,
-            cache_write_extended_input_tokens: cache_write_extended
+            cache_write_extended_input_tokens: cache_write_extended,
+            hidden_output_tokens: usage.dig(:output_tokens_details, :thinking_tokens).to_i
           )
         end
 
         def self.pricing_mode(request:, usage:)
-          speed = request&.dig(:speed)
+          speed = usage&.dig(:speed) || request&.dig(:speed)
           service_tier = usage&.dig(:service_tier) || request&.dig(:service_tier)
           geo = (usage&.dig(:inference_geo) || request&.dig(:inference_geo)).to_s.downcase
 

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

@@ -38,6 +38,25 @@ module LlmCostTracker
           match = uri&.path&.match(%r{/openai/deployments/([^/]+)/})
           match && match[1]
         end
+
+        def auto_enable_stream_usage?(request_url, request_parsed)
+          super && stream_options_api?(parsed_uri(request_url)) &&
+            !request_parsed.key?("data_sources") && !image_input?(request_parsed)
+        end
+
+        private
+
+        def stream_options_api?(uri)
+          uri.path.start_with?("/openai/v1/") ||
+            uri.query.to_s[/api-version=(\d{4}-\d{2}-\d{2})/, 1].to_s >= "2024-06-01"
+        end
+
+        def image_input?(request)
+          Array(request["messages"]).any? do |message|
+            message.is_a?(Hash) &&
+              Array(message["content"]).any? { |part| part.is_a?(Hash) && part["type"] == "image_url" }
+          end
+        end
       end
     end
   end

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

@@ -78,6 +78,10 @@ module LlmCostTracker
           extract_model_from_url(request_url)
         end
 
+        def retain_stream_event?(data)
+          data.is_a?(Hash) && grounding_request_count(data["candidates"]).positive?
+        end
+
         def provider_for(_request_url)
           "gemini"
         end

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

@@ -4,9 +4,6 @@ module LlmCostTracker
   module Providers
     module Openai
       module ModelFamilies
-        DATA_RESIDENCY_MODEL_PATTERN =
-          /\Agpt-5\.(?:4|5)(?:-(?:mini|nano|pro|codex(?:-mini|-max)?))?(?:-\d{4}-\d{2}-\d{2})?\z/
-
         IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
 
         CHARACTER_BILLED_TTS_MODEL_PATTERN = /\Atts-1(-hd)?\z/
@@ -19,10 +16,6 @@ module LlmCostTracker
         NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
 
         CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN = /-search-(?:preview|api)\b/i
-        def self.data_residency?(model)
-          model.to_s.match?(DATA_RESIDENCY_MODEL_PATTERN)
-        end
-
         def self.image_output?(model)
           model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
         end

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

@@ -16,7 +16,10 @@ module LlmCostTracker
         class << self
           def combined_pricing_mode(host:, model:, service_tier:)
             modes = [Pricing::Mode.normalize(service_tier)]
-            modes << "data_residency" if Hosts.data_residency?(host) && ModelFamilies.data_residency?(model)
+            if Hosts.data_residency?(host) &&
+               Pricing::Matcher.modifier_priced?(provider: "openai", model: model, modifier: "data_residency")
+              modes << "data_residency"
+            end
             Pricing::Mode.compose(modes)
           end
 
@@ -26,7 +29,7 @@ module LlmCostTracker
 
             model = response["model"] || request["model"]
             service_line_items =
-              ServiceCharges.service_line_items_for(response, request: request, model: response["model"]) +
+              ServiceCharges.service_line_items_for(response, request: request, model: model) +
               ServiceCharges.transcription_line_items(usage)
             Event.build(
               provider: provider,
@@ -67,10 +70,14 @@ module LlmCostTracker
           build_unknown_stream_usage(**context)
         end
 
-        def auto_enable_stream_usage?(request_url)
+        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
+
         private
 
         def stream_capture_context(events:, request:, request_url:)

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

@@ -12,9 +12,11 @@ module LlmCostTracker
           input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
           output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
           cache_read = cache_read_input_tokens(usage)
-          audio_input = audio_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_input = image_input_tokens(usage)
           image_output, regular_output = split_output(
             output_tokens: output_tokens,
             image_output_details: image_output_tokens(usage),
@@ -24,10 +26,11 @@ module LlmCostTracker
           )
 
           Usage::TokenUsage.build(
-            input_tokens: [input_tokens - cache_read - 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,
+            cache_write_input_tokens: cache_write,
             audio_input_tokens: audio_input,
             audio_output_tokens: audio_output,
             image_input_tokens: image_input,
@@ -46,12 +49,11 @@ module LlmCostTracker
             return default_to_image ? [remainder, 0] : [0, remainder]
           end
 
-          text_output = text_output_details
-          text_output = [output_tokens - image_output_details - audio_output, 0].max if text_output.zero?
-          [image_output_details, text_output]
+          [image_output_details, [output_tokens - image_output_details - audio_output, 0].max]
         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)
@@ -59,9 +61,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

@@ -14,7 +14,7 @@ module LlmCostTracker
           end
 
           def provider_names
-            custom = LlmCostTracker.configuration.openai_compatible_providers.each_value.map do |provider|
+            custom = LlmCostTracker.configuration.capture.openai_compatible_providers.each_value.map do |provider|
               provider.to_s.downcase
             end
             ["openai_compatible", *custom].uniq
@@ -23,13 +23,17 @@ module LlmCostTracker
           def provider_for_uri(uri)
             return nil unless uri
 
-            LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
+            LlmCostTracker.configuration.capture.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
           end
         end
 
         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