llm_cost_tracker 0.8.0 → 0.9.0

data/lib/llm_cost_tracker/prices.json

@@ -1,6 +1,6 @@
 {
   "metadata": {
-    "updated_at": "2026-05-02",
+    "updated_at": "2026-05-08",
     "currency": "USD",
     "unit": "1M tokens",
     "source_urls": [
@@ -18,10 +18,13 @@
   "service_charges": {
     "anthropic": {
       "web_search_request": 10.0,
+      "web_fetch_request": 0.0,
       "code_execution_hour": 0.05
     },
     "openai": {
       "web_search_request": 10.0,
+      "web_search_preview_request_reasoning": 10.0,
+      "web_search_preview_request_non_reasoning": 25.0,
       "file_search_call": 2.5
     }
   },
@@ -140,13 +143,13 @@
     },
     "gemini/gemini-2.0-flash": {
       "input": 0.1,
-      "cache_read_input": 0.025,
       "output": 0.4,
+      "audio_input": 0.7,
+      "cache_read_input": 0.025,
       "batch_input": 0.05,
       "batch_output": 0.2,
-      "batch_cache_read_input": 0.025,
-      "audio_input": 0.7,
-      "batch_audio_input": 0.35
+      "batch_audio_input": 0.35,
+      "batch_cache_read_input": 0.025
     },
     "gemini/gemini-2.0-flash-lite": {
       "input": 0.075,
@@ -157,52 +160,52 @@
     "gemini/gemini-2.5-flash": {
       "input": 0.3,
       "output": 2.5,
+      "audio_input": 1.0,
       "cache_read_input": 0.03,
       "batch_input": 0.15,
       "batch_output": 1.25,
+      "batch_audio_input": 0.5,
       "batch_cache_read_input": 0.03,
       "flex_input": 0.15,
       "flex_output": 1.25,
+      "flex_audio_input": 0.5,
       "flex_cache_read_input": 0.03,
       "priority_input": 0.54,
       "priority_output": 4.5,
-      "priority_cache_read_input": 0.054,
-      "audio_input": 1.0,
-      "batch_audio_input": 0.5,
-      "flex_audio_input": 0.5,
-      "priority_audio_input": 1.8
+      "priority_audio_input": 1.8,
+      "priority_cache_read_input": 0.054
     },
     "gemini/gemini-2.5-flash-lite": {
       "input": 0.1,
       "output": 0.4,
+      "audio_input": 0.3,
       "cache_read_input": 0.01,
       "batch_input": 0.05,
       "batch_output": 0.2,
+      "batch_audio_input": 0.15,
       "batch_cache_read_input": 0.01,
       "flex_input": 0.05,
       "flex_output": 0.2,
+      "flex_audio_input": 0.15,
       "flex_cache_read_input": 0.01,
       "priority_input": 0.18,
       "priority_output": 0.72,
-      "priority_cache_read_input": 0.018,
-      "audio_input": 0.3,
-      "batch_audio_input": 0.15,
-      "flex_audio_input": 0.15,
-      "priority_audio_input": 0.54
+      "priority_audio_input": 0.54,
+      "priority_cache_read_input": 0.018
     },
     "gemini/gemini-2.5-pro": {
       "input": 1.25,
       "output": 10.0,
-      "cache_read_input": 0.125,
-      "batch_input": 0.625,
-      "batch_output": 5.0,
-      "batch_cache_read_input": 0.125,
       "_context_price_threshold_tokens": 200000,
       "above_context_input": 2.5,
       "above_context_output": 15.0,
+      "cache_read_input": 0.125,
       "above_context_cache_read_input": 0.25,
+      "batch_input": 0.625,
+      "batch_output": 5.0,
       "above_context_batch_input": 1.25,
       "above_context_batch_output": 7.5,
+      "batch_cache_read_input": 0.125,
       "above_context_batch_cache_read_input": 0.25,
       "flex_input": 0.625,
       "flex_output": 5.0,
@@ -394,6 +397,76 @@
       "output": 0.6,
       "audio_output": 20.0
     },
+    "openai/text-embedding-3-small": {
+      "input": 0.02,
+      "batch_input": 0.01
+    },
+    "openai/text-embedding-3-large": {
+      "input": 0.13,
+      "batch_input": 0.065
+    },
+    "openai/text-embedding-ada-002": {
+      "input": 0.10,
+      "batch_input": 0.05
+    },
+    "openai/gpt-4o-transcribe": {
+      "input": 2.5,
+      "audio_input": 6.0,
+      "output": 10.0
+    },
+    "openai/gpt-4o-mini-transcribe": {
+      "input": 1.25,
+      "audio_input": 3.0,
+      "output": 5.0
+    },
+    "openai/tts-1": {
+      "text_to_speech_character": 15.0
+    },
+    "openai/tts-1-hd": {
+      "text_to_speech_character": 30.0
+    },
+    "openai/gpt-image-1": {
+      "input": 5.0,
+      "cache_read_input": 1.25,
+      "image_input": 10.0,
+      "image_output": 40.0,
+      "batch_input": 2.5,
+      "batch_cache_read_input": 0.63,
+      "batch_image_input": 5.0,
+      "batch_image_output": 20.0
+    },
+    "openai/gpt-image-1-mini": {
+      "input": 2.0,
+      "cache_read_input": 0.2,
+      "image_input": 2.5,
+      "image_output": 8.0,
+      "batch_input": 1.0,
+      "batch_cache_read_input": 0.1,
+      "batch_image_input": 1.25,
+      "batch_image_output": 4.0
+    },
+    "openai/gpt-image-1.5": {
+      "input": 5.0,
+      "cache_read_input": 1.25,
+      "output": 10.0,
+      "image_input": 8.0,
+      "image_output": 32.0,
+      "batch_input": 2.5,
+      "batch_cache_read_input": 0.63,
+      "batch_output": 5.0,
+      "batch_image_input": 4.0,
+      "batch_image_output": 16.0
+    },
+    "openai/gpt-image-2": {
+      "input": 5.0,
+      "cache_read_input": 1.25,
+      "image_input": 8.0,
+      "image_output": 30.0,
+      "batch_input": 2.5,
+      "batch_cache_read_input": 0.625,
+      "batch_image_input": 4.0,
+      "batch_image_output": 15.0
+    },
     "openai/gpt-5": {
       "input": 1.25,
       "output": 10.0,
@@ -805,6 +878,24 @@
       "input": 1.5,
       "output": 6.0,
       "cache_read_input": 0.375
+    },
+    "gemini/gemini-3.1-flash-lite": {
+      "input": 0.25,
+      "output": 1.5,
+      "audio_input": 0.5,
+      "cache_read_input": 0.025,
+      "batch_input": 0.125,
+      "batch_output": 0.75,
+      "batch_audio_input": 0.25,
+      "batch_cache_read_input": 0.0125,
+      "flex_input": 0.125,
+      "flex_output": 0.75,
+      "flex_audio_input": 0.25,
+      "flex_cache_read_input": 0.0125,
+      "priority_input": 0.45,
+      "priority_output": 2.7,
+      "priority_audio_input": 0.9,
+      "priority_cache_read_input": 0.045
     }
   }
 }

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../billing/components"
+require_relative "mode"
 
 module LlmCostTracker
   module Pricing
@@ -8,6 +9,7 @@ module LlmCostTracker
       class << self
         def call(usage:, prices:, pricing_mode:)
           context_tier = context_tier?(usage: usage, prices: prices)
+          orderings = pricing_mode && Mode.parse(pricing_mode).permutations
 
           Billing::Components::TOKEN_PRICED.to_h do |component|
             price_key = component.key
@@ -16,7 +18,7 @@ module LlmCostTracker
                       price_for(
                         prices: prices,
                         key: price_key,
-                        pricing_mode: pricing_mode,
+                        orderings: orderings,
                         context_tier: context_tier
                       )
                     else
@@ -28,10 +30,9 @@ module LlmCostTracker
 
         private
 
-        def price_for(prices:, key:, pricing_mode:, context_tier:)
-          return contextual_price(prices: prices, key: key, context_tier: context_tier) unless pricing_mode
+        def price_for(prices:, key:, orderings:, context_tier:)
+          return contextual_price(prices: prices, key: key, context_tier: context_tier) unless orderings
 
-          orderings = mode_orderings_for(pricing_mode)
           orderings.each do |mode|
             direct = contextual_price(prices: prices, key: :"#{mode}_#{key}", context_tier: context_tier)
             return direct if direct
@@ -41,38 +42,6 @@ module LlmCostTracker
           derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
         end
 
-        def mode_orderings_for(pricing_mode)
-          mode_string = pricing_mode.to_s
-          return [mode_string] unless mode_string.include?("_")
-
-          tokens = tokenize_mode(mode_string)
-          return [mode_string] if tokens.size <= 1
-
-          [mode_string, *tokens.permutation.map { |permutation| permutation.join("_") }].uniq
-        end
-
-        def tokenize_mode(mode_string)
-          remaining = mode_string.dup
-          tokens = []
-          loop do
-            break if remaining.empty?
-
-            compound = COMPOUND_MODE_TOKENS.find { |token| remaining == token || remaining.start_with?("#{token}_") }
-            if compound
-              tokens << compound
-              remaining = remaining.delete_prefix(compound).delete_prefix("_")
-            else
-              first, _, rest = remaining.partition("_")
-              tokens << first
-              remaining = rest
-            end
-          end
-          tokens
-        end
-
-        COMPOUND_MODE_TOKENS = %w[data_residency].freeze
-        private_constant :COMPOUND_MODE_TOKENS
-
         def contextual_price(prices:, key:, context_tier:)
           return prices[key] unless context_tier
 

data/lib/llm_cost_tracker/pricing/lookup.rb

@@ -7,6 +7,9 @@ module LlmCostTracker
       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:)
