llm_cost_tracker 0.8.0 → 0.9.0

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -2,6 +2,7 @@
 
 require "faraday"
 require "json"
+require "stringio"
 require "uri"
 
 require_relative "../logging"
@@ -23,28 +24,82 @@ module LlmCostTracker
         request_body = read_body(request_env.body)
         parser       = Parsers.find_for(request_url)
         streaming    = parser&.streaming_request?(request_url, request_body)
+        request_body = inject_stream_usage_flag(request_env, parser, request_url) if streaming
         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 = LlmCostTracker::Timing.now_monotonic
 
+        invoke_app_with_capture(
+          request_env: request_env, parser: parser, request_url: request_url,
+          request_body: request_body, streaming: streaming, stream_buffer: stream_buffer,
+          context_tags: context_tags, metadata: metadata, started_at: started_at
+        )
+      end
+
+      private
+
+      def invoke_app_with_capture(request_env:, parser:, request_url:, request_body:, streaming:,
+                                  stream_buffer:, context_tags:, metadata:, started_at:)
+        response_received = false
         @app.call(request_env).on_complete do |response_env|
+          response_received = true
           process(
-            parser: parser,
-            request_url: request_url,
-            request_body: request_body,
-            response_env: response_env,
+            parser: parser, request_url: request_url, request_body: request_body,
+            response_env: response_env, latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
+            streaming: streaming, stream_buffer: stream_buffer,
+            context_tags: context_tags, metadata: metadata
+          )
+        end
+      rescue StandardError => e
+        if streaming && parser && !response_received
+          process_interrupted_stream(
+            parser: parser, request_url: request_url, request_body: request_body,
             latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
-            streaming: streaming,
-            stream_buffer: stream_buffer,
-            context_tags: context_tags,
-            metadata: metadata
+            context_tags: context_tags, metadata: metadata, error: e
           )
         end
+        raise
       end
 
-      private
+      def inject_stream_usage_flag(request_env, parser, request_url)
+        body_string = read_body(request_env.body)
+        return body_string unless LlmCostTracker.configuration.auto_enable_stream_usage
+        return body_string unless parser&.auto_enable_stream_usage?(request_url)
+
+        body = JSON.parse(body_string)
+        return body_string if body["stream_options"].is_a?(Hash) && body["stream_options"].key?("include_usage")
+
+        body["stream_options"] = (body["stream_options"] || {}).merge("include_usage" => true)
+        new_body = body.to_json
+        request_env.body = new_body
+        new_body
+      end
+
+      def process_interrupted_stream(parser:, request_url:, request_body:, latency_ms:,
+                                     context_tags:, metadata:, error:)
+        request = parser.safe_json_parse(request_body)
+        capture = UsageCapture.build(
+          provider: parser.provider_for(request_url),
+          model: request["model"] || UsageCapture::UNKNOWN_MODEL,
+          token_usage: TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
+          stream: true,
+          usage_source: :unknown
+        )
+        merged_metadata = (metadata || {}).merge(
+          stream_interrupted: true,
+          stream_interrupted_error: "#{error.class}: #{error.message}"
+        )
+        Tracker.record(
+          capture: capture,
+          latency_ms: latency_ms,
+          metadata: merged_metadata,
+          context_tags: context_tags
+        )
+      rescue StandardError => e
+        Logging.warn("Error recording interrupted stream: #{e.class}: #{e.message}")
+      end
 
       def process(parser:, request_url:, request_body:, response_env:,
                   latency_ms:, streaming:, stream_buffer:, context_tags:, metadata:)
@@ -102,21 +157,14 @@ module LlmCostTracker
       end
 
       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_url,
-            request_body: request_body,
-            response_status: response_env.status,
-            response_headers: response_env.response_headers
-          )
-        end
+        overflowed = stream_buffer&.dig(:overflowed) == true
+        Logging.warn(capture_warning(request_url, stream_buffer)) if overflowed
 
         body = stream_buffer&.dig(:buffer)&.string
         body = read_body(response_env.body) if body.blank?
 
         if body.blank?
-          Logging.warn(capture_warning(request_url, stream_buffer))
+          Logging.warn(capture_warning(request_url, stream_buffer)) unless overflowed
           return parser.parse_stream(
             request_url: request_url,
             request_body: request_body,
@@ -125,7 +173,7 @@ module LlmCostTracker
           )
         end
 
