llm_cost_tracker 0.9.0 → 0.11.0

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,36 +1,29 @@
 # frozen_string_literal: true
 
-require_relative "openai_service_charges"
+require_relative "../providers/openai/hosts"
+require_relative "../providers/openai/model_families"
+require_relative "../providers/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/
+      include LlmCostTracker::Providers::Openai::ServiceCharges
 
       class << self
         def combined_pricing_mode(host:, model:, service_tier:)
-          modes = [Pricing.normalize_mode(service_tier)]
+          modes = [Pricing::Mode.normalize(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/
-          )
+          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,44 @@
 
 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 :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