llm_cost_tracker 0.14.1 → 0.15.0

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

@@ -1,16 +1,34 @@
 # 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}
+        INTERACTION_RETRIEVE_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/
+        MODEL_PATH_PATTERN = %r{/models/([^/:]+)}
+        PENDING_STATUSES = %w[queued in_progress].freeze
+        TRAFFIC_TYPE_MODES = {
+          "ON_DEMAND" => nil,
+          "TRAFFIC_TYPE_UNSPECIFIED" => nil,
+          "ON_DEMAND_PRIORITY" => "priority",
+          "ON_DEMAND_FLEX" => "flex"
+        }.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,161 +37,204 @@ module LlmCostTracker
         end
 
         def streaming_request?(request_url, request_parsed)
-          return true if match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
-
-          super
+          path_matches?(request_url, STREAM_PATH_PATTERN) || super
         end
 
         def parse(request_url:, request_body:, response_status:, response_body:, response_headers: nil)
           return nil unless response_status == 200
 
           response = safe_json_parse(response_body)
-          usage    = response["usageMetadata"]
-          return nil unless usage
-
           request = safe_json_parse(request_body)
-          model = extract_model_from_url(request_url)
-          build_event(
-            request_url: request_url,
-            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)
-          )
+          if path_matches?(request_url, INTERACTIONS_PATH_PATTERN)
+            return interaction_response_event(response, request_url:, request:, response_headers:)
+          end
+          return cache_storage_event(response) if path_matches?(request_url, CACHE_PATH_PATTERN)
+
+          content_event(response, request_url:, request:, response_headers:)
         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)
-          usage = merged_stream_usage(events)
-          model = extract_model_from_url(request_url)
-          response_id = stream_response_id(events)
-          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,
-              usage: usage,
-              stream: true,
-              usage_source: Usage::Source::STREAM_FINAL,
-              provider_response_id: response_id,
-              pricing_mode: mode,
-              service_line_items: service_line_items
-            )
-          else
-            build_unknown_stream_usage(
-              provider: "gemini",
-              model: model,
-              provider_response_id: response_id,
-              pricing_mode: mode,
-              service_line_items: service_line_items
-            )
-          end
+          interaction = find_event_value(events, reverse: true) { |data| completed_interaction(data) }
+          return interaction_event(interaction, request:, response_headers:, stream: true) if interaction
+
+          content_stream_event(events, request:, request_url:, response_headers:, fallback_model: model)
         end
 
-        def model_for(request_url, _request_parsed)
-          extract_model_from_url(request_url)
+        def model_for(request_url, request_parsed)
+          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_request_count(data["candidates"]).positive?
+          data.is_a?(Hash) && Grounding.from_candidates(data["candidates"]).any?
         end
 
         def provider_for(_request_url)
           "gemini"
         end
 
-        private
+        def service_line_items_for(response, model:)
+          Grounding.from_response(response).line_items(model: model)
+        end
+
+        def cache_storage_event(response)
+          tokens = response.dig("usageMetadata", "totalTokenCount")
+          from = response["createTime"]
+          to = response["expireTime"]
+          return nil unless tokens && from && to
 
