llm_cost_tracker 0.7.3 → 0.9.0

data/lib/llm_cost_tracker/doctor.rb

@@ -2,23 +2,18 @@
 
 require_relative "ledger"
 require_relative "doctor/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 "generators/llm_cost_tracker/add_token_usage_generator"
+require_relative "doctor/schema_check"
+require_relative "doctor/cost_drift_check"
+require_relative "doctor/pricing_snapshot_drift_check"
 
 module LlmCostTracker
   class Doctor
-    COLUMN_GENERATORS = {
-      "event_id" => "bin/rails generate llm_cost_tracker:add_ingestion",
-      "latency_ms" => "bin/rails generate llm_cost_tracker:add_latency_ms",
-      "stream" => "bin/rails generate llm_cost_tracker:add_streaming",
-      "usage_source" => "bin/rails generate llm_cost_tracker:add_streaming",
-      "provider_response_id" => "bin/rails generate llm_cost_tracker:add_provider_response_id"
-    }.merge(
-      Generators::AddTokenUsageGenerator::COLUMN_NAMES.to_h do |column|
-        [column, "bin/rails generate llm_cost_tracker:add_token_usage"]
-      end
-    ).freeze
+    autoload :InvoiceReconciliationCheck, "llm_cost_tracker/doctor/invoice_reconciliation_check"
 
     class << self
       def call
@@ -44,7 +39,17 @@ module LlmCostTracker
         active_record_check,
         table_check,
         column_check,
-        period_totals_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,
+        call_rollups_check,
         IngestionCheck.new.call,
         PriceCheck.new.call,
         calls_check
@@ -53,6 +58,26 @@ module LlmCostTracker
 
     private
 
+    def reconciliation_schema_checks
+      return [] unless LlmCostTracker.reconciliation_enabled?
+
+      LlmCostTracker.const_get(:Reconciliation) # autoload reconciliation + its ledger schemas
+      Reconciliation::SCHEMA_TABLES.map do |schema, table|
+        SchemaCheck.new(name: humanize_table(table), schema: schema, table: table,
+                        optional: false, install_command: "llm_cost_tracker:reconciliation").call
+      end.compact
+    end
+
+    def humanize_table(table)
+      table.delete_prefix("llm_cost_tracker_").tr("_", " ")
+    end
+
+    def reconciliation_invoice_check
+      return [] unless LlmCostTracker.reconciliation_enabled?
+
+      Array(InvoiceReconciliationCheck.new.call)
+    end
+
     def configuration_check
       config = LlmCostTracker.configuration
       Check.new(:ok, "configuration", "active_record ledger enabled=#{config.enabled}")
@@ -68,7 +93,7 @@ module LlmCostTracker
         return Check.new(
           :ok,
           "capture",
-          "SDK integrations enabled: #{config.instrumented_integrations.join(', ')}"
+          "SDK integrations enabled: #{config.instrumented_integrations.to_a.join(', ')}"
         )
       end
 
@@ -93,68 +118,110 @@ module LlmCostTracker
 
     def table_check
       return unless active_record_available?
-      return Check.new(:ok, "llm_api_calls", "table exists") if llm_api_calls_table?
+      return Check.new(:ok, "llm_cost_tracker_calls", "table exists") if llm_cost_tracker_calls_table?
 
       Check.new(
         :error,
-        "llm_api_calls",
+        "llm_cost_tracker_calls",
         "missing; run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
       )
     end
 
     def column_check
-      return unless llm_api_calls_table?
+      return unless llm_cost_tracker_calls_table?
 
       errors = LlmCostTracker::Ledger::Schema::Calls.current_schema_errors
-      return Check.new(:ok, "llm_api_calls columns", "current") if errors.empty?
-
-      missing = LlmCostTracker::Ledger::Schema::Calls.missing_current_schema_columns
-      generators = missing.filter_map { |column| COLUMN_GENERATORS[column] }.uniq
-      message = "current schema required; #{errors.join('; ')}"
-      message = "#{message}; run #{generators.join(' && ')} && bin/rails db:migrate" if generators.any?
+      return Check.new(:ok, "llm_cost_tracker_calls columns", "current") if errors.empty?
 
