llm_cost_tracker 0.10.0 → 0.11.0

data/lib/llm_cost_tracker/integrations/openai.rb

@@ -2,9 +2,9 @@
 
 require_relative "base"
 require_relative "../billing/line_item"
-require_relative "../parsers/openai_service_charges"
 require_relative "../providers/azure/hosts"
 require_relative "../providers/openai/model_families"
+require_relative "../providers/openai/service_charges"
 
 module LlmCostTracker
   module Integrations
@@ -245,7 +245,7 @@ module LlmCostTracker
           output_items << chat_search if chat_search
           return [] if output_items.empty?
 
-          LlmCostTracker::Parsers::OpenaiServiceCharges.line_items_from_output(
+          LlmCostTracker::Providers::Openai::ServiceCharges.line_items_from_output(
             output_items, request: request, model: model
           )
         end
@@ -255,9 +255,9 @@ module LlmCostTracker
           return nil unless choices.respond_to?(:any?)
 
           provider_field = if choices.any? { |choice| choice_used_url_citation?(choice) }
-                             LlmCostTracker::Parsers::OpenaiServiceCharges::CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD
+                             LlmCostTracker::Providers::Openai::ServiceCharges::CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD
                            elsif LlmCostTracker::Providers::Openai::ModelFamilies.chat_completions_search?(model)
-                             LlmCostTracker::Parsers::OpenaiServiceCharges::CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD
+                             LlmCostTracker::Providers::Openai::ServiceCharges::CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD
                            end
           return nil unless provider_field
 
@@ -355,79 +355,22 @@ module LlmCostTracker
         end
       end
 
-      module ResponsesPatch
-        def create(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.record_response(
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
-            host: LlmCostTracker::Integrations::Openai.client_host_for(self)
-          )
-          response
-        end
-
-        def stream(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, _|
-            super(*normalized)
-          end
-        end
-
-        def stream_raw(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, _|
-            super(*normalized)
-          end
-        end
-
-        def retrieve_streaming(response_id, *args, **kwargs)
-          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, collector|
-            collector.provider_response_id = response_id
-            super(response_id, *normalized)
-          end
-        end
-      end
-
-      module ChatCompletionsPatch
-        def create(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.record_response(
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
-            host: LlmCostTracker::Integrations::Openai.client_host_for(self)
-          )
-          response
-        end
-
-        def stream(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, _|
-            super(*normalized)
-          end
-        end
-
-        def stream_raw(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, _|
-            super(*normalized)
-          end
-        end
-      end
-
       module PatchBuilder
         module_function
 
         def build(record_method:, methods:)
           Module.new.tap do |mod|
-            methods.each { |method_name| define_wrapped_method(mod, method_name, record_method) }
+            methods.each { |method_name| define_blocking_method(mod, method_name, record_method) }
           end
         end
 
-        def define_wrapped_method(mod, method_name, record_method)
+        def build_stream(methods:)
+          Module.new.tap do |mod|
+            methods.each { |method_name| define_stream_method(mod, method_name) }
+          end
+        end
+
+        def define_blocking_method(mod, method_name, record_method)
           mod.define_method(method_name) do |*args, **kwargs, &block|
             integration = LlmCostTracker::Integrations::Openai
             request = integration.request_params(args, kwargs)
@@ -443,38 +386,41 @@ module LlmCostTracker
             response
           end
         end
+
+        def define_stream_method(mod, method_name)
+          mod.define_method(method_name) do |*args, **kwargs|
+            LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, _|
+              super(*normalized)
+            end
+          end
+        end
       end
 
-      EmbeddingsPatch = PatchBuilder.build(record_method: :record_response, methods: %i[create])
-      ImagesPatch = PatchBuilder.build(record_method: :record_image, methods: %i[generate edit create_variation])
-      TranscriptionsPatch = PatchBuilder.build(record_method: :record_transcription, methods: %i[create])
-      TranslationsPatch = PatchBuilder.build(record_method: :record_transcription, methods: %i[create])
-      SpeechPatch = PatchBuilder.build(record_method: :record_speech, methods: %i[create])
-      ModerationsPatch = PatchBuilder.build(record_method: :record_moderation, methods: %i[create])
+      module ResponsesPatch
+        include PatchBuilder.build(record_method: :record_response, methods: %i[create])
+        include PatchBuilder.build_stream(methods: %i[stream stream_raw])
 
-      module StreamingImagesPatch
-        %i[generate_stream_raw edit_stream_raw].each do |method_name|
-          define_method(method_name) do |*args, **kwargs|
-            request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-            LlmCostTracker::Integrations::Openai.enforce_budget!(request: request)
-            host = LlmCostTracker::Integrations::Openai.client_host_for(self)
-            collector = LlmCostTracker::Integrations::Openai.stream_collector(request, host: host)
-            stream = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-            LlmCostTracker::Integrations::Openai.track_stream(stream, collector: collector)
+        def retrieve_streaming(response_id, *args, **kwargs)
+          LlmCostTracker::Integrations::Openai.wrap_stream_call(args, kwargs, self) do |normalized, collector|
+            collector.provider_response_id = response_id
+            super(response_id, *normalized)
           end
         end
       end
 
-      module StreamingTranscriptionsPatch
-        def create_streaming(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!(request: request)
-          host = LlmCostTracker::Integrations::Openai.client_host_for(self)
-          collector = LlmCostTracker::Integrations::Openai.stream_collector(request, host: host)
-          stream = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.track_stream(stream, collector: collector)
-        end
+      module ChatCompletionsPatch
+        include PatchBuilder.build(record_method: :record_response, methods: %i[create])
+        include PatchBuilder.build_stream(methods: %i[stream stream_raw])
       end
+
+      EmbeddingsPatch = PatchBuilder.build(record_method: :record_response, methods: %i[create])
+      ImagesPatch = PatchBuilder.build(record_method: :record_image, methods: %i[generate edit create_variation])
+      TranscriptionsPatch = PatchBuilder.build(record_method: :record_transcription, methods: %i[create])
+      TranslationsPatch = PatchBuilder.build(record_method: :record_transcription, methods: %i[create])
+      SpeechPatch = PatchBuilder.build(record_method: :record_speech, methods: %i[create])
+      ModerationsPatch = PatchBuilder.build(record_method: :record_moderation, methods: %i[create])
+      StreamingImagesPatch = PatchBuilder.build_stream(methods: %i[generate_stream_raw edit_stream_raw])
+      StreamingTranscriptionsPatch = PatchBuilder.build_stream(methods: %i[create_streaming])
     end
   end
 end

data/lib/llm_cost_tracker/integrations/ruby_llm.rb

@@ -31,20 +31,16 @@ module LlmCostTracker
           ]
         end
 
-        def record_completion(provider, response, request:, latency_ms:, stream:)
+        def record_completion(provider, response, request:, latency_ms:, has_block:)
           record_usage(
             provider: provider_slug(provider),
             model: response_model_id(response) || model_id(request[:model]),
             response: response,
             latency_ms: latency_ms,
-            stream: stream
+            stream: has_block || request[:stream] == true
           )
         end
 
-        def streaming_request?(request, has_block:)
-          has_block || request[:stream] == true
-        end
-
         def record_embedding(provider, response, request:, latency_ms:)
           record_usage(
             provider: provider_slug(provider),
@@ -198,77 +194,37 @@ module LlmCostTracker
 
       module ProviderPatch
         def complete(*args, **kwargs, &)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_completion(
-            self,
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
-            stream: integration.streaming_request?(request, has_block: block_given?)
-          )
-          response
+          measure(args, kwargs, recorder: :record_completion, has_block: block_given?) { super }
         end
 
         def embed(*args, **kwargs)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_embedding(
-            self,
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
-          )
-          response
+          measure(args, kwargs, recorder: :record_embedding) { super }
         end
 
         def transcribe(*args, **kwargs)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_transcription(
-            self,
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
-          )
-          response
+          measure(args, kwargs, recorder: :record_transcription) { super }
         end
 
         def paint(*args, **kwargs)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_image(
-            self,
-            response,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
-          )
-          response
+          measure(args, kwargs, recorder: :record_image) { super }
         end
 
         def moderate(*args, **kwargs)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!(request: request)
+          measure(args, kwargs, recorder: :record_moderation) { super }
+        end
+
+        private
+
+        def measure(args, kwargs, recorder:, **extras)
+          request = RubyLlm.request_params(args, kwargs)
+          RubyLlm.enforce_budget!(request: request)
           started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_moderation(
-            self,
-            response,
+          response = yield
+          RubyLlm.public_send(
+            recorder, self, response,
             request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
+            **extras
           )
           response
         end

data/lib/llm_cost_tracker/ledger.rb

@@ -14,3 +14,16 @@ require_relative "ledger/rollups/upsert_sql"
 require_relative "ledger/rollups"
 require_relative "ledger/store"
 require_relative "ledger/period/totals"
+
+module LlmCostTracker
+  module Ledger
+    module Schema
+      CORE_SCHEMAS = [
+        [Calls, "llm_cost_tracker_calls"],
+        [CallLineItems, "llm_cost_tracker_call_line_items"],
+        [CallTags, "llm_cost_tracker_call_tags"]
+      ].freeze
+      CACHE_ROLLUPS_SCHEMA = [CallRollups, "llm_cost_tracker_call_rollups"].freeze
+    end
+  end
+end

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -6,6 +6,7 @@ require "stringio"
 require "uri"
 
 require_relative "../logging"
+require_relative "../capture/sse"
 require_relative "../capture/stream"
 require_relative "../timing"
 
@@ -201,7 +202,7 @@ module LlmCostTracker
           )
         end
 
-        events = overflowed ? [] : Parsers::SSE.parse(body)
+        events = overflowed ? [] : Capture::SSE.parse(body)
         parser.parse_stream(
           request_url: request_url,
           request_body: request_body,

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../providers/anthropic/server_tools"
 require_relative "../providers/anthropic/tier_classification"
 
 module LlmCostTracker
@@ -104,36 +105,18 @@ module LlmCostTracker
         server_tool_use = usage["server_tool_use"]
         return [] unless server_tool_use.is_a?(Hash)
 
-        [
-          service_line_item(
-            component_key: :web_search_request,
-            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"],
-            provider_field: "usage.server_tool_use.code_execution_requests"
-          )
-        ].compact
-      end
-
-      def service_line_item(component_key:, quantity:, provider_field:)
-        quantity = quantity.to_i
-        return if quantity.zero?
+        Providers::Anthropic::ServerTools::LINE_ITEMS.filter_map do |component_key, count_key|
+          quantity = server_tool_use[count_key.to_s].to_i
+          next if quantity.zero?
 
-        Billing::LineItem.build(
-          component_key: component_key,
-          quantity: quantity,
-          cost_status: Billing::CostStatus::UNKNOWN,
-          pricing_basis: :provider_usage,
-          provider_field: provider_field
-        )
+          Billing::LineItem.build(
+            component_key: component_key,
+            quantity: quantity,
+            cost_status: Billing::CostStatus::UNKNOWN,
+            pricing_basis: :provider_usage,
+            provider_field: "usage.server_tool_use.#{count_key}"
+          )
+        end
       end
 
       def token_usage(usage:, cache_read:)
@@ -176,8 +159,8 @@ module LlmCostTracker
         service_tier = usage&.fetch("service_tier", nil) || request["service_tier"]
         service_tier = nil if Providers::Anthropic::TierClassification.standard_equivalent_tier?(service_tier)
 
-        modes << Pricing.normalize_mode(speed)
-        modes << Pricing.normalize_mode(service_tier)
+        modes << Pricing::Mode.normalize(speed)
+        modes << Pricing::Mode.normalize(service_tier)
         geo = inference_geo(request: request, usage: usage).downcase
         modes << "data_residency" if Providers::Anthropic::TierClassification.data_residency_geo?(geo)
 

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -152,9 +152,7 @@ module LlmCostTracker
 
       def modality_tokens(details, modality)
         Array(details).sum do |detail|
-          next 0 unless detail.is_a?(Hash)
-
-          next 0 unless detail["modality"] == modality
+          next 0 unless detail.is_a?(Hash) && detail["modality"] == modality
 
           (detail["tokenCount"] || detail["token_count"]).to_i
         end
@@ -174,10 +172,10 @@ module LlmCostTracker
 
       def pricing_mode(request:, response_headers:)
         response_tier = response_header(response_headers, "x-gemini-service-tier")
-        response_mode = Pricing.normalize_mode(response_tier)
+        response_mode = Pricing::Mode.normalize(response_tier)
         return response_mode if response_mode
 
-        request_mode = Pricing.normalize_mode(
+        request_mode = Pricing::Mode.normalize(
           request["service_tier"] ||
           request["serviceTier"] ||
           request.dig("config", "service_tier") ||

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -30,12 +30,6 @@ module LlmCostTracker
           @provider_names = names
         end
 
-        def provider_for(request_url)
-          provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
-        end
-
-        private
-
         def provider_for_uri(uri)
           return nil unless uri
 
@@ -44,7 +38,7 @@ module LlmCostTracker
       end
 
       def provider_for(request_url)
-        self.class.provider_for(request_url)
+        self.class.provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,17 +1,17 @@
 # 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
+      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("_")

data/lib/llm_cost_tracker/parsers.rb

@@ -4,8 +4,6 @@ module LlmCostTracker
   module Parsers
     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"

data/lib/llm_cost_tracker/pricing/explainer.rb

@@ -50,7 +50,7 @@ module LlmCostTracker
 
         def explanation(provider:, model:, pricing_mode:, match:, usage:)
           prices = match&.prices
-          pricing_mode = Pricing.normalize_mode(pricing_mode)
+          pricing_mode = Pricing::Mode.normalize(pricing_mode)
           effective = if prices
                         EffectivePrices.call(usage: usage, quantities: usage.priced_quantities,
                                              prices: prices, pricing_mode: pricing_mode)

data/lib/llm_cost_tracker/pricing/mode.rb

@@ -3,10 +3,39 @@
 module LlmCostTracker
   module Pricing
     class Mode
-      COMPOUND_MODIFIERS = %w[data_residency].freeze
+      STANDARD_MODE_VALUES = %i[auto default standard standard_only].freeze
+      COMPOUND_MODIFIERS = %i[data_residency].freeze
 
       attr_reader :modifiers
 
+      def self.normalize(value)
+        return nil if value.nil?
+
+        symbol = normalize_string(value.to_s)
+        return nil unless symbol
+
+        STANDARD_MODE_VALUES.include?(symbol) ? nil : symbol
+      end
+
+      def self.merge(provider_mode, request_mode)
+        return normalize(request_mode) if provider_mode.to_s.strip.empty?
+
+        provider_tokens = tokenize(provider_mode) - STANDARD_MODE_VALUES
+        request_host_tokens = tokenize(request_mode || "") & COMPOUND_MODIFIERS
+        combined = provider_tokens | request_host_tokens
+        return nil if combined.empty?
+
+        normalize(combined.join("_"))
+      end
+
+      def self.normalize_string(value)
+        normalized = value.strip
+        return nil if normalized.empty?
+
+        normalized.downcase.tr("-", "_").to_sym
+      end
+      private_class_method :normalize_string
+
       def self.parse(value)
         return value if value.is_a?(self)
         return new([]) if value.nil?
@@ -21,11 +50,12 @@ module LlmCostTracker
           break if remaining.empty?
 
           compound = COMPOUND_MODIFIERS.find do |token|
-            remaining == token || remaining.start_with?("#{token}_")
+            name = token.name
+            remaining == name || remaining.start_with?("#{name}_")
           end
           if compound
-            tokens << compound.to_sym
-            remaining = remaining.delete_prefix(compound).delete_prefix("_")
+            tokens << compound
+            remaining = remaining.delete_prefix(compound.name).delete_prefix("_")
           else
             first, _, rest = remaining.partition("_")
             tokens << first.to_sym unless first.empty?

data/lib/llm_cost_tracker/pricing/service_charges.rb

@@ -68,7 +68,7 @@ module LlmCostTracker
       end
 
       def charge_rate(provider:, component:, pricing_mode:)
-        pricing_mode = Pricing.normalize_mode(pricing_mode)
+        pricing_mode = Pricing::Mode.normalize(pricing_mode)
         match = charge_rate_match(provider: provider, component: component, pricing_mode: pricing_mode)
         return nil unless match
 

data/lib/llm_cost_tracker/pricing.rb

@@ -21,20 +21,10 @@ module LlmCostTracker
   module Pricing # rubocop:disable Metrics/ModuleLength
     extend ServiceCharges
 
-    STANDARD_MODE_VALUES = %i[auto default standard standard_only].freeze
     RATE_DENOMINATOR_TOKENS = 1_000_000
     private_constant :RATE_DENOMINATOR_TOKENS
 
     class << self
-      def normalize_mode(value)
-        return nil if value.nil?
-
-        mode = normalize_string_mode(value.to_s)
-        return nil unless mode
-
-        STANDARD_MODE_VALUES.include?(mode) ? nil : mode
-      end
-
       def cost_for(provider:, model:, tokens:, pricing_mode: nil)
         calculation = calculation_for(
           provider: provider,
@@ -139,13 +129,6 @@ module LlmCostTracker
         )
       end
 
-      def normalize_string_mode(value)
-        normalized = value.strip
-        return nil if normalized.empty?
-
-        normalized.downcase.tr("-", "_").to_sym
-      end
-
       def cost_from(calculation)
         costs = calculation[:costs]
         values = Billing::Components::TOKEN_PRICED.each_with_object({}) do |component, result|
@@ -184,7 +167,7 @@ module LlmCostTracker
 
         token_usage = TokenUsage.build_from_tokens(tokens)
         quantities = token_usage.priced_quantities
-        mode = normalize_mode(pricing_mode)
+        mode = Mode.normalize(pricing_mode)
         effective = EffectivePrices.call(usage: token_usage, quantities: quantities, prices: match.prices,
                                          pricing_mode: mode)
         return nil unless any_billable_priced?(quantities, effective)

data/lib/llm_cost_tracker/providers/anthropic/server_tools.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      module ServerTools
+        LINE_ITEMS = {
+          web_search_request: :web_search_requests,
+          web_fetch_request: :web_fetch_requests,
+          code_execution_request: :code_execution_requests
+        }.freeze
+      end
+    end
+  end
+end