llm_cost_tracker 0.14.1 → 0.15.0

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

@@ -11,13 +11,18 @@ module LlmCostTracker
   module Providers
     module Openai
       module ResponseParser
-        include LlmCostTracker::Providers::Openai::ServiceCharges
+        PENDING_STATUSES = %w[queued in_progress].freeze
+        RETRIEVE_PATH_PATTERN = %r{/(?:responses|agent)/resp_}
+        TRANSCRIPTION_PATH_PATTERN = %r{/audio/(?:transcriptions|translations)\z}
 
         class << self
-          def combined_pricing_mode(host:, model:, service_tier:)
+          def included(base) = base.include(StreamParser)
+
+          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")
+            owners = %w[gemini/ anthropic/] if Hosts.vertex_non_global?(host)
+            if (owners || Hosts.data_residency?(host)) &&
+               Pricing::Matcher.modifier_priced?(provider:, model:, modifier: "data_residency", owners:)
               modes << "data_residency"
             end
             Pricing::Mode.compose(modes)
@@ -25,133 +30,130 @@ module LlmCostTracker
 
           def event_from_response(response:, request:, provider:, host:, usage_source:, pricing_mode: nil)
             usage = response["usage"]&.deep_symbolize_keys
-            return nil unless usage
+            return nil if usage.nil? || pending?(response)
 
             model = response["model"] || request["model"]
-            service_line_items =
-              ServiceCharges.service_line_items_for(response, request: request, model: model) +
-              ServiceCharges.transcription_line_items(usage)
-            Event.build(
+            service_tier = response["service_tier"] || usage[:service_tier] || request["service_tier"]
+            usage_event(
+              usage,
               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"]
-              ),
               model: model,
-              token_usage: UsageExtractor.token_usage(usage, model: model),
               usage_source: usage_source,
-              service_line_items: service_line_items
+              service_line_items: ServiceCharges.service_line_items_for(response, request: request, model: model),
+              pricing_mode: pricing_mode || combined_pricing_mode(provider:, host:, model:, service_tier:)
             )
           end
-        end
 
-        def parse(request_url:, request_body:, response_status:, response_body:, **)
-          return nil unless response_status == 200
+          def retrieved_event(response:, provider:, host:, usage_source:)
+            return nil unless response["background"] && response["usage"] && !pending?(response)
+            return nil if Call.already_recorded?(provider: provider, provider_response_id: response["id"])
 
-          ResponseParser.event_from_response(
-            response: safe_json_parse(response_body),
-            request: safe_json_parse(request_body),
-            provider: provider_for(request_url),
-            host: parsed_uri(request_url)&.host,
-            usage_source: Usage::Source::RESPONSE
-          )
-        end
-
-        def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
-          return nil unless response_status == 200
+            event_from_response(
+              response: response,
+              request: { "tools" => response["tools"] },
+              provider: provider,
+              host: host,
+              usage_source: usage_source
+            )&.keyed_by_response_id
+          end
 
-          request = safe_json_parse(request_body)
-          usage = detect_stream_usage(events)
-          context = stream_capture_context(events: events, request: request, request_url: request_url)
+          def usage_event(usage, model:, service_line_items:, **attributes)
+            Event.build(
+              model: model,
+              token_usage: UsageExtractor.token_usage(usage, model: model),
+              service_line_items: service_line_items + ServiceCharges.transcription_line_items(usage) +
+                                  ServiceCharges.billed_line_items(usage) + UsageExtractor.cache_read_line_items(usage),
+              **attributes
+            )
+          end
 
-          return build_known_stream_usage(usage: usage, **context) if usage
+          private
 
-          warn_missing_stream_usage(request_url: request_url, request: request)
-          build_unknown_stream_usage(**context)
+          def pending?(response)
+            PENDING_STATUSES.include?(response["status"].to_s)
+          end
         end
 
