llm_cost_tracker 0.3.3 → 0.4.1

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
 require_relative "base"
 
 module LlmCostTracker
@@ -10,10 +8,7 @@ module LlmCostTracker
       HOSTS = %w[api.anthropic.com].freeze
 
       def match?(url)
-        uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host.to_s.downcase) && uri.path.include?("/v1/messages")
-      rescue URI::InvalidURIError
-        false
+        match_uri?(url, hosts: HOSTS, path_includes: "/v1/messages")
       end
 
       def provider_names
@@ -28,6 +23,8 @@ module LlmCostTracker
         return nil unless usage
 
         request = safe_json_parse(request_body)
+        cache_read = usage["cache_read_input_tokens"].to_i
+        cache_write = usage["cache_creation_input_tokens"].to_i
 
         ParsedUsage.build(
           provider: "anthropic",
@@ -35,10 +32,9 @@ module LlmCostTracker
           model: response["model"] || request["model"],
           input_tokens: usage["input_tokens"].to_i,
           output_tokens: usage["output_tokens"].to_i,
-          total_tokens: usage["input_tokens"].to_i + usage["output_tokens"].to_i +
-            usage["cache_read_input_tokens"].to_i + usage["cache_creation_input_tokens"].to_i,
+          total_tokens: usage["input_tokens"].to_i + usage["output_tokens"].to_i + cache_read + cache_write,
           cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          cache_write_input_tokens: usage["cache_creation_input_tokens"],
           usage_source: :response
         )
       end
@@ -51,25 +47,25 @@ module LlmCostTracker
         usage = stream_usage(events)
         response_id = stream_response_id(events)
 
-        usage ? build_stream_result(model, usage, response_id) : build_unknown_stream_result(model, response_id)
+        if usage
+          build_stream_result(model, usage, response_id)
+        else
+          build_unknown_stream_usage(
+            provider: "anthropic",
+            model: model,
+            provider_response_id: response_id
+          )
+        end
       end
 
       private
 
       def stream_usage(events)
-        start_usage = nil
-        latest_delta = nil
-
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
-          case data["type"]
-          when "message_start"
-            start_usage = data.dig("message", "usage")
-          when "message_delta"
-            latest_delta = data["usage"] if data["usage"].is_a?(Hash)
-          end
+        start_usage = find_event_value(events, reverse: true) do |data|
+          data.dig("message", "usage") if data["type"] == "message_start"
+        end
+        latest_delta = find_event_value(events, reverse: true) do |data|
+          data["usage"] if data["type"] == "message_delta" && data["usage"].is_a?(Hash)
         end
 
         return nil unless start_usage || latest_delta
@@ -80,32 +76,18 @@ module LlmCostTracker
       end
 
       def stream_model(events)
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
-          model = data.dig("message", "model")
-          return model if model && !model.empty?
-        end
-        nil
+        find_event_value(events) { |data| data.dig("message", "model") }
       end
 
       def stream_response_id(events)
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
-          id = data.dig("message", "id") || data["id"]
-          return id if id && !id.to_s.empty?
-        end
-        nil
+        find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
       end
 
       def build_stream_result(model, usage, response_id)
         input = usage["input_tokens"].to_i
         output = usage["output_tokens"].to_i
         cache_read = usage["cache_read_input_tokens"].to_i
-        cache_creation = usage["cache_creation_input_tokens"].to_i
+        cache_write = usage["cache_creation_input_tokens"].to_i
 
         ParsedUsage.build(
           provider: "anthropic",
@@ -113,26 +95,13 @@ module LlmCostTracker
           model: model,
           input_tokens: input,
           output_tokens: output,
-          total_tokens: input + output + cache_read + cache_creation,
+          total_tokens: input + output + cache_read + cache_write,
           cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          cache_write_input_tokens: usage["cache_creation_input_tokens"],
           stream: true,
           usage_source: :stream_final
         )
       end
-
-      def build_unknown_stream_result(model, response_id)
-        ParsedUsage.build(
-          provider: "anthropic",
-          provider_response_id: response_id,
-          model: model,
-          input_tokens: 0,
-          output_tokens: 0,
-          total_tokens: 0,
-          stream: true,
-          usage_source: :unknown
-        )
-      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "uri"
 
 module LlmCostTracker
   module Parsers
@@ -40,6 +41,85 @@ module LlmCostTracker
       rescue JSON::ParserError
         {}
       end
