floe-guard 0.3.0 → 0.5.0

package/dist/index.d.cts

@@ -68,7 +68,8 @@ declare namespace pricing {
  * One priced spend event in the guard's per-call ledger.
  *
  * Every {@link BudgetGuard.record} / {@link BudgetGuard.settle} /
- * {@link BudgetGuard.recordTool} that accrues spend appends exactly one event, so
+ * {@link BudgetGuard.recordTool} / {@link BudgetGuard.settleTool} that accrues
+ * spend appends exactly one event, so
  * the ledger's costs sum to `spentUsd` (unless a `maxLogEvents` ring buffer has
  * evicted old events). The schema is identical in the Python
  * package (`SpendEvent` in `src/floe_guard/guard.py`) and
@@ -149,13 +150,26 @@ declare class BudgetGuard {
     failClosed: boolean;
     nearLimitBps: number;
     private readonly onBlock;
-    /** Cost of the most recent priced call, used to predict the next one. */
-    private lastCost;
+    /**
+     * Costs of the most recent priced LLM call and tool call, tracked
+     * SEPARATELY: the default next-call prediction is the max of the two, so a
+     * cheap tool call can't shrink the estimate right before an expensive LLM
+     * call (or vice versa) — conservative beats one-call-too-late.
+     */
+    private lastLlmCost;
+    private lastToolCost;
     /** USD held for in-flight calls (reserved, not yet settled). Counts toward the ceiling. */
     private reserved;
     /** Per-call ledger, oldest first; a ring buffer when maxLogEvents is set. */
     private readonly spendEvents;
     private readonly maxLogEvents?;
+    /**
+     * Per-tool running totals (settleTool/recordTool) — the tool side of the one
+     * shared ceiling, exposed via the toolCosts getter. null-prototype: tool
+     * names are caller-supplied strings, so a "__proto__" name is stored as
+     * plain data instead of mutating the object's prototype.
+     */
+    private readonly toolCostTotals;
     /**
      * @param limitUsd the spend ceiling, in USD. `0` blocks the very first call.
      */
@@ -164,7 +178,8 @@ declare class BudgetGuard {
      * Throw {@link BudgetExceeded} if the next call would cross the ceiling.
      *
      * Call this immediately before each LLM request. The "next call" is estimated
-     * from the last recorded call's cost (override with `estimatedNextCost`); the
+     * conservatively as the costlier of the last LLM call and the last tool call
+     * (override with `estimatedNextCost`); the
      * first call is always allowed unless the ceiling is already met. In-flight
      * reservations count toward the total, so this stays correct alongside
      * {@link BudgetGuard.reserve}.
@@ -181,7 +196,8 @@ declare class BudgetGuard {
      * the same stale total. Throws {@link BudgetExceeded} (without reserving) if
      * the reservation would cross the ceiling. Returns the reservation handle to
      * pass to {@link BudgetGuard.settle} (or {@link BudgetGuard.release} on error).
-     * `estimatedCost` defaults to the last call's cost.
+     * `estimatedCost` defaults to the costlier of the last LLM call and the last
+     * tool call.
      */
     reserve(estimatedCost?: number): number;
     /**
@@ -209,16 +225,49 @@ declare class BudgetGuard {
         price?: ManualPrice;
         label?: string;
     }): number;
+    /**
+     * Atomically check the ceiling AND hold a tool call's cost in flight.
+     *
+     * The tool-spend counterpart of {@link BudgetGuard.reserve} — and STRONGER
+     * than the LLM path, because a paid tool's price is usually known exactly
+     * before the call, so the pre-call hard-stop is precise rather than
+     * estimated:
+     *
+     *     const handle = guard.reserveTool(0.02);   // throws BEFORE Apollo runs
+     *     const result = await apollo.peopleLookup(...);
+     *     guard.settleTool("apollo.people_lookup", 0.02, { reserved: handle });
+     *
+     * Throws {@link BudgetExceeded} (without reserving) if the call would cross
+     * the ceiling. The estimate is required — tools have no last-cost prediction
+     * worth falling back to. Pass the returned handle to
+     * {@link BudgetGuard.settleTool}, or {@link BudgetGuard.release} on failure.
+     */
+    reserveTool(estimatedCost: number): number;
+    /**
+     * Release a reservation and record a tool call's actual cost.
+     *
+     * `recordTool` is `settleTool` with no reservation. The caller supplies the
+     * cost — tools have no token usage to price. Accrues into the same
+     * `spentUsd` ceiling as tokens, tallies the per-tool total
+     * ({@link BudgetGuard.toolCosts}), updates the tool side of the next-call
+     * estimate (tracked separately from the LLM side; the default prediction is
+     * the max of the two, so a tool-hammering loop's plain `check()` stops
+     * BEFORE the crossing call without a cheap tool shrinking the LLM
+     * prediction), and appends
+     * a `kind: "tool"` {@link SpendEvent} to {@link BudgetGuard.spendLog}.
+     * Returns `costUsd`.
+     */
+    settleTool(tool: string, costUsd: number, options?: {
+        reserved?: number;
+        label?: string;
+    }): number;
     /**
      * Accrue a non-LLM cost (a paid tool/API call) against the same ceiling.
      *
-     * Tools with direct dollar costs — search APIs, scrapers, sandboxes — spend the
-     * same budget the LLM calls do; `recordTool` folds them into `spentUsd` (so
-     * `check()` / `reserve()` see them) and appends a `kind: "tool"`
-     * {@link SpendEvent} to {@link BudgetGuard.spendLog}. The caller supplies the
-     * cost: tools have no token usage to price. Deliberately does NOT update the
-     * next-call estimate — that predicts the next *LLM* call, and a tool's price
-     * would skew it. Returns `costUsd`.
+     * Post-hoc accrual for costs only known after the call (metered APIs); when
+     * the price is known up front, {@link BudgetGuard.reserveTool} /
+     * {@link BudgetGuard.settleTool} give the stronger pre-call hard-stop. See
+     * `settleTool` for the full contract. Returns `costUsd`.
      */
     recordTool(tool: string, costUsd: number, options?: {
         label?: string;
@@ -230,10 +279,17 @@ declare class BudgetGuard {
     release(reserved: number): void;
     /** USD left before the ceiling, net of in-flight reservations (never negative). */
     get remainingUsd(): number;
+    /**
+     * Per-tool running USD totals, keyed by the name given to `settleTool()` /
+     * `recordTool()` — e.g. `{"apollo.people_lookup": 0.42, "exa.search": 0.11}`.
+     * Makes the token/tool split of the one shared ceiling inspectable
+     * (`spentUsd - sum of toolCosts` is the token side). Returns a snapshot copy.
+     */
+    get toolCosts(): Record<string, number>;
     /**
      * The per-call spend ledger, oldest first — one {@link SpendEvent} per priced
-     * `record()` / `settle()` / `recordTool()`. Returns a snapshot copy: mutating
-     * it cannot corrupt the ledger.
+     * `record()` / `settle()` / `recordTool()` / `settleTool()`. Returns a
+     * snapshot copy: mutating it cannot corrupt the ledger.
      */
     get spendLog(): SpendEvent[];
     /**
@@ -247,6 +303,25 @@ declare class BudgetGuard {
      * Python `2.5e-06`.) Empty ledger yields `""`.
      */
     exportLog(): string;
+    /**
+     * The default next-call prediction when the caller supplies no estimate.
+     * Conservative: the costlier of the last LLM call and the last tool call — a
+     * mixed loop predicts the pricier kind, which at worst blocks one call early
+     * (fail-closed) rather than letting a crossing call through because the LAST
+     * event happened to be cheap.
+     */
+    private defaultEstimate;
+    /**
+     * Subtract a settled/released hold from the in-flight tally. A handle larger
+     * than EVERYTHING currently held cannot have come from a matching
+     * `reserve()` — throwing beats silently clamping, which would free OTHER
+     * callers' holds and fail the ceiling open. The epsilon absorbs float dust
+     * from accumulating and draining many holds; per-caller over-release (a
+     * handle within the total but larger than the caller's own hold) is
+     * undetectable without per-handle tracking and remains the caller's
+     * responsibility.
+     */
+    private consumeReservation;
     private appendEvent;
     /**
      * Context-aware spend advisory for this budget — see {@link BudgetAdvisory}.
@@ -258,6 +333,77 @@ declare class BudgetGuard {
     advisory(): BudgetAdvisory;
 }
 
+/**
+ * LatencyBudget — a cumulative tool-chain deadline, sibling to BudgetGuard.
+ *
+ * BudgetGuard stops an agent before its next call crosses a USD ceiling;
+ * LatencyBudget stops it before the next call would blow an end-user SLA:
+ *
+ * ```ts
+ * const deadline = new LatencyBudget(5000);
+ * ...
+ * deadline.check(800);                       // throws DeadlineExceeded when projected over
+ * if (deadline.advisory().nearDeadline) useFasterModel();
+ * router.pick({ maxLatencyMs: deadline.remainingMs });
+ * ```
+ *
+ * Design notes (mirroring `src/floe_guard/latency.py`):
+ * - **Monotonic clock** — `performance.now()`, never wall time.
+ * - **Cooperative, not preemptive** — the guard provides the deadline signal;
+ *   aborting a stalled in-flight call is the framework's job (AbortSignal).
+ *   `check()` prevents the NEXT call from starting.
+ * - **Advisory symmetry** — `nearDeadline` / `usedBps` / `remainingMs` are the
+ *   latency twin of BudgetGuard's `nearLimit` / `usedBps` / `remainingUsd`.
+ * - **In-process scope** — one instance per request/run; distributed latency
+ *   tracking is out of scope.
+ */
+/** A context-aware deadline signal — the latency twin of {@link BudgetAdvisory}.
+ *  Soft by design; the hard-stop is {@link LatencyBudget.check}. */
+interface LatencyAdvisory {
+    nearDeadline: boolean;
+    /** SLA consumed, basis points 0..10000 (8500 = 85%). */
+    usedBps: number;
+    remainingMs: number;
+    slaMs: number;
+    elapsedMs: number;
+}
+interface LatencyBudgetOptions {
+    /**
+     * Utilization (basis points, 0..10000) at which {@link LatencyBudget.advisory}
+     * flags `nearDeadline` so an agent can downshift to a faster path before the
+     * wall. Default 8000 (80%), matching BudgetGuard's `nearLimitBps`.
+     */
+    nearDeadlineBps?: number;
+    /** Invoked with `(elapsedMs, slaMs)` right before {@link DeadlineExceeded} is thrown. */
+    onBlock?: (elapsedMs: number, slaMs: number) => void;
+    /** Milliseconds-returning monotonic clock, injectable for tests. Defaults to `performance.now`. */
+    clock?: () => number;
+}
+declare class LatencyBudget {
+    readonly slaMs: number;
+    readonly nearDeadlineBps: number;
+    private readonly onBlock?;
+    private readonly clock;
+    private readonly startedAt;
+    /** The budget starts counting at construction — build it when the request
+     *  (and its SLA) starts. */
+    constructor(slaMs: number, options?: LatencyBudgetOptions);
+    /** Milliseconds since construction (monotonic). */
+    get elapsedMs(): number;
+    /** Milliseconds left before the SLA, floored at 0 — the readable signal a
+     *  router uses to pick a faster fallback or truncate work mid-chain. */
+    get remainingMs(): number;
+    /**
+     * Throw {@link DeadlineExceeded} when the projected elapsed time (now +
+     * `expectedMs` for the upcoming call) would blow the SLA. Call it
+     * immediately before each tool/model call; pass 0 to only gate on time
+     * already spent.
+     */
+    check(expectedMs?: number): void;
+    /** The soft near-deadline signal — symmetric to `BudgetGuard.advisory()`. */
+    advisory(): LatencyAdvisory;
+}
+
 /**
  * Exceptions for floe-guard.
  *
@@ -293,6 +439,11 @@ declare class UnpriceableModelError extends FloeGuardError {
     readonly model: string;
     constructor(model: string);
 }
+declare class DeadlineExceeded extends FloeGuardError {
+    readonly elapsedMs: number;
+    readonly slaMs: number;
+    constructor(elapsedMs: number, slaMs: number);
+}
 
 /**
  * Vercel AI SDK middleware that enforces a {@link BudgetGuard} in the call path.
@@ -363,4 +514,4 @@ interface BudgetGuardMiddleware {
  */
 declare function budgetGuardMiddleware(guard: BudgetGuard): BudgetGuardMiddleware;
 
-export { type BudgetAdvisory, BudgetExceeded, BudgetGuard, type BudgetGuardMiddleware, type BudgetGuardOptions, FloeGuardError, type ManualPrice, type PricedModel, type SpendEvent, UnpriceableModelError, budgetGuardMiddleware, priceTokens, pricing, resolvePrice };
+export { type BudgetAdvisory, BudgetExceeded, BudgetGuard, type BudgetGuardMiddleware, type BudgetGuardOptions, DeadlineExceeded, FloeGuardError, type LatencyAdvisory, LatencyBudget, type LatencyBudgetOptions, type ManualPrice, type PricedModel, type SpendEvent, UnpriceableModelError, budgetGuardMiddleware, priceTokens, pricing, resolvePrice };

package/dist/index.d.ts

@@ -68,7 +68,8 @@ declare namespace pricing {
  * One priced spend event in the guard's per-call ledger.
  *
  * Every {@link BudgetGuard.record} / {@link BudgetGuard.settle} /
- * {@link BudgetGuard.recordTool} that accrues spend appends exactly one event, so
+ * {@link BudgetGuard.recordTool} / {@link BudgetGuard.settleTool} that accrues
+ * spend appends exactly one event, so
  * the ledger's costs sum to `spentUsd` (unless a `maxLogEvents` ring buffer has
  * evicted old events). The schema is identical in the Python
  * package (`SpendEvent` in `src/floe_guard/guard.py`) and
@@ -149,13 +150,26 @@ declare class BudgetGuard {
     failClosed: boolean;
     nearLimitBps: number;
     private readonly onBlock;
-    /** Cost of the most recent priced call, used to predict the next one. */
-    private lastCost;
+    /**
+     * Costs of the most recent priced LLM call and tool call, tracked
+     * SEPARATELY: the default next-call prediction is the max of the two, so a
+     * cheap tool call can't shrink the estimate right before an expensive LLM
+     * call (or vice versa) — conservative beats one-call-too-late.
+     */
+    private lastLlmCost;
+    private lastToolCost;
     /** USD held for in-flight calls (reserved, not yet settled). Counts toward the ceiling. */
     private reserved;
     /** Per-call ledger, oldest first; a ring buffer when maxLogEvents is set. */
     private readonly spendEvents;
     private readonly maxLogEvents?;
+    /**
+     * Per-tool running totals (settleTool/recordTool) — the tool side of the one
+     * shared ceiling, exposed via the toolCosts getter. null-prototype: tool
+     * names are caller-supplied strings, so a "__proto__" name is stored as
+     * plain data instead of mutating the object's prototype.
+     */
+    private readonly toolCostTotals;
     /**
      * @param limitUsd the spend ceiling, in USD. `0` blocks the very first call.
      */
@@ -164,7 +178,8 @@ declare class BudgetGuard {
      * Throw {@link BudgetExceeded} if the next call would cross the ceiling.
      *
      * Call this immediately before each LLM request. The "next call" is estimated
-     * from the last recorded call's cost (override with `estimatedNextCost`); the
+     * conservatively as the costlier of the last LLM call and the last tool call
+     * (override with `estimatedNextCost`); the
      * first call is always allowed unless the ceiling is already met. In-flight
      * reservations count toward the total, so this stays correct alongside
      * {@link BudgetGuard.reserve}.
@@ -181,7 +196,8 @@ declare class BudgetGuard {
      * the same stale total. Throws {@link BudgetExceeded} (without reserving) if
      * the reservation would cross the ceiling. Returns the reservation handle to
      * pass to {@link BudgetGuard.settle} (or {@link BudgetGuard.release} on error).
-     * `estimatedCost` defaults to the last call's cost.
+     * `estimatedCost` defaults to the costlier of the last LLM call and the last
+     * tool call.
      */
     reserve(estimatedCost?: number): number;
     /**
@@ -209,16 +225,49 @@ declare class BudgetGuard {
         price?: ManualPrice;
         label?: string;
     }): number;
+    /**
+     * Atomically check the ceiling AND hold a tool call's cost in flight.
+     *
+     * The tool-spend counterpart of {@link BudgetGuard.reserve} — and STRONGER
+     * than the LLM path, because a paid tool's price is usually known exactly
+     * before the call, so the pre-call hard-stop is precise rather than
+     * estimated:
+     *
+     *     const handle = guard.reserveTool(0.02);   // throws BEFORE Apollo runs
+     *     const result = await apollo.peopleLookup(...);
+     *     guard.settleTool("apollo.people_lookup", 0.02, { reserved: handle });
+     *
+     * Throws {@link BudgetExceeded} (without reserving) if the call would cross
+     * the ceiling. The estimate is required — tools have no last-cost prediction
+     * worth falling back to. Pass the returned handle to
+     * {@link BudgetGuard.settleTool}, or {@link BudgetGuard.release} on failure.
+     */
+    reserveTool(estimatedCost: number): number;
+    /**
+     * Release a reservation and record a tool call's actual cost.
+     *
+     * `recordTool` is `settleTool` with no reservation. The caller supplies the
+     * cost — tools have no token usage to price. Accrues into the same
+     * `spentUsd` ceiling as tokens, tallies the per-tool total
+     * ({@link BudgetGuard.toolCosts}), updates the tool side of the next-call
+     * estimate (tracked separately from the LLM side; the default prediction is
+     * the max of the two, so a tool-hammering loop's plain `check()` stops
+     * BEFORE the crossing call without a cheap tool shrinking the LLM
+     * prediction), and appends
+     * a `kind: "tool"` {@link SpendEvent} to {@link BudgetGuard.spendLog}.
+     * Returns `costUsd`.
+     */
+    settleTool(tool: string, costUsd: number, options?: {
+        reserved?: number;
+        label?: string;
+    }): number;
     /**
      * Accrue a non-LLM cost (a paid tool/API call) against the same ceiling.
      *
-     * Tools with direct dollar costs — search APIs, scrapers, sandboxes — spend the
-     * same budget the LLM calls do; `recordTool` folds them into `spentUsd` (so
-     * `check()` / `reserve()` see them) and appends a `kind: "tool"`
-     * {@link SpendEvent} to {@link BudgetGuard.spendLog}. The caller supplies the
-     * cost: tools have no token usage to price. Deliberately does NOT update the
-     * next-call estimate — that predicts the next *LLM* call, and a tool's price
-     * would skew it. Returns `costUsd`.
+     * Post-hoc accrual for costs only known after the call (metered APIs); when
+     * the price is known up front, {@link BudgetGuard.reserveTool} /
+     * {@link BudgetGuard.settleTool} give the stronger pre-call hard-stop. See
+     * `settleTool` for the full contract. Returns `costUsd`.
      */
     recordTool(tool: string, costUsd: number, options?: {
         label?: string;
@@ -230,10 +279,17 @@ declare class BudgetGuard {
     release(reserved: number): void;
     /** USD left before the ceiling, net of in-flight reservations (never negative). */
     get remainingUsd(): number;
+    /**
+     * Per-tool running USD totals, keyed by the name given to `settleTool()` /
+     * `recordTool()` — e.g. `{"apollo.people_lookup": 0.42, "exa.search": 0.11}`.
+     * Makes the token/tool split of the one shared ceiling inspectable
+     * (`spentUsd - sum of toolCosts` is the token side). Returns a snapshot copy.
+     */
+    get toolCosts(): Record<string, number>;
     /**
      * The per-call spend ledger, oldest first — one {@link SpendEvent} per priced
-     * `record()` / `settle()` / `recordTool()`. Returns a snapshot copy: mutating
-     * it cannot corrupt the ledger.
+     * `record()` / `settle()` / `recordTool()` / `settleTool()`. Returns a
+     * snapshot copy: mutating it cannot corrupt the ledger.
      */
     get spendLog(): SpendEvent[];
     /**
@@ -247,6 +303,25 @@ declare class BudgetGuard {
      * Python `2.5e-06`.) Empty ledger yields `""`.
      */
     exportLog(): string;
+    /**
+     * The default next-call prediction when the caller supplies no estimate.
+     * Conservative: the costlier of the last LLM call and the last tool call — a
+     * mixed loop predicts the pricier kind, which at worst blocks one call early
+     * (fail-closed) rather than letting a crossing call through because the LAST
+     * event happened to be cheap.
+     */
+    private defaultEstimate;
+    /**
+     * Subtract a settled/released hold from the in-flight tally. A handle larger
+     * than EVERYTHING currently held cannot have come from a matching
+     * `reserve()` — throwing beats silently clamping, which would free OTHER
+     * callers' holds and fail the ceiling open. The epsilon absorbs float dust
+     * from accumulating and draining many holds; per-caller over-release (a
+     * handle within the total but larger than the caller's own hold) is
+     * undetectable without per-handle tracking and remains the caller's
+     * responsibility.
+     */
+    private consumeReservation;
     private appendEvent;
     /**
      * Context-aware spend advisory for this budget — see {@link BudgetAdvisory}.
@@ -258,6 +333,77 @@ declare class BudgetGuard {
     advisory(): BudgetAdvisory;
 }
 
+/**
+ * LatencyBudget — a cumulative tool-chain deadline, sibling to BudgetGuard.
+ *
+ * BudgetGuard stops an agent before its next call crosses a USD ceiling;
+ * LatencyBudget stops it before the next call would blow an end-user SLA:
+ *
+ * ```ts
+ * const deadline = new LatencyBudget(5000);
+ * ...
+ * deadline.check(800);                       // throws DeadlineExceeded when projected over
+ * if (deadline.advisory().nearDeadline) useFasterModel();
+ * router.pick({ maxLatencyMs: deadline.remainingMs });
+ * ```
+ *
+ * Design notes (mirroring `src/floe_guard/latency.py`):
+ * - **Monotonic clock** — `performance.now()`, never wall time.
+ * - **Cooperative, not preemptive** — the guard provides the deadline signal;
+ *   aborting a stalled in-flight call is the framework's job (AbortSignal).
+ *   `check()` prevents the NEXT call from starting.
+ * - **Advisory symmetry** — `nearDeadline` / `usedBps` / `remainingMs` are the
+ *   latency twin of BudgetGuard's `nearLimit` / `usedBps` / `remainingUsd`.
+ * - **In-process scope** — one instance per request/run; distributed latency
+ *   tracking is out of scope.
+ */
+/** A context-aware deadline signal — the latency twin of {@link BudgetAdvisory}.
+ *  Soft by design; the hard-stop is {@link LatencyBudget.check}. */
+interface LatencyAdvisory {
+    nearDeadline: boolean;
+    /** SLA consumed, basis points 0..10000 (8500 = 85%). */
+    usedBps: number;
+    remainingMs: number;
+    slaMs: number;
+    elapsedMs: number;
+}
+interface LatencyBudgetOptions {
+    /**
+     * Utilization (basis points, 0..10000) at which {@link LatencyBudget.advisory}
+     * flags `nearDeadline` so an agent can downshift to a faster path before the
+     * wall. Default 8000 (80%), matching BudgetGuard's `nearLimitBps`.
+     */
+    nearDeadlineBps?: number;
+    /** Invoked with `(elapsedMs, slaMs)` right before {@link DeadlineExceeded} is thrown. */
+    onBlock?: (elapsedMs: number, slaMs: number) => void;
+    /** Milliseconds-returning monotonic clock, injectable for tests. Defaults to `performance.now`. */
+    clock?: () => number;
+}
+declare class LatencyBudget {
+    readonly slaMs: number;
+    readonly nearDeadlineBps: number;
+    private readonly onBlock?;
+    private readonly clock;
+    private readonly startedAt;
+    /** The budget starts counting at construction — build it when the request
+     *  (and its SLA) starts. */
+    constructor(slaMs: number, options?: LatencyBudgetOptions);
+    /** Milliseconds since construction (monotonic). */
+    get elapsedMs(): number;
+    /** Milliseconds left before the SLA, floored at 0 — the readable signal a
+     *  router uses to pick a faster fallback or truncate work mid-chain. */
+    get remainingMs(): number;
+    /**
+     * Throw {@link DeadlineExceeded} when the projected elapsed time (now +
+     * `expectedMs` for the upcoming call) would blow the SLA. Call it
+     * immediately before each tool/model call; pass 0 to only gate on time
+     * already spent.
+     */
+    check(expectedMs?: number): void;
+    /** The soft near-deadline signal — symmetric to `BudgetGuard.advisory()`. */
+    advisory(): LatencyAdvisory;
+}
+
 /**
  * Exceptions for floe-guard.
  *
@@ -293,6 +439,11 @@ declare class UnpriceableModelError extends FloeGuardError {
     readonly model: string;
     constructor(model: string);
 }
+declare class DeadlineExceeded extends FloeGuardError {
+    readonly elapsedMs: number;
+    readonly slaMs: number;
+    constructor(elapsedMs: number, slaMs: number);
+}
 
 /**
  * Vercel AI SDK middleware that enforces a {@link BudgetGuard} in the call path.
@@ -363,4 +514,4 @@ interface BudgetGuardMiddleware {
  */
 declare function budgetGuardMiddleware(guard: BudgetGuard): BudgetGuardMiddleware;
 
-export { type BudgetAdvisory, BudgetExceeded, BudgetGuard, type BudgetGuardMiddleware, type BudgetGuardOptions, FloeGuardError, type ManualPrice, type PricedModel, type SpendEvent, UnpriceableModelError, budgetGuardMiddleware, priceTokens, pricing, resolvePrice };
+export { type BudgetAdvisory, BudgetExceeded, BudgetGuard, type BudgetGuardMiddleware, type BudgetGuardOptions, DeadlineExceeded, FloeGuardError, type LatencyAdvisory, LatencyBudget, type LatencyBudgetOptions, type ManualPrice, type PricedModel, type SpendEvent, UnpriceableModelError, budgetGuardMiddleware, priceTokens, pricing, resolvePrice };