llm_cost_tracker 0.5.0 → 0.5.1

data/lib/llm_cost_tracker/pricing.rb

@@ -32,27 +32,20 @@ module LlmCostTracker
       end
 
       def lookup(provider:, model:)
-        table = prices
         provider_name = provider.to_s
         model_name = model.to_s
         provider_model = provider_name.empty? ? model_name : "#{provider_name}/#{model_name}"
         normalized_model = normalize_model_name(model_name)
+        current = current_price_tables
 
-        table[provider_model] ||
-          table[model_name] ||
-          table[normalized_model] ||
-          fuzzy_match(provider_model, normalized_model, table)
-      end
-
-      def models
-        prices.keys
+        lookup_in_table(current.fetch(:pricing_overrides), provider_model, model_name, normalized_model) ||
+          lookup_in_table(current.fetch(:file_prices), provider_model, model_name, normalized_model) ||
+          lookup_in_table(PRICES, provider_model, model_name, normalized_model)
       end
 
-      def metadata
-        PriceRegistry.metadata
-      end
+      private
 
-      def prices
+      def current_price_tables
         file_prices = PriceRegistry.file_prices(LlmCostTracker.configuration.prices_file)
         overrides = PriceRegistry.normalize_price_table(LlmCostTracker.configuration.pricing_overrides)
         cache_key = [file_prices.object_id, LlmCostTracker.configuration.pricing_overrides.hash]
@@ -64,13 +57,22 @@ module LlmCostTracker
           cached = @prices_cache
           return cached[:value] if cached && cached[:key] == cache_key
 
-          value = PRICES.merge(file_prices).merge(overrides).freeze
+          value = { pricing_overrides: overrides, file_prices: file_prices }.freeze
           @prices_cache = { key: cache_key, value: value }.freeze
           value
         end
       end
 
-      private
+      def lookup_in_table(table, provider_model, model_name, normalized_model)
+        return nil if table.empty?
+
+        table[provider_model] ||
+          table[model_name] ||
+          table[normalized_model] ||
+          unique_providerless_lookup(normalized_model, table) ||
+          fuzzy_match(provider_model, normalized_model, table) ||
+          unique_providerless_fuzzy_match(normalized_model, table)
+      end
 
       def calculate_costs(usage, prices, pricing_mode:)
         {
@@ -113,6 +115,11 @@ module LlmCostTracker
         model.to_s.split("/").last
       end
 
+      def unique_providerless_lookup(model, table)
+        matches = sorted_price_keys(table).select { |key| normalize_model_name(key) == model }
+        table[matches.first] if matches.one?
+      end
+
       def fuzzy_match(model, normalized_model, table)
         sorted_price_keys(table).each do |key|
           return table[key] if snapshot_variant?(model, key) || snapshot_variant?(normalized_model, key)
@@ -121,6 +128,11 @@ module LlmCostTracker
         nil
       end
 
+      def unique_providerless_fuzzy_match(model, table)
+        matches = sorted_price_keys(table).select { |key| snapshot_variant?(model, normalize_model_name(key)) }
+        table[matches.first] if matches.one?
+      end
+
       def snapshot_variant?(model, key)
         suffix = model.delete_prefix("#{key}-")
         return false if suffix == model

data/lib/llm_cost_tracker/storage/dispatcher.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../logging"
+
+module LlmCostTracker
+  module Storage
+    class Dispatcher
+      class << self
+        def save(event)
+          config = LlmCostTracker.configuration
+          case config.storage_backend
+          when :log           then log_event(event, config)
+          when :active_record then active_record_save(event)
+          when :custom        then custom_save(event, config)
+          end
+        rescue LlmCostTracker::BudgetExceededError, LlmCostTracker::UnknownPricingError
+          raise
+        rescue StandardError => e
+          handle_error(e)
+          false
+        end
+
+        private
+
+        def log_event(event, config)
+          message = "#{event.provider}/#{event.model} " \
+                    "tokens=#{event.total_tokens} " \
+                    "cost=#{log_cost_label(event)}"
+          message += " latency=#{event.latency_ms}ms" if event.latency_ms
+          message += " stream=#{event.stream}" if event.stream
+          message += " source=#{event.usage_source}" if event.usage_source
+          message += " tags=#{event.tags}" unless event.tags.empty?
+
+          Logging.log(config.log_level, message)
+          event
+        end
+
+        def log_cost_label(event) = event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
+
+        def active_record_save(event)
+          require_relative "../llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
+          require_relative "active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
+
+          ActiveRecordStore.save(event)
+          event
+        rescue LoadError => e
+          raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
+        end
+
+        def custom_save(event, config)
+          result = config.custom_storage&.call(event)
+          result == false ? false : event
+        end
+
+        def handle_error(error)
+          case LlmCostTracker.configuration.storage_error_behavior
+          when :ignore
+            nil
+          when :warn
+            Logging.warn("Storage failed; tracking event was not persisted: #{error.class}: #{error.message}")
+          when :raise
+            raise StorageError, error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/tracker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "logging"
+require_relative "storage/dispatcher"
 
 module LlmCostTracker
   class Tracker
@@ -39,7 +39,7 @@ module LlmCostTracker
 
         ActiveSupport::Notifications.instrument(EVENT_NAME, event.to_h)
 
-        stored = store(event)
+        stored = Storage::Dispatcher.save(event)
         Budget.check!(event) unless stored == false
 
         event
@@ -93,62 +93,6 @@ module LlmCostTracker
         )
       end
 