-      Check.new(:error, "llm_api_calls columns", message)
+      Check.new(
+        :error,
+        "llm_cost_tracker_calls columns",
+        "schema mismatch: #{errors.join('; ')}; see docs/upgrading.md"
+      )
     end
 
-    def period_totals_check
-      return unless llm_api_calls_table?
+    def call_rollups_check
+      return unless llm_cost_tracker_calls_table?
+      return live_rollups_check unless LlmCostTracker.configuration.cache_rollups
 
-      errors = LlmCostTracker::Ledger::Schema::PeriodTotals.current_schema_errors
-      return Check.new(:ok, "period totals", "llm_cost_tracker_period_totals exists") if errors.empty?
+      errors = LlmCostTracker::Ledger::Schema::CallRollups.current_schema_errors
+      return rollups_drift_check if errors.empty?
 
       Check.new(
         :error,
-        "period totals",
-        "current schema required; #{errors.join('; ')}; " \
-        "run bin/rails generate llm_cost_tracker:add_period_totals && bin/rails db:migrate"
+        "call rollups",
+        "schema mismatch: #{errors.join('; ')}; see docs/upgrading.md"
       )
     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(
+          :warn,
+          "call rollups",
+          "cache_rollups=false but llm_cost_tracker_call_rollups exists. " \
+          "Set config.cache_rollups = true to keep budget reads on the rollups fast path or drop the table."
+        )
+      else
+        Check.new(
+          :ok,
+          "call rollups",
+          "cache_rollups=false; budget reads aggregate from llm_cost_tracker_calls directly"
+        )
+      end
+    end
+
     def calls_check
-      return unless llm_api_calls_table?
+      return unless llm_cost_tracker_calls_table?
 
-      count = LlmCostTracker::Ledger::Call.count
+      snapshot = LlmCostTracker::Call
+                 .select("COUNT(*) AS tracked_call_count, MAX(tracked_at) AS latest_tracked_at")
+                 .take
+      count = snapshot.tracked_call_count.to_i
       return Check.new(:warn, "tracked calls", "none recorded yet") if count.zero?
 
-      latest = LlmCostTracker::Ledger::Call.maximum(:tracked_at)&.utc&.iso8601
+      latest_at = snapshot.latest_tracked_at
+      latest_at = latest_at.to_time if latest_at.respond_to?(:to_time)
+      latest = latest_at&.utc&.iso8601
       Check.new(:ok, "tracked calls", "#{count} recorded; latest #{latest}")
     end
 
     def active_record_available?
-      LlmCostTracker::Ledger::Call.connection
+      LlmCostTracker::Call.connection
       true
     rescue LoadError, StandardError
       false
     end
 
-    def llm_api_calls_table?
-      active_record_available? && table_exists?("llm_api_calls")
-    end
-
-    def table_exists?(name)
-      LlmCostTracker::Ledger::Call.connection.data_source_exists?(name)
-    rescue StandardError
-      false
-    end
+    def llm_cost_tracker_calls_table? = active_record_available? && Probe.table_exists?("llm_cost_tracker_calls")
   end
 end

data/lib/llm_cost_tracker/engine.rb

@@ -3,10 +3,19 @@
 require "rails"
 require_relative "../llm_cost_tracker"
 require_relative "assets"
+require_relative "dashboard_setup_state"
 require "rack/files"
 
 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::DashboardSetupState.reset! }
+    end
   end
 end

data/lib/llm_cost_tracker/errors.rb

@@ -6,16 +6,12 @@ module LlmCostTracker
   class InvalidFilterError < Error; end
 
   class BudgetExceededError < Error
