llm_cost_tracker 0.10.0 → 0.12.0

data/lib/llm_cost_tracker/budget.rb

@@ -2,31 +2,25 @@
 
 require "bigdecimal"
 
-require_relative "logging"
 require_relative "ledger"
 require_relative "pricing/estimator"
 
 module LlmCostTracker
-  class Budget
+  module Budget
     BUDGET_TYPE_TO_PERIOD = { monthly: :month, daily: :day }.freeze
 
     class << self
-      def enforce!(provider: nil, model: nil, request: nil)
+      def enforce!(provider: nil, model: nil, request: nil, estimate: nil, force: false)
         config = LlmCostTracker.configuration
-        return unless config.budget_exceeded_behavior == :block_requests
+        return unless config.enabled
+        return unless force || config.budget_exceeded_behavior == :block_requests
 
-        estimate = estimate_cost(provider: provider, model: model, request: request)
+        estimate ||= estimate_cost(provider: provider, model: model, request: request)
         raise_per_call_pre_send(estimate, config.per_call_budget) if config.per_call_budget && estimate.positive?
 
-        budgets = { monthly: config.monthly_budget, daily: config.daily_budget }.compact
-        return if budgets.empty?
-
-        totals = totals_for(budgets.keys, time: Time.now.utc)
-
-        budgets.each do |budget_type, budget|
-          total = totals.fetch(budget_type) + estimate
-          next unless total >= budget
-
+        check_windowed({ monthly: config.monthly_budget, daily: config.daily_budget }.compact,
+                       time: Time.now.utc,
+estimate: estimate) do |budget_type, total, budget|
           raise BudgetExceededError.new(**budget_payload(
             budget_type: budget_type, total: total, budget: budget, last_event: nil, stage: :pre_send
           ))
@@ -38,13 +32,9 @@ module LlmCostTracker
         return unless event.total_cost
 
         check_per_call_budget(event, config)
-        budgets = { daily: config.daily_budget, monthly: config.monthly_budget }.compact
-        totals = totals_for(budgets.keys, time: event.tracked_at)
-
-        budgets.each do |budget_type, budget|
-          total = totals.fetch(budget_type)
-
-          handle_exceeded(budget_type: budget_type, total: total, budget: budget, last_event: event) if total >= budget
+        check_windowed({ daily: config.daily_budget, monthly: config.monthly_budget }.compact,
+                       time: event.tracked_at) do |budget_type, total, budget|
+          handle_exceeded(budget_type: budget_type, total: total, budget: budget, last_event: event)
         end
       end
 
@@ -74,14 +64,22 @@ module LlmCostTracker
         handle_exceeded(budget_type: :per_call, total: total, budget: budget, last_event: event)
       end
 
+      def check_windowed(budgets, time:, estimate: BigDecimal("0"))
+        return if budgets.empty?
+
+        totals = totals_for(budgets.keys, time: time)
+        budgets.each do |budget_type, budget|
+          total = totals.fetch(budget_type) + estimate
+          yield(budget_type, total, budget) if total >= budget
+        end
+      end
+
       def totals_for(budget_types, time:)
         return {} if budget_types.empty?
 
-        periods = budget_types.map { |type| BUDGET_TYPE_TO_PERIOD.fetch(type) }
-        period_totals = LlmCostTracker::Ledger::Period::Totals.call(periods, time: time)
-        BUDGET_TYPE_TO_PERIOD.each_with_object({}) do |(budget_type, period), totals|
-          totals[budget_type] = period_totals[period] if period_totals.key?(period)
-        end
+        period_for = budget_types.to_h { |type| [type, BUDGET_TYPE_TO_PERIOD.fetch(type)] }
+        period_totals = LlmCostTracker::Ledger::Period::Totals.call(period_for.values, time: time)
+        period_for.transform_values { |period| period_totals.fetch(period) }
       end
 
       def handle_exceeded(budget_type:, total:, budget:, last_event: nil)
@@ -112,8 +110,7 @@ module LlmCostTracker
 
       def notify_exceeded?(config, budget_type:, total:, budget:, last_event:)
         return false unless config.on_budget_exceeded
