llm_cost_tracker 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbf918d9a4886e24ba99f93dc1125e016e50b45208437dd3254adda76f58033a
-  data.tar.gz: 8a22ccfa517549f55d2a302287660a8a5d7faf03568e80c253e6024ad4988743
+  metadata.gz: a5d394087953583d254479b4fe162adbb5b5a0f4de09c535428d514a6c623e76
+  data.tar.gz: b3269262ceec2e1f622780e3e44ac33adb1df703e077bee43fcddd7c251a21dc
 SHA512:
-  metadata.gz: 4ef6bc278f6f98ce37a91e515e8b4a004aaff5f573fc8580e312e53b903d1e7700b2cd58b9bea72fc0ec904010cba43fb0209e7993c31bb69205b42564554884
-  data.tar.gz: 4c9a193d16bb5e8bfa58aaefb6fb9b7d98a632a8e19203927c3fd29b957da6088af71caf5c14f5f2b7452660f78001d7898745f8d7611a4fd6e94311b723bc71
+  metadata.gz: 93ce84108bea091e89df70b28a192e280a1e3de92bdb14b8d47ca4057527ebcd4ec1ffa25fc37fc5216df4804539f5b1b9483d6f1fb1afdd292fd19e836431e5
+  data.tar.gz: f69fed55512f322118e93493b9069821e3cd9b372940b6163b7f80578afc3b95799126b91178b25125c7eba871ebe8b3a8fd32e607f8103649c1f3d4d606923d

data/CHANGELOG.md

