llm_cost_tracker 0.4.1 → 0.5.1

data/lib/llm_cost_tracker/integrations/openai.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module LlmCostTracker
+  module Integrations
+    module Openai
+      extend Base
+
+      class << self
+        def integration_name = :openai
+
+        def target_patches
+          [
+            [constant("OpenAI::Resources::Responses"), ResponsesPatch],
+            [constant("OpenAI::Resources::Chat::Completions"), ChatCompletionsPatch]
+          ]
+        end
+
+        def record_response(response, request:, latency_ms:)
+          return unless active?
+
+          record_safely do
+            usage = ObjectReader.first(response, :usage)
+            next unless usage
+
+            input_tokens = ObjectReader.first(usage, :input_tokens, :prompt_tokens)
+            output_tokens = ObjectReader.first(usage, :output_tokens, :completion_tokens)
+            next if input_tokens.nil? && output_tokens.nil?
+
+            LlmCostTracker::Tracker.record(
+              provider: "openai",
+              model: ObjectReader.first(response, :model) || request[:model],
+              input_tokens: ObjectReader.integer(input_tokens),
+              output_tokens: ObjectReader.integer(output_tokens),
+              latency_ms: latency_ms,
+              usage_source: :sdk_response,
+              provider_response_id: ObjectReader.first(response, :id),
+              metadata: usage_metadata(usage)
+            )
+          end
+        end
+
+        def usage_metadata(usage)
+          {
+            cache_read_input_tokens: cache_read_input_tokens(usage),
+            hidden_output_tokens: hidden_output_tokens(usage)
+          }
+        end
+
+        def cache_read_input_tokens(usage)
+          ObjectReader.integer(
+            ObjectReader.nested(usage, :input_tokens_details, :cached_tokens) ||
+            ObjectReader.nested(usage, :prompt_tokens_details, :cached_tokens)
+          )
+        end
+
+        def hidden_output_tokens(usage)
+          ObjectReader.integer(
+            ObjectReader.nested(usage, :output_tokens_details, :reasoning_tokens) ||
+            ObjectReader.nested(usage, :completion_tokens_details, :reasoning_tokens)
+          )
+        end
+      end
+
+      module ResponsesPatch
+        def create(*args, **kwargs)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          LlmCostTracker::Integrations::Openai.enforce_budget!
+          response = super
+          LlmCostTracker::Integrations::Openai.record_response(
+            response,
+            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
+            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at)
+          )
+          response
+        end
+      end
+
+      module ChatCompletionsPatch
+        def create(*args, **kwargs)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          LlmCostTracker::Integrations::Openai.enforce_budget!
+          response = super
+          LlmCostTracker::Integrations::Openai.record_response(
+            response,
+            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
+            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at)
+          )
+          response
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/integrations/registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "openai"
+require_relative "anthropic"
+
+module LlmCostTracker
+  module Integrations
+    module Registry
+      INTEGRATIONS = {
+        openai: Openai,
+        anthropic: Anthropic
+      }.freeze
+
+      module_function
+
+      def install!(names = LlmCostTracker.configuration.instrumented_integrations)
+        normalize(names).each { |name| fetch(name).install }
+      end
+
+      def checks(names = LlmCostTracker.configuration.instrumented_integrations)
+        return [Base::Result.new(:integrations, :ok, "no SDK integrations enabled")] if names.empty?
+
+        normalize(names).map { |name| fetch(name).status }
+      end
+
+      def normalize(names)
+        Array(names).flatten.map(&:to_sym).uniq
+      end
+
+      def fetch(name)
+        INTEGRATIONS.fetch(name.to_sym) do
+          message = "Unknown integration: #{name.inspect}. Use one of: #{INTEGRATIONS.keys.join(', ')}"
+          raise LlmCostTracker::Error, message
+        end
+      end
+    end
+
+    def self.install! = Registry.install!
+    def self.checks = Registry.checks
+  end
+end

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -4,6 +4,7 @@ require "faraday"
 require "json"
 
 require_relative "../logging"
