vern-llm 2.5.0 → 2.6.0

package/dist/index.d.cts

@@ -7,16 +7,7 @@ type LLMErrorType = 'timeout' | 'api' | 'network' | 'parse' | 'validation' | 'in
  * e.g. `authentication`/`authorization` apply the same way regardless of
  * which type wraps them.
  */
-type LLMErrorCode = 'unknown_tool' | 'duplicate_tool_call_id' | 'tool_choice_none_violated' | 'unexpected_tool_calls' | 'unsupported_capability' | 'duplicate_tool_names' | 'unknown_tool_choice' | 'duplicate_tool_result_ids' | 'unknown_tool_result_ids' | 'missing_tool_results' | 'middleware_threw' | 'rate_limit_queue_full' | 'rate_limit_queue_timeout' | 'rate_limit_capacity_exceeded' | 'provider_rate_limited' | 'request_timeout' | 'idle_timeout' | 'middleware_timeout' | 'deadline_exceeded' | 'authentication' | 'authorization' | 'not_found' | 'payload_too_large' | 'server_error' | 'empty_response' | 'connection_failed' | 'circuit_cooling_down' | 'circuit_trial_in_flight' | 'fallback_exhausted' | 'tool_arguments_parse_failed' | 'stream_frame_invalid';
-/**
- * Tool contract codes: a model or provider response defect, not a
- * transient provider fault. Deterministic on the wire request, so
- * retrying can't change the outcome and it shouldn't count toward the
- * circuit breaker either. Shared by `LLMError.retryable` below and by
- * `CallExecutor`'s own retry/breaker accounting, so the two can't drift
- * apart.
- */
-
+type LLMErrorCode = 'unknown_tool' | 'duplicate_tool_call_id' | 'tool_choice_none_violated' | 'unexpected_tool_calls' | 'unsupported_capability' | 'duplicate_tool_names' | 'unknown_tool_choice' | 'duplicate_tool_result_ids' | 'unknown_tool_result_ids' | 'missing_tool_results' | 'middleware_threw' | 'rate_limit_queue_full' | 'rate_limit_queue_timeout' | 'rate_limit_capacity_exceeded' | 'provider_rate_limited' | 'retry_budget_exhausted' | 'request_timeout' | 'idle_timeout' | 'middleware_timeout' | 'deadline_exceeded' | 'authentication' | 'authorization' | 'not_found' | 'payload_too_large' | 'server_error' | 'empty_response' | 'connection_failed' | 'circuit_cooling_down' | 'circuit_trial_in_flight' | 'fallback_exhausted' | 'tool_arguments_parse_failed' | 'stream_frame_invalid' | 'soft_failure_detected';
 /** One tool call's contract failure, used to report every bad call in a response at once. */
 interface ToolIssue {
   name: string;
@@ -133,21 +124,6 @@ interface LLMRequestSnapshot {
   /** Wall clock time the attempt started, ms since epoch. */
   startedAt: number;
 }
-/**
- * Builds a point-in-time, plain data copy of one attempt's outgoing
- * request. Mirrors `LLMError.toSnapshot()`: never thrown or dispatched
- * again, safe to serialize and store. A plain function rather than a
- * method, since unlike `LLMError` a request has no throwable identity or
- * derived state worth wrapping in a class.
- *
- * `startedAt` is optional so existing call sites (and tests) that don't
- * care about exact timing keep working, but a caller that has a real
- * capture time should always pass it: this function may run well after
- * the request was actually dispatched (e.g. `callExecutor` only builds
- * the snapshot once an attempt has failed), so defaulting to `Date.now()`
- * here would record failure-handling time, not request-start time.
- */
-
 /**
  * One failed attempt on the way to a terminal error: which attempt index
  * it was, and a snapshot of the error it failed with. The base shape
@@ -193,6 +169,14 @@ declare class LLMError extends Error {
    * alone carries no retry signal.
    */
   get retryable(): boolean;
+  /**
+   * Whether this failure should count toward the circuit breaker's
+   * failure threshold. Not the same question as `retryable`:
+   * `quota_exceeded` is retryable but says nothing about provider
+   * health, so it's excluded here even though `retryable` is true for
+   * it. Always false whenever `retryable` is false.
+   */
+  get countsTowardBreaker(): boolean;
   /**
    * Copies this error's fields into an {@link LLMErrorSnapshot}, for
    * recording as a `RetryAttempt`/`FallbackAttempt`. `retryable` is
@@ -235,10 +219,9 @@ declare function isLLMError(err: unknown): err is LLMError;
 declare function hasIssues<C extends keyof LLMErrorIssuesByCode>(err: LLMError, code: C): err is LLMError & {
   code: C;
   issues: LLMErrorIssuesByCode[C];
-}; //#endregion
+};
+//#endregion
 //#region src/types/cache.d.ts
-
-//# sourceMappingURL=errors.d.ts.map
 interface CacheAdapter<T = unknown> {
   get(key: string): Promise<{
     hit: boolean;
@@ -249,13 +232,20 @@ interface CacheAdapter<T = unknown> {
   resolveKey?(key: string): Promise<string>;
 }
 /**
- * Trivial default so the package works out of the box with no external deps
- * Not shared across processes, swap in Redis/Upstash/etc for production
+ * Which entry `InMemoryCacheAdapter` evicts once `maxSize` is exceeded.
+ * `'fifo'` (default) drops the oldest inserted entry. `'lru'` drops the
+ * least recently read or written entry.
+ */
+type EvictionOption = 'fifo' | 'lru';
+/**
+ * Trivial default so the package works out of the box with no external deps.
+ * Not shared across processes, swap in Redis/Upstash/etc for production.
  */
 declare class InMemoryCacheAdapter<T = unknown> implements CacheAdapter<T> {
   private readonly maxSize;
   private store;
-  constructor(maxSize?: number);
+  private readonly eviction;
+  constructor(maxSize?: number, eviction?: EvictionOption);
   get(key: string): Promise<{
     hit: boolean;
     value: T | null;
@@ -302,10 +292,8 @@ declare class TieredCacheAdapter<T = unknown> implements CacheAdapter<T> {
   set(key: string, value: T, ttl: number): Promise<void>;
   delete(key: string): Promise<void>;
 }
-
 //#endregion
 //#region src/types/events.d.ts
-//# sourceMappingURL=cache.d.ts.map
 /**
  * Reports what happened during a call. Fire and forget, mirroring
  * `onUsage`: the return value is never read and a throwing handler cannot
@@ -373,10 +361,8 @@ type VernLLMEvent = {
   patchedFields?: string[];
 };
 type OnEvent = (event: VernLLMEvent) => void;
-
 //#endregion
 //#region src/types/middleware.d.ts
-//# sourceMappingURL=events.d.ts.map
 /** Capabilities of the target a middleware hook is currently looking at. */
 interface MiddlewareCapabilities {
   /**
@@ -584,21 +570,14 @@ interface VernLLMMiddleware {
   /** Observes the same events reported on `VernLLMOptions.onEvent`, filtered by this middleware's own `enabled`. Called from both stages; narrow on `ctx.stage` before reading stage-specific fields. */
   onEvent?: (event: VernLLMEvent, ctx: MiddlewareContext) => void;
 }
-
 //#endregion
 //#region src/circuitBreaker.d.ts
-//# sourceMappingURL=middleware.d.ts.map
-/** The call this mutation happened as part of, forwarded to `onStateChange` untouched. `CircuitBreaker` never inspects it. */
+/** The call this mutation happened as part of, forwarded to `onStateChange` untouched. */
 interface CircuitBreakerCallContext {
   requestId: string;
   state: MiddlewareStateBag;
   signal?: AbortSignal;
-  /**
-   * The real, current attempt number for this dispatch, when the call
-   * site actually has one in scope (i.e. after a dispatch was made or
-   * failed). Omitted for calls that happen before any attempt exists,
-   * like `assertClosed`'s pre-dispatch check.
-   */
+  /** Omitted for calls before any attempt exists, like `assertClosed`'s pre-dispatch check. */
   attempt?: number;
 }
 interface CircuitBreakerOptions {
@@ -607,95 +586,218 @@ interface CircuitBreakerOptions {
   /** How long the circuit stays open before allowing a trial request, in ms. Default 30000 */
   cooldownMs?: number;
   /**
-   * Called after every real state change, never for a no-op transition
-   * (e.g. open to open). `model` is the resolved model of whichever call
-   * triggered this specific transition (the `model` passed to whichever
-   * of `assertClosed`/`recordSuccess`/`recordFailure` caused it).
-   *
-   * With `isolateByModel` off (the default), this is a label only: the
-   * breaker still counts failures across every model together, so a
-   * threshold crossing can be the sum of several different models'
-   * failures even though only the triggering call's `model` is reported
-   * here. With `isolateByModel` on, it's exact: each model has its own
-   * counter, so the transition really was caused solely by that model.
+   * Fires after every real state change, never a no-op transition. `model`
+   * is the resolved model of whichever call triggered it. With
+   * `isolateByModel` off, failures are still counted across every model.
    */
-  onStateChange?: (from: CircuitState, to: CircuitState, consecutiveFailures: number, model?: string, /** See `CircuitBreakerCallContext`. */
-  context?: CircuitBreakerCallContext) => void;
+  onStateChange?: (from: CircuitState, to: CircuitState, consecutiveFailures: number, model?: string, context?: CircuitBreakerCallContext) => void;
   /**
    * Track a separate circuit per resolved model instead of one shared
-   * circuit for the whole instance. A failure on one model then never
-   * opens another model's circuit, at the cost of slower detection for
-   * an outage spread across many distinct models (each model's counter
-   * must independently cross `threshold`). Default false: one shared
-   * circuit, matching every version before this option existed.
-   *
-   * A call that omits `model` (only possible calling `CircuitBreaker`
-   * directly, `VernLLM` always passes one) falls into one shared bucket
-   * alongside every other call that also omits it.
+   * circuit. Default false. A call that omits `model` falls into one
+   * shared bucket alongside every other call that also omits it.
    */
   isolateByModel?: boolean;
-}
+  /** Trial calls allowed through per half-open cycle. Default 1, clamped to at least 1. */
+  halfOpenProbes?: number;
+  /** Fraction of `halfOpenProbes` that must succeed to close the circuit. Default 1, clamped to `[0, 1]`. */
+  halfOpenSuccessRatio?: number;
+  /**
+   * Grows `cooldownMs` on each repeat open instead of a fixed wait.
+   * `{ multiplier, maxMs }` covers exponential growth; a `CooldownBackoff`
+   * function covers anything else. Omitted means `cooldownMs` stays fixed.
+   */
+  cooldownBackoff?: ExponentialBackoffOptions | CooldownBackoff;
+  /**
+   * Decides when a bucket's failures should open the circuit.
+   * `{ kind: 'consecutive', threshold }` (the default) opens after that
+   * many failures in a row. `{ kind: 'rolling', windowMs, minCalls,
+   * failureRatio }` opens once at least `minCalls` calls have landed in
+   * the trailing `windowMs` and the failure ratio reaches `failureRatio`.
+   * `minCalls` must be a non-negative integer; `failureRatio` must be
+   * finite and within `[0, 1]`. Both are validated at construction,
+   * thrown as `RangeError`. A `TrippingPolicy` covers anything else, one
+   * instance shared across every model automatically under
+   * `isolateByModel`, since it tracks its own state per key rather than
+   * owning one flat counter.
+   */
+  tripping?: TrippingOption;
+}
+/** Computes the cooldown for a bucket's `reopenCount`-th repeat open. */
+type CooldownBackoff = (reopenCount: number, baseCooldownMs: number) => number;
+interface ExponentialBackoffOptions {
+  /** Growth factor applied per repeat open, e.g. 2 doubles each time. */
+  multiplier: number;
+  /** Upper bound on the computed cooldown, in ms. Default `Infinity`. */
+  maxMs?: number;
+}
+/**
+ * Decides when a bucket's failures should open the circuit. Keyed by
+ * `key` (a resolved model, or the shared bucket's key when
+ * `isolateByModel` is off) rather than holding one flat counter, so a
+ * single `TrippingPolicy` instance is always safe to share across every
+ * bucket: `CircuitBreaker` never needs to clone or construct a fresh one
+ * per model, `isolateByModel` isolation falls out of `key` alone.
+ */
+interface TrippingPolicy {
+  onSuccess(key: string): void;
+  /** Returns true if this failure should open the circuit for `key`. */
+  onFailure(key: string): boolean;
+  reset(key: string): void;
+  /**
+   * Called when `key`'s bucket is discarded (closed and idle, under
+   * `isolateByModel`), so a keyed policy can release that key's state.
+   * Optional: omit if there's nothing to release.
+   */
+  forget?(key: string): void;
+}
+declare class ConsecutiveTripping implements TrippingPolicy {
+  private readonly threshold;
+  private failuresByKey;
+  constructor(threshold: number);
+  onSuccess(key: string): void;
+  onFailure(key: string): boolean;
+  reset(key: string): void;
+  forget(key: string): void;
+}
+declare class RollingTripping implements TrippingPolicy {
+  private readonly windowMs;
+  private readonly minCalls;
+  private readonly failureRatio;
+  private ratiosByKey;
+  constructor(windowMs: number, minCalls: number, failureRatio: number);
+  private ratioFor;
+  onSuccess(key: string): void;
+  onFailure(key: string): boolean;
+  reset(key: string): void;
+  forget(key: string): void;
+}
+/** Not exported. Internal shorthand union for `CircuitBreakerOptions.tripping`. */
+type TrippingOption = {
+  kind: 'consecutive';
+  threshold: number;
+} | {
+  kind: 'rolling';
+  windowMs: number;
+  minCalls: number;
+  failureRatio: number;
+} | TrippingPolicy;
 type CircuitState = 'closed' | 'open' | 'half-open';
 /**
- * Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
- * calls. Once the threshold is hit, short-circuits new calls with an
- * LLMError('circuit_open') instead of hitting the provider, until the
- * cooldown elapses and a single trial call is allowed through
+ * Per retry VernLLM-instance circuit breaker. Tracks consecutive failures
+ * across calls. Once the threshold is hit, short-circuits new calls with
+ * LLMError('circuit_open') until the cooldown elapses and a trial succeeds.
  */
 declare class CircuitBreaker {
-  private readonly threshold;
   private readonly cooldownMs;
   private readonly onStateChange?;
-  /** Whether this breaker tracks failures per model instead of one shared circuit. Read by `CallExecutor`/`VernLLM` to report per-target in `getCircuitStates`. */
+  /** Whether this breaker tracks failures per model instead of one shared circuit. */
   readonly isolateByModel: boolean;
+  private readonly halfOpenProbes;
+  private readonly halfOpenSuccessRatio;
+  private readonly cooldownBackoff?;
+  /** One instance, keyed per model internally. See `TrippingPolicy`. */
+  private readonly tripping;
   private readonly sharedBucket;
   private readonly bucketsByModel;
   constructor(options?: CircuitBreakerOptions);
-  /** Returns the bucket for a model if one already exists, without allocating. */
-  private lookupBucket;
-  /** Creates and stores a bucket for a model when the first mutation needs one. */
-  private ensureBucketFor;
-  /** Every state mutation routes through here, so `onStateChange` fires exactly once per real change. */
-  private transition;
   /**
    * Throws if the circuit is open and the cooldown hasn't elapsed, or if
-   * the circuit is half-open and a trial call is already in flight.
-   * Otherwise, if the circuit just became eligible for a trial (cooldown
-   * elapsed, or half-open with no trial currently running), this call
-   * becomes that trial
+   * half-open with every trial slot claimed. Otherwise claims a trial slot.
    */
   assertClosed(model?: string, context?: CircuitBreakerCallContext): void;
   recordSuccess(model?: string, context?: CircuitBreakerCallContext): void;
-  recordFailure(model?: string, context?: CircuitBreakerCallContext): void;
-  /**
-   * With `isolateByModel` off (the default), `model` is ignored and the
-   * one shared circuit's state is returned, unchanged from every version
-   * before this option existed. With `isolateByModel` on, returns that
-   * model's own state, `'closed'` for a model never seen yet, same as a
-   * fresh breaker.
-   */
+  /** `code`, when present, is the failing `LLMError`'s `code`. Missing attributes to `'unknown'`. */
+  recordFailure(model?: string, context?: CircuitBreakerCallContext, code?: LLMErrorCode): void;
+  /** With `isolateByModel` off, `model` is ignored and the shared circuit's state is returned. */
   getState(model?: string): CircuitState;
+  /** Failure counts by `LLMErrorCode` for `model`'s bucket. Returned as a plain object copy. */
+  getFailureBreakdown(model?: string): Partial<Record<LLMErrorCode | 'unknown', number>>;
+  /** Manually opens the circuit, as if `threshold` consecutive failures had just happened. */
+  open(model?: string, context?: CircuitBreakerCallContext): void;
+  /** Manually closes the circuit and resets its failure count, without requiring a real success first. */
+  close(model?: string, context?: CircuitBreakerCallContext): void;
   /**
-   * Manually opens the circuit, as if `threshold` consecutive failures had
-   * just happened, e.g. to pull a provider out of rotation ahead of known
-   * maintenance. Resets the cooldown window from now, same as a real
-   * threshold-crossing failure would, and clears any in-flight half-open
-   * trial since it no longer applies once the circuit is (re)opened.
+   * Opens `bucket`: stamps `openedAt`/`cooldownMsForOpen` and transitions
+   * to `open`. Shared by `recordFailure`'s trip, `settleTrialIfComplete`'s
+   * reopen, and the manual `open()`, all of which reach this with
+   * `bucket.trial` already `null`.
    */
-  open(model?: string, context?: CircuitBreakerCallContext): void;
+  private openBucket;
+  /** Computes and clamps the cooldown for `bucket`'s current `reopenCount`. Called once, on open. */
+  private computeCooldown;
+  /** Returns the bucket for a model if one already exists, without allocating. */
+  private lookupBucket;
   /**
-   * Manually closes the circuit and resets its failure count, e.g. once a
-   * provider is confirmed healthy again without waiting out the cooldown.
-   * Mirrors `recordSuccess`'s bookkeeping (including dropping the
-   * per-model bucket under `isolateByModel`, once idle) but without
-   * requiring an actual successful call first.
+   * The key `tripping` is called with. Real per-model isolation under
+   * `isolateByModel`, matching `ensureBucketFor`/`lookupBucket`'s own
+   * per-model key. Otherwise one fixed shared key regardless of what
+   * `model` was passed, matching `sharedBucket` being the one and only
+   * bucket in that mode: `model` is never allowed to split tripping state
+   * when `isolateByModel` is off, the same way it never splits which
+   * bucket a call lands in.
    */
-  close(model?: string, context?: CircuitBreakerCallContext): void;
+  private trippingKeyFor;
+  /** Creates and stores a bucket for a model when the first mutation needs one. */
+  private ensureBucketFor;
+  /** Drops an idle model's bucket and lets `tripping` release that key's state too. */
+  private forgetModel;
+  /** Every state mutation routes through here, so `onStateChange` fires exactly once per real change. */
+  private transition;
+  /** Once every admitted trial has reported in, closes or reopens based on `halfOpenSuccessRatio`. */
+  private settleTrialIfComplete;
+}
+//#endregion
+//#region src/internal/retryBudget.d.ts
+/**
+ * Tunables for a `RetryBudget`. `windowMs`/`minCalls` behave the same as
+ * `RollingTripping`'s (see `circuitBreaker.ts`): `minCalls` gates the
+ * check so a cold start with too little traffic to judge doesn't trip.
+ * `retryRatio` is the max fraction of calls in the window allowed to be
+ * retries before the budget stops allowing more. `minCalls` must be a
+ * non-negative integer; `retryRatio` must be finite and within `[0, 1]`.
+ * Both are validated at construction, thrown as `RangeError`.
+ */
+interface RetryBudgetOptions {
+  windowMs: number;
+  minCalls: number;
+  retryRatio: number;
+}
+/**
+ * Caps how much of a target's recent traffic is allowed to be retries,
+ * independent of the circuit breaker. The breaker asks whether the
+ * provider is healthy; this asks whether retrying is still worth the
+ * capacity it costs, regardless of provider health. Reuses `RollingRatio`,
+ * the same primitive `RollingTripping` is built on, rather than a second
+ * hand rolled window.
+ */
+declare class RetryBudget {
+  private readonly options;
+  private readonly ratio;
+  constructor(options: RetryBudgetOptions);
+  /**
+   * Throws `LLMError('retry_budget_exhausted')` once at least `minCalls`
+   * calls have landed in the trailing `windowMs` and the retry ratio
+   * among them has reached `retryRatio`. A no-op otherwise.
+   */
+  assertAvailable(): void;
+  /** Records one attempt. `isRetry` is false for a call's first attempt, true for every attempt after it. */
+  recordAttempt(isRetry: boolean): void;
+  /** Current traffic and retry ratio in the trailing window. */
+  getSnapshot(): {
+    attempts: number;
+    retryRatio: number;
+  };
+}
+//#endregion
+//#region src/internal/utils/rateLimitHint.utils.d.ts
+/** A normalized read of a provider's rate limit headers. */
+interface ProviderRateLimitHint {
+  remainingRequests?: number;
+  limitRequests?: number;
+  resetAfterMs?: number;
 }
-
 //#endregion
 //#region src/rateLimit.d.ts
-//# sourceMappingURL=circuitBreaker.d.ts.map
 /** The request shape sent to `LLMClient['chat']['completions']['create']`, used for token estimation. */
 type WireRequest = Parameters<LLMClient['chat']['completions']['create']>[0];
 /** Which configured bucket is currently blocking a call. */
@@ -724,6 +826,27 @@ interface RateLimitOptions {
    * chars/4 heuristic over message content plus `max_tokens`.
    */
   estimateTokens?: (request: WireRequest) => number;
+  /**
+   * AIMD against the `requestsPerMinute` bucket. Omit for a fixed
+   * ceiling, today's behavior. Requires `requestsPerMinute`.
+   */
+  aimd?: AimdOptions;
+}
+interface AimdOptions {
+  /** Added to the requests-per-minute ceiling on every clean release. */
+  increaseBy: number;
+  /** Multiplied against the ceiling on a rate-limit signal. Must be in `(0, 1]`; clamped otherwise. */
+  decreaseFactor: number;
+  /** Floor the ceiling never shrinks below. */
+  minCapacity: number;
+  /** Ceiling the bucket never grows above. */
+  maxCapacity: number;
+  /**
+   * Shrink proactively once a provider hint reports `remainingRequests`
+   * at or below this, before a real 429 happens. Default 0, meaning
+   * off.
+   */
+  proactiveFloor?: number;
 }
 interface RateLimitAcquireResult {
   /**
@@ -732,7 +855,7 @@ interface RateLimitAcquireResult {
    * Idempotent: only the first call does anything. Must run in a
    * `finally` block so a slot is never leaked on a failed attempt.
    */
-  release: (actualTokens?: number) => void;
+  release: (actualTokens?: number, success?: boolean) => void;
   /** How long this attempt waited in queue before capacity was available. */
   waitedMs: number;
   /** Which bucket was blocking this attempt just before it cleared, if any wait happened. */
@@ -740,19 +863,35 @@ interface RateLimitAcquireResult {
 }
 /** Default `estimateTokens`: chars/4 over every message's content, plus the requested `max_tokens`. */
 declare function defaultEstimateTokens(request: WireRequest): number;
+/**
+ * What VernLLM's dispatch layer needs from a limiter. `RateLimiter`
+ * implements this; a caller wanting cross-process coordination can hand
+ * over their own instance instead, see `buildRateLimit`. Every method is
+ * required, `RateLimiter` itself already no-ops the AIMD methods when
+ * `aimd` isn't configured, so a custom limiter follows the same pattern.
+ */
+interface RateLimiterAdapter {
+  estimate(request: WireRequest): number;
+  acquire(estimatedTokens: number, signal?: AbortSignal): Promise<RateLimitAcquireResult>;
+  signalRateLimit(): void;
+  reactToRateLimitHint(hint: ProviderRateLimitHint | undefined): void;
+}
 /**
  * Per-target rate limiter. Up to three buckets (requests/min, tokens/min,
  * concurrency) behind one FIFO queue, so a large call isn't starved by a
  * stream of small ones. Any bucket omitted from `options` has infinite
  * capacity and never blocks.
  */
-declare class RateLimiter {
+declare class RateLimiter implements RateLimiterAdapter {
   private readonly requests?;
   private readonly tokens?;
   private readonly concurrency?;
+  /** Buckets in acquire precedence order (concurrency, rpm, tpm), omitted ones filtered out. Built once so order can't drift between `tryAcquireBuckets` and `scheduleWake`. */
+  private readonly buckets;
   private readonly maxQueueMs;
   private readonly maxQueueSize;
   private readonly estimateTokensFn;
+  private readonly aimd?;
   private readonly queue;
   /**
    * A single scheduled re-check for the head of the queue when it's
@@ -773,12 +912,7 @@ declare class RateLimiter {
   acquire(estimatedTokens: number, signal?: AbortSignal): Promise<RateLimitAcquireResult>;
   private queueFullError;
   private enqueue;
-  /**
-   * Checks and takes from every configured bucket as one atomic unit: if
-   * any bucket lacks capacity, whatever was already taken from the
-   * earlier ones in this attempt is rolled back before reporting which
-   * bucket blocked.
-   */
+  /** Takes from every configured bucket as one atomic unit, in `this.buckets`' order. Rolls back whatever was already taken if any bucket lacks capacity. */
   private tryAcquireBuckets;
   /** Drains the queue head first. Stops at the first waiter that still can't proceed, so no one is starved out of turn. */
   private drain;
@@ -795,13 +929,37 @@ declare class RateLimiter {
    * bucket is a real spend that only recovers via its own refill, and the
    * tokens bucket is reconciled against `actualTokens` rather than fully
    * refunded, since real tokens really were spent.
+   *
+   * `success` defaults to `false`: the AIMD ceiling only grows when the
+   * caller explicitly confirms a successful attempt. A failed or
+   * rate-limited attempt still releases its slot (so nothing leaks), but
+   * must not also grow the ceiling right back up after
+   * `signalRateLimit()` just shrank it.
    */
   private makeRelease;
+  /** Shared guard and resize call behind both AIMD halves below; only the arithmetic differs. */
+  private resizeRequestsCeiling;
+  /** AIMD's additive-increase half: grows the ceiling by `aimd.increaseBy` on a clean release. No-op without `aimd`/`requestsPerMinute`. */
+  private growOnSuccess;
+  /**
+   * AIMD's multiplicative-decrease half. Called on a real 429, and,
+   * where an adapter can produce a hint, proactively via
+   * `reactToRateLimitHint`. Never throws or blocks a call itself, only
+   * adjusts the ceiling as a side effect.
+   */
+  signalRateLimit(): void;
+  /**
+   * AIMD's proactive entry point: shrinks via `signalRateLimit()` if
+   * `hint.remainingRequests` is at or below `aimd.proactiveFloor`.
+   */
+  reactToRateLimitHint(hint: ProviderRateLimitHint | undefined): void;
 }
-
+//#endregion
+//#region src/internal/utils/rateLimitAdapter.utils.d.ts
+/** Not exported. Internal shorthand only, so this union isn't duplicated between the public option fields and `buildRateLimit`'s own signature. */
+type RateLimitOption = RateLimitOptions | RateLimiterAdapter;
 //#endregion
 //#region src/types/fallback.d.ts
-//# sourceMappingURL=rateLimit.d.ts.map
 /**
  * One provider to try after the primary (or after an earlier fallback
  * target) fails. Order is the policy: VernLLM never reorders, scores, or
@@ -810,11 +968,11 @@ declare class RateLimiter {
  * Most per-target overrides fall back to the parent `VernLLM` instance's
  * own option when omitted, so a target only needs to specify what's
  * actually different about it (a different client/model is the common
- * case). `circuitBreaker` and `rateLimit` are the exception: they are
- * never inherited from the parent, since a breaker or limiter tuned for
- * the primary provider's limits is rarely right for a fallback's. Leave
- * them unset on a target to run it without one, even if the parent has
- * one configured.
+ * case). `circuitBreaker`, `rateLimit`, and `retryBudget` are the
+ * exception: they are never inherited from the parent, since a breaker,
+ * limiter, or budget tuned for the primary provider's limits is rarely
+ * right for a fallback's. Leave them unset on a target to run it without
+ * one, even if the parent has one configured.
  */
 interface FallbackTarget {
   client: LLMClient;
@@ -833,7 +991,16 @@ interface FallbackTarget {
   /** This target's own circuit breaker, independent of every other target's. Not inherited from the parent's `circuitBreaker`. */
   circuitBreaker?: boolean | CircuitBreakerOptions;
   /** This target's own rate limiter, independent of every other target's. Not inherited from the parent's `rateLimit`. */
-  rateLimit?: RateLimitOptions;
+  rateLimit?: RateLimitOption;
+  /** This target's own retry budget, independent of every other target's. Not inherited from the parent's `retryBudget`. */
+  retryBudget?: RetryBudgetOptions;
+  /**
+   * Reclassifies an otherwise-successful result from this target as a
+   * failure. Falls back to the parent `VernLLM` instance's own
+   * `detectSoftFailure` when omitted, same as most other per-target
+   * options (unlike `circuitBreaker`/`rateLimit`, which never inherit).
+   */
+  detectSoftFailure?: DetectSoftFailure;
 }
 /**
  * Written into `CallParams['meta']` once `call()` resolves, so a caller
@@ -926,10 +1093,8 @@ declare function isFallbackExhaustedError(err: unknown): err is FallbackExhauste
 declare function metaRef(): {
   current?: CallMeta;
 };
-
 //#endregion
 //#region src/types/schema.d.ts
-//# sourceMappingURL=fallback.d.ts.map
 /**
  * Minimal structural type for a Zod-like schema, so this package doesnt need
  * a hard dependency on a specific Zod major version. Any object exposing
@@ -959,10 +1124,8 @@ interface JsonSchemaSpec {
   strict?: boolean;
   description?: string;
 }
-
 //#endregion
 //#region src/types/tools.d.ts
-//# sourceMappingURL=schema.d.ts.map
 /**
  * Describes a capability the model may request, not the capability
  * itself. VernLLM transports this to the provider and parses what comes
@@ -1113,7 +1276,6 @@ declare function isToolCallResult<Tools extends readonly ToolDefinition[] | unde
 type ToolChoice = 'auto' | 'none' | 'required' | {
   name: string;
 };
-
 //#endregion
 //#region src/types/usage.d.ts
 type ReserveUsage = (params: {
@@ -1179,10 +1341,8 @@ type OnUsage = (usage: TokenUsage) => void;
  * to report.
  */
 type OnUsageFailure = (usage: TokenUsage, error: LLMError) => void;
-
 //#endregion
 //#region src/types/call.d.ts
-//# sourceMappingURL=usage.d.ts.map
 /**
  * Any valid JSON value: a primitive, `null`, or a JSON array/object made
  * of the same. This is what `call()` returns when `jsonMode: true`.
@@ -1514,10 +1674,26 @@ type CachedJsonModeEnabledCallParams = CachedCallInput & {
     schema?: never;
   };
 };
-
+/** Context handed to `DetectSoftFailure` alongside the response it's inspecting. */
+interface SoftFailureMeta {
+  requestId: string;
+  model: string;
+  providerName: string;
+  isFallback: boolean;
+  /** 1-based, matching `CallMeta.attempts`. */
+  attempt: number;
+}
+/**
+ * Inspects an otherwise-successful result and optionally reclassifies it
+ * as a failure. Returning `undefined` leaves the result as a success;
+ * returning an `LLMErrorCode` fails the attempt with that code, feeding
+ * the same retry and circuit-breaker paths a thrown error would. A
+ * result that parses fine but is empty, truncated, or a low-confidence
+ * refusal is otherwise invisible to both.
+ */
+type DetectSoftFailure<T = unknown> = (result: T | CallWithToolsResult<T>, meta: SoftFailureMeta) => LLMErrorCode | undefined;
 //#endregion
 //#region src/types/stream.d.ts
-//# sourceMappingURL=call.d.ts.map
 /** One incremental unit of a streaming response, as delivered to the caller. */
 type StreamChunk = {
   type: 'text-delta';
@@ -1622,6 +1798,18 @@ type WireStreamChunk = {
    * Never surfaced to callers as a `StreamChunk`.
    */
   type: 'ping';
+} | {
+  /**
+   * AIMD's proactive rate-limit hint, read off the stream's
+   * response headers (where the adapter/SDK can get at them) and
+   * yielded once, as early as possible. Mirrors `attachRateLimitHint`
+   * for the non-streaming path, just carried as a chunk instead of a
+   * hidden property on a response object, since a stream has no
+   * single response value to attach one to. Never surfaced to
+   * callers as a `StreamChunk`.
+   */
+  type: 'rate_limit_hint';
+  hint: ProviderRateLimitHint;
 };
 /**
  * Parameters for a cached, streaming LLM call without tool calling.
@@ -1696,10 +1884,8 @@ type CachedStreamJsonModeEnabledCallParams = CachedCallInput & {
     schema?: never;
   };
 };
-
 //#endregion
 //#region src/types/client.d.ts
-//# sourceMappingURL=stream.d.ts.map
 /** A tool call as it appears on the wire, OpenAI's `function`-wrapped shape. */
 interface WireToolCall {
   id: string;
@@ -1829,10 +2015,20 @@ interface LLMClient {
     };
   };
 }
-
+//#endregion
+//#region src/internal/utils/cacheAdapter.utils.d.ts
+/**
+ * Not exported. Internal shorthand for `VernLLMOptions.cache`, so the
+ * union isn't duplicated between that field and `buildCache`'s own
+ * signature. A caller never writes this type by name, either a config
+ * object literal or a real `CacheAdapter`.
+ */
+type CacheOption = {
+  maxSize?: number;
+  eviction?: EvictionOption;
+} | CacheAdapter;
 //#endregion
 //#region src/logger.d.ts
-//# sourceMappingURL=client.d.ts.map
 interface Logger {
   debug(message: string): void;
   warn(message: string): void;
@@ -1849,10 +2045,8 @@ declare class ConsoleLogger implements Logger {
   warn(message: string): void;
   error(message: string, meta?: Record<string, unknown>): void;
 }
-
 //#endregion
 //#region src/types/options.d.ts
-//# sourceMappingURL=logger.d.ts.map
 interface VernLLMOptions {
   client: LLMClient;
   model: string;
@@ -1921,8 +2115,24 @@ interface VernLLMOptions {
    * (no redaction).
    */
   redact?: (text: string) => string;
-  /** Cache adapter for cachedCall. Defaults to an in-memory adapter */
-  cache?: CacheAdapter;
+  /**
+   * Cache for cachedCall. `{ maxSize, eviction }` configures the
+   * built-in in-memory adapter (`eviction` default `'fifo'`). Pass a
+   * `CacheAdapter` directly for a real backend. Default: in-memory,
+   * maxSize 1000, fifo.
+   */
+  cache?: CacheOption;
+  /**
+   * Reclassifies an otherwise-successful result as a failure, e.g. a
+   * response that parsed fine but came back empty or truncated. Runs
+   * once per attempt, right after a response is validated. Returning
+   * `undefined` leaves the result untouched; returning an
+   * `LLMErrorCode` fails that attempt with it, feeding the same retry
+   * and circuit-breaker paths a thrown error would. A throwing hook is
+   * caught, logged, and treated as no soft failure, so a broken hook
+   * degrades safely instead of failing every call.
+   */
+  detectSoftFailure?: DetectSoftFailure;
   /** HTTP status codes that should fail fast without retrying. Default [400, 401, 403, 404, 422] */
   nonRetryableStatus?: number[];
   /** Custom JSON parser. Must return undefined/null on failure. Default: JSON.parse wrapped in try/catch */
@@ -1961,8 +2171,22 @@ interface VernLLMOptions {
    * letting the provider reject them. Independent of the `Retry-After`
    * handling already applied to a provider 429: this avoids tripping the
    * limit in the first place. Omit for unlimited (the default).
+   *
+   * A plain config object builds an in-process limiter. Pass a
+   * `RateLimiterAdapter` instead for cross-process coordination.
+   */
+  rateLimit?: RateLimitOption;
+  /**
+   * Caps how much of this target's recent traffic is allowed to be
+   * retries, independent of `circuitBreaker`. Once at least `minCalls`
+   * calls have landed in the trailing `windowMs` and the retry ratio
+   * among them reaches `retryRatio`, further retries against this target
+   * throw `LLMError('retry_budget_exhausted')` instead of retrying,
+   * protecting the target's real capacity even while its breaker is
+   * still closed. Omit for no budget (the default). Never inherited by
+   * `fallback` targets, same as `circuitBreaker`/`rateLimit`.
    */
-  rateLimit?: RateLimitOptions;
+  retryBudget?: RetryBudgetOptions;
   /**
    * Ordered targets tried after the primary, in order, once it (and its
    * own retries) is exhausted or abandoned. Order is the policy: VernLLM
@@ -1999,10 +2223,8 @@ interface VernLLMOptions {
    */
   middlewareTimeoutMs?: number;
 }
-
 //#endregion
 //#region src/types/createMiddleware.d.ts
-//# sourceMappingURL=options.d.ts.map
 /**
  * `VernLLMMiddleware` plus `onError`, a convenience for the common "I
  * only care about failures" case. Everything else is passed through to
@@ -2035,10 +2257,8 @@ type CreateMiddlewareOptions = Omit<VernLLMMiddleware, 'wrap'> & {
  * returns or throws, only what gets observed about it.
  */
 declare function createMiddleware(options: CreateMiddlewareOptions): VernLLMMiddleware;
-
 //#endregion
 //#region src/vernLLM.d.ts
-//# sourceMappingURL=createMiddleware.d.ts.map
 /**
  * A LLM call framework for resilience, observability and control. This is VernLLM!
  *
@@ -2178,6 +2398,26 @@ declare class VernLLM {
    * target that doesn't exist.
    */
   getCircuitState(target?: CircuitTarget): CircuitState | undefined;
+  /**
+   * @param target.index Which target to read. Defaults to the primary.
+   * @param target.model Which model bucket to read, if the target isolates by model.
+   * @returns Failure counts by `LLMErrorCode`, `'unknown'` for a missing
+   * code, or `undefined` if that target has no breaker.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  getFailureBreakdown(target?: CircuitTarget): Partial<Record<LLMErrorCode | 'unknown', number>> | undefined;
+  /**
+   * @param target.index Which target to read. Defaults to the primary.
+   * @returns This target's current retry traffic/ratio in the trailing
+   * window, or `undefined` if that target has no retry budget
+   * configured. A budget is target-scoped, not model-scoped, so unlike
+   * `getFailureBreakdown` there's no `target.model` to pass.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  getRetryBudgetState(target?: Pick<CircuitTarget, 'index'>): {
+    attempts: number;
+    retryRatio: number;
+  } | undefined;
   /**
    * @param model Which model bucket to read, for targets that isolate by model.
    * @returns Every target's state, in chain order.
@@ -2202,10 +2442,8 @@ declare class VernLLM {
    */
   closeCircuit(target?: CircuitTarget): void;
 }
-
 //#endregion
 //#region src/paramsHelpers.d.ts
-//# sourceMappingURL=vernLLM.d.ts.map
 /**
  * Identity function preserving `params`'s own precise type, unlike a `:
  * CallParams<T>` annotation, which would widen `tools` away and break the
@@ -2241,10 +2479,8 @@ declare function defineCallParams<P extends CallParams<unknown>>(params: P): P;
  * ```
  */
 declare function defineCachedCallParams<P extends CachedCallParams<unknown>>(params: P): P;
-
 //#endregion
 //#region src/adapters/internal/sse.d.ts
-//# sourceMappingURL=paramsHelpers.d.ts.map
 /**
  * Parses a Server-Sent-Events byte/text stream into the JSON payload of
  * each `data:` frame, in arrival order. Generic over transport: works with
@@ -2280,29 +2516,18 @@ declare function parseSseStream(source: AsyncIterable<Uint8Array | string>): Asy
  * alive" separately from a genuinely empty frame (`NO_DATA`, kept internal).
  */
 declare const SSE_PING: unique symbol;
-
 //#endregion
 //#region src/adapters/internal/imageFormat.d.ts
-//# sourceMappingURL=sse.d.ts.map
 /**
  * MIME types accepted for `ImageBlock.mimeType` across all adapters. This is
  * the intersection of what Anthropic, Gemini, OpenAI-compatible, and Bedrock
  * Converse all natively support, so a `ContentBlock[]` that validates for
  * one provider validates for all of them.
  */
-declare const SUPPORTED_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
+declare const SUPPORTED_IMAGE_MIME_TYPES: readonly ['image/png', 'image/jpeg', 'image/gif', 'image/webp'];
 type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
-
 //#endregion
 //#region src/adapters/internal/nativeStructuredOutput.d.ts
-/**
- * Validates an `ImageBlock.mimeType` against the shared supported set.
- * Throws a non-retryable `LLMError('invalid_params')`, since an unsupported
- * mimeType is a bug in the caller's own input, deterministic before any
- * request is built, the same class of failure as every other check in
- * `RequestBuilder`.
- */
-
 /**
  * A static allow-list or predicate naming which models support native,
  * schema-constrained output as its own request field. Anthropic's
@@ -2323,10 +2548,8 @@ type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
  * exactly this package's behavior before native support was added.
  */
 type ModelCapabilityOverride = string[] | ((model: string) => boolean);
-
 //#endregion
 //#region src/adapters/internal/reasoningBudget.utils.d.ts
-/** Resolves whether `model` is covered by a caller-supplied allow-list/predicate. */
 /**
  * Shared conversion between the two reasoning controls VernLLM exposes:
  * `reasoningEffort` (a tier string, OpenAI's native shape) and
@@ -2347,7 +2570,6 @@ type ModelCapabilityOverride = string[] | ((model: string) => boolean);
  * doesn't match these numbers.
  */
 type EffortTokenTable = Record<'minimal' | 'low' | 'medium' | 'high', number>;
-
 //#endregion
 //#region src/adapters/anthropic.d.ts
 /** Anthropic's native per-block content shape for a message. */
@@ -2501,6 +2723,13 @@ interface AnthropicAdapterOptions {
    * predicate.
    */
   adaptiveOnlyModels?: ModelCapabilityOverride;
+  /**
+   * Whether the client's `messages.create` supports `.withResponse()`
+   * (needed for AIMD's proactive path). Default `false`, since
+   * `AnthropicClient` is structural and a test fake or thin wrapper
+   * won't implement it.
+   */
+  supportsWithResponse?: boolean;
 }
 /**
  * Wraps an Anthropic SDK client so it satisfies the same `LLMClient`
@@ -2534,7 +2763,6 @@ interface AnthropicAdapterOptions {
  * `output_config.format` or a forced tool call).
  */
 declare function fromAnthropic(anthropicClient: AnthropicClient, options?: AnthropicAdapterOptions): LLMClient;
-
 //#endregion
 //#region src/adapters/gemini.d.ts
 /**
@@ -2747,7 +2975,6 @@ interface GeminiAdapterOptions {
   thinkingLevelModels?: ModelCapabilityOverride;
 }
 declare function fromGemini(client: GeminiClient, options?: GeminiAdapterOptions): LLMClient;
-
 //#endregion
 //#region src/adapters/bedrock.d.ts
 /** Bedrock Converse's supported inline image formats. */
@@ -3107,7 +3334,6 @@ interface AwsSendClient {
  * `create` branch above unwraps it.
  */
 declare function fromBedrock(bedrockClient: BedrockConverseClient | AwsSendClient, options?: BedrockAdapterOptions): LLMClient;
-
 //#endregion
 //#region src/adapters/fetch.d.ts
 /** The chat-completion-shaped request VernLLM builds internally */
@@ -3225,6 +3451,11 @@ interface FetchAdapterConfig {
    * silently empty stream.
    */
   mapStreamEvent?: (event: unknown) => WireStreamChunk | WireStreamChunk[] | undefined;
+  /**
+   * Optional. How to read AIMD's proactive rate limit hint off a
+   * successful response. Defaults to OpenAI's header set.
+   */
+  parseRateLimitHint?: (headers: ResponseLike['headers']) => ProviderRateLimitHint;
 }
 /**
  * A fetch-based escape hatch for providers with no SDK, or where pulling one
@@ -3249,7 +3480,6 @@ interface FetchAdapterConfig {
  * `mapStreamEvent` seam via `WireStreamChunk`'s `tool_call_delta` variant,
  * no separate config is needed for streaming vs non-streaming tool calls.
  *
-
  * `createStream` requires `mapStreamEvent` (there's no non-streaming
  * response to fall back on, unlike the other three optional streaming
  * seams). It opens the request via `requestStream` (defaults to native
@@ -3266,7 +3496,6 @@ interface FetchAdapterConfig {
  * `fetch`.
  */
 declare function fromFetch(config: FetchAdapterConfig): LLMClient;
-
 //#endregion
 //#region src/adapters/openaiCompatible.d.ts
 /**
@@ -3326,6 +3555,12 @@ interface OpenAICompatibleAdapterOptions {
    * effect when `reasoningEffort` is set directly.
    */
   reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Whether the client's request builder supports `.withResponse()`
+   * (needed for AIMD's proactive path). Default `false`, since not
+   * every "OpenAI-compatible" client is confirmed to support it.
+   */
+  supportsWithResponse?: boolean;
 }
 declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibleAdapterOptions): LLMClient;
 /**
@@ -3335,11 +3570,15 @@ declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibl
  * variant) in ways that no longer structurally satisfy VernLLM's
  * provider-agnostic `ContentBlock[]` on `userContent`, so passing the SDK
  * instance directly can fail to typecheck depending on the installed
- * `openai` version. Wrapping with `fromOpenAI()` (a plain alias of
- * `fromOpenAICompatible()`) sidesteps that by translating through
- * `unknown` at the boundary, and also picks up multimodal image
- * translation and `createStream` wiring that a raw client doesn't have.
- * See Migration Notes for details.
+ * `openai` version. Wrapping with `fromOpenAI()` sidesteps that by
+ * translating through `unknown` at the boundary, and also picks up
+ * multimodal image translation and `createStream` wiring that a raw
+ * client doesn't have. See Migration Notes for details.
+ *
+ * `supportsWithResponse` defaults to `false` here too:
+ * `client` is `unknown`, so there's no way to verify it's really the
+ * official `openai` package's client versus a fake or a test double.
+ * Pass `supportsWithResponse: true` once you've confirmed it.
  */
 declare const fromOpenAI: typeof fromOpenAICompatible;
 /** Groqs SDK matches the OpenAI wire format */
@@ -3433,9 +3672,6 @@ declare const fromInfermatic: typeof fromOpenAICompatible;
 declare const fromAtlasCloud: typeof fromOpenAICompatible;
 /** 01.AI's (Yi models) API is OpenAI-compatible */
 declare const from01AI: typeof fromOpenAICompatible;
-
 //#endregion
-//# sourceMappingURL=openaiCompatible.d.ts.map
-
-export { AnthropicClient, AssistantContent, AttemptContext, BedrockConverseClient, CacheAdapter, CachedCallParams, CachedConditionalToolCallParams, CachedJsonModeDisabledCallParams, CachedJsonModeEnabledCallParams, CachedStreamCallParams, CachedStreamConditionalToolCallParams, CachedStreamJsonModeDisabledCallParams, CachedStreamJsonModeEnabledCallParams, CachedStreamToolCallParams, CachedToolCallParams, CallMeta, CallParams, CallResult, CallWithToolsResult, CircuitBreaker, CircuitBreakerOptions, CircuitState, CircuitTarget, ConditionalToolCallParams, ConsoleLogger, ContentBlock, ContentResult, ConversationTurn, CreateMiddlewareOptions, DuplicateToolNamesIssue, FallbackAttempt, FallbackExhaustedError, FallbackOn, FallbackTarget, FetchAdapterConfig, GeminiClient, HistoryToolResultIssue, ImageBlock, InMemoryCacheAdapter, JsonModeDisabledCallParams, JsonModeEnabledCallParams, JsonSchemaSpec, JsonValue, LLMClient, LLMError, LLMErrorCode, LLMErrorIssuesByCode, LLMErrorSnapshot, LLMErrorType, LLMRequestShape, LLMRequestSnapshot, Logger, MiddlewareCapabilities, MiddlewareContext, MiddlewareContextBase, MiddlewareStateBag, MiddlewareStateKey, NormalizedCacheAdapter, OnEvent, OnUsage, PreDispatchContext, RateLimitAcquireResult, RateLimitOptions, RateLimitReason, RateLimiter, RefundUsage, ReserveUsage, RetryAttempt, SSE_PING, SchemaLike, StreamCallResult, StreamChunk, StreamEnabledCallParams, StreamJsonModeDisabledCallParams, StreamJsonModeEnabledCallParams, TargetCircuitState, TextBlock, TieredCacheAdapter, TokenUsage, ToolCall, ToolCallResult, ToolChoice, ToolDefinition, ToolEnabledCallParams, ToolIssue, ToolResult, ToolsDisabledCallParams, UnknownToolChoiceIssue, UnsupportedCapabilityIssue, VernLLM, VernLLMEvent, VernLLMMiddleware, VernLLMOptions, WireCallRequest, WireCallRequestPatch, WireMessage, WireRequest, WireResponseFormat, WireStreamChunk, WireTool, WireToolCall, WireToolChoice, createMiddleware, createMiddlewareStateBag, createStateKey, defaultEstimateTokens, defaultFallbackOn, defineCachedCallParams, defineCallParams, defineTool, from01AI, fromAnthropic, fromAnyscale, fromAtlasCloud, fromBaseten, fromBedrock, fromCerebras, fromCloudflareWorkersAI, fromDeepInfra, fromDeepSeek, fromFeatherless, fromFetch, fromFireworks, fromFriendli, fromGemini, fromGroq, fromHyperbolic, fromInferenceNet, fromInfermatic, fromLMStudio, fromLambdaLabs, fromLepton, fromMiniMax, fromMistral, fromMoonshot, fromNebius, fromNovita, fromNvidiaNIM, fromOllama, fromOpenAI, fromOpenAICompatible, fromOpenRouter, fromParasail, fromPerplexity, fromSambaNova, fromSiliconFlow, fromSnowflakeCortex, fromStepFun, fromTogether, fromVLLM, fromVercelAIGateway, fromXAI, fromZhipu, hasIssues, isFallbackExhaustedError, isLLMError, isToolCallResult, metaRef, parseSseStream };
+export { type AnthropicClient, type AssistantContent, type AttemptContext, type BedrockConverseClient, type CacheAdapter, type CachedCallParams, type CachedConditionalToolCallParams, type CachedJsonModeDisabledCallParams, type CachedJsonModeEnabledCallParams, type CachedStreamCallParams, type CachedStreamConditionalToolCallParams, type CachedStreamJsonModeDisabledCallParams, type CachedStreamJsonModeEnabledCallParams, type CachedStreamToolCallParams, type CachedToolCallParams, type CallMeta, type CallParams, type CallResult, type CallWithToolsResult, CircuitBreaker, type CircuitBreakerOptions, type CircuitState, type CircuitTarget, type ConditionalToolCallParams, ConsecutiveTripping, ConsoleLogger, type ContentBlock, type ContentResult, type ConversationTurn, type CooldownBackoff, type CreateMiddlewareOptions, type DuplicateToolNamesIssue, type EvictionOption, type ExponentialBackoffOptions, type FallbackAttempt, FallbackExhaustedError, type FallbackOn, type FallbackTarget, type FetchAdapterConfig, type GeminiClient, type HistoryToolResultIssue, type ImageBlock, InMemoryCacheAdapter, type JsonModeDisabledCallParams, type JsonModeEnabledCallParams, type JsonSchemaSpec, type JsonValue, type LLMClient, LLMError, type LLMErrorCode, type LLMErrorIssuesByCode, type LLMErrorSnapshot, type LLMErrorType, type LLMRequestShape, type LLMRequestSnapshot, type Logger, type MiddlewareCapabilities, type MiddlewareContext, type MiddlewareContextBase, type MiddlewareStateBag, type MiddlewareStateKey, NormalizedCacheAdapter, type OnEvent, type OnUsage, type PreDispatchContext, type RateLimitAcquireResult, type RateLimitOptions, type RateLimitReason, RateLimiter, type RateLimiterAdapter, type RefundUsage, type ReserveUsage, type RetryAttempt, RetryBudget, type RetryBudgetOptions, RollingTripping, SSE_PING, type SchemaLike, type StreamCallResult, type StreamChunk, type StreamEnabledCallParams, type StreamJsonModeDisabledCallParams, type StreamJsonModeEnabledCallParams, type TargetCircuitState, type TextBlock, TieredCacheAdapter, type TokenUsage, type ToolCall, type ToolCallResult, type ToolChoice, type ToolDefinition, type ToolEnabledCallParams, type ToolIssue, type ToolResult, type ToolsDisabledCallParams, type TrippingPolicy, type UnknownToolChoiceIssue, type UnsupportedCapabilityIssue, VernLLM, type VernLLMEvent, type VernLLMMiddleware, type VernLLMOptions, type WireCallRequest, type WireCallRequestPatch, type WireMessage, type WireRequest, type WireResponseFormat, type WireStreamChunk, type WireTool, type WireToolCall, type WireToolChoice, createMiddleware, createMiddlewareStateBag, createStateKey, defaultEstimateTokens, defaultFallbackOn, defineCachedCallParams, defineCallParams, defineTool, from01AI, fromAnthropic, fromAnyscale, fromAtlasCloud, fromBaseten, fromBedrock, fromCerebras, fromCloudflareWorkersAI, fromDeepInfra, fromDeepSeek, fromFeatherless, fromFetch, fromFireworks, fromFriendli, fromGemini, fromGroq, fromHyperbolic, fromInferenceNet, fromInfermatic, fromLMStudio, fromLambdaLabs, fromLepton, fromMiniMax, fromMistral, fromMoonshot, fromNebius, fromNovita, fromNvidiaNIM, fromOllama, fromOpenAI, fromOpenAICompatible, fromOpenRouter, fromParasail, fromPerplexity, fromSambaNova, fromSiliconFlow, fromSnowflakeCortex, fromStepFun, fromTogether, fromVLLM, fromVercelAIGateway, fromXAI, fromZhipu, hasIssues, isFallbackExhaustedError, isLLMError, isToolCallResult, metaRef, parseSseStream };
 //# sourceMappingURL=index.d.cts.map