llm_cost_tracker 0.7.0 → 0.7.2

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -1,73 +1,69 @@
 # frozen_string_literal: true
 
+require_relative "components"
+
 module LlmCostTracker
   module Pricing
-    EffectivePriceSet = Data.define(:input, :cache_read_input, :cache_write_input, :output) do
-      def to_h
-        {
-          input: input,
-          cache_read_input: cache_read_input,
-          cache_write_input: cache_write_input,
-          output: output
-        }
-      end
-
-      def complete?
-        missing_keys.empty?
-      end
-
-      def missing_keys
-        to_h.filter_map { |key, value| key if value.nil? }
-      end
-    end
-
     module EffectivePrices
       class << self
         def call(usage:, prices:, pricing_mode:)
-          EffectivePriceSet.new(
-            input: price_for_usage(usage.input_tokens, prices, :input, pricing_mode),
-            cache_read_input: price_for_cache_usage(
-              usage.cache_read_input_tokens,
-              prices,
-              :cache_read_input,
-              pricing_mode
-            ),
-            cache_write_input: price_for_cache_usage(
-              usage.cache_write_input_tokens,
-              prices,
-              :cache_write_input,
-              pricing_mode
-            ),
-            output: price_for_usage(usage.output_tokens, prices, :output, pricing_mode)
-          )
+          quantities = usage.price_quantities
+          context_tier = context_tier?(usage: usage, prices: prices)
+
+          Pricing::COMPONENTS.to_h do |component|
+            price_key = component.price_key
+            tokens = quantities.fetch(price_key)
+            price = if tokens.positive?
+                      price_for(
+                        prices: prices,
+                        key: price_key,
+                        pricing_mode: pricing_mode,
+                        context_tier: context_tier
+                      )
+                    else
+                      0.0
+                    end
+            [price_key, price]
+          end
         end
 
         private
 
-        def price_for_cache_usage(tokens, prices, key, pricing_mode)
-          return 0.0 unless tokens.positive?
+        def price_for(prices:, key:, pricing_mode:, context_tier:)
+          mode = Pricing.normalize_mode(pricing_mode)
+          return contextual_price(prices: prices, key: key, context_tier: context_tier) unless mode
 
-          price_for(prices, key, pricing_mode) || price_for(prices, :input, pricing_mode)
+          contextual_price(prices: prices, key: :"#{mode}_#{key}", context_tier: context_tier) ||
+            derived_mode_price(prices: prices, key: key, mode: mode, context_tier: context_tier)
         end
 
-        def price_for_usage(tokens, prices, key, pricing_mode)
-          tokens.positive? ? price_for(prices, key, pricing_mode) : 0.0
+        def contextual_price(prices:, key:, context_tier:)
+          return prices[key] unless context_tier
+
+          prices[:"above_context_#{key}"]
         end
 
-        def price_for(prices, key, pricing_mode)
-          mode = normalized_pricing_mode(pricing_mode)
-          return prices[key] unless mode
+        def derived_mode_price(prices:, key:, mode:, context_tier:)
+          standard_price = contextual_price(prices: prices, key: key, context_tier: context_tier)
+          return nil unless standard_price
 
-          prices[:"#{mode}_#{key}"] || prices[key]
-        end
+          base_key = key == :output ? :output : :input
+          base_price = contextual_price(prices: prices, key: base_key, context_tier: context_tier)
+          mode_base_price = contextual_price(prices: prices, key: :"#{mode}_#{base_key}", context_tier: context_tier)
+          return nil unless base_price && mode_base_price
 
-        def normalized_pricing_mode(value)
-          return nil if value.nil?
+          standard_price * (mode_base_price.to_f / base_price)
+        end
 
-          mode = value.to_s.strip
-          return nil if mode.empty? || mode == "standard"
+        def context_tier?(usage:, prices:)
+          threshold = prices[:_context_price_threshold_tokens]
+          return false unless threshold
 
-          mode
+          input_tokens = usage.input_tokens +
+                         usage.cache_read_input_tokens +
+                         usage.cache_write_input_tokens +
+                         usage.cache_write_1h_input_tokens
+          input_tokens > threshold.to_i
         end
       end
     end

