llm_cost_tracker 0.7.0 → 0.7.2

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -21,12 +21,22 @@ module LlmCostTracker
         ].uniq.freeze
       end
 
-      def parse(request_url, request_body, response_status, response_body)
-        parse_openai_usage(request_url, request_body, response_status, response_body)
+      def parse(request_url:, request_body:, response_status:, response_body:, **)
+        parse_openai_usage(
+          request_url: request_url,
+          request_body: request_body,
+          response_status: response_status,
+          response_body: response_body
+        )
       end
 
-      def parse_stream(request_url, request_body, response_status, events)
-        parse_openai_stream_usage(request_url, request_body, response_status, events)
+      def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
+        parse_openai_stream_usage(
+          request_url: request_url,
+          request_body: request_body,
+          response_status: response_status,
+          events: events
+        )
       end
 
       private

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -5,7 +5,7 @@ module LlmCostTracker
     module OpenaiUsage
       private
 
-      def parse_openai_usage(request_url, request_body, response_status, response_body)
+      def parse_openai_usage(request_url:, request_body:, response_status:, response_body:)
         return nil unless response_status == 200
 
         response = safe_json_parse(response_body)
@@ -15,38 +15,44 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
         cache_read = cache_read_input_tokens(usage)
 
-        ParsedUsage.build(
+        model = response["model"] || request["model"]
+
+        UsageCapture.build(
           provider: provider_for(request_url),
           provider_response_id: response["id"],
-          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),
+          pricing_mode: pricing_mode(
+            request_url: request_url,
+            model: model,
+            service_tier: response["service_tier"] || request["service_tier"]
+          ),
+          model: model,
+          token_usage: token_usage(usage: usage, cache_read: cache_read),
           usage_source: :response
         )
       end
 
-      def parse_openai_stream_usage(request_url, request_body, response_status, events)
+      def parse_openai_stream_usage(response_status:, request_url: nil, request_body: nil, events: [])
         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 = pricing_mode(
+          request_url: request_url,
+          model: model,
+          service_tier: 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: usage, cache_read: cache_read),
             stream: true,
             usage_source: :stream_final
           )
@@ -54,7 +60,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,15 +73,41 @@ 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 pricing_mode(request_url:, model:, service_tier:)
+        modes = [Pricing.normalize_mode(service_tier)]
+        modes << "data_residency" if openai_regional_processing?(request_url: request_url, model: model)
+        modes = modes.compact.uniq
+        modes.empty? ? nil : modes.join("_")
       end
 
-      def detect_stream_response_id(events)
-        find_event_value(events) { |data| data["id"] || data.dig("response", "id") }
+      def openai_regional_processing?(request_url:, model:)
+        uri = parsed_uri(request_url)
+        return false unless %w[us.api.openai.com eu.api.openai.com].include?(uri&.host.to_s.downcase)
+
+        openai_data_residency_model?(model)
+      end
+
+      def openai_data_residency_model?(model)
+        model.to_s.match?(/\Agpt-5\.(?:4|5)(?:-(?:mini|nano|pro))?(?:-\d{4}-\d{2}-\d{2})?\z/)
+      end
+
+      def token_usage(usage:, cache_read:)
+        TokenUsage.build(
+          input_tokens: regular_input_tokens(usage: usage, cache_read: cache_read),
+          output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
+          total_tokens: total_tokens(usage: usage, cache_read: cache_read),
+          cache_read_input_tokens: cache_read,
+          hidden_output_tokens: hidden_output_tokens(usage)
+        )
       end
 
-      def regular_input_tokens(usage, cache_read)
+      def regular_input_tokens(usage:, cache_read:)
         [(usage["prompt_tokens"] || usage["input_tokens"]).to_i - cache_read.to_i, 0].max
       end
 
@@ -88,11 +121,11 @@ module LlmCostTracker
         details["reasoning_tokens"]
       end
 
-      def total_tokens(usage, cache_read)
+      def total_tokens(usage:, cache_read:)
         total = usage["total_tokens"]
         return total.to_i unless total.nil?
 
-        regular_input_tokens(usage, cache_read) +
+        regular_input_tokens(usage: usage, cache_read: cache_read) +
           cache_read.to_i +
           (usage["completion_tokens"] || usage["output_tokens"]).to_i
       end

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