@@ -4,6 +4,21 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [S
 
 ## [Unreleased]
 
+## [0.7.2] - 2026-05-01
+
+### Added
+
+- Groq auto-detection, price scraping, and bundled production text model prices.
+
+### Changed
+
+- Bundled prices refreshed from official provider pricing as of 2026-05-01.
+- Bundled prices now include OpenAI Flex/Priority/regional processing, Gemini Flex/Priority, and Anthropic fast/data residency rates.
+
+### Fixed
+
+- Streaming capture now snapshots tags when the stream starts.
+
 ## [0.7.1] - 2026-04-30
 
 ### Changed

data/README.md

@@ -35,7 +35,7 @@ Drop this into `config/initializers/llm_cost_tracker.rb`:
 
 ```ruby
 LlmCostTracker.configure do |config|
-  config.default_tags    = -> { { environment: Rails.env } }
+  config.default_tags = -> { { environment: Rails.env } }
   config.instrument :openai
 end
 ```
@@ -78,7 +78,7 @@ Drop-in for RubyLLM and the official `openai` and `anthropic` gems. `config.inst
 
 ```ruby
 LlmCostTracker.configure do |config|
-  config.instrument :openai      # or :anthropic / :ruby_llm
+  config.instrument :openai # or :anthropic / :ruby_llm
 end
 
 LlmCostTracker.with_tags(feature: "support_chat") do
@@ -98,7 +98,7 @@ This patches **only** RubyLLM and the official Ruby SDKs. `ruby-openai` (alexrud
 
 ### 2. Faraday middleware
 
-For `ruby-openai`, the Gemini REST API, custom Faraday clients, or anything OpenAI-compatible (OpenRouter, DeepSeek, LiteLLM proxies):
+For `ruby-openai`, the Gemini REST API, custom Faraday clients, or anything OpenAI-compatible (OpenRouter, DeepSeek, Groq, LiteLLM proxies):
 
 ```ruby
 conn = Faraday.new(url: "https://api.openai.com") do |f|
@@ -137,13 +137,15 @@ For streaming the same way, `track_stream` accepts a block, parses provider even
 Tags answer the only question that matters in attribution: which feature, which user, which job, which tenant. They're free-form strings, stored as JSONB on PostgreSQL or JSON on MySQL, and queryable from both Ruby and the dashboard.
 
 ```ruby
-LlmCostTracker.with_tags(user_id: current_user.id, feature: "support_chat", trace_id: request.uuid) do
+LlmCostTracker.with_tags(user_id: current_user.id, feature: "support_chat") do
   client.chat(parameters: { model: "gpt-4o", messages: [...] })
 end
 ```
 
 `with_tags` is thread- and fiber-isolated, so concurrent requests in Puma or jobs in Sidekiq don't bleed into each other. A `default_tags` callable on configuration runs on every event for things you always want — `environment`, `region`, deployment SHA. Explicit tags passed to `track` win over scoped tags, scoped tags win over defaults.
 
+Streaming capture snapshots tags when the stream starts, so attribution survives delayed or cross-thread stream consumption.
+
 What you put in tags is **your** input — they're queryable strings. Don't put prompts, completions, emails, or secrets there. Use IDs.
 
 ## Pricing
@@ -184,7 +186,7 @@ Budgets are guardrails, not transactional caps:
 config.monthly_budget           = 500.00
 config.daily_budget             = 50.00
 config.per_call_budget          = 2.00
-config.budget_exceeded_behavior = :block_requests   # or :notify, :raise
+config.budget_exceeded_behavior = :block_requests # or :notify, :raise
 config.on_budget_exceeded       = ->(data) { SlackNotifier.notify("#alerts", "...") }
 ```
 
@@ -233,6 +235,7 @@ Auth is your job. Examples for basic auth and Devise: [`docs/dashboard.md`](docs
 | Google Gemini | Yes | Gemini 2.5 Pro/Flash/Flash-Lite, 2.0 Flash/Flash-Lite |
 | OpenRouter | Yes | OpenAI-compatible usage; provider-prefixed model IDs are normalized |
 | DeepSeek | Yes | OpenAI-compatible usage; add `pricing_overrides` for DeepSeek-specific rates |
+| Groq | Yes | OpenAI-compatible usage with bundled prices for production text models |
 | Other OpenAI-compatible hosts | Configurable | Register the host via `config.openai_compatible_providers` |
 | Anything else | Manual | Use `LlmCostTracker.track` / `track_stream` |
 
@@ -275,10 +278,10 @@ is still brief.
 
 ```bash
 bundle install
-bin/check       # rubocop + rspec + coverage gate
+bin/check # rubocop + rspec + coverage gate
 ```
 
-Architecture rules and conventions for contributions live in [`AGENTS.md`](AGENTS.md) and [`docs/architecture.md`](docs/architecture.md).
+Architecture rules and conventions for contributions live in [`docs/architecture.md`](docs/architecture.md).
 
 ## License
 

data/lib/llm_cost_tracker/capture/stream_collector.rb

@@ -10,13 +10,15 @@ module LlmCostTracker
     class StreamCollector
       attr_reader :provider
 
-      def initialize(provider:, model:, latency_ms: nil, provider_response_id: nil, pricing_mode: nil, metadata: {})
+      def initialize(provider:, model:, latency_ms: nil, provider_response_id: nil, pricing_mode: nil, metadata: {},
+                     context_tags: nil)
         @provider = provider.to_s
         @model = model
         @latency_ms = latency_ms
         @provider_response_id = provider_response_id
         @pricing_mode = pricing_mode
         @metadata = (metadata || {}).deep_dup
+        @context_tags = (context_tags || LlmCostTracker::Tags::Context.tags).deep_dup
         @events = []
         @captured_bytes = 0
         @overflowed = false
@@ -85,7 +87,8 @@ module LlmCostTracker
             latency_ms: @latency_ms,
             provider_response_id: @provider_response_id,
             pricing_mode: @pricing_mode,
-            metadata: @metadata.deep_dup
+            metadata: @metadata.deep_dup,
+            context_tags: @context_tags.deep_dup
           }
         end
 
@@ -98,7 +101,8 @@ module LlmCostTracker
           latency_ms: snapshot[:latency_ms] ||
             ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at) * 1000).round,
           pricing_mode: snapshot[:pricing_mode],
-          metadata: (errored ? { stream_errored: true } : {}).merge(snapshot[:metadata])
+          metadata: (errored ? { stream_errored: true } : {}).merge(snapshot[:metadata]),
+          context_tags: snapshot[:context_tags]
         )
       end
 
