llm_cost_tracker 0.14.0 → 0.14.2

data/lib/llm_cost_tracker/providers/gemini/parser.rb

@@ -1,16 +1,33 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+require "time"
+
 module LlmCostTracker
   module Providers
     module Gemini
       class Parser < LlmCostTracker::Parsers::Base
         HOSTS = %w[generativelanguage.googleapis.com].freeze
-        TRACKED_PATH_PATTERN = %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}
-        STREAM_PATH_PATTERN  = /:streamGenerateContent\z/
+        INTERACTIONS_PATH_PATTERN = %r{/interactions(?:/[^/]+)?\z}
+        CACHE_PATH_PATTERN = %r{/cachedContents\z}
+        TRACKED_PATH_PATTERN = Regexp.union(
+          %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}, INTERACTIONS_PATH_PATTERN, CACHE_PATH_PATTERN
+        )
+        STREAM_PATH_PATTERN = /:streamGenerateContent\z/
+        GROUNDING_FIELDS = {
+          "grounding_request" => "response.candidates.groundingMetadata.webSearchQueries",
+          "maps_grounding_request" => "response.candidates.groundingMetadata.groundingChunks.maps"
+        }.freeze
+        INTERACTION_GROUNDING_KINDS = {
+          "google_search" => "grounding_request",
+          "google_maps" => "maps_grounding_request"
+        }.freeze
 
         class << self
           def match?(url)
-            match_uri?(url, hosts: HOSTS, path_pattern: TRACKED_PATH_PATTERN)
+            uri_matches?(url) do |uri|
+              HOSTS.include?(uri.host.to_s.downcase) && uri.path.to_s.match?(TRACKED_PATH_PATTERN)
+            end
           end
 
           def provider_names
@@ -19,7 +36,7 @@ module LlmCostTracker
         end
 
         def streaming_request?(request_url, request_parsed)
-          return true if match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
+          return true if path_matches?(request_url, STREAM_PATH_PATTERN)
 
           super
         end
@@ -28,34 +45,54 @@ module LlmCostTracker
           return nil unless response_status == 200
 
           response = safe_json_parse(response_body)
-          usage    = response["usageMetadata"]
+          request = safe_json_parse(request_body)
+          if path_matches?(request_url, INTERACTIONS_PATH_PATTERN)
+            event = interaction_event(response, request: request, response_headers: response_headers)
+            return nil if event && path_matches?(request_url, %r{/interactions/[^/]+\z}) &&
+                          Call.already_recorded?(provider: "gemini", provider_response_id: event.provider_response_id)
+
+            return event
+          end
+          return cache_storage_event(response) if path_matches?(request_url, CACHE_PATH_PATTERN)
+
+          usage = response["usageMetadata"]
           return nil unless usage
 
-          request = safe_json_parse(request_body)
-          model = extract_model_from_url(request_url)
+          model = response["modelVersion"].presence || extract_model_from_url(request_url)
           build_event(
-            request_url: request_url,
+            model: model,
             usage: usage,
             usage_source: Usage::Source::RESPONSE,
             provider_response_id: response["responseId"],
             pricing_mode: pricing_mode(request: request, usage: usage, response_headers: response_headers),
-            service_line_items: grounding_line_items(grounding_request_count(response["candidates"]), model: model)
+            service_line_items: service_line_items_for(response, model: model)
           )
         end
 
-        def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], response_headers: nil)
+        def parse_stream(response_status:,
+                         request_url: nil,
+                         request_body: nil,
+                         events: [],
+                         response_headers: nil,
+                         model: nil)
           return nil unless response_status == 200
 
           request = safe_json_parse(request_body)
+          interaction = find_event_value(events, reverse: true) { |data| completed_interaction(data) }
+          if interaction
+            return interaction_event(interaction, request: request, response_headers: response_headers, stream: true)
+          end
+
           usage = merged_stream_usage(events)