@@ -14,6 +17,8 @@ module LlmCostTracker
           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)
@@ -25,14 +30,41 @@ module LlmCostTracker
 
         def reset!
           MUTEX.synchronize do
-            @prices_cache = nil
-            @lookup_cache = nil
-            @sorted_price_keys_cache = nil
+            reset_prices_caches!(signature: nil)
+            @prices_file_last_check_at = nil
           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_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)
@@ -86,6 +118,7 @@ module LlmCostTracker
         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

data/lib/llm_cost_tracker/pricing/mode.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Pricing
+    class Mode
+      COMPOUND_MODIFIERS = %w[data_residency].freeze
+
+      attr_reader :modifiers
+
+      def self.parse(value)
+        return value if value.is_a?(self)
+        return new([]) if value.nil?
+
+        new(tokenize(value.to_s))
+      end
+
+      def self.tokenize(value)
+        remaining = value.to_s.downcase.tr("-", "_")
+        tokens = []
+        loop do
+          break if remaining.empty?
+
+          compound = COMPOUND_MODIFIERS.find do |token|
+            remaining == token || remaining.start_with?("#{token}_")
+          end
+          if compound
+            tokens << compound.to_sym
+            remaining = remaining.delete_prefix(compound).delete_prefix("_")
+          else
+            first, _, rest = remaining.partition("_")
+            tokens << first.to_sym unless first.empty?
+            remaining = rest
+          end
+        end
+        tokens
+      end
+
+      def initialize(modifiers)
+        @modifiers = Array(modifiers).map(&:to_sym).uniq.sort
+        freeze
+      end
+
+      def empty?
+        modifiers.empty?
+      end
+
+      def include?(modifier)
+        modifiers.include?(modifier.to_sym)
+      end
+
+      def canonical
+        modifiers.join("_")
+      end
+      alias to_s canonical
+
+      def to_sym
+        empty? ? nil : canonical.to_sym
+      end
+
+      def permutations
+        return [canonical] if modifiers.size <= 1
+
+        modifiers.permutation.map { |permutation| permutation.join("_") }.uniq
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && modifiers == other.modifiers
+      end
+      alias eql? ==
+
+      def hash
+        modifiers.hash
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -115,6 +115,7 @@ module LlmCostTracker
 
         def non_negative_float(key, value)
           rate = Float(value)
