llm_cost_tracker 0.14.1 → 0.14.2

data/lib/llm_cost_tracker/pricing/rate.rb

@@ -5,6 +5,7 @@ module LlmCostTracker
     RATE_BASIS_QUANTITIES = {
       "per_million_tokens" => 1_000_000,
       "per_million_characters" => 1_000_000,
+      "per_million_token_hours" => 1_000_000,
       "per_request" => 1,
       "per_1k_requests" => 1_000,
       "per_session" => 1,

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -16,7 +16,7 @@ module LlmCostTracker
     module Registry
       DEFAULT_PRICES_PATH = File.expand_path("../prices.json", __dir__)
       CONTEXT_THRESHOLD_KEY = "_context_price_threshold_tokens"
-      PRICE_KEYS = Usage::Catalog.token_priced.map(&:key).freeze
+      PRICE_KEYS = Usage::Catalog.all.select(&:token?).map(&:key).freeze
       METADATA_KEYS = ["_source", CONTEXT_THRESHOLD_KEY].freeze
 
       class << self
@@ -185,10 +185,9 @@ module LlmCostTracker
         def normalize_price_entry(model, price, context)
           unknown = []
           normalized = price.each_with_object({}) do |(key, value), acc|
-            registry_key = registry_key_for(key)
-            if registry_key == CONTEXT_THRESHOLD_KEY
-              acc[registry_key] = Integer(value)
-            elsif registry_key
+            if key.to_s == CONTEXT_THRESHOLD_KEY
+              acc[CONTEXT_THRESHOLD_KEY] = Integer(value)
+            elsif (registry_key = PriceKey.price_key_for(key))
               acc[registry_key] = non_negative_decimal(value, label: "price for #{registry_key.inspect}")
             elsif !METADATA_KEYS.include?(key)
               unknown << key
@@ -213,12 +212,6 @@ module LlmCostTracker
           )
         end
 
-        def registry_key_for(key)
-          return CONTEXT_THRESHOLD_KEY if key.to_s == CONTEXT_THRESHOLD_KEY
-
-          PriceKey.price_key_for(key)
-        end
-
         def validate_price_entry(price, model:, context:)
           return {} if price.nil?
           return price if price.is_a?(Hash)
@@ -240,7 +233,7 @@ module LlmCostTracker
 
             rate = {
               amount: amount,
-              quantity: rate_quantity(dimension),
+              quantity: Pricing::RATE_BASIS_QUANTITIES.fetch(dimension.rate_basis).to_d,
               currency: currency,
               source_key: key
             }
@@ -258,10 +251,6 @@ module LlmCostTracker
           [dimension, tier]
         end
 
-        def rate_quantity(dimension)
-          Pricing::RATE_BASIS_QUANTITIES.fetch(dimension.rate_basis).to_d
-        end
-
         def upcased_currency(value)
           (value || LlmCostTracker::DEFAULT_CURRENCY).upcase
         end

data/lib/llm_cost_tracker/pricing/service_rates.rb

@@ -44,19 +44,12 @@ module LlmCostTracker
             return rate if rate
 
             tier_rates.each do |candidate, candidate_rate|
-              return candidate_rate if tier_includes?(pricing_mode, candidate)
+              return candidate_rate if "_#{pricing_mode}_".include?("_#{candidate}_")
             end
           end
           dimension_rates[:default]
         end
 
-        def tier_includes?(tier_name, candidate_name)
-          tier_name == candidate_name ||
-            tier_name.start_with?("#{candidate_name}_") ||
-            tier_name.end_with?("_#{candidate_name}") ||
-            tier_name.include?("_#{candidate_name}_")
-        end
-
         def charge_dimension_key(dimension)
           billing_dimension = Usage::Catalog[dimension]
           return billing_dimension.key if billing_dimension && billing_dimension.token_key.nil?

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

@@ -6,22 +6,26 @@ module LlmCostTracker
       module RegistryDiff
         class << self
           def call(current_models, updated_models)
-            current_models = Registry.normalize_price_entries(current_models, context: "current price table")
-            updated_models = Registry.normalize_price_entries(updated_models, context: "updated price table")
-
-            (current_models.keys | updated_models.keys).sort.each_with_object({}) do |model, changes|
-              fields = price_field_changes(current_models[model], updated_models[model])
-              changes[model] = fields if fields.any?
-            end
+            nested(
+              Registry.normalize_price_entries(current_models, context: "current price table"),
+              Registry.normalize_price_entries(updated_models, context: "updated price table")
+            )
           rescue ArgumentError, TypeError => e
             raise Error, e.message
           end
 