-          model = extract_model_from_url(request_url)
-          response_id = stream_response_id(events)
+          model = find_event_value(events, reverse: true) { |data| data["modelVersion"] } ||
+                  extract_model_from_url(request_url) || model || request["model"]
+          response_id = find_event_value(events) { |data| data["responseId"] }
           mode = pricing_mode(request: request, usage: usage, response_headers: response_headers)
           service_line_items = grounding_line_items_for_stream(events, model: model)
 
           if usage
             build_event(
-              request_url: request_url,
+              model: model,
               usage: usage,
               stream: true,
               usage_source: Usage::Source::STREAM_FINAL,
@@ -74,35 +111,96 @@ module LlmCostTracker
           end
         end
 
-        def model_for(request_url, _request_parsed)
-          extract_model_from_url(request_url)
+        def model_for(request_url, request_parsed)
+          extract_model_from_url(request_url) ||
+            (request_parsed["model"] if path_matches?(request_url, INTERACTIONS_PATH_PATTERN))
+        end
+
+        def retain_stream_event?(data)
+          data.is_a?(Hash) && grounding_counts(data["candidates"]).values.any?(&:positive?)
         end
 
         def provider_for(_request_url)
           "gemini"
         end
 
+        def service_line_items_for(response, model:)
+          usage = response["usage"]
+          return grounding_line_items(grounding_counts(response["candidates"]), model: model) unless usage.is_a?(Hash)
+
+          counts = Array(usage["grounding_tool_count"]).each_with_object(Hash.new(0)) do |entry, acc|
+            kind = INTERACTION_GROUNDING_KINDS[entry["type"]]
+            acc[kind] += entry["count"].to_i if kind
+          end
+          grounding_line_items(counts, model: model, provider_field: "response.usage.grounding_tool_count")
+        end
+
+        def interaction_usage_metadata(usage, service_tier)
+          {
+            "promptTokenCount" => usage["total_input_tokens"],
+            "cachedContentTokenCount" => usage["total_cached_tokens"],
+            "toolUsePromptTokenCount" => usage["total_tool_use_tokens"],
+            "candidatesTokenCount" => usage["total_output_tokens"],
+            "thoughtsTokenCount" => usage["total_thought_tokens"],
+            "totalTokenCount" => usage["total_tokens"],
+            "promptTokensDetails" => modality_details(usage["input_tokens_by_modality"]),
+            "cacheTokensDetails" => modality_details(usage["cached_tokens_by_modality"]),
+            "candidatesTokensDetails" => modality_details(usage["output_tokens_by_modality"]),
+            "serviceTier" => service_tier
+          }
+        end
+
+        def cache_storage_event(response)
+          tokens = response.dig("usageMetadata", "totalTokenCount")
+          from = response["createTime"]
+          to = response["expireTime"]
+          return nil unless tokens && from && to
+
+          seconds = Time.iso8601(to) - Time.iso8601(from)
+          Event.build(
+            provider: "gemini",
+            model: response["model"].to_s.delete_prefix("models/"),
+            token_usage: Usage::TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
+            usage_source: Usage::Source::RESPONSE,
+            provider_response_id: response["name"],
+            service_line_items: [
+              Charges::LineItem.build(
+                dimension_key: "cache_storage_token_hour",
+                quantity: BigDecimal(tokens.to_s) * BigDecimal(seconds.to_s) / 3600,
+                cost_status: Charges::CostStatus::UNKNOWN,
+                pricing_basis: "provider_usage",
+                provider_field: "response.usageMetadata.totalTokenCount",
+                details: { cached_tokens: tokens, expire_time: to }
+              )
+            ]
+          )
+        end
+
         private
 
-        def build_event(request_url:,
+        def build_event(model:,
                         usage:,
                         usage_source:,
-                        stream: false,
-                        provider_response_id: nil,
-                        pricing_mode: nil,
-                        service_line_items: nil)
+                        provider_response_id:,
+                        pricing_mode:,
+                        service_line_items:,
+                        stream: false)
           Event.build(
             provider: "gemini",
-            model: extract_model_from_url(request_url),
+            model: model,
             pricing_mode: pricing_mode,
             token_usage: UsageExtractor.token_usage(usage),
             stream: stream,
             usage_source: usage_source,
             provider_response_id: provider_response_id,
-            service_line_items: service_line_items
+            service_line_items: service_line_items + UsageExtractor.cache_read_line_items(usage)
           )
         end
 
+        def path_matches?(url, pattern)
+          uri_matches?(url) { |uri| uri.path.to_s.match?(pattern) }
+        end
+
         def merged_stream_usage(events)
           find_event_value(events, reverse: true) do |data|
             meta = data["usageMetadata"]
@@ -110,10 +208,6 @@ module LlmCostTracker
           end
         end
 
-        def stream_response_id(events)
-          find_event_value(events) { |data| data["responseId"] }
-        end
-
         def extract_model_from_url(url)
           uri = parsed_uri(url)
           return nil unless uri
@@ -137,39 +231,73 @@ module LlmCostTracker
           headers.to_h.find { |key, _value| key.to_s.downcase == name }&.last
         end
 
+        def completed_interaction(data)
+          interaction = data["interaction"]
+          interaction if interaction.is_a?(Hash) && interaction["usage"].is_a?(Hash)
+        end
+
+        def interaction_event(interaction, request:, response_headers:, stream: false)
+          usage = interaction["usage"]
+          return nil unless usage.is_a?(Hash) && !%w[queued in_progress].include?(interaction["status"])
+
+          model = interaction["model"] || request["model"]
+          metadata = interaction_usage_metadata(usage, interaction["service_tier"])
+          build_event(
+            model: model,
+            usage: metadata,
+            stream: stream,
+            usage_source: stream ? Usage::Source::STREAM_FINAL : Usage::Source::RESPONSE,
+            provider_response_id: interaction["id"],
+            pricing_mode: pricing_mode(request: request, usage: metadata, response_headers: response_headers),
+            service_line_items: service_line_items_for(interaction, model: model)
+          ).keyed_by_response_id
+        end
+
+        def modality_details(entries)
+          Array(entries).map do |entry|
+            { "modality" => entry["modality"].to_s.upcase, "tokenCount" => entry["tokens"] }
+          end
+        end
+
         def grounding_line_items_for_stream(events, model:)
-          quantity = find_event_value(events, reverse: true) do |data|
-            count = grounding_request_count(data["candidates"])
-            count if count.positive?
+          counts = find_event_value(events, reverse: true) do |data|
+            candidate_counts = grounding_counts(data["candidates"])
+            candidate_counts if candidate_counts.values.any?(&:positive?)
           end
-          grounding_line_items(quantity || 0, model: model)
+          grounding_line_items(counts || {}, model: model)
         end
 
-        def grounding_request_count(candidates)
-          Array(candidates).sum do |candidate|
-            queries = candidate.dig("groundingMetadata", "webSearchQueries") || []
-            Array(queries).size
+        def grounding_counts(candidates)
+          Array(candidates).each_with_object(Hash.new(0)) do |candidate, counts|
+            meta = candidate["groundingMetadata"]
+            next unless meta.is_a?(Hash)
+
+            queries = unique_query_count(meta["webSearchQueries"])
+            if Array(meta["groundingChunks"]).any? { |chunk| chunk.is_a?(Hash) && chunk.key?("maps") }
+              counts["maps_grounding_request"] += [queries, 1].max
+            else
+              counts["grounding_request"] += queries + unique_query_count(meta["imageSearchQueries"])
+            end
           end
         end
 
-        def grounding_line_items(query_count, model:)
-          return [] unless query_count.positive?
+        def unique_query_count(queries)
+          Array(queries).map { |query| query.to_s.strip }.reject(&:empty?).uniq.size
+        end
+
+        def grounding_line_items(counts, model:, provider_field: nil)
+          counts.filter_map do |kind, count|
+            next unless count.positive?
 
-          billed_quantity = grounding_billed_quantity(query_count, model: model)
-          [
             Charges::LineItem.build(
-              dimension_key: "grounding_request",
-              quantity: billed_quantity,
+              dimension_key: kind,
+              quantity: ModelFamilies.per_query_grounding?(model) ? count : 1,
               cost_status: Charges::CostStatus::UNKNOWN,
               pricing_basis: "provider_usage",
-              provider_field: "response.candidates.groundingMetadata.webSearchQueries",
-              details: { web_search_queries: query_count }
+              provider_field: provider_field || GROUNDING_FIELDS.fetch(kind),
+              details: { web_search_queries: count }
             )
-          ]
-        end
-
-        def grounding_billed_quantity(query_count, model:)
-          ModelFamilies.per_query_grounding?(model) ? query_count : 1
+          end
         end
       end
     end

data/lib/llm_cost_tracker/providers/gemini/usage_extractor.rb

@@ -7,10 +7,10 @@ module LlmCostTracker
         def self.token_usage(usage)
           cache_read = usage["cachedContentTokenCount"].to_i
           tool_use_prompt = usage["toolUsePromptTokenCount"].to_i
-          audio_input = audio_input_tokens(usage)
-          audio_output = audio_output_tokens(usage)
-          image_input = image_input_tokens(usage)
-          image_output = image_output_tokens(usage)
+          audio_input = uncached_prompt_tokens(usage, "AUDIO")
+          audio_output = modality_tokens(usage["candidatesTokensDetails"], "AUDIO")
+          image_input = uncached_prompt_tokens(usage, "IMAGE") + uncached_prompt_tokens(usage, "DOCUMENT")
+          image_output = modality_tokens(usage["candidatesTokensDetails"], "IMAGE")
 
           Usage::TokenUsage.build(
             input_tokens: regular_input_tokens(usage: usage,
@@ -31,6 +31,11 @@ module LlmCostTracker
           )
         end
 
+        def self.cache_read_line_items(usage)
+          audio = modality_tokens(usage["cacheTokensDetails"], "AUDIO")
+          audio.positive? ? [Charges::LineItem.build(dimension_key: "audio_cache_read_input", quantity: audio)] : []
+        end
+
         def self.gross_output_tokens(usage)
           usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
         end
@@ -43,24 +48,10 @@ module LlmCostTracker
           [gross_output_tokens(usage) - audio_output - image_output, 0].max
         end
 
-        def self.audio_input_tokens(usage)
-          prompt_audio = modality_tokens(usage["promptTokensDetails"], "AUDIO")
-          cache_audio = modality_tokens(usage["cacheTokensDetails"], "AUDIO")
-          [prompt_audio - cache_audio, 0].max
-        end
-
-        def self.audio_output_tokens(usage)
-          modality_tokens(usage["candidatesTokensDetails"], "AUDIO")
-        end
-
-        def self.image_input_tokens(usage)
-          prompt_image = modality_tokens(usage["promptTokensDetails"], "IMAGE")
-          cache_image = modality_tokens(usage["cacheTokensDetails"], "IMAGE")
-          [prompt_image - cache_image, 0].max
-        end
-
-        def self.image_output_tokens(usage)
-          modality_tokens(usage["candidatesTokensDetails"], "IMAGE")
+        def self.uncached_prompt_tokens(usage, modality)
+          prompt = modality_tokens(usage["promptTokensDetails"], modality)
+          cached = modality_tokens(usage["cacheTokensDetails"], modality)
+          [prompt - cached, 0].max
         end
 
         def self.modality_tokens(details, modality)

data/lib/llm_cost_tracker/providers/openai/hosts.rb

@@ -18,7 +18,7 @@ module LlmCostTracker
           ae.api.openai.com
         ].freeze
 
-        DATA_RESIDENCY_HOST_PATTERN = /\A[a-z]{2,3}\.api\.openai\.com\z/
+        DATA_RESIDENCY_HOST_PATTERN = /\A(?:[a-z]{2,3}\.api\.openai\.com|us\.api\.x\.ai|api\.(?:eu|us)\.mistral\.ai)\z/
 
         def self.data_residency?(host)
           host.to_s.downcase.match?(DATA_RESIDENCY_HOST_PATTERN)

data/lib/llm_cost_tracker/providers/openai/parser.rb

@@ -6,23 +6,21 @@ module LlmCostTracker
       class Parser < LlmCostTracker::Parsers::Base
         include ResponseParser
 
-        TRACKED_PATHS = %w[
-          /v1/chat/completions
-          /v1/completions
-          /v1/embeddings
-          /v1/responses
-          /v1/images/generations
-          /v1/images/edits
-          /v1/images/variations
-          /v1/audio/transcriptions
-          /v1/audio/translations
-          /v1/audio/speech
-          /v1/moderations
+        TRACKED_ENDPOINTS = %w[
+          chat/completions completions embeddings moderations responses
+          audio/transcriptions audio/translations audio/speech
+          images/generations images/edits images/variations
         ].freeze
+        TRACKED_PATHS = TRACKED_ENDPOINTS.map { |endpoint| "/v1/#{endpoint}" }.freeze
+        RETRIEVE_PATH = %r{\A/v1/responses/resp_[^/]+\z}
 
         class << self
           def match?(url)
-            match_uri?(url, hosts: Hosts::API_HOSTS, exact_paths: TRACKED_PATHS)
+            uri_matches?(url) do |uri|
+              path = uri.path.to_s
+              Hosts::API_HOSTS.include?(uri.host.to_s.downcase) &&
+                (TRACKED_PATHS.include?(path) || path.match?(RETRIEVE_PATH))
+            end
           end
 
           def provider_names

data/lib/llm_cost_tracker/providers/openai/response_parser.rb

@@ -11,13 +11,11 @@ module LlmCostTracker
   module Providers
     module Openai
       module ResponseParser
-        include LlmCostTracker::Providers::Openai::ServiceCharges
-
         class << self
-          def combined_pricing_mode(host:, model:, service_tier:)
+          def combined_pricing_mode(host:, model:, service_tier:, provider: "openai")
             modes = [Pricing::Mode.normalize(service_tier)]
             if Hosts.data_residency?(host) &&
-               Pricing::Matcher.modifier_priced?(provider: "openai", model: model, modifier: "data_residency")
+               Pricing::Matcher.modifier_priced?(provider: provider, model: model, modifier: "data_residency")
               modes << "data_residency"
             end
             Pricing::Mode.compose(modes)
@@ -30,12 +28,17 @@ module LlmCostTracker
             model = response["model"] || request["model"]
             service_line_items =
               ServiceCharges.service_line_items_for(response, request: request, model: model) +
-              ServiceCharges.transcription_line_items(usage)
+              ServiceCharges.transcription_line_items(usage) +
+              ServiceCharges.billed_line_items(usage) +
+              UsageExtractor.cache_read_line_items(usage)
             Event.build(
               provider: provider,
               provider_response_id: response["id"],
               pricing_mode: pricing_mode || combined_pricing_mode(
-                host: host, model: model, service_tier: response["service_tier"] || request["service_tier"]
+                provider: provider,
+                host: host,
+                model: model,
+                service_tier: response["service_tier"] || usage[:service_tier] || request["service_tier"]
               ),
               model: model,
               token_usage: UsageExtractor.token_usage(usage, model: model),
@@ -43,18 +46,44 @@ module LlmCostTracker
               service_line_items: service_line_items
             )
           end
+
+          def retrieved_event(response:, provider:, host:, usage_source:)
+            finished = !%w[queued in_progress].include?(response["status"].to_s)
+            return nil unless finished && response["background"] && response["usage"]
+            return nil if Call.already_recorded?(provider: provider, provider_response_id: response["id"])
+
+            event_from_response(
+              response: response,
+              request: { "tools" => response["tools"] },
+              provider: provider,
+              host: host,
+              usage_source: usage_source
+            )&.keyed_by_response_id
+          end
         end
 
         def parse(request_url:, request_body:, response_status:, response_body:, **)
           return nil unless response_status == 200
 
+          response = safe_json_parse(response_body)
+          host = parsed_uri(request_url)&.host
+          if parsed_uri(request_url)&.path.to_s.include?("/responses/resp_")
+            return ResponseParser.retrieved_event(
+              response: response,
+              provider: provider_for(request_url),
+              host: host,
+              usage_source: Usage::Source::RESPONSE
+            )
+          end
+
+          request = safe_json_parse(request_body)
           ResponseParser.event_from_response(
-            response: safe_json_parse(response_body),
-            request: safe_json_parse(request_body),
+            response: response,
+            request: request,
             provider: provider_for(request_url),
-            host: parsed_uri(request_url)&.host,
+            host: host,
             usage_source: Usage::Source::RESPONSE
-          )
+          ) || speech_event(request_url, request) || transcription_without_usage_event(request_url, request)
         end
 
         def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
@@ -62,34 +91,69 @@ module LlmCostTracker
 
           request = safe_json_parse(request_body)
           usage = detect_stream_usage(events)
-          context = stream_capture_context(events: events, request: request, request_url: request_url)
+          context = stream_capture_context(events: events, request: request, request_url: request_url, usage: usage)
 
-          return build_known_stream_usage(usage: usage, **context) if usage
+          background = find_event_value(events) { |data| data.dig("response", "background") }
+          if usage
+            event = build_known_stream_usage(usage: usage, **context)
+            return background ? event.keyed_by_response_id : event
+          end
 
           warn_missing_stream_usage(request_url: request_url, request: request)
-          build_unknown_stream_usage(**context)
+          build_unknown_stream_usage(**context, service_line_items: background ? [] : context[:service_line_items])
         end
 
-        def auto_enable_stream_usage?(request_url)
+        def auto_enable_stream_usage?(request_url, _request_parsed)
           openai_chat_completions_url?(request_url)
         end
 
+        def retain_stream_event?(data)
+          data.is_a?(Hash) && (data["item"].is_a?(Hash) || data["response"].is_a?(Hash))
+        end
+
         private
 
-        def stream_capture_context(events:, request:, request_url:)
+        def speech_event(request_url, request)
+          uri = parsed_uri(request_url)
+          return nil unless uri && uri.path.to_s.end_with?("/audio/speech")
+
+          Event.build(
+            provider: provider_for(request_url),
+            model: model_for(request_url, request),
+            token_usage: Usage::TokenUsage.build(input_tokens: 0, output_tokens: 0),
+            usage_source: Usage::Source::RESPONSE,
+            service_line_items: ServiceCharges.speech_line_items(request)
+          )
+        end
+
+        def transcription_without_usage_event(request_url, request)
+          uri = parsed_uri(request_url)
+          return nil unless uri && uri.path.to_s.match?(%r{/audio/(?:transcriptions|translations)\z})
+
+          Event.build(
+            provider: provider_for(request_url),
+            model: model_for(request_url, request) || Event::UNKNOWN_MODEL,
+            token_usage: Usage::TokenUsage.build(input_tokens: 0, output_tokens: 0),
+            usage_source: Usage::Source::UNKNOWN
+          )
+        end
+
+        def stream_capture_context(events:, request:, request_url:, usage:)
           model = find_event_value(events) do |data|
             data["model"] || data.dig("response", "model") || data.dig("chunk", "model")
           end || request["model"]
+          provider = provider_for(request_url)
           {
-            provider: provider_for(request_url),
+            provider: provider,
             model: model,
             provider_response_id: find_event_value(events) do |data|
               data["id"] || data.dig("response", "id") || data.dig("chunk", "id")
             end,
-            pricing_mode: pricing_mode(
-              request_url: request_url,
+            pricing_mode: ResponseParser.combined_pricing_mode(
+              provider: provider,
+              host: parsed_uri(request_url)&.host,
               model: model,
-              service_tier: stream_pricing_mode(events) || request["service_tier"]
+              service_tier: stream_pricing_mode(events) || usage&.dig(:service_tier) || request["service_tier"]
             ),
             service_line_items: openai_stream_service_line_items(events, request: request, model: model)
           }
@@ -109,13 +173,14 @@ module LlmCostTracker
             token_usage: UsageExtractor.token_usage(usage, model: model),
             stream: true,
             usage_source: Usage::Source::STREAM_FINAL,
-            service_line_items: service_line_items
+            service_line_items: service_line_items + ServiceCharges.transcription_line_items(usage) +
+                                ServiceCharges.billed_line_items(usage) + UsageExtractor.cache_read_line_items(usage)
           )
         end
 
         def warn_missing_stream_usage(request_url:, request:)
-          return unless request["stream"]
-          return unless openai_chat_completions_url?(request_url)
+          return unless request_url.nil? || request["stream"]
+          return unless request_url ? openai_chat_completions_url?(request_url) : request["messages"]
           return if request.dig("stream_options", "include_usage")
 
           Logging.warn(
@@ -132,7 +197,8 @@ module LlmCostTracker
 
         def detect_stream_usage(events)
           usage = find_event_value(events, reverse: true) do |data|
-            candidate = data["usage"] || data.dig("response", "usage") || data.dig("chunk", "usage")
+            candidate = data["usage"] || data.dig("response", "usage") || data.dig("chunk", "usage") ||
+                        data.dig("x_groq", "usage") || data.dig("chunk", "x_groq", "usage")
             candidate if candidate.is_a?(Hash)
           end
           usage&.deep_symbolize_keys
@@ -144,10 +210,18 @@ module LlmCostTracker
           end
         end
 
-        def pricing_mode(request_url:, model:, service_tier:)
-          ResponseParser.combined_pricing_mode(host: parsed_uri(request_url)&.host,
-                                               model: model,
-                                               service_tier: service_tier)
+        def openai_stream_service_line_items(events, request: nil, model: nil)
+          response = { "output" => [] }
+          each_event_data(events) do |data|
+            response["output"].concat(Array(data.dig("response", "output")))
+            response["output"] << data["item"] if data["item"]
+            chunk = data["chunk"] || data
+            next unless chunk["choices"].is_a?(Array)
+
+            response["id"] ||= chunk["id"]
+            response["choices"] ||= chunk["choices"]
+          end
+          ServiceCharges.service_line_items_for(response, request: request, model: model)
         end
       end
     end