@@ -114,7 +118,10 @@ module LlmCostTracker
         return build_from_explicit_usage(snapshot) if snapshot[:explicit_usage]
         return build_unknown_usage(snapshot) if snapshot[:overflowed]
 
-        capture = Parsers.find_for_provider(@provider)&.parse_stream(nil, nil, 200, snapshot[:events])
+        capture = Parsers.find_for_provider(@provider)&.parse_stream(
+          response_status: 200,
+          events: snapshot[:events]
+        )
         if capture
           model = present_model(capture.model) || present_model(snapshot[:model]) || UsageCapture::UNKNOWN_MODEL
           return capture.with(provider: @provider, model: model)

data/lib/llm_cost_tracker/capture/stream_tracker.rb

@@ -8,7 +8,7 @@ require_relative "../logging"
 module LlmCostTracker
   module Capture
     class StreamTracker
-      def initialize(stream, collector, active, finish)
+      def initialize(stream:, collector:, active:, finish: nil)
         @stream = stream
         @collector = collector
         @active = active

data/lib/llm_cost_tracker/configuration.rb

@@ -8,7 +8,11 @@ module LlmCostTracker
   class Configuration
     include ConfigurationInstrumentation
 
-    OPENAI_COMPATIBLE_PROVIDERS = { "openrouter.ai" => "openrouter", "api.deepseek.com" => "deepseek" }.freeze
+    OPENAI_COMPATIBLE_PROVIDERS = {
+      "openrouter.ai" => "openrouter",
+      "api.deepseek.com" => "deepseek",
+      "api.groq.com" => "groq"
+    }.freeze
 
     BUDGET_EXCEEDED_BEHAVIORS = %i[notify raise block_requests].freeze
     UNKNOWN_PRICING_BEHAVIORS = %i[ignore warn raise].freeze

data/lib/llm_cost_tracker/integrations/anthropic.rb

@@ -49,9 +49,8 @@ module LlmCostTracker
               capture: UsageCapture.build(
                 provider: "anthropic",
                 model: object_value(message, :model) || request[:model],
-                pricing_mode: object_value(usage, :service_tier) || object_value(message, :service_tier) ||
-                  request[:service_tier],
-                token_usage: token_usage(usage, input_tokens, output_tokens),
+                pricing_mode: pricing_mode(message: message, request: request, usage: usage),
+                token_usage: token_usage(usage: usage, input_tokens: input_tokens, output_tokens: output_tokens),
                 usage_source: :sdk_response,
                 provider_response_id: object_value(message, :id)
               ),
@@ -60,7 +59,7 @@ module LlmCostTracker
           end
         end
 
-        def token_usage(usage, input_tokens, output_tokens)
+        def token_usage(usage:, input_tokens:, output_tokens:)
           cache_write_1h = object_dig(usage, :cache_creation, :ephemeral_1h_input_tokens).to_i
           cache_write_5m = object_dig(usage, :cache_creation, :ephemeral_5m_input_tokens)
           cache_write = if cache_write_5m.nil?
@@ -84,14 +83,32 @@ module LlmCostTracker
           )
         end
 
+        def pricing_mode(message:, request:, usage:)
+          modes = [
+            Pricing.normalize_mode(object_value(usage, :speed) || object_value(message, :speed) || request[:speed]),
+            Pricing.normalize_mode(
+              object_value(usage, :service_tier) || object_value(message, :service_tier) || request[:service_tier]
+            )
+          ]
+          modes << "data_residency" if inference_geo(message: message, request: request, usage: usage).to_s == "us"
+          modes = modes.compact.uniq
+          modes.empty? ? nil : modes.join("_")
+        end
+
+        def inference_geo(message:, request:, usage:)
+          object_value(usage, :inference_geo) ||
+            object_value(message, :inference_geo) ||
+            request[:inference_geo]
+        end
+
         def track_stream(stream, collector:)
           return stream unless active?
 
           LlmCostTracker::Capture::StreamTracker.new(
-            stream,
-            collector,
-            -> { active? },
-            ->(errored:) { finish_stream(collector, errored: errored) }
+            stream: stream,
+            collector: collector,
+            active: -> { active? },
+            finish: ->(errored:) { finish_stream(collector, errored: errored) }
           ).wrap
         end
 