-        def auto_enable_stream_usage?(request_url, _request_parsed)
-          openai_chat_completions_url?(request_url)
-        end
+        def parse(request_url:, request_body:, response_status:, response_body:, **)
+          return nil unless response_status == 200
+
+          response = safe_json_parse(response_body)
+          uri = parsed_uri(request_url)
+          source = { provider: provider_for(request_url), host: uri&.host, usage_source: Usage::Source::RESPONSE }
+          if uri&.path.to_s.match?(RETRIEVE_PATH_PATTERN)
+            return ResponseParser.retrieved_event(response: response, **source)
+          end
 
-        def retain_stream_event?(data)
-          data.is_a?(Hash) && (data["item"].is_a?(Hash) || data["response"].is_a?(Hash))
+          request = safe_json_parse(request_body)
+          ResponseParser.event_from_response(response: response, request: request, **source) ||
+            usage_free_event(request_url, request, response)
         end
 
         private
 
-        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,
-            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,
-              service_tier: stream_pricing_mode(events) || request["service_tier"]
-            ),
-            service_line_items: openai_stream_service_line_items(events, request: request, model: model)
-          }
+        def usage_free_event(request_url, request, response)
+          path = parsed_uri(request_url)&.path.to_s
+          if path.end_with?("/audio/speech")
+            speech_event(request_url, request)
+          elsif path.match?(TRANSCRIPTION_PATH_PATTERN)
+            transcription_event(request_url, request, response)
+          else
+            ocr_event(request_url, request, response) ||
+              (moderation_event(request_url, request, response) if path.end_with?("/moderations"))
+          end
         end
 
-        def build_known_stream_usage(usage:,
-                                     provider:,
-                                     model:,
-                                     provider_response_id:,
-                                     pricing_mode:,
-                                     service_line_items:)
-          Event.build(
-            provider: provider,
-            provider_response_id: provider_response_id,
-            pricing_mode: pricing_mode,
-            model: model,
-            token_usage: UsageExtractor.token_usage(usage, model: model),
-            stream: true,
-            usage_source: Usage::Source::STREAM_FINAL,
-            service_line_items: service_line_items
-          )
+        def speech_event(request_url, request)
+          line_item_event(request_url, model_for(request_url, request), ServiceCharges.speech_line_items(request))
         end
 
-        def warn_missing_stream_usage(request_url:, request:)
-          return unless request["stream"]
-          return unless openai_chat_completions_url?(request_url)
-          return if request.dig("stream_options", "include_usage")
+        def transcription_event(request_url, request, response)
+          seconds = response["duration"].to_f.ceil
+          line_items = ServiceCharges.transcription_line_items(type: "duration", seconds: seconds)
+          line_item_event(request_url, model_for(request_url, request) || Event::UNKNOWN_MODEL, line_items)
+        end
 
-          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=#{Usage::Source::UNKNOWN}."
+        def line_item_event(request_url, model, line_items)
+          zero_token_event(
+            request_url,
+            model: model,
+            usage_source: line_items.empty? ? Usage::Source::UNKNOWN : Usage::Source::RESPONSE,
+            service_line_items: line_items
           )
         end
 
-        def openai_chat_completions_url?(request_url)
-          uri = parsed_uri(request_url)
-          uri && uri.path.to_s.end_with?("/chat/completions")
-        end
+        def ocr_event(request_url, request, response)
+          line_items = ServiceCharges.ocr_line_items(response)
+          return nil if line_items.empty?
 
-        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 if candidate.is_a?(Hash)
-          end
-          usage&.deep_symbolize_keys
+          model = response["model"] || model_for(request_url, request)
+          zero_token_event(
+            request_url,
+            model: model,
+            pricing_mode: ResponseParser.combined_pricing_mode(
+              provider: provider_for(request_url), host: parsed_uri(request_url)&.host, model: model, service_tier: nil
+            ),
+            usage_source: Usage::Source::RESPONSE,
+            service_line_items: line_items
+          )
         end
 
