llm_cost_tracker 0.10.0 → 0.12.0

data/lib/llm_cost_tracker/configuration.rb

@@ -17,7 +17,7 @@ module LlmCostTracker
     INGESTION_MODES = %i[inline async].freeze
     SCALAR_ATTRIBUTES = %i[enabled default_tags on_budget_exceeded monthly_budget daily_budget per_call_budget
                            log_level prices_file max_tag_count max_tag_value_bytesize
-                           ingestion_pool_size].freeze
+                           ingestion_pool_size auto_enable_stream_usage cache_rollups].freeze
     ENUM_ATTRIBUTES = {
       budget_exceeded_behavior: [BUDGET_EXCEEDED_BEHAVIORS, :notify],
       unknown_pricing_behavior: [UNKNOWN_PRICING_BEHAVIORS, :warn],
@@ -34,11 +34,7 @@ module LlmCostTracker
       :report_tag_breakdowns,
       :redacted_tag_keys,
       :unknown_pricing_behavior,
-      :openai_compatible_providers,
-      :reconciliation_importers,
-      :reconciliation_enabled,
-      :auto_enable_stream_usage,
-      :cache_rollups
+      :openai_compatible_providers
     )
 
     def initialize
@@ -60,51 +56,12 @@ module LlmCostTracker
       @report_tag_breakdowns = []
       @redacted_tag_keys = DEFAULT_REDACTED_TAG_KEYS.dup
       self.openai_compatible_providers = OPENAI_COMPATIBLE_PROVIDERS
-      @reconciliation_importers = {}
-      @reconciliation_enabled = false
       @auto_enable_stream_usage = true
       self.ingestion = :inline
       @cache_rollups = false
       @finalized = false
     end
 
-    def cache_rollups=(value)
-      ensure_mutable!
-      @cache_rollups = value
-    end
-
-    def reconciliation_enabled=(value)
-      ensure_mutable!
-      @reconciliation_enabled = value
-    end
-
-    def auto_enable_stream_usage=(value)
-      ensure_mutable!
-      @auto_enable_stream_usage = value
-    end
-
-    def reconciliation_importers=(importers)
-      ensure_mutable!
-      raise Error, RECONCILIATION_DISABLED_MESSAGE unless @reconciliation_enabled
-
-      @reconciliation_importers = (importers || {}).to_h do |source, importer|
-        raise Error, "reconciliation_importers[#{source}] must respond to call" unless importer.respond_to?(:call)
-
-        [source.to_sym, importer]
-      end
-    end
-
-    def register_reconciliation_importer(source, &block)
-      ensure_mutable!
-      raise Error, RECONCILIATION_DISABLED_MESSAGE unless @reconciliation_enabled
-      raise Error, "register_reconciliation_importer requires a block" unless block
-
-      @reconciliation_importers[source.to_sym] = block
-    end
-
-    RECONCILIATION_DISABLED_MESSAGE = "reconciliation is disabled; set config.reconciliation_enabled = true first"
-    private_constant :RECONCILIATION_DISABLED_MESSAGE
-
     def openai_compatible_providers=(providers)
       ensure_mutable!
       @openai_compatible_providers = normalize_openai_compatible_providers(providers)
@@ -112,8 +69,8 @@ module LlmCostTracker
 
     def pricing_overrides=(value)
       ensure_mutable!
-      @pricing_overrides = Pricing::Registry.normalize_price_table(value || {})
-    rescue ArgumentError => e
+      @pricing_overrides = Pricing::Registry.normalize_price_entries(value || {}, context: "pricing_overrides")
+    rescue ArgumentError, TypeError => e
       raise Error, "invalid pricing_overrides: #{e.message}"
     end
 
@@ -129,7 +86,9 @@ module LlmCostTracker
 
     def instrument(*names)
       ensure_mutable!
-      @instrumented_integrations.merge(normalize_instrumentation_names(names))
+      names = names.flatten
+      names = Integrations.names if names == [:all]
+      @instrumented_integrations.merge(names)
     end
 
     def instrumented?(name)
@@ -167,6 +126,12 @@ module LlmCostTracker
         Array(@redacted_tag_keys).map { |key| Tags::Sanitizer.normalized_key(key) }.freeze
     end
 
+    def static_sanitized_default_tags
+      return nil if @default_tags.respond_to?(:call)
+
+      @static_sanitized_default_tags ||= Tags::Sanitizer.call((@default_tags || {}).to_h).freeze
+    end
+
     def finalized?
       @finalized
     end