data/lib/llm_cost_tracker/integrations/openai.rb

@@ -90,10 +90,10 @@ module LlmCostTracker
           return stream unless active?
 
           LlmCostTracker::Capture::StreamTracker.new(
-            stream,
-            collector,
-            -> { active? },
-            ->(errored:) { finish_stream(collector, errored: errored) }
+            stream: stream,
+            collector: collector,
+            active: -> { active? },
+            finish: ->(errored:) { finish_stream(collector, errored: errored) }
           ).wrap
         end
 

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -25,40 +25,54 @@ module LlmCostTracker
         stream_buffer = install_stream_tap(request_env) if streaming
 
         Tracker.enforce_budget! if parser
+        context_tags, metadata = tag_snapshot(request_env) if parser
         started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         @app.call(request_env).on_complete do |response_env|
           process(
             parser: parser,
-            request_env: request_env,
             request_url: request_url,
             request_body: request_body,
             response_env: response_env,
             latency_ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round,
             streaming: streaming,
-            stream_buffer: stream_buffer
+            stream_buffer: stream_buffer,
+            context_tags: context_tags,
+            metadata: metadata
           )
         end
       end
 
       private
 
-      def process(parser:, request_env:, request_url:, request_body:, response_env:,
-                  latency_ms:, streaming:, stream_buffer:)
+      def process(parser:, request_url:, request_body:, response_env:,
+                  latency_ms:, streaming:, stream_buffer:, context_tags:, metadata:)
         return unless parser
 
         parsed =
           if streaming
-            parse_stream(parser, request_url, request_body, response_env, stream_buffer)
+            parse_stream(
+              parser: parser,
+              request_url: request_url,
+              request_body: request_body,
+              response_env: response_env,
+              stream_buffer: stream_buffer
+            )
           else
-            parse_response(parser, request_url, request_body, response_env)
+            parse_response(
+              parser: parser,
+              request_url: request_url,
+              request_body: request_body,
+              response_env: response_env
+            )
           end
         return unless parsed
 
         Tracker.record(
           capture: parsed,
           latency_ms: latency_ms,
-          metadata: resolved_tags(request_env)
+          metadata: metadata,
+          context_tags: context_tags
         )
       rescue LlmCostTracker::Error
         raise
@@ -66,7 +80,7 @@ module LlmCostTracker
         Logging.warn("Error processing response: #{e.class}: #{e.message}")
       end
 