-        def stream_pricing_mode(events)
-          find_event_value(events, reverse: true) do |data|
-            data["service_tier"] || data.dig("response", "service_tier") || data.dig("chunk", "service_tier")
-          end
+        def moderation_event(request_url, request, response)
+          zero_token_event(
+            request_url,
+            model: response["model"] || model_for(request_url, request),
+            provider_response_id: response["id"],
+            usage_source: Usage::Source::RESPONSE
+          )
         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 zero_token_event(request_url, **attributes)
+          Event.build(
+            provider: provider_for(request_url),
+            token_usage: Usage::TokenUsage.build(input_tokens: 0, output_tokens: 0),
+            **attributes
+          )
         end
       end
     end

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

@@ -1,179 +1,173 @@
 # frozen_string_literal: true
 
 require_relative "model_families"
+require_relative "output_item"
 
 module LlmCostTracker
   module Providers
     module Openai
       module ServiceCharges
-        RESPONSE_OUTPUT_RENAMES = {
-          "web_search_call" => "web_search_request",
-          "code_interpreter_call" => "container_session"
-        }.freeze
-
-        module_function
-
-        def line_items_from_output(output_items, request: nil, model: nil)
-          deduped = {}
-          Array(output_items).each { |item| store_output_item(deduped, item) }
-          deduped.values
-                 .select { |item| billable?(item) }
-                 .filter_map { |item| build_line_item(item, request: request, model: model) }
-        end
-
-        def service_line_items_for(response, request: nil, model: nil)
-          output_items = Array(response["output"])
-          output_items += chat_completions_web_search_items(response, model: model) if output_items.empty?
-          line_items_from_output(output_items, request: request, model: model)
-        end
+        TICKS_PER_USD = 10_000_000_000
 
-        CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD = "choices.message.annotations.url_citation"
-        CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD = "request.model"
+        class << self
+          def service_line_items_for(response, request: nil, model: nil)
+            output_items = Array(response["output"])
+            output_items += chat_completions_web_search_items(response, model: model) if output_items.empty?
+            line_items_from_output(output_items, request: request, model: model)
+          end
 
-        def chat_completions_web_search_items(response, model: nil)
-          return [] unless response["choices"]
+          def line_items_from_output(output_items, request: nil, model: nil)
+            unique = {}
+            Array(output_items).each do |data|
+              item = OutputItem.wrap(data)
+              unique[item.dedup_key(unique.length)] = item if item
+            end
+            unique.values.select(&:billable?).map { |item| priced_line_item(item, request: request, model: model) }
+          end
 
-          provider_field = chat_completions_search_provider_field(response["choices"], model)
-          return [] unless provider_field
+          def billable?(item)
+            OutputItem.wrap(item)&.billable? || false
+          end
 
-          [{ "type" => "web_search_call", "id" => response["id"], "action" => { "type" => "search" },
-             "provider_field" => provider_field }]
-        end
+          def build_line_item(item, request: nil, model: nil)
+            output_item = OutputItem.wrap(item)
+            priced_line_item(output_item, request: request, model: model) if output_item
+          end
 
-        def chat_completions_search_provider_field(choices, model)
-          return CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD if chat_completions_used_web_search?(choices)
-          return CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD if chat_completions_search_model?(model)
+          def billing_fields(item)
+            OutputItem.wrap(item)&.billing_fields
+          end
 
-          nil
-        end
+          def transcription_line_items(usage)
+            return [] unless usage
+
+            field = (usage[:type] || usage["type"]).to_s == "duration" ? "seconds" : "prompt_audio_seconds"
+            seconds = (usage[field.to_sym] || usage[field]).to_f
+            return [] unless seconds.positive?
+
+            [Charges::LineItem.build(
+              dimension_key: "transcription_minute",
+              quantity: BigDecimal(seconds.to_s) / 60,
+              cost_status: Charges::CostStatus::UNKNOWN,
+              pricing_basis: "provider_usage",
+              provider_field: "usage.#{field}",
+              details: { seconds: seconds }
+            )]
+          end
 