-      def store(event)
-        config = LlmCostTracker.configuration
-        case config.storage_backend
-        when :log            then log_event(event, config)
-        when :active_record  then active_record_save(event)
-        when :custom         then custom_save(event, config)
-        end
-      rescue BudgetExceededError, UnknownPricingError
-        raise
-      rescue StandardError => e
-        handle_storage_error(e)
-        false
-      end
-
-      def log_event(event, config)
-        message = "#{event.provider}/#{event.model} " \
-                  "tokens=#{event.total_tokens} " \
-                  "cost=#{log_cost_label(event)}"
-        message += " latency=#{event.latency_ms}ms" if event.latency_ms
-        message += " stream=#{event.stream}" if event.stream
-        message += " source=#{event.usage_source}" if event.usage_source
-        message += " tags=#{event.tags}" unless event.tags.empty?
-
-        Logging.log(config.log_level, message)
-        event
-      end
-
-      def log_cost_label(event) = event.cost ? "$#{format('%.6f', event.cost.total_cost)}" : "unknown"
-
-      def active_record_save(event)
-        require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
-        require_relative "storage/active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
-
-        Storage::ActiveRecordStore.save(event)
-        event
-      rescue LoadError => e
-        raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
-      end
-
-      def custom_save(event, config)
-        result = config.custom_storage&.call(event)
-        result == false ? false : event
-      end
-
-      def handle_storage_error(error)
-        case LlmCostTracker.configuration.storage_error_behavior
-        when :ignore
-          nil
-        when :warn
-          Logging.warn("Storage failed; tracking event was not persisted: #{error.class}: #{error.message}")
-        when :raise
-          storage_error = StorageError.new(error)
-          raise storage_error
-        end
-      end
-
       def normalized_latency_ms(latency_ms) = latency_ms.nil? ? nil : [latency_ms.to_i, 0].max
 
       def normalized_usage_source(value)

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/tasks/llm_cost_tracker.rake

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 # rubocop:disable Metrics/BlockLength
 namespace :llm_cost_tracker do
   desc "Check LLM Cost Tracker setup"
@@ -26,56 +28,49 @@ namespace :llm_cost_tracker do
 
   namespace :prices do
     desc(
-      "Sync the configured pricing file from LiteLLM/OpenRouter JSON sources. " \
-      "Use PREVIEW=1 to preview, STRICT=1 to fail on provider errors, " \
-      "or OUTPUT=path/to/file.json."
+      "Refresh the configured pricing file from the maintained LLM Cost Tracker price snapshot. " \
+      "Use PREVIEW=1 to preview, URL=... to override the source, or OUTPUT=path/to/file.json."
     )