+
+      def uri_matches?(url)
+        uri = parsed_uri(url)
+        uri ? yield(uri) : false
+      end
+
+      def match_uri?(url, hosts: nil, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
+        uri_matches?(url) do |uri|
+          host_match = hosts.nil? || host_matches?(uri, hosts)
+          path_match = path_matches?(
+            uri,
+            exact_paths: exact_paths,
+            path_includes: path_includes,
+            path_suffixes: path_suffixes,
+            path_pattern: path_pattern
+          )
+          extra_match = block_given? ? yield(uri) : true
+
+          host_match && path_match && extra_match ? true : false
+        end
+      end
+
+      def parsed_uri(url)
+        URI.parse(url.to_s)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def host_matches?(uri, hosts)
+        hosts.include?(uri.host.to_s.downcase)
+      end
+
+      def path_matches?(uri, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
+        path = uri.path.to_s
+        matches = true
+
+        matches &&= exact_paths.include?(path) if exact_paths
+        matches &&= Array(path_includes).all? { |fragment| path.include?(fragment) } if path_includes
+        matches &&= path.match?(path_pattern) if path_pattern
+
+        matches &&= path_suffixes.any? { |suffix| path == suffix || path.end_with?(suffix) } if path_suffixes
+
+        matches
+      end
+
+      def each_event_data(events, reverse: false)
+        enumerator = reverse ? events.reverse_each : events.each
+
+        enumerator.each do |event|
+          data = event[:data]
+          yield data if data.is_a?(Hash)
+        end
+      end
+
+      def find_event_value(events, reverse: false)
+        each_event_data(events, reverse:) do |data|
+          value = yield(data)
+          return value if event_value_present?(value)
+        end
+
+        nil
+      end
+
+      def build_unknown_stream_usage(provider:, model:, provider_response_id:)
+        ParsedUsage.build(
+          provider: provider,
+          provider_response_id: provider_response_id,
+          model: model,
+          input_tokens: 0,
+          output_tokens: 0,
+          total_tokens: 0,
+          stream: true,
+          usage_source: :unknown
+        )
+      end
+
+      def event_value_present?(value)
+        !value.nil? && (!value.respond_to?(:empty?) || !value.empty?)
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
 require_relative "base"
 
 module LlmCostTracker
@@ -12,10 +10,7 @@ module LlmCostTracker
       STREAM_PATH_PATTERN  = /:streamGenerateContent\z/
 
       def match?(url)
-        uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host.to_s.downcase) && uri.path.match?(TRACKED_PATH_PATTERN)
-      rescue URI::InvalidURIError
-        false
+        match_uri?(url, hosts: HOSTS, path_pattern: TRACKED_PATH_PATTERN)
       end
 
       def provider_names
@@ -48,6 +43,7 @@ module LlmCostTracker
 
         usage = merged_stream_usage(events)
         model = extract_model_from_url(request_url)
+        response_id = stream_response_id(events)
 
         if usage
           build_parsed_usage(
@@ -55,18 +51,13 @@ module LlmCostTracker
             usage,
             stream: true,
             usage_source: :stream_final,
-            provider_response_id: stream_response_id(events)
+            provider_response_id: response_id
           )
         else
-          ParsedUsage.build(
+          build_unknown_stream_usage(
             provider: "gemini",
-            provider_response_id: stream_response_id(events),
             model: model,
-            input_tokens: 0,
-            output_tokens: 0,
-            total_tokens: 0,
-            stream: true,
-            usage_source: :unknown
+            provider_response_id: response_id
           )
         end
       end
@@ -74,13 +65,16 @@ module LlmCostTracker
       private
 
       def build_parsed_usage(request_url, usage, usage_source:, stream: false, provider_response_id: nil)
+        cache_read = usage["cachedContentTokenCount"].to_i
+
         ParsedUsage.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
-          input_tokens: usage["promptTokenCount"].to_i,
+          input_tokens: [usage["promptTokenCount"].to_i - cache_read, 0].max,
           output_tokens: output_tokens(usage),
           total_tokens: usage["totalTokenCount"].to_i,
-          cached_input_tokens: usage["cachedContentTokenCount"],
+          cache_read_input_tokens: usage["cachedContentTokenCount"],
+          hidden_output_tokens: usage["thoughtsTokenCount"],
           stream: stream,
           usage_source: usage_source,
           provider_response_id: provider_response_id
@@ -88,15 +82,10 @@ module LlmCostTracker
       end
 
       def merged_stream_usage(events)
-        latest = nil
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
+        find_event_value(events, reverse: true) do |data|
           meta = data["usageMetadata"]
-          latest = meta if meta.is_a?(Hash)
+          meta if meta.is_a?(Hash)
         end
-        latest
       end
 
       def output_tokens(usage)
@@ -104,28 +93,19 @@ module LlmCostTracker
       end
 
       def stream_response_id(events)
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
-          id = data["responseId"]
-          return id if id && !id.to_s.empty?
-        end
-        nil
+        find_event_value(events) { |data| data["responseId"] }
       end
 
       def streaming_url?(request_url)
-        URI.parse(request_url.to_s).path.match?(STREAM_PATH_PATTERN)
-      rescue URI::InvalidURIError
-        false
+        match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
       end
 
       def extract_model_from_url(url)
-        uri = URI.parse(url.to_s)
+        uri = parsed_uri(url)
+        return nil unless uri
+
         match = uri.path.match(%r{/models/([^/:]+)})
         match && match[1]
-      rescue URI::InvalidURIError
-        nil
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
 require_relative "base"
 require_relative "openai_usage"
 
@@ -14,10 +12,7 @@ module LlmCostTracker
       TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
 
       def match?(url)
-        uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host.to_s.downcase) && TRACKED_PATHS.include?(uri.path)
-      rescue URI::InvalidURIError
-        false
+        match_uri?(url, hosts: HOSTS, exact_paths: TRACKED_PATHS)
       end
 
       def provider_names

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "uri"
-
 require_relative "base"
 require_relative "openai_usage"
 
@@ -13,10 +11,7 @@ module LlmCostTracker
       TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
 
       def match?(url)
-        uri = URI.parse(url.to_s)
-        !provider_for_host(uri.host).nil? && tracked_path?(uri.path)
-      rescue URI::InvalidURIError
-        false
+        match_uri?(url, path_suffixes: TRACKED_PATH_SUFFIXES) { |uri| provider_for_uri(uri) }
       end
 
       def provider_names
@@ -37,18 +32,14 @@ module LlmCostTracker
       private
 
       def provider_for(request_url)
-        uri = URI.parse(request_url.to_s)
-        provider_for_host(uri.host) || "openai_compatible"
-      rescue URI::InvalidURIError
-        "openai_compatible"
+        uri = parsed_uri(request_url)
+        provider_for_uri(uri) || "openai_compatible"
       end
 
-      def provider_for_host(host)
-        LlmCostTracker.configuration.openai_compatible_providers[host.to_s.downcase]&.to_s
-      end
+      def provider_for_uri(uri)
+        return nil unless uri
 
-      def tracked_path?(path)
-        TRACKED_PATH_SUFFIXES.any? { |suffix| path == suffix || path.end_with?(suffix) }
+        LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -13,15 +13,17 @@ module LlmCostTracker
         return nil unless usage
 
         request = safe_json_parse(request_body)
+        cache_read = cache_read_input_tokens(usage)
 
         ParsedUsage.build(
           provider: provider_for(request_url),
           provider_response_id: response["id"],
           model: response["model"] || request["model"],
-          input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
+          input_tokens: regular_input_tokens(usage, cache_read),
           output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
           total_tokens: usage["total_tokens"].to_i,
-          cached_input_tokens: cached_input_tokens(usage),
+          cache_read_input_tokens: cache_read,
+          hidden_output_tokens: hidden_output_tokens(usage),
           usage_source: :response
         )
       end
@@ -32,70 +34,59 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
         model = detect_stream_model(events) || request["model"]
         usage = detect_stream_usage(events)
+        response_id = detect_stream_response_id(events)
 
         if usage
+          cache_read = cache_read_input_tokens(usage)
           ParsedUsage.build(
             provider: provider_for(request_url),
-            provider_response_id: detect_stream_response_id(events),
+            provider_response_id: response_id,
             model: model,
-            input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
+            input_tokens: regular_input_tokens(usage, cache_read),
             output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
             total_tokens: usage["total_tokens"].to_i,
-            cached_input_tokens: cached_input_tokens(usage),
+            cache_read_input_tokens: cache_read,
+            hidden_output_tokens: hidden_output_tokens(usage),
             stream: true,
             usage_source: :stream_final
           )
         else
-          ParsedUsage.build(
+          build_unknown_stream_usage(
             provider: provider_for(request_url),
-            provider_response_id: detect_stream_response_id(events),
             model: model,
-            input_tokens: 0,
-            output_tokens: 0,
-            total_tokens: 0,
-            stream: true,
-            usage_source: :unknown
+            provider_response_id: response_id
           )
         end
       end
 
       def detect_stream_usage(events)
-        events.reverse_each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
+        find_event_value(events, reverse: true) do |data|
           usage = data["usage"]
-          return usage if usage.is_a?(Hash) && !usage.empty?
+          usage if usage.is_a?(Hash)
         end
-        nil
       end
 
       def detect_stream_model(events)
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
-
-          model = data["model"]
-          return model if model && !model.to_s.empty?
-        end
-        nil
+        find_event_value(events) { |data| data["model"] }
       end
 
       def detect_stream_response_id(events)
-        events.each do |event|
-          data = event[:data]
-          next unless data.is_a?(Hash)
+        find_event_value(events) { |data| data["id"] || data.dig("response", "id") }
+      end
 
-          id = data["id"] || data.dig("response", "id")
-          return id if id && !id.to_s.empty?
-        end
-        nil
+      def regular_input_tokens(usage, cache_read)
+        [(usage["prompt_tokens"] || usage["input_tokens"]).to_i - cache_read.to_i, 0].max
       end
 
-      def cached_input_tokens(usage)
+      def cache_read_input_tokens(usage)
         details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
         details["cached_tokens"]
       end
+
+      def hidden_output_tokens(usage)
+        details = usage["completion_tokens_details"] || usage["output_tokens_details"] || {}
+        details["reasoning_tokens"]
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/registry.rb

@@ -13,10 +13,14 @@ module LlmCostTracker
         end
 
         def register(parser)
+          parser = coerce_parser(parser)
+
           MUTEX.synchronize do
             current = @parsers || default_parsers.freeze
             @parsers = ([parser] + current).freeze
           end
+
+          parser
         end
 
         def find_for(url)
@@ -24,8 +28,8 @@ module LlmCostTracker
         end
 
         def find_for_provider(provider)
-          provider_name = provider.to_s
-          parsers.find { |parser| parser.provider_names.include?(provider_name) }
+          provider_name = provider.to_s.downcase
+          parsers.find { |parser| provider_names_for(parser).include?(provider_name) }
         end
 
         def reset!
@@ -34,6 +38,17 @@ module LlmCostTracker
 
         private
 
+        def coerce_parser(parser)
+          return parser.new if parser.is_a?(Class) && parser <= Base
+          return parser if parser.is_a?(Base)
+
+          raise ArgumentError, "parser must be a LlmCostTracker::Parsers::Base instance or class"
+        end
+
+        def provider_names_for(parser)
+          Array(parser.provider_names).map { |name| name.to_s.downcase }
+        end
+
         def default_parsers
           [Openai.new, OpenaiCompatible.new, Anthropic.new, Gemini.new]
         end

data/lib/llm_cost_tracker/period_total.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module LlmCostTracker
+  class PeriodTotal < ActiveRecord::Base
+    self.table_name = "llm_cost_tracker_period_totals"
+  end
+end

data/lib/llm_cost_tracker/price_registry.rb

@@ -10,7 +10,7 @@ module LlmCostTracker
   module PriceRegistry
     DEFAULT_PRICES_PATH = File.expand_path("prices.json", __dir__)
     EMPTY_PRICES = {}.freeze
-    PRICE_KEYS = %w[input cached_input output cache_read_input cache_creation_input].freeze
+    PRICE_KEYS = %w[input output cache_read_input cache_write_input].freeze
     METADATA_KEYS = %w[_source _source_version _fetched_at _updated _notes _validator_override].freeze
     MUTEX = Monitor.new
 
@@ -60,7 +60,7 @@ module LlmCostTracker
       def normalize_price_entry(price)
         price.each_with_object({}) do |(key, value), normalized|
           key = key.to_s
-          normalized[key.to_sym] = Float(value) if PRICE_KEYS.include?(key)
+          normalized[key.to_sym] = Float(value) if price_key?(key)
         end
       end
 
@@ -80,15 +80,25 @@ module LlmCostTracker
       end
 
       def warn_unknown_keys(model, price, path)
-        unknown_keys = price.keys.map(&:to_s) - PRICE_KEYS - METADATA_KEYS
+        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}"
+          "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)
         contents = File.read(path)
         return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)