data/lib/llm_cost_tracker/pricing/explainer.rb

@@ -15,9 +15,13 @@ module LlmCostTracker
       :effective_prices,
       :missing_price_keys
     ) do
-      def matched? = !prices.nil?
+      def matched?
+        !prices.nil?
+      end
 
-      def complete? = matched? && missing_price_keys.empty?
+      def complete?
+        matched? && missing_price_keys.empty?
+      end
 
       def message
         return "No price entry matched #{provider}/#{model}" unless matched?
@@ -29,48 +33,39 @@ module LlmCostTracker
 
     module Explainer
       class << self
-        def call(provider:, model:, input_tokens: 1, output_tokens: 1, cache_read_input_tokens: 0,
-                 cache_write_input_tokens: 0, pricing_mode: nil)
+        def call(provider:, model:, token_usage:, pricing_mode: nil)
           match = Lookup.call(provider: provider, model: model)
-          usage = match && UsageBreakdown.build(
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            cache_read_input_tokens: cache_read_input_tokens,
-            cache_write_input_tokens: cache_write_input_tokens
-          )
 
-          explanation(provider, model, pricing_mode, match, usage)
+          explanation(
+            provider: provider,
+            model: model,
+            pricing_mode: pricing_mode,
+            match: match,
+            usage: token_usage
+          )
         end
 
         private
 
-        def explanation(provider, model, pricing_mode, match, usage)
+        def explanation(provider:, model:, pricing_mode:, match:, usage:)
           prices = match&.prices