-        return true unless last_event&.total_cost
-        return true if budget_type == :per_call
+        return true if !last_event&.total_cost || budget_type == :per_call
 
         total - last_event.total_cost < budget
       end

data/lib/llm_cost_tracker/capture/sdk_payload.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/object/try"
+
+module LlmCostTracker
+  module Capture
+    module SdkPayload
+      module_function
+
+      def normalize(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, nested), out| out[key.to_s] = normalize(nested) }
+        when Array
+          value.map { |nested| normalize(nested) }
+        when Symbol
+          value.to_s
+        when NilClass
+          nil
+        else
+          converted = container_for(value)
+          converted ? normalize(converted) : value.deep_dup
+        end
+      end
+
+      def container_for(value)
+        value.try(:deep_to_h) || value.try(:to_h)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/{parsers → capture}/sse.rb

@@ -4,9 +4,10 @@ require "active_support/core_ext/object/blank"
 require "json"
 
 module LlmCostTracker
-  module Parsers
+  module Capture
     module SSE
       DONE_MARKER = "[DONE]"
+      LIMIT_BYTES = 1_048_576
 
       class << self
         def parse(body)

data/lib/llm_cost_tracker/capture/stream_collector.rb

@@ -4,8 +4,7 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/object/deep_dup"
 require "json"
 
-require_relative "stream"
-require_relative "../pricing/mode"
+require_relative "sse"
 require_relative "../timing"
 
 module LlmCostTracker
@@ -13,9 +12,17 @@ module LlmCostTracker
     class StreamCollector
       attr_reader :provider
 
-      def initialize(provider:, model:, latency_ms: nil, provider_response_id: nil, provider_project_id: nil,
-                     provider_api_key_id: nil, provider_workspace_id: nil, batch: nil, pricing_mode: nil,
-                     metadata: {}, context_tags: nil, request: nil)
+      def initialize(provider:,
+                     model:,
+                     latency_ms: nil,
+                     provider_response_id: nil,
+                     provider_project_id: nil,
+                     provider_api_key_id: nil,
+                     provider_workspace_id: nil,
+                     pricing_mode: nil,
+                     metadata: {},
+                     context_tags: nil,
+                     request: nil)
         @provider = provider.to_s
         @model = model
         @latency_ms = latency_ms
@@ -23,7 +30,6 @@ module LlmCostTracker
         @provider_project_id = provider_project_id
         @provider_api_key_id = provider_api_key_id
         @provider_workspace_id = provider_workspace_id
-        @batch = batch
         @pricing_mode = pricing_mode
         @metadata = (metadata || {}).deep_dup
         @context_tags = (context_tags || LlmCostTracker::Tags::Context.tags).deep_dup
@@ -38,18 +44,6 @@ module LlmCostTracker
         @mutex = Mutex.new
       end
 
-      def model
-        @mutex.synchronize { @model }
-      end
-
-      def metadata
-        @mutex.synchronize { @metadata.deep_dup }
-      end
-
-      def provider_response_id
-        @mutex.synchronize { @provider_response_id }
-      end
-
       def model=(value)
         @mutex.synchronize do
           ensure_open!
@@ -72,16 +66,20 @@ module LlmCostTracker
       end
 
       def usage(input_tokens:, output_tokens:, **extra)
+        if extra.key?(:batch)
+          raise ArgumentError,
+                "`batch:` is no longer accepted by stream.usage; " \
+                "pass `pricing_mode: :batch` to track_stream"
+        end
+
         @mutex.synchronize do
           ensure_open!
           @provider_response_id = extra.delete(:provider_response_id) || @provider_response_id
           @provider_project_id = extra.delete(:provider_project_id) || @provider_project_id
           @provider_api_key_id = extra.delete(:provider_api_key_id) || @provider_api_key_id
           @provider_workspace_id = extra.delete(:provider_workspace_id) || @provider_workspace_id
