vern-llm 2.6.2 → 2.8.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?;
@@ -372,6 +372,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 +395,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 +406,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 +454,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;
@@ -415,6 +465,14 @@ interface MiddlewareContextBase {
   state: MiddlewareStateBag;
   /** Simple, string-keyed scratch space, pre-namespaced to this one middleware so two middleware can never collide here even by accident. */
   own: Record<string, unknown>;
+  /**
+   * Every registered middleware's resolved label, in `transformOrder`,
+   * frozen. Lets a middleware make an informed call, like skipping a
+   * duplicate action when it detects another known middleware by name
+   * already handles it, without needing to know anything else about
+   * that middleware's own configuration.
+   */
+  registeredMiddlewareNames: readonly string[];
 }
 /**
  * The `ctx` `transform` receives, and every attempt-scoped event context
@@ -546,8 +604,45 @@ 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;
+  /**
+   * 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?: (MiddlewareRef | RequiredMiddlewareRef)[];
+  /**
+   * Other middleware this entry must run before. See `runsAfter`; a
+   * bare reference is dropped if unresolved, a `requireRef`-wrapped one
+   * throws.
+   */
+  runsBefore?: (MiddlewareRef | RequiredMiddlewareRef)[];
+  /**
+   * Pins this entry's slot in `wrap` nesting only, independent of
+   * `priority`/`runsAfter`/`runsBefore`, which still govern
+   * `transform`/`onEvent` order. `'outermost'` sees the net
+   * `CallResult` of every retry, fallback, and other middleware's
+   * `wrap`; `'innermost'` sits closest to the real dispatch. A numeric
+   * value behaves like `priority`, but only for `wrap` nesting.
+   */
+  position?: 'outermost' | 'innermost' | number;
   /**
    * Boolean for a static on/off switch, or a predicate evaluated per
    * call. A throwing, rejecting, or timed-out predicate is logged and
@@ -650,7 +745,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);
@@ -659,7 +754,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;
@@ -687,7 +782,7 @@ type CircuitState = 'closed' | 'open' | 'half-open';
  * 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 {
   private readonly cooldownMs;
   private readonly onStateChange?;
   /** Whether this breaker tracks failures per model instead of one shared circuit. */
@@ -770,7 +865,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);
@@ -826,6 +921,16 @@ interface RateLimitOptions {
    * chars/4 heuristic over message content plus `max_tokens`.
    */
   estimateTokens?: (request: WireRequest) => number;
+  /**
+   * Scales the pre-flight estimate down before it's reserved against
+   * `tokensPerMinute`, since most calls don't use their full `max_tokens`
+   * budget. Applied after `estimateTokens`, as rate-limiter bookkeeping
+   * only; never changes the `max_tokens` sent to the provider.
+   * `release`'s `actualTokens` still reconciles against real usage
+   * afterward. Default `1` (today's behavior, no scaling). Must be a
+   * finite number greater than `0`; values above `1` are clamped to `1`.
+   */
+  estimateFraction?: number;
   /**
    * AIMD against the `requestsPerMinute` bucket. Omit for a fixed
    * ceiling, today's behavior. Requires `requestsPerMinute`.
@@ -835,7 +940,7 @@ interface RateLimitOptions {
 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. */
+  /** Multiplied against the ceiling on a rate-limit signal. Must be greater than `0` and at most `1`; clamped otherwise. */
   decreaseFactor: number;
   /** Floor the ceiling never shrinks below. */
   minCapacity: number;
@@ -848,6 +953,14 @@ interface AimdOptions {
    */
   proactiveFloor?: number;
 }
+interface RateLimitState {
+  /** Requests still available this window, or `undefined` if `requestsPerMinute` isn't configured. */
+  requestsRemaining?: number;
+  /** Tokens still available this window, or `undefined` if `tokensPerMinute` isn't configured. */
+  tokensRemaining?: number;
+  /** Concurrency slots currently in use, or `undefined` if `maxConcurrent` isn't configured. */
+  concurrentInFlight?: number;
+}
 interface RateLimitAcquireResult {
   /**
    * Releases the concurrency slot this attempt held and reconciles the
@@ -862,7 +975,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
@@ -875,6 +988,8 @@ interface RateLimiterAdapter {
   acquire(estimatedTokens: number, signal?: AbortSignal): Promise<RateLimitAcquireResult>;
   signalRateLimit(): void;
   reactToRateLimitHint(hint: ProviderRateLimitHint | undefined): void;
+  /** Optional: current bucket levels, for introspection. Omit if the adapter has no state worth reporting. */
+  getState?(): RateLimitState;
 }
 /**
  * Per-target rate limiter. Up to three buckets (requests/min, tokens/min,
@@ -882,7 +997,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?;
@@ -891,6 +1006,7 @@ declare class RateLimiter implements RateLimiterAdapter {
   private readonly maxQueueMs;
   private readonly maxQueueSize;
   private readonly estimateTokensFn;
+  private readonly estimateFraction;
   private readonly aimd?;
   private readonly queue;
   /**
@@ -902,7 +1018,13 @@ declare class RateLimiter implements RateLimiterAdapter {
    */
   private wakeTimer?;
   constructor(options: RateLimitOptions);
-  /** Pre-flight token estimate for a request, per the configured (or default) heuristic. */
+  /**
+   * Pre-flight token estimate for a request, per the configured (or
+   * default) heuristic, scaled by `estimateFraction`. This is the sole
+   * value reserved against `tokensPerMinute` and later reconciled in
+   * `release`; the provider-facing `max_tokens` on the request itself is
+   * never touched.
+   */
   estimate(request: WireRequest): number;
   /**
    * Waits for capacity in every configured bucket, then takes from each.
@@ -953,6 +1075,12 @@ declare class RateLimiter implements RateLimiterAdapter {
    * `hint.remainingRequests` is at or below `aimd.proactiveFloor`.
    */
   reactToRateLimitHint(hint: ProviderRateLimitHint | undefined): void;
+  /**
+   * Current bucket levels, read live rather than cached. `concurrency`
+   * tracks free slots internally, so `concurrentInFlight` is reported as
+   * `capacity - available`, the inverse of what the bucket itself holds.
+   */
+  getState(): RateLimitState;
 }
 //#endregion
 //#region src/internal/utils/rateLimitAdapter.utils.d.ts