+require_relative "../request_url"
 
 module LlmCostTracker
   module Middleware
@@ -76,9 +77,9 @@ module LlmCostTracker
         response_body = read_body(response_env.body)
         unless response_body
           Logging.warn(
-            "Unable to read response body for #{request_url}; " \
-            "streaming responses are captured automatically for OpenAI/Anthropic/Gemini " \
-            "or via LlmCostTracker.track_stream for custom clients."
+            "Unable to read response body for #{RequestUrl.label(request_url)}; " \
+            "known streaming responses are captured automatically, or via LlmCostTracker.track_stream " \
+            "for custom clients."
           )
           return nil
         end
@@ -156,11 +157,11 @@ module LlmCostTracker
 
       def capture_warning(request_url, stream_buffer)
         unless stream_buffer&.dig(:overflowed)
-          return "Unable to capture streaming response for #{request_url}; " \
+          return "Unable to capture streaming response for #{RequestUrl.label(request_url)}; " \
                  "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
         end
 
-        "Streaming response for #{request_url} exceeded #{STREAM_CAPTURE_LIMIT_BYTES} bytes; " \
+        "Streaming response for #{RequestUrl.label(request_url)} exceeded #{STREAM_CAPTURE_LIMIT_BYTES} bytes; " \
           "recording usage_source=unknown. Use LlmCostTracker.track_stream for manual capture."
       end
     end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -16,6 +16,7 @@ module LlmCostTracker
   )
 
   class ParsedUsage
