llm_cost_tracker 0.10.0 → 0.12.0

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.normalize_mode(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/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,134 +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)
-      return if diff.unmatched_provider_rows.empty?
-
-      output.puts "  unmatched provider rows#{truncation_suffix(diff.unmatched_provider_rows.size,
-                                                                diff.unmatched_provider_rows_total)}:"
-      diff.unmatched_provider_rows.each do |row|
-        output.puts "    #{row[:external_id]} (#{row[:match_basis]}): " \
-                    "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
-      end
-    end
-
-    def print_unmatched_local_calls(diff, output)
-      return if diff.unmatched_local_calls.empty?
-
-      output.puts "  unmatched local calls#{truncation_suffix(diff.unmatched_local_calls.size,
-                                                              diff.unmatched_local_calls_total)}:"
-      diff.unmatched_local_calls.each do |row|
-        output.puts "    #{row[:count]} calls / #{row[:total_cost].to_s('F')} " \
-                    "#{format_attribution(row[:attribution])}"
-      end
-    end
-
-    def print_non_cost_rows(diff, output)
-      return if diff.non_cost_rows.empty?
-
-      output.puts "  non-cost evidence#{truncation_suffix(diff.non_cost_rows.size,
-                                                          diff.non_cost_rows_total)}:"
-      diff.non_cost_rows.each do |row|
-        output.puts "    [#{row[:row_type]}/#{row[:meter]}] #{format_amount(row[:billed_amount])} " \
-                    "#{format_attribution(row[:attribution])}"
-      end
-    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