-    task :sync do
+    task :refresh do
       Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
       require_relative "../llm_cost_tracker"
 
-      output_path = price_sync_output_path
-      strict = ENV["STRICT"] == "1" || ARGV.include?("--strict")
-      result = LlmCostTracker::PriceSync.sync(
+      output_path = price_refresh_output_path
+      source_url = LlmCostTracker::PriceSync.configured_remote_url
+      preview = ENV["PREVIEW"] == "1"
+      result = LlmCostTracker::PriceSync.refresh(
         path: output_path,
-        preview: ENV["PREVIEW"] == "1",
-        strict: strict
+        url: source_url,
+        preview: preview
       )
 
-      action = if ENV["PREVIEW"] == "1"
+      action = if preview
                  "previewed"
                elsif result.written
-                 "updated"
+                 "refreshed"
                else
                  "kept"
                end
 
       puts "llm_cost_tracker: #{action} pricing file #{result.path}"
-      print_source_usage(result.sources_used)
+      puts "  source: #{result.source_url}"
+      puts "  version: #{result.source_version.inspect}" if result.source_version
       print_changes(result.changes)
-      print_discrepancies(result.discrepancies)
-      print_issues("validator rejected", result.rejected)
-      print_issues("validator flagged", result.flagged)
-      print_models("orphaned models (no JSON source match)", result.orphaned_models)
-      print_failures(result.failed_sources, heading: "source failures (kept existing values)")
     end
 
-    desc "Compare the current pricing snapshot with LiteLLM/OpenRouter JSON sources and exit non-zero on drift."
+    desc "Compare the current pricing file with the maintained LLM Cost Tracker price snapshot."
     task :check do
       Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
       require_relative "../llm_cost_tracker"
 
-      output_path = price_sync_output_path
-      result = LlmCostTracker::PriceSync.check(path: output_path)
+      output_path = price_refresh_output_path
+      source_url = LlmCostTracker::PriceSync.configured_remote_url
+      result = LlmCostTracker::PriceSync.check(path: output_path, url: source_url)
 
       puts "llm_cost_tracker: checked pricing file #{result.path}"
-      print_source_usage(result.sources_used)
+      puts "  source: #{result.source_url}"
+      puts "  version: #{result.source_version.inspect}" if result.source_version
       print_changes(result.changes)
-      print_discrepancies(result.discrepancies)
-      print_issues("validator rejected", result.rejected)
-      print_issues("validator flagged", result.flagged)
-      print_models("orphaned models (no JSON source match)", result.orphaned_models)
-      print_failures(result.failed_sources, heading: "source failures")
       puts "  pricing is up to date" if result.up_to_date
       abort("llm_cost_tracker: pricing check failed") unless result.up_to_date
     end
@@ -83,16 +78,6 @@ namespace :llm_cost_tracker do
 end
 # rubocop:enable Metrics/BlockLength
 
-def print_source_usage(sources_used)
-  return if sources_used.empty?
-
-  puts "  sources used:"
-  sources_used.each do |source, usage|
-    version = usage.source_version ? ", version=#{usage.source_version.inspect}" : ""
-    puts "    - #{source} (#{usage.prices_count} prices#{version})"
-  end
-end
-
 def print_changes(changes)
   puts "  changed models: #{changes.size}"
   return if changes.empty?
@@ -105,47 +90,8 @@ def print_changes(changes)
   end
 end
 
-def print_discrepancies(discrepancies)
-  return if discrepancies.empty?
-
-  puts "  source discrepancies: #{discrepancies.size}"
-  discrepancies.each do |issue|
-    formatted = issue.values.map { |source, value| "#{source}=#{value.inspect}" }.join(", ")
-    puts "    - #{issue.model} #{issue.field}: #{formatted}"
-  end
-end
-
-def print_issues(heading, issues)
-  return if issues.empty?
-
-  puts "  #{heading}: #{issues.size}"
-  issues.each do |issue|
-    puts "    - #{issue.model}: #{issue.reason}"
-  end
-end
-
-def print_models(heading, models)
-  return if models.empty?
-
-  puts "  #{heading}: #{models.size}"
-  models.each { |model| puts "    - #{model}" }
-end
-
-def print_failures(failed_sources, heading:)
-  return if failed_sources.empty?
-
-  puts "  #{heading}: #{failed_sources.size}"
-  failed_sources.each do |source, message|
-    puts "    - #{source}: #{message}"
-  end
-end
-
-def price_sync_output_path
+def price_refresh_output_path
   path = LlmCostTracker::PriceSync.configured_output_path
-  return path if path
-
-  abort(
-    "llm_cost_tracker: configure prices_file, run bin/rails generate llm_cost_tracker:prices, " \
-    "or set OUTPUT=config/llm_cost_tracker_prices.yml"
-  )
+  FileUtils.mkdir_p(File.dirname(path))
+  path
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Sergii Khomenko
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-25 00:00:00.000000000 Z
+date: 2026-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,6 +84,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -322,17 +336,9 @@ files:
 - lib/llm_cost_tracker/price_registry.rb
 - lib/llm_cost_tracker/price_sync.rb
 - lib/llm_cost_tracker/price_sync/fetcher.rb
-- lib/llm_cost_tracker/price_sync/merger.rb
-- lib/llm_cost_tracker/price_sync/model_catalog.rb
-- lib/llm_cost_tracker/price_sync/raw_price.rb
-- lib/llm_cost_tracker/price_sync/refresh_plan_builder.rb
+- lib/llm_cost_tracker/price_sync/registry_diff.rb
 - lib/llm_cost_tracker/price_sync/registry_loader.rb
 - lib/llm_cost_tracker/price_sync/registry_writer.rb
-- lib/llm_cost_tracker/price_sync/source.rb
-- lib/llm_cost_tracker/price_sync/source_result.rb
-- lib/llm_cost_tracker/price_sync/sources/litellm.rb
-- lib/llm_cost_tracker/price_sync/sources/open_router.rb
-- lib/llm_cost_tracker/price_sync/validator.rb
 - lib/llm_cost_tracker/prices.json
 - lib/llm_cost_tracker/pricing.rb
 - lib/llm_cost_tracker/railtie.rb
@@ -343,6 +349,7 @@ files:
 - lib/llm_cost_tracker/retention.rb
 - lib/llm_cost_tracker/storage/active_record_rollups.rb
 - lib/llm_cost_tracker/storage/active_record_store.rb
+- lib/llm_cost_tracker/storage/dispatcher.rb
 - lib/llm_cost_tracker/stream_collector.rb
 - lib/llm_cost_tracker/tag_accessors.rb
 - lib/llm_cost_tracker/tag_context.rb

data/lib/llm_cost_tracker/price_sync/merger.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module PriceSync
-    class Merger
-      Discrepancy = Data.define(:model, :field, :values)
-
-      PRIORITY_ORDER = %i[litellm openrouter].freeze
-      SUPPLEMENTAL_FIELDS = %i[cache_read_input cache_write_input].freeze
-
-      def merge(results_by_source)
-        prices = collect_prices(results_by_source)
-        discrepancies = []
-
-        merged = prices.group_by(&:model).sort.to_h.transform_values do |candidates|
-          sorted = sort_candidates(candidates)
-          discrepancies.concat(detect_discrepancies(sorted))
-          fill_missing_fields(sorted.first, sorted.drop(1))
-        end
-
-        [merged, discrepancies]
-      end
-
-      private
-
-      def collect_prices(results_by_source)
-        results_by_source.flat_map do |source_name, result|
-          result.prices.map do |price|
-            price.with(source: source_name)
-          end
-        end
-      end
-
-      def sort_candidates(candidates)
-        candidates.sort_by do |price|
-          PRIORITY_ORDER.index(price.source.to_sym) || PRIORITY_ORDER.length
-        end
-      end
-
-      def fill_missing_fields(primary, fallbacks)
-        SUPPLEMENTAL_FIELDS.reduce(primary) do |current, field|
-          next current if current.public_send(field)
-
-          fallback = fallbacks.find { |candidate| candidate.public_send(field) }
-          fallback ? current.with(field => fallback.public_send(field)) : current
-        end
-      end
-
-      def detect_discrepancies(candidates)
-        return [] if candidates.length < 2
-
-        RawPrice::PRICE_FIELDS.filter_map do |field|
-          values = candidates.each_with_object({}) do |price, collected|
-            value = price.public_send(field)
-            collected[price.source] = value unless value.nil?
-          end
-          next if values.size < 2
-          next unless discrepant?(values.values)
-
-          Discrepancy.new(model: candidates.first.model, field: field, values: values)
-        end
-      end
-
-      def discrepant?(values)
-        min, max = values.minmax
-        return max != min if min.to_f.zero?
-
-        ((max - min).abs / min.to_f) >= 0.05
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/model_catalog.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module PriceSync
-    class ModelCatalog
-      OPENROUTER_PROVIDER_PREFIXES = {
-        openai: %w[openai],
-        anthropic: %w[anthropic],
-        gemini: %w[google]
-      }.freeze
-      LITELLM_PROVIDER_PREFIXES = {
-        openai: [nil, "openai"],
-        anthropic: [nil, "anthropic"],
-        gemini: [nil, "gemini"]
-      }.freeze
-      ALIASES = {
-        "gpt-4o-2024-05-13" => "gpt-4o"
-      }.freeze
-
-      class << self
-        def resolve_from_litellm(our_model, payload)
-          litellm_candidates(our_model).find { |candidate| payload.key?(candidate) }
-        end
-
-        def resolve_from_openrouter(our_model, index)
-          openrouter_candidates(our_model).find { |candidate| index.key?(candidate) }
-        end
-
-        def guess_provider(our_model)
-          case our_model.to_s
-          when /\A(?:gpt-|o1|o3|o4|chatgpt|text-embedding)/
-            :openai
-          when /\Aclaude-/
-            :anthropic
-          when /\Agemini-/
-            :gemini
-          end
-        end
-
-        private
-
-        def litellm_candidates(our_model)
-          provider = guess_provider(our_model)
-          prefixes = LITELLM_PROVIDER_PREFIXES.fetch(provider, [nil])
-
-          model_variants(our_model).flat_map do |variant|
-            prefixes.map { |prefix| prefix ? "#{prefix}/#{variant}" : variant }
-          end.uniq
-        end
-
-        def openrouter_candidates(our_model)
-          provider = guess_provider(our_model)
-          prefixes = OPENROUTER_PROVIDER_PREFIXES.fetch(provider, [])
-
-          model_variants(our_model).flat_map do |variant|
-            prefixes.map { |prefix| "#{prefix}/#{variant}" }
-          end.uniq
-        end
-
-        def model_variants(our_model)
-          model = our_model.to_s
-          canonical = ALIASES.fetch(model, model)
-
-          [model, canonical].flat_map do |variant|
-            [variant, anthropic_version_variant(variant)]
-          end.compact.uniq
-        end
-
-        def anthropic_version_variant(model)
-          return nil unless guess_provider(model) == :anthropic
-
-          model.gsub(/(?<=\d)-(?=\d)/, ".")
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/raw_price.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module PriceSync
-    RawPrice = Data.define(
-      :model,
-      :provider,
-      :input,
-      :output,
-      :cache_read_input,
-      :cache_write_input,
-      :source,
-      :source_version,
-      :fetched_at
-    )
-
-    class RawPrice
-      PRICE_FIELDS = %w[input output cache_read_input cache_write_input].freeze
-
-      def to_registry_entry(today:)
-        {
-          "input" => input,
-          "output" => output,
-          "cache_read_input" => cache_read_input,
-          "cache_write_input" => cache_write_input,
-          "_source" => source.to_s,
-          "_source_version" => source_version,
-          "_fetched_at" => fetched_at || today.iso8601
-        }.compact
-      end
-    end
-  end
-end