llm_cost_tracker 0.10.0 → 0.11.0

data/app/views/llm_cost_tracker/tags/show.html.erb

@@ -1,150 +1,131 @@
+<% form_url = tag_path(params[:key]) %>
+
 <% if @value.present? %>
-  <section class="lct-panel lct-toolbar">
-    <div class="lct-toolbar-head">
-      <div>
-        <p class="lct-muted"><%= link_to "← All values for #{params[:key]}", tag_path(params[:key], current_query.except(:tag_value)) %></p>
-        <h2 class="lct-section-title">Tag: <code class="lct-code"><%= params[:key] %></code> = <code class="lct-code"><%= @value %></code></h2>
-      </div>
-    </div>
+  <p class="lct-breadcrumb-back"><%= link_to "← All values for #{params[:key]}", tag_path(params[:key], current_query.except(:tag_value)) %></p>
+  <h2 class="lct-page-title">Tag: <code class="lct-code-id"><%= params[:key] %></code> = <code class="lct-code-id"><%= @value %></code></h2>
 
-    <%= render "llm_cost_tracker/shared/filters",
-               path: tag_path(params[:key]),
-               fields: %i[from to provider model],
-               hidden_fields: { tag_value: @value },
-               reset_path: tag_path(params[:key], tag_value: @value) %>
-  </section>
+  <div class="lct-filter-row">
+    <%= render "llm_cost_tracker/shared/filter_pill_date", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
+    <%= render "llm_cost_tracker/shared/filter_pill_provider", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
+    <%= render "llm_cost_tracker/shared/filter_pill_model", path: form_url, extra_hidden: { tag_value: @value }, extra_except: [:tag_value] %>
+
+    <% if params[:provider].present? || params[:model].present? %>
+      <%= link_to "× Clear filters", tag_path(params[:key], current_query(provider: nil, model: nil, page: nil)), class: "lct-filter-clear" %>
+    <% end %>
+
+    <span class="lct-filter-row-meta"><%= number(@value_calls) %> call<%= "s" unless @value_calls == 1 %> · <%= money(@value_total_cost) %></span>
+  </div>
 
   <% if @value_calls.zero? %>
     <section class="lct-panel lct-empty">
       <h2 class="lct-state-title">No calls tagged with <%= params[:key] %>=<%= @value %></h2>
       <p class="lct-state-copy">No matching calls in the current slice.</p>
-      <div class="lct-state-actions">
-        <%= link_to "Back to values", tag_path(params[:key]), class: "lct-button lct-button-secondary" %>
-      </div>
     </section>
   <% else %>
-    <section class="lct-stat-grid lct-stat-grid-spaced">
-      <article class="lct-stat">
-        <p class="lct-stat-label">Total cost</p>
+    <div class="lct-stat-grid">
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Total cost</p></div>
         <p class="lct-stat-value"><%= money(@value_total_cost) %></p>
-        <p class="lct-stat-copy">Across <%= number(@value_calls) %> calls</p>
-      </article>
-
-      <article class="lct-stat">
-        <p class="lct-stat-label">Calls</p>
+        <p class="lct-stat-foot">Across <%= number(@value_calls) %> calls</p>
+      </div>
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Calls</p></div>
         <p class="lct-stat-value"><%= number(@value_calls) %></p>
-        <p class="lct-stat-copy">Tagged with <code class="lct-code"><%= @value %></code></p>
-      </article>
-
-      <article class="lct-stat">
-        <p class="lct-stat-label">Avg cost / call</p>
+        <p class="lct-stat-foot">Tagged with <code class="lct-code-id"><%= @value %></code></p>
+      </div>
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Avg cost / call</p></div>
         <p class="lct-stat-value"><%= money(@value_calls.positive? ? @value_total_cost / @value_calls : 0) %></p>
-        <p class="lct-stat-copy">Mean over the slice</p>
-      </article>
-    </section>
+      </div>
+    </div>
 
     <section class="lct-panel">
-      <div class="lct-section-head">
-        <div>
-          <h2 class="lct-section-title">Spend over time</h2>
-          <p class="lct-section-copy">Daily total cost for calls tagged <code class="lct-code"><%= params[:key] %>=<%= @value %></code>.</p>
-        </div>
-        <%= link_to "Calls", calls_path(calls_query_for_tag(key: @key, value: @value)), class: "lct-button lct-button-secondary lct-button-compact" %>
+      <div class="lct-panel-head">
+        <h2 class="lct-panel-title">Spend over time</h2>
+        <span class="lct-panel-meta"><%= link_to "View calls →", calls_path(calls_query_for_tag(key: @key, value: @value)) %></span>
       </div>