@@ -186,19 +151,6 @@ module LlmCostTracker
       end
     end
 
-    def normalize_instrumentation_names(names)
-      names = names.flatten
-      integrations = Integrations.names
-      return integrations if names == [:all]
-
-      names.each do |name|
-        next if integrations.include?(name)
-
-        raise Error, "Unknown integration: #{name.inspect}. Use one of: #{integrations.join(', ')}"
-      end
-      names
-    end
-
     def ensure_mutable!
       return unless finalized?
 

data/lib/llm_cost_tracker/currency.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  DEFAULT_CURRENCY = "USD"
+end

data/lib/llm_cost_tracker/doctor/ingestion_check.rb

@@ -1,39 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "check"
+require_relative "../check"
 require_relative "probe"
 require_relative "../ingestion"
 
 module LlmCostTracker
   class Doctor
     class IngestionCheck
-      PENDING_AGE_WARNING_SECONDS = 60
-
       def call
         return unless Probe.table_exists?("llm_cost_tracker_calls")
         return inline_check unless LlmCostTracker::Ingestion.async?
 
         missing = missing_parts
-        if missing.empty?
-          inbox = inbox_snapshot
-          quarantined = inbox.try(:quarantined_count).to_i
-          if quarantined.positive?
-            return Check.new(:warn, "async ingestion", "#{quarantined} inbox entries quarantined after retries")
-          end
-
-          pending_count = inbox.try(:pending_count).to_i
-          oldest_pending_at = inbox.try(:oldest_pending_at)&.to_time&.utc
-          pending_age = oldest_pending_at && (Time.now.utc - oldest_pending_at)
-          if pending_count.positive? && pending_age && pending_age >= PENDING_AGE_WARNING_SECONDS
-            return Check.new(
-              :warn,
-              "async ingestion",
-              "#{pending_count} inbox entries pending; oldest pending age #{pending_age.round}s"
-            )
-          end
-
-          return Check.new(:ok, "async ingestion", "inbox and ingestion lease tables available")
-        end
+        return async_ok if missing.empty?
 
         Check.new(
           :error,
@@ -44,14 +23,16 @@ module LlmCostTracker
 
       private
 
+      def async_ok
+        Check.new(:ok, "async ingestion", "inbox and ingestion lease tables available")
+      end
+
       def inline_check
         leftovers = inline_leftover_tables
         if leftovers.empty?
-          return Check.new(
-            :ok,
-            "inline ingestion",
-            "config.ingestion = :inline; events write directly to the ledger"
-          )
+          return Check.new(:ok,
+                           "inline ingestion",
+                           "config.ingestion = :inline; events write directly to the ledger")
         end
 
         Check.new(
@@ -63,33 +44,18 @@ module LlmCostTracker
       end
 
       def inline_leftover_tables
-        [
-          LlmCostTracker::Ingestion::InboxEntry.table_name,
-          LlmCostTracker::Ingestion::Lease.table_name
-        ].select { |table| Probe.table_exists?(table) }
+        async_tables.select { |table| Probe.table_exists?(table) }
       end
 
       def missing_parts
+        async_tables.reject { |table| Probe.table_exists?(table) }
+      end
+
+      def async_tables
         [
           LlmCostTracker::Ingestion::InboxEntry.table_name,
           LlmCostTracker::Ingestion::Lease.table_name
-        ].reject { |table| Probe.table_exists?(table) }
-      end
-
-      def inbox_snapshot
-        max_attempts = LlmCostTracker::Ingestion::InboxEntry::MAX_ATTEMPTS_BEFORE_QUARANTINE
-        LlmCostTracker::Ingestion::InboxEntry
-          .select(
-            "COALESCE(SUM(CASE WHEN attempts >= #{max_attempts} " \
-            "THEN 1 ELSE 0 END), 0) AS quarantined_count, " \
-            "COALESCE(SUM(CASE WHEN attempts < #{max_attempts} " \
-            "THEN 1 ELSE 0 END), 0) AS pending_count, " \
-            "MIN(CASE WHEN attempts < #{max_attempts} " \
-            "THEN created_at ELSE NULL END) AS oldest_pending_at"
-          )
-          .take
-      rescue StandardError
-        nil
+        ]
       end
     end
   end

data/lib/llm_cost_tracker/doctor/price_check.rb

@@ -2,7 +2,7 @@
 
 require "date"
 
-require_relative "check"
+require_relative "../check"
 
 module LlmCostTracker
   class Doctor

data/lib/llm_cost_tracker/doctor/probe.rb

@@ -5,11 +5,10 @@ require_relative "../ledger"
 module LlmCostTracker
   class Doctor
     module Probe
-      module_function
-
-      def table_exists?(name)
+      def self.table_exists?(name)
         LlmCostTracker::Call.connection.data_source_exists?(name)
-      rescue StandardError
+      rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::NoDatabaseError,
+             ActiveRecord::ConnectionFailed, ActiveRecord::StatementInvalid
         false
       end
     end

data/lib/llm_cost_tracker/doctor/schema_check.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-require_relative "check"
+require_relative "../check"
 require_relative "probe"
 require_relative "../ledger"
 
 module LlmCostTracker
   class Doctor
     class SchemaCheck
-      def initialize(name:, schema:, table:, optional: false, install_command: "llm_cost_tracker:install")
+      def initialize(name:, schema:, table:)
         @name = name
         @schema = schema
         @table = table
-        @optional = optional
-        @install_command = install_command
       end
 
       def call
         return unless Probe.table_exists?("llm_cost_tracker_calls")
-        return if @optional && !Probe.table_exists?(@table)
 
         errors = @schema.current_schema_errors
         return Check.new(:ok, @name, "#{@table} exists") if errors.empty?
@@ -26,7 +23,7 @@ module LlmCostTracker
           :error,
           @name,
           "current schema required; #{errors.join('; ')}; " \
-          "run bin/rails generate #{@install_command} && bin/rails db:migrate"
+          "run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
         )
       end
     end