-        events = Parsers::SSE.parse(body)
+        events = overflowed ? [] : Parsers::SSE.parse(body)
         parser.parse_stream(
           request_url: request_url,
           request_body: request_body,
@@ -135,6 +183,17 @@ module LlmCostTracker
         )
       end
 
+      def forward_on_data_chunk(callable, chunk, size, env)
+        arity = callable.arity
+        return callable.call(chunk, size, env) if arity.negative?
+
+        case arity
+        when 0, 1 then callable.call(chunk)
+        when 2 then callable.call(chunk, size)
+        else callable.call(chunk, size, env)
+        end
+      end
+
       def install_stream_tap(request_env)
         request = request_env.request
         return nil unless request
@@ -145,16 +204,16 @@ module LlmCostTracker
         state = { buffer: StringIO.new, bytes: 0, overflowed: false }
         request.on_data = proc do |chunk, size, env|
           chunk = chunk.to_s
-          unless state[:overflowed]
-            if state[:bytes] + chunk.bytesize <= Capture::Stream::LIMIT_BYTES
-              state[:buffer] << chunk
-              state[:bytes] += chunk.bytesize
-            else
-              state[:overflowed] = true
-              state[:buffer] = nil
-            end
+          remaining = Capture::Stream::LIMIT_BYTES - state[:bytes]
+          if chunk.bytesize <= remaining
+            state[:buffer] << chunk
+            state[:bytes] += chunk.bytesize
+          else
+            state[:buffer] << chunk.byteslice(0, remaining) if remaining.positive?
+            state[:bytes] += [remaining, 0].max
+            state[:overflowed] = true
           end
-          original.call(chunk, size, env)
+          forward_on_data_chunk(original, chunk, size, env)
         end
         state
       rescue StandardError => e

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -61,20 +61,28 @@ module LlmCostTracker
         end
       end
 
+      def provider_for(_request_url)
+        "anthropic"
+      end
+
+      DATA_RESIDENCY_GEOS = %w[us].freeze
+      STANDARD_EQUIVALENT_SERVICE_TIERS = %w[standard standard_only priority].freeze
+      private_constant :DATA_RESIDENCY_GEOS, :STANDARD_EQUIVALENT_SERVICE_TIERS
+
       private
 
       def stream_usage(events)
-        start_usage = find_event_value(events, reverse: true) do |data|
-          data.dig("message", "usage") if data["type"] == "message_start"
-        end
         latest_delta = find_event_value(events, reverse: true) do |data|
           data["usage"] if data["type"] == "message_delta" && data["usage"].is_a?(Hash)
         end
+        return nil unless latest_delta
 
-        return nil unless start_usage || latest_delta
+        start_usage = find_event_value(events, reverse: true) do |data|
+          data.dig("message", "usage") if data["type"] == "message_start"
+        end
 
-        (start_usage || {}).merge(latest_delta || {}) do |_key, start_val, delta_val|
-          delta_val.nil? ? start_val : delta_val
+        (start_usage || {}).merge(latest_delta) do |_key, start_val, delta_val|
+          delta_val || start_val
         end
       end
 
@@ -103,6 +111,11 @@ module LlmCostTracker
             quantity: server_tool_use["web_search_requests"],
             provider_field: "usage.server_tool_use.web_search_requests"
           ),
+          service_line_item(
+            component_key: :web_fetch_request,
+            quantity: server_tool_use["web_fetch_requests"],
+            provider_field: "usage.server_tool_use.web_fetch_requests"
+          ),
           service_line_item(
             component_key: :code_execution_request,
             quantity: server_tool_use["code_execution_requests"],
@@ -164,10 +177,12 @@ module LlmCostTracker
         service_tier = usage&.fetch("service_tier", nil) ||
                        response&.fetch("service_tier", nil) ||
                        request["service_tier"]
+        service_tier = nil if STANDARD_EQUIVALENT_SERVICE_TIERS.include?(service_tier.to_s)
 
         modes << Pricing.normalize_mode(speed)
         modes << Pricing.normalize_mode(service_tier)
-        modes << "data_residency" if inference_geo(request: request, response: response, usage: usage) == "us"
+        geo = inference_geo(request: request, response: response, usage: usage).downcase
+        modes << "data_residency" if DATA_RESIDENCY_GEOS.include?(geo)
 
         modes = modes.compact.uniq
         modes.empty? ? nil : modes.join("_")

data/lib/llm_cost_tracker/parsers/base.rb

@@ -32,7 +32,9 @@ module LlmCostTracker
         nil
       end
 
-      private
+      def auto_enable_stream_usage?(_request_url)
+        false
+      end
 
       def safe_json_parse(body)
         return {} if body.blank?
@@ -42,6 +44,8 @@ module LlmCostTracker
         {}
       end
 
+      private
+
       def uri_matches?(url)
         uri = parsed_uri(url)
         uri ? yield(uri) : false

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -75,6 +75,10 @@ module LlmCostTracker
         end
       end
 
+      def provider_for(_request_url)
+        "gemini"
+      end
+
       private
 
       def build_usage_capture(request_url:, usage:, usage_source:, stream: false, provider_response_id: nil,

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -21,7 +21,19 @@ module LlmCostTracker
         gb.api.openai.com
         ae.api.openai.com
       ].freeze
-      TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
+      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
+      ].freeze
 
       def match?(url)
         match_uri?(url, hosts: HOSTS, exact_paths: TRACKED_PATHS)