-
-      <%= render "llm_cost_tracker/shared/spend_chart", series: @value_points %>
+      <%= render "llm_cost_tracker/shared/spend_chart", series: @value_points, comparison_series: [] %>
     </section>
   <% end %>
+
 <% else %>
-<section class="lct-panel lct-toolbar">
-  <div class="lct-toolbar-head">
-    <div>
-      <p class="lct-muted"><%= link_to "← All tag keys", tags_path(current_query) %></p>
-      <h2 class="lct-section-title">Tag: <code class="lct-code"><%= params[:key] %></code></h2>
-    </div>
-  </div>
 
-  <%= render "llm_cost_tracker/shared/filters",
-             path: tag_path(params[:key]),
-             fields: %i[from to provider model],
-             reset_path: tag_path(params[:key]) %>
+  <p class="lct-breadcrumb-back"><%= link_to "← All tag keys", tags_path(current_query) %></p>
+  <h2 class="lct-page-title">Tag: <code class="lct-code-id"><%= params[:key] %></code></h2>
 
-  <%= render "llm_cost_tracker/shared/active_filters", chips: active_tag_filters, clear_path: tag_path(params[:key]) %>
+  <div class="lct-filter-row">
+    <%= render "llm_cost_tracker/shared/filter_pill_date", path: form_url %>
+    <%= render "llm_cost_tracker/shared/filter_pill_provider", path: form_url %>
+    <%= render "llm_cost_tracker/shared/filter_pill_model", path: form_url %>
 
-  <p class="lct-summary-row">
-    <span><strong><%= number(@breakdown.tagged_calls) %></strong> tagged calls</span>
-    <span><strong><%= percent(coverage_percent(@breakdown.tagged_calls, @breakdown.total_calls)) %></strong> coverage</span>
-    <span><strong><%= number(@breakdown.distinct_values) %></strong> distinct values</span>
-  </p>
+    <% if params[:provider].present? || params[:model].present? %>
+      <%= link_to "× Clear filters", tag_path(params[:key], current_query(provider: nil, model: nil, page: nil)), class: "lct-filter-clear" %>
+    <% end %>
 
-  <% if @breakdown.distinct_values > @breakdown.rows.size %>
-    <p class="lct-toolbar-note">Showing top <%= number(@breakdown.limit) %> values by spend.</p>
-  <% end %>
-</section>
+    <span class="lct-filter-row-meta"><%= number(@breakdown.tagged_calls) %> tagged call<%= "s" unless @breakdown.tagged_calls == 1 %> · <%= percent(coverage_percent(@breakdown.tagged_calls, @breakdown.total_calls)) %> coverage · <%= number(@breakdown.distinct_values) %> distinct value<%= "s" unless @breakdown.distinct_values == 1 %></span>
+  </div>
 
-<% if @breakdown.rows.empty? %>
-  <section class="lct-panel lct-empty">
-    <h2 class="lct-state-title">No calls tagged with <%= params[:key] %></h2>
-    <p class="lct-state-copy">Values for this key will appear here once matching calls carry the tag in the current slice.</p>
-    <div class="lct-state-actions">
-      <%= link_to "Clear filters", tag_path(params[:key]), class: "lct-button lct-button-secondary" %>
+  <% if @breakdown.rows.empty? %>
+    <section class="lct-panel lct-empty">
+      <h2 class="lct-state-title">No calls tagged with <%= params[:key] %></h2>
+      <p class="lct-state-copy">Values for this key will appear here once matching calls carry the tag in the current slice.</p>
+    </section>
+  <% else %>
+    <div class="lct-stat-grid">
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Tagged calls</p></div>
+        <p class="lct-stat-value"><%= number(@breakdown.tagged_calls) %></p>
+        <p class="lct-stat-foot">Rows that include <code class="lct-code-id"><%= params[:key] %></code></p>
+      </div>
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Coverage</p></div>
+        <p class="lct-stat-value"><%= percent(coverage_percent(@breakdown.tagged_calls, @breakdown.total_calls)) %></p>
+        <p class="lct-stat-foot"><%= number(@breakdown.total_calls) %> total calls in this slice</p>
+      </div>
+      <div class="lct-stat">
+        <div class="lct-stat-head"><p class="lct-stat-label">Distinct values</p></div>
+        <p class="lct-stat-value"><%= number(@breakdown.distinct_values) %></p>
+      </div>
     </div>
