llm_cost_tracker 0.9.0 → 0.11.0

data/lib/llm_cost_tracker/integrations/openai.rb

@@ -2,7 +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
@@ -24,22 +26,35 @@ module LlmCostTracker
 
         def stream_collector(request, host: nil)
           LlmCostTracker::Capture::StreamCollector.new(
-            provider: integration_name.to_s,
+            provider: provider_for_host(host),
             model: request[:model],
             pricing_mode: stream_pricing_mode(request, host: host),
             request: request
           )
         end
 
+        def wrap_stream_call(args, kwargs, resource)
+          request = request_params(args, kwargs)
+          enforce_budget!(request: request)
+          host = client_host_for(resource)
+          collector = stream_collector(request, host: host)
+          stream = yield(normalize_sdk_args(args, kwargs), collector)
+          track_stream(stream, collector: collector)
+        end
+
         def client_host_for(resource)
           client = resource.instance_variable_get(:@client)
-          return nil unless client.respond_to?(:base_url, true)
+          return nil unless client
 
-          URI.parse(client.send(:base_url).to_s).host
+          URI.parse(client.base_url.to_s).host
         rescue URI::InvalidURIError
           nil
         end
 
+        def provider_for_host(host)
+          LlmCostTracker::Providers::Azure::Hosts.openai?(host) ? "azure_openai" : "openai"
+        end
+
         def minimum_version
           "0.59.0"
         end
