llm_cost_tracker 0.7.1 → 0.7.2

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -8,7 +8,19 @@ module LlmCostTracker
     class Openai < Base
       include OpenaiUsage
 
-      HOSTS = %w[api.openai.com].freeze
+      HOSTS = %w[
+        api.openai.com
+        us.api.openai.com
+        eu.api.openai.com
+        au.api.openai.com
+        ca.api.openai.com
+        jp.api.openai.com
+        in.api.openai.com
+        sg.api.openai.com
+        kr.api.openai.com
+        gb.api.openai.com
+        ae.api.openai.com
+      ].freeze
       TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
 
       def match?(url)
@@ -19,12 +31,22 @@ module LlmCostTracker
         %w[openai]
       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_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,17 +15,23 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
         cache_read = cache_read_input_tokens(usage)
 
+        model = response["model"] || request["model"]
+
         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"],
-          token_usage: token_usage(usage, cache_read),
+          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)
@@ -33,7 +39,11 @@ module LlmCostTracker
           find_event_value(events) { |data| data["model"] || data.dig("response", "model") } || request["model"]
         usage = detect_stream_usage(events)
         response_id = find_event_value(events) { |data| data["id"] || data.dig("response", "id") }
-        pricing_mode = stream_pricing_mode(events) || request["service_tier"]
+        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)
@@ -42,7 +52,7 @@ module LlmCostTracker
             provider_response_id: response_id,
             pricing_mode: pricing_mode,
             model: model,
-            token_usage: token_usage(usage, cache_read),
+            token_usage: token_usage(usage: usage, cache_read: cache_read),
             stream: true,
             usage_source: :stream_final
           )
@@ -69,17 +79,35 @@ module LlmCostTracker
         end
       end
 
-      def token_usage(usage, cache_read)
+      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 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, cache_read),
+          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, cache_read),
+          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
 
@@ -93,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