-        def chat_completions_used_web_search?(choices)
-          Array(choices).any? do |choice|
-            Array(choice.dig("message", "annotations")).any? do |annotation|
-              annotation.is_a?(Hash) && annotation["type"].to_s == "url_citation"
-            end
+          def speech_line_items(request)
+            input = request["input"]
+            return [] unless input.is_a?(String) && ModelFamilies.character_billed_tts?(request["model"])
+
+            [Charges::LineItem.build(
+              dimension_key: "text_to_speech_character",
+              quantity: input.length,
+              cost_status: Charges::CostStatus::UNKNOWN,
+              pricing_basis: "provider_usage",
+              provider_field: "request.input"
+            )]
           end
-        end
 
-        def billable?(item)
-          return false unless item.is_a?(Hash)
+          def ocr_line_items(response)
+            pages = response.dig("usage_info", "pages_processed")
+            return unit_line_items("ocr_page", pages, "usage_info.pages_processed") if pages
 
-          dimension = output_dimension(item["type"])
-          return false unless dimension
-          return true unless dimension == "web_search_request"
+            unit_line_items("ocr_page", response.dig("meta", "billed_units", "pages"), "meta.billed_units.pages")
+          end
 
-          action_type = item.dig("action", "type")
-          action_type.nil? || action_type == "search"
-        end
+          def rerank_line_items(response)
+            units = response.dig("meta", "billed_units", "search_units")
+            unit_line_items("rerank_search_unit", units, "meta.billed_units.search_units")
+          end
 
-        def store_output_item(output_items, item)
-          return unless item.is_a?(Hash)
+          def billed_line_items(usage)
+            amount, field = billed_amount(usage)
+            return [] unless amount
+
+            [Charges::LineItem.build(
+              dimension_key: "billed_request",
+              quantity: 1,
+              rate_amount: amount,
+              cost: amount,
+              pricing_basis: "provider_usage",
+              price_source: "provider_response",
+              provider_field: field
+            )]
+          end
 
-          dimension = output_dimension(item["type"])
-          return unless dimension
+          private
 
-          key = if dimension == "container_session" && item["container_id"]
-                  "#{dimension}:#{item['container_id']}"
-                else
-                  item["id"] || "#{item['type']}:#{output_items.length}"
-                end
-          output_items[key] = item
-        end
+          def chat_completions_web_search_items(response, model: nil)
+            return [] unless response["choices"] && chat_completions_search_model?(model)
 
-        def build_line_item(item, request: nil, model: nil)
-          return nil unless item.is_a?(Hash)
-
-          dimension_key = dimension_key_for(item, request: request, model: model)
-          return nil unless dimension_key
-
-          provider_item_id = if dimension_key == "container_session"
-                               item["container_id"] || item["id"]
-                             else
-                               item["id"]
-                             end
-          Charges::LineItem.build(
-            dimension_key: dimension_key,
-            quantity: 1,
-            cost_status: Charges::CostStatus::UNKNOWN,
-            pricing_basis: "provider_usage",
-            provider_field: item["provider_field"] || "response.output.#{item['type']}",
-            provider_item_id: provider_item_id,
-            details: line_item_details(item)
-          )
-        end
+            [{ "type" => "web_search_call", "id" => response["id"], "action" => { "type" => "search" },
+               "provider_field" => "request.model" }]
+          end
 
-        def dimension_key_for(item, request:, model:)
-          dimension = output_dimension(item["type"])
-          return dimension unless dimension == "web_search_request"
-          return dimension unless web_search_preview_used?(request) || chat_completions_search_model?(model)
+          def priced_line_item(item, request:, model:)
+            item.line_item(priced_dimension(item.dimension, request: request, model: model))
+          end
 