+          pricing_mode = Pricing.normalize_mode(pricing_mode)
           effective = if prices && usage
                         EffectivePrices.call(usage: usage, prices: prices, pricing_mode: pricing_mode)
                       end
 
           Explanation.new(
-            provider.to_s,
-            model.to_s,
-            normalized_pricing_mode(pricing_mode),
-            match&.source,
-            match&.key,
-            match&.matched_by,
-            prices,
-            effective ? effective.to_h : {},
-            effective ? effective.missing_keys : []
+            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
-
-        def normalized_pricing_mode(value)
-          return nil if value.nil?
-
-          mode = value.to_s.strip
-          return nil if mode.empty? || mode == "standard"
-
-          mode
-        end
       end
     end
   end

data/lib/llm_cost_tracker/pricing/lookup.rb

@@ -1,120 +1,141 @@
 # frozen_string_literal: true
 
-require "monitor"
-
 module LlmCostTracker
   module Pricing
     module Lookup
       Match = Data.define(:source, :key, :prices, :matched_by)
-      MUTEX = Monitor.new
+      MUTEX = Mutex.new
       CACHE_MISS = Object.new.freeze
       NO_MATCH = Object.new.freeze
       MAX_LOOKUP_CACHE_ENTRIES = 512
 
       class << self
         def call(provider:, model:)
-          provider_name = provider.to_s
+          provider_name = provider.to_s.presence
           model_name = model.to_s
-          generation = LlmCostTracker.configuration_generation
-          cache_key = [generation, provider_name, model_name]
+          cache_key = [provider_name, model_name]
           cached = cached_lookup(cache_key)
           return cached unless cached.equal?(CACHE_MISS)
 
-          provider_model = provider_name.empty? ? model_name : "#{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(generation)
+          current = current_price_tables
 
           match =
-            explain_table(current.fetch(:pricing_overrides), :pricing_overrides, provider_model, model_name,
-                          normalized_model) ||
-            explain_table(current.fetch(:file_prices), :prices_file, provider_model, model_name, normalized_model) ||
-            explain_table(Pricing::PRICES, :bundled, provider_model, model_name, normalized_model)
+            explain_table(
+              table: current.fetch(:pricing_overrides),
+              source: :pricing_overrides,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            ) ||
+            explain_table(
+              table: current.fetch(:file_prices),
+              source: :prices_file,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            ) ||
+            explain_table(
+              table: Registry.builtin_prices,
+              source: :bundled,
+              provider_model: provider_model,
+              model_name: model_name,
+              normalized_model: normalized_model
+            )
           cache_lookup(cache_key, match)
           match
         end
 
+        def reset!
+          MUTEX.synchronize do
+            @prices_cache = nil
+            @lookup_cache = nil
+            @sorted_price_keys_cache = nil
+          end
+        end
+
         private
 
-        def current_price_tables(generation)
+        def current_price_tables
           cached = @prices_cache
-          return cached[:value] if cached && cached[:generation] == generation
+          return cached if cached
 
           MUTEX.synchronize do
             cached = @prices_cache
-            return cached[:value] if cached && cached[:generation] == generation
+            return cached if cached
 
             config = LlmCostTracker.configuration
-            file_prices = PriceRegistry.file_prices(config.prices_file)
-            overrides = PriceRegistry.normalize_price_table(config.pricing_overrides)
+            file_prices = Registry.file_prices(config.prices_file)
+            overrides = Registry.normalize_price_table(config.pricing_overrides)
             value = { pricing_overrides: overrides, file_prices: file_prices }.freeze
-            @prices_cache = { generation: generation, value: value }.freeze
+            @prices_cache = value
             value
           end
         end
 
         def cached_lookup(cache_key)
           cached = @lookup_cache
-          return CACHE_MISS unless cached && cached[:generation] == cache_key.first
-          return CACHE_MISS unless cached[:values].key?(cache_key)
+          return CACHE_MISS unless cached&.key?(cache_key)
 
-          match = cached[:values].fetch(cache_key)
+          match = cached.fetch(cache_key)
           match.equal?(NO_MATCH) ? nil : match
         end
 
         def cache_lookup(cache_key, match)
           MUTEX.synchronize do
-            cached = @lookup_cache
-            values = if cached && cached[:generation] == cache_key.first
-                       cached[:values].dup
-                     else
-                       {}
-                     end
+            values = (@lookup_cache || {}).dup
             values.clear if values.size >= MAX_LOOKUP_CACHE_ENTRIES
             values[cache_key] = match || NO_MATCH
-            @lookup_cache = { generation: cache_key.first, values: values.freeze }.freeze
+            @lookup_cache = values.freeze
           end
         end
 
-        def explain_table(table, source, provider_model, model_name, normalized_model)
+        def explain_table(table:, source:, provider_model:, model_name:, normalized_model:)
           return nil if table.empty?
 
-          direct_match(table, source, provider_model, :provider_model) ||
-            direct_match(table, source, model_name, :model) ||
-            direct_match(table, source, normalized_model, :normalized_model) ||
-            unique_providerless_lookup(normalized_model, table, source) ||
-            fuzzy_match(provider_model, normalized_model, table, source) ||
-            unique_providerless_fuzzy_match(normalized_model, table, source)
+          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)
+        def unique_providerless_lookup(model:, table:, source:)
           matches = sorted_price_keys(table).select { |key| normalize_model_name(key) == model }
-          match(table, source, matches.first, :unique_providerless_model) if matches.one?
+          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)
+        def fuzzy_match(model:, normalized_model:, table:, source:)
           sorted_price_keys(table).each do |key|
-            return match(table, source, key, :dated_snapshot) if snapshot_variant?(model, key) ||
-                                                                 snapshot_variant?(normalized_model, 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)
+        def unique_providerless_fuzzy_match(model:, table:, source:)
           matches = sorted_price_keys(table).select { |key| snapshot_variant?(model, normalize_model_name(key)) }
