llm_cost_tracker 0.11.0 → 0.12.0

data/lib/llm_cost_tracker/pricing/explainer.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../token_usage"
-require_relative "effective_prices"
-
-module LlmCostTracker
-  module Pricing
-    Explanation = Data.define(
-      :provider,
-      :model,
-      :pricing_mode,
-      :source,
-      :matched_key,
-      :matched_by,
-      :prices,
-      :effective_prices,
-      :missing_price_keys
-    ) do
-      def matched?
-        !prices.nil?
-      end
-
-      def complete?
-        matched? && missing_price_keys.empty?
-      end
-
-      def message
-        return "No price entry matched #{provider}/#{model}" unless matched?
-        return "Matched #{matched_key} from #{source} via #{matched_by}" if complete?
-
-        "Matched #{matched_key} from #{source} via #{matched_by}, but missing #{missing_price_keys.join(', ')}"
-      end
-    end
-
-    module Explainer
-      class << self
-        def call(provider:, model:, tokens:, pricing_mode: nil)
-          match = Lookup.call(provider: provider, model: model)
-
-          explanation(
-            provider: provider,
-            model: model,
-            pricing_mode: pricing_mode,
-            match: match,
-            usage: TokenUsage.build_from_tokens(tokens)
-          )
-        end
-
-        private
-
-        def explanation(provider:, model:, pricing_mode:, match:, usage:)
-          prices = match&.prices
-          pricing_mode = Pricing::Mode.normalize(pricing_mode)
-          effective = if prices
-                        EffectivePrices.call(usage: usage, quantities: usage.priced_quantities,
-                                             prices: prices, pricing_mode: pricing_mode)
-                      end
-
-          Explanation.new(
-            provider: provider.to_s,
-            model: model.to_s,
-            pricing_mode: pricing_mode,
-            source: match&.source,
-            matched_key: match&.key,
-            matched_by: match&.matched_by,
-            prices: prices,
-            effective_prices: effective || {},
-            missing_price_keys: effective ? effective.filter_map { |key, value| key if value.nil? } : []
-          )
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/pricing/lookup.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Pricing
-    module Lookup
-      Match = Data.define(:source, :key, :prices, :matched_by, :currency)
-      DEFAULT_CURRENCY = "USD"
-      MUTEX = Mutex.new
-      CACHE_MISS = Object.new.freeze
-      NO_MATCH = Object.new.freeze
-      LOOKUP_CACHE_LIMIT = 2_048
-      PRICE_FILE_RECHECK_INTERVAL = 1.0
-      private_constant :PRICE_FILE_RECHECK_INTERVAL
-
-      class << self
-        def call(provider:, model:)
-          provider_name = provider.to_s.presence
-          model_name = model.to_s
-          return nil if model_name.empty?
-
-          invalidate_cache_if_prices_file_changed!
-
-          cache_key = [provider_name, model_name]
-          cached = cached_lookup(cache_key)
-          return cached unless cached.equal?(CACHE_MISS)
-
-          match = lookup_match(provider_name: provider_name, model_name: model_name)
-          cache_lookup(cache_key, match)
-          match
-        end
-
-        def reset!
-          MUTEX.synchronize do
-            reset_prices_caches!(signature: nil)
-            @prices_file_last_check_at = nil
-          end
-        end
-
-        def prices_file_mtime_iso
-          invalidate_cache_if_prices_file_changed!
-          signature = @prices_file_signature
-          return nil unless signature
-
-          cached = @prices_file_iso_cache
-          return cached[:value] if cached && cached[:mtime] == signature
-
-          MUTEX.synchronize do
-            cached = @prices_file_iso_cache
-            return cached[:value] if cached && cached[:mtime] == signature
-
-            iso = signature.utc.iso8601
-            @prices_file_iso_cache = { mtime: signature, value: iso }.freeze
-            iso
-          end
-        end
-
-        private
-
-        def invalidate_cache_if_prices_file_changed!
-          path = LlmCostTracker.configuration.prices_file
-
-          unless path
-            return if @prices_file_signature.nil?
-
-            MUTEX.synchronize { reset_prices_caches!(signature: nil) unless @prices_file_signature.nil? }
-            return
-          end
-
-          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          last_check = @prices_file_last_check_at
-          return if last_check && (now - last_check) < PRICE_FILE_RECHECK_INTERVAL
-
-          signature = File.exist?(path) ? File.mtime(path) : nil
-          MUTEX.synchronize do
-            @prices_file_last_check_at = now
-            reset_prices_caches!(signature: signature) if @prices_file_signature != signature
-          end
-        end
-
-        def reset_prices_caches!(signature:)
-          @prices_cache = nil
-          @lookup_cache = nil
-          @sorted_price_keys_cache = nil
-          @prices_file_iso_cache = nil
-          @prices_file_signature = signature
-        end
-
-        def lookup_match(provider_name:, model_name:)
-          provider_model = provider_name ? "#{provider_name}/#{model_name}" : model_name
-          normalized_model = normalize_model_name(model_name)
-          current = current_price_tables
-
-          ordered_table_lookups(current).each do |source, table|
-            match = explain_table(
-              table: table,
-              source: source,
-              provider_model: provider_model,
-              model_name: model_name,
-              normalized_model: normalized_model
-            )
-            return match if match
-          end
-          nil
-        end
-
-        def ordered_table_lookups(current)
-          [
-            [:pricing_overrides, current.fetch(:pricing_overrides)],
-            [:prices_file, current.fetch(:file_prices)],
-            [:bundled, Registry.builtin_prices]
-          ]
-        end
-
-        def current_price_tables
-          cached = @prices_cache
-          return cached if cached
-
-          MUTEX.synchronize do
-            cached = @prices_cache
-            return cached if cached
-
-            config = LlmCostTracker.configuration
-            file_prices = Registry.file_prices(config.prices_file)
-            value = { pricing_overrides: config.pricing_overrides, file_prices: file_prices }.freeze
-            @prices_cache = value
-            value
-          end
-        end
-
-        def cached_lookup(cache_key)
-          cached = @lookup_cache
-          return CACHE_MISS unless cached&.key?(cache_key)
-
-          match = cached.fetch(cache_key)
-          match.equal?(NO_MATCH) ? nil : match
-        end
-
-        def cache_lookup(cache_key, match)
-          MUTEX.synchronize do
-            values = (@lookup_cache || {}).dup
-            values.shift while values.size >= LOOKUP_CACHE_LIMIT
-            values[cache_key] = match || NO_MATCH
-            @lookup_cache = values.freeze
-          end
-        end
-
-        def explain_table(table:, source:, provider_model:, model_name:, normalized_model:)
-          return nil if table.empty?
-
-          direct_match(table: table, source: source, key: provider_model, matched_by: :provider_model) ||
-            direct_match(table: table, source: source, key: model_name, matched_by: :model) ||
-            direct_match(table: table, source: source, key: normalized_model, matched_by: :normalized_model) ||
-            unique_providerless_lookup(model: normalized_model, table: table, source: source) ||
-            fuzzy_match(model: provider_model, normalized_model: normalized_model, table: table, source: source) ||
-            unique_providerless_fuzzy_match(model: normalized_model, table: table, source: source)
-        end
-
-        def normalize_model_name(model)
-          model.to_s.split("/").last
-        end
-
-        def unique_providerless_lookup(model:, table:, source:)
-          matches = sorted_price_keys(table).select { |key| normalize_model_name(key) == model }
-          return unless matches.one?
-
-          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_model)
-        end
-
-        def fuzzy_match(model:, normalized_model:, table:, source:)
-          sorted_price_keys(table).each do |key|
-            if snapshot_variant?(model, key) || snapshot_variant?(normalized_model, key)
-              return match(table: table, source: source, key: key, matched_by: :dated_snapshot)
-            end
-          end
-
-          nil
-        end
-
-        def unique_providerless_fuzzy_match(model:, table:, source:)
-          matches = sorted_price_keys(table).select { |key| snapshot_variant?(model, normalize_model_name(key)) }
-          return unless matches.one?
-
-          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_dated_snapshot)
-        end
-
-        def direct_match(table:, source:, key:, matched_by:)
-          match(table: table, source: source, key: key, matched_by: matched_by) if table.key?(key)
-        end
-
-        def match(table:, source:, key:, matched_by:)
-          Match.new(
-            source: source,
-            key: key,
-            prices: table[key],
-            matched_by: matched_by,
-            currency: source_currency(source)
-          )
-        end
-
-        def source_currency(source)
-          case source
-          when :bundled then Registry.metadata["currency"] || DEFAULT_CURRENCY
-          when :prices_file
-            Registry.file_metadata(LlmCostTracker.configuration.prices_file)["currency"] || DEFAULT_CURRENCY
-          else DEFAULT_CURRENCY
-          end
-        end
-
-        def snapshot_variant?(model, key)
-          suffix = model.delete_prefix("#{key}-")
-          return false if suffix == model
-
-          suffix.match?(/\A(?:\d{4}-\d{2}-\d{2}|\d{8})\z/)
-        end
-
-        def sorted_price_keys(table)
-          cached = @sorted_price_keys_cache
-          existing = cached && cached[table]
-          return existing if existing
-
-          MUTEX.synchronize do
-            cached = @sorted_price_keys_cache
-            existing = cached && cached[table]
-            return existing if existing
-
-            keys = table.keys.sort_by { |key| -key.length }
-            next_cache = cached ? cached.dup : {}.compare_by_identity
-            next_cache[table] = keys
-            @sorted_price_keys_cache = next_cache.freeze
-            keys
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/pricing/service_charges.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/blank"
-require "bigdecimal"
-require "time"
-require "yaml"
-
-require_relative "../billing/components"
-require_relative "registry"
-
-module LlmCostTracker
-  module Pricing
-    module ServiceCharges
-      extend self
-
-      DEFAULT_CURRENCY = "USD"
-      EMPTY_RATES = {}.freeze
-      MUTEX = Mutex.new
-
-      def reset!
-        MUTEX.synchronize do
-          @builtin_rates = nil
-          @file_rates_cache = nil
-        end
-      end
-
-      def builtin_rates
-        cached = @builtin_rates
-        return cached if cached
-
-        MUTEX.synchronize do
-          @builtin_rates ||= begin
-            registry = YAML.safe_load_file(Registry::DEFAULT_PRICES_PATH, aliases: false) || {}
-            rates_from_registry(registry).freeze
-          end
-        end
-      end
-
-      def file_rates(path)
-        return EMPTY_RATES unless path
-
-        cache_key = [path, File.mtime(path)]
-        cached = @file_rates_cache
-        return cached[:value] if cached && cached[:key] == cache_key
-
-        MUTEX.synchronize do
-          cached = @file_rates_cache
-          return cached[:value] if cached && cached[:key] == cache_key
-
-          registry = YAML.safe_load_file(path, aliases: false) || {}
-          value = rates_from_registry(registry, context: path).freeze
-          @file_rates_cache = { key: cache_key, value: value }.freeze
-          value
-        end
-      rescue Errno::ENOENT, Psych::Exception, ArgumentError, TypeError => e
-        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
-      end
-
-      def rates_from_registry(registry, context: "price registry")
-        data = registry.fetch("service_charges", EMPTY_RATES)
-        raise ArgumentError, "#{context} service_charges must be a hash" unless data.is_a?(Hash)
-
-        currency = registry.dig("metadata", "currency") || DEFAULT_CURRENCY
-        data.each_with_object({}) do |(provider, entries), rates|
-          section_context = "#{context} service_charges.#{provider}"
-          rates[provider] = rates_from_section(entries, currency: currency, context: section_context)
-        end
-      end
-
-      def charge_rate(provider:, component:, pricing_mode:)
-        pricing_mode = Pricing::Mode.normalize(pricing_mode)
-        match = charge_rate_match(provider: provider, component: component, pricing_mode: pricing_mode)
-        return nil unless match
-
-        rate = match.fetch(:rate)
-        {
-          amount: rate.fetch(:amount),
-          quantity: rate.fetch(:quantity),
-          currency: rate.fetch(:currency),
-          source: match.fetch(:source),
-          source_key: match.fetch(:key),
-          source_version: rate_source_version_for(match.fetch(:source))
-        }
-      end
-
-      private
-
-      def rates_from_section(entries, currency:, context:)
-        raise ArgumentError, "#{context} must be a hash" unless entries.is_a?(Hash)
-
-        entries.each_with_object({}) do |(key, amount), rates|
-          key = key.name if key.is_a?(Symbol)
-          component, tier = component_and_tier_for(key, context: context)
-          amount = amount_for(key, amount, context: context)
-
-          rate = {
-            amount: amount,
-            quantity: rate_quantity(component),
-            currency: currency,
-            source_key: key
-          }
-          component_rates = rates[component.key] ||= { tiers: {} }
-          (tier ? component_rates[:tiers] : component_rates)[tier || :default] = rate
-        end
-      end
-
-      def component_and_tier_for(key, context:)
-        Billing::Components::REGISTRY.each do |component|
-          next if component.token_key
-
-          return [component, nil] if key == component.key.name
-
-          suffix = "_#{component.key.name}"
-          next unless key.end_with?(suffix)
-
-          tier = key.delete_suffix(suffix)
-          return [component, :"#{tier}"] unless tier.empty?
-        end
-
-        raise ArgumentError, "service charge price key #{key.inspect} in #{context} uses unknown billing component"
-      end
-
-      def amount_for(key, amount, context:)
-        value = BigDecimal(amount.to_s)
-        if value.infinite? || value.nan?
-          raise ArgumentError,
-                "service charge price amount for #{key.inspect} in #{context} must be finite"
-        end
-        if value.negative?
-          raise ArgumentError,
-                "service charge price amount for #{key.inspect} in #{context} must be non-negative"
-        end
-
-        value
-      end
-
-      def rate_quantity(component)
-        BigDecimal(Billing::RATE_BASIS_QUANTITIES.fetch(component.rate_basis, 1).to_s)
-      end
-
-      def charge_rate_match(provider:, component:, pricing_mode:)
-        provider_name = provider.is_a?(Symbol) ? provider.name : provider.presence
-        return nil unless provider_name
-
-        component_key = charge_component_key(component)
-
-        table = ServiceCharges.file_rates(LlmCostTracker.configuration.prices_file)
-        provider_table = table.fetch(provider_name, EMPTY_RATES)
-        rate = rate_for(provider_table, component_key: component_key, pricing_mode: pricing_mode)
-        if rate
-          return {
-            source: :prices_file,
-            key: "service_charges.#{provider_name}.#{rate.fetch(:source_key)}",
-            rate: rate
-          }
-        end
-
-        table = ServiceCharges.builtin_rates
-        provider_table = table.fetch(provider_name, EMPTY_RATES)
-        rate = rate_for(provider_table, component_key: component_key, pricing_mode: pricing_mode)
-        return unless rate
-
-        {
-          source: :bundled,
-          key: "service_charges.#{provider_name}.#{rate.fetch(:source_key)}",
-          rate: rate
-        }
-      end
-
-      def rate_for(provider_table, component_key:, pricing_mode:)
-        component_rates = provider_table.fetch(component_key, EMPTY_RATES)
-        tier_rates = component_rates.fetch(:tiers, EMPTY_RATES)
-        if pricing_mode
-          rate = tier_rates[pricing_mode]
-          return rate if rate
-
-          name = pricing_mode.name
-          tier_rates.each do |candidate, candidate_rate|
-            return candidate_rate if tier_includes?(name, candidate.name)
-          end
-        end
-        component_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_component_key(component)
-        billing_component = Billing::Components::BY_KEY[component]
-        return billing_component.key if billing_component && billing_component.token_key.nil?
-
-        raise Error, "Unknown billing component: #{component.inspect}"
-      end
-
-      def rate_source_version_for(source)
-        return LlmCostTracker::VERSION if source == :bundled
-
-        Lookup.prices_file_mtime_iso
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Providers
-    module Anthropic
-      module ServerTools
-        LINE_ITEMS = {
-          web_search_request: :web_search_requests,
-          web_fetch_request: :web_fetch_requests,
-          code_execution_request: :code_execution_requests
-        }.freeze
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Providers
-    module Anthropic
-      module TierClassification
-        DATA_RESIDENCY_GEOS = %w[us].freeze
-        STANDARD_EQUIVALENT_SERVICE_TIERS = %w[standard standard_only priority].freeze
-
-        module_function
-
-        def data_residency_geo?(geo)
-          DATA_RESIDENCY_GEOS.include?(geo.to_s.downcase)
-        end
-
-        def standard_equivalent_tier?(service_tier)
-          STANDARD_EQUIVALENT_SERVICE_TIERS.include?(service_tier.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/reconcile_tasks.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-require_relative "reconciliation"
-
-module LlmCostTracker
-  module ReconcileTasks
-    SOURCE_PARSERS = {
-      "openai" => Reconciliation::Sources::OpenaiUsage,
-      "anthropic" => Reconciliation::Sources::AnthropicUsage
-    }.freeze
-    GENERIC_SOURCES = %w[csv].freeze
-
-    module_function
-
-    def run_import(env: ENV, output: $stdout, error_output: $stderr)
-      result = import_from_env(env: env)
-      output.puts "llm_cost_tracker: imported #{result.total_imported} rows " \
-                  "(inserted=#{result.inserted}, updated=#{result.updated}, skipped=#{result.skipped})"
-      result.errors.each { |error| error_output.puts "  error: #{error}" }
-      raise "llm_cost_tracker: reconcile import had errors" unless result.success?
-
-      result
-    end
-
-    def run_diff(env: ENV, output: $stdout)
-      diff = diff_from_env(env: env)
-      print_diff(diff, output: output)
-      diff
-    end
-
-    def import_from_env(env: ENV)
-      source = required_env(env, "SOURCE")
-      input_path = required_env(env, "INPUT")
-      raise ArgumentError, "INPUT file not found: #{input_path}" unless File.exist?(input_path)
-
-      payload = JSON.parse(File.read(input_path))
-      rows = parse_rows(source: source, payload: payload)
-      Reconciliation.import(source: source.to_sym, rows: rows, provider: env["PROVIDER"])
-    end
-
-    def diff_from_env(env: ENV)
-      source = required_env(env, "SOURCE")
-      period_start = Date.parse(required_env(env, "PERIOD_START"))
-      period_end = Date.parse(required_env(env, "PERIOD_END"))
-      Reconciliation.diff(source: source.to_sym, period_start: period_start, period_end: period_end,
-                          provider: env["PROVIDER"],
-                          drilldown_limit: parse_drilldown_limit(env["DRILLDOWN_LIMIT"]))
-    end
-
-    def parse_drilldown_limit(value)
-      return Reconciliation::Diff::DEFAULT_DRILLDOWN_LIMIT if value.nil? || value.to_s.empty?
-      return nil if value.to_s.downcase == "all"
-
-      Integer(value)
-    end
-
-    def print_diff(diff, output: $stdout)
-      output.puts "llm_cost_tracker: reconciliation diff for #{diff.source} " \
-                  "#{diff.period_start}..#{diff.period_end}"
-      output.puts "  provider_total: #{diff.provider_total.to_s('F')} #{diff.currency}"
-      output.puts "  local_total:    #{diff.local_total.to_s('F')} #{diff.currency} " \
-                  "(from #{diff.local_total_source})"
-      output.puts "  delta:          #{diff.delta_amount.to_s('F')} (#{diff.delta_percent || 'n/a'}%)"
-      print_unmatched_provider_rows(diff, output)
-      print_unmatched_local_calls(diff, output)
-      print_non_cost_rows(diff, output)
-    end
-
-    def parse_rows(source:, payload:)
-      parser = SOURCE_PARSERS[source.to_s]
-      return parser.parse(payload) if parser
-      return Array(payload["rows"]) if GENERIC_SOURCES.include?(source.to_s)
-
-      known = (SOURCE_PARSERS.keys + GENERIC_SOURCES).join(", ")
-      raise ArgumentError, "unknown SOURCE #{source.inspect}; known sources: #{known}"
-    end
-
-    def required_env(env, key)
-      value = env[key].to_s.strip
-      raise ArgumentError, "missing #{key}" if value.empty?
-
-      value
-    end
-
-    def print_unmatched_provider_rows(diff, output)
-      print_section(output, "unmatched provider rows",
-                    diff.unmatched_provider_rows, diff.unmatched_provider_rows_total) do |row|
-        "#{row[:external_id]} (#{row[:match_basis]}): " \
-          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
-      end
-    end
-
-    def print_unmatched_local_calls(diff, output)
-      print_section(output, "unmatched local calls",
-                    diff.unmatched_local_calls, diff.unmatched_local_calls_total) do |row|
-        "#{row[:count]} calls / #{row[:total_cost].to_s('F')} #{format_attribution(row[:attribution])}"
-      end
-    end
-
-    def print_non_cost_rows(diff, output)
-      print_section(output, "non-cost evidence",
-                    diff.non_cost_rows, diff.non_cost_rows_total) do |row|
-        "[#{row[:row_type]}/#{row[:meter]}] " \
-          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
-      end
-    end
-
-    def print_section(output, label, rows, total)
-      return if rows.empty?
-
-      output.puts "  #{label}#{truncation_suffix(rows.size, total)}:"
-      rows.each { |row| output.puts "    #{yield(row)}" }
-    end
-
-    def truncation_suffix(shown, total)
-      return "" if shown >= total
-
-      " (showing #{shown} of #{total} — pass DRILLDOWN_LIMIT=all to see every row)"
-    end
-
-    def format_amount(value)
-      value.nil? ? "n/a" : value.to_s("F")
-    end
-
-    def format_attribution(attribution)
-      LlmCostTracker::Masking.format_attribution(attribution, separator: ",")
-    end
-  end
-end