@@ -49,7 +61,9 @@ module LlmCostTracker
         )
       end
 
-      private
+      def auto_enable_stream_usage?(request_url)
+        openai_chat_completions_url?(request_url)
+      end
 
       def provider_for(_request_url)
         "openai"

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -47,13 +47,17 @@ module LlmCostTracker
         )
       end
 
-      private
+      def auto_enable_stream_usage?(request_url)
+        openai_chat_completions_url?(request_url)
+      end
 
       def provider_for(request_url)
         uri = parsed_uri(request_url)
         provider_for_uri(uri) || "openai_compatible"
       end
 
+      private
+
       def provider_for_uri(uri)
         return nil unless uri
 

data/lib/llm_cost_tracker/parsers/openai_service_charges.rb

@@ -8,15 +8,25 @@ module LlmCostTracker
       RESPONSE_OUTPUT_COMPONENTS = {
         "web_search_call" => :web_search_request,
         "file_search_call" => :file_search_call,
-        "code_interpreter_call" => :container_session
+        "code_interpreter_call" => :container_session,
+        "mcp_call" => :mcp_call
       }.freeze
 
+      REASONING_MODEL_PATTERNS = [
+        /\Agpt-5(\b|[\d.-])/i,
+        /\Ao\d+(\b|[\d.-])/i
+      ].freeze
+      NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
+      private_constant :NON_REASONING_GPT5_PATTERN
+
       module_function
 
-      def line_items_from_output(output_items)
+      def line_items_from_output(output_items, request: nil, model: nil)
         deduped = {}
         Array(output_items).each { |item| store_output_item(deduped, item) }
-        deduped.values.filter_map { |item| build_line_item(item) }
+        deduped.values
+               .select { |item| billable?(item) }
+               .filter_map { |item| build_line_item(item, request: request, model: model) }
       end
 
       def billable?(item)
@@ -31,7 +41,7 @@ module LlmCostTracker
       end
 
       def store_output_item(output_items, item)
-        return unless billable?(item)
+        return unless item.is_a?(Hash) && RESPONSE_OUTPUT_COMPONENTS.key?(item["type"])
 
         component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
         key = if component == :container_session && item["container_id"]
@@ -42,8 +52,10 @@ module LlmCostTracker
         output_items[key] = item
       end
 
-      def build_line_item(item)
-        component_key = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+      def build_line_item(item, request: nil, model: nil)
+        return nil unless item.is_a?(Hash)
+
+        component_key = component_key_for(item, request: request, model: model)
         return nil unless component_key
 
         provider_item_id = if component_key == :container_session
@@ -62,6 +74,33 @@ module LlmCostTracker
         )
       end
 
+      def component_key_for(item, request:, model:)
+        component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+        return component unless component == :web_search_request
+        return component unless web_search_preview_used?(request)
+
+        reasoning_model?(model) ? :web_search_preview_request_reasoning : :web_search_preview_request_non_reasoning
+      end
+
+      def web_search_preview_used?(request)
+        tools = request && (request[:tools] || request["tools"])
+        return false unless tools.respond_to?(:each)
+
+        tools.any? do |tool|
+          type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
+          type.to_s.include?("web_search_preview")
+        end
+      end
+
+      def reasoning_model?(model)
+        return false unless model
+
+        name = model.to_s.split("/", 2).last
+        return false if NON_REASONING_GPT5_PATTERN.match?(name)
+
+        REASONING_MODEL_PATTERNS.any? { |pattern| pattern.match?(name) }
+      end
+
       def line_item_details(item)
         {
           "status" => item["status"],
@@ -70,17 +109,17 @@ module LlmCostTracker
         }.compact
       end
 