-  </section>
-<% else %>
-  <section class="lct-stat-grid lct-stat-grid-spaced">
-    <article class="lct-stat">
-      <p class="lct-stat-label">Tagged calls</p>
-      <p class="lct-stat-value"><%= number(@breakdown.tagged_calls) %></p>
-      <p class="lct-stat-copy">Rows that include <code class="lct-code"><%= params[:key] %></code></p>
-    </article>
-
-    <article class="lct-stat">
-      <p class="lct-stat-label">Coverage</p>
-      <p class="lct-stat-value"><%= percent(coverage_percent(@breakdown.tagged_calls, @breakdown.total_calls)) %></p>
-      <p class="lct-stat-copy"><%= number(@breakdown.total_calls) %> total calls in this slice</p>
-    </article>
 
-    <article class="lct-stat">
-      <p class="lct-stat-label">Distinct values</p>
-      <p class="lct-stat-value"><%= number(@breakdown.distinct_values) %></p>
-      <p class="lct-stat-copy">Unique values currently visible</p>
-    </article>
-  </section>
+    <% if @breakdown.distinct_values > @breakdown.rows.size %>
+      <div class="lct-alert lct-alert-info">
+        <span>Showing top <%= number(@breakdown.limit) %> values by spend.</span>
+      </div>
+    <% end %>
 
-  <section class="lct-panel">
-    <div class="lct-table-wrap">
-      <table class="lct-table lct-table-compact">
+    <section class="lct-panel">
+      <table class="lct-tbl">
         <thead>
           <tr>
-            <th>Value</th>
-            <th class="lct-num">Calls</th>
+            <%= sortable_header("Value", "value") %>
+            <%= sortable_header("Calls", "calls", num: true) %>
             <th class="lct-num">Share</th>
-            <th class="lct-num">Total cost</th>
-            <th class="lct-num">Avg cost / call</th>
+            <%= sortable_header("Total cost", "cost", num: true) %>
+            <%= sortable_header("Avg cost / call", "avg_cost", num: true) %>
             <th></th>
           </tr>
         </thead>
         <tbody>
           <% @breakdown.rows.each do |row| %>
             <tr>
-              <td><code class="lct-code"><%= row.value %></code></td>
+              <td><code class="lct-code-id"><%= row.value %></code></td>
               <td class="lct-num"><%= number(row.calls) %></td>
               <td class="lct-num"><%= percent(row.share_percent) %></td>
               <td class="lct-num"><%= money(row.total_cost) %></td>
               <td class="lct-num"><%= money(row.average_cost_per_call) %></td>
-              <td>
+              <td class="lct-num">
                 <% if row.value == "(untagged)" %>
-                  <span class="lct-muted">n/a</span>
+                  <span class="lct-num-muted">n/a</span>
                 <% else %>
-                  <%= link_to "Trend", tag_path(params[:key], current_query.merge(tag_value: row.value)), class: "lct-button lct-button-secondary lct-button-compact" %>
-                  <%= link_to "Calls", calls_path(calls_query_for_tag(key: params[:key], value: row.value)), class: "lct-button lct-button-secondary lct-button-compact" %>
+                  <%= link_to "Trend", tag_path(params[:key], current_query.merge(tag_value: row.value)), class: "lct-page-link" %>
+                  <%= link_to "Calls", calls_path(calls_query_for_tag(key: params[:key], value: row.value)), class: "lct-page-link" %>
                 <% end %>
               </td>
             </tr>
           <% end %>
         </tbody>
       </table>
-    </div>
-  </section>
-<% end %>
+    </section>
+  <% end %>
 <% end %>

data/config/routes.rb

@@ -6,6 +6,7 @@ LlmCostTracker::Engine.routes.draw do
   resources :models, only: :index
   resources :tags, only: %i[index show], param: :key, format: false
   get "data_quality", to: "data_quality#index", as: :data_quality
+  get "pricing", to: "pricing#index", as: :pricing
   get "reconciliation", to: "reconciliation#index", as: :reconciliation
   post "reconciliation/import", to: "reconciliation#trigger_import", as: :reconciliation_import
 

