llm_cost_tracker 0.10.0 → 0.12.0

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

@@ -6,13 +6,15 @@ module LlmCostTracker
       module RegistryDiff
         class << self
           def call(current_models, updated_models)
-            current_models = normalize_models(current_models)
-            updated_models = normalize_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
+          rescue ArgumentError, TypeError => e
+            raise Error, e.message
           end
 
           private
@@ -29,14 +31,6 @@ module LlmCostTracker
               changes[field] = { "from" => from, "to" => to }
             end
           end
-
-          def normalize_models(models)
-            Registry.normalize_price_table(models).transform_values do |price|
-              price.to_h { |key, value| [key.name, value] }
-            end
-          rescue ArgumentError, TypeError => e
-            raise Error, e.message
-          end
         end
       end
     end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
 require "fileutils"
 require "json"
 require "yaml"
@@ -12,9 +13,8 @@ module LlmCostTracker
         MANUAL_SOURCE = "manual"
 
         def call(path:, registry:)
+          payload = render(path: path, registry: registry)
           FileUtils.mkdir_p(File.dirname(path))
-          merged = canonicalize(merge_with_existing(path: path, registry: registry))
-          payload = yaml_file?(path) ? YAML.dump(merged) : "#{JSON.pretty_generate(merged)}\n"
           temp_path = "#{path}.tmp-#{Process.pid}-#{Thread.current.object_id}"
           File.write(temp_path, payload)
           File.rename(temp_path, path)
@@ -22,6 +22,11 @@ module LlmCostTracker
           FileUtils.rm_f(temp_path) if temp_path && File.exist?(temp_path)
         end
 
+        def render(path:, registry:)
+          merged = canonicalize(merge_with_existing(path: path, registry: registry))
+          yaml_file?(path) ? YAML.dump(merged) : "#{JSON.pretty_generate(merged)}\n"
+        end
+
         private
 
         def canonicalize(value)
@@ -30,6 +35,8 @@ module LlmCostTracker
             value.sort_by { |key, _| key.to_s }.to_h { |key, nested| [key, canonicalize(nested)] }
           when Array
             value.map { |element| canonicalize(element) }
+          when BigDecimal
+            value.to_f
           else
             value
           end
@@ -79,7 +86,7 @@ module LlmCostTracker
           else
             JSON.parse(contents)
           end
-        rescue StandardError
+        rescue Errno::ENOENT, Psych::Exception, JSON::ParserError
           nil
         end
 

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -36,7 +36,10 @@ module LlmCostTracker
           env["URL"].to_s.strip.presence || DEFAULT_REMOTE_URL
         end
 
