llm_cost_tracker 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f17f618b28473afa871c9961a443a34152f4de81f7026d676d62b7e2bd1396d8
-  data.tar.gz: d024b23f0ca6cd117afa5d10faa0a0b96374391a4741ea330b924b5091f665f7
+  metadata.gz: e84eab476358c65154ce99e1c1b95d91406094a1221e3724253b3a2efb471ed5
+  data.tar.gz: 8793c30b7cdbd161cc9ea4b242969f8c3ba61e164aa5779c84e33e4d5ac38db5
 SHA512:
-  metadata.gz: 0abf684c595b7bc84dfda26ffc62eaabc0c6d91d0b93f1065bf6e824c7867326b7978875d845d3df8be25bfa04ff9091150e0a4cac7f84d835ceaf2f1e2996bb
-  data.tar.gz: 5b9405bf332b2e9e1eae05f0e7d107d4bb76ea71a6602846a16198540f3e0f315f48dbb316bbda24812d4d66c56ba837a42bfe81aeea502238f09e1f0202c6b4
+  metadata.gz: b377e608cf26ae425ac6eda48213878b14d108aa559c56035279e83f0414370db21fc05f8115d27094a92beaa380959b50a21c46730f7cc4ee8b63f8db7f2ad8
+  data.tar.gz: b53b1587f4080f74140cc73854edd1d1916b66a6e8e4b520a33b4897a0d5b428798c9cd6f248e189628d5fd6f71460727306523de0ce7268ced2c0a183b9b5bd

data/CHANGELOG.md

@@ -2,7 +2,35 @@
 
 Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [SemVer](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.10.0] - 2026-05-17