data/lib/llm_cost_tracker/budget.rb

@@ -112,8 +112,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/{parsers → capture}/sse.rb

@@ -4,7 +4,7 @@ require "active_support/core_ext/object/blank"
 require "json"
 
 module LlmCostTracker
-  module Parsers
+  module Capture
     module SSE
       DONE_MARKER = "[DONE]"
 

data/lib/llm_cost_tracker/capture/stream_collector.rb

@@ -102,7 +102,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,
@@ -129,7 +129,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,20 +141,6 @@ 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
         {

data/lib/llm_cost_tracker/capture/stream_tracker.rb

@@ -74,11 +74,7 @@ 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
+        raw_payload = event.try(:deep_to_h) || event.try(:to_h) || {}
         payload = normalize(raw_payload)
         type = event.try(:type) || payload["type"]
         @collector.event(payload, type: type&.to_s)

data/lib/llm_cost_tracker/configuration.rb

@@ -17,7 +17,8 @@ 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
+                           reconciliation_enabled].freeze
     ENUM_ATTRIBUTES = {
       budget_exceeded_behavior: [BUDGET_EXCEEDED_BEHAVIORS, :notify],
       unknown_pricing_behavior: [UNKNOWN_PRICING_BEHAVIORS, :warn],
@@ -35,10 +36,7 @@ module LlmCostTracker
       :redacted_tag_keys,
       :unknown_pricing_behavior,
       :openai_compatible_providers,
-      :reconciliation_importers,
-      :reconciliation_enabled,
-      :auto_enable_stream_usage,
-      :cache_rollups
+      :reconciliation_importers
     )
 
     def initialize
@@ -68,21 +66,6 @@ module LlmCostTracker
       @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

data/lib/llm_cost_tracker/doctor.rb

@@ -16,20 +16,82 @@ module LlmCostTracker
     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 = ["Setup", "Schema", "Data integrity", "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",
+      "provider invoices" => "Schema",
+      "provider invoice imports" => "Schema",
+      "cost drift" => "Data integrity",
+      "pricing snapshot drift" => "Data integrity",
+      "pricing snapshot audit" => "Data integrity",
+      "cost status" => "Data integrity",
+      "invoice reconciliation" => "Data integrity",
+      "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,10 +102,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,
+        *dependent_core_schema_checks,
         *reconciliation_schema_checks,
         CostDriftCheck.new.call,
         PricingSnapshotDriftCheck.new.call,
@@ -59,6 +118,13 @@ module LlmCostTracker
 
     private
 
+    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).call
+      end
+    end
+
     def reconciliation_schema_checks
       return [] unless LlmCostTracker.reconciliation_enabled?
 

data/lib/llm_cost_tracker/event.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "pricing"
+require_relative "pricing/mode"
 require_relative "billing/line_item"
 
 module LlmCostTracker
@@ -30,7 +30,7 @@ module LlmCostTracker
     end
 
     def self.build(**attributes)
-      pricing_mode = Pricing.normalize_mode(attributes[:pricing_mode])
+      pricing_mode = Pricing::Mode.normalize(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)

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)

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

@@ -8,6 +8,8 @@ class UpgradeLlmCostTrackerProviderInvoiceImportsProvider < ActiveRecord::Migrat
   NEW_INDEX = %i[source provider started_at].freeze
 
   def up
+    return unless table_exists?(TABLE)
+
     add_column TABLE, :provider, :string, null: false, default: "" unless column_exists?(TABLE, :provider)
     if postgresql?
       remove_index TABLE, column: OLD_INDEX, algorithm: :concurrently, if_exists: true
@@ -19,6 +21,8 @@ class UpgradeLlmCostTrackerProviderInvoiceImportsProvider < ActiveRecord::Migrat
   end
 
   def down
+    return unless table_exists?(TABLE)
+
     remove_index TABLE, column: NEW_INDEX, if_exists: true
     add_index TABLE, OLD_INDEX, if_not_exists: true
     remove_column TABLE, :provider if column_exists?(TABLE, :provider)

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

@@ -7,12 +7,14 @@ class UpgradeLlmCostTrackerProviderInvoicesMetadataIndex < ActiveRecord::Migrati
 
   def up
     return unless postgresql?
