llm_cost_tracker 0.7.0 → 0.7.1

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -24,17 +24,13 @@ module LlmCostTracker
 
         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(
+        UsageCapture.build(
           provider: "anthropic",
           provider_response_id: response["id"],
+          pricing_mode: pricing_mode(request, response, usage),
           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 + cache_read + cache_write,
-          cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_write_input_tokens: usage["cache_creation_input_tokens"],
+          token_usage: token_usage(usage, cache_read),
           usage_source: :response
         )
       end
@@ -43,17 +39,18 @@ module LlmCostTracker
         return nil unless response_status == 200
 
         request = safe_json_parse(request_body)
-        model = stream_model(events) || request["model"]
+        model = find_event_value(events) { |data| data.dig("message", "model") } || request["model"]
         usage = stream_usage(events)
-        response_id = stream_response_id(events)
+        response_id = find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
 
         if usage
-          build_stream_result(model, usage, response_id)
+          build_stream_result(model, usage, response_id, pricing_mode(request, nil, usage))
         else
           build_unknown_stream_usage(
             provider: "anthropic",
             model: model,
-            provider_response_id: response_id
+            provider_response_id: response_id,
+            pricing_mode: pricing_mode(request, nil, usage)
           )
         end
       end
@@ -75,33 +72,47 @@ module LlmCostTracker
         end
       end
 
-      def stream_model(events)
-        find_event_value(events) { |data| data.dig("message", "model") }
-      end
+      def build_stream_result(model, usage, response_id, pricing_mode)
+        cache_read = usage["cache_read_input_tokens"].to_i
 
-      def stream_response_id(events)
-        find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
+        UsageCapture.build(
+          provider: "anthropic",
+          provider_response_id: response_id,
+          pricing_mode: pricing_mode,
+          model: model,
+          token_usage: token_usage(usage, cache_read),
+          stream: true,
+          usage_source: :stream_final
+        )
       end
 
-      def build_stream_result(model, usage, response_id)
+      def token_usage(usage, cache_read)
         input = usage["input_tokens"].to_i
         output = usage["output_tokens"].to_i
-        cache_read = usage["cache_read_input_tokens"].to_i
-        cache_write = usage["cache_creation_input_tokens"].to_i
+        cache_creation = usage["cache_creation"]
+        if cache_creation.is_a?(Hash)
+          cache_write = cache_creation["ephemeral_5m_input_tokens"].to_i
+          cache_write_1h = cache_creation["ephemeral_1h_input_tokens"].to_i
+        else
+          cache_write = usage["cache_creation_input_tokens"].to_i
+          cache_write_1h = 0
+        end
 
-        ParsedUsage.build(
-          provider: "anthropic",
-          provider_response_id: response_id,
-          model: model,
+        TokenUsage.build(
           input_tokens: input,
           output_tokens: output,
-          total_tokens: input + output + cache_read + cache_write,
+          total_tokens: input + output + cache_read + cache_write + cache_write_1h,
           cache_read_input_tokens: usage["cache_read_input_tokens"],
-          cache_write_input_tokens: usage["cache_creation_input_tokens"],
-          stream: true,
-          usage_source: :stream_final
+          cache_write_input_tokens: cache_write,
+          cache_write_1h_input_tokens: cache_write_1h
         )
       end
+
+      def pricing_mode(request, response, usage)
+        usage&.fetch("service_tier", nil) ||
+          response&.fetch("service_tier", nil) ||
+          request["service_tier"]
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
 require "json"
 require "uri"
 
@@ -19,10 +20,9 @@ module LlmCostTracker
       end
 
       def streaming_request?(_request_url, request_body)
-        return false if request_body.nil?
+        return false if request_body.blank?
 
         body = request_body.to_s
-        return false if body.empty?
 
         request = safe_json_parse(body)
         request.is_a?(Hash) && request["stream"] == true
@@ -35,7 +35,7 @@ module LlmCostTracker
       private
 
       def safe_json_parse(body)
-        return {} if body.nil? || body.empty?
+        return {} if body.blank?
 
         JSON.parse(body)
       rescue JSON::ParserError
@@ -49,7 +49,7 @@ module LlmCostTracker
 
       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)
+          host_match = hosts.nil? || hosts.include?(uri.host.to_s.downcase)
           path_match = path_matches?(
             uri,
             exact_paths: exact_paths,
@@ -69,10 +69,6 @@ module LlmCostTracker
         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
@@ -98,28 +94,23 @@ module LlmCostTracker
       def find_event_value(events, reverse: false)
         each_event_data(events, reverse:) do |data|
           value = yield(data)
-          return value if event_value_present?(value)
+          return value if value.present?
         end
 
         nil
       end
 
-      def build_unknown_stream_usage(provider:, model:, provider_response_id:)
-        ParsedUsage.build(
+      def build_unknown_stream_usage(provider:, model:, provider_response_id:, pricing_mode: nil)
+        UsageCapture.build(
           provider: provider,
           provider_response_id: provider_response_id,
-          model: model || ParsedUsage::UNKNOWN_MODEL,
-          input_tokens: 0,
-          output_tokens: 0,
-          total_tokens: 0,
+          pricing_mode: pricing_mode,
+          model: model || UsageCapture::UNKNOWN_MODEL,
+          token_usage: TokenUsage.build(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

@@ -18,7 +18,7 @@ module LlmCostTracker
       end
 
       def streaming_request?(request_url, request_body)
-        return true if streaming_url?(request_url)
+        return true if match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
 
         super
       end
@@ -30,7 +30,7 @@ module LlmCostTracker
         usage    = response["usageMetadata"]
         return nil unless usage
 
-        build_parsed_usage(
+        build_usage_capture(
           request_url,
           usage,
           usage_source: :response,
@@ -46,7 +46,7 @@ module LlmCostTracker
         response_id = stream_response_id(events)
 
         if usage
-          build_parsed_usage(
+          build_usage_capture(
             request_url,
             usage,
             stream: true,
@@ -64,17 +64,20 @@ module LlmCostTracker
 
       private
 
-      def build_parsed_usage(request_url, usage, usage_source:, stream: false, provider_response_id: nil)
+      def build_usage_capture(request_url, usage, usage_source:, stream: false, provider_response_id: nil)
         cache_read = usage["cachedContentTokenCount"].to_i
+        tool_use_prompt = usage["toolUsePromptTokenCount"].to_i
 
-        ParsedUsage.build(
+        UsageCapture.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
-          input_tokens: [usage["promptTokenCount"].to_i - cache_read, 0].max,
-          output_tokens: output_tokens(usage),
-          total_tokens: total_tokens(usage, cache_read),
-          cache_read_input_tokens: usage["cachedContentTokenCount"],
-          hidden_output_tokens: usage["thoughtsTokenCount"],
+          token_usage: TokenUsage.build(
+            input_tokens: [usage["promptTokenCount"].to_i - cache_read, 0].max + tool_use_prompt,
+            output_tokens: output_tokens(usage),
+            total_tokens: total_tokens(usage, cache_read, tool_use_prompt),
+            cache_read_input_tokens: usage["cachedContentTokenCount"],
+            hidden_output_tokens: usage["thoughtsTokenCount"]
+          ),
           stream: stream,
           usage_source: usage_source,
           provider_response_id: provider_response_id
@@ -92,21 +95,17 @@ module LlmCostTracker
         usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
       end
 
-      def total_tokens(usage, cache_read)
+      def total_tokens(usage, cache_read, tool_use_prompt)
         total = usage["totalTokenCount"]
         return total.to_i unless total.nil?
 
-        [usage["promptTokenCount"].to_i - cache_read, 0].max + cache_read + output_tokens(usage)
+        [usage["promptTokenCount"].to_i - cache_read, 0].max + cache_read + tool_use_prompt + output_tokens(usage)
       end
 
       def stream_response_id(events)
         find_event_value(events) { |data| data["responseId"] }
       end
 
-      def streaming_url?(request_url)
-        match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
-      end
-
       def extract_model_from_url(url)
         uri = parsed_uri(url)
         return nil unless uri

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -15,15 +15,12 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
         cache_read = cache_read_input_tokens(usage)
 
-        ParsedUsage.build(
+        UsageCapture.build(
           provider: provider_for(request_url),
           provider_response_id: response["id"],
+          pricing_mode: response["service_tier"] || request["service_tier"],
           model: response["model"] || request["model"],
-          input_tokens: regular_input_tokens(usage, cache_read),
-          output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
-          total_tokens: total_tokens(usage, cache_read),
-          cache_read_input_tokens: cache_read,
-          hidden_output_tokens: hidden_output_tokens(usage),
+          token_usage: token_usage(usage, cache_read),
           usage_source: :response
         )
       end
@@ -32,21 +29,20 @@ module LlmCostTracker
         return nil unless response_status == 200
 
         request = safe_json_parse(request_body)
-        model = detect_stream_model(events) || request["model"]
+        model =
+          find_event_value(events) { |data| data["model"] || data.dig("response", "model") } || request["model"]
         usage = detect_stream_usage(events)
-        response_id = detect_stream_response_id(events)
+        response_id = find_event_value(events) { |data| data["id"] || data.dig("response", "id") }
+        pricing_mode = stream_pricing_mode(events) || request["service_tier"]
 
         if usage
           cache_read = cache_read_input_tokens(usage)
-          ParsedUsage.build(
+          UsageCapture.build(
             provider: provider_for(request_url),
             provider_response_id: response_id,
+            pricing_mode: pricing_mode,
             model: model,
-            input_tokens: regular_input_tokens(usage, cache_read),
-            output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
-            total_tokens: total_tokens(usage, cache_read),
-            cache_read_input_tokens: cache_read,
-            hidden_output_tokens: hidden_output_tokens(usage),
+            token_usage: token_usage(usage, cache_read),
             stream: true,
             usage_source: :stream_final
           )
@@ -54,7 +50,8 @@ module LlmCostTracker
           build_unknown_stream_usage(
             provider: provider_for(request_url),
             model: model,
-            provider_response_id: response_id
+            provider_response_id: response_id,
+            pricing_mode: pricing_mode
           )
         end
       end
@@ -66,12 +63,20 @@ module LlmCostTracker
         end
       end
 
-      def detect_stream_model(events)
-        find_event_value(events) { |data| data["model"] || data.dig("response", "model") }
+      def stream_pricing_mode(events)
+        find_event_value(events, reverse: true) do |data|
+          data["service_tier"] || data.dig("response", "service_tier")
+        end
       end
 
-      def detect_stream_response_id(events)
-        find_event_value(events) { |data| data["id"] || data.dig("response", "id") }
+      def token_usage(usage, cache_read)
+        TokenUsage.build(
+          input_tokens: regular_input_tokens(usage, cache_read),
+          output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
+          total_tokens: total_tokens(usage, cache_read),
+          cache_read_input_tokens: cache_read,
+          hidden_output_tokens: hidden_output_tokens(usage)
+        )
       end
 
       def regular_input_tokens(usage, cache_read)

data/lib/llm_cost_tracker/parsers/sse.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/object/blank"
 require "json"
 
 module LlmCostTracker
@@ -9,9 +10,9 @@ module LlmCostTracker
 
       class << self
         def parse(body)
-          return [] if body.nil? || body.empty?
+          return [] if body.blank?
 
-          return parse_json_array(body) if probably_json_array?(body)
+          return parse_json_array(body) if body.lstrip.start_with?("[")
 
           parse_event_stream(body)
         end
@@ -65,16 +66,12 @@ module LlmCostTracker
         end
 
         def decode_data(payload)
-          return payload if payload.empty?
+          return payload if payload.blank?
 
           JSON.parse(payload)
         rescue JSON::ParserError
           payload
         end
-
-        def probably_json_array?(body)
-          body.lstrip.start_with?("[")
-        end
       end
     end
   end

data/lib/llm_cost_tracker/parsers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Parsers
+    BUILT_INS = [Openai.new, OpenaiCompatible.new, Anthropic.new, Gemini.new].freeze
+
+    module_function
+
+    def find_for(url)
+      BUILT_INS.find { |parser| parser.match?(url) }
+    end
+
+    def find_for_provider(provider)
+      provider_name = provider.to_s.downcase
+      BUILT_INS.find do |parser|
+        Array(parser.provider_names).map { |name| name.to_s.downcase }.include?(provider_name)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/prices.json

@@ -17,6 +17,7 @@
       "output": 5.0,
       "cache_read_input": 0.1,
       "cache_write_input": 1.25,
+      "cache_write_1h_input": 2.0,
       "batch_input": 0.5,
       "batch_output": 2.5
     },
@@ -25,6 +26,7 @@
       "output": 75.0,
       "cache_read_input": 1.5,
       "cache_write_input": 18.75,
+      "cache_write_1h_input": 30.0,
       "batch_input": 7.5,
       "batch_output": 37.5
     },
@@ -33,6 +35,7 @@
       "output": 75.0,
       "cache_read_input": 1.5,
       "cache_write_input": 18.75,
+      "cache_write_1h_input": 30.0,
       "batch_input": 7.5,
       "batch_output": 37.5
     },
@@ -41,6 +44,7 @@
       "output": 25.0,
       "cache_read_input": 0.5,
       "cache_write_input": 6.25,
+      "cache_write_1h_input": 10.0,
       "batch_input": 2.5,
       "batch_output": 12.5
     },
@@ -49,6 +53,7 @@
       "output": 25.0,
       "cache_read_input": 0.5,
       "cache_write_input": 6.25,
+      "cache_write_1h_input": 10.0,
       "batch_input": 2.5,
       "batch_output": 12.5
     },
@@ -57,6 +62,7 @@
       "output": 25.0,
       "cache_read_input": 0.5,
       "cache_write_input": 6.25,
+      "cache_write_1h_input": 10.0,
       "batch_input": 2.5,
       "batch_output": 12.5
     },
@@ -65,6 +71,7 @@
       "output": 15.0,
       "cache_read_input": 0.3,
       "cache_write_input": 3.75,
+      "cache_write_1h_input": 6.0,
       "batch_input": 1.5,
       "batch_output": 7.5
     },
@@ -73,6 +80,7 @@
       "output": 15.0,
       "cache_read_input": 0.3,
       "cache_write_input": 3.75,
+      "cache_write_1h_input": 6.0,
       "batch_input": 1.5,
       "batch_output": 7.5
     },
@@ -81,6 +89,7 @@
       "output": 15.0,
       "cache_read_input": 0.3,
       "cache_write_input": 3.75,
+      "cache_write_1h_input": 6.0,
       "batch_input": 1.5,
       "batch_output": 7.5
     },
@@ -89,7 +98,8 @@
       "cache_read_input": 0.025,
       "output": 0.4,
       "batch_input": 0.05,
-      "batch_output": 0.2
+      "batch_output": 0.2,
+      "batch_cache_read_input": 0.025
     },
     "gemini/gemini-2.0-flash-lite": {
       "input": 0.075,
@@ -101,25 +111,32 @@
       "input": 0.3,
       "output": 2.5,
       "cache_read_input": 0.03,
-      "cache_write_input": 0.083333333333,
       "batch_input": 0.15,
-      "batch_output": 1.25
+      "batch_output": 1.25,
+      "batch_cache_read_input": 0.03
     },
     "gemini/gemini-2.5-flash-lite": {
       "input": 0.1,
       "output": 0.4,
       "cache_read_input": 0.01,
-      "cache_write_input": 0.083333333333,
       "batch_input": 0.05,
-      "batch_output": 0.2
+      "batch_output": 0.2,
+      "batch_cache_read_input": 0.01
     },
     "gemini/gemini-2.5-pro": {
       "input": 1.25,
       "output": 10.0,
       "cache_read_input": 0.125,
-      "cache_write_input": 0.375,
       "batch_input": 0.625,
-      "batch_output": 5.0
+      "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,
+      "above_context_cache_read_input": 0.25,
+      "above_context_batch_input": 1.25,
+      "above_context_batch_output": 7.5,
+      "above_context_batch_cache_read_input": 0.25
     },
     "openai/gpt-3.5-turbo": {
       "input": 0.5,
@@ -276,7 +293,14 @@
       "cache_read_input": 0.25,
       "batch_input": 1.25,
       "batch_output": 7.5,
-      "batch_cache_read_input": 0.13
+      "batch_cache_read_input": 0.13,
+      "_context_price_threshold_tokens": 272000,
+      "above_context_input": 5.0,
+      "above_context_output": 22.5,
+      "above_context_cache_read_input": 0.5,
+      "above_context_batch_input": 2.5,
+      "above_context_batch_output": 11.25,
+      "above_context_batch_cache_read_input": 0.25
     },
     "openai/gpt-5.4-mini": {
       "input": 0.75,
@@ -298,7 +322,12 @@
       "input": 30.0,
       "output": 180.0,
       "batch_input": 15.0,
-      "batch_output": 90.0
+      "batch_output": 90.0,
+      "_context_price_threshold_tokens": 272000,
+      "above_context_input": 60.0,
+      "above_context_output": 270.0,
+      "above_context_batch_input": 30.0,
+      "above_context_batch_output": 135.0
     },
     "openai/gpt-5.5": {
       "input": 5.0,
@@ -306,13 +335,23 @@
       "cache_read_input": 0.5,
       "batch_input": 2.5,
       "batch_output": 15.0,
-      "batch_cache_read_input": 0.25
+      "batch_cache_read_input": 0.25,
+      "_context_price_threshold_tokens": 272000,
+      "above_context_input": 10.0,
+      "above_context_output": 45.0,
+      "above_context_cache_read_input": 1.0,
+      "above_context_batch_input": 5.0,
+      "above_context_batch_output": 22.5,
+      "above_context_batch_cache_read_input": 0.5
     },
     "openai/gpt-5.5-pro": {
       "input": 30.0,
       "output": 180.0,
       "batch_input": 15.0,
-      "batch_output": 90.0
+      "batch_output": 90.0,
+      "_context_price_threshold_tokens": 272000,
+      "above_context_input": 60.0,
+      "above_context_output": 270.0
     },
     "openai/o1": {
       "input": 15.0,
@@ -352,6 +391,7 @@
     "anthropic/claude-haiku-3-5": {
       "input": 0.8,
       "cache_write_input": 1.0,
+      "cache_write_1h_input": 1.6,
       "cache_read_input": 0.08,
       "output": 4.0,
       "batch_input": 0.4,
@@ -360,6 +400,7 @@
     "anthropic/claude-haiku-3": {
       "input": 0.25,
       "cache_write_input": 0.3,
+      "cache_write_1h_input": 0.5,
       "cache_read_input": 0.03,
       "output": 1.25,
       "batch_input": 0.125,

data/lib/llm_cost_tracker/pricing/components.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Pricing
+    Component = Data.define(:price_key, :token_key, :cost_key)
+
+    COMPONENTS = [
+      Component.new(
+        price_key: :input,
+        token_key: :input_tokens,
+        cost_key: :input_cost
+      ),
+      Component.new(
+        price_key: :cache_read_input,
+        token_key: :cache_read_input_tokens,
+        cost_key: :cache_read_input_cost
+      ),
+      Component.new(
+        price_key: :cache_write_input,
+        token_key: :cache_write_input_tokens,
+        cost_key: :cache_write_input_cost
+      ),
+      Component.new(
+        price_key: :cache_write_1h_input,
+        token_key: :cache_write_1h_input_tokens,
+        cost_key: :cache_write_1h_input_cost
+      ),
+      Component.new(
+        price_key: :output,
+        token_key: :output_tokens,
+        cost_key: :output_cost
+      )
+    ].freeze
+
+    COST_KEYS = (COMPONENTS.map(&:cost_key) + %i[total_cost]).freeze
+  end
+end