+          raise ArgumentError, "price for #{key.inspect} must be finite (got #{rate})" unless rate.finite?
           raise ArgumentError, "price for #{key.inspect} must be non-negative (got #{rate})" if rate.negative?
 
           rate
@@ -145,8 +146,9 @@ module LlmCostTracker
 
         def price_key_for(key)
           name = key.is_a?(Symbol) ? key.name : key
-          Billing::Components::TOKEN_PRICED.each do |candidate|
+          Billing::Components::REGISTRY.each do |candidate|
             return candidate.key if candidate.key.name == name
+            next unless candidate.token_key
 
             suffix = "_#{candidate.key.name}"
             next unless name.end_with?(suffix)

data/lib/llm_cost_tracker/pricing/service_charges.rb

@@ -121,14 +121,20 @@ module LlmCostTracker
 
       def amount_for(key, amount, context:)
         value = BigDecimal(amount.to_s)
-        message = "service charge price amount for #{key.inspect} in #{context} must be non-negative"
-        raise ArgumentError, message if value.negative?
+        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)
-        component.unit == :request ? BigDecimal("1000") : BigDecimal("1")
+        BigDecimal(Billing::RATE_BASIS_QUANTITIES.fetch(component.rate_basis, 1).to_s)
       end
 
       def charge_rate_match(provider:, component:, pricing_mode:)

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