-    attr_reader :monthly_total, :daily_total, :call_cost, :total, :budget, :budget_type, :last_event
-
-    def initialize(budget:, last_event: nil, budget_type: nil, total: nil, monthly_total: nil, daily_total: nil,
-                   call_cost: nil)
-      @monthly_total = monthly_total
-      @daily_total = daily_total
-      @call_cost = call_cost
-      @total = total || monthly_total || daily_total || call_cost
+    attr_reader :total, :budget, :budget_type, :last_event
+
+    def initialize(budget:, budget_type:, total:, last_event: nil)
+      @total = total
       @budget = budget
-      @budget_type = budget_type || inferred_budget_type
+      @budget_type = budget_type
       @last_event = last_event
 
       super(
@@ -23,16 +19,6 @@ module LlmCostTracker
         "$#{format('%.6f', @total)} / $#{format('%.6f', budget)}"
       )
     end
-
-    private
-
-    def inferred_budget_type
-      return :monthly if monthly_total
-      return :daily if daily_total
-      return :per_call if call_cost
-
-      :unknown
-    end
   end
 
   class UnknownPricingError < Error

data/lib/llm_cost_tracker/event.rb

@@ -13,7 +13,14 @@ module LlmCostTracker
     :stream,
     :usage_source,
     :provider_response_id,
-    :tracked_at
+    :provider_project_id,
+    :provider_api_key_id,
+    :provider_workspace_id,
+    :batch,
+    :tracked_at,
+    :cost_status,
+    :pricing_snapshot,
+    :line_items
   ) do
     def total_cost
       cost&.fetch(:total_cost, nil)
@@ -22,8 +29,9 @@ module LlmCostTracker
     def to_h
       super.merge(
         token_usage: token_usage.to_h,
-        cost: cost&.to_h,
-        tags: tags ? tags.to_h : {}
+        cost: cost && cost.to_h.transform_values { |v| v.is_a?(BigDecimal) ? v.to_f : v },
+        tags: tags ? tags.to_h : {},
+        line_items: (line_items || []).map(&:to_h)
       )
     end
   end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/call_rollups_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class CallRollupsGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the optional llm_cost_tracker_call_rollups table for fast budget reads. " \
+           "Required when config.cache_rollups = true."
+
+      def create_migration_file
+        migration_template(
+          "create_llm_cost_tracker_call_rollups.rb.erb",
+          "db/migrate/create_llm_cost_tracker_call_rollups.rb"
+        )
+      end
+
+      def warn_about_config_flag
+        say(<<~MSG, :yellow)
+          After migrating, set the following in config/initializers/llm_cost_tracker.rb:
+
+            LlmCostTracker.configure do |config|
+              config.cache_rollups = true
+            end
+
+          Without it Tracker keeps reading budget totals as live SUM aggregates over
+          llm_cost_tracker_calls. The doctor check warns about an unused rollups table.
+        MSG
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/durable_ingestion_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class DurableIngestionGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the durable ingestion tables (llm_cost_tracker_ingestion_inbox_entries + _leases). " \
+           "Required when config.durable_ingestion = true."
+
+      def create_migration_file
+        migration_template(
+          "create_llm_cost_tracker_durable_ingestion.rb.erb",
+          "db/migrate/create_llm_cost_tracker_durable_ingestion.rb"
+        )
+      end
+
+      def warn_about_config_flag
+        say(<<~MSG, :yellow)
+          After migrating, set the following in config/initializers/llm_cost_tracker.rb:
+
+            LlmCostTracker.configure do |config|
+              config.durable_ingestion = true
+            end
+
+          Without it the durable inbox tables stay unused and Tracker keeps writing
+          inline. The doctor check warns about unused durable tables.
+        MSG
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

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

@@ -2,6 +2,8 @@
 
 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/pricing"
 require "llm_cost_tracker/token_usage"
 
@@ -18,8 +20,8 @@ module LlmCostTracker
 
       def create_migration_file
         migration_template(
-          "create_llm_api_calls.rb.erb",
-          "db/migrate/create_llm_api_calls.rb"
+          "create_llm_cost_tracker_calls.rb.erb",
+          "db/migrate/create_llm_cost_tracker_calls.rb"
         )
       end
 