+    return unless table_exists?(TABLE)
 
     add_index TABLE, :metadata, using: :gin, algorithm: :concurrently, if_not_exists: true
   end
 
   def down
     return unless postgresql?
+    return unless table_exists?(TABLE)
 
     remove_index TABLE, column: :metadata, if_exists: true
   end

data/lib/llm_cost_tracker/ingestion/inbox.rb

@@ -38,7 +38,7 @@ module LlmCostTracker
             provider: payload.fetch(:provider),
             model: payload.fetch(:model),
             token_usage: token_usage,
-            pricing_mode: Pricing.normalize_mode(payload[:pricing_mode]),
+            pricing_mode: Pricing::Mode.normalize(payload[:pricing_mode]),
             cost: cost,
             tags: payload.fetch(:tags),
             latency_ms: payload[:latency_ms],

data/lib/llm_cost_tracker/integrations/anthropic.rb

@@ -2,6 +2,7 @@
 
 require_relative "base"
 require_relative "../billing/line_item"
+require_relative "../providers/anthropic/server_tools"
 require_relative "../providers/anthropic/tier_classification"
 
 module LlmCostTracker
@@ -64,27 +65,18 @@ module LlmCostTracker
           server_tool_use = object_value(usage, :server_tool_use)
           return [] unless server_tool_use
 
-          [
-            line_item_for_server_tool(server_tool_use, :web_search_request, :web_search_requests,
-                                      "usage.server_tool_use.web_search_requests"),
-            line_item_for_server_tool(server_tool_use, :web_fetch_request, :web_fetch_requests,
-                                      "usage.server_tool_use.web_fetch_requests"),
-            line_item_for_server_tool(server_tool_use, :code_execution_request, :code_execution_requests,
-                                      "usage.server_tool_use.code_execution_requests")
-          ].compact
-        end
+          Providers::Anthropic::ServerTools::LINE_ITEMS.filter_map do |component_key, count_key|
+            quantity = object_value(server_tool_use, count_key).to_i
+            next if quantity.zero?
 
-        def line_item_for_server_tool(server_tool_use, component_key, count_key, provider_field)
-          quantity = object_value(server_tool_use, count_key).to_i
-          return nil if quantity.zero?
-
-          Billing::LineItem.build(
-            component_key: component_key,
-            quantity: quantity,
-            cost_status: Billing::CostStatus::UNKNOWN,
-            pricing_basis: :provider_usage,
-            provider_field: provider_field
-          )
+            Billing::LineItem.build(
+              component_key: component_key,
+              quantity: quantity,
+              cost_status: Billing::CostStatus::UNKNOWN,
+              pricing_basis: :provider_usage,
+              provider_field: "usage.server_tool_use.#{count_key}"
+            )
+          end
         end
 
         def token_usage(usage:, input_tokens:, output_tokens:)
@@ -117,8 +109,8 @@ module LlmCostTracker
           service_tier = nil if tier.standard_equivalent_tier?(service_tier)
 
           modes = [
-            Pricing.normalize_mode(object_value(usage, :speed) || request[:speed]),
-            Pricing.normalize_mode(service_tier)
+            Pricing::Mode.normalize(object_value(usage, :speed) || request[:speed]),
+            Pricing::Mode.normalize(service_tier)
           ]
           geo = inference_geo(request: request, usage: usage).to_s.downcase
           modes << "data_residency" if tier.data_residency_geo?(geo)
@@ -141,20 +133,20 @@ module LlmCostTracker
           stream = yield
           track_stream(stream, collector: collector)
         end
+
+        def wrap_blocking_call(args, kwargs)
+          request = request_params(args, kwargs)
+          enforce_budget!(request: request)
+          started_at = LlmCostTracker::Timing.now_monotonic
+          message = yield
+          record_message(message, request: request, latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at))
+          message
+        end
       end
 
       module MessagesPatch
         def create(*args, **kwargs)
-          request = LlmCostTracker::Integrations::Anthropic.request_params(args, kwargs)
-          LlmCostTracker::Integrations::Anthropic.enforce_budget!(request: request)
-          started_at = LlmCostTracker::Timing.now_monotonic
-          message = super
-          LlmCostTracker::Integrations::Anthropic.record_message(
-            message,
-            request: request,
-            latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at)
-          )
-          message
+          LlmCostTracker::Integrations::Anthropic.wrap_blocking_call(args, kwargs) { super }
         end
 
         def stream(*args, **kwargs)