+          def nested(current, updated)
+            (current.keys | updated.keys).sort.each_with_object({}) do |key, changes|
+              fields = price_field_changes(current[key], updated[key])
+              changes[key] = fields if fields.any?
+            end
+          end
+
           private
 
           def price_field_changes(current_entry, updated_entry)
-            current_price = current_entry || {}
-            updated_price = updated_entry || {}
+            current_price = (current_entry || {}).transform_keys(&:to_s)
+            updated_price = (updated_entry || {}).transform_keys(&:to_s)
 
             (current_price.keys | updated_price.keys).sort.each_with_object({}) do |field, changes|
               from = current_price[field]

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -43,59 +43,26 @@ module LlmCostTracker
                     force: false,
                     fetcher: Fetcher.new,
                     today: Date.today)
-          current = load_registry(path)
-          response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
-
-          if response.not_modified
-            return refresh_result(
-              path: path,
-              url: url,
-              response: response,
-              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
+          response, remote, changes, suspicious = compare(path, url, fetcher, today)
+          written = !preview && !response.not_modified
+          if written
             refuse_suspicious_snapshot!(path, suspicious) unless force || suspicious.empty?
             RegistryWriter.new.call(path: path, registry: remote)
             Pricing::Registry.reset!
           end
-          refresh_result(
+          RefreshResult.new(
             path: path,
-            url: url,
-            response: response,
+            source_url: Redaction.text(url),
+            source_version: response.source_version,
             changes: changes,
             suspicious: suspicious,
-            written: !preview,
-            not_modified: false
+            written: written,
+            not_modified: response.not_modified
           )
         end
 
         def check(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, fetcher: Fetcher.new, today: Date.today)
-          current = load_registry(path)
-          response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
-
-          if response.not_modified
-            return CheckResult.new(
-              path: path,
-              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)
-
+          response, _remote, changes, suspicious = compare(path, url, fetcher, today)
           CheckResult.new(
             path: path,
             source_url: Redaction.text(url),
@@ -147,6 +114,16 @@ module LlmCostTracker
           raise Error, "Unable to load remote pricing snapshot: #{e.message}"
         end
 
+        def compare(path, url, fetcher, today)
+          current = load_registry(path)
+          response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
+          return [response, nil, {}, []] if response.not_modified
+
+          remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+          changes = registry_changes(current, remote)
+          [response, remote, changes, SnapshotGuard.call(current: current, remote: remote, changes: changes)]
+        end
+
         def load_registry(path)
           return {} unless File.exist?(path)
 
@@ -164,29 +141,18 @@ module LlmCostTracker
           raise Error, "Unable to parse remote pricing snapshot: #{e.message}"
         end
 
-        def refresh_result(path:, url:, response:, changes:, suspicious:, written:, not_modified:)
-          RefreshResult.new(
-            path: path,
-            source_url: Redaction.text(url),
-            source_version: response.source_version,
-            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."
+                "Review them with llm_cost_tracker:prices:check, " \
+                "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(
+          charge_changes = RegistryDiff.nested(
             current.fetch("service_charges", {}),
             remote.fetch("service_charges", {})
           )
@@ -194,21 +160,6 @@ module LlmCostTracker
 
           model_changes.merge("service_charges" => charge_changes)
         end
-
-        def service_charges_diff(current, remote)
-          (current.keys | remote.keys).sort.each_with_object({}) do |provider, changes|
-            current_rates = (current[provider] || {}).transform_keys(&:to_s)
-            remote_rates = (remote[provider] || {}).transform_keys(&:to_s)
-            (current_rates.keys | remote_rates.keys).sort.each_with_object(changes) do |component, _|
-              from = current_rates[component]
-              to = remote_rates[component]
-              next if from == to
-
-              changes[provider] ||= {}
-              changes[provider][component] = { "from" => from, "to" => to }
-            end
-          end
-        end
       end
     end
   end

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

@@ -10,7 +10,9 @@ module LlmCostTracker
 
         class << self
           def match?(url)
-            match_uri?(url, hosts: HOSTS, path_includes: "/v1/messages")
+            uri_matches?(url) do |uri|
+              HOSTS.include?(uri.host.to_s.downcase) && uri.path.to_s.include?("/v1/messages")
+            end
           end
 
           def provider_names
@@ -32,7 +34,9 @@ module LlmCostTracker
             model: response["model"] || request[:model],
             provider_response_id: response["id"],
             usage_source: Usage::Source::RESPONSE,
-            request: request
+            request: request,
+            content: Array(response["content"]).grep(Hash).map(&:deep_symbolize_keys),
+            **stop_fields(response)
           )
         end
 
@@ -51,7 +55,9 @@ module LlmCostTracker
               provider_response_id: response_id,
               usage_source: Usage::Source::STREAM_FINAL,
               request: request,
-              stream: true
+              stream: true,
+              content: content_blocks(events),
+              **stop_fields(final_delta(events))
             )
           else
             build_unknown_stream_usage(
@@ -67,12 +73,36 @@ module LlmCostTracker
           "anthropic"
         end
 
+        def retain_stream_event?(data)
+          data.is_a?(Hash) && data.dig("content_block", "type") == "fallback"
+        end
+
         private
 
         def symbolize_request(request_body)
           safe_json_parse(request_body).deep_symbolize_keys
         end
 
+        def final_delta(events)
+          find_event_value(events, reverse: true) { |data| data["delta"] if data["type"] == "message_delta" }
+        end
+
+        def content_blocks(events)
+          blocks = []
+          each_event_data(events) do |data|
+            block = data["content_block"] if data["type"] == "content_block_start"
+            blocks << block.deep_symbolize_keys if block.is_a?(Hash)
+          end
+          blocks
+        end
+
+        def stop_fields(source)
+          return {} unless source.is_a?(Hash)
+
+          details = source["stop_details"]
+          { stop_reason: source["stop_reason"], refusal_category: (details["category"] if details.is_a?(Hash)) }
+        end
+
         def stream_usage(events)
           latest_delta = find_event_value(events, reverse: true) do |data|
             data["usage"] if data["type"] == "message_delta" && data["usage"].is_a?(Hash)

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

@@ -11,17 +11,23 @@ module LlmCostTracker
                                   provider_response_id:,
                                   usage_source:,
                                   request: nil,
-                                  pricing_mode: nil,
-                                  stream: false)
+                                  stream: false,
+                                  stop_reason: nil,
+                                  refusal_category: nil,
+                                  content: nil)
+          pricing_mode = UsageExtractor.pricing_mode(request: request, usage: usage)
+          line_items = UsageExtractor.service_line_items(usage) +
+                       UsageExtractor.iteration_line_items(usage, content: content) +
+                       UsageExtractor.refusal_line_items(usage, stop_reason:, refusal_category:)
           Event.build(
             provider: "anthropic",
             provider_response_id: provider_response_id,
-            pricing_mode: pricing_mode || UsageExtractor.pricing_mode(request: request, usage: usage),
-            model: model,
+            pricing_mode: pricing_mode,
+            model: UsageExtractor.served_model(usage, content) || model,
             token_usage: UsageExtractor.token_usage(usage),
             stream: stream,
             usage_source: usage_source,
-            service_line_items: UsageExtractor.service_line_items(usage)
+            service_line_items: line_items
           )
         end
       end

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

@@ -9,34 +9,100 @@ module LlmCostTracker
           "web_fetch_request" => :web_fetch_requests
         }.freeze
         DATA_RESIDENCY_GEOS = %w[us].freeze