@@ -33,15 +35,25 @@ module LlmCostTracker
       def create_prices_file
         return unless options[:prices]
 
-        invoke "llm_cost_tracker:prices"
+        require_relative "prices_generator"
+        invoke LlmCostTracker::Generators::PricesGenerator
       end
 
       def mount_engine
         return unless options[:dashboard]
 
         add_engine_require
-        route %(mount LlmCostTracker::Engine => "/llm-costs")
-        say "Mount /llm-costs behind your app's admin auth before deploying.", :yellow
+        say(<<~MSG, :yellow)
+          The LLM Cost Tracker dashboard ships without authentication.
+          Mount it in config/routes.rb behind your app's admin auth, e.g.:
+
+            authenticate :admin do
+              mount LlmCostTracker::Engine => "/llm-costs"
+            end
+
+          The generator does NOT add a route automatically — leaving the dashboard
+          unauthenticated would expose spend, tags, and provider IDs to anyone.
+        MSG
       end
 
       private

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "rails/generators"
+require "yaml"
 
 require_relative "../../pricing/registry"
-require_relative "../../pricing/sync/registry_loader"
 require_relative "../../pricing/sync/registry_writer"
 
 module LlmCostTracker
@@ -12,13 +12,9 @@ module LlmCostTracker
       desc "Creates a local LLM Cost Tracker price snapshot"
 
       def create_prices_file
-        registry = LlmCostTracker::Pricing::Sync::RegistryLoader.new.call(
-          path: LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH,
-          seed_path: LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH
-        )
         LlmCostTracker::Pricing::Sync::RegistryWriter.new.call(
           path: File.join(destination_root, "config/llm_cost_tracker_prices.yml"),
-          registry: registry
+          registry: YAML.safe_load_file(LlmCostTracker::Pricing::Registry::DEFAULT_PRICES_PATH, aliases: false) || {}
         )
       end
     end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/reconciliation_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class ReconciliationGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the optional invoice reconciliation tables. Requires provider admin/org-level API keys."
+
+      def create_migration_file
+        migration_template(
+          "create_llm_cost_tracker_reconciliation.rb.erb",
+          "db/migrate/create_llm_cost_tracker_reconciliation.rb"
+        )
+      end
+
+      def warn_about_admin_keys
+        say "Reconciliation requires admin/org-level API keys (OpenAI sk-admin-..., Anthropic admin keys, " \
+            "GCP billing.viewer service accounts). Do NOT use the runtime inference key.", :yellow
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+class CreateLlmCostTrackerCallRollups < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :llm_cost_tracker_call_rollups do |t|
+      t.string :period, null: false
+      t.date :period_start, null: false
+      t.string :currency, null: false, default: "USD"
+      t.string :provider, null: false, default: ""
+      t.decimal :total_cost, precision: 20, scale: 8, null: false, default: 0
+
+      t.timestamps
+    end
+
+    add_index :llm_cost_tracker_call_rollups, [:period, :period_start, :currency, :provider], unique: true
+  end
+end

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

