vern-llm 2.3.0 → 2.4.0

package/dist/index.d.cts

@@ -115,6 +115,39 @@ interface LLMErrorSnapshot {
   /** This attempt's own prior attempts, if it was itself the terminal failure of a retry loop. */
   attempts?: RetryAttempt[];
 }
+/**
+ * Point-in-time copy of the request an attempt sent, produced by
+ * `toRequestSnapshot()`. This is what `RetryAttempt.request` holds.
+ * Mirrors `LLMErrorSnapshot`: plain data, never thrown or dispatched
+ * again, safe to serialize and store.
+ */
+interface LLMRequestSnapshot {
+  /** Provider id this attempt targeted, e.g. "openai". */
+  provider: string;
+  /** Model id this attempt targeted. */
+  model: string;
+  /** The payload as actually sent for this attempt, after any transform/repair. Passed through `safeBody`. */
+  body: unknown;
+  /** Non sensitive request headers. Auth headers are stripped before the snapshot is built, never included. */
+  headers?: Record<string, string>;
+  /** Wall clock time the attempt started, ms since epoch. */
+  startedAt: number;
+}
+/**
+ * Builds a point-in-time, plain data copy of one attempt's outgoing
+ * request. Mirrors `LLMError.toSnapshot()`: never thrown or dispatched
+ * again, safe to serialize and store. A plain function rather than a
+ * method, since unlike `LLMError` a request has no throwable identity or
+ * derived state worth wrapping in a class.
+ *
+ * `startedAt` is optional so existing call sites (and tests) that don't
+ * care about exact timing keep working, but a caller that has a real
+ * capture time should always pass it: this function may run well after
+ * the request was actually dispatched (e.g. `callExecutor` only builds
+ * the snapshot once an attempt has failed), so defaulting to `Date.now()`
+ * here would record failure-handling time, not request-start time.
+ */
+
 /**
  * One failed attempt on the way to a terminal error: which attempt index
  * it was, and a snapshot of the error it failed with. The base shape
@@ -124,6 +157,8 @@ interface LLMErrorSnapshot {
 interface RetryAttempt {
   index: number;
   error: LLMErrorSnapshot;
+  /** What was sent for this attempt. Optional: absent for attempts predating this field. */
+  request?: LLMRequestSnapshot;
 }
 /** Optional fields for constructing an {@link LLMError}. `message` and `type` stay positional since every throw site sets both. */
 interface LLMErrorOptions {
@@ -495,6 +530,8 @@ interface FallbackTarget {
   baseDelayMs?: number;
   defaultMaxTokens?: number;
   defaultTemperature?: number | null;
+  defaultReasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+  defaultBudgetTokens?: number;
   nonRetryableStatus?: number[];
   /** This target's own circuit breaker, independent of every other target's. Not inherited from the parent's `circuitBreaker`. */
   circuitBreaker?: boolean | CircuitBreakerOptions;
@@ -715,6 +752,13 @@ 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;
   /**
@@ -747,6 +791,20 @@ type OnUsageFailure = (usage: TokenUsage, error: LLMError) => void;
 //#endregion
 //#region src/types/call.d.ts
 //# sourceMappingURL=usage.d.ts.map
+/**
+ * Any valid JSON value: a primitive, `null`, or a JSON array/object made
+ * of the same. This is what `call()` returns when `jsonMode: true`.
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * Content for an `assistant` turn in `history`. Accepts a string or a
+ * parsed `JsonValue`, so a prior `jsonMode: true` response can be pushed
+ * straight back into history. Request construction stringifies non-string
+ * content before it's sent to the provider.
+ */
+type AssistantContent = string | JsonValue;
 /**
  * A single prior turn in a multi-turn conversation, passed via `history`.
  *
@@ -760,7 +818,7 @@ type ConversationTurn = {
   content: string;
 } | {
   role: 'assistant';
-  content?: string;
+  content?: AssistantContent;
   toolCalls?: ToolCall[];
 } | {
   role: 'tool';
@@ -817,8 +875,29 @@ interface CallParams<T = unknown> extends UsageHooks {
   chunkIdleTimeoutMs?: number;
   /** Overrides the instance model for this call. */
   model?: string;
-  /** Reasoning effort for supported reasoning models. */
-  reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+  /**
+   * Reasoning effort for supported reasoning models. Pass `null` to
+   * explicitly skip an instance-level `defaultReasoningEffort` for this
+   * one call (e.g. a call using a forced `toolChoice`, which Anthropic
+   * rejects alongside any reasoning at all), the same way `temperature:
+   * null` opts a call out of `defaultTemperature`. Omitting the field
+   * entirely (`undefined`) defers to the instance default instead.
+   */
+  reasoningEffort?: 'minimal' | 'low' | 'medium' | 'high' | null;
+  /**
+   * Token budget for internal reasoning, for models with a native numeric
+   * budget (Anthropic's `budget_tokens`, Gemini's `thinkingBudget`). On a
+   * provider that only understands `reasoningEffort` tiers (OpenAI-
+   * compatible), this is converted to the nearest tier instead of sent as
+   * a raw number. When both `budgetTokens` and `reasoningEffort` are set,
+   * each adapter prefers whichever field it natively understands and
+   * ignores the other. See the reasoning budget docs for the conversion
+   * table used in each direction. Pass `null` to explicitly skip an
+   * instance-level `defaultBudgetTokens` for this one call, mirroring
+   * `reasoningEffort: null` above; omitting the field entirely defers to
+   * the instance default.
+   */
+  budgetTokens?: number | null;
   /**
    * Provider-native JSON Schema output constraint. Implies jsonMode: true.
    */
@@ -829,23 +908,9 @@ interface CallParams<T = unknown> extends UsageHooks {
    */
   schema?: SchemaLike<T>;
   /**
-   * Tools the model may call. When set, `call()` always returns a
-   * `CallWithToolsResult<T>` discriminated union instead of `T` directly
-   * (see `CallWithToolsResult`), a breaking-change point: omitting `tools`
-   * keeps `call()`'s old `Promise<T>` behavior exactly.
-   *
-   * Can be combined with `jsonSchema` on Gemini and OpenAI-compatible
-   * clients unconditionally (neither ever restricted the combination:
-   * Gemini builds `responseSchema`/`tools` as independent fields, OpenAI-
-   * compatible clients pass both straight through). On Anthropic and
-   * Bedrock, combining the two is opt-in per call site, via each
-   * adapter's `nativeStructuredOutputModels` option: models not covered
-   * by it still throw `LLMError('validation')`, since `jsonSchema` falls
-   * back to a forced single-tool call there, which would collide with
-   * real tools. See `fromAnthropic`/`fromBedrock`.
-   *
-   * `schema` (client-side validation, distinct from `jsonSchema`) was
-   * never restricted from combining with `tools` on any provider.
+   * Tools the model may call. When set, `call()` returns a
+   * `CallWithToolsResult<T>` union instead of `T` directly. Combining with
+   * `jsonSchema` is provider-dependent; see the Tool Calling docs.
    */
   tools?: ToolDefinition[];
   /** Defaults to `'auto'` when `tools` is set. */
@@ -887,6 +952,20 @@ interface CallParams<T = unknown> extends UsageHooks {
 type ToolEnabledCallParams<T> = CallParams<T> & {
   tools: NonNullable<CallParams<T>['tools']>;
 };
+/**
+ * A `CallParams` variant for tools set conditionally, e.g. `tools:
+ * someCondition ? [myTool] : undefined`. Selects the `call()` overload
+ * returning the honest union `T | CallWithToolsResult<T>` instead of
+ * falling through to plain `T` (which is what happened before this type
+ * existed, since `ToolDefinition[] | undefined` matched neither
+ * `ToolEnabledCallParams` nor `ToolsDisabledCallParams`). Forces an
+ * `isToolCallResult()` check before treating the result as plain
+ * content. Omitting `tools` entirely still resolves to plain `T`, since
+ * tools genuinely cannot have run there.
+ */
+type ConditionalToolCallParams<T> = CallParams<T> & {
+  tools: ToolDefinition[] | undefined;
+};
 /**
  * A `CallParams` variant where tools are offered but the model is barred
  * from calling one. `toolChoice: 'none'` guarantees the response can never
@@ -901,6 +980,35 @@ type ToolsDisabledCallParams<T> = CallParams<T> & {
   tools: NonNullable<CallParams<T>['tools']>;
   toolChoice: 'none';
 };
+/**
+ * `CallParams` with `jsonMode: false`. Selects the `call()` overload
+ * that returns a plain `string`. `jsonSchema` is typed `never` here: a
+ * truthy `jsonSchema` forces JSON parsing at runtime regardless of
+ * `jsonMode` (see `RequestBuilder.build()`), so `jsonMode: false` +
+ * `jsonSchema` together would otherwise still match this overload and
+ * falsely promise a `string`.
+ */
+type JsonModeDisabledCallParams = Omit<CallParams<unknown>, 'jsonSchema'> & {
+  jsonMode: false;
+  jsonSchema?: never;
+};
+/**
+ * `CallParams` with `jsonMode: true` and no `schema`. Selects the
+ * `call()` overload that returns a `JsonValue`.
+ *
+ * `schema` is explicitly typed `never` here, not just omitted: `CallParams<JsonValue>['schema']`
+ * would be `SchemaLike<JsonValue> | undefined`, and a schema whose inferred result type is
+ * itself structurally assignable to `JsonValue` (e.g. a schema for `string[]` or
+ * `Record<string, string>`) would still satisfy that shape, incorrectly selecting this
+ * overload over the schema-aware generic one and widening the result to `JsonValue`. Forcing
+ * `schema?: never` makes any call that sets `schema` fail this overload's structural check
+ * regardless of the schema's result type, so it always falls through to the generic
+ * `CallParams<T>` overload and infers `T` from the schema instead.
+ */
+type JsonModeEnabledCallParams = Omit<CallParams<JsonValue>, 'schema'> & {
+  jsonMode: true;
+  schema?: never;
+};
 /** Shared cache-configuration fields, minus the internal `fn` primitive. */
 interface CachedCallInput extends UsageHooks {
   cacheKey: string;
@@ -908,22 +1016,10 @@ interface CachedCallInput extends UsageHooks {
   signal?: AbortSignal;
 }
 /**
- * Parameters for a cached LLM call without tool calling.
- *
- * Combines the cache configuration with the `CallParams` passed to
- * `VernLLM.call()`. The cached value is the normal LLM response type `T`.
- *
- * `reserveUsage`/`refundUsage` are omitted from `call`'s type on purpose:
- * `CachedCallInput` already extends `UsageHooks`, so those two hooks
- * belong at the top level, alongside `cacheKey`/`ttl`, not nested inside
- * `call`. Both positions used to typecheck, which meant `cachedCall`
- * could only catch the mistake at runtime with a warning, after silently
- * ignoring the caller's usage hooks. Putting them inside `call` as an
- * inline object literal is now a compile error instead; TypeScript's
- * excess-property check only applies to object literals though, so a
- * preconstructed value carrying `reserveUsage`/`refundUsage` can still be
- * structurally assignable, which is why `cachedCall` also checks for and
- * rejects both hooks at runtime.
+ * Parameters for a cached LLM call without tool calling: cache config
+ * plus the `CallParams` passed to `call()`. `reserveUsage`/`refundUsage`
+ * belong at the top level (`CachedCallInput`), not nested in `call`; see
+ * the caching docs for why.
  */
 type CachedCallParams<T> = CachedCallInput & {
   call: Omit<CallParams<T>, 'reserveUsage' | 'refundUsage'>;
@@ -941,6 +1037,29 @@ type CachedCallParams<T> = CachedCallInput & {
 type CachedToolCallParams<T> = CachedCallInput & {
   call: Omit<ToolEnabledCallParams<T>, 'reserveUsage' | 'refundUsage'>;
 };
+/**
+ * Parameters for a cached LLM call with `call.tools` set conditionally.
+ * Selects the `cachedCall()` overload that returns the honest union
+ * `T | CallWithToolsResult<T>` instead of narrowing to plain `T`. See
+ * `ConditionalToolCallParams` for why this overload exists.
+ */
+type CachedConditionalToolCallParams<T> = CachedCallInput & {
+  call: Omit<ConditionalToolCallParams<T>, 'reserveUsage' | 'refundUsage'>;
+};
+/**
+ * Parameters for a cached LLM call with `jsonMode: false`. Selects the
+ * `cachedCall()` overload that returns a plain `string`.
+ */
+type CachedJsonModeDisabledCallParams = CachedCallInput & {
+  call: Omit<JsonModeDisabledCallParams, 'reserveUsage' | 'refundUsage'>;
+};
+/**
+ * Parameters for a cached LLM call with `jsonMode: true` and no `schema`.
+ * Selects the `cachedCall()` overload that returns a `JsonValue`.
+ */
+type CachedJsonModeEnabledCallParams = CachedCallInput & {
+  call: Omit<JsonModeEnabledCallParams, 'reserveUsage' | 'refundUsage'>;
+};
 
 //#endregion
 //#region src/types/stream.d.ts
@@ -969,32 +1088,10 @@ type StreamChunk = {
   usage: TokenUsage;
 };
 /**
- * What `call()` returns when `stream: true`. `chunks` is for live rendering;
- * `finalResult` resolves to the same validated `T`/`CallWithToolsResult<T>`
- * shape `call()` would have returned had `stream` been omitted, once the
- * stream completes successfully.
- *
- * `chunks` is single-use and supports only one consumer: iterating it more
- * than once, or from more than one place concurrently, shares the same
- * underlying buffered stream rather than replaying or forking it, which can
- * split chunks unpredictably between consumers. Stopping iteration early
- * (e.g. `break`ing out of a `for await`) does not cancel or otherwise
- * signal the underlying stream, the background pump keeps running to
- * completion regardless, buffering any chunks emitted after that point, so
- * `finalResult` still settles normally even if `chunks` is abandoned or
- * never read at all.
- *
- * Unread chunks are buffered internally for the duration of one stream,
- * this is what lets a caller start iterating `chunks` after the stream has
- * already progressed (or finished) and still see everything. That backlog
- * is capped: an unusually large stream whose `chunks` is never read at all
- * has its oldest buffered chunks dropped once the backlog grows past
- * roughly twice a fixed internal limit, trimmed back down to that limit in
- * one batch rather than one-at-a-time, bounding both peak memory and the
- * eviction work itself for that pathological case instead of the array
- * growing (or being trimmed) proportional to the whole stream's output.
- * Ordinary consumption, even started somewhat late, stays far under the
- * limit and is unaffected.
+ * What `call()` returns when `stream: true`. `finalResult` resolves to
+ * the same shape `call()` would have returned with `stream` omitted.
+ * `chunks` is single-use and buffered; see the streaming docs for the
+ * full consumption/backpressure semantics.
  */
 interface StreamCallResult<R> {
   chunks: AsyncIterable<StreamChunk>;
@@ -1010,6 +1107,31 @@ interface StreamCallResult<R> {
 type StreamEnabledCallParams<T> = CallParams<T> & {
   stream: true;
 };
+/**
+ * `StreamEnabledCallParams` with `jsonMode: false`. Selects the streaming
+ * `call()` overload whose `finalResult` resolves to a plain `string`.
+ * `jsonSchema` is typed `never` for the same reason as
+ * `JsonModeDisabledCallParams`.
+ */
+type StreamJsonModeDisabledCallParams = Omit<StreamEnabledCallParams<unknown>, 'jsonSchema'> & {
+  jsonMode: false;
+  jsonSchema?: never;
+};
+/**
+ * `StreamEnabledCallParams` with `jsonMode: true` and no `schema`. Selects
+ * the streaming `call()` overload whose `finalResult` resolves to a
+ * `JsonValue`.
+ *
+ * `schema` is explicitly `never` here for the same reason as
+ * `JsonModeEnabledCallParams`: a schema whose result type is itself
+ * structurally assignable to `JsonValue` would otherwise still satisfy this
+ * overload's shape and incorrectly widen the result to `JsonValue` instead
+ * of the schema's real type.
+ */
+type StreamJsonModeEnabledCallParams = Omit<StreamEnabledCallParams<JsonValue>, 'schema'> & {
+  jsonMode: true;
+  schema?: never;
+};
 /**
  * The adapter-facing, pre-normalization shape a `createStream` client
  * implementation emits, analogous to how `WireMessage`/`WireToolCall`
@@ -1032,6 +1154,9 @@ type WireStreamChunk = {
     prompt_tokens?: number;
     completion_tokens?: number;
     total_tokens?: number;
+    completion_tokens_details?: {
+      reasoning_tokens?: number;
+    };
   };
 } | {
   /**
@@ -1067,6 +1192,32 @@ type CachedStreamCallParams<T> = CachedCallInput & {
 type CachedStreamToolCallParams<T> = CachedCallInput & {
   call: Omit<StreamEnabledCallParams<T> & ToolEnabledCallParams<T>, 'reserveUsage' | 'refundUsage'>;
 };
+/**
+ * Parameters for a cached, streaming LLM call with `call.tools` set
+ * conditionally. Selects the `cachedCall()` overload whose `finalResult`
+ * (on a miss) or cached value (on a hit) is the honest union
+ * `T | CallWithToolsResult<T>` instead of narrowing to plain `T`. See
+ * `ConditionalToolCallParams` for why this overload exists.
+ */
+type CachedStreamConditionalToolCallParams<T> = CachedCallInput & {
+  call: Omit<StreamEnabledCallParams<T> & ConditionalToolCallParams<T>, 'reserveUsage' | 'refundUsage'>;
+};
+/**
+ * Parameters for a cached, streaming LLM call with `jsonMode: false`.
+ * Selects the `cachedCall()` overload whose `finalResult` (on a miss) or
+ * cached value (on a hit) is a plain `string`.
+ */
+type CachedStreamJsonModeDisabledCallParams = CachedCallInput & {
+  call: Omit<StreamJsonModeDisabledCallParams, 'reserveUsage' | 'refundUsage'>;
+};
+/**
+ * Parameters for a cached, streaming LLM call with `jsonMode: true` and no
+ * `schema`. Selects the `cachedCall()` overload whose `finalResult` (on a
+ * miss) or cached value (on a hit) is a `JsonValue`.
+ */
+type CachedStreamJsonModeEnabledCallParams = CachedCallInput & {
+  call: Omit<StreamJsonModeEnabledCallParams, 'reserveUsage' | 'refundUsage'>;
+};
 
 //#endregion
 //#region src/types/client.d.ts
@@ -1115,6 +1266,19 @@ type WireToolChoice = 'auto' | 'none' | 'required' | {
  * rather than importing the SDKs own params type
  */
 interface LLMClient {
+  /**
+   * Whether this client supports OpenAI's `response_format: { type:
+   * 'json_object' }` as a real, API-level constraint. Defaults to `true`
+   * when omitted (every OpenAI-compatible client and `fromGemini` map it to
+   * a real field). `fromAnthropic` and `fromBedrock` set this to `false`:
+   * neither provider has a field that mechanically guarantees JSON output
+   * for this mode, so `RequestBuilder` downgrades a *default* (unset)
+   * `jsonMode` to plain text for these clients instead of requesting
+   * `json_object` and getting an unenforced, provider-side no-op back. An
+   * *explicit* `jsonMode: true` still throws for such clients, since that's
+   * a caller deliberately asking for a guarantee the client can't provide.
+   */
+  supportsJsonObjectMode?: boolean;
   chat: {
     completions: {
       create(params: {
@@ -1134,6 +1298,13 @@ interface LLMClient {
         };
         /** OpenAI reasoning-model param (o-series, gpt-5), ignored by providers that don't support it */
         reasoning_effort?: 'minimal' | 'low' | 'medium' | 'high';
+        /**
+         * Numeric reasoning token budget, for providers with a native
+         * budget field (Anthropic, Gemini). Ignored by clients that only
+         * understand `reasoning_effort` tiers, use that field instead for
+         * those.
+         */
+        budget_tokens?: number;
         /** Tools the model may call, OpenAI's `function`-wrapped shape. */
         tools?: Array<{
           type: 'function';
@@ -1163,6 +1334,9 @@ interface LLMClient {
           prompt_tokens?: number;
           completion_tokens?: number;
           total_tokens?: number;
+          completion_tokens_details?: {
+            reasoning_tokens?: number;
+          };
         };
       }>;
       /**
@@ -1296,6 +1470,20 @@ interface VernLLMOptions {
    * request entirely, so the provider applies its own default instead.
    */
   defaultTemperature?: number | null;
+  /**
+   * Default reasoning effort for calls that don't override it. Not sent
+   * when omitted, same as leaving `reasoningEffort` unset on a call. See
+   * `budgetTokens`/`reasoningEffort` on `CallParams` for how the two
+   * relate and how each adapter converts between them.
+   */
+  defaultReasoningEffort?: 'minimal' | 'low' | 'medium' | 'high';
+  /**
+   * Default reasoning token budget for calls that don't override it. Not
+   * sent when omitted. If both this and `defaultReasoningEffort` are set,
+   * each adapter still prefers whichever field it natively understands,
+   * same as at the per-call level.
+   */
+  defaultBudgetTokens?: number;
   /**
    * Enables debug logging of raw model output (logs up to 800 chars of each
    * response) and provider errors. Off by default. Only controls the
@@ -1387,7 +1575,7 @@ interface VernLLMOptions {
 //#region src/vernLLM.d.ts
 //# sourceMappingURL=options.d.ts.map
 /**
- * A resilient layer around an LLM chat completions client. This is VernLLM!
+ * A LLM call framework for resilience, observability and control. This is VernLLM!
  *
  * Adds retry with backoff and jitter, per-attempt timeouts, an optional
  * circuit breaker, JSON parsing with optional schema validation, usage
@@ -1449,10 +1637,16 @@ declare class VernLLM {
    * continue via `history` (see `ConversationTurn`). Mutually exclusive
    * with `jsonSchema`/`schema`.
    *
-   * TypeScript only picks the tools-aware overload when `tools` is
-   * statically present on `params`. If set conditionally on a plain
-   * `CallParams<T>`, use `isToolCallResult()` to check the shape at
-   * runtime instead. See the Tool Calling docs for details.
+   * TypeScript picks the tools-aware overload (`CallWithToolsResult<T>`)
+   * when `tools` is a literal array on `params`, and the conditional-tools
+   * overload (`T | CallWithToolsResult<T>`, see `ConditionalToolCallParams`)
+   * when `tools` is present but statically `ToolDefinition[] | undefined`,
+   * e.g. `const tools = condition ? [myTool] : undefined`. Either way, use
+   * `isToolCallResult()` to narrow the result once `tools` isn't a literal
+   * array: TypeScript's static type can't know from the `ConditionalToolCallParams`
+   * shape alone whether tools actually ran on a given call. Only omitting
+   * `tools` entirely resolves to the plain `T` overload, since then tools
+   * genuinely cannot have run. See the Tool Calling docs for details.
    *
    * The same static-vs-dynamic caveat applies to `stream`: TypeScript only
    * selects the streaming overload (returning `StreamCallResult<...>`) when
@@ -1474,9 +1668,15 @@ declare class VernLLM {
    */
   call<T = unknown>(params: StreamEnabledCallParams<T> & ToolsDisabledCallParams<T>): Promise<StreamCallResult<ContentResult<T>>>;
   call<T = unknown>(params: StreamEnabledCallParams<T> & ToolEnabledCallParams<T>): Promise<StreamCallResult<CallWithToolsResult<T>>>;
+  call<T = unknown>(params: StreamEnabledCallParams<T> & ConditionalToolCallParams<T>): Promise<StreamCallResult<T | CallWithToolsResult<T>>>;
+  call(params: StreamJsonModeDisabledCallParams): Promise<StreamCallResult<string>>;
+  call(params: StreamJsonModeEnabledCallParams): Promise<StreamCallResult<JsonValue>>;
   call<T = unknown>(params: StreamEnabledCallParams<T>): Promise<StreamCallResult<T>>;
   call<T = unknown>(params: ToolsDisabledCallParams<T>): Promise<ContentResult<T>>;
   call<T = unknown>(params: ToolEnabledCallParams<T>): Promise<CallWithToolsResult<T>>;
+  call<T = unknown>(params: ConditionalToolCallParams<T>): Promise<T | CallWithToolsResult<T>>;
+  call(params: JsonModeDisabledCallParams): Promise<string>;
+  call(params: JsonModeEnabledCallParams): Promise<JsonValue>;
   call<T = unknown>(params: CallParams<T>): Promise<T>;
   /**
    * Thin delegator kept private on `VernLLM` (rather than only existing on
@@ -1523,8 +1723,14 @@ declare class VernLLM {
    * @returns The cached value on a hit, or the freshly-called result on a miss.
    */
   cachedCall<T>(params: CachedStreamToolCallParams<T>): Promise<StreamCallResult<CallWithToolsResult<T>>>;
+  cachedCall<T>(params: CachedStreamConditionalToolCallParams<T>): Promise<StreamCallResult<T | CallWithToolsResult<T>>>;
+  cachedCall(params: CachedStreamJsonModeDisabledCallParams): Promise<StreamCallResult<string>>;
+  cachedCall(params: CachedStreamJsonModeEnabledCallParams): Promise<StreamCallResult<JsonValue>>;
   cachedCall<T>(params: CachedStreamCallParams<T>): Promise<StreamCallResult<T>>;
   cachedCall<T>(params: CachedToolCallParams<T>): Promise<CallWithToolsResult<T>>;
+  cachedCall<T>(params: CachedConditionalToolCallParams<T>): Promise<T | CallWithToolsResult<T>>;
+  cachedCall(params: CachedJsonModeDisabledCallParams): Promise<string>;
+  cachedCall(params: CachedJsonModeEnabledCallParams): Promise<JsonValue>;
   cachedCall<T>(params: CachedCallParams<T>): Promise<T>;
   /**
    * @param target.index Which target to read. Defaults to the primary.
@@ -1563,6 +1769,41 @@ declare class VernLLM {
   /** Warns when `model` can't do anything on this target, so it's never silently ignored. */
   private warnIfModelUnsupported;
 }
+/**
+ * Identity function preserving `params`'s own precise type, unlike a `:
+ * CallParams<T>` annotation, which would widen `tools` away and break the
+ * `ConditionalToolCallParams<T>` overload for `tools: someCondition ?
+ * [tool] : undefined`. Use it when you need `call()` params in a named,
+ * reusable variable; skip it when you can pass the object inline.
+ *
+ * ```ts
+ * const params = defineCallParams({
+ *   userContent: 'What is the weather?',
+ *   tools: someCondition ? [weatherTool] : undefined,
+ * });
+ * const result = await llm.call(params);
+ * // result: unknown | CallWithToolsResult<unknown>, same as inline
+ * ```
+ *
+ * `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;
+/**
+ * The `cachedCall()` counterpart to `defineCallParams`: preserves the
+ * whole `{ cacheKey, ttl, call }` object, `call.tools` included, in one
+ * named variable.
+ *
+ * ```ts
+ * const params = defineCachedCallParams({
+ *   cacheKey: 'weather-ny',
+ *   ttl: 60,
+ *   call: { userContent: 'What is the weather?', tools: someCondition ? [weatherTool] : undefined },
+ * });
+ * const result = await llm.cachedCall(params);
+ * ```
+ */
+declare function defineCachedCallParams<P extends CachedCallParams<unknown>>(params: P): P;
 
 //#endregion
 //#region src/adapters/internal/sse.d.ts
@@ -1647,8 +1888,31 @@ type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
 type ModelCapabilityOverride = string[] | ((model: string) => boolean);
 
 //#endregion
-//#region src/adapters/anthropic.d.ts
+//#region src/adapters/internal/reasoningBudget.utils.d.ts
 /** Resolves whether `model` is covered by a caller-supplied allow-list/predicate. */
+/**
+ * Shared conversion between the two reasoning controls VernLLM exposes:
+ * `reasoningEffort` (a tier string, OpenAI's native shape) and
+ * `budgetTokens` (a raw integer, Anthropic's and Gemini's native shape).
+ *
+ * Every adapter prefers its own native field when the caller set it, and
+ * only calls into this table when the caller set the other one instead.
+ * The numbers here are a guess, not a provider guarantee, callers who
+ * need a precise budget on a specific model should set `budgetTokens`
+ * directly rather than relying on this table's `reasoningEffort` mapping.
+ *
+ * The table itself is overridable per adapter instance, via
+ * `reasoningEffortTokens` on each `from*` adapter's options (see
+ * `AnthropicAdapterOptions`, `GeminiAdapterOptions`,
+ * `OpenAICompatibleAdapterOptions`, `BedrockAdapterOptions`), for callers
+ * who want `reasoningEffort` tiers to map onto different token counts
+ * than the defaults below, e.g. a model whose useful reasoning range
+ * doesn't match these numbers.
+ */
+type EffortTokenTable = Record<'minimal' | 'low' | 'medium' | 'high', number>;
+
+//#endregion
+//#region src/adapters/anthropic.d.ts
 /** Anthropic's native per-block content shape for a message. */
 type AnthropicContentBlock = {
   type: 'text';
@@ -1719,10 +1983,33 @@ interface AnthropicClient {
        * output endpoint has no equivalent for any of them.
        */
       output_config?: {
-        format: {
+        format?: {
           type: 'json_schema';
           schema: Record<string, unknown>;
         };
+        /**
+         * Effort control for adaptive thinking, on models where manual
+         * `budget_tokens` thinking is no longer accepted (see
+         * `supportsManualThinkingBudget` in
+         * `adapters/internal/reasoningBudget.utils.ts`). Sibling to
+         * `format`, either or both may be present independently.
+         */
+        effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+      };
+      /**
+       * Native reasoning control. `{ type: 'enabled', budget_tokens }`
+       * is built directly from `CallParams.budgetTokens`, or converted
+       * from `reasoningEffort`, on models that still accept a manual
+       * token budget. `{ type: 'adaptive' }` is sent instead, paired
+       * with `output_config.effort`, on models that only support
+       * adaptive thinking. See
+       * `adapters/internal/reasoningBudget.utils.ts`.
+       */
+      thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+      } | {
+        type: 'adaptive';
       };
     }, options: {
       signal: AbortSignal;
@@ -1737,6 +2024,9 @@ interface AnthropicClient {
       usage?: {
         input_tokens?: number;
         output_tokens?: number;
+        output_tokens_details?: {
+          thinking_tokens?: number;
+        } | null;
       };
     }>;
   };
@@ -1755,6 +2045,25 @@ interface AnthropicAdapterOptions {
    * exactly this adapter's behavior before native support was added.
    */
   nativeStructuredOutputModels?: ModelCapabilityOverride;
+  /**
+   * Overrides the token count `reasoningEffort` tiers map onto when the
+   * caller sets `reasoningEffort` but not `budgetTokens` (Claude has no
+   * tier concept of its own, see `adapters/internal/reasoningBudget.utils.ts`).
+   * Only the tiers listed are changed; any omitted tier keeps the
+   * built-in default. Has no effect when `budgetTokens` is set directly.
+   */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Marks additional models as adaptive-only, on top of this package's
+   * own built-in rule (Claude Opus 4.7 and later, every Claude 5 tier
+   * model, see `isAdaptiveOnlyModel` in
+   * `adapters/internal/reasoningBudget.utils.ts`). Additive, not a
+   * replacement: it can correct a false negative (a newer model this
+   * package doesn't know about yet), it can't un-mark a model the
+   * built-in rule already caught. Pass a static list of model IDs or a
+   * predicate.
+   */
+  adaptiveOnlyModels?: ModelCapabilityOverride;
 }
 /**
  * Wraps an Anthropic SDK client so it satisfies the same `LLMClient`
@@ -1778,17 +2087,25 @@ interface AnthropicAdapterOptions {
  * schema matching applies only when `strict: true` is forwarded and
  * supported.
  *
- * `response_format: json_object` (no schema to build a tool from) falls
- * back to a system-prompt instruction, since there's nothing to constrain
- * generation against. Unlike `jsonSchema`, this combines with real `tools`
- * freely on every model: it's a prompt nudge, not a request field, so
- * there's nothing for it to collide with.
+ * `response_format: json_object` throws `LLMError('validation')`. Anthropic
+ * has no API-level field that mechanically guarantees JSON output the way
+ * OpenAI's `json_object` mode does; the only way to emulate it was a
+ * system-prompt instruction with no actual enforcement behind it, a
+ * guarantee this adapter no longer pretends to make. Use `jsonSchema`
+ * 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;
 
 //#endregion
 //#region src/adapters/gemini.d.ts
-/** Gemini's native per-part content shape for a `contents` entry. */
+/**
+ * Gemini's native per-part content shape for a `contents` entry.
+ * `functionCall.args` and `functionResponse.response` are typed as
+ * `Record<string, unknown>` (not `unknown`) to match the real SDK's
+ * `FunctionCall.args` / `FunctionResponse.response`, see the doc comment
+ * on {@link GeminiClient}.
+ */
 type GeminiPart = {
   text: string;
 } | {
@@ -1799,31 +2116,44 @@ type GeminiPart = {
 } | {
   functionCall: {
     name: string;
-    args: unknown;
+    args: Record<string, unknown>;
   };
 } | {
   functionResponse: {
     name: string;
-    response: unknown;
+    response: Record<string, unknown>;
   };
 };
 /**
- * Structural type matching the real `@google/genai` SDK's `ai.models`
- * object: `generateContent`/`generateContentStream` both take a single
- * `{ model, contents, config }` argument (config carries
- * `systemInstruction`, `tools`, `toolConfig`, generation settings, and
- * `abortSignal` all together), matching the real SDK closely enough that
- * `fromGemini(ai.models)` works directly, e.g:
+ * Structural type matching the real `@google/genai` SDK, in either shape
+ * it's commonly held in: the callable model methods directly (`ai.models`),
+ * or the complete top-level client (`ai`, via the optional `models` field
+ * below). Both work with `fromGemini` directly, with no cast:
  *
  * ```ts
  * import { GoogleGenAI } from '@google/genai';
  * const ai = new GoogleGenAI({ apiKey: '...' });
- * const llm = new VernLLM({ client: fromGemini(ai.models), model: 'gemini-2.5-flash' });
+ * const llm = new VernLLM({ client: fromGemini(ai), model: 'gemini-2.5-flash' });
  * ```
+ *
+ * `generateContent` is optional so a `{ models: ... }`-shaped value is
+ * still a structural `GeminiClient`; `fromGemini` resolves `models` at
+ * runtime and throws if nothing callable results.
+ *
+ * Every field is shaped to be structurally assignable from the real SDK's
+ * generated types without importing them, so provider SDKs stay optional:
+ * `model` is required (the real SDK requires it), `functionCall.args` /
+ * `functionResponse.response` are `Record<string, unknown>` (matching the
+ * real SDK, not `unknown`), `toolConfig...mode` is `any` (TypeScript never
+ * treats a string-literal union as assignable to the real SDK's string
+ * enum), and response-side `functionCall.name` is optional (matching the
+ * real SDK).
  */
 interface GeminiClient {
-  generateContent(params: {
-    model?: string;
+  /** Present when this is the whole top-level SDK client, not `ai.models`. `fromGemini` unwraps it at runtime. */
+  models?: GeminiClient;
+  generateContent?(params: {
+    model: string;
     contents: Array<{
       role: 'user' | 'model';
       parts: GeminiPart[];
@@ -1847,10 +2177,25 @@ interface GeminiClient {
       }>;
       toolConfig?: {
         functionCallingConfig: {
-          mode: 'AUTO' | 'ANY' | 'NONE';
+          mode: any;
           allowedFunctionNames?: string[];
         };
       };
+      /**
+       * Native reasoning control. `thinkingBudget` is built from
+       * `CallParams.budgetTokens` directly when set (0 disables thinking,
+       * -1 requests automatic budgeting, both passed through unchanged),
+       * or converted from `reasoningEffort`, on Gemini 2.5 and earlier
+       * models. `thinkingLevel` is used instead on Gemini 3 and later,
+       * which use a level-based control rather than a numeric budget.
+       * `any`, same reason as `toolConfig...mode` above, see class doc
+       * comment. See `usesGeminiThinkingLevel` in
+       * `adapters/internal/reasoningBudget.utils.ts`.
+       */
+      thinkingConfig?: {
+        thinkingBudget?: number;
+        thinkingLevel?: any;
+      };
       abortSignal?: AbortSignal;
     };
   }): Promise<{
@@ -1859,8 +2204,8 @@ interface GeminiClient {
         parts?: Array<{
           text?: string;
           functionCall?: {
-            name: string;
-            args: unknown;
+            name?: string;
+            args?: unknown;
           };
         }>;
       };
@@ -1869,6 +2214,7 @@ interface GeminiClient {
       promptTokenCount?: number;
       candidatesTokenCount?: number;
       totalTokenCount?: number;
+      thoughtsTokenCount?: number;
     };
   }>;
   /**
@@ -1879,14 +2225,14 @@ interface GeminiClient {
    * holding the same `candidates[].content.parts[]` structure as
    * `generateContent`'s response, just incremental.
    */
-  generateContentStream?(params: Parameters<GeminiClient['generateContent']>[0]): Promise<AsyncIterable<{
+  generateContentStream?(params: Parameters<NonNullable<GeminiClient['generateContent']>>[0]): Promise<AsyncIterable<{
     candidates?: Array<{
       content?: {
         parts?: Array<{
           text?: string;
           functionCall?: {
-            name: string;
-            args: unknown;
+            name?: string;
+            args?: unknown;
           };
         }>;
       };
@@ -1895,6 +2241,7 @@ interface GeminiClient {
       promptTokenCount?: number;
       candidatesTokenCount?: number;
       totalTokenCount?: number;
+      thoughtsTokenCount?: number;
     };
   }>>;
 }
@@ -1905,9 +2252,10 @@ interface GeminiClient {
  * `systemInstruction` field instead of a `system` role message,
  * `generationConfig` instead of top-level `temperature`/`max_tokens`, and
  * native JSON Schema support via `responseMimeType: 'application/json'` +
- * `responseSchema`. `reasoning_effort` has no equivalent. Gemini's thinking
- * models use a token budget, not an effort tier, so it's dropped, same as
- * Anthropic.
+ * `responseSchema`. `reasoning_effort` has no native Gemini equivalent, so
+ * it's converted to a `thinkingConfig.thinkingBudget` token count; `budget_tokens`
+ * maps to `thinkingBudget` directly, Gemini's native reasoning control. See
+ * `adapters/internal/reasoningBudget.utils.ts`.
  *
  * `tools` maps to Gemini's native `functionDeclarations`/`functionCall`;
  * `tool_choice` maps to `toolConfig.functionCallingConfig`. Gemini accepts
@@ -1927,8 +2275,36 @@ interface GeminiClient {
  * own behavior) only reliably present on the last chunk, so the `usage`
  * `WireStreamChunk` is emitted once, after the stream completes, from
  * whichever chunk's `usageMetadata` was seen last.
+ *
+ * Accepts a `GeminiClient` in either shape it structurally covers: the
+ * callable model methods directly (`ai.models`), or the complete
+ * top-level client (`ai`), unwrapping `.models` internally when present.
+ * Both work with no cast: `fromGemini(ai.models)` and `fromGemini(ai)`.
+ * Throws `LLMError('invalid_params')` up front if nothing callable
+ * results.
  */
-declare function fromGemini(geminiClient: GeminiClient): LLMClient;
+interface GeminiAdapterOptions {
+  /**
+   * Overrides the token count `reasoningEffort` tiers map onto when the
+   * caller sets `reasoningEffort` but not `budgetTokens` (Gemini has no
+   * tier string of its own, see `adapters/internal/reasoningBudget.utils.ts`).
+   * Only the tiers listed are changed; any omitted tier keeps the
+   * built-in default. Has no effect when `budgetTokens` is set directly.
+   */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Marks additional models as using `thinkingLevel` instead of
+   * `thinkingBudget`, on top of this package's own built-in rule (every
+   * Gemini 3 series model and later, see `usesGeminiThinkingLevel` in
+   * `adapters/internal/reasoningBudget.utils.ts`). Additive, not a
+   * replacement: it can correct a false negative (a newer model this
+   * package doesn't know about yet), it can't un-mark a model the
+   * built-in rule already caught. Pass a static list of model IDs or a
+   * predicate.
+   */
+  thinkingLevelModels?: ModelCapabilityOverride;
+}
+declare function fromGemini(client: GeminiClient, options?: GeminiAdapterOptions): LLMClient;
 
 //#endregion
 //#region src/adapters/bedrock.d.ts
@@ -2027,7 +2403,7 @@ interface BedrockConverseClient {
      * included). There is no `strict` field here, unlike `toolSpec`.
      */
     outputConfig?: {
-      textFormat: {
+      textFormat?: {
         type: 'json_schema';
         structure: {
           jsonSchema: {
@@ -2037,7 +2413,23 @@ interface BedrockConverseClient {
           };
         };
       };
+      /**
+       * Effort control for adaptive thinking, on Claude models where
+       * manual `budget_tokens` thinking is no longer accepted (see
+       * `supportsManualThinkingBudget` in
+       * `adapters/internal/reasoningBudget.utils.ts`). Sibling to
+       * `textFormat`, either or both may be present independently.
+       */
+      effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     };
+    /**
+     * Model-specific passthrough. Converse has no reasoning-budget field
+     * of its own, so a token budget for a Claude model on Bedrock is
+     * forwarded here under Anthropic's own key, `{ thinking: { type:
+     * 'enabled', budget_tokens } }`. Non-Claude models get nothing here,
+     * there is no equivalent field to reach for.
+     */
+    additionalModelRequestFields?: Record<string, unknown>;
   }, options: {
     signal: AbortSignal;
   }): Promise<{
@@ -2175,6 +2567,37 @@ interface BedrockAdapterOptions {
    * added.
    */
   nativeStructuredOutputModels?: ModelCapabilityOverride;
+  /**
+   * Overrides the token count `reasoningEffort` tiers map onto when the
+   * caller sets `reasoningEffort` but not `budgetTokens` (Converse has no
+   * tier string of its own, see `adapters/internal/reasoningBudget.utils.ts`).
+   * Only the tiers listed are changed; any omitted tier keeps the
+   * built-in default. Has no effect when `budgetTokens` is set directly,
+   * or when the target model isn't a Claude model.
+   */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
+  /**
+   * Marks additional models as adaptive-only, on top of this package's
+   * own built-in rule (Claude Opus 4.7 and later, every Claude 5 tier
+   * model, see `isAdaptiveOnlyModel` in
+   * `adapters/internal/reasoningBudget.utils.ts`). Additive, not a
+   * replacement: it can correct a false negative (a newer model this
+   * package doesn't know about yet), it can't un-mark a model the
+   * built-in rule already caught. Pass a static list of model IDs or a
+   * predicate.
+   */
+  adaptiveOnlyModels?: ModelCapabilityOverride;
+}
+/**
+ * Minimal structural shape of an AWS SDK v3 client that exposes `.send()`,
+ * matching `BedrockRuntimeClient` (and its abort-signal-aware call
+ * convention). Avoids importing `@aws-sdk/client-bedrock-runtime` for the
+ * type.
+ */
+interface AwsSendClient {
+  send(command: unknown, options?: {
+    abortSignal?: AbortSignal;
+  }): Promise<unknown>;
 }
 /**
  * Wraps a Bedrock Converse-API client so it satisfies the `LLMClient`
@@ -2184,6 +2607,16 @@ interface BedrockAdapterOptions {
  * regardless of which underlying model `modelId` points at, as long as
  * that model supports Converse (most current-generation ones do)
  *
+ * `bedrockClient` accepts either a hand-written `BedrockConverseClient`
+ * (a `.converse()`/`.converseStream()` wrapper you provide) or a real AWS
+ * SDK v3 client (anything with `.send()`, matching `BedrockRuntimeClient`)
+ * directly, detected structurally. Passing a raw AWS client skips the
+ * hand-written wrapper entirely, internally doing what it would
+ * (`send(new ConverseCommand(...))`, `send(new
+ * ConverseStreamCommand(...))`). See `wrapAwsSendClient` for how that path
+ * is implemented, including why `@aws-sdk/client-bedrock-runtime` stays
+ * out of this package's dependencies either way.
+ *
  * `response_format: json_schema`, on a model covered by
  * `options.nativeStructuredOutputModels` (opt-in, unset by default), is
  * sent as `outputConfig.textFormat`, its own request field, independent of
@@ -2205,12 +2638,15 @@ interface BedrockAdapterOptions {
  * `BedrockAdapterOptions`), otherwise a `jsonSchema` call to an
  * unsupported model surfaces Bedrock's raw error unchanged.
  *
- * `response_format: json_object` (no schema to build a tool from) and
- * `reasoning_effort` (no Converse equivalent) fall back to a system-prompt
- * instruction and are dropped respectively. Unlike `jsonSchema`,
- * `json_object` combines with real `tools` freely on every model: it's a
- * prompt nudge, not a request field, so there's nothing for it to collide
- * with.
+ * `response_format: json_object` throws `LLMError('validation')`: Converse
+ * has no field that mechanically guarantees JSON output, and the only way
+ * to emulate it was an unenforced system-prompt instruction, a guarantee
+ * this adapter no longer pretends to make. Use `jsonSchema` instead.
+ * `reasoning_effort` (no Converse equivalent) is converted to a token
+ * budget and forwarded via `additionalModelRequestFields` for Claude
+ * models only; `budget_tokens` is forwarded the same way directly. Both
+ * are silently dropped for non-Claude models, which have no equivalent
+ * field to reach for. See `adapters/internal/reasoningBudget.utils.ts`.
  *
  * `tools` alone maps to Converse's native `toolConfig`/`toolUse`/
  * `toolResult`; `tool_choice` maps to `toolConfig.toolChoice`.
@@ -2227,7 +2663,7 @@ interface BedrockAdapterOptions {
  * `finalizeResponse`'s `content` path exactly like the non-streaming
  * `create` branch above unwraps it.
  */
-declare function fromBedrock(bedrockClient: BedrockConverseClient, options?: BedrockAdapterOptions): LLMClient;
+declare function fromBedrock(bedrockClient: BedrockConverseClient | AwsSendClient, options?: BedrockAdapterOptions): LLMClient;
 
 //#endregion
 //#region src/adapters/fetch.d.ts
@@ -2438,6 +2874,15 @@ interface OpenAICompatibleAdapterOptions {
    * with such a provider won't get one.
    */
   supportsStreamUsage?: boolean;
+  /**
+   * Overrides the token count `budgetTokens` buckets into when the caller
+   * sets `budgetTokens` but not `reasoningEffort` (OpenAI-compatible
+   * clients have no numeric budget field of their own, see
+   * `adapters/internal/reasoningBudget.utils.ts`). Only the tiers listed
+   * are changed; any omitted tier keeps the built-in default. Has no
+   * effect when `reasoningEffort` is set directly.
+   */
+  reasoningEffortTokens?: Partial<EffortTokenTable>;
 }
 declare function fromOpenAICompatible(client: unknown, options?: OpenAICompatibleAdapterOptions): LLMClient;
 /**
@@ -2549,5 +2994,5 @@ declare const from01AI: typeof fromOpenAICompatible;
 //#endregion
 //# sourceMappingURL=openaiCompatible.d.ts.map
 
-export { AnthropicClient, BedrockConverseClient, CacheAdapter, CachedCallParams, CachedStreamCallParams, CachedStreamToolCallParams, CachedToolCallParams, CallMeta, CallParams, CallWithToolsResult, CircuitBreaker, CircuitBreakerOptions, CircuitState, CircuitTarget, ConsoleLogger, ContentBlock, ContentResult, ConversationTurn, DuplicateToolNamesIssue, FallbackAttempt, FallbackExhaustedError, FallbackOn, FallbackTarget, FetchAdapterConfig, GeminiClient, HistoryToolResultIssue, ImageBlock, InMemoryCacheAdapter, JsonSchemaSpec, LLMClient, LLMError, LLMErrorCode, LLMErrorIssuesByCode, LLMErrorSnapshot, LLMErrorType, Logger, NormalizedCacheAdapter, OnEvent, OnUsage, RateLimitAcquireResult, RateLimitOptions, RateLimitReason, RateLimiter, RefundUsage, ReserveUsage, RetryAttempt, SSE_PING, SchemaLike, StreamCallResult, StreamChunk, StreamEnabledCallParams, TargetCircuitState, TextBlock, TieredCacheAdapter, TokenUsage, ToolCall, ToolCallResult, ToolChoice, ToolDefinition, ToolEnabledCallParams, ToolIssue, ToolResult, ToolsDisabledCallParams, UnknownToolChoiceIssue, UnsupportedCapabilityIssue, VernLLM, VernLLMEvent, VernLLMOptions, WireMessage, WireRequest, WireStreamChunk, WireToolCall, WireToolChoice, defaultEstimateTokens, defaultFallbackOn, from01AI, fromAnthropic, fromAnyscale, fromAtlasCloud, fromBaseten, fromBedrock, fromCerebras, fromCloudflareWorkersAI, fromDeepInfra, fromDeepSeek, fromFeatherless, fromFetch, fromFireworks, fromFriendli, fromGemini, fromGroq, fromHyperbolic, fromInferenceNet, fromInfermatic, fromLMStudio, fromLambdaLabs, fromLepton, fromMiniMax, fromMistral, fromMoonshot, fromNebius, fromNovita, fromNvidiaNIM, fromOllama, fromOpenAI, fromOpenAICompatible, fromOpenRouter, fromParasail, fromPerplexity, fromSambaNova, fromSiliconFlow, fromSnowflakeCortex, fromStepFun, fromTogether, fromVLLM, fromVercelAIGateway, fromXAI, fromZhipu, hasIssues, isFallbackExhaustedError, isLLMError, isToolCallResult, parseSseStream };
+export { AnthropicClient, AssistantContent, BedrockConverseClient, CacheAdapter, CachedCallParams, CachedConditionalToolCallParams, CachedJsonModeDisabledCallParams, CachedJsonModeEnabledCallParams, CachedStreamCallParams, CachedStreamConditionalToolCallParams, CachedStreamJsonModeDisabledCallParams, CachedStreamJsonModeEnabledCallParams, CachedStreamToolCallParams, CachedToolCallParams, CallMeta, CallParams, CallWithToolsResult, CircuitBreaker, CircuitBreakerOptions, CircuitState, CircuitTarget, ConditionalToolCallParams, ConsoleLogger, ContentBlock, ContentResult, ConversationTurn, DuplicateToolNamesIssue, FallbackAttempt, FallbackExhaustedError, FallbackOn, FallbackTarget, FetchAdapterConfig, GeminiClient, HistoryToolResultIssue, ImageBlock, InMemoryCacheAdapter, JsonModeDisabledCallParams, JsonModeEnabledCallParams, JsonSchemaSpec, JsonValue, LLMClient, LLMError, LLMErrorCode, LLMErrorIssuesByCode, LLMErrorSnapshot, LLMErrorType, LLMRequestSnapshot, Logger, NormalizedCacheAdapter, OnEvent, OnUsage, RateLimitAcquireResult, RateLimitOptions, RateLimitReason, RateLimiter, RefundUsage, ReserveUsage, RetryAttempt, SSE_PING, SchemaLike, StreamCallResult, StreamChunk, StreamEnabledCallParams, StreamJsonModeDisabledCallParams, StreamJsonModeEnabledCallParams, TargetCircuitState, TextBlock, TieredCacheAdapter, TokenUsage, ToolCall, ToolCallResult, ToolChoice, ToolDefinition, ToolEnabledCallParams, ToolIssue, ToolResult, ToolsDisabledCallParams, UnknownToolChoiceIssue, UnsupportedCapabilityIssue, VernLLM, VernLLMEvent, VernLLMOptions, WireMessage, WireRequest, WireStreamChunk, WireToolCall, WireToolChoice, defaultEstimateTokens, defaultFallbackOn, defineCachedCallParams, defineCallParams, from01AI, fromAnthropic, fromAnyscale, fromAtlasCloud, fromBaseten, fromBedrock, fromCerebras, fromCloudflareWorkersAI, fromDeepInfra, fromDeepSeek, fromFeatherless, fromFetch, fromFireworks, fromFriendli, fromGemini, fromGroq, fromHyperbolic, fromInferenceNet, fromInfermatic, fromLMStudio, fromLambdaLabs, fromLepton, fromMiniMax, fromMistral, fromMoonshot, fromNebius, fromNovita, fromNvidiaNIM, fromOllama, fromOpenAI, fromOpenAICompatible, fromOpenRouter, fromParasail, fromPerplexity, fromSambaNova, fromSiliconFlow, fromSnowflakeCortex, fromStepFun, fromTogether, fromVLLM, fromVercelAIGateway, fromXAI, fromZhipu, hasIssues, isFallbackExhaustedError, isLLMError, isToolCallResult, parseSseStream };
 //# sourceMappingURL=index.d.cts.map