-        private_constant :SERVER_TOOL_LINE_ITEMS, :DATA_RESIDENCY_GEOS
+        BILLED_REFUSAL_CATEGORIES = %w[bio frontier_llm reasoning_extraction].freeze
+        BEDROCK_REGIONAL_PROFILE = /\A(?!global\.)[a-z]+\.anthropic\./
+        private_constant :SERVER_TOOL_LINE_ITEMS,
+                         :DATA_RESIDENCY_GEOS,
+                         :BILLED_REFUSAL_CATEGORIES,
+                         :BEDROCK_REGIONAL_PROFILE
 
         def self.token_usage(usage)
-          input = usage[:input_tokens].to_i
-          output = usage[:output_tokens].to_i
-          cache_read = usage[:cache_read_input_tokens].to_i
-          cache_write, cache_write_extended = cache_writes(usage)
+          entries = [usage, *iterations(usage, "compaction")]
+          writes = entries.map { |entry| cache_writes(entry) }
 
           Usage::TokenUsage.build(
-            input_tokens: input,
-            output_tokens: output,
-            cache_read_input_tokens: cache_read,
-            cache_write_input_tokens: cache_write,
-            cache_write_extended_input_tokens: cache_write_extended,
+            input_tokens: entries.sum { |entry| entry[:input_tokens].to_i },
+            output_tokens: entries.sum { |entry| entry[:output_tokens].to_i },
+            cache_read_input_tokens: entries.sum { |entry| entry[:cache_read_input_tokens].to_i },
+            cache_write_input_tokens: writes.sum(&:first),
+            cache_write_extended_input_tokens: writes.sum(&:last),
             hidden_output_tokens: usage.dig(:output_tokens_details, :thinking_tokens).to_i
           )
         end
 
