llm_cost_tracker 0.7.0 → 0.7.1

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -1,73 +1,63 @@
 # 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, prices)
+
+          Pricing::COMPONENTS.to_h do |component|
+            price_key = component.price_key
+            tokens = quantities.fetch(price_key)
+            price = tokens.positive? ? price_for(prices, price_key, pricing_mode, context_tier) : 0.0
+            [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, key, context_tier) unless mode
 
-          price_for(prices, key, pricing_mode) || price_for(prices, :input, pricing_mode)
+          contextual_price(prices, :"#{mode}_#{key}", context_tier) ||
+            derived_batch_price(prices, key, mode, 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_batch_price(prices, key, mode, context_tier)
+          return nil unless mode == "batch"
 
-          prices[:"#{mode}_#{key}"] || prices[key]
-        end
+          standard_price = contextual_price(prices, key, context_tier)
+          return nil unless standard_price
+
+          base_key = key == :output ? :output : :input
+          batch_key = key == :output ? :batch_output : :batch_input
+          base_price = contextual_price(prices, base_key, context_tier)
+          batch_price = contextual_price(prices, batch_key, context_tier)
+          return nil unless base_price && batch_price
 
-        def normalized_pricing_mode(value)
-          return nil if value.nil?
+          standard_price * (batch_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,23 +33,17 @@ 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, model, pricing_mode, match, token_usage)
         end
 
         private
 
         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
@@ -53,24 +51,15 @@ module LlmCostTracker
           Explanation.new(
             provider.to_s,
             model.to_s,
-            normalized_pricing_mode(pricing_mode),
+            pricing_mode,
             match&.source,
             match&.key,
             match&.matched_by,
             prices,
-            effective ? effective.to_h : {},
-            effective ? effective.missing_keys : []
+            effective || {},
+            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,77 +1,76 @@
 # 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(Registry.builtin_prices, :bundled, provider_model, model_name, 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
 

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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      module RegistryDiff
+        class << self
+          def call(current_models, updated_models)
+            current_models = normalize_models(current_models)
+            updated_models = normalize_models(updated_models)
+
+            (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
+          end
+
+          private
+
+          def price_field_changes(current_entry, updated_entry)
+            current_price = comparable_price(current_entry)
+            updated_price = comparable_price(updated_entry)
+
+            (current_price.keys | updated_price.keys).sort.each_with_object({}) do |field, changes|
+              from = current_price[field]
+              to = updated_price[field]
+              next if from == to
+
+              changes[field] = { "from" => from, "to" => to }
+            end
+          end
+
+          def comparable_price(entry)
+            normalize_hash(entry).slice(*Registry::PRICE_KEYS)
+          end
+
+          def normalize_models(models)
+            normalize_hash(models).transform_values { |entry| normalize_hash(entry) }
+          end
+
+          def normalize_hash(hash)
+            return {} if hash.nil?
+            raise Error, "pricing entries must be hashes" unless hash.is_a?(Hash)
+
+            hash.each_with_object({}) do |(key, value), normalized|
+              normalized[key.to_s] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+require_relative "../registry"
+
+module LlmCostTracker
+  module Pricing
+    module Sync
+      class RegistryLoader
+        YAML_EXTENSIONS = %w[.yml .yaml].freeze
+
+        def call(path:, seed_path:)
+          source_path = File.exist?(path.to_s) ? path.to_s : seed_path.to_s
+          normalize_registry(load_registry_file(source_path))
+        rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+          raise Error, "Unable to load pricing registry #{source_path.inspect}: #{e.message}"
+        end
+
+        private
+
+        def load_registry_file(path)
+          if File.size(path) > Registry::MAX_FILE_BYTES
+            raise ArgumentError, "pricing registry exceeds #{Registry::MAX_FILE_BYTES} bytes"
+          end
+
+          contents = File.read(path)
+          registry = yaml_file?(path) ? (YAML.safe_load(contents, aliases: false) || {}) : JSON.parse(contents)
+          raise ArgumentError, "pricing registry must be a hash" unless registry.is_a?(Hash)
+
+          registry
+        end
+
+        def normalize_registry(registry)
+          {
+            "metadata" => normalize_hash(registry.fetch("metadata", {}), label: "pricing metadata"),
+            "models" => normalize_models(registry.fetch("models", {}))
+          }
+        end
+
+        def normalize_models(models)
+          normalize_hash(models, label: "pricing models").each_with_object({}) do |(model, entry), normalized|
+            normalized[model.to_s] = normalize_hash(entry, label: "pricing model entry")
+          end
+        end
+
+        def normalize_hash(hash, label:)
+          return {} if hash.nil?
+          raise ArgumentError, "#{label} must be a hash" unless hash.is_a?(Hash)
+
+          hash.each_with_object({}) do |(key, value), normalized|
+            normalized[key.to_s] = value
+          end
+        end
+
+        def yaml_file?(path)
+          YAML_EXTENSIONS.include?(File.extname(path).downcase)
+        end
+      end
+    end
+  end
+end