vern-llm 3.0.0 → 3.1.0

package/dist/{client-HWxkwVvj.d.mts → client-D4eRQMgc.d.mts}

@@ -1,10 +1,13 @@
-//#region src/types/errors.d.ts
 type LLMErrorType = 'timeout' | 'api' | 'network' | 'parse' | 'validation' | 'invalid_params' | 'rate_limited' | 'quota_exceeded' | 'circuit_open' | 'fallback_exhausted' | 'aborted' | 'unknown';
 /**
  * Machine readable detail within a `type`, for when `type` alone is too coarse to act on. Optional:
  * errors from before a code existed omit it.
  */
-type LLMErrorCode = 'unknown_tool' | 'duplicate_tool_call_id' | 'tool_choice_none_violated' | 'unexpected_tool_calls' | 'unsupported_capability' | 'duplicate_tool_names' | 'unknown_tool_choice' | 'duplicate_tool_result_ids' | 'unknown_tool_result_ids' | 'missing_tool_results' | 'invalid_context' | 'unknown_target' | 'no_eligible_targets' | 'middleware_threw' | 'rate_limit_queue_full' | 'rate_limit_queue_timeout' | 'rate_limit_capacity_exceeded' | 'provider_rate_limited' | 'retry_budget_exhausted' | 'request_timeout' | 'idle_timeout' | 'reader_stall_timeout' | 'middleware_timeout' | 'deadline_exceeded' | 'authentication' | 'authorization' | 'not_found' | 'payload_too_large' | 'server_error' | 'empty_response' | 'connection_failed' | 'circuit_cooling_down' | 'circuit_trial_in_flight' | 'fallback_exhausted' | 'tool_arguments_parse_failed' | 'stream_frame_invalid' | 'response_truncated' | 'soft_failure_detected';
+type LLMErrorCode = 'unknown_tool' | 'duplicate_tool_call_id' | 'tool_choice_none_violated' | 'unexpected_tool_calls' | 'unsupported_capability' | 'duplicate_tool_names' | 'unknown_tool_choice' | 'duplicate_tool_result_ids' | 'unknown_tool_result_ids' | 'missing_tool_results' | 'invalid_context' | 'unknown_target' | 'no_eligible_targets' | 'middleware_threw' | 'policy_denied' |
+/** A middleware refused the call, or the answer it got, because of its content. Not retried, no fallback. */
+'content_blocked' |
+/** The provider declined the call with no content. Not retried, no fallback by default. */
+'model_refused' | 'budget_exceeded' | 'rate_limit_queue_full' | 'rate_limit_queue_timeout' | 'rate_limit_capacity_exceeded' | 'provider_rate_limited' | 'retry_budget_exhausted' | 'request_timeout' | 'idle_timeout' | 'reader_stall_timeout' | 'middleware_timeout' | 'deadline_exceeded' | 'authentication' | 'authorization' | 'not_found' | 'payload_too_large' | 'server_error' | 'empty_response' | 'connection_failed' | 'circuit_cooling_down' | 'circuit_trial_in_flight' | 'fallback_exhausted' | 'tool_arguments_parse_failed' | 'stream_frame_invalid' | 'response_truncated' | 'soft_failure_detected';
 /** One tool call's contract failure, used to report every bad call in a response at once. */
 interface ToolIssue {
   name: string;
@@ -148,8 +151,6 @@ declare function hasIssues<C extends keyof LLMErrorIssuesByCode>(err: LLMError,
   code: C;
   issues: LLMErrorIssuesByCode[C];
 };
-//#endregion
-//#region src/logger.d.ts
 interface Logger {
   debug(message: string): void;
   warn(message: string): void;
@@ -166,8 +167,6 @@ declare class ConsoleLogger implements Logger {
   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;
@@ -210,6 +209,12 @@ interface TokenUsage {
   cacheWriteTokens?: number;
   /** `cacheWriteTokens` by the provider's TTL label. `undefined` when not split. */
   cacheWriteTokensByTtl?: Readonly<Record<string, number>>;
+  /**
+   * What the provider says this call cost, in USD, when its response carries it (OpenRouter's
+   * `usage.cost`, or a `fromFetch` mapper's `costUsd`). `undefined` when it doesn't. It is the
+   * provider's own figure, so it wins over any price you compute from the token counts.
+   */
+  costUsd?: number;
   requestId: string;
   model: string;
   /**
@@ -231,8 +236,6 @@ type OnUsage = (usage: TokenUsage) => void;
  * transport failures, which have no usage 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
  * `onUsage`: the return value is never read and a throwing handler cannot
@@ -251,6 +254,8 @@ type VernLLMEvent = {
   retryAfterHonored: boolean;
   error: LLMError;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   kind: 'circuit_state';
   provider: string;
@@ -263,6 +268,8 @@ type VernLLMEvent = {
   to: CircuitState;
   consecutiveFailures: number;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   kind: 'fallback';
   requestId: string;
@@ -278,6 +285,8 @@ type VernLLMEvent = {
   /** Time spent on `from`, including its own retries, before giving up. */
   elapsedMs: number;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   kind: 'rate_limited';
   requestId: string;
@@ -289,6 +298,8 @@ type VernLLMEvent = {
   /** Which configured bucket was blocking this attempt just before it cleared. */
   reason: 'concurrency' | 'rpm' | 'tpm';
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   kind: 'middleware';
   requestId: string;
@@ -298,6 +309,8 @@ type VernLLMEvent = {
   /** For `hook: 'transform'` only: which top-level fields the merged patch touched. */
   patchedFields?: string[];
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   /**
    * Reported once a call fully succeeds. Same data `VernLLMOptions.onUsage`
@@ -308,6 +321,8 @@ type VernLLMEvent = {
   requestId: string;
   usage: TokenUsage;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   /**
    * A response carried usage and post-processing then failed. Once per such attempt;
@@ -318,6 +333,8 @@ type VernLLMEvent = {
   usage: TokenUsage;
   error: LLMError;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 } | {
   /** Reported by a middleware through `ctx.emit`. */
   kind: 'custom';
@@ -328,10 +345,10 @@ type VernLLMEvent = {
   source: string;
   data?: JsonValue;
   context?: CallContext;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 };
 type OnEvent = (event: VernLLMEvent) => void;
-//#endregion
-//#region src/types/middleware.d.ts
 /** Capabilities of the target a middleware hook is currently looking at. */
 interface MiddlewareCapabilities {
   /**
@@ -422,6 +439,14 @@ interface MiddlewareContextBase {
   emit(name: string, data?: JsonValue): void;
   /** The call's `context`, frozen. `undefined` when none was given. */
   context: CallContext | undefined;
+  /** Whether the call asked for a stream. */
+  streaming?: boolean;
+  /** The call's own `targets`, when it passed one. The order a caller chose by hand. */
+  callTargets?: readonly string[];
+  /** When the call's `deadlineMs` runs out, as epoch milliseconds. Absent without a deadline. */
+  deadlineAt?: number;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
 }
 /**
  * The `ctx` for `transform` and every attempt scoped event. Built once a target is selected, so
@@ -518,12 +543,35 @@ interface WireCallRequestPatch {
   addTools?: WireTool[];
 }
 /**
- * The settled outcome of one logical call, from `wrap`'s `next()`. `meta` is `undefined` only on a
- * cache hit.
+ * The settled outcome of one logical call, from `wrap`'s `next()`. `meta` is `undefined` on a
+ * cache hit, and on a streamed `cachedCall` join, which returns before the shared call has answered.
  */
 interface CallResult<T = unknown> {
   value: T;
   meta?: CallMeta;
+  /**
+   * Set only by `cachedCall()` when no call of its own ran: `'hit'` served a stored value,
+   * `'join'` shared another caller's in flight call. Unlike `meta` it is known when `next()`
+   * returns, for streams too.
+   */
+  cache?: 'hit' | 'join';
+}
+/** Options for `wrap`'s `next()` and `next.again()`. */
+interface WrapNextOptions {
+  /** Reorders or drops targets by name, never adds one. */
+  targets?: readonly string[];
+}
+/** `wrap`'s `next`. Calling it runs everything inside this `wrap` once; later calls return the same result. */
+interface WrapNext {
+  (options?: WrapNextOptions): Promise<CallResult>;
+  /**
+   * Runs everything inside this `wrap` again as a separate chain, at the same time as other chains
+   * or after them. Set only for entries with `reruns: true`, and not after 4 per call. Inside
+   * `cachedCall()` it's a fresh call for this caller: no cache read or joining, and its answer is
+   * cached. Return a chain's result unchanged: when the `wrap` settles, every chain whose result it
+   * didn't return is cancelled.
+   */
+  readonly again?: (options?: WrapNextOptions) => Promise<CallResult>;
 }
 /**
  * One entry in `VernLLMOptions.middleware`. Every hook is optional. See the middleware docs for how
@@ -570,9 +618,12 @@ interface VernLLMMiddleware {
    * primary and the order so far (`ctx.targets`); read `next()`'s `CallResult.meta` for what
    * happened. `next({ targets })` reorders or drops targets by name, never adds one.
    */
-  wrap?: (request: Readonly<WireCallRequest>, next: (options?: {
-    targets?: readonly string[];
-  }) => Promise<CallResult>, ctx: PreDispatchContext) => Promise<CallResult>;
+  wrap?: (request: Readonly<WireCallRequest>, next: WrapNext, ctx: PreDispatchContext) => Promise<CallResult>;
+  /**
+   * Gives this entry's `wrap` `next.again()`, and cancels every chain it starts but doesn't return,
+   * when it settles. Off by default; entries without it run exactly as before.
+   */
+  reruns?: boolean;
   /**
    * Wraps one attempt's provider request, after the limiter and every `transform`. `request` is
    * exactly what the adapter gets. Runs per attempt, nested in `wrap` order.
@@ -586,8 +637,6 @@ interface VernLLMMiddleware {
   /** Observes the same events reported on `VernLLMOptions.onEvent`, filtered by this middleware's own `enabled`. Called from both stages; narrow on `ctx.stage` before reading stage-specific fields. */
   onEvent?: (event: VernLLMEvent, ctx: MiddlewareContext) => void;
 }
-//#endregion
-//#region src/circuitBreaker.d.ts
 /** The call this mutation happened as part of, forwarded to `onStateChange` untouched. */
 interface CircuitBreakerCallContext {
   requestId: string;
@@ -804,54 +853,14 @@ declare class CircuitBreaker implements CircuitBreakerAdapter {
   /** Once every admitted trial has reported in, closes or reopens based on `halfOpenSuccessRatio`. */
   private settleTrialIfComplete;
 }
-//#endregion
-//#region src/internal/retryBudget.d.ts
-/**
- * `windowMs` and `minCalls` work as in `RollingTripping`: `minCalls` keeps a cold start from
- * tripping. `retryRatio` is the largest share of calls in the window that may be retries. Invalid
- * values throw `RangeError` at construction.
- */
-interface RetryBudgetOptions {
-  windowMs: number;
-  minCalls: number;
-  retryRatio: number;
-}
-/**
- * Caps the share of a target's recent traffic that may be retries. The breaker asks whether the
- * provider is healthy; this asks whether retrying is still worth the capacity it costs.
- */
-declare class RetryBudget {
-  private readonly options;
-  private readonly ratio;
-  constructor(options: RetryBudgetOptions);
-  /**
-   * Throws `LLMError('retry_budget_exhausted')` once at least `minCalls`
-   * calls have landed in the trailing `windowMs` and the retry ratio
-   * among them has reached `retryRatio`. A no-op otherwise.
-   */
-  assertAvailable(): void;
-  /** Records one attempt. `isRetry` is false for a call's first attempt, true for every attempt after it. */
-  recordAttempt(isRetry: boolean): void;
-  /** Current traffic and retry ratio in the trailing window. */
-  getSnapshot(): {
-    attempts: number;
-    retryRatio: number;
-  };
-}
-//#endregion
-//#region src/internal/utils/circuit-breaker/circuitBreakerAdapter.utils.d.ts
 /** The `circuitBreaker` option union, shared by `VernLLMOptions` and `buildCircuitBreaker`. */
 type CircuitBreakerOption = boolean | CircuitBreakerOptions | CircuitBreakerAdapter;
-//#endregion
-//#region src/internal/utils/rate-limit/rateLimitHint.utils.d.ts
 /** A normalized read of a provider's rate limit headers. */
 interface ProviderRateLimitHint {
   remainingRequests?: number;
   limitRequests?: number;
   resetAfterMs?: number;
 }
-//#endregion
-//#region src/rateLimit.d.ts
 /** The request shape sent to `LLMClient['chat']['completions']['create']`, used for token estimation. */
 type WireRequest = Parameters<LLMClient['chat']['completions']['create']>[0];
 /** Which configured bucket is currently blocking a call. */
@@ -1019,12 +1028,63 @@ declare class RateLimiter implements RateLimiterAdapter {
    */
   getState(): RateLimitState;
 }
-//#endregion
-//#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
-//#region src/types/fallback.d.ts
+/**
+ * `windowMs` and `minCalls` work as in `RollingTripping`: `minCalls` keeps a cold start from
+ * tripping. `retryRatio` is the largest share of calls in the window that may be retries. Invalid
+ * values throw `RangeError` at construction.
+ */
+interface RetryBudgetOptions {
+  windowMs: number;
+  minCalls: number;
+  retryRatio: number;
+}
+/** Traffic and retry ratio in a budget's trailing window. */
+interface RetryBudgetSnapshot {
+  attempts: number;
+  retryRatio: number;
+}
+/**
+ * What `retryBudget` accepts in place of options, e.g. a budget shared across processes. Both
+ * required methods run on the call path and are synchronous: keep remote state in a local copy.
+ */
+interface RetryBudgetAdapter {
+  /**
+   * Throws an `LLMError` when no retry may run, normally `type: 'rate_limited'` with
+   * `code: 'retry_budget_exhausted'`. Anything else it throws is logged and the retry goes ahead.
+   */
+  assertAvailable(): void;
+  /** `isRetry` is false for a call's first attempt. Fire and forget: a returned rejection is logged. */
+  recordAttempt(isRetry: boolean): void;
+  /** Read by `VernLLM.getRetryBudgetState()`. */
+  getSnapshot?(): RetryBudgetSnapshot;
+  /** Live counterpart of `getSnapshot`, read by `VernLLM.readRetryBudgetState()`. */
+  readState?(): Promise<RetryBudgetSnapshot>;
+  /** Receives the instance's `Logger` once, when `VernLLM` wires this adapter in. */
+  setLogger?(logger: Logger): void;
+}
+/**
+ * Caps the share of a target's recent traffic that may be retries. The breaker asks whether the
+ * provider is healthy; this asks whether retrying is still worth the capacity it costs.
+ */
+declare class RetryBudget implements RetryBudgetAdapter {
+  private readonly options;
+  private readonly ratio;
+  constructor(options: RetryBudgetOptions);
+  /**
+   * Throws `LLMError('retry_budget_exhausted')` once at least `minCalls`
+   * calls have landed in the trailing `windowMs` and the retry ratio
+   * among them has reached `retryRatio`. A no-op otherwise.
+   */
+  assertAvailable(): void;
+  /** Records one attempt. `isRetry` is false for a call's first attempt, true for every attempt after it. */
+  recordAttempt(isRetry: boolean): void;
+  /** Current traffic and retry ratio in the trailing window. */
+  getSnapshot(): RetryBudgetSnapshot;
+}
+/** What `retryBudget` accepts: options for the built in budget, or an adapter. */
+type RetryBudgetOption = RetryBudgetOptions | RetryBudgetAdapter;
 /**
  * A provider tried after the primary fails, in the order given. Omitted overrides fall back to the
  * instance's options, except `circuitBreaker`, `rateLimit` and `retryBudget`, which are never
@@ -1051,7 +1111,7 @@ interface FallbackTarget {
   /** This target's own rate limiter, independent of every other target's. Not inherited from the parent's `rateLimit`. */
   rateLimit?: RateLimitOption;
   /** This target's own retry budget, independent of every other target's. Not inherited from the parent's `retryBudget`. */
-  retryBudget?: RetryBudgetOptions;
+  retryBudget?: RetryBudgetOption;
   /**
    * Reclassifies a successful result from this target as a failure. Inherits the instance's
    * `detectSoftFailure` when omitted.
@@ -1063,6 +1123,11 @@ interface FallbackTarget {
  * who wants provider identity on the same line as the result doesn't need
  * to read it back out of `onUsage`.
  */
+/**
+ * Why the answering target stopped. Adapters map their provider's reason onto these. `'other'`
+ * is any reason with no match here.
+ */
+type FinishReason = 'stop' | 'length' | 'tool_calls' | 'refusal' | 'guardrail' | 'content_filter' | 'other';
 interface CallMeta {
   provider: string;
   model: string;
@@ -1073,6 +1138,13 @@ interface CallMeta {
   attempts: number;
   /** Position of the answering target in the order tried, 0 based. */
   position: number;
+  /** Absent for the main chain, 1 and up for chains started with `next.again()`. */
+  chain?: number;
+  /**
+   * Why the answering target stopped, when its adapter reports it. For a stream it is set once
+   * `finalResult` resolves. Absent on a cache hit.
+   */
+  finishReason?: FinishReason;
 }
 /** One configured target, as a middleware sees it in `ctx.targets`. */
 interface TargetInfo {
@@ -1154,8 +1226,6 @@ declare function isFallbackExhaustedError(err: unknown): err is FallbackExhauste
 declare function metaRef(): {
   current?: CallMeta;
 };
-//#endregion
-//#region src/types/schema.d.ts
 /**
  * Minimal structural type for a Zod-like schema, so this package doesnt need
  * a hard dependency on a specific Zod major version. Any object exposing
@@ -1185,8 +1255,6 @@ interface JsonSchemaSpec {
   strict?: boolean;
   description?: string;
 }
-//#endregion
-//#region src/types/tools.d.ts
 /**
  * Describes a capability the model may request, not the capability
  * itself. VernLLM transports this to the provider and parses what comes
@@ -1266,8 +1334,6 @@ declare function isToolCallResult<Tools extends readonly ToolDefinition[] | unde
 type ToolChoice = 'auto' | 'none' | 'required' | {
   name: string;
 };
-//#endregion
-//#region src/types/call.d.ts
 /**
  * Any valid JSON value: a primitive, `null`, or a JSON array/object made
  * of the same. This is what `call()` returns when `jsonMode: true`.
@@ -1542,8 +1608,6 @@ interface SoftFailureMeta {
  * refusal answers that parse fine.
  */
 type DetectSoftFailure<T = unknown> = (result: T | CallWithToolsResult<T>, meta: SoftFailureMeta) => LLMErrorCode | undefined;
-//#endregion
-//#region src/types/stream.d.ts
 /** One incremental unit of a streaming response, as delivered to the caller. */
 type StreamChunk = {
   type: 'text-delta';
@@ -1632,6 +1696,8 @@ type WireStreamChunk = {
       /** Writes by TTL label, e.g. `{ '5m': 1200, '1h': 800 }`. */
       cache_write_tokens_by_ttl?: Record<string, number>;
     };
+    /** What the provider billed for the call, in USD. OpenRouter reports it as `usage.cost`. */
+    cost?: number;
   };
 } | {
   /** A provider keep-alive with no content. Resets the idle timeout; never reaches callers. */
@@ -1643,6 +1709,14 @@ type WireStreamChunk = {
    */
   type: 'rate_limit_hint';
   hint: ProviderRateLimitHint;
+} | {
+  /** The provider declined. Never reaches callers: with no content, the call fails as `model_refused`. */
+  type: 'refusal';
+  delta?: string;
+} | {
+  /** Why generation stopped, as the provider spells it. Never reaches callers; core maps it onto `FinishReason`. */
+  type: 'finish';
+  reason: string;
 } | {
   /**
    * One complete reasoning block, yielded once it has fully arrived.
@@ -1708,8 +1782,6 @@ type CachedStreamJsonModeEnabledCallParams = CachedCallInput & {
     schema?: never;
   };
 };
-//#endregion
-//#region src/types/client.d.ts
 /** A tool call as it appears on the wire, OpenAI's `function`-wrapped shape. */
 interface WireToolCall {
   id: string;
@@ -1833,10 +1905,13 @@ interface LLMClient {
             tool_calls?: WireToolCall[];
             /** Reasoning blocks the model produced, in order. Only Claude adapters report them. */
             thinking?: ThinkingBlock[];
+            /** Set when the provider declined. With no content or tool calls, fails as `model_refused`. */
+            refusal?: string | null;
           };
           /**
-           * Why generation stopped, in OpenAI's terms. Only `'length'` is read: output that then
-           * fails to parse becomes the retryable `response_truncated`. Optional.
+           * Why generation stopped, in OpenAI's terms. Reported as `CallMeta.finishReason`, and
+           * `'length'` also turns output that fails to parse into the retryable
+           * `response_truncated`. Optional.
            */
           finish_reason?: string | null;
         }>;
@@ -1854,6 +1929,8 @@ interface LLMClient {
             /** Writes by TTL label, e.g. `{ '5m': 1200, '1h': 800 }`. */
             cache_write_tokens_by_ttl?: Record<string, number>;
           };
+          /** What the provider billed for the call, in USD. OpenRouter reports it as `usage.cost`. */
+          cost?: number;
         };
       }>;
       /**
@@ -1866,6 +1943,5 @@ interface LLMClient {
     };
   };
 }
-//#endregion
-export { SchemaLike as $, createStateKey as $t, ConditionalToolCallParams as A, ConsecutiveTripping as At, ThinkingBlock as B, MiddlewareRef as Bt, CachedConditionalToolCallParams as C, hasIssues as Cn, RetryBudgetOptions as Ct, CallContext as D, CircuitBreakerOptions as Dt, CachedToolCallParams as E, CircuitBreakerCallContext as Et, JsonModeDisabledCallParams as F, AttemptContext as Ft, ToolCall as G, RequiredMiddlewareRef as Gt, ToolsDisabledCallParams as H, MiddlewareStateEntry as Ht, JsonModeEnabledCallParams as I, CallResult as It, ToolDefinition as J, WireCallRequestPatch as Jt, ToolCallResult as K, VernLLMMiddleware as Kt, JsonValue as L, MiddlewareCapabilities as Lt, ConversationTurn as M, ExponentialBackoffOptions as Mt, DetectSoftFailure as N, RollingTripping as Nt, CallParams as O, CircuitBreakerStateChangeHandler as Ot, ImageBlock as P, TrippingPolicy as Pt, JsonSchemaSpec as Q, createMiddlewareStateBag as Qt, LLMRequestShape as R, MiddlewareContext as Rt, CachedConditionalStringToolCallParams as S, UnsupportedCapabilityIssue as Sn, RetryBudget as St, CachedJsonModeEnabledCallParams as T, CircuitBreakerAdapter as Tt, CallWithToolsResult as U, MiddlewareStateKey as Ut, ToolEnabledCallParams as V, MiddlewareStateBag as Vt, ContentResult as W, PreDispatchContext as Wt, defineTool as X, WireTool as Xt, ToolResult as Y, WireResponseFormat as Yt, isToolCallResult as Z, createMiddlewareRef as Zt, StreamJsonModeEnabledCallParams as _, LLMErrorType as _n, RateLimiter as _t, WireToolChoice as a, OnUsageFailure as an, FallbackOnContext as at, AssistantContent as b, ToolIssue as bn, ProviderRateLimitHint as bt, CachedStreamConditionalToolCallParams as c, TokenUsage as cn, TargetInfo as ct, CachedStreamToolCallParams as d, DuplicateToolNamesIssue as dn, metaRef as dt, requireRef as en, CallMeta as et, StreamCallResult as f, HistoryToolResultIssue as fn, RateLimitOption as ft, StreamJsonModeDisabledCallParams as g, LLMErrorSnapshot as gn, RateLimitState as gt, StreamEnabledCallParams as h, LLMErrorIssuesByCode as hn, RateLimitReason as ht, WireToolCall as i, OnUsage as in, FallbackOn as it, ContentBlock as j, CooldownBackoff as jt, ConditionalStringToolCallParams as k, CircuitState as kt, CachedStreamJsonModeDisabledCallParams as l, ConsoleLogger as ln, defaultFallbackOn as lt, StreamConditionalStringToolCallParams as m, LLMErrorCode as mn, RateLimitOptions as mt, LLMClient as n, OnEvent as nn, FallbackAttempt as nt, CachedStreamCallParams as o, RefundUsage as on, FallbackTarget as ot, StreamChunk as p, LLMError as pn, RateLimitAcquireResult as pt, ToolChoice as q, WireCallRequest as qt, WireMessage as r, VernLLMEvent as rn, FallbackExhaustedError as rt, CachedStreamConditionalStringToolCallParams as s, ReserveUsage as sn, TargetCircuitState as st, AdapterInfo as t, stateEntry as tn, CircuitTarget as tt, CachedStreamJsonModeEnabledCallParams as u, Logger as un, isFallbackExhaustedError as ut, WireStreamChunk as v, LLMRequestSnapshot as vn, RateLimiterAdapter as vt, CachedJsonModeDisabledCallParams as w, isLLMError as wn, CircuitBreaker as wt, CachedCallParams as x, UnknownToolChoiceIssue as xn, CircuitBreakerOption as xt, isStreamResult as y, RetryAttempt as yn, WireRequest as yt, TextBlock as z, MiddlewareContextBase as zt };
-//# sourceMappingURL=client-HWxkwVvj.d.mts.map
+export { SchemaLike as $, WireResponseFormat as $t, ConditionalToolCallParams as A, isLLMError as An, CircuitBreakerCallContext as At, ThinkingBlock as B, CallResult as Bt, CachedConditionalToolCallParams as C, LLMErrorType as Cn, RateLimiter as Ct, CallContext as D, UnknownToolChoiceIssue as Dn, CircuitBreakerOption as Dt, CachedToolCallParams as E, ToolIssue as En, ProviderRateLimitHint as Et, JsonModeDisabledCallParams as F, CooldownBackoff as Ft, ToolCall as G, MiddlewareStateBag as Gt, ToolsDisabledCallParams as H, MiddlewareContext as Ht, JsonModeEnabledCallParams as I, ExponentialBackoffOptions as It, ToolDefinition as J, PreDispatchContext as Jt, ToolCallResult as K, MiddlewareStateEntry as Kt, JsonValue as L, RollingTripping as Lt, ConversationTurn as M, CircuitBreakerStateChangeHandler as Mt, DetectSoftFailure as N, CircuitState as Nt, CallParams as O, UnsupportedCapabilityIssue as On, CircuitBreaker as Ot, ImageBlock as P, ConsecutiveTripping as Pt, JsonSchemaSpec as Q, WireCallRequestPatch as Qt, LLMRequestShape as R, TrippingPolicy as Rt, CachedConditionalStringToolCallParams as S, LLMErrorSnapshot as Sn, RateLimitState as St, CachedJsonModeEnabledCallParams as T, RetryAttempt as Tn, WireRequest as Tt, CallWithToolsResult as U, MiddlewareContextBase as Ut, ToolEnabledCallParams as V, MiddlewareCapabilities as Vt, ContentResult as W, MiddlewareRef as Wt, defineTool as X, VernLLMMiddleware as Xt, ToolResult as Y, RequiredMiddlewareRef as Yt, isToolCallResult as Z, WireCallRequest as Zt, StreamJsonModeEnabledCallParams as _, DuplicateToolNamesIssue as _n, RetryBudgetSnapshot as _t, WireToolChoice as a, createStateKey as an, FallbackOnContext as at, AssistantContent as b, LLMErrorCode as bn, RateLimitOptions as bt, CachedStreamConditionalToolCallParams as c, OnEvent as cn, TargetCircuitState as ct, CachedStreamToolCallParams as d, OnUsageFailure as dn, isFallbackExhaustedError as dt, WireTool as en, CallMeta as et, StreamCallResult as f, RefundUsage as fn, metaRef as ft, StreamJsonModeDisabledCallParams as g, Logger as gn, RetryBudgetOptions as gt, StreamEnabledCallParams as h, ConsoleLogger as hn, RetryBudgetAdapter as ht, WireToolCall as i, createMiddlewareStateBag as in, FallbackOn as it, ContentBlock as j, CircuitBreakerOptions as jt, ConditionalStringToolCallParams as k, hasIssues as kn, CircuitBreakerAdapter as kt, CachedStreamJsonModeDisabledCallParams as l, VernLLMEvent as ln, TargetInfo as lt, StreamConditionalStringToolCallParams as m, TokenUsage as mn, RetryBudget as mt, LLMClient as n, WrapNextOptions as nn, FallbackAttempt as nt, CachedStreamCallParams as o, requireRef as on, FallbackTarget as ot, StreamChunk as p, ReserveUsage as pn, RetryBudgetOption as pt, ToolChoice as q, MiddlewareStateKey as qt, WireMessage as r, createMiddlewareRef as rn, FallbackExhaustedError as rt, CachedStreamConditionalStringToolCallParams as s, stateEntry as sn, FinishReason as st, AdapterInfo as t, WrapNext as tn, CircuitTarget as tt, CachedStreamJsonModeEnabledCallParams as u, OnUsage as un, defaultFallbackOn as ut, WireStreamChunk as v, HistoryToolResultIssue as vn, RateLimitOption as vt, CachedJsonModeDisabledCallParams as w, LLMRequestSnapshot as wn, RateLimiterAdapter as wt, CachedCallParams as x, LLMErrorIssuesByCode as xn, RateLimitReason as xt, isStreamResult as y, LLMError as yn, RateLimitAcquireResult as yt, TextBlock as z, AttemptContext as zt };
+//# sourceMappingURL=client-D4eRQMgc.d.mts.map

package/dist/client-D4eRQMgc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-D4eRQMgc.d.mts","names":[],"sources":["../src/types/errors.ts","../src/logger.ts","../src/types/usage.ts","../src/types/events.ts","../src/types/middleware.ts","../src/circuitBreaker.ts","../src/internal/utils/circuit-breaker/circuitBreakerAdapter.utils.ts","../src/internal/utils/rate-limit/rateLimitHint.utils.ts","../src/rateLimit.ts","../src/internal/utils/rate-limit/rateLimitAdapter.utils.ts","../src/retryBudget.ts","../src/internal/utils/retry-budget/retryBudgetAdapter.utils.ts","../src/types/fallback.ts","../src/types/schema.ts","../src/types/tools.ts","../src/types/call.ts","../src/types/stream.ts","../src/types/client.ts"],"mappings":"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"}