-          reasoning_model?(model) ? "web_search_preview_request_reasoning" : "web_search_preview_request_non_reasoning"
-        end
+          def priced_dimension(dimension, request:, model:)
+            return dimension unless dimension == "web_search_request"
+            return dimension unless web_search_preview_used?(request) || chat_completions_search_model?(model)
+            return "web_search_preview_request_reasoning" if reasoning_model?(model)
 
-        def output_dimension(type)
-          key = RESPONSE_OUTPUT_RENAMES[type] || type
-          dimension = Usage::Catalog[key]
-          key if dimension && dimension.token_key.nil?
-        end
+            "web_search_preview_request_non_reasoning"
+          end
 
-        def web_search_preview_used?(request)
-          tools = request && (request[:tools] || request["tools"])
-          Array(tools).any? do |tool|
-            type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
-            type.to_s.include?("web_search_preview")
+          def web_search_preview_used?(request)
+            tools = request && (request[:tools] || request["tools"])
+            Array(tools).any? do |tool|
+              type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
+              type.to_s.include?("web_search_preview")
+            end
           end
-        end
 
-        def chat_completions_search_model?(model)
-          name = local_model_name(model)
-          name && ModelFamilies.chat_completions_search?(name)
-        end
+          def chat_completions_search_model?(model)
+            name = local_model_name(model)
+            name && ModelFamilies.chat_completions_search?(name)
+          end
 
-        def reasoning_model?(model)
-          name = local_model_name(model)
-          name && ModelFamilies.reasoning?(name)
-        end
+          def reasoning_model?(model)
+            name = local_model_name(model)
+            name && ModelFamilies.reasoning?(name)
+          end
 
-        def local_model_name(model)
-          return nil unless model
+          def local_model_name(model)
+            return nil unless model
 
-          model.to_s.split("/", 2).last
-        end
+            model.to_s.split("/", 2).last
+          end
 
-        def line_item_details(item)
-          {
-            status: item["status"],
-            action_type: item.dig("action", "type"),
-            container_id: item["container_id"]
-          }.compact
-        end
+          def unit_line_items(dimension_key, quantity, provider_field)
+            return [] unless quantity.is_a?(Numeric) && quantity.positive?
 
-        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"]
+            [Charges::LineItem.build(
+              dimension_key: dimension_key,
+              quantity: quantity,
+              cost_status: Charges::CostStatus::UNKNOWN,
+              pricing_basis: "provider_usage",
+              provider_field: provider_field
+            )]
           end
-          line_items_from_output(output_items, request: request, model: model)
-        end
 
-        def transcription_line_items(usage)
-          return [] unless usage
+          def billed_amount(usage)
+            cost = usage[:cost]
+            return reported_cost(usage, cost) if cost.is_a?(Numeric)
 
-          type = (usage[:type] || usage["type"]).to_s
-          return [] unless type == "duration"
+            ticks = usage[:cost_in_usd_ticks]
+            return [BigDecimal(ticks.to_s) / TICKS_PER_USD, "usage.cost_in_usd_ticks"] if ticks.is_a?(Numeric)
 
-          seconds = (usage[:seconds] || usage["seconds"]).to_f
-          return [] unless seconds.positive?
+            total = cost[:total_cost] if cost.is_a?(Hash)
+            [BigDecimal(total.to_s), "usage.cost.total_cost"] if total.is_a?(Numeric) && total.positive?
+          end
 
-          [Charges::LineItem.build(
-            dimension_key: "transcription_minute",
-            quantity: (seconds / 60.0).ceil,
-            cost_status: Charges::CostStatus::UNKNOWN,
-            pricing_basis: "provider_usage",
-            provider_field: "usage.seconds",
-            details: { seconds: seconds }
-          )]
+          def reported_cost(usage, cost)
+            amounts = [cost]
+            amounts << usage.dig(:cost_details, :upstream_inference_cost) if usage[:is_byok]
+            [amounts.sum { |value| BigDecimal(value.to_s) }, "usage.cost"] if amounts.all?(Numeric)
+          end
         end
       end
     end