-        def refresh(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, preview: false, fetcher: Fetcher.new,
+        def refresh(path: DEFAULT_OUTPUT_PATH,
+                    url: DEFAULT_REMOTE_URL,
+                    preview: false,
+                    fetcher: Fetcher.new,
                     today: Date.today)
           current = load_registry(path)
           response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
@@ -56,7 +59,7 @@ module LlmCostTracker
           remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
           unless preview
             RegistryWriter.new.call(path: path, registry: remote)
-            invalidate_pricing_caches!
+            Pricing::Registry.reset!
           end
           refresh_result(
             path: path,
@@ -69,12 +72,6 @@ module LlmCostTracker
           )
         end
 
-        def invalidate_pricing_caches!
-          Pricing::Lookup.reset!
-          Pricing::Registry.reset!
-          Pricing::ServiceCharges.reset!
-        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"))
@@ -119,12 +116,13 @@ module LlmCostTracker
           end
 
           raw_models = registry.fetch("models", {})
-          models = Registry.normalize_price_table(raw_models).each_with_object({}) do |(model, prices), normalized|
+          models = Registry.normalize_price_entries(raw_models, context: "remote pricing snapshot")
+                           .each_with_object({}) do |(model, prices), normalized|
             model_metadata = (raw_models[model] || {}).slice(*Registry::METADATA_KEYS)
-            normalized[model] = model_metadata.merge(prices.to_h { |key, value| [key.name, value] })
+            normalized[model] = model_metadata.merge(prices)
           end
           service_charges = registry["service_charges"]
-          ServiceCharges.rates_from_registry(registry, context: "remote pricing snapshot") if service_charges
+          Registry.rates_from_registry(registry, context: "remote pricing snapshot") if service_charges
 
           normalized = {
             "metadata" => metadata.merge(

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -4,7 +4,7 @@ require_relative "../logging"
 
 module LlmCostTracker
   module Pricing
-    class Unknown
+    module Unknown
       MUTEX = Mutex.new
       WARN_CACHE_LIMIT = 1024
 
@@ -22,10 +22,6 @@ module LlmCostTracker
           end
         end
 
-        def reset!
-          MUTEX.synchronize { @warned_models = Set.new }
-        end
-
         private
 
         def warn_missing(model)

data/lib/llm_cost_tracker/pricing.rb

@@ -5,308 +5,23 @@ require "bigdecimal"
 require "time"
 
 require_relative "version"
-require_relative "logging"
-require_relative "token_usage"
-require_relative "billing/components"
-require_relative "billing/line_item"
-require_relative "pricing/mode"
+require_relative "usage/token_usage"
+require_relative "charges/cost"
+require_relative "charges/cost_status"
+require_relative "pricing/price_key"
 require_relative "pricing/registry"
-require_relative "pricing/lookup"
+require_relative "pricing/source"
+require_relative "pricing/matcher"
+require_relative "pricing/service_rates"
 require_relative "pricing/effective_prices"
-require_relative "pricing/explainer"
-require_relative "pricing/service_charges"
 require_relative "pricing/estimator"
+require_relative "pricing/calculation"
 
 module LlmCostTracker
-  module Pricing # rubocop:disable Metrics/ModuleLength
-    extend ServiceCharges
-
-    STANDARD_MODE_VALUES = %i[auto default standard standard_only].freeze
-    RATE_DENOMINATOR_TOKENS = 1_000_000
-    private_constant :RATE_DENOMINATOR_TOKENS
-
+  module Pricing
     class << self
-      def normalize_mode(value)
-        return nil if value.nil?
-
-        mode = normalize_string_mode(value.to_s)
-        return nil unless mode
-
-        STANDARD_MODE_VALUES.include?(mode) ? nil : mode
-      end
-
       def cost_for(provider:, model:, tokens:, pricing_mode: nil)
-        calculation = calculation_for(
-          provider: provider,
-          model: model,
-          tokens: tokens,
-          pricing_mode: pricing_mode
-        )
-        return nil unless calculation
-
-        cost_from(calculation)
-      end
-
-      def calculate(provider:, model:, tokens:, line_items:, pricing_mode: nil)
-        calculation = calculation_for(
-          provider: provider,
-          model: model,
-          tokens: tokens,
-          pricing_mode: pricing_mode
-        )
-        cost_data = calculation && cost_from(calculation)
-        snapshot = calculation && snapshot_from(calculation)
-        priced = apply_calculation_to_line_items(line_items, calculation,
-                                                 provider: provider, pricing_mode: pricing_mode)
-        [cost_data, snapshot, priced]
-      end
-
-      def price_line_items(provider:, model:, line_items:, pricing_mode: nil)
-        token_usage = TokenUsage.build_from_tokens(token_attributes_from(line_items))
-        calculation = calculation_for(provider: provider, model: model, tokens: token_usage, pricing_mode: pricing_mode)
-        snapshot = calculation && snapshot_from(calculation)
-        priced = apply_calculation_to_line_items(line_items, calculation,
-                                                 provider: provider, pricing_mode: pricing_mode)
-        [priced, snapshot]
-      end
-
-      def snapshot_for(provider:, model:, tokens:, pricing_mode: nil)
-        calculation = calculation_for(
-          provider: provider,
-          model: model,
-          tokens: tokens,
-          pricing_mode: pricing_mode
-        )
-        return nil unless calculation
-
-        snapshot_from(calculation)
-      end
-
-      def explain(provider:, model:, tokens:, pricing_mode: nil)
-        Explainer.call(
-          provider: provider,
-          model: model,
-          tokens: tokens,
-          pricing_mode: pricing_mode
-        )
-      end
-
-      def stored_cost_attributes(attributes)
-        value = attributes.to_h[:total_cost]
-        value ? { total_cost: value } : {}
-      end
-
-      def combine_with_service_lines(cost_data, line_items)
-        priced_services = line_items.reject(&:token?).select(&:priced?)
-        return cost_data if priced_services.empty?
-
-        base_currency = base_currency_for(cost_data, priced_services)
-        matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
-        warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
-
-        cost = cost_data ? cost_data.dup : {}
-        cost[:currency] ||= base_currency.to_s
-        return cost if matching.empty?
-
-        service_total = matching.sum(BigDecimal("0"), &:cost_value)
-        base_total = BigDecimal(cost.fetch(:total_cost, 0).to_s)
-        cost[:total_cost] = (base_total + service_total).round(8)
-        cost
-      end
-
-      def token_pricing_partial?(token_usage, cost_data)
-        return false unless cost_data
-
-        token_usage.priced_quantities.any? do |key, quantity|
-          next false unless quantity.positive?
-
-          cost_data[Billing::Components::BY_KEY.fetch(key).cost_key].nil?
-        end
-      end
-
-      private
-
-      def base_currency_for(cost_data, priced_services)
-        (cost_data && cost_data[:currency]) || priced_services.first.currency || Billing::LineItem::USD
-      end
-
-      def warn_currency_mismatch(lines, base_currency)
-        currencies = lines.map { |line| line.currency.to_s }.uniq.sort
-        Logging.warn(
-          "Service line currency mismatch: header is #{base_currency}, dropping " \
-          "#{lines.size} priced line(s) in #{currencies.join(', ')} from header total. " \
-          "Per-line costs are still recorded; header total reflects #{base_currency} only."
-        )
-      end
-
-      def normalize_string_mode(value)
-        normalized = value.strip
-        return nil if normalized.empty?
-
-        normalized.downcase.tr("-", "_").to_sym
-      end
-
-      def cost_from(calculation)
-        costs = calculation[:costs]
-        values = Billing::Components::TOKEN_PRICED.each_with_object({}) do |component, result|
-          cost = costs[component.key]
-          result[component.cost_key] = cost.round(8) unless cost.nil?
-        end
-        values[:total_cost] = costs.values.compact.sum(BigDecimal("0")).round(8)
-        values[:currency] = calculation[:match].currency
-        values
-      end
-
-      def snapshot_from(calculation)
-        match = calculation[:match]
-        effective = calculation[:effective]
-        rates = calculation[:quantities].each_with_object({}) do |(key, quantity), values|
-          price = effective[key]
-          next if quantity.zero? || price.nil?
-
-          values[key] = { amount: price, quantity: RATE_DENOMINATOR_TOKENS }
-        end
-
-        {
-          schema_version: 1,
-          source: match.source,
-          source_key: match.key,
-          source_version: source_version_for(match.source),
-          matched_by: match.matched_by,
-          currency: match.currency,
-          rates: rates
-        }
-      end
-
-      def calculation_for(provider:, model:, tokens:, pricing_mode:)
-        match = Lookup.call(provider: provider, model: model)
-        return nil unless match
-
-        token_usage = TokenUsage.build_from_tokens(tokens)
-        quantities = token_usage.priced_quantities
-        mode = normalize_mode(pricing_mode)
-        effective = EffectivePrices.call(usage: token_usage, quantities: quantities, prices: match.prices,
-                                         pricing_mode: mode)
-        return nil unless any_billable_priced?(quantities, effective)
-
-        { match: match, effective: effective, token_usage: token_usage, quantities: quantities,
-          costs: costs_for(quantities, effective) }
-      end
-
-      def any_billable_priced?(quantities, effective)
-        any_billable = false
-        quantities.each_pair do |key, quantity|
-          next unless quantity.positive?
-          return true if effective[key]
-
-          any_billable = true
-        end
-        !any_billable
-      end
-
-      def costs_for(quantities, effective)
-        quantities.to_h { |key, tokens| [key, token_cost(tokens, effective[key])] }
-      end
-
-      def apply_calculation_to_line_items(line_items, calculation, provider:, pricing_mode:)
-        line_items.map do |line_item|
-          next price_token_line_item(line_item, calculation) if line_item.unit == :token
-
-          price_service_charge_line_item(line_item,
-                                         provider: provider,
-                                         calculation: calculation,
-                                         pricing_mode: pricing_mode)
-        end
-      end
-
-      def token_attributes_from(line_items)
-        line_items.each_with_object({}) do |line_item, totals|
-          next unless line_item.unit == :token
-
-          component = component_for_line_item(line_item)
-          next unless component
-
-          totals[component.key] = (totals[component.key] || 0) + line_item.quantity.to_i
-        end
-      end
-
-      def price_token_line_item(line_item, calculation)
-        component = component_for_line_item(line_item)
-        return line_item unless component
-        return line_item.with(cost_status: Billing::CostStatus::UNKNOWN) unless calculation
-
-        effective_price = calculation[:effective][component.key]
-        return line_item.with(cost_status: Billing::CostStatus::UNKNOWN) if effective_price.nil?
-
-        cost = (line_item.quantity * BigDecimal(effective_price.to_s)) / RATE_DENOMINATOR_TOKENS
-        match = calculation[:match]
-        line_item.with(
-          rate_amount: BigDecimal(effective_price.to_s),
-          rate_quantity: BigDecimal(RATE_DENOMINATOR_TOKENS),
-          cost: cost,
-          currency: match.currency,
-          cost_status: cost.zero? ? Billing::CostStatus::FREE : Billing::CostStatus::COMPLETE,
-          price_key: component.key,
-          price_source: match.source,
-          price_source_version: source_version_for(match.source)
-        )
-      end
-
-      def price_service_charge_line_item(line_item, provider:, calculation:, pricing_mode:)
-        return line_item if line_item.priced?
-        return line_item unless line_item.billable?
-
-        rate = model_rate_for(line_item, calculation) ||
-               charge_rate(provider: provider, component: line_item.kind, pricing_mode: pricing_mode)
-        return line_item unless rate
-
-        line_item.with_rate(rate)
-      end
-
-      def model_rate_for(line_item, calculation)
-        return nil unless calculation
-
-        match = calculation[:match]
-        amount = match.prices[line_item.kind] || match.prices[line_item.kind.to_s]
-        return nil unless amount.is_a?(Numeric)
-
-        component = Billing::Components::BY_KEY[line_item.kind]
-        {
-          amount: BigDecimal(amount.to_s),
-          quantity: BigDecimal(Billing::RATE_BASIS_QUANTITIES.fetch(component.rate_basis).to_s),
-          currency: match.currency,
-          source: match.source,
-          source_key: "#{match.key}.#{line_item.kind}",
-          source_version: source_version_for(match.source)
-        }
-      end
-
-      def component_for_line_item(line_item)
-        Billing::Components::REGISTRY.find do |component|
-          component.kind == line_item.kind &&
-            component.direction == line_item.direction &&
-            component.modality == line_item.modality &&
-            component.cache_state == line_item.cache_state &&
-            component.unit == line_item.unit
-        end
-      end
-
-      def source_version_for(source)
-        case source
-        when :bundled
-          LlmCostTracker::VERSION
-        when :prices_file
-          Lookup.prices_file_mtime_iso
-        when :pricing_overrides
-          "configuration"
-        end
-      end
-
-      def token_cost(tokens, per_million_price)
-        return BigDecimal("0") if tokens.zero?
-        return nil if per_million_price.nil?
-
-        (BigDecimal(tokens.to_s) * BigDecimal(per_million_price.to_s)) / RATE_DENOMINATOR_TOKENS
+        Calculation.for(provider: provider, model: model, tokens: tokens, pricing_mode: pricing_mode).token_cost
       end
     end
   end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      class Parser < LlmCostTracker::Parsers::Base
+        HOSTS = %w[api.anthropic.com].freeze
+
+        class << self
+          def match?(url)
+            match_uri?(url, hosts: HOSTS, path_includes: "/v1/messages")
+          end
+
+          def provider_names
+            %w[anthropic]
+          end
+        end
+
+        def parse(request_body:, response_status:, response_body:, **)
+          return nil unless response_status == 200
+
+          response = safe_json_parse(response_body)
+          usage = response["usage"]&.deep_symbolize_keys
+          return nil unless usage
+
+          request = symbolize_request(request_body)
+
+          ResponseParser.event_from_usage(
+            usage: usage,
+            model: response["model"] || request[:model],
+            provider_response_id: response["id"],
+            usage_source: Usage::Source::RESPONSE,
+            request: request
+          )
+        end
+
+        def parse_stream(response_status:, request_body: nil, events: [], **)
+          return nil unless response_status == 200
+
+          request = symbolize_request(request_body)
+          model = find_event_value(events) { |data| data.dig("message", "model") } || request[:model]
+          usage = stream_usage(events)&.deep_symbolize_keys
+          response_id = find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
+
+          if usage
+            ResponseParser.event_from_usage(
+              usage: usage,
+              model: model,
+              provider_response_id: response_id,
+              usage_source: Usage::Source::STREAM_FINAL,
+              request: request,
+              stream: true
+            )
+          else
+            build_unknown_stream_usage(
+              provider: "anthropic",
+              model: model,
+              provider_response_id: response_id,
+              pricing_mode: UsageExtractor.pricing_mode(request: request, usage: usage)
+            )
+          end
+        end
+
+        def provider_for(_request_url)
+          "anthropic"
+        end
+
+        private
+
+        def symbolize_request(request_body)
+          safe_json_parse(request_body).deep_symbolize_keys
+        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)
+          end
+          return nil unless latest_delta
+
+          start_usage = find_event_value(events, reverse: true) do |data|
+            data.dig("message", "usage") if data["type"] == "message_start"
+          end
+
+          (start_usage || {}).merge(latest_delta) do |_key, start_val, delta_val|
+            delta_val || start_val
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "usage_extractor"
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      module ResponseParser
+        def self.event_from_usage(usage:,
+                                  model:,
+                                  provider_response_id:,
+                                  usage_source:,
+                                  request: nil,
+                                  pricing_mode: nil,
+                                  stream: false)
+          Event.build(
+            provider: "anthropic",
+            provider_response_id: provider_response_id,
+            pricing_mode: pricing_mode || UsageExtractor.pricing_mode(request: request, usage: usage),
+            model: model,
+            token_usage: UsageExtractor.token_usage(usage),
+            stream: stream,
+            usage_source: usage_source,
+            service_line_items: UsageExtractor.service_line_items(usage)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      module UsageExtractor
+        SERVER_TOOL_LINE_ITEMS = {
+          "web_search_request" => :web_search_requests,
+          "web_fetch_request" => :web_fetch_requests
+        }.freeze
+        DATA_RESIDENCY_GEOS = %w[us].freeze
+        private_constant :SERVER_TOOL_LINE_ITEMS, :DATA_RESIDENCY_GEOS
+
+        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)
+
+          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
+          )
+        end
+
+        def self.pricing_mode(request:, usage:)
+          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)
+          Pricing::Mode.compose(modes)
+        end
+
+        def self.service_line_items(usage)
+          server_tool_use = usage[:server_tool_use]
+          return [] unless server_tool_use.is_a?(Hash)
+
+          SERVER_TOOL_LINE_ITEMS.filter_map do |dimension_key, count_key|
+            quantity = server_tool_use[count_key].to_i
+            next if quantity.zero?
+
+            Charges::LineItem.build(
+              dimension_key: dimension_key,
+              quantity: quantity,
+              cost_status: Charges::CostStatus::UNKNOWN,
+              pricing_basis: "provider_usage",
+              provider_field: "usage.server_tool_use.#{count_key}"
+            )
+          end
+        end
+
+        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]
+          else
+            warn_unexpected_cache_creation(cache_creation, usage)
+            [usage[:cache_creation_input_tokens].to_i, 0]
+          end
+        end
+
+        def self.warn_unexpected_cache_creation(cache_creation, usage)
+          return if cache_creation.nil?
+          return if usage.key?(:cache_creation_input_tokens)
+
+          Logging.warn("Anthropic usage.cache_creation has unexpected shape: #{cache_creation.class}")
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,7 @@ module LlmCostTracker
     module Azure
       module Hosts
         OPENAI_HOST_PATTERN = /\A[a-z0-9][a-z0-9-]*\.(?:openai\.azure\.com|services\.ai\.azure\.com)\z/i
-
-        module_function
-
-        def openai?(host)
+        def self.openai?(host)
           host.to_s.match?(OPENAI_HOST_PATTERN)
         end
       end