data/lib/llm_cost_tracker/doctor.rb

@@ -1,35 +1,83 @@
 # frozen_string_literal: true
 
 require_relative "ledger"
-require_relative "doctor/check"
+require_relative "check"
 require_relative "doctor/probe"
 require_relative "doctor/ingestion_check"
-require_relative "doctor/legacy_audit_check"
-require_relative "doctor/legacy_billing_status_check"
 require_relative "doctor/price_check"
 require_relative "doctor/schema_check"
-require_relative "doctor/cost_drift_check"
-require_relative "doctor/pricing_snapshot_drift_check"
 
 module LlmCostTracker
   class Doctor
-    autoload :InvoiceReconciliationCheck, "llm_cost_tracker/doctor/invoice_reconciliation_check"
-    autoload :CaptureVerifier,            "llm_cost_tracker/doctor/capture_verifier"
+    STATUS_GLYPHS = { ok: "✓", warn: "!", error: "x" }.freeze
+    STATUS_COLORS = { ok: 32, warn: 33, error: 31 }.freeze
+
+    SECTIONS = %w[Setup Schema Operations].freeze
+
+    SECTION_FOR_CHECK = {
+      "configuration" => "Setup",
+      "capture" => "Setup",
+      "active_record" => "Schema",
+      "llm_cost_tracker_calls" => "Schema",
+      "llm_cost_tracker_calls columns" => "Schema",
+      "call line items" => "Schema",
+      "call tags" => "Schema",
+      "call rollups" => "Operations",
+      "inline ingestion" => "Operations",
+      "async ingestion" => "Operations",
+      "prices" => "Operations",
+      "tracked calls" => "Operations"
+    }.freeze
+
+    private_constant :STATUS_GLYPHS, :STATUS_COLORS, :SECTIONS, :SECTION_FOR_CHECK
 
     class << self
       def call
         new.checks
       end
 
-      def report(checks = call)
-        (["LLM Cost Tracker doctor"] + checks.map do |check|
-          "[#{check.status}] #{check.name}: #{check.message}"
-        end).join("\n")
+      def report(checks = call, color: $stdout.tty?)
+        name_width = checks.map { |c| c.name.length }.max.to_i
+
+        lines = [bold("LLM Cost Tracker doctor", color), ""]
+        each_section(checks) do |section, members|
+          lines << bold(section, color)
+          members.each do |check|
+            status = paint_status("[#{STATUS_GLYPHS.fetch(check.status, check.status)}]", check.status, color)
+            lines << "  #{status} #{"#{check.name}:".ljust(name_width + 1)} #{check.message}"
+          end
+          lines << ""
+        end
+        lines.pop if lines.last == ""
+        lines.join("\n")
       end
 
       def healthy?(checks = call)
         checks.none? { |check| check.status == :error }
       end