+        def self.served_model(usage, content = nil)
+          served = iterations(usage, "fallback_message").last&.dig(:model)
+          served ||= fallback_blocks(content).last&.dig(:to, :model)
+          served&.to_s.presence
+        end
+
+        def self.iteration_line_items(usage, content: nil)
+          other_model_iterations(usage, content).map do |iteration|
+            tokens = token_usage(iteration)
+            Charges::LineItem.build(
+              dimension_key: "model_iteration",
+              quantity: 1,
+              pricing_basis: "provider_usage",
+              provider_field: "usage.iterations.#{iteration[:type]}",
+              details: tokens.to_h.select { |_key, count| count.positive? }.merge(model: iteration[:model].to_s)
+            )
+          end
+        end
+
+        def self.refusal_line_items(usage, stop_reason:, refusal_category:)
+          return [] unless stop_reason.to_s == "refusal" && token_usage(usage).output_tokens.zero?
+          return [] if BILLED_REFUSAL_CATEGORIES.include?(refusal_category.to_s)
+
+          [Charges::LineItem.build(
+            dimension_key: "billed_request",
+            quantity: 1,
+            rate_amount: 0,
+            cost: 0,
+            pricing_basis: "provider_usage",
+            price_source: "provider_response",
+            provider_field: "stop_details.category",
+            details: { category: refusal_category&.to_s }.compact
+          )]
+        end
+
+        def self.other_model_iterations(usage, content)
+          advisors = iterations(usage, "advisor_message")
+          served = served_model(usage, content)
+          return advisors unless served
+
+          categories = fallback_blocks(content).map { |block| block.dig(:trigger, :category).to_s }
+          declined = iterations(usage, "message").reject { |entry| ["", served].include?(entry[:model].to_s) }
+          hops = declined.group_by { |entry| entry[:model].to_s }.values
+          billed = hops.select.with_index do |hop, index|
+            hop.any? { |entry| entry[:output_tokens].to_i.positive? } ||
+              BILLED_REFUSAL_CATEGORIES.include?(categories[index])
+          end
+          advisors + billed.flatten
+        end
+
+        def self.fallback_blocks(content)
+          Array(content).select { |block| block.is_a?(Hash) && block[:type].to_s == "fallback" }
+        end
+
+        def self.iterations(usage, type)
+          Array(usage[:iterations]).select { |entry| entry.is_a?(Hash) && entry[:type].to_s == type }
+        end
+
         def self.pricing_mode(request:, usage:)
           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
 
           modes = [Pricing::Mode.normalize(speed), Pricing::Mode.normalize(service_tier)]
-          modes << "data_residency" if DATA_RESIDENCY_GEOS.include?(geo)
+          modes << "data_residency" if DATA_RESIDENCY_GEOS.include?(geo) || bedrock_regional?(request&.dig(:model))
           Pricing::Mode.compose(modes)
         end
 
+        def self.bedrock_regional?(model)
+          model.to_s.match?(BEDROCK_REGIONAL_PROFILE) &&
+            Pricing::Matcher.modifier_priced?(provider: "bedrock", model: model.to_s, modifier: "data_residency")
+        end
+
         def self.service_line_items(usage)
           server_tool_use = usage[:server_tool_use]
           return [] unless server_tool_use.is_a?(Hash)
@@ -58,7 +124,10 @@ module LlmCostTracker
         def self.cache_writes(usage)
           cache_creation = usage[:cache_creation]
           if cache_creation.is_a?(Hash)
-            [cache_creation[:ephemeral_5m_input_tokens].to_i, cache_creation[:ephemeral_1h_input_tokens].to_i]
+            five = cache_creation[:ephemeral_5m_input_tokens].to_i
+            one = cache_creation[:ephemeral_1h_input_tokens].to_i
+            # A stream's message_delta total also counts later server-tool breakpoints, which are always 5m.
+            [five + [usage[:cache_creation_input_tokens].to_i - five - one, 0].max, one]
           else
             warn_unexpected_cache_creation(cache_creation, usage)
             [usage[:cache_creation_input_tokens].to_i, 0]

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

@@ -6,13 +6,9 @@ module LlmCostTracker
       class Parser < LlmCostTracker::Parsers::Base
         include Openai::ResponseParser
 
-        TRACKED_ENDPOINTS = %w[
-          chat/completions completions embeddings moderations responses
-          audio/transcriptions audio/translations audio/speech
-          images/generations images/edits images/variations
-        ].freeze
-
-        PATH_PATTERN = %r{\A/openai/(?:deployments/[^/]+|v1)/(?:#{TRACKED_ENDPOINTS.join('|')})\z}
+        PATH_PATTERN = %r{
+          \A/openai/(?:deployments/[^/]+|v1)/(?:#{Openai::Parser::TRACKED_ENDPOINTS.join('|')}|responses/resp_[^/]+)\z
+        }x
 
         class << self
           def match?(url)