-      def parse_response(parser, request_url, request_body, response_env)
+      def parse_response(parser:, request_url:, request_body:, response_env:)
         response_body = read_body(response_env.body)
         unless response_body
           Logging.warn(
@@ -77,13 +91,24 @@ module LlmCostTracker
           return nil
         end
 
-        parser.parse(request_url, request_body, response_env.status, response_body)
+        parser.parse(
+          request_url: request_url,
+          request_body: request_body,
+          response_status: response_env.status,
+          response_body: response_body,
+          response_headers: response_env.response_headers
+        )
       end
 
-      def parse_stream(parser, request_url, request_body, response_env, stream_buffer)
+      def parse_stream(parser:, request_url:, request_body:, response_env:, stream_buffer:)
         if stream_buffer&.dig(:overflowed)
           Logging.warn(capture_warning(request_url, stream_buffer))
-          return parser.parse_stream(request_url, request_body, response_env.status, [])
+          return parser.parse_stream(
+            request_url: request_url,
+            request_body: request_body,
+            response_status: response_env.status,
+            response_headers: response_env.response_headers
+          )
         end
 
         body = stream_buffer&.dig(:buffer)&.string
@@ -91,11 +116,22 @@ module LlmCostTracker
 
         if body.blank?
           Logging.warn(capture_warning(request_url, stream_buffer))
-          return parser.parse_stream(request_url, request_body, response_env.status, [])
+          return parser.parse_stream(
+            request_url: request_url,
+            request_body: request_body,
+            response_status: response_env.status,
+            response_headers: response_env.response_headers
+          )
         end
 
         events = Parsers::SSE.parse(body)
-        parser.parse_stream(request_url, request_body, response_env.status, events)
+        parser.parse_stream(
+          request_url: request_url,
+          request_body: request_body,
+          response_status: response_env.status,
+          events: events,
+          response_headers: response_env.response_headers
+        )
       end
 
       def install_stream_tap(request_env)
@@ -147,6 +183,13 @@ module LlmCostTracker
         tags.to_h
       end
 
+      def tag_snapshot(request_env)
+        [LlmCostTracker::Tags::Context.tags, resolved_tags(request_env)]
+      rescue StandardError => e
+        Logging.warn("Error resolving request tags: #{e.class}: #{e.message}")
+        [{}, {}]
+      end
+
       def capture_warning(request_url, stream_buffer)
         unless stream_buffer&.dig(:overflowed)
           return "Unable to capture streaming response for #{request_url_label(request_url)}; " \

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -15,7 +15,7 @@ module LlmCostTracker
         %w[anthropic]
       end
 
-      def parse(_request_url, request_body, response_status, response_body)
+      def parse(request_body:, response_status:, response_body:, **)
         return nil unless response_status == 200
 
         response = safe_json_parse(response_body)
@@ -28,14 +28,14 @@ module LlmCostTracker
         UsageCapture.build(
           provider: "anthropic",
           provider_response_id: response["id"],
-          pricing_mode: pricing_mode(request, response, usage),
+          pricing_mode: pricing_mode(request: request, response: response, usage: usage),
           model: response["model"] || request["model"],
-          token_usage: token_usage(usage, cache_read),
+          token_usage: token_usage(usage: usage, cache_read: cache_read),
           usage_source: :response
         )
       end
 
-      def parse_stream(_request_url, request_body, response_status, events)
+      def parse_stream(response_status:, request_body: nil, events: [], **)
         return nil unless response_status == 200
 
         request = safe_json_parse(request_body)
@@ -44,13 +44,18 @@ module LlmCostTracker
         response_id = find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
 
         if usage
-          build_stream_result(model, usage, response_id, pricing_mode(request, nil, usage))
+          build_stream_result(
+            model: model,
+            usage: usage,
+            response_id: response_id,
+            pricing_mode: pricing_mode(request: request, response: nil, usage: usage)
+          )
         else
           build_unknown_stream_usage(
             provider: "anthropic",
             model: model,
             provider_response_id: response_id,
-            pricing_mode: pricing_mode(request, nil, usage)
+            pricing_mode: pricing_mode(request: request, response: nil, usage: usage)
           )
         end
       end
@@ -72,7 +77,7 @@ module LlmCostTracker
         end
       end
 
-      def build_stream_result(model, usage, response_id, pricing_mode)
+      def build_stream_result(model:, usage:, response_id:, pricing_mode:)
         cache_read = usage["cache_read_input_tokens"].to_i
 
         UsageCapture.build(
@@ -80,13 +85,13 @@ 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
         )
       end
 
-      def token_usage(usage, cache_read)
+      def token_usage(usage:, cache_read:)
         input = usage["input_tokens"].to_i
         output = usage["output_tokens"].to_i
         cache_creation = usage["cache_creation"]
@@ -108,10 +113,27 @@ module LlmCostTracker
         )
       end
 