@@ -1057,7 +1185,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
@@ -1067,7 +1195,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[]);
   /**
@@ -1079,7 +1207,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
@@ -1090,7 +1218,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
@@ -1165,7 +1293,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;
@@ -1226,7 +1354,7 @@ 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;
@@ -1637,6 +1765,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
@@ -1711,7 +1846,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`.
@@ -2011,7 +2146,7 @@ interface Logger {
  * Default logger. `debug` is gated by the `debug` option on VernLLM
  * warn/error always fire since they indicate real problems (retries, cache failures)
  */
-declare class ConsoleLogger implements Logger {
+export declare class ConsoleLogger implements Logger {
   private debugEnabled;
   constructor(debugEnabled: boolean);
   debug(message: string): void;
@@ -2124,8 +2259,11 @@ interface VernLLMOptions {
    * for the final close), in which case this does fire.
    */
   onUsageFailure?: OnUsageFailure;
-  /** Injectable logger. Defaults to a console-based logger gated by `debug` */
-  logger?: Logger;
+  /**
+   * Injectable logger. Defaults to a console-based logger gated by `debug`.
+   * Pass `'silent'` to discard all log output without stubbing a Logger.
+   */
+  logger?: Logger | 'silent';
   /**
    * Enables a circuit breaker that short-circuits calls after repeated
    * consecutive failures, instead of continuing to hammer a down provider
@@ -2229,7 +2367,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
 /**
@@ -2240,7 +2378,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,
@@ -2255,8 +2393,14 @@ declare class VernLLM {
   private readonly reportEvent;
   /** Owns cache reads/writes and in-flight coalescing for `cachedCall()`. Only calls back into `this.call()` as an opaque function. */
   private readonly cacheOrchestrator;
-  /** See `VernLLMOptions.middleware`. Sorted once here by `priority`, ascending, ties broken by original array order. */
-  private readonly middleware;
+  /**
+   * See `VernLLMOptions.middleware`. Every resolved view of composition
+   * order, built once here at construction time by
+   * `buildMiddlewarePipeline`. Nothing downstream computes order
+   * itself; each consumer reads `transformOrder`, `wrapOrder`, or
+   * `names`, whichever it actually needs.
+   */
+  private readonly pipeline;
   /** See `VernLLMOptions.middlewareTimeoutMs`. Bounds `transform` and a function `enabled`; `wrap` itself is never bounded by this. */
   private readonly middlewareTimeoutMs;
   /**
@@ -2391,6 +2535,15 @@ declare class VernLLM {
     attempts: number;
     retryRatio: number;
   } | undefined;
+  /**
+   * @param target.index Which target to read. Defaults to the primary.
+   * @returns This target's current rate limit levels, or `undefined` if
+   * that target has no limiter configured. A limiter is target-scoped,
+   * not model-scoped, so unlike `getFailureBreakdown` there's no
+   * `target.model` to pass.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  getRateLimitState(target?: Pick<CircuitTarget, 'index'>): RateLimitState | undefined;
   /**
    * @param model Which model bucket to read, for targets that isolate by model.
    * @returns Every target's state, in chain order.
@@ -2436,7 +2589,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
@@ -2451,7 +2604,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
 /**
@@ -2481,14 +2634,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
 /**
@@ -2735,7 +2888,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
 /**
@@ -2947,7 +3100,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. */
@@ -3306,7 +3459,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 */
@@ -3468,7 +3621,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
 /**
@@ -3535,7 +3688,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
@@ -3553,9 +3706,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
@@ -3563,88 +3716,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, 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, CircuitBreakerOptions, 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