+    UNKNOWN_MODEL = "unknown"
     TRACKING_KEYS = %i[
       provider
       model
@@ -30,7 +31,7 @@ module LlmCostTracker
     def self.build(**attributes)
       new(
         provider: attributes.fetch(:provider),
-        model: attributes.fetch(:model),
+        model: normalize_model(attributes.fetch(:model)),
         input_tokens: attributes.fetch(:input_tokens).to_i,
         output_tokens: attributes.fetch(:output_tokens).to_i,
         total_tokens: attributes.fetch(:total_tokens, usage_breakdown(attributes).total_tokens).to_i,
@@ -61,5 +62,11 @@ module LlmCostTracker
       )
     end
     private_class_method :usage_breakdown
+
+    def self.normalize_model(value)
+      model = value.to_s.strip
+      model.empty? ? UNKNOWN_MODEL : model
+    end
+    private_class_method :normalize_model
   end
 end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -108,7 +108,7 @@ module LlmCostTracker
         ParsedUsage.build(
           provider: provider,
           provider_response_id: provider_response_id,
-          model: model,
+          model: model || ParsedUsage::UNKNOWN_MODEL,
           input_tokens: 0,
           output_tokens: 0,
           total_tokens: 0,

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -67,7 +67,7 @@ module LlmCostTracker
       end
 
       def detect_stream_model(events)
-        find_event_value(events) { |data| data["model"] }
+        find_event_value(events) { |data| data["model"] || data.dig("response", "model") }
       end
 
       def detect_stream_response_id(events)

data/lib/llm_cost_tracker/price_freshness.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "date"
+
+module LlmCostTracker
+  module PriceFreshness
+    STALE_AFTER_DAYS = 30
+
+    class << self
+      def call(metadata, today: Date.today)
+        updated_at = metadata["updated_at"] || metadata[:updated_at]
+        return missing unless updated_at
+
+        date = Date.iso8601(updated_at.to_s)
+        age_days = (today - date).to_i
+        return stale(updated_at) if age_days > STALE_AFTER_DAYS
+
+        [:ok, "updated_at=#{updated_at}"]
+      rescue Date::Error
+        [:warn, "metadata.updated_at=#{updated_at.inspect} is invalid; run bin/rails llm_cost_tracker:prices:refresh"]
+      end
+
+      private
+
+      def missing
+        [:warn, "metadata.updated_at missing; run bin/rails llm_cost_tracker:prices:refresh"]
+      end
+
+      def stale(updated_at)
+        [
+          :warn,
+          "updated_at=#{updated_at} is older than #{STALE_AFTER_DAYS} days; " \
+          "run bin/rails llm_cost_tracker:prices:refresh"
+        ]
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/price_registry.rb

@@ -25,6 +25,20 @@ module LlmCostTracker
         @metadata ||= MUTEX.synchronize { @metadata || raw_registry.fetch("metadata", {}).freeze }
       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

data/lib/llm_cost_tracker/price_sync/fetcher.rb

@@ -2,6 +2,7 @@
 
 require "digest"
 require "net/http"
+require "openssl"
 require "time"
 require "uri"
 
@@ -14,7 +15,7 @@ module LlmCostTracker
         end
       end
 
-      USER_AGENT = "llm_cost_tracker price sync"
+      USER_AGENT = "llm_cost_tracker price refresh"
       MAX_REDIRECTS = 5
       OPEN_TIMEOUT = 5
       READ_TIMEOUT = 10
@@ -24,6 +25,8 @@ module LlmCostTracker
         raise Error, "Too many redirects while fetching #{url}" if redirects > MAX_REDIRECTS
 
         uri = URI.parse(url)
+        raise Error, "Pricing snapshot URL must use http or https" unless %w[http https].include?(uri.scheme)
+
         request = Net::HTTP::Get.new(uri)
         request["User-Agent"] = USER_AGENT
         request["If-None-Match"] = etag if etag
@@ -52,7 +55,7 @@ module LlmCostTracker
         else
           raise Error, "Unable to fetch #{url}: HTTP #{response.code}"
         end
-      rescue SocketError, SystemCallError, Timeout::Error => e
+      rescue OpenSSL::SSL::SSLError, SocketError, SystemCallError, Timeout::Error => e
         raise Error, "Unable to fetch #{url}: #{e.class}: #{e.message}"
       end
 

data/lib/llm_cost_tracker/price_sync/registry_diff.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module PriceSync
+    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(*PriceRegistry::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

data/lib/llm_cost_tracker/price_sync/registry_writer.rb

@@ -12,7 +12,11 @@ module LlmCostTracker
       def call(path:, registry:)
         FileUtils.mkdir_p(File.dirname(path))
         payload = yaml_file?(path) ? YAML.dump(registry) : "#{JSON.pretty_generate(registry)}\n"
-        File.write(path, payload)
+        temp_path = "#{path}.tmp-#{Process.pid}-#{Thread.current.object_id}"
+        File.write(temp_path, payload)
+        File.rename(temp_path, path)
+      ensure
+        FileUtils.rm_f(temp_path) if temp_path && File.exist?(temp_path)
       end
 
       private

data/lib/llm_cost_tracker/price_sync.rb

@@ -1,141 +1,143 @@
 # frozen_string_literal: true
 
 require "date"
+require "json"
+require "rubygems"
 
 require_relative "price_sync/fetcher"
-require_relative "price_sync/raw_price"
-require_relative "price_sync/source"
-require_relative "price_sync/source_result"
+require_relative "price_sync/registry_diff"
 require_relative "price_sync/registry_loader"
 require_relative "price_sync/registry_writer"
-require_relative "price_sync/refresh_plan_builder"
-require_relative "price_sync/model_catalog"
-require_relative "price_sync/merger"
-require_relative "price_sync/validator"
-require_relative "price_sync/sources/litellm"
-require_relative "price_sync/sources/open_router"
 
 module LlmCostTracker
   module PriceSync
-    DEFAULT_OUTPUT_PATH = PriceRegistry::DEFAULT_PRICES_PATH
-
-    SourceUsage = Data.define(:prices_count, :source_version)
-    SyncResult = Data.define(
-      :path,
-      :updated_models,
-      :changes,
-      :orphaned_models,
-      :failed_sources,
-      :discrepancies,
-      :rejected,
-      :flagged,
-      :sources_used,
-      :written
-    )
-    CheckResult = Data.define(
-      :path,
-      :changes,
-      :orphaned_models,
-      :failed_sources,
-      :discrepancies,
-      :rejected,
-      :flagged,
-      :sources_used,
-      :up_to_date
-    )
-    RefreshPlan = Data.define(
-      :path,
-      :registry,
-      :updated_registry,
-      :accepted,
-      :changes,
-      :orphaned_models,
-      :failed_sources,
-      :discrepancies,
-      :rejected,
-      :flagged,
-      :sources_used,
-      :source_results
-    ) do
-      def refresh_succeeded?
-        source_results.any? { |_source, result| result.prices.any? }
+    DEFAULT_OUTPUT_PATH = "config/llm_cost_tracker_prices.yml"
+    DEFAULT_REMOTE_URL =
+      "https://raw.githubusercontent.com/sergey-homenko/llm_cost_tracker/main/lib/llm_cost_tracker/prices.json"
+    SUPPORTED_SCHEMA_VERSION = 1
+
+    RefreshResult = Data.define(:path, :source_url, :source_version, :changes, :written, :not_modified)
+    CheckResult = Data.define(:path, :source_url, :source_version, :changes, :up_to_date)
+
+    class << self
+      def configured_output_path(env: ENV, config: LlmCostTracker.configuration)
+        output = env["OUTPUT"].to_s.strip
+        return output unless output.empty?
+
+        prices_file = config.prices_file
+        return prices_file.to_s if prices_file
+
+        default_output_path
       end
 
-      def up_to_date?
-        changes.empty? && failed_sources.empty? && rejected.empty?
+      def configured_remote_url(env: ENV)
+        url = env["URL"].to_s.strip
+        url.empty? ? DEFAULT_REMOTE_URL : url
       end
-    end
 
-    class << self
-      def sync(path: DEFAULT_OUTPUT_PATH, seed_path: DEFAULT_OUTPUT_PATH, preview: false, strict: false,
-               fetcher: Fetcher.new, today: Date.today)
-        plan = RefreshPlanBuilder.new(sources: sources).call(
-          path: path,
-          seed_path: seed_path,
-          fetcher: fetcher,
-          today: today
-        )
-        raise Error, strict_failure_message(plan) if strict_sync_failure?(plan, strict: strict)
-
-        written = !preview && plan.refresh_succeeded?
-        RegistryWriter.new.call(path: plan.path, registry: plan.updated_registry) if written
-
-        SyncResult.new(
-          path: plan.path,
-          updated_models: plan.changes.keys.sort,
-          changes: plan.changes,
-          orphaned_models: plan.orphaned_models,
-          failed_sources: plan.failed_sources,
-          discrepancies: plan.discrepancies,
-          rejected: plan.rejected,
-          flagged: plan.flagged,
-          sources_used: plan.sources_used,
-          written: written
-        )
+      def refresh(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, preview: false, fetcher: Fetcher.new,
+                  today: Date.today)
+        current = load_current_registry(path)
+        response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
+
+        if response.not_modified
+          return refresh_result(path, url, response, current, current, written: false, not_modified: true)
+        end
+
+        remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+        RegistryWriter.new.call(path: path, registry: remote) unless preview
+        refresh_result(path, url, response, current, remote, written: !preview, not_modified: false)
       end
 
-      def check(path: DEFAULT_OUTPUT_PATH, seed_path: DEFAULT_OUTPUT_PATH, fetcher: Fetcher.new, today: Date.today)
-        plan = RefreshPlanBuilder.new(sources: sources).call(
-          path: path,
-          seed_path: seed_path,
-          fetcher: fetcher,
-          today: today
-        )
+      def check(path: DEFAULT_OUTPUT_PATH, url: DEFAULT_REMOTE_URL, fetcher: Fetcher.new, today: Date.today)
+        current = load_current_registry(path)
+        response = fetcher.get(url, etag: current.dig("metadata", "source_version"))
+
+        if response.not_modified
+          return CheckResult.new(
+            path: path,
+            source_url: url,
+            source_version: response.source_version,
+            changes: {},
+            up_to_date: true
+          )
+        end
+
+        remote = normalize_remote_registry(response.body, url: url, response: response, today: today)
+        changes = RegistryDiff.call(current.fetch("models", {}), remote.fetch("models", {}))
 
         CheckResult.new(
-          path: plan.path,
-          changes: plan.changes,
-          orphaned_models: plan.orphaned_models,
-          failed_sources: plan.failed_sources,
-          discrepancies: plan.discrepancies,
-          rejected: plan.rejected,
-          flagged: plan.flagged,
-          sources_used: plan.sources_used,
-          up_to_date: plan.up_to_date?
+          path: path,
+          source_url: url,
+          source_version: response.source_version,
+          changes: changes,
+          up_to_date: changes.empty?
         )
       end
 
       private
 
-      def sources
-        [Sources::Litellm.new, Sources::OpenRouter.new]
+      def default_output_path
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.join(DEFAULT_OUTPUT_PATH).to_s
+        else
+          DEFAULT_OUTPUT_PATH
+        end
       end
 
-      def strict_sync_failure?(plan, strict:)
-        strict && (plan.failed_sources.any? || plan.rejected.any?)
+      def load_current_registry(path)
+        RegistryLoader.new.call(path: path, seed_path: PriceRegistry::DEFAULT_PRICES_PATH)
       end
 
-      def strict_failure_message(plan)
-        messages = []
-        if plan.failed_sources.any?
-          details = plan.failed_sources.map { |source, message| "#{source}: #{message}" }.join(", ")
-          messages << "source failures: #{details}"
+      def normalize_remote_registry(body, url:, response:, today:)
+        registry = parse_registry(body)
+        metadata = registry.fetch("metadata", {})
+        raise Error, "remote pricing metadata must be a hash" unless metadata.is_a?(Hash)
+
+        schema_version = Integer(metadata.fetch("schema_version", 1))
+        if schema_version > SUPPORTED_SCHEMA_VERSION
+          raise Error, "remote pricing schema_version=#{schema_version} requires a newer llm_cost_tracker"
         end
-        if plan.rejected.any?
-          details = plan.rejected.map { |issue| "#{issue.model} (#{issue.reason})" }.join(", ")
-          messages << "validator rejections: #{details}"
+
+        min_gem_version = metadata["min_gem_version"]
+        if min_gem_version && Gem::Version.new(min_gem_version) > Gem::Version.new(LlmCostTracker::VERSION)
+          raise Error, "remote pricing snapshot requires llm_cost_tracker >= #{min_gem_version}"
         end
-        "Price sync failed in strict mode: #{messages.join('; ')}"
+
+        models = registry.fetch("models", {})
+        PriceRegistry.normalize_price_table(models)
+
+        registry.merge(
+          "metadata" => metadata.merge(
+            "schema_version" => schema_version,
+            "updated_at" => metadata["updated_at"] || today.iso8601,
+            "source_url" => url,
+            "source_version" => response.source_version
+          ),
+          "models" => models
+        )
+      rescue ArgumentError, TypeError => e
+        raise Error, "Unable to load remote pricing snapshot: #{e.message}"
+      end
+
+      def parse_registry(body)
+        registry = JSON.parse(body.to_s)
+        raise Error, "remote pricing snapshot must be a JSON object" unless registry.is_a?(Hash)
+
+        registry
+      rescue JSON::ParserError => e
+        raise Error, "Unable to parse remote pricing snapshot: #{e.message}"
+      end
+
+      def refresh_result(path, url, response, current, remote, written:, not_modified:)
+        RefreshResult.new(
+          path: path,
+          source_url: url,
+          source_version: response.source_version,
+          changes: RegistryDiff.call(current.fetch("models", {}), remote.fetch("models", {})),
+          written: written,
+          not_modified: not_modified
+        )
       end
     end
   end