-      def openai_service_line_items(response)
-        line_items_from_output(response["output"])
+      def openai_service_line_items(response, request: nil)
+        line_items_from_output(response["output"], request: request, model: response["model"])
       end
 
-      def openai_stream_service_line_items(events)
+      def openai_stream_service_line_items(events, request: nil, model: nil)
         output_items = []
         each_event_data(events) do |data|
           output_items.concat(Array(data.dig("response", "output")))
           output_items << data["item"] if data["item"]
         end
-        line_items_from_output(output_items)
+        line_items_from_output(output_items, request: request, model: model)
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -9,6 +9,25 @@ module LlmCostTracker
 
       OPENAI_DATA_RESIDENCY_HOST_PATTERN = /\A[a-z]{2,3}\.api\.openai\.com\z/
 
+      class << self
+        def combined_pricing_mode(host:, model:, service_tier:)
+          modes = [Pricing.normalize_mode(service_tier)]
+          modes << "data_residency" if regional_processing?(host: host, model: model)
+          modes = modes.compact.uniq
+          modes.empty? ? nil : modes.join("_")
+        end
+
+        def regional_processing?(host:, model:)
+          host.to_s.downcase.match?(OPENAI_DATA_RESIDENCY_HOST_PATTERN) && data_residency_model?(model)
+        end
+
+        def data_residency_model?(model)
+          model.to_s.match?(
+            /\Agpt-5\.(?:4|5)(?:-(?:mini|nano|pro|codex(?:-mini|-max)?))?(?:-\d{4}-\d{2}-\d{2})?\z/
+          )
+        end
+      end
+
       private
 
       def parse_openai_usage(request_url:, request_body:, response_status:, response_body:)
@@ -32,9 +51,9 @@ module LlmCostTracker
             service_tier: response["service_tier"] || request["service_tier"]
           ),
           model: model,
-          token_usage: token_usage(usage: usage, cache_read: cache_read),
+          token_usage: token_usage(usage: usage, cache_read: cache_read, model: model),
           usage_source: :response,
-          service_line_items: openai_service_line_items(response)
+          service_line_items: openai_service_line_items(response, request: request)
         )
       end
 
@@ -42,91 +61,128 @@ module LlmCostTracker
         return nil unless response_status == 200
 
         request = safe_json_parse(request_body)
-        model = 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 = pricing_mode(
-          request_url: request_url,
+        context = stream_capture_context(events: events, request: request, request_url: request_url)
+
+        return build_known_stream_usage(usage: usage, **context) if usage
+
+        warn_missing_stream_usage(request_url: request_url, request: request)
+        build_unknown_stream_usage(**context)
+      end
+
+      def stream_capture_context(events:, request:, request_url:)
+        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),
           model: model,
-          service_tier: stream_pricing_mode(events) || request["service_tier"]
-        )
-        service_line_items = openai_stream_service_line_items(events)
-
-        if usage
-          cache_read = cache_read_input_tokens(usage)
-          UsageCapture.build(
-            provider: provider_for(request_url),
-            provider_response_id: response_id,
-            pricing_mode: pricing_mode,
-            model: model,
-            token_usage: token_usage(usage: usage, cache_read: cache_read),
-            stream: true,
-            usage_source: :stream_final,
-            service_line_items: service_line_items
-          )
-        else
-          build_unknown_stream_usage(
-            provider: provider_for(request_url),
+          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,
             model: model,
-            provider_response_id: response_id,
-            pricing_mode: pricing_mode,
-            service_line_items: service_line_items
-          )
-        end
+            service_tier: stream_pricing_mode(events) || request["service_tier"]
+          ),
+          service_line_items: openai_stream_service_line_items(events, request: request, model: model)
+        }
+      end
+
+      def build_known_stream_usage(usage:, provider:, model:, provider_response_id:, pricing_mode:, service_line_items:)
+        cache_read = cache_read_input_tokens(usage)
+        UsageCapture.build(
+          provider: provider,
+          provider_response_id: provider_response_id,
+          pricing_mode: pricing_mode,
+          model: model,
+          token_usage: token_usage(usage: usage, cache_read: cache_read, model: model),
+          stream: true,
+          usage_source: :stream_final,
+          service_line_items: service_line_items
+        )
+      end
+
+      def warn_missing_stream_usage(request_url:, request:)
+        return unless request.is_a?(Hash) && request["stream"]
+        return unless openai_chat_completions_url?(request_url)
+        return if request.dig("stream_options", "include_usage")
+
+        Logging.warn(
+          "OpenAI-compatible chat-completions stream finished without a final usage chunk. " \
+          "Set `stream_options: { include_usage: true }` in your request body so the gem can " \
+          "record token counts. This call was stored with usage_source=unknown."
+        )
+      end
+
+      def openai_chat_completions_url?(request_url)
+        uri = parsed_uri(request_url)
+        uri && uri.path.to_s.end_with?("/chat/completions")
       end
 
       def detect_stream_usage(events)
         find_event_value(events, reverse: true) do |data|