-          batch = extra.delete(:batch)
-          @batch = batch unless batch.nil?
-          @explicit_usage = TokenUsage.build(
-            **extra.slice(*TokenUsage.members),
+          @explicit_usage = Usage::TokenUsage.build(
+            **extra.slice(*Usage::TokenUsage.members),
             input_tokens: input_tokens,
             output_tokens: output_tokens
           )
@@ -102,7 +100,7 @@ module LlmCostTracker
           return nil if @finished || @recording
 
           @recording = true
-          pricing_mode = Pricing.normalize_mode(@pricing_mode)
+          pricing_mode = Pricing::Mode.normalize(@pricing_mode)
           {
             events: @events.dup,
             overflowed: @overflowed,
@@ -110,7 +108,7 @@ module LlmCostTracker
             model: @model,
             latency_ms: @latency_ms,
             provider_response_id: @provider_response_id,
-            capture_dimensions: capture_dimensions(pricing_mode),
+            capture_dimensions: capture_dimensions,
             pricing_mode: pricing_mode,
             metadata: @metadata.deep_dup,
             context_tags: @context_tags.deep_dup,
@@ -129,7 +127,7 @@ module LlmCostTracker
           Tracker.record(
             event: event,
             latency_ms: snapshot[:latency_ms] || LlmCostTracker::Timing.elapsed_ms(@started_at),
-            pricing_mode: merge_pricing_modes(event.pricing_mode, snapshot[:pricing_mode]),
+            pricing_mode: Pricing::Mode.merge(event.pricing_mode, snapshot[:pricing_mode]),
             metadata: (errored ? { stream_errored: true } : {}).merge(snapshot[:metadata]),
             context_tags: snapshot[:context_tags]
           ) { save_succeeded = true }
@@ -141,27 +139,11 @@ module LlmCostTracker
         end
       end
 
-      HOST_DERIVED_MODE_TOKENS = %i[data_residency].freeze
-      private_constant :HOST_DERIVED_MODE_TOKENS
-
-      def merge_pricing_modes(provider_mode, request_mode)
-        return Pricing.normalize_mode(request_mode) if provider_mode.to_s.strip.empty?
-
-        provider_tokens = Pricing::Mode.tokenize(provider_mode) - Pricing::STANDARD_MODE_VALUES
-        request_host_tokens = Pricing::Mode.tokenize(request_mode || "") & HOST_DERIVED_MODE_TOKENS
-        combined = provider_tokens | request_host_tokens
-        return nil if combined.empty?
-
-        Pricing.normalize_mode(combined.join("_"))
-      end
-
-      def capture_dimensions(pricing_mode)
-        batch = @batch.nil? ? Event.batch_from_pricing_mode?(pricing_mode).presence : @batch
+      def capture_dimensions
         {
           provider_project_id: @provider_project_id.to_s.strip.presence,
           provider_api_key_id: @provider_api_key_id.to_s.strip.presence,
-          provider_workspace_id: @provider_workspace_id.to_s.strip.presence,
-          batch: batch
+          provider_workspace_id: @provider_workspace_id.to_s.strip.presence
         }.compact
       end
 
@@ -197,12 +179,8 @@ module LlmCostTracker
       end
 
       def present_model(value)
-        return nil if value.nil?
-
         string = value.to_s.presence
-        return nil if string.nil? || string == Event::UNKNOWN_MODEL
-
-        string
+        string unless string == Event::UNKNOWN_MODEL
       end
 
       def build_from_explicit_usage(snapshot)
@@ -211,7 +189,7 @@ module LlmCostTracker
           model: snapshot[:model] || Event::UNKNOWN_MODEL,
           token_usage: snapshot[:explicit_usage],
           stream: true,
-          usage_source: :manual,
+          usage_source: Usage::Source::MANUAL,
           pricing_mode: snapshot[:pricing_mode],
           **snapshot.fetch(:capture_dimensions)
         )
@@ -221,9 +199,9 @@ module LlmCostTracker
         Event.build(
           provider: @provider,
           model: snapshot[:model] || Event::UNKNOWN_MODEL,
-          token_usage: TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
+          token_usage: Usage::TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
           stream: true,
-          usage_source: :unknown,
+          usage_source: Usage::Source::UNKNOWN,
           pricing_mode: snapshot[:pricing_mode],
           **snapshot.fetch(:capture_dimensions)
         )
@@ -238,7 +216,7 @@ module LlmCostTracker
       def capture_event(data, type:)
         event = { event: type, data: strip_heavy_payload(data) }
         size = approximate_bytesize(event)
-        if @captured_bytes + size <= Capture::Stream::LIMIT_BYTES
+        if @captured_bytes + size <= Capture::SSE::LIMIT_BYTES
           @events << event
           @captured_bytes += size
         else

data/lib/llm_cost_tracker/capture/stream_tracker.rb

@@ -3,7 +3,7 @@
 require "active_support/core_ext/object/deep_dup"
 require "active_support/core_ext/object/try"
 
-require_relative "../logging"
+require_relative "sdk_payload"
 
 module LlmCostTracker
   module Capture
@@ -26,13 +26,24 @@ module LlmCostTracker
         if @stream.instance_variable_defined?(:@iterator)
           iterator = @stream.instance_variable_get(:@iterator)
           if iterator.respond_to?(:each)
-            @stream.instance_variable_set(:@iterator, Enumerator.new do |yielder|
-              each_from(iterator) { |event| yielder << event }
-            end)
+            @stream.instance_variable_set(:@iterator,
+                                          Enumerator.new do |yielder|
+                                            each_from(iterator) { |event| yielder << event }
+                                          end)
             iterator_wrapped = true
           end
         end
-        wrap_each if !iterator_wrapped && @stream.respond_to?(:each)
+        each_wrapped = false
+        if !iterator_wrapped && @stream.respond_to?(:each)
+          wrap_each
+          each_wrapped = true
+        end
+        unless iterator_wrapped || each_wrapped
+          Logging.warn(
+            "stream integration found no wrappable iterator on #{@stream.class} " \
+            "(missing both `@iterator` ivar and `#each`); usage will not be captured"
+          )
+        end
 
         register_orphan_finalizer
         @stream
@@ -74,40 +85,14 @@ module LlmCostTracker
       end
 
       def capture(event)
-        raw_payload = event.try(:deep_to_h) || event.try(:to_h)
-        raw_payload ||= %i[type id model usage response message].each_with_object({}) do |key, attributes|
-          value = event.try(key)
-          attributes[key] = value unless value.nil?
-        end
-        payload = normalize(raw_payload)
+        raw_payload = event.try(:deep_to_h) || event.try(:to_h) || {}
+        payload = SdkPayload.normalize(raw_payload)
         type = event.try(:type) || payload["type"]
         @collector.event(payload, type: type&.to_s)
       rescue StandardError => e
         warn_capture_failure(e)
       end
 
-      def normalize(value)
-        case value
-        when Hash
-          value.each_with_object({}) do |(key, nested), normalized|
-            normalized[key.to_s] = normalize(nested)
-          end
-        when Array
-          value.map { |nested| normalize(nested) }
-        when Symbol
-          value.to_s
-        when NilClass
-          nil
-        else
-          converted = begin
-            value.try(:deep_to_h) || value.try(:to_h)
-          rescue StandardError
-            nil
-          end
-          converted ? normalize(converted) : value.deep_dup
-        end
-      end
-
       def warn_capture_failure(error)
         should_warn = @mutex.synchronize do
           next false if @capture_failed

data/lib/llm_cost_tracker/capture_verifier.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "check"
+require_relative "ingestion"
+
+module LlmCostTracker
+  class CaptureVerifier
+    class << self
+      def call
+        new.checks
+      end
+
+      def report(checks = call)
+        (["LLM Cost Tracker capture verification"] + checks.map do |check|
+          "[#{check.status}] #{check.name}: #{check.message}"
+        end).join("\n")
+      end
+
+      def healthy?(checks = call)
+        checks.none? { |check| check.status == :error }
+      end
+    end
+
+    def checks
+      [
+        enabled_check,
+        *integration_checks,
+        *storage_checks
+      ].compact
+    end
+
+    private
+
+    def enabled_check
+      return Check.new(:ok, "tracking", "enabled") if LlmCostTracker.configuration.enabled
+
+      Check.new(:error, "tracking", "disabled; set config.enabled = true before verifying capture")
+    end
+
+    def integration_checks
+      enabled = LlmCostTracker.configuration.instrumented_integrations
+      if enabled.empty?
+        return [
+          Check.new(:ok, "sdk integrations", "none enabled; Faraday middleware and manual capture remain available")
+        ]
+      end
+
+      LlmCostTracker::Integrations.checks.map do |check|
+        check.with(name: "sdk integration #{check.name}")
+      end
+    end
+
+    def storage_checks
+      LlmCostTracker::Ingestion.verify
+    rescue LlmCostTracker::Error => e
+      [Check.new(:error, "storage", e.message)]
+    end
+  end
+end

data/lib/llm_cost_tracker/charges/cost.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module LlmCostTracker
+  module Charges
+    Cost = Data.define(:components, :total, :currency) do
+      def self.from_h(attributes)
+        components = attributes.key?(:components) ? attributes[:components] : attributes.except(:total_cost, :currency)
+        total = attributes.fetch(:total) { attributes[:total_cost] }
+        new(
+          components: components.transform_values { |value| BigDecimal(value.to_s) }.freeze,
+          total: total && BigDecimal(total.to_s),
+          currency: attributes[:currency]
+        )
+      end
+
+      def to_h
+        {
+          components: components.transform_values { |value| value.to_s("F") },
+          total: total&.to_s("F"),
+          currency: currency
+        }
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/{billing → charges}/cost_status.rb

@@ -1,19 +1,29 @@
 # frozen_string_literal: true
 
-require_relative "components"
+require_relative "../usage/source"
 
 module LlmCostTracker
-  module Billing
+  module Charges
     module CostStatus
       COMPLETE = "complete"
       FREE = "free"
       PARTIAL = "partial"
       UNKNOWN = "unknown"
+      INCOMPLETE = [UNKNOWN, PARTIAL].freeze
+
+      def self.unknown_pricing_sql(total_cost: "total_cost", cost_status: "cost_status")
+        statuses = INCOMPLETE.map { |status| ActiveRecord::Base.connection.quote(status) }.join(", ")
+        "#{total_cost} IS NULL OR #{cost_status} IN (#{statuses})"
+      end
 
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def self.call(token_usage:, usage_source:, token_cost:, service_line_items:, total_cost:,
+      def self.call(token_usage:,
+                    usage_source:,
+                    token_cost:,
+                    service_line_items:,
+                    total_cost:,
                     token_pricing_partial: false)
-        return UNKNOWN if usage_source == :unknown
+        return UNKNOWN if usage_source == Usage::Source::UNKNOWN
 
         token_billable = token_usage.priced_quantities.any? { |_key, quantity| quantity.positive? }
         service_billable = false

data/lib/llm_cost_tracker/{billing → charges}/line_item.rb

@@ -2,11 +2,12 @@
 
 require "bigdecimal"
 
-require_relative "components"
+require_relative "../currency"
+require_relative "../usage/catalog"
 require_relative "cost_status"
 
 module LlmCostTracker
-  module Billing
+  module Charges
     LineItem = Data.define(
       :kind,
       :direction,
@@ -29,26 +30,24 @@ module LlmCostTracker
     )
 
     class LineItem
-      USD = "USD"
-
       def self.build(attributes)
         attributes = attributes.to_h
-        component = component_for(attributes)
+        dimension = dimension_for(attributes)
         new(
-          kind: symbol_or_nil(attributes[:kind]) || component&.kind,
-          direction: symbol_or_nil(attributes[:direction]) || component&.direction,
-          modality: symbol_or_nil(attributes[:modality]) || component&.modality,
-          cache_state: symbol_or_nil(attributes[:cache_state]) || component&.cache_state,
-          quantity: decimal_or_zero(attributes[:quantity]),
-          unit: symbol_or_nil(attributes[:unit]) || component&.unit,
+          kind: attributes[:kind]&.to_s || dimension&.kind,
+          direction: attributes[:direction]&.to_s || dimension&.direction,
+          modality: attributes[:modality]&.to_s || dimension&.modality,
+          cache_state: attributes[:cache_state]&.to_s || dimension&.cache_state || "none",
+          quantity: decimal_or_nil(attributes[:quantity]) || BigDecimal("0"),
+          unit: attributes[:unit]&.to_s || dimension&.unit,
           rate_amount: decimal_or_nil(attributes[:rate_amount]),
           rate_quantity: decimal_or_nil(attributes[:rate_quantity]) || BigDecimal("1"),
           cost: decimal_or_nil(attributes[:cost]),
-          currency: attributes[:currency] || USD,
+          currency: canonical_currency(attributes[:currency]),
           cost_status: cost_status_for(attributes),
-          pricing_basis: symbol_or_nil(attributes[:pricing_basis]),
-          price_key: attributes[:price_key],
-          price_source: symbol_or_nil(attributes[:price_source]),
+          pricing_basis: attributes[:pricing_basis]&.to_s,
+          price_key: attributes[:price_key]&.to_s,
+          price_source: attributes[:price_source]&.to_s,
           price_source_version: attributes[:price_source_version],
           provider_field: attributes[:provider_field],
           provider_item_id: attributes[:provider_item_id],
@@ -62,14 +61,14 @@ module LlmCostTracker
         token_usage.priced_quantities.filter_map do |key, quantity|
           next unless quantity.positive?
 
-          component = Components::BY_KEY.fetch(key)
+          dimension = Usage::Catalog.fetch(key)
           build(
-            kind: component.kind,
-            direction: component.direction,
-            modality: component.modality,
-            cache_state: component.cache_state,
+            kind: dimension.kind,
+            direction: dimension.direction,
+            modality: dimension.modality,
+            cache_state: dimension.cache_state,
             quantity: quantity,
-            unit: component.unit
+            unit: dimension.unit
           )
         end
       end
@@ -84,17 +83,11 @@ module LlmCostTracker
         cost.zero? ? CostStatus::FREE : CostStatus::COMPLETE
       end
 
-      def self.component_for(attributes)
-        component_key = attributes[:component_key] || attributes[:price_key]
-        return nil unless component_key
-
-        Components::BY_KEY[component_key.to_sym]
-      end
-
-      def self.symbol_or_nil(value)
-        return nil if value.nil?
+      def self.dimension_for(attributes)
+        dimension_key = attributes[:dimension_key] || attributes[:price_key]
+        return nil unless dimension_key
 
-        value.to_s.to_sym
+        Usage::Catalog[dimension_key.to_s]
       end
 
       def self.decimal_or_nil(value)
@@ -103,11 +96,11 @@ module LlmCostTracker
         BigDecimal(value.to_s)
       end
 
-      def self.decimal_or_zero(value)
-        decimal_or_nil(value) || BigDecimal("0")
+      def self.canonical_currency(value)
+        (value || LlmCostTracker::DEFAULT_CURRENCY).to_s.upcase
       end
 
-      private_class_method :cost_status_for, :component_for, :symbol_or_nil, :decimal_or_nil, :decimal_or_zero
+      private_class_method :cost_status_for, :dimension_for, :decimal_or_nil, :canonical_currency
 
       def billable?
         quantity.positive?
@@ -122,7 +115,12 @@ module LlmCostTracker
       end
 
       def token?
-        unit == :token
+        unit == "token"
+      end
+
+      def dimension
+        Usage::Catalog[price_key] ||
+          Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
       end
 
       def cost_value
@@ -130,18 +128,16 @@ module LlmCostTracker
       end
 
       def with_rate(rate)
-        rate_amount = rate.fetch(:amount)
-        rate_quantity = rate.fetch(:quantity)
-        applied_cost = (quantity / rate_quantity) * rate_amount
+        applied_cost = (quantity / rate.quantity) * rate.amount
         with(
-          rate_amount: rate_amount,
-          rate_quantity: rate_quantity,
+          rate_amount: rate.amount,
+          rate_quantity: rate.quantity,
           cost: applied_cost,
-          currency: rate.fetch(:currency),
+          currency: rate.currency.upcase,
           cost_status: applied_cost.zero? ? CostStatus::FREE : CostStatus::COMPLETE,
-          price_key: rate.fetch(:source_key),
-          price_source: rate.fetch(:source),
-          price_source_version: rate.fetch(:source_version)
+          price_key: rate.source_key,
+          price_source: rate.source,
+          price_source_version: rate.source_version
         )
       end
 

data/lib/llm_cost_tracker/check.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  Check = Data.define(:status, :name, :message)
+end