-        def build_event(request_url:,
-                        usage:,
-                        usage_source:,
-                        stream: false,
-                        provider_response_id: nil,
-                        pricing_mode: nil,
-                        service_line_items: nil)
           Event.build(
             provider: "gemini",
-            model: extract_model_from_url(request_url),
-            pricing_mode: pricing_mode,
-            token_usage: UsageExtractor.token_usage(usage),
+            model: response["model"].to_s.split("/").last,
+            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: [cache_storage_line_item(tokens, from, to)]
+          )
+        end
+
+        def pricing_mode(request:, usage:, response_headers:, host: nil, model: nil)
+          regional = Openai::Hosts.vertex_non_global?(host) &&
+                     Pricing::Matcher.modifier_priced?(provider: "gemini", model: model, modifier: "data_residency")
+          Pricing::Mode.compose([service_tier(request, usage, response_headers), ("data_residency" if regional)])
+        end
+
+        private
+
+        def interaction_response_event(response, request_url:, request:, response_headers:)
+          event = interaction_event(response, request:, response_headers:)
+          return event unless event && path_matches?(request_url, INTERACTION_RETRIEVE_PATH_PATTERN)
+
+          event unless Call.already_recorded?(provider: "gemini", provider_response_id: event.provider_response_id)
+        end
+
+        def interaction_event(interaction, request:, response_headers:, stream: false)
+          usage = interaction["usage"]
+          return nil unless usage.is_a?(Hash) && !PENDING_STATUSES.include?(interaction["status"])
+
+          model = interaction["model"] || request["model"]
+          metadata = UsageExtractor.from_interaction(usage, interaction["service_tier"])
+          build_event(
+            model: model,
+            usage: metadata,
             stream: stream,
-            usage_source: usage_source,
-            provider_response_id: provider_response_id,
-            service_line_items: service_line_items
+            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 content_event(response, request_url:, request:, response_headers:)
+          usage = response["usageMetadata"]
+          return nil unless usage
+
+          model = response["modelVersion"].presence || model_from_url(request_url)
+          host = parsed_uri(request_url)&.host
+          build_event(
+            model: model,
+            usage: usage,
+            usage_source: Usage::Source::RESPONSE,
+            provider_response_id: response["responseId"],
+            pricing_mode: pricing_mode(request:, usage:, response_headers:, host:, model:),
+            service_line_items: service_line_items_for(response, model: model)
           )
         end
 
-        def merged_stream_usage(events)
-          find_event_value(events, reverse: true) do |data|
-            meta = data["usageMetadata"]
-            meta if meta.is_a?(Hash)
-          end
+        def content_stream_event(events, request:, request_url:, response_headers:, fallback_model:)
+          usage = last_usage_metadata(events)
+          model = find_event_value(events, reverse: true) { |data| data["modelVersion"] } ||
+                  model_from_url(request_url) || fallback_model || request["model"]
+          host = parsed_uri(request_url)&.host
+          attributes = {
+            model: model,
+            provider_response_id: find_event_value(events) { |data| data["responseId"] },
+            pricing_mode: pricing_mode(request:, usage:, response_headers:, host:, model:),
+            service_line_items: stream_grounding_line_items(events, model: model)
+          }
+          return build_unknown_stream_usage(provider: "gemini", **attributes) unless usage
+
+          build_event(usage: usage, stream: true, usage_source: Usage::Source::STREAM_FINAL, **attributes)
         end
 
-        def stream_response_id(events)
-          find_event_value(events) { |data| data["responseId"] }
+        def build_event(usage:, service_line_items:, **attributes)
+          Event.build(
+            provider: "gemini",
+            token_usage: UsageExtractor.token_usage(usage),
+            service_line_items: service_line_items + UsageExtractor.line_items(usage),
+            **attributes
+          )
         end
 
-        def extract_model_from_url(url)
-          uri = parsed_uri(url)
-          return nil unless uri
+        def cache_storage_line_item(tokens, from, to)
+          seconds = Time.iso8601(to) - Time.iso8601(from)
+          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
 
-          match = uri.path.match(%r{/models/([^/:]+)})
-          match && match[1]
+        def service_tier(request, usage, response_headers)
+          reported_service_tier(usage) ||
+            Pricing::Mode.normalize(response_header(response_headers, "x-gemini-service-tier")) ||
+            requested_flex_tier(request)
         end
 
-        def pricing_mode(request:, usage:, response_headers:)
-          body_mode = Pricing::Mode.normalize(usage && usage["serviceTier"])
-          return body_mode if body_mode
+        def reported_service_tier(usage)
+          return nil unless usage
 
-          header_mode = Pricing::Mode.normalize(response_header(response_headers, "x-gemini-service-tier"))
-          return header_mode if header_mode
+          traffic = usage["trafficType"]
+          Pricing::Mode.normalize(usage["serviceTier"]) ||
+            TRAFFIC_TYPE_MODES.fetch(traffic.to_s) { Pricing::Mode.normalize(traffic) }
+        end
 
-          request_mode = Pricing::Mode.normalize(request["service_tier"] || request["serviceTier"])
-          request_mode == "flex" ? request_mode : nil
+        def requested_flex_tier(request)
+          "flex" if Pricing::Mode.normalize(request["service_tier"] || request["serviceTier"]) == "flex"
         end
 
         def response_header(headers, name)
           headers.to_h.find { |key, _value| key.to_s.downcase == name }&.last
         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?
-          end
-          grounding_line_items(quantity || 0, model: model)
+        def path_matches?(url, pattern)
+          uri_matches?(url) { |uri| uri.path.to_s.match?(pattern) }
         end
 
-        def grounding_request_count(candidates)
-          Array(candidates).sum do |candidate|
-            queries = candidate.dig("groundingMetadata", "webSearchQueries") || []
-            Array(queries).size
-          end
+        def model_from_url(url)
+          uri = parsed_uri(url)
+          uri.path[MODEL_PATH_PATTERN, 1] if uri
         end
 
-        def grounding_line_items(query_count, model:)
-          return [] unless query_count.positive?
+        def last_usage_metadata(events)
+          find_event_value(events, reverse: true) do |data|
+            metadata = data["usageMetadata"]
+            metadata if metadata.is_a?(Hash)
+          end
+        end
 
-          billed_quantity = grounding_billed_quantity(query_count, model: model)
-          [
-            Charges::LineItem.build(
-              dimension_key: "grounding_request",
-              quantity: billed_quantity,
-              cost_status: Charges::CostStatus::UNKNOWN,
-              pricing_basis: "provider_usage",
-              provider_field: "response.candidates.groundingMetadata.webSearchQueries",
-              details: { web_search_queries: query_count }
-            )
-          ]
+        def completed_interaction(data)
+          interaction = data["interaction"]
+          interaction if interaction.is_a?(Hash) && interaction["usage"].is_a?(Hash)
         end
 
-        def grounding_billed_quantity(query_count, model:)
-          ModelFamilies.per_query_grounding?(model) ? query_count : 1
+        def stream_grounding_line_items(events, model:)
+          grounding = find_event_value(events, reverse: true) do |data|
+            candidates = Grounding.from_candidates(data["candidates"])
+            candidates if candidates.any?
+          end
+          grounding ? grounding.line_items(model: model) : []
         end
       end
     end

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

@@ -4,70 +4,80 @@ module LlmCostTracker
   module Providers
     module Gemini
       module UsageExtractor
-        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)
-
-          Usage::TokenUsage.build(
-            input_tokens: regular_input_tokens(usage: usage,
-                                               cache_read: cache_read,
-                                               audio_input: audio_input,
-                                               image_input: image_input) +
-                          tool_use_prompt,
-            output_tokens: regular_output_tokens(usage: usage,
-                                                 audio_output: audio_output,
-                                                 image_output: image_output),
-            total_tokens: usage["totalTokenCount"],
-            cache_read_input_tokens: cache_read,
-            audio_input_tokens: audio_input,
-            audio_output_tokens: audio_output,
-            image_input_tokens: image_input,
-            image_output_tokens: image_output,
-            hidden_output_tokens: usage["thoughtsTokenCount"]
-          )
-        end
+        class << self
+          def token_usage(usage)
+            Usage::TokenUsage.build(
+              **input_counts(usage),
+              **output_counts(usage),
+              total_tokens: usage["totalTokenCount"],
+              hidden_output_tokens: usage["thoughtsTokenCount"]
+            )
+          end
 