+
+      private
+
+      def each_section(checks)
+        SECTIONS.each do |section|
+          members = checks.select { |c| (SECTION_FOR_CHECK[c.name] || "Setup") == section }
+          next if members.empty?
+
+          yield section, members
+        end
+      end
+
+      def paint_status(text, status, color)
+        return text unless color && STATUS_COLORS.key?(status)
+
+        "\e[#{STATUS_COLORS[status]}m#{text}\e[0m"
+      end
+
+      def bold(text, color)
+        return text unless color
+
+        "\e[1m#{text}\e[0m"
+      end
     end
 
     def checks
@@ -40,16 +88,7 @@ module LlmCostTracker
         active_record_check,
         table_check,
         column_check,
-        SchemaCheck.new(name: "call line items", schema: Ledger::Schema::CallLineItems,
-                        table: "llm_cost_tracker_call_line_items").call,
-        SchemaCheck.new(name: "call tags", schema: Ledger::Schema::CallTags,
-                        table: "llm_cost_tracker_call_tags").call,
-        *reconciliation_schema_checks,
-        CostDriftCheck.new.call,
-        PricingSnapshotDriftCheck.new.call,
-        *reconciliation_invoice_check,
-        LegacyBillingStatusCheck.new.call,
-        LegacyAuditCheck.new.call,
+        *dependent_core_schema_checks,
         call_rollups_check,
         IngestionCheck.new.call,
         PriceCheck.new.call,
@@ -59,20 +98,12 @@ module LlmCostTracker
 
     private
 
-    def reconciliation_schema_checks
-      return [] unless LlmCostTracker.reconciliation_enabled?
-
-      Reconciliation::SCHEMA_TABLES.map do |schema, table|
+    def dependent_core_schema_checks
+      Ledger::Schema::CORE_SCHEMAS.reject { |schema, _| schema == Ledger::Schema::Calls }.map do |schema, table|
         SchemaCheck.new(name: table.delete_prefix("llm_cost_tracker_").tr("_", " "),
-                        schema: schema, table: table,
-                        optional: false, install_command: "llm_cost_tracker:reconciliation").call
-      end.compact
-    end
-
-    def reconciliation_invoice_check
-      return [] unless LlmCostTracker.reconciliation_enabled?
-
-      Array(InvoiceReconciliationCheck.new.call)
+                        schema: schema,
+                        table: table).call
+      end
     end
 
     def configuration_check
@@ -136,7 +167,7 @@ module LlmCostTracker
       return live_rollups_check unless LlmCostTracker.configuration.cache_rollups
 
       errors = LlmCostTracker::Ledger::Schema::CallRollups.current_schema_errors
-      return rollups_drift_check if errors.empty?
+      return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if errors.empty?
 
       Check.new(
         :error,
@@ -145,35 +176,6 @@ module LlmCostTracker
       )
     end
 
