llm_cost_tracker 0.11.0 → 0.13.0

data/app/services/llm_cost_tracker/dashboard/data_quality.rb

@@ -1,19 +1,32 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/billing/components"
-require "llm_cost_tracker/ledger/schema/adapter"
-
 module LlmCostTracker
   module Dashboard
-    class DataQuality
+    module DataQuality
       UnknownPricingRow = ::Data.define(:provider, :model, :calls, :share_percent)
+      QuarantinedInbox = ::Data.define(:count, :total_cost)
       StreamingHealthRow = ::Data.define(:provider, :streams, :with_usage, :unknown, :unknown_share)
-      Summary = ::Data.define(:total, :unknown_pricing_count, :untagged_calls_count, :missing_latency_count,
-                              :streaming_count, :streaming_missing_usage, :missing_provider_response_id_count,
-                              :calls_with_pricing, :tagged_calls, :calls_with_latency, :streams_with_usage,
-                              :calls_with_provider_response_id, :unknown_pricing_share, :untagged_share,
-                              :missing_latency_share, :streaming_share, :streaming_missing_usage_share,
-                              :cost_coverage, :tag_coverage, :latency_coverage, :stream_coverage,
+      Summary = ::Data.define(:total,
+                              :unknown_pricing_count,
+                              :untagged_calls_count,
+                              :missing_latency_count,
+                              :streaming_count,
+                              :streaming_missing_usage,
+                              :missing_provider_response_id_count,
+                              :calls_with_pricing,
+                              :tagged_calls,
+                              :calls_with_latency,
+                              :streams_with_usage,
+                              :calls_with_provider_response_id,
+                              :unknown_pricing_share,
+                              :untagged_share,
+                              :missing_latency_share,
+                              :streaming_share,
+                              :streaming_missing_usage_share,
+                              :cost_coverage,
+                              :tag_coverage,
+                              :latency_coverage,
+                              :stream_coverage,
                               :provider_response_id_coverage)
 
       class << self
@@ -21,6 +34,17 @@ module LlmCostTracker
           scope.unscope(:order).select(aggregate_selects(scope)).take
         end
 
+        def quarantined_inbox
+          return nil unless Ingestion.async?
+          return nil unless Ingestion::InboxEntry.table_exists?
+
+          row = Ingestion::InboxEntry
+                .quarantined
+                .select("COUNT(*) AS quarantined_count, COALESCE(SUM(total_cost), 0) AS quarantined_cost")
+                .take
+          QuarantinedInbox.new(count: row.quarantined_count.to_i, total_cost: row.quarantined_cost.to_d)
+        end
+
         def summary(stats)
           total = stats.total_calls.to_i
           unknown_pricing_count = stats.unknown_pricing_count.to_i
@@ -36,14 +60,28 @@ module LlmCostTracker
           calls_with_provider_response_id = total - missing_provider_response_id_count
 
           Summary.new(
-            total, unknown_pricing_count, untagged_calls_count, missing_latency_count, streaming_count,
-            streaming_missing_usage, missing_provider_response_id_count, calls_with_pricing, tagged_calls,
-            calls_with_latency, streams_with_usage, calls_with_provider_response_id,
-            percentage(unknown_pricing_count, total), percentage(untagged_calls_count, total),
-            percentage(missing_latency_count, total), percentage(streaming_count, total),
-            percentage(streaming_missing_usage, streaming_count), percentage(calls_with_pricing, total),
-            percentage(tagged_calls, total), percentage(calls_with_latency, total),
-            percentage(streams_with_usage, streaming_count), percentage(calls_with_provider_response_id, total)
+            total,
+            unknown_pricing_count,
+            untagged_calls_count,
+            missing_latency_count,
+            streaming_count,
+            streaming_missing_usage,
+            missing_provider_response_id_count,
+            calls_with_pricing,
+            tagged_calls,
+            calls_with_latency,
+            streams_with_usage,
+            calls_with_provider_response_id,
+            percentage(unknown_pricing_count, total),
+            percentage(untagged_calls_count, total),
+            percentage(missing_latency_count, total),
+            percentage(streaming_count, total),
+            percentage(streaming_missing_usage, streaming_count),
+            percentage(calls_with_pricing, total),
+            percentage(tagged_calls, total),
+            percentage(calls_with_latency, total),
+            percentage(streams_with_usage, streaming_count),
+            percentage(calls_with_provider_response_id, total)
           )
         end
 
@@ -55,7 +93,9 @@ module LlmCostTracker
                .limit(10)
                .map do |row|
                  calls = row.calls.to_i
-                 UnknownPricingRow.new(provider: row.provider, model: row.model, calls: calls,
+                 UnknownPricingRow.new(provider: row.provider,
+                                       model: row.model,
+                                       calls: calls,
                                        share_percent: percentage(calls, total_calls))
                end
         end
@@ -85,7 +125,7 @@ module LlmCostTracker
         def usage_rows(stats, component_costs: {})
           billable_tokens = stats.billable_tokens.to_f
 
-          rows = Billing::Components::TOKEN_PRICED.map do |component|
+          rows = Usage::Catalog.token_priced.map do |component|
             token_value = stats[component.token_key].to_i
 
             {
@@ -118,7 +158,8 @@ module LlmCostTracker
                  .where(unit: "token")
                  .joins(:call)
                  .merge(scope.unscope(:select, :order, :group))
-                 .group("#{line_item_table}.kind", "#{line_item_table}.direction",
+                 .group("#{line_item_table}.kind",
+                        "#{line_item_table}.direction",
                         "#{line_item_table}.cache_state")
                  .pluck(Arel.sql("#{line_item_table}.kind"),
                         Arel.sql("#{line_item_table}.direction"),
@@ -130,7 +171,7 @@ module LlmCostTracker
         def streaming_health_rows(scope, total_streaming:)
           return [] unless total_streaming.positive?
 
-          unknown_predicate = "usage_source = 'unknown' OR usage_source IS NULL"
+          unknown_predicate = unknown_usage_source_predicate(scope)
           rows = scope.unscope(:select, :order, :group)
                       .where(stream: true)
                       .group(:provider)
@@ -169,11 +210,7 @@ module LlmCostTracker
 
         def index_costs_by_component(rows)
           rows.each_with_object({}) do |(kind, direction, cache_state, cost), accumulator|
-            component = Billing::Components::TOKEN_PRICED.find do |item|
-              item.kind.to_s == kind.to_s &&
-                item.direction.to_s == direction.to_s &&
-                item.cache_state.to_s == cache_state.to_s
-            end
+            component = Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
             accumulator[component.key] = cost if component
           end
         end
@@ -185,14 +222,15 @@ module LlmCostTracker
         end
 
         def aggregate_selects(scope)
+          unknown_pricing = Charges::CostStatus.unknown_pricing_sql
           selects = [
             "COUNT(*) AS total_calls",
-            "#{conditional_count_sql(unknown_pricing_predicate(scope))} AS unknown_pricing_count",
+            "#{conditional_count_sql(unknown_pricing)} AS unknown_pricing_count",
             "#{tagged_calls_sql(scope)} AS tagged_calls_count",
             "COUNT(*) - #{tagged_calls_sql(scope)} AS untagged_calls_count",
             "#{conditional_count_sql('latency_ms IS NULL')} AS missing_latency_count",
             "#{conditional_count_sql('stream')} AS streaming_count",
-            "#{streaming_missing_usage_select} AS streaming_missing_usage_count",
+            "#{streaming_missing_usage_select(scope)} AS streaming_missing_usage_count",
             "#{provider_response_id_select} AS missing_provider_response_id_count"
           ]
 
@@ -207,13 +245,13 @@ module LlmCostTracker
         end
 
         def usage_sum_columns
-          Billing::Components::TOKEN_PRICED.map(&:token_key) + [:hidden_output_tokens]
+          Usage::Catalog.token_priced.map(&:token_key) + [:hidden_output_tokens]
         end
 
         def billable_tokens_select(scope)
-          Billing::Components::TOKEN_PRICED
-            .map { |component| column_sum(scope, component.token_key) }
-            .join(" + ")
+          Usage::Catalog.token_priced
+                        .map { |component| column_sum(scope, component.token_key) }
+                        .join(" + ")
         end
 
         def hidden_output_share_select(scope)
@@ -223,13 +261,9 @@ module LlmCostTracker
           "CASE WHEN #{output} > 0 THEN #{hidden_output} * 100.0 / #{output} ELSE 0 END"
         end
 
-        def unknown_pricing_predicate(scope)
-          values = [
-            LlmCostTracker::Billing::CostStatus::UNKNOWN,
-            LlmCostTracker::Billing::CostStatus::PARTIAL
-          ].map { |value| scope.connection.quote(value) }
-
-          "total_cost IS NULL OR cost_status IN (#{values.join(', ')})"
+        def unknown_usage_source_predicate(scope)
+          quoted = scope.connection.quote(LlmCostTracker::Usage::Source::UNKNOWN)
+          "usage_source = #{quoted} OR usage_source IS NULL"
         end
 
         def column_sum(scope, column)
@@ -240,9 +274,8 @@ module LlmCostTracker
           "COALESCE(SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END), 0)"
         end
 
-        def streaming_missing_usage_select
-          predicate = "stream AND (usage_source = 'unknown' OR usage_source IS NULL)"
-          conditional_count_sql(predicate)
+        def streaming_missing_usage_select(scope)
+          conditional_count_sql("stream AND (#{unknown_usage_source_predicate(scope)})")
         end
 
         def provider_response_id_select

data/app/services/llm_cost_tracker/dashboard/filter.rb

@@ -5,6 +5,11 @@ require "date"
 module LlmCostTracker
   module Dashboard
     class Filter
+      STREAM_FILTER_OPTIONS = [
+        ["Streaming only", "yes"],
+        ["Non-streaming only", "no"]
+      ].freeze
+
       class << self
         def call(scope: LlmCostTracker::Call.all, params: {})
           new(scope: scope, params: params).relation

data/app/services/llm_cost_tracker/dashboard/masking.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module Masking
+      SENSITIVE_KEYS = %w[provider_api_key_id provider_workspace_id provider_project_id].freeze
+      MASK_TAIL_LENGTH = 4
+
+      def self.mask_value(key, value)
+        string = value.to_s
+        return string unless SENSITIVE_KEYS.include?(key.to_s)
+        return string if string.length <= MASK_TAIL_LENGTH
+
+        "***#{string[-MASK_TAIL_LENGTH, MASK_TAIL_LENGTH]}"
+      end
+
+      def self.mask_hash(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(key, value), masked|
+          masked[key] = case value
+                        when Hash then mask_hash(value)
+                        when Array then value.map { |entry| entry.is_a?(Hash) ? mask_hash(entry) : entry }
+                        else
+                          mask_value(key, value)
+                        end
+        end
+      end
+    end
+  end
+end

data/app/services/llm_cost_tracker/dashboard/monthly_budget.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Dashboard
+    module MonthlyBudget
+      module_function
+
+      def status
+        budget = LlmCostTracker.configuration.monthly_budget
+        return nil unless budget
+
+        budget = budget.to_f
+        now = Time.now.utc
+        month_start = now.beginning_of_month
+        month_end = now.end_of_month
+        spent = LlmCostTracker::Ledger::Period::Totals.call(%i[month], time: now).fetch(:month)
+        elapsed_seconds = now - month_start
+        total_seconds = month_end - month_start
+        projected_spent = if spent.zero? || !elapsed_seconds.positive?
+                            spent
+                          else
+                            spent * (total_seconds / elapsed_seconds)
+                          end
+        percent_used = budget.positive? ? (spent / budget) * 100.0 : 0.0
+        projected_percent_used = budget.positive? ? (projected_spent / budget) * 100.0 : 0.0
+        projected_delta = projected_spent - budget
+
+        {
+          budget: budget,
+          spent: spent,
+          percent_used: percent_used,
+          projected_spent: projected_spent,
+          projected_percent_used: projected_percent_used,
+          projected_delta: projected_delta,
+          projection_end_label: month_end.strftime("%b %-d"),
+          fill_modifier: fill_modifier(percent_used),
+          progress_percent: clamped_percent(percent_used),
+          projected_marker_percent: clamped_percent(projected_percent_used),
+          projected_delta_amount: projected_delta.abs,
+          projected_delta_direction: projected_delta.positive? ? "over" : "under",
+          projected_delta_status_class: projected_delta_status_class(projected_delta)
+        }
+      end
+
+      def clamped_percent(value)
+        value.clamp(0.0, 100.0)
+      end
+
+      def fill_modifier(percent)
+        return "lct-budget-fill--over" if percent >= 100.0
+        return "lct-budget-fill--warn" if percent >= 80.0
+
+        ""
+      end
+
+      def projected_delta_status_class(delta)
+        return "lct-budget-projection-status--over" if delta.positive?
+
+        "lct-budget-projection-status--under"
+      end
+    end
+  end
+end

data/app/services/llm_cost_tracker/dashboard/overview_stats.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/ledger"
-
 module LlmCostTracker
   module Dashboard
-    class OverviewStats
+    module OverviewStats
       class << self
         def call(scope: LlmCostTracker::Call.all, previous_scope: nil)
           return scope.select(aggregate_selects).take unless previous_scope
@@ -16,48 +14,6 @@ module LlmCostTracker
                .take
         end
 
-        def monthly_budget_status
-          budget = LlmCostTracker.configuration.monthly_budget
-          return nil unless budget
-
-          budget = budget.to_f
-          now = Time.now.utc
-          month_start = now.beginning_of_month
-          month_end = now.end_of_month
-          spent = LlmCostTracker::Ledger::Period::Totals.call(%i[month], time: now).fetch(:month)
-          elapsed_seconds = now - month_start
-          total_seconds = month_end - month_start
-          projected_spent = if spent.zero? || !elapsed_seconds.positive?
-                              spent
-                            else
-                              spent * (total_seconds / elapsed_seconds)
-                            end
-          percent_used = budget.positive? ? (spent / budget) * 100.0 : 0.0
-          projected_percent_used = budget.positive? ? (projected_spent / budget) * 100.0 : 0.0
-          projected_delta = projected_spent - budget
-
-          {
-            budget: budget,
-            spent: spent,
-            percent_used: percent_used,
-            projected_spent: projected_spent,
-            projected_percent_used: projected_percent_used,
-            projected_delta: projected_delta,
-            projection_end_label: month_end.strftime("%b %-d"),
-            fill_modifier: budget_fill_modifier(percent_used),
-            progress_percent: clamped_percent(percent_used),
-            projected_marker_percent: clamped_percent(projected_percent_used),
-            projected_delta_amount: projected_delta.abs,
-            projected_delta_direction: projected_delta.positive? ? "over" : "under",
-            projected_delta_status_class: projected_delta_status_class(projected_delta)
-          }
-        end
-
-        UNKNOWN_PRICING_COST_STATUSES = [
-          LlmCostTracker::Billing::CostStatus::UNKNOWN,
-          LlmCostTracker::Billing::CostStatus::PARTIAL
-        ].freeze
-
         private
 
         def aggregate_selects(table_name: nil, previous: false)
@@ -69,11 +25,10 @@ module LlmCostTracker
             THEN COALESCE(SUM(#{total_cost}), 0) * 1.0 / COUNT(*)
             ELSE 0 END
           SQL
-          unknown_pricing_sql = <<~SQL.squish
-            SUM(CASE WHEN #{total_cost} IS NULL OR
-                          #{cost_status} IN (#{UNKNOWN_PRICING_COST_STATUSES.map { |s| connection.quote(s) }.join(', ')})
-                THEN 1 ELSE 0 END)
-          SQL
+          predicate = LlmCostTracker::Charges::CostStatus.unknown_pricing_sql(
+            total_cost: total_cost, cost_status: cost_status
+          )
+          unknown_pricing_sql = "SUM(CASE WHEN #{predicate} THEN 1 ELSE 0 END)"
           selects = [
             "COUNT(*) AS total_calls",
             "COALESCE(SUM(#{total_cost}), 0) AS total_cost",
@@ -85,10 +40,6 @@ module LlmCostTracker
           selects.join(", ")
         end
 
-        def connection
-          LlmCostTracker::Call.connection
-        end
-
         def previous_selects(previous)
           unless previous
             return [
@@ -125,23 +76,6 @@ module LlmCostTracker
             .select("COALESCE(SUM(total_cost), 0) AS total_cost", "COUNT(*) AS total_calls")
             .to_sql
         end
-
-        def clamped_percent(value)
-          value.clamp(0.0, 100.0)
-        end
-
-        def budget_fill_modifier(percent)
-          return "lct-budget-fill--over" if percent >= 100.0
-          return "lct-budget-fill--warn" if percent >= 80.0
-
-          ""
-        end
-
-        def projected_delta_status_class(delta)
-          return "lct-budget-projection-status--over" if delta.positive?
-
-          "lct-budget-projection-status--under"
-        end
       end
     end
   end

data/app/services/llm_cost_tracker/dashboard/pagination.rb

@@ -6,6 +6,7 @@ module LlmCostTracker
       DEFAULT_PER = 50
       MAX_PER = 200
       MIN_PAGE = 1
+      MIN_PER = 1
 
       attr_reader :page, :per
 
@@ -13,7 +14,7 @@ module LlmCostTracker
         params = Params.to_hash(params).symbolize_keys
         new(
           page: integer_param(params, :page, default: MIN_PAGE, min: MIN_PAGE),
-          per: integer_param(params, :per, default: DEFAULT_PER, min: 1, max: MAX_PER)
+          per: integer_param(params, :per, default: DEFAULT_PER, min: MIN_PER, max: MAX_PER)
         )
       end
 
@@ -33,10 +34,6 @@ module LlmCostTracker
         freeze
       end
 
-      def limit
-        per
-      end
-
       def offset
         (page - 1) * per
       end

data/app/services/llm_cost_tracker/dashboard/pricing_overview.rb

@@ -4,9 +4,13 @@ module LlmCostTracker
   module Dashboard
     class PricingOverview
       SOURCES = %i[overrides file bundled].freeze
-      RATE_COLUMNS = %i[input output cache_read_input cache_write_input batch_input batch_output].freeze
+      RATE_COLUMNS = %w[input output cache_read_input cache_write_input batch_input batch_output].freeze
       Row = Data.define(:provider, :model, :rates)
 
+      SOURCE_NAME = { overrides: "pricing_overrides", file: "prices_file", bundled: "bundled" }.freeze
+      LABEL = { overrides: "Overrides", file: "Custom file", bundled: "Bundled" }.freeze
+      private_constant :SOURCE_NAME, :LABEL
+
       class << self
         def call
           new.call
@@ -14,9 +18,9 @@ module LlmCostTracker
       end
 
       def call
-        sources = SOURCES.each_with_object({}) do |source, acc|
-          built = build_source(source)
-          acc[source] = built if built
+        sources = SOURCES.each_with_object({}) do |key, acc|
+          source = sources_by_name.fetch(SOURCE_NAME.fetch(key))
+          acc[key] = present(key, source) unless source.prices.empty?
         end
         {
           sources: sources,
@@ -26,54 +30,36 @@ module LlmCostTracker
 
       private
 
-      def build_source(source)
-        case source
-        when :overrides then build_overrides
-        when :file then build_file
-        when :bundled then build_bundled
-        end
+      def sources_by_name
+        @sources_by_name ||= Pricing::Registry.sources.to_h { |source| [source.name, source] }
       end
 
-      def build_overrides
-        prices = LlmCostTracker.configuration.pricing_overrides
-        return nil if prices.nil? || prices.empty?
-
+      def present(key, source)
         {
-          label: "Overrides",
-          subtitle: "config.pricing_overrides",
-          updated_at: nil,
-          currency: nil,
-          rows: build_rows(prices)
+          label: LABEL.fetch(key),
+          subtitle: subtitle_for(key),
+          updated_at: updated_at_for(key),
+          currency: source.currency,
+          rows: build_rows(source.prices)
         }
       end
 
-      def build_file
-        path = LlmCostTracker.configuration.prices_file
-        return nil unless path && File.exist?(path)
-
-        prices = Pricing::Registry.file_prices(path)
-        return nil if prices.empty?
-
-        meta = Pricing::Registry.file_metadata(path)
-        {
-          label: "Custom file",
-          subtitle: path.to_s,
-          updated_at: meta["updated_at"] || Pricing::Lookup.prices_file_mtime_iso,
-          currency: meta["currency"] || Pricing::Lookup::DEFAULT_CURRENCY,
-          rows: build_rows(prices)
-        }
+      def subtitle_for(key)
+        case key
+        when :overrides then "config.pricing_overrides"
+        when :file then LlmCostTracker.configuration.prices_file.to_s
+        when :bundled then "ships with the gem"
+        end
       end
 
-      def build_bundled
-        prices = Pricing::Registry.builtin_prices
-        meta = Pricing::Registry.metadata
-        {
-          label: "Bundled",
-          subtitle: "ships with the gem",
-          updated_at: meta["updated_at"],
-          currency: meta["currency"] || Pricing::Lookup::DEFAULT_CURRENCY,
-          rows: build_rows(prices)
-        }
+      def updated_at_for(key)
+        case key
+        when :file
+          path = LlmCostTracker.configuration.prices_file
+          Pricing::Registry.file_metadata(path)["updated_at"] || Pricing::Registry.prices_file_mtime_iso
+        when :bundled
+          Pricing::Registry.metadata["updated_at"]
+        end
       end
 
       def build_rows(prices)

data/app/services/llm_cost_tracker/dashboard/setup_state.rb

@@ -1,65 +1,28 @@
 # frozen_string_literal: true
 
-require "llm_cost_tracker/ledger"
-
 module LlmCostTracker
   module Dashboard
     module SetupState
       SetupRequired = Data.define(:message, :details)
-      DOCS_HINT = "See docs/upgrading.md for the migration path."
-      MUTEX = Mutex.new
-
-      private_constant :MUTEX, :DOCS_HINT
 
       class << self
         def current
-          fingerprint = schema_fingerprint
+          return @current if defined?(@current)
 
-          MUTEX.synchronize do
-            if !defined?(@cache_fingerprint) || @cache_fingerprint != fingerprint
-              LlmCostTracker::Call.reset_column_information
-              @cached = compute
-              @cache_fingerprint = fingerprint
-            end
-          end
-          @cached
+          @current = compute
         end
 
         def reset!
-          MUTEX.synchronize do
-            remove_instance_variable(:@cached) if defined?(@cached)
-            remove_instance_variable(:@cache_fingerprint) if defined?(@cache_fingerprint)
-          end
+          remove_instance_variable(:@current) if defined?(@current)
         end
 
         private
 
-        SCHEMA_MIGRATIONS_TABLE = "schema_migrations"
-        private_constant :SCHEMA_MIGRATIONS_TABLE
-
-        def schema_fingerprint
-          connection = ActiveRecord::Base.connection
-          quoted = connection.quote_table_name(SCHEMA_MIGRATIONS_TABLE)
-          connection.query_value("SELECT MAX(version) FROM #{quoted}")
-        rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
-          nil
-        end
-
         def compute
           LlmCostTracker::Logging.debug("Dashboard::SetupState recomputing")
           return calls_table_missing unless LlmCostTracker::Call.table_exists?
 
-          core_drift = drift_in(schema_checks_for_current_config)
-          return core_drift if core_drift
-          return nil unless LlmCostTracker.reconciliation_enabled?
-
-          reconciliation_drift
-        end
-
-        def schema_checks_for_current_config
-          return LlmCostTracker::Ledger::Schema::CORE_SCHEMAS unless LlmCostTracker.configuration.cache_rollups
-
-          LlmCostTracker::Ledger::Schema::CORE_SCHEMAS + [LlmCostTracker::Ledger::Schema::CACHE_ROLLUPS_SCHEMA]
+          drift_in(LlmCostTracker::Ingestion.guards_for_current_config)
         end
 
         def drift_in(checks)
@@ -73,25 +36,6 @@ module LlmCostTracker
           nil
         end
 
-        def reconciliation_drift
-          connection = ActiveRecord::Base.connection
-          LlmCostTracker::Reconciliation::SCHEMA_TABLES.each do |schema, table|
-            unless connection.data_source_exists?(table)
-              return SetupRequired.new(
-                message: "The #{table} table is required when reconciliation is enabled.",
-                details: ["bin/rails generate llm_cost_tracker:reconciliation && bin/rails db:migrate"]
-              )
-            end
-
-            errors = schema.current_schema_errors
-            next if errors.empty?
-
-            message = "The #{table} table does not match the current LLM Cost Tracker schema."
-            return SetupRequired.new(message: message, details: errors)
-          end
-          nil
-        end
-
         def calls_table_missing
           SetupRequired.new(
             message: "The llm_cost_tracker_calls table is not available yet.",