+
+### Added
+
+- `budget_exceeded_behavior = :block_requests` now also blocks before send when an estimate of the call's input cost plus prior spend would cross the daily / monthly limit, or when the estimate alone crosses `per_call_budget`. `BudgetExceededError` and `on_budget_exceeded` payloads gain a `stage` field (`:pre_send` or `:post_spend`). Calls to models with no pricing match skip the pre-send check. See [Budgets](docs/budgets.md).
+- `bin/rails llm_cost_tracker:backfill_unknown_pricing` rake task recomputes cost, pricing snapshot, line-item costs, and rollup buckets for calls that landed with no pricing (e.g. a new model recorded before the next scraper refresh added its rates). The Data Quality dashboard's "Unknown pricing by model" panel points at this task. Idempotent — re-running only touches calls still missing a cost.
+- Azure OpenAI Service is captured out of the box across both Azure OpenAI (`*.openai.azure.com`) and Microsoft Foundry (`*.services.ai.azure.com`) hostnames, and on both the classic `/openai/deployments/{name}/{operation}` path and the v1 `/openai/v1/{operation}` path. OpenAI Ruby SDK calls made with either base URL also tag as `provider: "azure_openai"`. Pricing resolves to the matching `openai/<model>` entry; regional / Data Zone uplifts are configurable via `config.pricing_overrides` with the `azure_openai/<model>` prefix. See [Configuration → Azure OpenAI Service](docs/configuration.md#azure-openai-service).
+- `bin/rails generate llm_cost_tracker:upgrade_provider_invoice_imports_provider` writes the migration so two reconciliation importers sharing a `source` (e.g. `csv/openai` and `csv/anthropic`) no longer cross-pollute resume cursors.
+- `bin/rails generate llm_cost_tracker:upgrade_provider_invoices_metadata_index` writes a migration adding a GIN index on `llm_cost_tracker_provider_invoices.metadata` (PostgreSQL only) so reconciliation metadata lookups don't seq-scan on large invoice sets. No-op on MySQL.
+- A `prices_file` with `metadata.currency: "EUR"` (or any non-USD code) now flows through to the call's `pricing_snapshot.currency`, the `call_rollups.currency` bucket, every `call_line_items.currency` row (token and service-charge alike), and the header `cost.currency` instead of being hardcoded to USD. The bundled price snapshot and `pricing_overrides` still default to USD; mixed-currency line items continue to drop from the header total with a warning.
+
+### Fixed
+
+- OpenAI Chat Completions calls to the specialized search models (`gpt-4o-search-preview`, `gpt-4o-mini-search-preview`, `gpt-5-search-api`) record the per-call web-search fee as a line item at OpenAI's "Web search preview" rate (non-reasoning $25/1k, reasoning $10/1k). These models always search before responding, so the fee applies on every non-streaming call.
+- Async ingestion writes through its own dedicated connection pool instead of competing with request-handling threads, so tracking an LLM call from inside a caller transaction no longer deadlocks under burst load and the inbox row still persists when the caller transaction rolls back. Tune via `config.ingestion_pool_size` if your PG / PgBouncer budget is tight.
+- `mount LlmCostTracker::Engine => "/llm-costs"` works without adding `require "llm_cost_tracker/engine"` to `config/application.rb` — the engine is autoloaded.
+- Upgrade migrations for the call_rollups and call_tags indexes build concurrently on PostgreSQL, so the upgrade no longer takes a long table-write lock on installs with millions of rows. The rollups upgrade keeps pre-upgrade aggregates (bucketed under empty provider) instead of wiping them.
+- CSV exports stream in 500-row batches so peak memory stays flat at large export sizes while the user-selected sort order is preserved (`?sort=expensive`, `?sort=slow`, etc.).
+- `bin/rails generate llm_cost_tracker:install` skips `config/initializers/llm_cost_tracker.rb` when it already exists instead of prompting Thor's "overwrite?" dialog, so re-running the generator in CI no longer hangs waiting on stdin.
+- Async inbox entries no longer truncate on MySQL — large pricing snapshots and stack traces stay intact (MEDIUMTEXT instead of TEXT cap at 64 KB). PostgreSQL is unaffected.
+- Logs no longer warn `unknown pricing for model X` when the call has no token pricing but at least one service charge was successfully priced. Misleading false-positive is gone for Anthropic web-search-style calls on models missing from the token-pricing table.
+- `llm_cost_tracker:prune` rake task also prunes async inbox entries and finished provider invoice imports past the `DAYS` cutoff, so pending or quarantined rows no longer flush retroactively and old import-cursor rows don't linger forever.
+- Azure OpenAI deployments using `audio/speech`, `images/edits`, `images/variations`, `moderations`, or `responses` endpoints are now captured by the Faraday parser; previously only `chat/completions`, `completions`, `embeddings`, `audio/transcriptions`, `audio/translations`, and `images/generations` matched.
+- `prices:refresh` drops service-charge keys when a scraper stops emitting them, so stale charges no longer linger in the local price snapshot. Scrapers that don't parse a charges section (groq, gemini) preserve existing entries.
+
+### Changed
+
+- Schema: `llm_cost_tracker_provider_invoice_imports` gains a `provider` column and replaces the `(source, started_at)` index with `(source, provider, started_at)`. Existing installs run `bin/rails generate llm_cost_tracker:upgrade_provider_invoice_imports_provider && bin/rails db:migrate`.
+- BREAKING: `config.durable_ingestion = true/false` is replaced by `config.ingestion = :inline | :async` (default `:inline`). `config.durable_ingestion_pool_size` is renamed to `config.ingestion_pool_size`, and the install generator is now `bin/rails generate llm_cost_tracker:async_ingestion`. Update `config/initializers/llm_cost_tracker.rb` accordingly.
 
 ## [0.9.0] - 2026-05-12
 

data/README.md

@@ -39,7 +39,7 @@ LlmCostTracker.configure do |config|
 end
 ```
 
-Tag your calls — that's how you find out who burned the money:
+Tag your calls to attribute spend:
 
 ```ruby
 LlmCostTracker.with_tags(user_id: Current.user&.id, feature: "chat") do
@@ -74,6 +74,7 @@ The engine ships without authentication on purpose.
 | --- | --- |
 | OpenAI | Official SDK or Faraday |
 | Anthropic | Official SDK or Faraday |
+| Azure OpenAI | Faraday or official SDK (auto-detected on `*.openai.azure.com` and Foundry `*.services.ai.azure.com`, both deployments and `/openai/v1/...`) |
 | Google Gemini | Faraday |
 | RubyLLM | Provider layer |
 | `ruby-openai` | Faraday |

data/app/controllers/llm_cost_tracker/application_controller.rb

@@ -22,7 +22,7 @@ module LlmCostTracker
     private
 
     def ensure_current_schema
-      drift = LlmCostTracker::DashboardSetupState.current
+      drift = LlmCostTracker::Dashboard::SetupState.current
       return unless drift
 
       @setup_message = drift.message

data/app/controllers/llm_cost_tracker/calls_controller.rb

@@ -6,6 +6,7 @@ require "json"
 module LlmCostTracker
   class CallsController < ApplicationController
     CSV_EXPORT_LIMIT = 10_000
+    CSV_EXPORT_BATCH_SIZE = 500
     CSV_FORMULA_PREFIXES = ["=", "+", "-", "@", "\t", "\r"].freeze
     DEFAULT_ORDER = "tracked_at DESC, id DESC"
 
@@ -23,7 +24,7 @@ module LlmCostTracker
         end
         format.csv do
           response.headers["Cache-Control"] = "no-store"
-          send_data render_csv(ordered_scope.limit(CSV_EXPORT_LIMIT)),
+          send_data render_csv(ordered_scope),
                     type: "text/csv",
                     disposition: %(attachment; filename="llm_calls_#{Time.now.utc.strftime('%Y%m%d_%H%M%S')}.csv")
         end
@@ -31,7 +32,7 @@ module LlmCostTracker
     end
 
     def show
-      @call = LlmCostTracker::Call.find(params[:id])
+      @call = LlmCostTracker::Call.includes(:line_items, :tag_records).find(params[:id])
     end
 
     private
@@ -55,13 +56,24 @@ module LlmCostTracker
       fields = csv_fields
       CSV.generate do |csv|
         csv << fields.map(&:to_s)
-
-        relation.includes(:tag_records).each do |call|
+        each_export_batch(relation) do |call|
           csv << fields.map { |field| csv_value(field, call) }
         end
       end
     end
 
+    def each_export_batch(relation, &)
+      offset = 0
+      while offset < CSV_EXPORT_LIMIT
+        batch_size = [CSV_EXPORT_BATCH_SIZE, CSV_EXPORT_LIMIT - offset].min
+        batch = relation.limit(batch_size).offset(offset).preload(:tag_records).to_a
+        break if batch.empty?
+
+        batch.each(&)
+        offset += batch.size
+      end
+    end
+
     def csv_fields
       %i[tracked_at provider model] +
         TokenUsage.members +

data/app/helpers/llm_cost_tracker/application_helper.rb

@@ -38,7 +38,7 @@ module LlmCostTracker
     end
 
     def number(value)
-      number_with_delimiter(value.to_i)
+      number_with_delimiter(value)
     end
 
     def format_date(value)

data/app/models/llm_cost_tracker/provider_invoice_import.rb

@@ -8,17 +8,22 @@ module LlmCostTracker
     STATES = [STATE_RUNNING, STATE_COMPLETED, STATE_FAILED].freeze
 
     scope :for_source, ->(source) { where(source: source.to_s) }
+    scope :for_provider, ->(provider) { where(provider: provider.to_s) }
     scope :running, -> { where(state: STATE_RUNNING) }
     scope :completed, -> { where(state: STATE_COMPLETED) }
     scope :failed, -> { where(state: STATE_FAILED) }
     scope :latest, -> { order(started_at: :desc, id: :desc) }
 
-    def self.resume_cursor_for(source)
-      for_source(source).latest.limit(1).pick(:cursor)
+    def self.resume_cursor_for(source, provider: nil)
+      scope = for_source(source)
+      scope = scope.for_provider(provider) if provider
+      scope.latest.limit(1).pick(:cursor)
     end
 
-    def self.last_completed_window_for(source)
-      for_source(source).completed.latest.limit(1).pick(:window_start, :window_end)
+    def self.last_completed_window_for(source, provider: nil)
+      scope = for_source(source)
+      scope = scope.for_provider(provider) if provider
+      scope.completed.latest.limit(1).pick(:window_start, :window_end)
     end
   end
 end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "llm_cost_tracker/ledger/schema/calls"
+require "llm_cost_tracker/ledger/schema/call_line_items"
+require "llm_cost_tracker/ledger/schema/call_tags"
+require "llm_cost_tracker/ledger/schema/call_rollups"
+
+module LlmCostTracker
+  module Dashboard
+    module SetupState
+      SetupRequired = Data.define(:message, :details)
+      DOCS_HINT = "See docs/upgrading.md for the migration path."
+      MUTEX = Mutex.new
+
+      CORE_SCHEMA_CHECKS = [
+        [
+          LlmCostTracker::Ledger::Schema::Calls,
+          "The llm_cost_tracker_calls table does not match the current LLM Cost Tracker schema."
+        ],
+        [
+          LlmCostTracker::Ledger::Schema::CallLineItems,
+          "The llm_cost_tracker_call_line_items table does not match the current LLM Cost Tracker schema."
+        ],
+        [
+          LlmCostTracker::Ledger::Schema::CallTags,
+          "The llm_cost_tracker_call_tags table does not match the current LLM Cost Tracker schema."
+        ]
+      ].freeze
+
+      OPTIONAL_CALL_ROLLUPS_CHECK = [
+        LlmCostTracker::Ledger::Schema::CallRollups,
+        "The llm_cost_tracker_call_rollups table does not match the current LLM Cost Tracker schema."
+      ].freeze
+
+      private_constant :MUTEX, :CORE_SCHEMA_CHECKS, :OPTIONAL_CALL_ROLLUPS_CHECK, :DOCS_HINT
+
+      class << self
+        def current
+          return @cached if defined?(@cached)
+
+          MUTEX.synchronize do
+            @cached = compute unless defined?(@cached)
+          end
+          @cached
+        end
+
+        def reset!
+          MUTEX.synchronize do
+            remove_instance_variable(:@cached) if defined?(@cached)
+          end
+        end
+
+        private
+
+        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 CORE_SCHEMA_CHECKS unless LlmCostTracker.configuration.cache_rollups
+
+          CORE_SCHEMA_CHECKS + [OPTIONAL_CALL_ROLLUPS_CHECK]
+        end
+
+        def drift_in(checks)
+          checks.each do |schema, message|
+            errors = schema.current_schema_errors
+            next if errors.empty?
+
+            return SetupRequired.new(message: message, details: errors + [DOCS_HINT])
+          end
+          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: ["run bin/rails generate llm_cost_tracker:reconciliation && bin/rails db:migrate", DOCS_HINT]
+              )
+            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 + [DOCS_HINT])
+          end
+          nil
+        end
+
+        def calls_table_missing
+          SetupRequired.new(
+            message: "The llm_cost_tracker_calls table is not available yet.",
+            details: nil
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -113,7 +113,7 @@ end %>
   </div>
 </section>
 
-<% service_line_items = @call.line_items.where.not(unit: "token").order(:position).to_a %>
+<% service_line_items = @call.line_items.reject { |li| li.unit == "token" }.sort_by(&:position) %>
 <% if service_line_items.any? %>
   <section class="lct-panel">
     <h2 class="lct-section-title">Service Charges</h2>

data/app/views/llm_cost_tracker/data_quality/index.html.erb

@@ -300,7 +300,7 @@
       <div class="lct-section-head">
         <div>
           <h2 class="lct-section-title">Unknown pricing by model</h2>
-          <p class="lct-section-copy">These models have token counts but no configured rates, so cost stays unknown.</p>
+          <p class="lct-section-copy">These models have token counts but no configured rates, so cost stays unknown. After the next price refresh or a <code class="lct-code">pricing_overrides</code> update, run <code class="lct-code">bin/rails llm_cost_tracker:backfill_unknown_pricing</code> to recompute these calls.</p>
         </div>
         <%= link_to "Calls", calls_path(current_query(sort: "unknown_pricing")), class: "lct-button lct-button-secondary" %>
       </div>

data/lib/llm_cost_tracker/billing/cost_status.rb

@@ -10,36 +10,32 @@ module LlmCostTracker
       PARTIAL = "partial"
       UNKNOWN = "unknown"
 
-      class << self
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def call(token_usage:, usage_source:, token_cost:, service_line_items:, total_cost:,
-                 token_pricing_partial: false)
-          return UNKNOWN if usage_source == :unknown
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def self.call(token_usage:, usage_source:, token_cost:, service_line_items:, total_cost:,
+                    token_pricing_partial: false)
+        return UNKNOWN if usage_source == :unknown
 
-          token_billable = Components::TOKEN_PRICED.any? do |component|
-            token_usage.public_send(component.token_key).positive?
-          end
-          service_billable = false
-          service_priced = false
-          service_unpriced = false
-          service_line_items.each do |line_item|
-            next unless line_item.billable?
+        token_billable = token_usage.priced_quantities.any? { |_key, quantity| quantity.positive? }
+        service_billable = false
+        service_priced = false
+        service_unpriced = false
+        service_line_items.each do |line_item|
+          next unless line_item.billable?
 
-            service_billable = true
-            service_priced ||= line_item.priced?
-            service_unpriced ||= line_item.unpriced?
-            break if service_priced && service_unpriced
-          end
+          service_billable = true
+          service_priced ||= line_item.priced?
+          service_unpriced ||= line_item.unpriced?
+          break if service_priced && service_unpriced
+        end
 
-          priced = (token_billable && !token_cost.nil?) || service_priced || (!token_billable && !service_billable)
-          unpriced = (token_billable && (token_cost.nil? || token_pricing_partial)) || service_unpriced
-          return UNKNOWN if unpriced && !priced
-          return PARTIAL if unpriced
+        priced = (token_billable && !token_cost.nil?) || service_priced || (!token_billable && !service_billable)
+        unpriced = (token_billable && (token_cost.nil? || token_pricing_partial)) || service_unpriced
+        return UNKNOWN if unpriced && !priced
+        return PARTIAL if unpriced
 
-          total_cost.nil? || total_cost.zero? ? FREE : COMPLETE
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        total_cost.nil? || total_cost.zero? ? FREE : COMPLETE
       end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/llm_cost_tracker/billing/line_item.rb

@@ -30,28 +30,11 @@ module LlmCostTracker
 
     class LineItem
       USD = "USD"
-      OPTIONAL_ATTRIBUTES = %i[
-        pricing_basis
-        price_key
-        price_source
-        price_source_version
-        provider_field
-        provider_item_id
-      ].freeze
-      SYMBOL_ATTRIBUTES = %i[
-        kind
-        direction
-        modality
-        cache_state
-        unit
-        pricing_basis
-        price_source
-      ].freeze
 
       def self.build(attributes)
         attributes = attributes.to_h
         component = component_for(attributes)
-        normalized = {
+        new(
           kind: symbol_or_nil(attributes[:kind]) || component&.kind,
           direction: symbol_or_nil(attributes[:direction]) || component&.direction,
           modality: symbol_or_nil(attributes[:modality]) || component&.modality,
@@ -63,38 +46,30 @@ module LlmCostTracker
           cost: decimal_or_nil(attributes[:cost]),
           currency: attributes[:currency] || USD,
           cost_status: cost_status_for(attributes),
+          pricing_basis: symbol_or_nil(attributes[:pricing_basis]),
+          price_key: attributes[:price_key],
+          price_source: symbol_or_nil(attributes[:price_source]),
+          price_source_version: attributes[:price_source_version],
+          provider_field: attributes[:provider_field],
+          provider_item_id: attributes[:provider_item_id],
           details: attributes[:details] || {}
-        }.merge(optional_attributes_for(attributes))
-
-        new(**normalized)
+        )
       end
 
       def self.from_token_usage(token_usage)
         return [] unless token_usage
 
-        Components::TOKEN_PRICED.filter_map do |component|
-          quantity = token_usage.public_send(component.token_key)
+        token_usage.priced_quantities.filter_map do |key, quantity|
           next unless quantity.positive?
 
-          new(
+          component = Components::BY_KEY.fetch(key)
+          build(
             kind: component.kind,
             direction: component.direction,
             modality: component.modality,
             cache_state: component.cache_state,
-            quantity: BigDecimal(quantity.to_s),
-            unit: component.unit,
-            rate_amount: nil,
-            rate_quantity: BigDecimal("1"),
-            cost: nil,
-            currency: USD,
-            cost_status: CostStatus::UNKNOWN,
-            pricing_basis: nil,
-            price_key: nil,
-            price_source: nil,
-            price_source_version: nil,
-            provider_field: nil,
-            provider_item_id: nil,
-            details: {}
+            quantity: quantity,
+            unit: component.unit
           )
         end
       end
@@ -132,16 +107,7 @@ module LlmCostTracker
         decimal_or_nil(value) || BigDecimal("0")
       end
 
-      def self.optional_attributes_for(attributes)
-        OPTIONAL_ATTRIBUTES.to_h do |key|
-          value = attributes[key]
-          value = value.to_sym if value.is_a?(String) && SYMBOL_ATTRIBUTES.include?(key)
-          [key, value]
-        end
-      end
-
-      private_class_method :cost_status_for, :component_for, :symbol_or_nil, :decimal_or_nil, :decimal_or_zero,
-                           :optional_attributes_for
+      private_class_method :cost_status_for, :component_for, :symbol_or_nil, :decimal_or_nil, :decimal_or_zero
 
       def billable?
         quantity.positive?
@@ -163,7 +129,7 @@ module LlmCostTracker
         cost || BigDecimal("0")
       end
 
-      def apply_rate(rate)
+      def with_rate(rate)
         rate_amount = rate.fetch(:amount)
         rate_quantity = rate.fetch(:quantity)
         applied_cost = (quantity / rate_quantity) * rate_amount

data/lib/llm_cost_tracker/budget.rb

@@ -1,28 +1,34 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 require_relative "logging"
 require_relative "ledger"
+require_relative "pricing/estimator"
 
 module LlmCostTracker
   class Budget
     BUDGET_TYPE_TO_PERIOD = { monthly: :month, daily: :day }.freeze
 
     class << self
-      def enforce!
+      def enforce!(provider: nil, model: nil, request: nil)
         config = LlmCostTracker.configuration
         return unless config.budget_exceeded_behavior == :block_requests
 
+        estimate = estimate_cost(provider: provider, model: model, request: request)
+        raise_per_call_pre_send(estimate, config.per_call_budget) if config.per_call_budget && estimate.positive?
+
         budgets = { monthly: config.monthly_budget, daily: config.daily_budget }.compact
         return if budgets.empty?
 
         totals = totals_for(budgets.keys, time: Time.now.utc)
 
         budgets.each do |budget_type, budget|
-          total = totals.fetch(budget_type)
+          total = totals.fetch(budget_type) + estimate
           next unless total >= budget
 
           raise BudgetExceededError.new(**budget_payload(
-            budget_type: budget_type, total: total, budget: budget, last_event: nil
+            budget_type: budget_type, total: total, budget: budget, last_event: nil, stage: :pre_send
           ))
         end
       end
@@ -44,6 +50,20 @@ module LlmCostTracker
 
       private
 
+      def estimate_cost(provider:, model:, request:)
+        return BigDecimal("0") unless provider && model && request
+
+        Pricing::Estimator.call(provider: provider, model: model, request: request) || BigDecimal("0")
+      end
+
+      def raise_per_call_pre_send(estimate, budget)
+        return unless estimate >= budget
+
+        raise BudgetExceededError.new(**budget_payload(
+          budget_type: :per_call, total: estimate, budget: budget, last_event: nil, stage: :pre_send
+        ))
+      end
+
       def check_per_call_budget(event, config)
         budget = config.per_call_budget
         return unless budget
@@ -70,7 +90,8 @@ module LlmCostTracker
           budget_type: budget_type,
           total: total,
           budget: budget,
-          last_event: last_event
+          last_event: last_event,
+          stage: :post_spend
         )
 
         if notify_exceeded?(config, budget_type: budget_type, total: total, budget: budget, last_event: last_event)
@@ -79,12 +100,13 @@ module LlmCostTracker
         raise BudgetExceededError.new(**payload) if %i[raise block_requests].include?(config.budget_exceeded_behavior)
       end
 
-      def budget_payload(budget_type:, total:, budget:, last_event:)
+      def budget_payload(budget_type:, total:, budget:, last_event:, stage:)
         {
           budget_type: budget_type,
           total: total,
           budget: budget,
-          last_event: last_event
+          last_event: last_event,
+          stage: stage
         }
       end