-          usage = data["usage"] || data.dig("response", "usage")
+          usage = data["usage"] || data.dig("response", "usage") || data.dig("chunk", "usage")
           usage if usage.is_a?(Hash)
         end
       end
 
       def stream_pricing_mode(events)
         find_event_value(events, reverse: true) do |data|
-          data["service_tier"] || data.dig("response", "service_tier")
+          data["service_tier"] || data.dig("response", "service_tier") || data.dig("chunk", "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 openai_regional_processing?(request_url:, model:)
-        uri = parsed_uri(request_url)
-        return false unless uri&.host.to_s.downcase.match?(OPENAI_DATA_RESIDENCY_HOST_PATTERN)
-
-        openai_data_residency_model?(model)
+        OpenaiUsage.combined_pricing_mode(host: parsed_uri(request_url)&.host, model: model, service_tier: service_tier)
       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
+      IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
+      private_constant :IMAGE_OUTPUT_MODEL_PATTERN
 
-      def token_usage(usage:, cache_read:)
+      def token_usage(usage:, cache_read:, model: nil)
         audio_input = audio_input_tokens(usage)
         audio_output = audio_output_tokens(usage)
+        image_input = image_input_tokens(usage)
+        image_output_details = image_output_tokens(usage)
+        text_output_details = text_output_tokens(usage)
+        raw_output = (usage["completion_tokens"] || usage["output_tokens"]).to_i
+        image_output, regular_output_remainder = split_stream_image_output(
+          raw_output: raw_output, image_output_details: image_output_details,
+          text_output_details: text_output_details, audio_output: audio_output,
+          default_to_image: model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
+        )
 
         TokenUsage.build(
-          input_tokens: regular_input_tokens(usage: usage, cache_read: cache_read, audio_input: audio_input),
-          output_tokens: regular_output_tokens(usage: usage, audio_output: audio_output),
+          input_tokens: regular_input_tokens(
+            usage: usage, cache_read: cache_read, audio_input: audio_input, image_input: image_input
+          ),
+          output_tokens: regular_output_remainder,
           total_tokens: usage["total_tokens"],
           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: hidden_output_tokens(usage)
         )
       end
 
-      def regular_input_tokens(usage:, cache_read:, audio_input:)
-        [(usage["prompt_tokens"] || usage["input_tokens"]).to_i - cache_read - audio_input, 0].max
+      def split_stream_image_output(raw_output:, image_output_details:, text_output_details:, audio_output:,
+                                    default_to_image: false)
+        if image_output_details.zero? && text_output_details.zero?
+          remainder = [raw_output - audio_output, 0].max
+          return default_to_image ? [remainder, 0] : [0, remainder]
+        end
+
+        text_output = text_output_details
+        text_output = [raw_output - image_output_details - audio_output, 0].max if text_output.zero?
+        [image_output_details, text_output]
       end
 
-      def regular_output_tokens(usage:, audio_output:)
-        [(usage["completion_tokens"] || usage["output_tokens"]).to_i - audio_output, 0].max
+      def regular_input_tokens(usage:, cache_read:, audio_input:, image_input:)
+        raw = (usage["prompt_tokens"] || usage["input_tokens"]).to_i
+        [raw - cache_read - audio_input - image_input, 0].max
       end
 
       def cache_read_input_tokens(usage)
@@ -149,6 +205,21 @@ module LlmCostTracker
         details["audio_tokens"].to_i
       end
 
+      def image_input_tokens(usage)
+        details = input_token_details(usage)
+        details["image_tokens"].to_i
+      end
+
+      def image_output_tokens(usage)
+        details = output_token_details(usage)
+        details["image_tokens"].to_i
+      end
+
+      def text_output_tokens(usage)
+        details = output_token_details(usage)
+        details["text_tokens"].to_i
+      end
+
       def input_token_details(usage)
         usage["prompt_tokens_details"] || usage["input_tokens_details"] || usage["input_token_details"] || {}
       end