@@ -0,0 +1,104 @@
+require "llm_cost_tracker/billing/components"
+require "llm_cost_tracker/billing/cost_status"
+require "llm_cost_tracker/ledger/schema/adapter"
+
+class CreateLlmCostTrackerCalls < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :llm_cost_tracker_calls do |t|
+      t.string  :event_id,      null: false
+      t.string  :provider,      null: false
+      t.string  :model,         null: false
+<% LlmCostTracker::TokenUsage.members.each do |column| -%>
+      t.integer :<%= column %>, null: false, default: 0
+<% end -%>
+      t.decimal :total_cost, precision: 20, scale: 8
+      t.integer :latency_ms
+      t.boolean :stream,        null: false, default: false
+      t.string  :usage_source
+      t.string  :provider_response_id
+      t.string  :provider_project_id
+      t.string  :provider_api_key_id
+      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
+      if postgresql?
+        t.jsonb :pricing_snapshot
+      elsif mysql?
+        t.json :pricing_snapshot
+      else
+        raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
+      end
+      t.datetime :tracked_at,   null: false
+
+      t.timestamps
+    end
+
+    create_table :llm_cost_tracker_call_line_items do |t|
+      t.references :llm_cost_tracker_call,
+                   null: false,
+                   index: false,
+                   foreign_key: { to_table: :llm_cost_tracker_calls, on_delete: :cascade }
+      t.integer :position, null: false, default: 0, limit: 2
+      t.string :kind, null: false
+      t.string :direction, null: false
+      t.string :modality, null: false
+      t.string :cache_state, null: false, default: "none"
+      t.decimal :quantity, precision: 30, scale: 10, null: false
+      t.string :unit, null: false
+      t.decimal :rate_amount, precision: 20, scale: 8
+      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 :pricing_basis
+      t.string :price_key
+      t.string :price_source
+      t.string :price_source_version
+      t.string :provider_field
+      t.string :provider_item_id
+      if postgresql?
+        t.jsonb :details, null: false, default: {}
+      elsif mysql?
+        t.json :details, null: false
+      else
+        raise "LLM Cost Tracker supports PostgreSQL and MySQL only"
+      end
+
+      t.datetime :created_at, null: false
+    end
+
+    create_table :llm_cost_tracker_call_tags do |t|
+      t.references :llm_cost_tracker_call,
+                   null: false,
+                   index: false,
+                   foreign_key: { to_table: :llm_cost_tracker_calls, on_delete: :cascade }
+      t.string :key, null: false
+      t.text :value, null: false
+    end
+
+    add_index :llm_cost_tracker_calls, :event_id, unique: true
+    add_index :llm_cost_tracker_calls, :tracked_at
+    add_index :llm_cost_tracker_calls, [:provider, :tracked_at]
+    add_index :llm_cost_tracker_calls, [:model, :tracked_at]
+    add_index :llm_cost_tracker_calls, :cost_status
+    add_index :llm_cost_tracker_calls, :provider_response_id
+    add_index :llm_cost_tracker_call_line_items, [:llm_cost_tracker_call_id, :position]
+    add_index :llm_cost_tracker_call_tags, :llm_cost_tracker_call_id
+    if postgresql?
+      add_index :llm_cost_tracker_call_tags, [:key, :value]
+    elsif mysql?
+      add_index :llm_cost_tracker_call_tags, [:key, :value], length: { value: 191 }
+    end
+  end
+
+  private
+
+  def postgresql?
+    LlmCostTracker::Ledger::Schema::Adapter.postgresql?(connection)
+  end
+
+  def mysql?
+    LlmCostTracker::Ledger::Schema::Adapter.mysql?(connection)
+  end
+end

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

@@ -0,0 +1,29 @@
+class CreateLlmCostTrackerDurableIngestion < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :llm_cost_tracker_ingestion_inbox_entries do |t|
+      t.string   :event_id, null: false
+      t.decimal  :total_cost, precision: 20, scale: 8
+      t.datetime :tracked_at, null: false
+      t.text     :payload, null: false
+      t.datetime :locked_at
+      t.string   :locked_by
+      t.integer  :attempts, null: false, default: 0
+      t.text     :last_error
+
+      t.timestamps
+    end
+
+    create_table :llm_cost_tracker_ingestion_leases do |t|
+      t.string   :name, null: false
+      t.string   :locked_by
+      t.datetime :locked_until
+
+      t.timestamps
+    end
+
+    add_index :llm_cost_tracker_ingestion_inbox_entries, :event_id, unique: true
+    add_index :llm_cost_tracker_ingestion_inbox_entries, [:tracked_at, :attempts]
+    add_index :llm_cost_tracker_ingestion_inbox_entries, [:locked_at, :id]
+    add_index :llm_cost_tracker_ingestion_leases, :name, unique: true
+  end
+end