@@ -97,8 +112,8 @@ module LlmCostTracker
             cache_read = cache_read_input_tokens(usage)
             model = object_value(response, :model) || request[:model]
             LlmCostTracker::Tracker.record(
-              capture: UsageCapture.build(
-                provider: "openai",
+              event: Event.build(
+                provider: provider_for_host(host),
                 model: model,
                 pricing_mode: LlmCostTracker::Parsers::OpenaiUsage.combined_pricing_mode(
                   host: host,
@@ -115,7 +130,7 @@ module LlmCostTracker
           end
         end
 
-        def record_image(response, request:, latency_ms:)
+        def record_image(response, request:, latency_ms:, host: nil)
           usage = object_value(response, :usage)
           raw_input = usage ? object_value(usage, :input_tokens).to_i : 0
           raw_output = usage ? object_value(usage, :output_tokens).to_i : 0
@@ -127,6 +142,7 @@ module LlmCostTracker
             model: request[:model],
             response: response,
             latency_ms: latency_ms,
+            host: host,
             input_tokens: text_input,
             image_input_tokens: image_input,
             output_tokens: text_output,
@@ -144,11 +160,12 @@ module LlmCostTracker
           [image_tokens, text_tokens]
         end
 
-        def record_transcription(response, request:, latency_ms:)
+        def record_transcription(response, request:, latency_ms:, host: nil)
           record_passthrough(
             model: request[:model],
             response: response,
             latency_ms: latency_ms,
+            host: host,
             **transcription_token_attributes(object_value(response, :usage))
           )
         end
@@ -165,24 +182,22 @@ module LlmCostTracker
           }
         end
 
-        def record_speech(_response, request:, latency_ms:)
+        def record_speech(_response, request:, latency_ms:, host: nil)
           record_passthrough(
             model: request[:model],
             response: nil,
             latency_ms: latency_ms,
+            host: host,
             input_tokens: 0,
             output_tokens: 0,
             service_line_items: speech_line_items(request)
           )
         end
 
-        CHARACTER_BILLED_TTS_MODELS = /\Atts-1(-hd)?\z/
-        private_constant :CHARACTER_BILLED_TTS_MODELS
-
         def speech_line_items(request)
           input = request[:input]
           return [] unless input.is_a?(String)
-          return [] unless CHARACTER_BILLED_TTS_MODELS.match?(request[:model].to_s)
+          return [] unless LlmCostTracker::Providers::Openai::ModelFamilies.character_billed_tts?(request[:model])
 
           [LlmCostTracker::Billing::LineItem.build(
             component_key: :text_to_speech_character,
@@ -193,23 +208,24 @@ module LlmCostTracker
           )]
         end
 
-        def record_moderation(response, request:, latency_ms:)
+        def record_moderation(response, request:, latency_ms:, host: nil)
           record_passthrough(
             model: object_value(response, :model) || request[:model],
             response: response,
             latency_ms: latency_ms,
+            host: host,
             input_tokens: 0,
             output_tokens: 0
           )
         end
 
-        def record_passthrough(model:, response:, latency_ms:, service_line_items: [], **token_attributes)
+        def record_passthrough(model:, response:, latency_ms:, host: nil, service_line_items: [], **token_attributes)
           return unless active?
 
           record_safely do
             LlmCostTracker::Tracker.record(
-              capture: UsageCapture.build(
-                provider: "openai",
+              event: Event.build(
+                provider: provider_for_host(host),
                 model: model,
                 token_usage: TokenUsage.build(**token_attributes),
                 usage_source: :sdk_response,
@@ -222,16 +238,41 @@ module LlmCostTracker
         end
 
         def service_line_items_from(response, request: nil)
+          model = object_value(response, :model) || request&.dig(:model)
           output = object_value(response, :output)
-          return [] unless output.respond_to?(:each)
+          output_items = output.respond_to?(:each) ? output.map { |item| normalize_output_item(item) }.compact : []
+          chat_search = output_items.empty? ? chat_completions_search_item(response, model: model) : nil
+          output_items << chat_search if chat_search
+          return [] if output_items.empty?
 
-          LlmCostTracker::Parsers::OpenaiServiceCharges.line_items_from_output(
-            output.map { |item| normalize_output_item(item) },
-            request: request,
-            model: object_value(response, :model) || request&.dig(:model)
+          LlmCostTracker::Providers::Openai::ServiceCharges.line_items_from_output(
+            output_items, request: request, model: model
           )
         end
 
+        def chat_completions_search_item(response, model: nil)
+          choices = object_value(response, :choices)
+          return nil unless choices.respond_to?(:any?)
+
+          provider_field = if choices.any? { |choice| choice_used_url_citation?(choice) }
+                             LlmCostTracker::Providers::Openai::ServiceCharges::CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD
+                           elsif LlmCostTracker::Providers::Openai::ModelFamilies.chat_completions_search?(model)
+                             LlmCostTracker::Providers::Openai::ServiceCharges::CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD
+                           end
+          return nil unless provider_field
+
+          { "type" => "web_search_call", "id" => object_value(response, :id),
+            "action" => { "type" => "search" }, "provider_field" => provider_field }
+        end
+
+        def choice_used_url_citation?(choice)
+          message = object_value(choice, :message)
+          annotations = message && object_value(message, :annotations)
+          return false unless annotations.respond_to?(:any?)
+
+          annotations.any? { |annotation| object_value(annotation, :type).to_s == "url_citation" }
+        end
+
         def normalize_output_item(item)
           return item if item.is_a?(Hash)
           return nil if item.nil?
@@ -252,9 +293,6 @@ module LlmCostTracker
           { "type" => object_value(action, :type)&.to_s }
         end
 
-        IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
-        private_constant :IMAGE_OUTPUT_MODEL_PATTERN
-
         def token_usage(usage:, input_tokens:, output_tokens:, cache_read:, model: nil)
           audio_input = audio_input_tokens(usage)
           audio_output = audio_output_tokens(usage)
@@ -266,7 +304,7 @@ module LlmCostTracker
             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(
@@ -317,137 +355,72 @@ module LlmCostTracker
         end
       end
 
-      module ResponsesPatch
-        def create(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.record_response(
-            response,
-            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
-            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at),
-            host: LlmCostTracker::Integrations::Openai.client_host_for(self)
-          )
-          response
-        end
-
-        def stream(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          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
-
-        def stream_raw(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          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
-
-        def retrieve_streaming(response_id, *args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          host = LlmCostTracker::Integrations::Openai.client_host_for(self)
-          collector = LlmCostTracker::Integrations::Openai.stream_collector(request, host: host)
-          collector.provider_response_id = response_id
-          stream = super(response_id, *LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.track_stream(stream, collector: collector)
-        end
-      end
-
-      module ChatCompletionsPatch
-        def create(*args, **kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super(*LlmCostTracker::Integrations::Openai.normalize_sdk_args(args, kwargs))
-          LlmCostTracker::Integrations::Openai.record_response(
-            response,
-            request: LlmCostTracker::Integrations::Openai.request_params(args, kwargs),
-            latency_ms: LlmCostTracker::Integrations::Openai.elapsed_ms(started_at),
-            host: LlmCostTracker::Integrations::Openai.client_host_for(self)
-          )
-          response
-        end
-
-        def stream(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          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
-
-        def stream_raw(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Openai.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Openai.enforce_budget!
-          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
-      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 build_stream(methods:)
+          Module.new.tap do |mod|
+            methods.each { |method_name| define_stream_method(mod, method_name) }
           end
         end
 
-        def define_wrapped_method(mod, method_name, record_method)
+        def define_blocking_method(mod, method_name, record_method)
           mod.define_method(method_name) do |*args, **kwargs, &block|
             integration = LlmCostTracker::Integrations::Openai
-            integration.enforce_budget!
+            request = integration.request_params(args, kwargs)
+            integration.enforce_budget!(request: request)
             started_at = LlmCostTracker::Timing.now_monotonic
             response = super(*integration.normalize_sdk_args(args, kwargs), &block)
             integration.public_send(
               record_method, response,
-              request: integration.request_params(args, kwargs),
-              latency_ms: integration.elapsed_ms(started_at)
+              request: request,
+              latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
+              host: integration.client_host_for(self)
             )
             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!
-            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!
-          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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../providers/anthropic/tier_classification"
 
 module LlmCostTracker
   module Integrations
@@ -30,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),
@@ -111,7 +108,7 @@ module LlmCostTracker
 
           record_safely do
             LlmCostTracker::Tracker.record(
-              capture: UsageCapture.build(
+              event: Event.build(
                 provider: provider,
                 model: model,
                 token_usage: TokenUsage.build(
@@ -140,7 +137,7 @@ module LlmCostTracker
             hidden_output = object_value(response, :thinking_tokens, :reasoning_tokens).to_i
 
             LlmCostTracker::Tracker.record(
-              capture: UsageCapture.build(
+              event: Event.build(
                 provider: provider,
                 model: model,
                 pricing_mode: pricing_mode(provider: provider, response: response),
@@ -182,17 +179,14 @@ module LlmCostTracker
         end
 
         def provider_response_id(response)
-          object_value(response, :id, :provider_response_id) || object_dig(response, :raw, :id)
+          object_value(response, :id, :provider_response_id)
         end
 
-        ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS = %w[standard standard_only priority].freeze
-        private_constant :ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS
-
         def pricing_mode(provider:, response:)
-          raw = object_value(response, :pricing_mode, :service_tier) ||
-                object_dig(response, :raw, :pricing_mode) ||
-                object_dig(response, :raw, :service_tier)
-          return nil if provider == "anthropic" && ANTHROPIC_STANDARD_EQUIVALENT_SERVICE_TIERS.include?(raw.to_s)
+          raw = object_value(response, :pricing_mode, :service_tier)
+          if provider == "anthropic" && LlmCostTracker::Providers::Anthropic::TierClassification.standard_equivalent_tier?(raw)
+            return nil
+          end
 
           raw
         end
@@ -200,77 +194,37 @@ module LlmCostTracker
 
       module ProviderPatch
         def complete(*args, **kwargs, &)
-          integration = LlmCostTracker::Integrations::RubyLlm
-          request = integration.request_params(args, kwargs)
-          integration.enforce_budget!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_completion(
-            self,
-            response,
-            request: request,
-            latency_ms: integration.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!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_embedding(
-            self,
-            response,
-            request: request,
-            latency_ms: integration.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!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_transcription(
-            self,
-            response,
-            request: request,
-            latency_ms: integration.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!
-          started_at = LlmCostTracker::Timing.now_monotonic
-          response = super
-          integration.record_image(
-            self,
-            response,
-            request: request,
-            latency_ms: integration.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!
+          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: integration.elapsed_ms(started_at)
+            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at),
+            **extras
           )
           response
         end

data/lib/llm_cost_tracker/integrations.rb

@@ -2,19 +2,17 @@
 
 require_relative "errors"
 require_relative "logging"
-require_relative "integrations/openai"
-require_relative "integrations/anthropic"
-require_relative "integrations/ruby_llm"
 
 module LlmCostTracker
   module Integrations
-    AVAILABLE = {
-      openai: Openai,
-      anthropic: Anthropic,
-      ruby_llm: RubyLlm
-    }.freeze
+    autoload :Base, "llm_cost_tracker/integrations/base"
+    autoload :Openai, "llm_cost_tracker/integrations/openai"
+    autoload :Anthropic, "llm_cost_tracker/integrations/anthropic"
+    autoload :RubyLlm, "llm_cost_tracker/integrations/ruby_llm"
 
+    INTEGRATION_CONSTANTS = { openai: :Openai, anthropic: :Anthropic, ruby_llm: :RubyLlm }.freeze
     DOUBLE_INSTRUMENTATION_OVERLAPS = %i[openai anthropic].freeze
+    private_constant :DOUBLE_INSTRUMENTATION_OVERLAPS
 
     module_function
 
@@ -25,7 +23,7 @@ module LlmCostTracker
     end
 
     def checks(names = LlmCostTracker.configuration.instrumented_integrations)
-      return [Base::Result.new(:integrations, :ok, "no SDK integrations enabled")] if names.empty?
+      return [Base::Result.new(:ok, "integrations", "no SDK integrations enabled")] if names.empty?
 
       normalize(names).map { |name| fetch(name).status }
     end
@@ -48,14 +46,17 @@ module LlmCostTracker
     end
 
     def fetch(name)
-      AVAILABLE.fetch(name) do
-        message = "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
-        raise LlmCostTracker::Error, message
+      const_name = INTEGRATION_CONSTANTS[name.to_sym]
+      unless const_name
+        raise LlmCostTracker::Error,
+              "Unknown integration: #{name.inspect}. Use one of: #{names.join(', ')}"
       end
+
+      const_get(const_name)
     end
 
     def names
-      AVAILABLE.keys
+      INTEGRATION_CONSTANTS.keys
     end
   end
 end

data/lib/llm_cost_tracker/ledger/period/totals.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 require_relative "../period"
 
 module LlmCostTracker
@@ -26,12 +28,12 @@ module LlmCostTracker
         attr_reader :periods, :time
 
         def snapshot_totals
-          values = periods.to_h { |period| [period, 0.0] }
+          values = periods.to_h { |period| [period, BigDecimal("0")] }
           period_by_name = periods.to_h { |period| [period.name, period] }
           sql = periods.map { |period| snapshot_select(period) }.join(" UNION ALL ")
           LlmCostTracker::Call.find_by_sql(sql).each do |row|
             period = period_by_name.fetch(row.period_key)
-            values[period] = row.total_cost.to_f
+            values[period] = BigDecimal(row.total_cost.to_s)
           end
           values
         end
@@ -39,7 +41,7 @@ module LlmCostTracker
         def snapshot_select(period)
           start = Period.range_start(period, time)
           components = [period_total_sql(period, start)]
-          components << pending_total_sql(start) if Ingestion.durable?
+          components << pending_total_sql(start) if Ingestion.async?
           "SELECT #{connection.quote(period.name)} AS period_key, " \
             "(#{components.join(') + (')}) AS total_cost"
         end