-          match(table, source, matches.first, :unique_providerless_dated_snapshot) if matches.one?
+          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, source, key, matched_by) if table.key?(key)
+        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.to_s, key, table[key], matched_by.to_s)
+        def match(table:, source:, key:, matched_by:)
+          Match.new(source: source.to_s, key: key, prices: table[key], matched_by: matched_by.to_s)
         end
 
         def snapshot_variant?(model, key)

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+require_relative "components"
+require_relative "../logging"
+
+module LlmCostTracker
+  module Pricing
+    module Registry
+      DEFAULT_PRICES_PATH = File.expand_path("../prices.json", __dir__)
+      EMPTY_PRICES = {}.freeze
+      PRICE_KEYS = Pricing::COMPONENTS.map { |component| component.price_key.to_s }.freeze
+      METADATA_KEYS = %w[
+        _source _source_version _fetched_at _updated _notes _validator_override
+        _context_price_threshold_tokens
+      ].freeze
+      MAX_FILE_BYTES = 2_097_152
+      MUTEX = Mutex.new
+
+      class << self
+        def builtin_prices
+          cached = @builtin_prices
+          return cached if cached
+
+          value = normalize_price_table(raw_registry.fetch("models", {})).freeze
+          MUTEX.synchronize { @builtin_prices ||= value }
+        end
+
+        def metadata
+          cached = @metadata
+          return cached if cached
+
+          value = raw_registry.fetch("metadata", {}).freeze
+          MUTEX.synchronize { @metadata ||= value }
+        end
+
+        def file_metadata(path)
+          return {} unless path
+
+          registry = load_price_file(path.to_s)
+          raise ArgumentError, "prices_file must be a hash" unless registry.is_a?(Hash)
+
+          metadata = registry.fetch("metadata", {})
+          raise ArgumentError, "prices_file metadata must be a hash" unless metadata.is_a?(Hash)
+
+          metadata
+        rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+          raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+        end
+
+        def normalize_price_table(table)
+          normalize_price_entries(table, context: "price table")
+        end
+
+        def file_prices(path)
+          return EMPTY_PRICES unless path
+
+          path = path.to_s
+          cache_key = [path, File.mtime(path).to_f]
+          cached = @file_prices_cache
+          return cached[:value] if cached && cached[:key] == cache_key
+
+          MUTEX.synchronize do
+            cached = @file_prices_cache
+            return cached[:value] if cached && cached[:key] == cache_key
+
+            value = normalize_price_entries(price_file_models(load_price_file(path)), context: path).freeze
+            @file_prices_cache = { key: cache_key, value: value }.freeze
+            value
+          end
+        rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+          raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+        end
+
+        private
+
+        def raw_registry
+          cached = @raw_registry
+          return cached if cached
+
+          MUTEX.synchronize { @raw_registry ||= JSON.parse(File.read(DEFAULT_PRICES_PATH)).freeze }
+        end
+
+        def normalize_price_entry(price)
+          price.each_with_object({}) do |(key, value), normalized|
+            key = key.to_s
+            if price_key?(key)
+              normalized[key.to_sym] = Float(value)
+            elsif key == "_context_price_threshold_tokens"
+              normalized[key.to_sym] = Integer(value)
+            end
+          end
+        end
+
+        def normalize_price_entries(table, context:)
+          table = {} if table.nil?
+          raise ArgumentError, "#{context} must be a hash of models" unless table.is_a?(Hash)
+
+          table.each_with_object({}) do |(model, price), normalized|
+            price = validate_price_entry(price, model: model, context: context)
+            warn_unknown_keys(model, price, context)
+            normalized[model.to_s] = normalize_price_entry(price)
+          end
+        end
+
+        def warn_unknown_keys(model, price, path)
+          unknown_keys = price.keys.map(&:to_s).reject do |key|
+            price_key?(key) || METADATA_KEYS.include?(key)
+          end
+          return if unknown_keys.empty?
+
+          Logging.warn(
+            "Unknown price keys #{unknown_keys.inspect} for #{model.inspect} in #{path}; " \
+            "ignored. Known keys: #{(PRICE_KEYS + METADATA_KEYS).inspect}; mode-specific keys use mode_input"
+          )
+        end
+
+        def price_key?(key)
+          return true if PRICE_KEYS.include?(key)
+
+          PRICE_KEYS.any? do |base_key|
+            key.end_with?("_#{base_key}") && key.delete_suffix("_#{base_key}") != ""
+          end
+        end
+
+        def load_price_file(path)
+          raise ArgumentError, "prices_file exceeds #{MAX_FILE_BYTES} bytes" if File.size(path) > MAX_FILE_BYTES
+
+          contents = File.read(path)
+          return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)
+
+          JSON.parse(contents)
+        end
+
+        def yaml_file?(path)
+          %w[.yaml .yml].include?(File.extname(path).downcase)
+        end
+
+        def price_file_models(registry)
+          raise ArgumentError, "prices_file must be a hash" unless registry.is_a?(Hash)
+
+          registry.fetch("models", registry)
+        end
+
+        def validate_price_entry(price, model:, context:)
+          return {} if price.nil?
+          return price if price.is_a?(Hash)
+
+          raise ArgumentError, "price entry for #{model.inspect} in #{context} must be a hash"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+require "digest"
+require "net/http"
+require "openssl"
+require "time"
+require "uri"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      class Fetcher
+        Response = Data.define(:body, :etag, :last_modified, :not_modified, :fetched_at) do
+          def source_version
+            etag || last_modified || Digest::SHA256.hexdigest(body.to_s)
+          end
+        end
+
+        USER_AGENT = "llm_cost_tracker price refresh"
+        MAX_REDIRECTS = 5
+        MAX_BODY_BYTES = 2_097_152
+        OPEN_TIMEOUT = 5
+        READ_TIMEOUT = 10
+        WRITE_TIMEOUT = 10
+
+        def get(url, etag: nil, redirects: 0)
+          raise Error, "Too many redirects while fetching #{url}" if redirects > MAX_REDIRECTS
+
+          uri = URI.parse(url)
+          raise Error, "Pricing snapshot URL must use https" unless uri.scheme == "https"
+
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = USER_AGENT
+          request["If-None-Match"] = etag if etag
+
+          response, body = fetch_response(uri, request)
+
+          case response
+          when Net::HTTPSuccess
+            build_response(response, body: body || limited_body(response), not_modified: false)
+          when Net::HTTPNotModified
+            build_response(response, body: nil, not_modified: true)
+          when Net::HTTPRedirection
+            location = response["location"]
+            raise Error, "Redirect without location while fetching #{url}" if location.blank?
+
+            get(URI.join(url, location).to_s, etag: etag, redirects: redirects + 1)
+          else
+            raise Error, "Unable to fetch #{url}: HTTP #{response.code}"
+          end
+        rescue OpenSSL::SSL::SSLError, SocketError, SystemCallError, Timeout::Error => e
+          raise Error, "Unable to fetch #{url}: #{e.class}: #{e.message}"
+        end
+
+        private
+
+        def fetch_response(uri, request)
+          body = nil
+          response = Net::HTTP.start(
+            uri.host,
+            uri.port,
+            use_ssl: uri.scheme == "https",
+            open_timeout: OPEN_TIMEOUT,
+            read_timeout: READ_TIMEOUT,
+            write_timeout: WRITE_TIMEOUT
+          ) do |http|
+            http.request(request) do |streamed_response|
+              body = limited_body(streamed_response) if streamed_response.is_a?(Net::HTTPSuccess)
+            end
+          end
+
+          [response, body]
+        end
+
+        def limited_body(response)
+          body = +""
+          if response.respond_to?(:read_body)
+            response.read_body do |chunk|
+              chunk = chunk.to_s
+              if body.bytesize + chunk.bytesize > MAX_BODY_BYTES
+                raise Error, "Pricing snapshot response exceeds #{MAX_BODY_BYTES} bytes"
+              end
+
+              body << chunk
+            end
+          else
+            body = response.body.to_s
+          end
+          raise Error, "Pricing snapshot response exceeds #{MAX_BODY_BYTES} bytes" if body.bytesize > MAX_BODY_BYTES
+
+          body
+        end
+
+        def build_response(response, not_modified:, body: response.body)
+          Response.new(
+            body: body,
+            etag: response["etag"],
+            last_modified: response["last-modified"],
+            not_modified: not_modified,
+            fetched_at: Time.now.utc.iso8601
+          )
+        end
+      end
+    end
+  end
+end