-    ROLLUPS_DRIFT_TOLERANCE_PERCENT = 1.0
-    private_constant :ROLLUPS_DRIFT_TOLERANCE_PERCENT
-
-    def rollups_drift_check
-      drift_window = Time.now.utc.beginning_of_day
-      calls_total = LlmCostTracker::Call
-                    .where(tracked_at: drift_window..)
-                    .where.not(total_cost: nil)
-                    .sum(:total_cost)
-      rollup_total = LlmCostTracker::CallRollup
-                     .where(period: "day", period_start: drift_window.to_date)
-                     .sum(:total_cost)
-      return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if calls_total.zero?
-
-      drift_percent = ((calls_total - rollup_total).abs * 100.0 / calls_total)
-      if drift_percent > ROLLUPS_DRIFT_TOLERANCE_PERCENT
-        return Check.new(
-          :warn, "call rollups",
-          "rollups drift detected: today's calls SUM=#{calls_total} vs rollups SUM=#{rollup_total} " \
-          "(#{drift_percent.round(2)}% > #{ROLLUPS_DRIFT_TOLERANCE_PERCENT}% threshold). " \
-          "Cached budget reads may understate spend until a rebuild."
-        )
-      end
-
-      Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists")
-    rescue StandardError => e
-      Check.new(:warn, "call rollups", "rollups drift check failed: #{e.class}: #{e.message}")
-    end
-
     def live_rollups_check
       if Probe.table_exists?("llm_cost_tracker_call_rollups")
         Check.new(

data/lib/llm_cost_tracker/engine.rb

@@ -9,12 +9,12 @@ module LlmCostTracker
   class Engine < ::Rails::Engine
     isolate_namespace LlmCostTracker
 
-    initializer "llm_cost_tracker.filter_parameters" do |app|
-      app.config.filter_parameters += %i[tag tag_value]
-    end
-
     initializer "llm_cost_tracker.dashboard_setup_state" do |app|
       app.reloader.to_prepare { LlmCostTracker::Dashboard::SetupState.reset! }
     end
+
+    initializer "llm_cost_tracker.pricing_cache" do |app|
+      app.reloader.to_prepare { LlmCostTracker::Pricing::Registry.reset! }
+    end
   end
 end

data/lib/llm_cost_tracker/event.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "pricing"
-require_relative "billing/line_item"
-
 module LlmCostTracker
   Event = Data.define(
     :event_id,
@@ -19,38 +16,30 @@ module LlmCostTracker
     :provider_project_id,
     :provider_api_key_id,
     :provider_workspace_id,
-    :batch,
     :tracked_at,
     :cost_status,
     :pricing_snapshot,
     :line_items
   ) do
-    def self.batch_from_pricing_mode?(pricing_mode)
-      pricing_mode.to_s.split("_").include?("batch")
-    end
-
     def self.build(**attributes)
-      pricing_mode = Pricing.normalize_mode(attributes[:pricing_mode])
       token_usage = attributes.fetch(:token_usage)
-      batch = attributes[:batch].nil? ? batch_from_pricing_mode?(pricing_mode) : attributes[:batch]
-      line_items = attributes[:line_items] || resolve_line_items(attributes[:service_line_items], token_usage)
+      line_items = attributes[:line_items] || resolve_line_items(attributes[:service_line_items])
 
       new(
         event_id: attributes[:event_id],
         provider: attributes.fetch(:provider).to_s,
         model: attributes.fetch(:model).to_s.strip.presence || Event::UNKNOWN_MODEL,
         token_usage: token_usage,
-        pricing_mode: pricing_mode,
+        pricing_mode: attributes[:pricing_mode],
         cost: attributes[:cost],
         tags: attributes[:tags],
         latency_ms: attributes[:latency_ms],
         stream: attributes[:stream] || false,
-        usage_source: attributes[:usage_source],
+        usage_source: attributes[:usage_source]&.to_s,
         provider_response_id: attributes[:provider_response_id].to_s.strip.presence,
         provider_project_id: attributes[:provider_project_id].to_s.strip.presence,
         provider_api_key_id: attributes[:provider_api_key_id].to_s.strip.presence,
         provider_workspace_id: attributes[:provider_workspace_id].to_s.strip.presence,
-        batch: batch,
         tracked_at: attributes[:tracked_at],
         cost_status: attributes[:cost_status],
         pricing_snapshot: attributes[:pricing_snapshot],
@@ -58,21 +47,24 @@ module LlmCostTracker
       )
     end
 
-    def self.resolve_line_items(service_items, token_usage)
-      service_line_items = Array(service_items).map do |item|
-        item.is_a?(Billing::LineItem) ? item : Billing::LineItem.build(item)
+    def batch?
+      pricing_mode.to_s.split("_").include?("batch")
+    end
+
+    def self.resolve_line_items(service_items)
+      Array(service_items).map do |item|
+        item.is_a?(Charges::LineItem) ? item : Charges::LineItem.build(item)
       end
-      Billing::LineItem.from_token_usage(token_usage) + service_line_items
     end
 
     def total_cost
-      cost&.fetch(:total_cost, nil)
+      cost&.total
     end
 
     def to_h
       super.merge(
         token_usage: token_usage.to_h,
-        cost: cost && cost.to_h.transform_values { |v| v.is_a?(BigDecimal) ? v.to_f : v },
+        cost: cost&.to_h,
         tags: tags ? tags.to_h : {},
         line_items: (line_items || []).map(&:to_h)
       )

data/lib/llm_cost_tracker/generators/llm_cost_tracker/install_generator.rb

@@ -2,10 +2,9 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
-require "llm_cost_tracker/billing/components"
-require "llm_cost_tracker/billing/cost_status"
+require "llm_cost_tracker/charges/cost_status"
 require "llm_cost_tracker/pricing"
-require "llm_cost_tracker/token_usage"
+require "llm_cost_tracker/usage/token_usage"
 
 module LlmCostTracker
   module Generators

data/lib/llm_cost_tracker/generators/llm_cost_tracker/prices_generator.rb

@@ -11,11 +11,14 @@ module LlmCostTracker
     class PricesGenerator < Rails::Generators::Base
       desc "Creates a local LLM Cost Tracker price snapshot"
 
+      PRICES_PATH = "config/llm_cost_tracker_prices.yml"
+
       def create_prices_file
-        LlmCostTracker::Pricing::Sync::RegistryWriter.new.call(
-          path: File.join(destination_root, "config/llm_cost_tracker_prices.yml"),
+        payload = LlmCostTracker::Pricing::Sync::RegistryWriter.new.render(
+          path: File.join(destination_root, PRICES_PATH),
           registry: YAML.safe_load_file(LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH, aliases: false) || {}
         )
+        create_file(PRICES_PATH, payload)
       end
     end
   end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_cost_tracker_calls.rb.erb

@@ -1,5 +1,4 @@
-require "llm_cost_tracker/billing/components"
-require "llm_cost_tracker/billing/cost_status"
+require "llm_cost_tracker/charges/cost_status"
 require "llm_cost_tracker/ledger/schema/adapter"
 
 class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %>
@@ -8,7 +7,7 @@ class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %
       t.string  :event_id,      null: false
       t.string  :provider,      null: false
       t.string  :model,         null: false
-<% LlmCostTracker::TokenUsage.members.each do |column| -%>
+<% LlmCostTracker::Usage::TokenUsage.members.each do |column| -%>
       t.integer :<%= column %>, null: false, default: 0
 <% end -%>
       t.decimal :total_cost, precision: 20, scale: 8
@@ -21,7 +20,7 @@ class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %
       t.string  :provider_workspace_id
       t.boolean :batch, null: false, default: false
       t.string  :pricing_mode
-      t.string  :cost_status, null: false, default: LlmCostTracker::Billing::CostStatus::UNKNOWN
+      t.string  :cost_status, null: false, default: LlmCostTracker::Charges::CostStatus::UNKNOWN
       if postgresql?
         t.jsonb :pricing_snapshot
       elsif mysql?
@@ -50,7 +49,7 @@ class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %
       t.decimal :rate_quantity, precision: 30, scale: 10, null: false, default: 1
       t.decimal :cost, precision: 20, scale: 8
       t.string :currency, null: false, default: "USD"
-      t.string :cost_status, null: false, default: LlmCostTracker::Billing::CostStatus::UNKNOWN
+      t.string :cost_status, null: false, default: LlmCostTracker::Charges::CostStatus::UNKNOWN
       t.string :pricing_basis
       t.string :price_key
       t.string :price_source

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/initializer.rb.erb

@@ -57,8 +57,9 @@ LlmCostTracker.configure do |config|
   # thread. Set to :async for a write-ahead inbox + background worker that batches
   # inserts and survives caller transaction rollbacks. Requires the optional
   # inbox/leases tables created by `bin/rails generate llm_cost_tracker:async_ingestion`.
-  # The worker uses a dedicated ActiveRecord pool (defaults to 2 connections) so it
-  # doesn't compete with request threads — bump ingestion_pool_size if your Puma
+  # Synchronous inbox writes use a dedicated ActiveRecord pool (defaults to 2 connections)
+  # so they don't compete with request threads for the default pool when a tracked call
+  # happens inside an open caller transaction. Bump ingestion_pool_size if your Puma
   # worker count outgrows that.
   # config.ingestion          = :async
   # config.ingestion_pool_size = 5

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/upgrade_call_rollups_provider.rb.erb

@@ -8,12 +8,16 @@ class UpgradeLlmCostTrackerCallRollupsProvider < ActiveRecord::Migration<%= migr
   NEW_INDEX = %i[period period_start currency provider].freeze
 
   def up
+    return unless table_exists?(TABLE)
+
     add_column TABLE, :provider, :string, null: false, default: "" unless column_exists?(TABLE, :provider)
     add_unique_index NEW_INDEX
     remove_index TABLE, column: OLD_INDEX, unique: true, if_exists: true
   end
 
   def down
+    return unless table_exists?(TABLE)
+
     add_unique_index OLD_INDEX
     remove_index TABLE, column: NEW_INDEX, unique: true, if_exists: true
     remove_column TABLE, :provider if column_exists?(TABLE, :provider)