data/lib/llm_cost_tracker/price_sync/merger.rb

@@ -6,7 +6,7 @@ module LlmCostTracker
       Discrepancy = Data.define(:model, :field, :values)
 
       PRIORITY_ORDER = %i[litellm openrouter].freeze
-      SUPPLEMENTAL_FIELDS = %i[cached_input cache_read_input cache_creation_input].freeze
+      SUPPLEMENTAL_FIELDS = %i[cache_read_input cache_write_input].freeze
 
       def merge(results_by_source)
         prices = collect_prices(results_by_source)

data/lib/llm_cost_tracker/price_sync/raw_price.rb

@@ -7,24 +7,22 @@ module LlmCostTracker
       :provider,
       :input,
       :output,
-      :cached_input,
       :cache_read_input,
-      :cache_creation_input,
+      :cache_write_input,
       :source,
       :source_version,
       :fetched_at
     )
 
     class RawPrice
-      PRICE_FIELDS = %w[input output cached_input cache_read_input cache_creation_input].freeze
+      PRICE_FIELDS = %w[input output cache_read_input cache_write_input].freeze
 
       def to_registry_entry(today:)
         {
           "input" => input,
           "output" => output,
-          "cached_input" => cached_input,
           "cache_read_input" => cache_read_input,
-          "cache_creation_input" => cache_creation_input,
+          "cache_write_input" => cache_write_input,
           "_source" => source.to_s,
           "_source_version" => source_version,
           "_fetched_at" => fetched_at || today.iso8601