llm_cost_tracker 0.7.3 → 0.9.0

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -15,10 +15,18 @@ module LlmCostTracker
       end
 
       def provider_names
-        [
+        providers = LlmCostTracker.configuration.openai_compatible_providers
+        cached = @provider_names
+        return cached if cached && @provider_names_providers.equal?(providers)
+
+        names = [
           "openai_compatible",
-          *LlmCostTracker.configuration.openai_compatible_providers.each_value.map(&:to_s)
+          *providers.each_value.map { |provider| provider.to_s.downcase }
         ].uniq.freeze
+        return names unless providers.frozen?
+
+        @provider_names_providers = providers
+        @provider_names = names
       end
 
       def parse(request_url:, request_body:, response_status:, response_body:, **)
@@ -39,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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../billing/line_item"
+
+module LlmCostTracker
+  module Parsers
+    module OpenaiServiceCharges
+      RESPONSE_OUTPUT_COMPONENTS = {
+        "web_search_call" => :web_search_request,
+        "file_search_call" => :file_search_call,
+        "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, 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 billable?(item)
+        return false unless item.is_a?(Hash)
+
+        component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+        return false unless component
+        return true unless component == :web_search_request
+
+        action_type = item.dig("action", "type")
+        action_type.nil? || action_type == "search"
+      end
+
+      def store_output_item(output_items, 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"]
+                "#{component}:#{item['container_id']}"
+              else
+                item["id"] || "#{item['type']}:#{output_items.length}"
+              end
+        output_items[key] = item
+      end
+
+      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
+                             item["container_id"] || item["id"]
+                           else
+                             item["id"]
+                           end
+        Billing::LineItem.build(
+          component_key: component_key,
+          quantity: 1,
+          cost_status: Billing::CostStatus::UNKNOWN,
+          pricing_basis: :provider_usage,
+          provider_field: "response.output.#{item['type']}",
+          provider_item_id: provider_item_id,
+          details: line_item_details(item)
+        )
+      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"],
+          "action_type" => item.dig("action", "type"),
+          "container_id" => item["container_id"]
+        }.compact
+      end
+
+      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, 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, request: request, model: model)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,8 +1,33 @@
 # frozen_string_literal: true
 
+require_relative "openai_service_charges"
+
 module LlmCostTracker
   module Parsers
     module OpenaiUsage
+      include OpenaiServiceCharges
+
+      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:)
@@ -26,8 +51,9 @@ module LlmCostTracker
             service_tier: response["service_tier"] || request["service_tier"]
           ),
           model: model,
-          token_usage: token_usage(usage: usage, cache_read: cache_read),
-          usage_source: :response
+          token_usage: token_usage(usage: usage, cache_read: cache_read, model: model),
+          usage_source: :response,
+          service_line_items: openai_service_line_items(response, request: request)
         )
       end
 
@@ -35,99 +61,171 @@ 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,
+          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)
+        }
+      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,
-          service_tier: stream_pricing_mode(events) || request["service_tier"]
+          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
 
-        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
-          )
-        else
-          build_unknown_stream_usage(
-            provider: provider_for(request_url),
-            model: model,
-            provider_response_id: response_id,
-            pricing_mode: pricing_mode
-          )
-        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("_")
+        OpenaiUsage.combined_pricing_mode(host: parsed_uri(request_url)&.host, model: model, service_tier: service_tier)
       end
 
-      def openai_regional_processing?(request_url:, model:)
-        uri = parsed_uri(request_url)
-        return false unless %w[us.api.openai.com eu.api.openai.com].include?(uri&.host.to_s.downcase)
-
-        openai_data_residency_model?(model)
-      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:, 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)
+        )
 
-      def token_usage(usage:, cache_read:)
         TokenUsage.build(
-          input_tokens: regular_input_tokens(usage: usage, cache_read: cache_read),
-          output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
-          total_tokens: total_tokens(usage: usage, cache_read: cache_read),
+          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:)
-        [(usage["prompt_tokens"] || usage["input_tokens"]).to_i - cache_read.to_i, 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_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)
-        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
-        details["cached_tokens"]
+        details = input_token_details(usage)
+        details["cached_tokens"].to_i
+      end
+
+      def audio_input_tokens(usage)
+        details = input_token_details(usage)
+        details["audio_tokens"].to_i
       end
 
       def hidden_output_tokens(usage)
-        details = usage["completion_tokens_details"] || usage["output_tokens_details"] || {}
-        details["reasoning_tokens"]
+        details = output_token_details(usage)
+        details["reasoning_tokens"].to_i
+      end
+
+      def audio_output_tokens(usage)
+        details = output_token_details(usage)
+        details["audio_tokens"].to_i
       end
 
-      def total_tokens(usage:, cache_read:)
-        total = usage["total_tokens"]
-        return total.to_i unless total.nil?
+      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
 
-        regular_input_tokens(usage: usage, cache_read: cache_read) +
-          cache_read.to_i +
-          (usage["completion_tokens"] || usage["output_tokens"]).to_i
+      def output_token_details(usage)
+        usage["completion_tokens_details"] || usage["output_tokens_details"] || usage["output_token_details"] || {}
       end
     end
   end

data/lib/llm_cost_tracker/parsers/sse.rb

@@ -12,7 +12,7 @@ module LlmCostTracker
         def parse(body)
           return [] if body.blank?
 
-          return parse_json_array(body) if body.lstrip.start_with?("[")
+          return parse_json_array(body) if body.match?(/\A\s*\[/)
 
           parse_event_stream(body)
         end

data/lib/llm_cost_tracker/parsers.rb

@@ -13,7 +13,7 @@ module LlmCostTracker
     def find_for_provider(provider)
       provider_name = provider.to_s.downcase
       BUILT_INS.find do |parser|
-        Array(parser.provider_names).map { |name| name.to_s.downcase }.include?(provider_name)
+        parser.provider_names.include?(provider_name)
       end
     end
   end