vern-llm 2.7.0 → 2.9.0

package/dist/index.d.mts

@@ -147,7 +147,7 @@ interface LLMErrorOptions {
   /** Every attempt made before this error was thrown, in order. Absent when nothing was retried. */
   attempts?: RetryAttempt[];
 }
-declare class LLMError extends Error {
+export declare class LLMError extends Error {
   type: LLMErrorType;
   status?: number;
   issues?: unknown;
@@ -203,7 +203,7 @@ declare class LLMError extends Error {
    */
   toJSON(): Record<string, unknown>;
 }
-declare function isLLMError(err: unknown): err is LLMError;
+export declare function isLLMError(err: unknown): err is LLMError;
 /**
  * Narrows `err.issues` to the exact shape {@link LLMErrorIssuesByCode} maps
  * `code` to, for any code listed there. `code` stays the only discriminator
@@ -216,7 +216,7 @@ declare function isLLMError(err: unknown): err is LLMError;
  * }
  * ```
  */
-declare function hasIssues<C extends keyof LLMErrorIssuesByCode>(err: LLMError, code: C): err is LLMError & {
+export declare function hasIssues<C extends keyof LLMErrorIssuesByCode>(err: LLMError, code: C): err is LLMError & {
   code: C;
   issues: LLMErrorIssuesByCode[C];
 };
@@ -241,7 +241,7 @@ 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> {
+export declare class InMemoryCacheAdapter<T = unknown> implements CacheAdapter<T> {
   private readonly maxSize;
   private store;
   private readonly eviction;
@@ -258,7 +258,7 @@ declare class InMemoryCacheAdapter<T = unknown> implements CacheAdapter<T> {
 /**
  * Normalizes keys before caching to avoid duplicate entries from formatting differences.
  */
-declare class NormalizedCacheAdapter<T = unknown> implements CacheAdapter<T> {
+export declare class NormalizedCacheAdapter<T = unknown> implements CacheAdapter<T> {
   private readonly inner;
   constructor(inner?: CacheAdapter<T>);
   private normalize;
@@ -274,7 +274,7 @@ declare class NormalizedCacheAdapter<T = unknown> implements CacheAdapter<T> {
  * Two-tier cache with fast local L1 and shared L2.
  * L2 hits are promoted back to L1.
  */
-declare class TieredCacheAdapter<T = unknown> implements CacheAdapter<T> {
+export declare class TieredCacheAdapter<T = unknown> implements CacheAdapter<T> {
   private readonly l1;
   private readonly l2;
   private readonly l1Ttl?;
@@ -293,6 +293,89 @@ declare class TieredCacheAdapter<T = unknown> implements CacheAdapter<T> {
   delete(key: string): Promise<void>;
 }
 //#endregion
+//#region src/logger.d.ts
+interface Logger {
+  debug(message: string): void;
+  warn(message: string): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+}
+/**
+ * Default logger. `debug` is gated by the `debug` option on VernLLM
+ * warn/error always fire since they indicate real problems (retries, cache failures)
+ */
+export declare class ConsoleLogger implements Logger {
+  private debugEnabled;
+  constructor(debugEnabled: boolean);
+  debug(message: string): void;
+  warn(message: string): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+}
+//#endregion
+//#region src/types/usage.d.ts
+type ReserveUsage = (params: {
+  coalesced: boolean;
+  signal?: AbortSignal;
+}) => Promise<void>;
+type RefundUsage = (params: {
+  coalesced: boolean;
+  signal?: AbortSignal;
+}) => Promise<void>;
+/**
+ * The reserve/refund usage hooks shared by `CallParams`, `CachedCallParams`,
+ * and `VernLLM`'s internal `withReservedUsage`. Centralized here so the pair
+ * has one definition instead of being redeclared at each use site.
+ */
+interface UsageHooks {
+  /**
+   * Reserves usage before the request. Failures become
+   * LLMError('quota_exceeded').
+   */
+  reserveUsage?: ReserveUsage;
+  /**
+   * Refunds usage after a failed call if reservation succeeded.
+   */
+  refundUsage?: RefundUsage;
+}
+interface TokenUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  /**
+   * Tokens spent on internal reasoning, a subset of `completionTokens`,
+   * never added on top of it. Undefined when the provider's response
+   * doesn't report a separate reasoning figure, e.g. Bedrock Converse
+   * without an explicit `additionalModelResponseFieldPaths` request.
+   */
+  reasoningTokens?: number;
+  requestId: string;
+  model: string;
+  /**
+   * The provider target that produced this usage. See `VernLLMOptions['name']`,
+   * default `'primary'`. Optional so consumers constructing a `TokenUsage`
+   * themselves (e.g. in tests) aren't forced to supply it; `VernLLM` always
+   * populates it. Absent means the same as `'primary'` if you need a value.
+   */
+  provider?: string;
+  /**
+   * Whether this usage came from a fallback target rather than the
+   * primary. Optional for the same reason `provider` is: `VernLLM`
+   * always populates it, a hand-constructed `TokenUsage` (e.g. in tests)
+   * isn't forced to.
+   */
+  usedFallback?: boolean;
+}
+type OnUsage = (usage: TokenUsage) => void;
+/**
+ * Called when a provider response arrives but VernLLM's own post-processing
+ * then fails, after usage data was already present in that response. Covers
+ * any error thrown after usage extraction, not just parse/validation, since
+ * everything in that path only runs once a response, and real spend, has
+ * already arrived. Fires once per failed attempt with extractable usage,
+ * never for transport failures, where no response means no honest number
+ * to report.
+ */
+type OnUsageFailure = (usage: TokenUsage, error: LLMError) => void;
+//#endregion
 //#region src/types/events.d.ts
 /**
  * Reports what happened during a call. Fire and forget, mirroring
@@ -359,6 +442,26 @@ type VernLLMEvent = {
   hook: 'transform' | 'wrap_short_circuit' | 'enabled_skip';
   /** For `hook: 'transform'` only: which top-level fields the merged patch touched. */
   patchedFields?: string[];
+} | {
+  /**
+   * Reported once a call fully succeeds. Same data `VernLLMOptions.onUsage`
+   * receives; that option is sugar over this event, not a second
+   * reporting path, see `makeEventReporter`.
+   */
+  kind: 'usage';
+  requestId: string;
+  usage: TokenUsage;
+} | {
+  /**
+   * A provider response arrived, carrying real usage, and VernLLM's own
+   * post-processing then failed. Fires once per failed attempt with
+   * extractable usage, matching `VernLLMOptions.onUsageFailure`'s own
+   * granularity, which this event is sugar over, not a second path.
+   */
+  kind: 'usage_failure';
+  requestId: string;
+  usage: TokenUsage;
+  error: LLMError;
 };
 type OnEvent = (event: VernLLMEvent) => void;
 //#endregion
@@ -372,6 +475,19 @@ interface MiddlewareCapabilities {
    */
   supportsJsonObjectMode: boolean;
 }
+/**
+ * Not exported. Distinguishes `MiddlewareStateKey<T>` from
+ * `MiddlewareRef` and from a plain `{ debugName }` object literal at
+ * the type level, even though all three have the identical runtime
+ * shape. Without this, `MiddlewareStateKey<T>`/`MiddlewareRef` are
+ * structurally just `{ debugName: string }`, so TypeScript would treat
+ * a state key as a valid middleware ref (or vice versa), and would let
+ * anyone hand-write `{ debugName: 'auth' }` in place of a real
+ * `createMiddlewareRef` result. Neither is possible once this brand is
+ * required: only `createStateKey`, which alone has access to this
+ * symbol, can produce a value satisfying `MiddlewareStateKey<T>`.
+ */
+declare const stateKeyBrand: unique symbol;
 /**
  * A typed reference to one slot in `ctx.state`. Create one with
  * `createStateKey`, export it, and import the same reference wherever
@@ -382,6 +498,7 @@ interface MiddlewareCapabilities {
  */
 interface MiddlewareStateKey<T> {
   readonly debugName: string;
+  readonly [stateKeyBrand]: true;
   /**
    * Never set at runtime; exists purely so `T` is actually used
    * somewhere in this interface's shape (a phantom type), which is what
@@ -392,7 +509,43 @@ interface MiddlewareStateKey<T> {
   readonly __phantom?: T;
 }
 /** Creates a new, distinct `MiddlewareStateKey`. `debugName` is used only in log lines and the `'middleware'` event; it never affects equality. */
-declare function createStateKey<T>(debugName: string): MiddlewareStateKey<T>;
+export declare function createStateKey<T>(debugName: string): MiddlewareStateKey<T>;
+/** Not exported. See `stateKeyBrand`; same reasoning, distinct symbol, so the two token types can't be cross-assigned either. */
+declare const middlewareRefBrand: unique symbol;
+/**
+ * A typed reference to one middleware's identity, for `runsAfter`/
+ * `runsBefore` to target. Purely an ordering concern: unlike `name`,
+ * `ref` is never used as a display label anywhere (`name` still covers
+ * that), only as a `runsAfter`/`runsBefore` match target. Create one
+ * with `createMiddlewareRef`, export it from the package that owns the
+ * middleware, and have any dependent import the same reference instead
+ * of typing a matching `name` string. Same reasoning as
+ * `MiddlewareStateKey`: a typo becomes a missing import, a compile
+ * error, instead of a silently unresolved (or worse, silently
+ * colliding) string.
+ */
+interface MiddlewareRef {
+  readonly debugName: string;
+  readonly [middlewareRefBrand]: true;
+}
+/** Creates a new, distinct `MiddlewareRef`. `debugName` is used only in error messages when a reference doesn't resolve; it never affects equality, so two refs with the same `debugName` never collide. */
+export declare function createMiddlewareRef(debugName: string): MiddlewareRef;
+/**
+ * A `runsAfter`/`runsBefore` entry that escalates an unresolved
+ * reference from a warning to a construction-time throw. Wrap a
+ * `MiddlewareRef` with `requireRef` when the dependency isn't optional:
+ * a bare `MiddlewareRef` in `runsAfter`/`runsBefore` means "order
+ * relative to this if it's registered," which is the right default for
+ * a dependency a third party may reasonably not have installed. A
+ * `RequiredMiddlewareRef` means "this middleware must not run without
+ * that dependency having already run". The app should fail to start
+ * rather than run with a silently-missing ordering guarantee.
+ */
+interface RequiredMiddlewareRef {
+  readonly ref: MiddlewareRef;
+}
+/** Wraps `ref` so `runsAfter`/`runsBefore` throws at `VernLLM` construction time if it doesn't resolve, instead of warning and continuing. */
+export declare function requireRef(ref: MiddlewareRef): RequiredMiddlewareRef;
 /**
  * Typed, per-logical-call storage two middleware can deliberately share a
  * value through (a span ID one sets, another reads). Backed by a plain
@@ -404,7 +557,7 @@ interface MiddlewareStateBag {
   set<T>(key: MiddlewareStateKey<T>, value: T): void;
 }
 /** A plain, `Map`-backed `MiddlewareStateBag`. */
-declare function createMiddlewareStateBag(): MiddlewareStateBag;
+export declare function createMiddlewareStateBag(): MiddlewareStateBag;
 /** Fields every `MiddlewareContext` variant carries, regardless of `stage`. */
 interface MiddlewareContextBase {
   requestId: string;
@@ -554,22 +707,36 @@ interface CallResult<T = unknown> {
 interface VernLLMMiddleware {
   /** Used in log lines and the `'middleware'` event. Defaults to this entry's array position when omitted. */
   name?: string;
+  /**
+   * This entry's own identity, purely for another middleware's
+   * `runsAfter`/`runsBefore` to target. Create with `createMiddlewareRef`,
+   * export it, and have a dependent import the same reference. Optional:
+   * only needed if something else must be able to depend on this
+   * specific entry. Unrelated to `name`: `ref` is never shown in logs,
+   * `name` is never matched against for ordering.
+   */
+  ref?: MiddlewareRef;
   /** Sort key for composition order, ascending, ties broken by array order. See the middleware docs for what "lower runs first" means for `wrap`. */
   priority?: number;
   /**
-   * Names of other middleware this entry must run after, breaking ties
-   * `priority` alone can't express. A referenced name absent from the
-   * registered set is dropped, not an error, since a third party may
-   * reasonably reference a well known name that isn't installed
-   * everywhere. A cycle across `runsAfter`/`runsBefore` throws at
-   * `VernLLM` construction time.
+   * Other middleware this entry must run after, breaking ties
+   * `priority` alone can't express. Matched by `ref` identity, so a
+   * typo or a stale copy simply fails to resolve instead of silently
+   * matching the wrong entry. A bare `MiddlewareRef` that doesn't
+   * resolve is dropped, not an error, since a third party may
+   * reasonably reference a well known middleware that isn't installed
+   * everywhere; wrap it with `requireRef` to make that same target
+   * mandatory instead, throwing at `VernLLM` construction time if it's
+   * missing. A cycle across `runsAfter`/`runsBefore` always throws,
+   * regardless of whether any individual entry is required.
    */
-  runsAfter?: string[];
+  runsAfter?: (MiddlewareRef | RequiredMiddlewareRef)[];
   /**
-   * Names of other middleware this entry must run before. See
-   * `runsAfter`; an absent reference is dropped, not an error.
+   * Other middleware this entry must run before. See `runsAfter`; a
+   * bare reference is dropped if unresolved, a `requireRef`-wrapped one
+   * throws.
    */
-  runsBefore?: string[];
+  runsBefore?: (MiddlewareRef | RequiredMiddlewareRef)[];
   /**
    * Pins this entry's slot in `wrap` nesting only, independent of
    * `priority`/`runsAfter`/`runsBefore`, which still govern
@@ -611,17 +778,21 @@ interface CircuitBreakerCallContext {
   /** Omitted for calls before any attempt exists, like `assertClosed`'s pre-dispatch check. */
   attempt?: number;
 }
+/**
+ * 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.
+ * Shared by `CircuitBreakerOptions` and `CircuitBreakerAdapter`, so a
+ * custom adapter reports state changes the same way the built in
+ * `CircuitBreaker` does.
+ */
+type CircuitBreakerStateChangeHandler = (from: CircuitState, to: CircuitState, consecutiveFailures: number, model?: string, context?: CircuitBreakerCallContext) => void;
 interface CircuitBreakerOptions {
   /** Consecutive failures before the circuit opens, default 5 */
   threshold?: number;
   /** How long the circuit stays open before allowing a trial request, in ms. Default 30000 */
   cooldownMs?: number;
-  /**
-   * 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, context?: CircuitBreakerCallContext) => void;
+  onStateChange?: CircuitBreakerStateChangeHandler;
   /**
    * Track a separate circuit per resolved model instead of one shared
    * circuit. Default false. A call that omits `model` falls into one
@@ -681,7 +852,7 @@ interface TrippingPolicy {
    */
   forget?(key: string): void;
 }
-declare class ConsecutiveTripping implements TrippingPolicy {
+export declare class ConsecutiveTripping implements TrippingPolicy {
   private readonly threshold;
   private failuresByKey;
   constructor(threshold: number);
@@ -690,7 +861,7 @@ declare class ConsecutiveTripping implements TrippingPolicy {
   reset(key: string): void;
   forget(key: string): void;
 }
-declare class RollingTripping implements TrippingPolicy {
+export declare class RollingTripping implements TrippingPolicy {
   private readonly windowMs;
   private readonly minCalls;
   private readonly failureRatio;
@@ -713,14 +884,65 @@ type TrippingOption = {
   failureRatio: number;
 } | TrippingPolicy;
 type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * What VernLLM's dispatch layer needs from a breaker. `CircuitBreaker`
+ * implements this; a caller wanting cross process coordination can hand
+ * over their own instance instead.
+ *
+ * `assertClosed`, `recordSuccess`, `recordFailure`, and `onStateChange`
+ * are required, mirroring `RateLimiterAdapter`'s four required methods.
+ * `onStateChange` is required so `circuit_state` events can't go
+ * silently missing; a no-op `() => {}` is fine if you don't care.
+ *
+ * `getState`, `getFailureBreakdown`, `isolateByModel`, `open`, and
+ * `close` are optional. Omitting one makes the matching call a no-op
+ * or return `undefined`/`false`, same as no breaker configured.
+ * `open`/`close` are optional since they let VernLLM force a
+ * transition, control a distributed adapter may not want to grant.
+ */
+interface CircuitBreakerAdapter {
+  /** Throws when the circuit is open (or half open with no trial slot free) for `model`. */
+  assertClosed(model?: string, context?: CircuitBreakerCallContext): void;
+  recordSuccess(model?: string, context?: CircuitBreakerCallContext): void;
+  /** `code`, when present, is the failing call's `LLMErrorCode`. */
+  recordFailure(model?: string, context?: CircuitBreakerCallContext, code?: LLMErrorCode): void;
+  getState?(model?: string): CircuitState;
+  /** Failure counts by `LLMErrorCode` for `model`'s bucket, `'unknown'` for one that carried no code. */
+  getFailureBreakdown?(model?: string): Partial<Record<LLMErrorCode | 'unknown', number>>;
+  /** Whether this adapter tracks failures per model, mirroring `CircuitBreakerOptions.isolateByModel`. Read by `warnIfModelUnsupported`'s diagnostic warning and by `VernLLM.getCircuitStates()`'s public output; omit if the notion doesn't apply to your adapter, `false` is assumed. */
+  isolateByModel?: boolean;
+  /** Manually opens the circuit, as if enough consecutive failures had just happened. Optional: an adapter that doesn't want external callers forcing a transition can omit it. */
+  open?(model?: string, context?: CircuitBreakerCallContext): void;
+  /** Manually closes the circuit, without requiring a real success first. Same opt-in reasoning as `open`. */
+  close?(model?: string, context?: CircuitBreakerCallContext): void;
+  /** Gives back a half-open trial slot when a call ends without `recordSuccess` or `recordFailure`. Idempotent, and a no-op for a call that holds no slot. */
+  releaseTrial?(model?: string, context?: CircuitBreakerCallContext): void;
+  /** Awaited right before `assertClosed` to refresh local state. Never blocks or fails a call: a rejection or `prepareTimeoutMs` is logged and the call carries on. */
+  prepare?(model?: string, context?: CircuitBreakerCallContext): Promise<void>;
+  /** How long to wait for `prepare`, in ms. Default 1000. */
+  prepareTimeoutMs?: number;
+  /** Live counterpart of `getState`, read by `VernLLM.readCircuitStates()`. */
+  readState?(model?: string): Promise<CircuitState>;
+  /** Receives the instance's `Logger` once, when `VernLLM` wires this adapter in. */
+  setLogger?(logger: Logger): void;
+  /**
+   * Called after every real state change, never a no-op transition. VernLLM
+   * wraps it the same way it wraps the built in `CircuitBreaker`'s
+   * `onStateChange`: every call still reports a `circuit_state` event
+   * first, then this hook is chained after that, wrapped so a throw here
+   * can't break the call that triggered it.
+   */
+  onStateChange: CircuitBreakerStateChangeHandler;
+}
 /**
  * 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 {
+export declare class CircuitBreaker implements CircuitBreakerAdapter {
   private readonly cooldownMs;
-  private readonly onStateChange?;
+  /** Satisfies `CircuitBreakerAdapter.onStateChange`, required there. Defaults to a no-op when `options.onStateChange` is omitted. */
+  readonly onStateChange: CircuitBreakerStateChangeHandler;
   /** Whether this breaker tracks failures per model instead of one shared circuit. */
   readonly isolateByModel: boolean;
   private readonly halfOpenProbes;
@@ -739,6 +961,14 @@ declare class CircuitBreaker {
   recordSuccess(model?: string, context?: CircuitBreakerCallContext): void;
   /** `code`, when present, is the failing `LLMError`'s `code`. Missing attributes to `'unknown'`. */
   recordFailure(model?: string, context?: CircuitBreakerCallContext, code?: LLMErrorCode): void;
+  /**
+   * Gives back the half-open trial slot `context`'s call claimed, when
+   * that call ended without recording an outcome. No-op without a
+   * `context`, when the bucket isn't half-open, or when the call's permit
+   * is stale or already spent (an outcome was recorded), so calling it
+   * defensively on every failure path is safe.
+   */
+  releaseTrial(model?: string, context?: CircuitBreakerCallContext): 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. */
@@ -801,7 +1031,7 @@ interface RetryBudgetOptions {
  * the same primitive `RollingTripping` is built on, rather than a second
  * hand rolled window.
  */
-declare class RetryBudget {
+export declare class RetryBudget {
   private readonly options;
   private readonly ratio;
   constructor(options: RetryBudgetOptions);
@@ -820,7 +1050,7 @@ declare class RetryBudget {
   };
 }
 //#endregion
-//#region src/internal/utils/rateLimitHint.utils.d.ts
+//#region src/internal/utils/rate-limit/rateLimitHint.utils.d.ts
 /** A normalized read of a provider's rate limit headers. */
 interface ProviderRateLimitHint {
   remainingRequests?: number;
@@ -911,7 +1141,7 @@ interface RateLimitAcquireResult {
   reason?: RateLimitReason;
 }
 /** Default `estimateTokens`: chars/4 over every message's content, plus the requested `max_tokens`. */
-declare function defaultEstimateTokens(request: WireRequest): number;
+export 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
@@ -926,6 +1156,10 @@ interface RateLimiterAdapter {
   reactToRateLimitHint(hint: ProviderRateLimitHint | undefined): void;
   /** Optional: current bucket levels, for introspection. Omit if the adapter has no state worth reporting. */
   getState?(): RateLimitState;
+  /** Optional: live bucket levels for `VernLLM.readRateLimitState()`, the async counterpart of `getState`. */
+  readState?(): Promise<RateLimitState>;
+  /** Optional: receives the instance's `Logger` once, when `VernLLM` wires this adapter in. */
+  setLogger?(logger: Logger): void;
 }
 /**
  * Per-target rate limiter. Up to three buckets (requests/min, tokens/min,
@@ -933,7 +1167,7 @@ interface RateLimiterAdapter {
  * stream of small ones. Any bucket omitted from `options` has infinite
  * capacity and never blocks.
  */
-declare class RateLimiter implements RateLimiterAdapter {
+export declare class RateLimiter implements RateLimiterAdapter {
   private readonly requests?;
   private readonly tokens?;
   private readonly concurrency?;
@@ -1019,7 +1253,7 @@ declare class RateLimiter implements RateLimiterAdapter {
   getState(): RateLimitState;
 }
 //#endregion
-//#region src/internal/utils/rateLimitAdapter.utils.d.ts
+//#region src/internal/utils/rate-limit/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
@@ -1121,7 +1355,7 @@ type FallbackOn = (error: LLMError, context: {
  * The default `fallbackOn` policy. Exported so a caller can wrap rather
  * than replace it, e.g. `fallbackOn: (e, ctx) => myCheck(e) ? 'stop' : defaultFallbackOn(e, ctx)`.
  */
-declare const defaultFallbackOn: FallbackOn;
+export declare const defaultFallbackOn: FallbackOn;
 /**
  * Thrown when the chain gives up, whether because the last target failed
  * or `fallbackOn` chose to stop early. Carries each attempt in order so
@@ -1131,7 +1365,7 @@ declare const defaultFallbackOn: FallbackOn;
  * so existing type-based handling, including reading `retryAfterMs` on an
  * `'api'`-typed error, keeps working on a fallback-exhausted error too.
  */
-declare class FallbackExhaustedError extends LLMError {
+export declare class FallbackExhaustedError extends LLMError {
   readonly attempts: FallbackAttempt[];
   constructor(attempts: FallbackAttempt[]);
   /**
@@ -1143,7 +1377,7 @@ declare class FallbackExhaustedError extends LLMError {
   get retryable(): boolean;
 }
 /** Narrows `err` to {@link FallbackExhaustedError}, for direct access to its `attempts` (`provider`/`model` per failed target) without a manual `instanceof` check. */
-declare function isFallbackExhaustedError(err: unknown): err is FallbackExhaustedError;
+export declare function isFallbackExhaustedError(err: unknown): err is FallbackExhaustedError;
 /**
  * Creates an empty ref box to pass as `CallParams['meta']`, so a caller can
  * read the `CallMeta` written by `call()` on the same line as the result
@@ -1154,7 +1388,7 @@ declare function isFallbackExhaustedError(err: unknown): err is FallbackExhauste
  * const result = await vern.call({ userContent: '...', meta });
  * meta.current?.provider;
  */
-declare function metaRef(): {
+export declare function metaRef(): {
   current?: CallMeta;
 };
 //#endregion
@@ -1229,7 +1463,7 @@ interface ToolDefinition<Name extends string = string, Args = unknown> {
  * in `defineTool()` preserves the literal `name` type without requiring
  * `as const` at every call site.
  */
-declare function defineTool<const Name extends string, Args = unknown>(tool: ToolDefinition<Name, Args>): ToolDefinition<Name, Args>;
+export declare function defineTool<const Name extends string, Args = unknown>(tool: ToolDefinition<Name, Args>): ToolDefinition<Name, Args>;
 /** Maps a single `ToolDefinition` to its matching `ToolCall` shape. */
 type ToolCallFor<T> = T extends ToolDefinition<infer N, infer A> ? {
   id: string;
@@ -1290,77 +1524,12 @@ type ResolvedTools<Tools, R> = [Tools] extends [never] ? ExtractTools<R> : Tools
  *
  * Pass `Tools` explicitly to override inference, e.g. `isToolCallResult<typeof tools>(result)`.
  */
-declare function isToolCallResult<Tools extends readonly ToolDefinition[] | undefined = never, R = unknown>(result: R): result is R & ToolCallResult<NonNullable<ResolvedTools<Tools, R>>>;
+export declare function isToolCallResult<Tools extends readonly ToolDefinition[] | undefined = never, R = unknown>(result: R): result is R & ToolCallResult<NonNullable<ResolvedTools<Tools, R>>>;
 /** What the model should do about tools on a given call. */
 type ToolChoice = 'auto' | 'none' | 'required' | {
   name: string;
 };
 //#endregion
-//#region src/types/usage.d.ts
-type ReserveUsage = (params: {
-  coalesced: boolean;
-  signal?: AbortSignal;
-}) => Promise<void>;
-type RefundUsage = (params: {
-  coalesced: boolean;
-  signal?: AbortSignal;
-}) => Promise<void>;
-/**
- * The reserve/refund usage hooks shared by `CallParams`, `CachedCallParams`,
- * and `VernLLM`'s internal `withReservedUsage`. Centralized here so the pair
- * has one definition instead of being redeclared at each use site.
- */
-interface UsageHooks {
-  /**
-   * Reserves usage before the request. Failures become
-   * LLMError('quota_exceeded').
-   */
-  reserveUsage?: ReserveUsage;
-  /**
-   * Refunds usage after a failed call if reservation succeeded.
-   */
-  refundUsage?: RefundUsage;
-}
-interface TokenUsage {
-  promptTokens: number;
-  completionTokens: number;
-  totalTokens: number;
-  /**
-   * Tokens spent on internal reasoning, a subset of `completionTokens`,
-   * never added on top of it. Undefined when the provider's response
-   * doesn't report a separate reasoning figure, e.g. Bedrock Converse
-   * without an explicit `additionalModelResponseFieldPaths` request.
-   */
-  reasoningTokens?: number;
-  requestId: string;
-  model: string;
-  /**
-   * The provider target that produced this usage. See `VernLLMOptions['name']`,
-   * default `'primary'`. Optional so consumers constructing a `TokenUsage`
-   * themselves (e.g. in tests) aren't forced to supply it; `VernLLM` always
-   * populates it. Absent means the same as `'primary'` if you need a value.
-   */
-  provider?: string;
-  /**
-   * Whether this usage came from a fallback target rather than the
-   * primary. Optional for the same reason `provider` is: `VernLLM`
-   * always populates it, a hand-constructed `TokenUsage` (e.g. in tests)
-   * isn't forced to.
-   */
-  usedFallback?: boolean;
-}
-type OnUsage = (usage: TokenUsage) => void;
-/**
- * Called when a provider response arrives but VernLLM's own post-processing
- * then fails, after usage data was already present in that response. Covers
- * any error thrown after usage extraction, not just parse/validation, since
- * everything in that path only runs once a response, and real spend, has
- * already arrived. Fires once per failed attempt with extractable usage,
- * never for transport failures, where no response means no honest number
- * to report.
- */
-type OnUsageFailure = (usage: TokenUsage, error: LLMError) => void;
-//#endregion
 //#region src/types/call.d.ts
 /**
  * Any valid JSON value: a primitive, `null`, or a JSON array/object made
@@ -1701,6 +1870,13 @@ interface SoftFailureMeta {
   isFallback: boolean;
   /** 1-based, matching `CallMeta.attempts`. */
   attempt: number;
+  /**
+   * Token usage for this attempt, if the provider reported it on this
+   * response. `undefined` when the provider omitted usage, not when
+   * usage was zero, so a cost check should treat a missing value as
+   * unknown rather than as free.
+   */
+  usage?: TokenUsage;
 }
 /**
  * Inspects an otherwise-successful result and optionally reclassifies it
@@ -1775,7 +1951,7 @@ type ExtractStreamValue<R> = Extract<R, StreamCallResult<unknown>> extends Strea
  * }
  * ```
  */
-declare function isStreamResult<R = unknown>(result: R): result is R & StreamCallResult<ExtractStreamValue<R>>;
+export declare function isStreamResult<R = unknown>(result: R): result is R & StreamCallResult<ExtractStreamValue<R>>;
 /**
  * `StreamEnabledCallParams` with `jsonMode: false`. Selects the streaming
  * `call()` overload whose `finalResult` resolves to a plain `string`.
@@ -2053,7 +2229,7 @@ interface LLMClient {
   };
 }
 //#endregion
-//#region src/internal/utils/cacheAdapter.utils.d.ts
+//#region src/internal/utils/cache/cacheAdapter.utils.d.ts
 /**
  * Not exported. Internal shorthand for `VernLLMOptions.cache`, so the
  * union isn't duplicated between that field and `buildCache`'s own
@@ -2065,23 +2241,15 @@ type CacheOption = {
   eviction?: EvictionOption;
 } | CacheAdapter;
 //#endregion
-//#region src/logger.d.ts
-interface Logger {
-  debug(message: string): void;
-  warn(message: string): void;
-  error(message: string, meta?: Record<string, unknown>): void;
-}
+//#region src/internal/utils/circuit-breaker/circuitBreakerAdapter.utils.d.ts
 /**
- * Default logger. `debug` is gated by the `debug` option on VernLLM
- * warn/error always fire since they indicate real problems (retries, cache failures)
+ * Not re-exported from the package root, imported directly from this
+ * internal module by `VernLLMOptions.circuitBreaker`'s own type (see
+ * options.ts) so that union isn't duplicated between the public option
+ * field and `buildCircuitBreaker`'s own signature below, same pattern
+ * `CacheOption` and `RateLimitOption` already use for their own options.
  */
-declare class ConsoleLogger implements Logger {
-  private debugEnabled;
-  constructor(debugEnabled: boolean);
-  debug(message: string): void;
-  warn(message: string): void;
-  error(message: string, meta?: Record<string, unknown>): void;
-}
+type CircuitBreakerOption = boolean | CircuitBreakerOptions | CircuitBreakerAdapter;
 //#endregion
 //#region src/types/options.d.ts
 interface VernLLMOptions {
@@ -2196,9 +2364,11 @@ interface VernLLMOptions {
   /**
    * Enables a circuit breaker that short-circuits calls after repeated
    * consecutive failures, instead of continuing to hammer a down provider
-   * Pass `true` for defaults, or an options object to tune threshold/cooldown
+   * Pass `true` for defaults, or an options object to tune threshold/cooldown.
+   * Pass a `CircuitBreakerAdapter` instead for cross-process coordination,
+   * the same pattern `cache` and `rateLimit` already support.
    */
-  circuitBreaker?: boolean | CircuitBreakerOptions;
+  circuitBreaker?: CircuitBreakerOption;
   /**
    * Reports retries and circuit-breaker state transitions as they happen.
    * Fire and forget: a throwing handler is caught and logged, and its
@@ -2296,7 +2466,7 @@ type CreateMiddlewareOptions = Omit<VernLLMMiddleware, 'wrap'> & {
  * error afterward, so `onError` never changes what the call itself
  * returns or throws, only what gets observed about it.
  */
-declare function createMiddleware(options: CreateMiddlewareOptions): VernLLMMiddleware;
+export declare function createMiddleware(options: CreateMiddlewareOptions): VernLLMMiddleware;
 //#endregion
 //#region src/vernLLM.d.ts
 /**
@@ -2307,7 +2477,7 @@ declare function createMiddleware(options: CreateMiddlewareOptions): VernLLMMidd
  * tracking, and an optional response cache. All configurable, all opt-in
  * beyond sensible defaults.
  */
-declare class VernLLM {
+export declare class VernLLM {
   private readonly logger;
   /**
    * One `CallExecutor` per provider target: index 0 is the primary,
@@ -2478,6 +2648,22 @@ declare class VernLLM {
    * @returns Every target's state, in chain order.
    */
   getCircuitStates(model?: string): TargetCircuitState[];
+  /**
+   * The live counterpart of `getRateLimitState`, asking the limiter for its current levels.
+   *
+   * @param target.index Which target to read. Defaults to the primary.
+   * @returns This target's live rate limit levels, or `undefined` if that target has no limiter
+   * configured.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  readRateLimitState(target?: Pick<CircuitTarget, 'index'>): Promise<RateLimitState | undefined>;
+  /**
+   * The live counterpart of `getCircuitStates`, asking each breaker for its current state.
+   *
+   * @param model Which model bucket to read, for targets that isolate by model.
+   * @returns Every target's state, in chain order.
+   */
+  readCircuitStates(model?: string): Promise<TargetCircuitState[]>;
   /**
    * Manually opens a target's breaker, e.g. to pull a provider out of
    * rotation ahead of known maintenance instead of waiting for it to fail.
@@ -2518,7 +2704,7 @@ declare class VernLLM {
  * `T` isn't a parameter here; pin it via `llm.call<T>(params)` as usual.
  * `defineCachedCallParams` is the `cachedCall()` counterpart.
  */
-declare function defineCallParams<P extends CallParams<unknown>>(params: P): P;
+export declare function defineCallParams<P extends CallParams<unknown>>(params: P): P;
 /**
  * The `cachedCall()` counterpart to `defineCallParams`: preserves the
  * whole `{ cacheKey, ttl, call }` object, `call.tools` included, in one
@@ -2533,7 +2719,7 @@ declare function defineCallParams<P extends CallParams<unknown>>(params: P): P;
  * const result = await llm.cachedCall(params);
  * ```
  */
-declare function defineCachedCallParams<P extends CachedCallParams<unknown>>(params: P): P;
+export declare function defineCachedCallParams<P extends CachedCallParams<unknown>>(params: P): P;
 //#endregion
 //#region src/adapters/internal/sse.d.ts
 /**
@@ -2563,14 +2749,14 @@ declare function defineCachedCallParams<P extends CachedCallParams<unknown>>(par
  * Malformed JSON in a frame throws `LLMError('parse')`, consistent with
  * how malformed JSON is handled elsewhere in VernLLM.
  */
-declare function parseSseStream(source: AsyncIterable<Uint8Array | string>): AsyncGenerator<unknown>;
+export declare function parseSseStream(source: AsyncIterable<Uint8Array | string>): AsyncGenerator<unknown>;
 /**
  * Sentinel yielded by `parseSseStream` for a comment-only frame (no
  * `data:` payload), the mechanism providers use for SSE keep-alive
  * pings. Exported so a consumer (e.g. `fromFetch`) can react to "still
  * alive" separately from a genuinely empty frame (`NO_DATA`, kept internal).
  */
-declare const SSE_PING: unique symbol;
+export declare const SSE_PING: unique symbol;
 //#endregion
 //#region src/adapters/internal/imageFormat.d.ts
 /**
@@ -2817,7 +3003,7 @@ interface AnthropicAdapterOptions {
  * instead, which maps to a real constraint either way (native
  * `output_config.format` or a forced tool call).
  */
-declare function fromAnthropic(anthropicClient: AnthropicClient, options?: AnthropicAdapterOptions): LLMClient;
+export declare function fromAnthropic(anthropicClient: AnthropicClient, options?: AnthropicAdapterOptions): LLMClient;
 //#endregion
 //#region src/adapters/gemini.d.ts
 /**
@@ -3029,7 +3215,7 @@ interface GeminiAdapterOptions {
    */
   thinkingLevelModels?: ModelCapabilityOverride;
 }
-declare function fromGemini(client: GeminiClient, options?: GeminiAdapterOptions): LLMClient;
+export declare function fromGemini(client: GeminiClient, options?: GeminiAdapterOptions): LLMClient;
 //#endregion
 //#region src/adapters/bedrock.d.ts
 /** Bedrock Converse's supported inline image formats. */
@@ -3388,7 +3574,7 @@ interface AwsSendClient {
  * `finalizeResponse`'s `content` path exactly like the non-streaming
  * `create` branch above unwraps it.
  */
-declare function fromBedrock(bedrockClient: BedrockConverseClient | AwsSendClient, options?: BedrockAdapterOptions): LLMClient;
+export declare function fromBedrock(bedrockClient: BedrockConverseClient | AwsSendClient, options?: BedrockAdapterOptions): LLMClient;
 //#endregion
 //#region src/adapters/fetch.d.ts
 /** The chat-completion-shaped request VernLLM builds internally */
@@ -3550,7 +3736,7 @@ interface FetchAdapterConfig {
  * `LLMError('validation')` instead of quietly using unrelated native
  * `fetch`.
  */
-declare function fromFetch(config: FetchAdapterConfig): LLMClient;
+export declare function fromFetch(config: FetchAdapterConfig): LLMClient;
 //#endregion
 //#region src/adapters/openaiCompatible.d.ts
 /**
@@ -3617,7 +3803,7 @@ interface OpenAICompatibleAdapterOptions {
    */
   supportsWithResponse?: boolean;
 }
-declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibleAdapterOptions): LLMClient;
+export declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibleAdapterOptions): LLMClient;
 /**
  * Named alias for the OpenAI SDK itself. A raw `new OpenAI(...)` instance
  * structurally matches most of `LLMClient`, but newer `openai` SDK major
@@ -3635,9 +3821,9 @@ declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibl
  * 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;
+export declare const fromOpenAI: typeof fromOpenAICompatible;
 /** Groqs SDK matches the OpenAI wire format */
-declare const fromGroq: typeof fromOpenAICompatible;
+export declare const fromGroq: typeof fromOpenAICompatible;
 /**
  * Mistrals `chat.completions`-shaped client (or their OpenAI-compat
  * endpoint). Mistral supports `stream_options.include_usage` (added after
@@ -3645,88 +3831,88 @@ declare const fromGroq: typeof fromOpenAICompatible;
  * Mistral's changelog and streaming docs), so this is a plain alias like
  * the others, `supportsStreamUsage` defaults to `true`.
  */
-declare const fromMistral: typeof fromOpenAICompatible;
+export declare const fromMistral: typeof fromOpenAICompatible;
 /** DeepSeeks API is OpenAI-compatible */
-declare const fromDeepSeek: typeof fromOpenAICompatible;
+export declare const fromDeepSeek: typeof fromOpenAICompatible;
 /** Cerebras inference API is OpenAI-compatible */
-declare const fromCerebras: typeof fromOpenAICompatible;
+export declare const fromCerebras: typeof fromOpenAICompatible;
 /** Together AIs API is OpenAI-compatible */
-declare const fromTogether: typeof fromOpenAICompatible;
+export declare const fromTogether: typeof fromOpenAICompatible;
 /** Fireworks AIs API is OpenAI-compatible */
-declare const fromFireworks: typeof fromOpenAICompatible;
+export declare const fromFireworks: typeof fromOpenAICompatible;
 /**
  * Ollama exposes an OpenAI-compatible endpoint at `/v1/chat/completions`
  * (as opposed to its native `/api/chat` format, which differs). Point an
  * OpenAI SDK instances `baseURL` at your Ollama server and pass it here:
  * this does not talk to Ollamas native API directly.
  */
-declare const fromOllama: typeof fromOpenAICompatible;
+export declare const fromOllama: typeof fromOpenAICompatible;
 /** OpenRouter's API is OpenAI-compatible */
-declare const fromOpenRouter: typeof fromOpenAICompatible;
+export declare const fromOpenRouter: typeof fromOpenAICompatible;
 /** Perplexity's API is OpenAI-compatible */
-declare const fromPerplexity: typeof fromOpenAICompatible;
+export declare const fromPerplexity: typeof fromOpenAICompatible;
 /** DeepInfra's API is OpenAI-compatible */
-declare const fromDeepInfra: typeof fromOpenAICompatible;
+export declare const fromDeepInfra: typeof fromOpenAICompatible;
 /** Novita's API is OpenAI-compatible */
-declare const fromNovita: typeof fromOpenAICompatible;
+export declare const fromNovita: typeof fromOpenAICompatible;
 /** Hyperbolic's API is OpenAI-compatible */
-declare const fromHyperbolic: typeof fromOpenAICompatible;
+export declare const fromHyperbolic: typeof fromOpenAICompatible;
 /** Moonshot's (Kimi) API is OpenAI-compatible */
-declare const fromMoonshot: typeof fromOpenAICompatible;
+export declare const fromMoonshot: typeof fromOpenAICompatible;
 /** Zhipu's (GLM) API is OpenAI-compatible */
-declare const fromZhipu: typeof fromOpenAICompatible;
+export declare const fromZhipu: typeof fromOpenAICompatible;
 /**
  * LM Studio exposes an OpenAI-compatible endpoint at `/v1/chat/completions`.
  * Point an OpenAI SDK instance's `baseURL` at your local LM Studio server.
  */
-declare const fromLMStudio: typeof fromOpenAICompatible;
+export declare const fromLMStudio: typeof fromOpenAICompatible;
 /**
  * vLLM's OpenAI-compatible server mode exposes `/v1/chat/completions`.
  * Point an OpenAI SDK instance's `baseURL` at your vLLM server.
  */
-declare const fromVLLM: typeof fromOpenAICompatible;
+export declare const fromVLLM: typeof fromOpenAICompatible;
 /** xAI's Grok API is OpenAI-compatible */
-declare const fromXAI: typeof fromOpenAICompatible;
+export declare const fromXAI: typeof fromOpenAICompatible;
 /** NVIDIA NIM's hosted and self-hosted endpoints are OpenAI-compatible */
-declare const fromNvidiaNIM: typeof fromOpenAICompatible;
+export declare const fromNvidiaNIM: typeof fromOpenAICompatible;
 /** Vercel AI Gateway is OpenAI-compatible */
-declare const fromVercelAIGateway: typeof fromOpenAICompatible;
+export declare const fromVercelAIGateway: typeof fromOpenAICompatible;
 /** Cloudflare Workers AI exposes an OpenAI-compatible endpoint */
-declare const fromCloudflareWorkersAI: typeof fromOpenAICompatible;
+export declare const fromCloudflareWorkersAI: typeof fromOpenAICompatible;
 /** Nebius AI Studio is OpenAI-compatible */
-declare const fromNebius: typeof fromOpenAICompatible;
+export declare const fromNebius: typeof fromOpenAICompatible;
 /** SambaNova Cloud's API is OpenAI-compatible */
-declare const fromSambaNova: typeof fromOpenAICompatible;
+export declare const fromSambaNova: typeof fromOpenAICompatible;
 /** Baseten's model hosting exposes an OpenAI-compatible endpoint */
-declare const fromBaseten: typeof fromOpenAICompatible;
+export declare const fromBaseten: typeof fromOpenAICompatible;
 /** Featherless AI's API is OpenAI-compatible */
-declare const fromFeatherless: typeof fromOpenAICompatible;
+export declare const fromFeatherless: typeof fromOpenAICompatible;
 /** Friendli AI's serving endpoint is OpenAI-compatible */
-declare const fromFriendli: typeof fromOpenAICompatible;
+export declare const fromFriendli: typeof fromOpenAICompatible;
 /** SiliconFlow's API is OpenAI-compatible */
-declare const fromSiliconFlow: typeof fromOpenAICompatible;
+export declare const fromSiliconFlow: typeof fromOpenAICompatible;
 /** Parasail's inference API is OpenAI-compatible */
-declare const fromParasail: typeof fromOpenAICompatible;
+export declare const fromParasail: typeof fromOpenAICompatible;
 /** StepFun's API is OpenAI-compatible */
-declare const fromStepFun: typeof fromOpenAICompatible;
+export declare const fromStepFun: typeof fromOpenAICompatible;
 /** MiniMax's API is OpenAI-compatible */
-declare const fromMiniMax: typeof fromOpenAICompatible;
+export declare const fromMiniMax: typeof fromOpenAICompatible;
 /** Lambda Labs' Inference API is OpenAI-compatible */
-declare const fromLambdaLabs: typeof fromOpenAICompatible;
+export declare const fromLambdaLabs: typeof fromOpenAICompatible;
 /** Snowflake Cortex's LLM endpoint is OpenAI-compatible */
-declare const fromSnowflakeCortex: typeof fromOpenAICompatible;
+export declare const fromSnowflakeCortex: typeof fromOpenAICompatible;
 /** Anyscale Endpoints' API is OpenAI-compatible */
-declare const fromAnyscale: typeof fromOpenAICompatible;
+export declare const fromAnyscale: typeof fromOpenAICompatible;
 /** Lepton AI's inference API is OpenAI-compatible */
-declare const fromLepton: typeof fromOpenAICompatible;
+export declare const fromLepton: typeof fromOpenAICompatible;
 /** Inference.net's API is OpenAI-compatible */
-declare const fromInferenceNet: typeof fromOpenAICompatible;
+export declare const fromInferenceNet: typeof fromOpenAICompatible;
 /** Infermatic's API is OpenAI-compatible */
-declare const fromInfermatic: typeof fromOpenAICompatible;
+export declare const fromInfermatic: typeof fromOpenAICompatible;
 /** AtlasCloud's inference API is OpenAI-compatible */
-declare const fromAtlasCloud: typeof fromOpenAICompatible;
+export declare const fromAtlasCloud: typeof fromOpenAICompatible;
 /** 01.AI's (Yi models) API is OpenAI-compatible */
-declare const from01AI: typeof fromOpenAICompatible;
+export declare const from01AI: typeof fromOpenAICompatible;
 //#endregion
-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, type RateLimitState, 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, isStreamResult, isToolCallResult, metaRef, parseSseStream };
+export type { AnthropicClient, AssistantContent, AttemptContext, BedrockConverseClient, CacheAdapter, CachedCallParams, CachedConditionalToolCallParams, CachedJsonModeDisabledCallParams, CachedJsonModeEnabledCallParams, CachedStreamCallParams, CachedStreamConditionalToolCallParams, CachedStreamJsonModeDisabledCallParams, CachedStreamJsonModeEnabledCallParams, CachedStreamToolCallParams, CachedToolCallParams, CallMeta, CallParams, CallResult, CallWithToolsResult, CircuitBreakerAdapter, CircuitBreakerCallContext, CircuitBreakerOptions, CircuitBreakerStateChangeHandler, CircuitState, CircuitTarget, ConditionalToolCallParams, ContentBlock, ContentResult, ConversationTurn, CooldownBackoff, CreateMiddlewareOptions, DuplicateToolNamesIssue, EvictionOption, ExponentialBackoffOptions, FallbackAttempt, FallbackOn, FallbackTarget, FetchAdapterConfig, GeminiClient, HistoryToolResultIssue, ImageBlock, JsonModeDisabledCallParams, JsonModeEnabledCallParams, JsonSchemaSpec, JsonValue, LLMClient, LLMErrorCode, LLMErrorIssuesByCode, LLMErrorSnapshot, LLMErrorType, LLMRequestShape, LLMRequestSnapshot, Logger, MiddlewareCapabilities, MiddlewareContext, MiddlewareContextBase, MiddlewareRef, MiddlewareStateBag, MiddlewareStateKey, OnEvent, OnUsage, PreDispatchContext, RateLimitAcquireResult, RateLimitOptions, RateLimitReason, RateLimitState, RateLimiterAdapter, RefundUsage, RequiredMiddlewareRef, ReserveUsage, RetryAttempt, RetryBudgetOptions, SchemaLike, StreamCallResult, StreamChunk, StreamEnabledCallParams, StreamJsonModeDisabledCallParams, StreamJsonModeEnabledCallParams, TargetCircuitState, TextBlock, TokenUsage, ToolCall, ToolCallResult, ToolChoice, ToolDefinition, ToolEnabledCallParams, ToolIssue, ToolResult, ToolsDisabledCallParams, TrippingPolicy, UnknownToolChoiceIssue, UnsupportedCapabilityIssue, VernLLMEvent, VernLLMMiddleware, VernLLMOptions, WireCallRequest, WireCallRequestPatch, WireMessage, WireRequest, WireResponseFormat, WireStreamChunk, WireTool, WireToolCall, WireToolChoice };
 //# sourceMappingURL=index.d.mts.map