-        def self.gross_output_tokens(usage)
-          usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
-        end
+          def line_items(usage)
+            {
+              "audio_cache_read_input" => modality_tokens(usage["cacheTokensDetails"], "AUDIO"),
+              "video_output" => modality_tokens(usage["candidatesTokensDetails"], "VIDEO")
+            }.filter_map do |dimension_key, quantity|
+              Charges::LineItem.build(dimension_key: dimension_key, quantity: quantity) if quantity.positive?
+            end
+          end
 
-        def self.regular_input_tokens(usage:, cache_read:, audio_input:, image_input:)
-          [usage["promptTokenCount"].to_i - cache_read - audio_input - image_input, 0].max
-        end
+          def from_interaction(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" => interaction_modalities(usage["input_tokens_by_modality"]),
+              "cacheTokensDetails" => interaction_modalities(usage["cached_tokens_by_modality"]),
+              "candidatesTokensDetails" => interaction_modalities(usage["output_tokens_by_modality"]),
+              "serviceTier" => service_tier
+            }
+          end
 
-        def self.regular_output_tokens(usage:, audio_output:, image_output:)
-          [gross_output_tokens(usage) - audio_output - image_output, 0].max
-        end
+          def modality_tokens(details, modality)
+            Array(details).sum do |detail|
+              next 0 unless detail["modality"] == modality
 
-        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
+              detail["tokenCount"].to_i
+            end
+          end
 
-        def self.audio_output_tokens(usage)
-          modality_tokens(usage["candidatesTokensDetails"], "AUDIO")
-        end
+          private
 
-        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 input_counts(usage)
+            cache_read = usage["cachedContentTokenCount"].to_i
+            audio = uncached_prompt_tokens(usage, "AUDIO")
+            image = uncached_prompt_tokens(usage, "IMAGE") + uncached_prompt_tokens(usage, "DOCUMENT")
+            text = [usage["promptTokenCount"].to_i - cache_read - audio - image, 0].max
+            {
+              input_tokens: text + usage["toolUsePromptTokenCount"].to_i,
+              cache_read_input_tokens: cache_read,
+              audio_input_tokens: audio,
+              image_input_tokens: image
+            }
+          end
 
