llm_cost_tracker 0.9.0 → 0.10.0

data/lib/llm_cost_tracker/parsers/openai_service_charges.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../billing/line_item"
+require_relative "../providers/openai/model_families"
 
 module LlmCostTracker
   module Parsers
@@ -12,13 +13,6 @@ module LlmCostTracker
         "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)
@@ -29,6 +23,40 @@ module LlmCostTracker
                .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
+
+      CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD = "choices.message.annotations.url_citation"
+      CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD = "request.model"
+
+      def chat_completions_web_search_items(response, model: nil)
+        return [] unless response["choices"]
+
+        provider_field = chat_completions_search_provider_field(response["choices"], model)
+        return [] unless provider_field
+
+        [{ "type" => "web_search_call", "id" => response["id"], "action" => { "type" => "search" },
+           "provider_field" => provider_field }]
+      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)
+
+        nil
+      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"] == "url_citation"
+          end
+        end
+      end
+
       def billable?(item)
         return false unless item.is_a?(Hash)
 
@@ -68,7 +96,7 @@ module LlmCostTracker
           quantity: 1,
           cost_status: Billing::CostStatus::UNKNOWN,
           pricing_basis: :provider_usage,
-          provider_field: "response.output.#{item['type']}",
+          provider_field: item["provider_field"] || "response.output.#{item['type']}",
           provider_item_id: provider_item_id,
           details: line_item_details(item)
         )
@@ -77,7 +105,7 @@ module LlmCostTracker
       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)
+        return component unless web_search_preview_used?(request) || chat_completions_search_model?(model)
 
         reasoning_model?(model) ? :web_search_preview_request_reasoning : :web_search_preview_request_non_reasoning
       end
@@ -92,13 +120,18 @@ module LlmCostTracker
         end
       end
 
-      def reasoning_model?(model)
+      def chat_completions_search_model?(model)
         return false unless model
 
         name = model.to_s.split("/", 2).last
-        return false if NON_REASONING_GPT5_PATTERN.match?(name)
+        LlmCostTracker::Providers::Openai::ModelFamilies.chat_completions_search?(name)
+      end
 
-        REASONING_MODEL_PATTERNS.any? { |pattern| pattern.match?(name) }
+      def reasoning_model?(model)
+        return false unless model
+
+        name = model.to_s.split("/", 2).last
+        LlmCostTracker::Providers::Openai::ModelFamilies.reasoning?(name)
       end
 
       def line_item_details(item)
@@ -109,10 +142,6 @@ module LlmCostTracker
         }.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|

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "openai_service_charges"
+require_relative "../providers/openai/hosts"
+require_relative "../providers/openai/model_families"
 
 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)]
@@ -18,19 +18,12 @@ module LlmCostTracker
         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/
-          )
+          LlmCostTracker::Providers::Openai::Hosts.data_residency?(host) &&
+            LlmCostTracker::Providers::Openai::ModelFamilies.data_residency?(model)
         end
       end
 
-      private
-
-      def parse_openai_usage(request_url:, request_body:, response_status:, response_body:)
+      def parse(request_url:, request_body:, response_status:, response_body:, **)
         return nil unless response_status == 200
 
         response = safe_json_parse(response_body)
@@ -42,7 +35,7 @@ module LlmCostTracker
 
         model = response["model"] || request["model"]
 
-        UsageCapture.build(
+        Event.build(
           provider: provider_for(request_url),
           provider_response_id: response["id"],
           pricing_mode: pricing_mode(
@@ -53,11 +46,11 @@ module LlmCostTracker
           model: model,
           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)
+          service_line_items: service_line_items_for(response, request: request, model: response["model"])
         )
       end
 
-      def parse_openai_stream_usage(response_status:, request_url: nil, request_body: nil, events: [])
+      def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
         return nil unless response_status == 200
 
         request = safe_json_parse(request_body)
@@ -70,6 +63,12 @@ module LlmCostTracker
         build_unknown_stream_usage(**context)
       end
 
+      def auto_enable_stream_usage?(request_url)
+        openai_chat_completions_url?(request_url)
+      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")
@@ -91,7 +90,7 @@ module LlmCostTracker
 
       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(
+        Event.build(
           provider: provider,
           provider_response_id: provider_response_id,
           pricing_mode: pricing_mode,
@@ -137,9 +136,6 @@ module LlmCostTracker
         OpenaiUsage.combined_pricing_mode(host: parsed_uri(request_url)&.host, model: model, service_tier: service_tier)
       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)
@@ -150,7 +146,7 @@ module LlmCostTracker
         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)
+          default_to_image: LlmCostTracker::Providers::Openai::ModelFamilies.image_output?(model)
         )
 
         TokenUsage.build(

data/lib/llm_cost_tracker/parsers.rb

@@ -2,19 +2,46 @@
 
 module LlmCostTracker
   module Parsers
-    BUILT_INS = [Openai.new, OpenaiCompatible.new, Anthropic.new, Gemini.new].freeze
+    autoload :Base,                 "llm_cost_tracker/parsers/base"
+    autoload :OpenaiUsage,          "llm_cost_tracker/parsers/openai_usage"
+    autoload :OpenaiServiceCharges, "llm_cost_tracker/parsers/openai_service_charges"
+    autoload :SSE,                  "llm_cost_tracker/parsers/sse"
+    autoload :Openai,               "llm_cost_tracker/parsers/openai"
+    autoload :Azure,                "llm_cost_tracker/parsers/azure"
+    autoload :OpenaiCompatible,     "llm_cost_tracker/parsers/openai_compatible"
+    autoload :Anthropic,            "llm_cost_tracker/parsers/anthropic"
+    autoload :Gemini,               "llm_cost_tracker/parsers/gemini"
+
+    MUTEX = Mutex.new
+    PARSER_CONSTANTS = %i[Openai Azure OpenaiCompatible Anthropic Gemini].freeze
 
     module_function
 
     def find_for(url)
-      BUILT_INS.find { |parser| parser.match?(url) }
+      PARSER_CONSTANTS.each do |name|
+        klass = const_get(name)
+        return instance_for(klass) if klass.match?(url)
+      end
+      nil
     end
 
     def find_for_provider(provider)
       provider_name = provider.to_s.downcase
-      BUILT_INS.find do |parser|
-        parser.provider_names.include?(provider_name)
+      PARSER_CONSTANTS.each do |name|
+        klass = const_get(name)
+        return instance_for(klass) if klass.provider_names.include?(provider_name)
+      end
+      nil
+    end
+
+    def instance_for(klass)
+      cached = (@instances ||= {})[klass]
+      return cached if cached
+
+      MUTEX.synchronize do
+        @instances[klass] ||= klass.new
       end
     end
+    private_class_method :instance_for
   end
 end