@@ -9,10 +9,12 @@ module LlmCostTracker
     module Sync
       class RegistryWriter
         YAML_EXTENSIONS = %w[.yml .yaml].freeze
+        MANUAL_SOURCE = "manual"
 
         def call(path:, registry:)
           FileUtils.mkdir_p(File.dirname(path))
-          payload = yaml_file?(path) ? YAML.dump(registry) : "#{JSON.pretty_generate(registry)}\n"
+          merged = 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 +24,53 @@ module LlmCostTracker
 
         private
 
+        def merge_with_existing(path:, registry:)
+          existing = read_existing(path)
+          return registry unless existing.is_a?(Hash)
+
+          merged = registry.dup
+          merged["models"] = merged_models(registry, existing) if existing["models"].is_a?(Hash)
+          if existing["service_charges"].is_a?(Hash)
+            merged["service_charges"] = merged_service_charges(registry, existing)
+          end
+          merged
+        end
+
+        def merged_models(registry, existing)
+          merged = registry.fetch("models", {}).dup
+          existing.fetch("models", {}).each do |model, attrs|
+            next unless attrs.is_a?(Hash) && attrs["_source"].to_s == MANUAL_SOURCE
+            next if merged.key?(model)
+
+            merged[model] = attrs
+          end
+          merged
+        end
+
+        def merged_service_charges(registry, existing)
+          remote = registry.fetch("service_charges", {})
+          existing.fetch("service_charges", {}).each_with_object(remote.dup) do |(provider, charges), merged|
+            next unless charges.is_a?(Hash)
+
+            merged[provider] = charges.merge(merged.fetch(provider, {}))
+          end
+        end
+
+        def read_existing(path)
+          return nil unless File.exist?(path)
+
+          contents = File.read(path)
+          return nil if contents.strip.empty?
+
+          if yaml_file?(path)
+            YAML.safe_load(contents, permitted_classes: [Symbol, Date, Time])
+          else
+            JSON.parse(contents)
+          end
+        rescue StandardError
+          nil
+        end
+
         def yaml_file?(path)
           YAML_EXTENSIONS.include?(File.extname(path).downcase)
         end

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -150,8 +150,10 @@ module LlmCostTracker
         end
 
         def load_registry(path)
+          return {} unless File.exist?(path)
+
           YAML.safe_load_file(path, aliases: false) || {}
-        rescue Errno::ENOENT, Psych::Exception, ArgumentError, TypeError => e
+        rescue Psych::Exception, ArgumentError, TypeError => e
           raise Error, "Unable to load pricing registry #{path.inspect}: #{e.message}"
         end