-        def self.image_output_tokens(usage)
-          modality_tokens(usage["candidatesTokensDetails"], "IMAGE")
-        end
+          def output_counts(usage)
+            audio = modality_tokens(usage["candidatesTokensDetails"], "AUDIO")
+            image = modality_tokens(usage["candidatesTokensDetails"], "IMAGE")
+            gross = usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
+            { output_tokens: [gross - audio - image, 0].max, audio_output_tokens: audio, image_output_tokens: image }
+          end
 
-        def self.modality_tokens(details, modality)
-          Array(details).sum do |detail|
-            next 0 unless detail["modality"] == modality
+          def uncached_prompt_tokens(usage, modality)
+            prompt = modality_tokens(usage["promptTokensDetails"] || usage["promptTokenDetails"], modality)
+            cached = modality_tokens(usage["cacheTokensDetails"], modality)
+            [prompt - cached, 0].max
+          end
 
-            detail["tokenCount"].to_i
+          def interaction_modalities(entries)
+            Array(entries).map do |entry|
+              { "modality" => entry["modality"].to_s.upcase, "tokenCount" => entry["tokens"] }
+            end
           end
         end
       end

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

@@ -18,11 +18,22 @@ 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/
+        VERTEX_NON_GLOBAL_HOST_PATTERN = /\A(?:[a-z0-9-]+-aiplatform|aiplatform\.[a-z0-9-]+\.rep)\.googleapis\.com\z/
+
+        BEDROCK_HOST_PATTERN = /\Abedrock-(?:mantle|runtime(?:-fips)?)\./
 
         def self.data_residency?(host)
           host.to_s.downcase.match?(DATA_RESIDENCY_HOST_PATTERN)
         end
+
+        def self.vertex_non_global?(host)
+          host.to_s.downcase.match?(VERTEX_NON_GLOBAL_HOST_PATTERN)
+        end
+
+        def self.bedrock?(host)
+          host.to_s.downcase.match?(BEDROCK_HOST_PATTERN)
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module LlmCostTracker
       module ModelFamilies
         IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
 
-        CHARACTER_BILLED_TTS_MODEL_PATTERN = /\Atts-1(-hd)?\z/
+        CHARACTER_BILLED_TTS_MODEL_PATTERN = %r{\A(?:tts-1(?:-hd)?|voxtral-mini-tts-[\w-]+|canopylabs/orpheus-[\w-]+)\z}
 
         REASONING_MODEL_PATTERNS = [
           /\Agpt-5(\b|[\d.-])/i,

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      class OutputItem
+        RENAMED_TYPES = {
+          "web_search_call" => "web_search_request",
+          "code_interpreter_call" => "container_session"
+        }.freeze
+
+        attr_reader :dimension
+
+        def self.wrap(data)
+          item = new(data) if data.is_a?(Hash)
+          item if item&.dimension
+        end
+
+        def initialize(data)
+          @data = data
+          @dimension = shell_session? ? "container_session" : catalog_dimension
+        end
+
+        def billable?
+          case dimension
+          when "image_generation_call" then @data["status"] == "completed"
+          when "web_search_request" then [nil, "search"].include?(@data.dig("action", "type"))
+          else true
+          end
+        end
+
+        def dedup_key(position)
+          return "#{dimension}:#{container_id}" if dimension == "container_session" && container_id
+
+          @data["id"] || "#{@data['type']}:#{position}"
+        end
+
+        def line_item(dimension_key)
+          Charges::LineItem.build(
+            dimension_key: dimension_key,
+            quantity: 1,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: @data["provider_field"] || "response.output.#{@data['type']}",
+            provider_item_id: dimension_key == "container_session" ? container_id || @data["id"] : @data["id"],
+            details: details
+          )
+        end
+
+        def billing_fields
+          @data.slice("type", "id", "status", "container_id").merge(
+            "action" => @data["action"]&.slice("type"),
+            "environment" => @data["environment"]&.slice("type", "container_id")
+          ).compact
+        end
+
+        private
+
+        def shell_session?
+          @data["type"] == "shell_call" && shell_container_id
+        end
+
+        def catalog_dimension
+          key = RENAMED_TYPES[@data["type"]] || @data["type"]
+          dimension = Usage::Catalog[key]
+          key if dimension && dimension.token_key.nil?
+        end
+
+        def container_id
+          @data["container_id"] || shell_container_id
+        end
+
+        def shell_container_id
+          environment = @data["environment"]
+          environment["container_id"] if environment.is_a?(Hash) && environment["type"] == "container_reference"
+        end
+
+        def details
+          { status: @data["status"], action_type: @data.dig("action", "type"), container_id: container_id }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -5,24 +5,23 @@ module LlmCostTracker
     module Openai
       class Parser < LlmCostTracker::Parsers::Base
         include ResponseParser
+        include StreamParser
 
-        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 responses/compact
+          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