-      def pricing_mode(request, response, usage)
-        usage&.fetch("service_tier", nil) ||
-          response&.fetch("service_tier", nil) ||
-          request["service_tier"]
+      def pricing_mode(request:, response:, usage:)
+        modes = []
+        speed = usage&.fetch("speed", nil) || response&.fetch("speed", nil) || request["speed"]
+        service_tier = usage&.fetch("service_tier", nil) ||
+                       response&.fetch("service_tier", nil) ||
+                       request["service_tier"]
+
+        modes << Pricing.normalize_mode(speed)
+        modes << Pricing.normalize_mode(service_tier)
+        modes << "data_residency" if inference_geo(request: request, response: response, usage: usage) == "us"
+
+        modes = modes.compact.uniq
+        modes.empty? ? nil : modes.join("_")
+      end
+
+      def inference_geo(request:, response:, usage:)
+        (
+          usage&.fetch("inference_geo", nil) ||
+          response&.fetch("inference_geo", nil) ||
+          request["inference_geo"]
+        ).to_s
       end
     end
   end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -7,7 +7,7 @@ require "uri"
 module LlmCostTracker
   module Parsers
     class Base
-      def parse(request_url, request_body, response_status, response_body)
+      def parse(**)
         raise NotImplementedError
       end
 
@@ -28,7 +28,7 @@ module LlmCostTracker
         request.is_a?(Hash) && request["stream"] == true
       end
 
-      def parse_stream(_request_url, _request_body, _response_status, _events)
+      def parse_stream(**)
         nil
       end
 

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -23,58 +23,66 @@ module LlmCostTracker
         super
       end
 
-      def parse(request_url, _request_body, response_status, response_body)
+      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)
         build_usage_capture(
-          request_url,
-          usage,
+          request_url: request_url,
+          usage: usage,
           usage_source: :response,
-          provider_response_id: response["responseId"]
+          provider_response_id: response["responseId"],
+          pricing_mode: pricing_mode(request: request, response_headers: response_headers)
         )
       end
 
-      def parse_stream(request_url, _request_body, response_status, events)
+      def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], response_headers: 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, response_headers: response_headers)
 
         if usage
           build_usage_capture(
-            request_url,
-            usage,
+            request_url: request_url,
+            usage: usage,
             stream: true,
             usage_source: :stream_final,
-            provider_response_id: response_id
+            provider_response_id: response_id,
+            pricing_mode: mode
           )
         else
           build_unknown_stream_usage(
             provider: "gemini",
             model: model,
-            provider_response_id: response_id
+            provider_response_id: response_id,
+            pricing_mode: mode
           )
         end
       end
 
       private
 
-      def build_usage_capture(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,
+                              pricing_mode: nil)
         cache_read = usage["cachedContentTokenCount"].to_i
         tool_use_prompt = usage["toolUsePromptTokenCount"].to_i
 
         UsageCapture.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
+          pricing_mode: pricing_mode,
           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),
+            total_tokens: total_tokens(usage: usage, cache_read: cache_read, tool_use_prompt: tool_use_prompt),
             cache_read_input_tokens: usage["cachedContentTokenCount"],
             hidden_output_tokens: usage["thoughtsTokenCount"]
           ),
@@ -95,7 +103,7 @@ module LlmCostTracker
         usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
       end
 
-      def total_tokens(usage, cache_read, tool_use_prompt)
+      def total_tokens(usage:, cache_read:, tool_use_prompt:)
         total = usage["totalTokenCount"]
         return total.to_i unless total.nil?
 
@@ -113,6 +121,24 @@ module LlmCostTracker
         match = uri.path.match(%r{/models/([^/:]+)})
         match && match[1]
       end
+
+      def pricing_mode(request:, response_headers:)
+        response_tier = response_header(response_headers, "x-gemini-service-tier")
+        response_mode = Pricing.normalize_mode(response_tier)
+        return response_mode if response_mode
+
+        request_mode = Pricing.normalize_mode(
+          request["service_tier"] ||
+          request["serviceTier"] ||
+          request.dig("config", "service_tier") ||
+          request.dig("config", "serviceTier")
+        )
+        request_mode == "flex" ? request_mode : nil
+      end
+
+      def response_header(headers, name)
+        headers.to_h.find { |key, _value| key.to_s.downcase == name }&.last
+      end
     end
   end
 end