vern-llm 2.2.0 → 2.4.0

package/dist/index.d.cts

@@ -1,87 +1,22 @@
-//#region src/circuitBreaker.d.ts
-interface CircuitBreakerOptions {
-  /** Consecutive failures before the circuit opens, default 5 */
-  threshold?: number;
-  /** How long the circuit stays open before allowing a trial request, in ms. Default 30000 */
-  cooldownMs?: number;
-  /**
-   * Called after every real state change, never for a no-op transition
-   * (e.g. open to open). `model` is the resolved model of whichever call
-   * triggered this specific transition (the `model` passed to whichever
-   * of `assertClosed`/`recordSuccess`/`recordFailure` caused it).
-   *
-   * With `isolateByModel` off (the default), this is a label only: the
-   * breaker still counts failures across every model together, so a
-   * threshold crossing can be the sum of several different models'
-   * failures even though only the triggering call's `model` is reported
-   * here. With `isolateByModel` on, it's exact: each model has its own
-   * counter, so the transition really was caused solely by that model.
-   */
-  onStateChange?: (from: CircuitState, to: CircuitState, consecutiveFailures: number, model?: string) => void;
-  /**
-   * Track a separate circuit per resolved model instead of one shared
-   * circuit for the whole instance. A failure on one model then never
-   * opens another model's circuit, at the cost of slower detection for
-   * an outage spread across many distinct models (each model's counter
-   * must independently cross `threshold`). Default false: one shared
-   * circuit, matching every version before this option existed.
-   *
-   * A call that omits `model` (only possible calling `CircuitBreaker`
-   * directly, `VernLLM` always passes one) falls into one shared bucket
-   * alongside every other call that also omits it.
-   */
-  isolateByModel?: boolean;
-}
-type CircuitState = 'closed' | 'open' | 'half-open';
-/**
- * Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
- * calls. Once the threshold is hit, short-circuits new calls with an
- * LLMError('circuit_open') instead of hitting the provider, until the
- * cooldown elapses and a single trial call is allowed through
- */
-declare class CircuitBreaker {
-  private readonly threshold;
-  private readonly cooldownMs;
-  private readonly onStateChange?;
-  private readonly isolateByModel;
-  private readonly sharedBucket;
-  private readonly bucketsByModel;
-  constructor(options?: CircuitBreakerOptions);
-  /** Returns the bucket for a model if one already exists, without allocating. */
-  private lookupBucket;
-  /** Creates and stores a bucket for a model when the first mutation needs one. */
-  private ensureBucketFor;
-  /** Every state mutation routes through here, so `onStateChange` fires exactly once per real change. */
-  private transition;
-  /**
-   * Throws if the circuit is open and the cooldown hasn't elapsed, or if
-   * the circuit is half-open and a trial call is already in flight.
-   * Otherwise, if the circuit just became eligible for a trial (cooldown
-   * elapsed, or half-open with no trial currently running), this call
-   * becomes that trial
-   */
-  assertClosed(model?: string): void;
-  recordSuccess(model?: string): void;
-  recordFailure(model?: string): void;
-  /**
-   * With `isolateByModel` off (the default), `model` is ignored and the
-   * one shared circuit's state is returned, unchanged from every version
-   * before this option existed. With `isolateByModel` on, returns that
-   * model's own state, `'closed'` for a model never seen yet, same as a
-   * fresh breaker.
-   */
-  getState(model?: string): CircuitState;
-} //#endregion
 //#region src/types/errors.d.ts
-
-//# sourceMappingURL=circuitBreaker.d.ts.map
-type LLMErrorType = 'timeout' | 'api' | 'parse' | 'validation' | 'circuit_open' | 'quota_exceeded' | 'unknown' | 'aborted';
+type LLMErrorType = 'timeout' | 'api' | 'network' | 'parse' | 'validation' | 'invalid_params' | 'rate_limited' | 'quota_exceeded' | 'circuit_open' | 'fallback_exhausted' | 'aborted' | 'unknown';
 /**
  * Machine readable discriminator within a `type`, for cases where `type`
  * alone is too coarse to act on. Optional and additive: errors thrown
- * before a given code existed simply omit it.
+ * before a given code existed simply omit it. Not owned by a single type;
+ * e.g. `authentication`/`authorization` apply the same way regardless of
+ * which type wraps them.
  */
-type LLMErrorCode = 'unknown_tool' | 'duplicate_tool_call_id' | 'local_rate_limit' | 'provider_rate_limited' | 'fallback_exhausted' | 'invalid_credentials' | 'connection_failed' | 'tool_choice_none_violated';
+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' | 'rate_limit_queue_full' | 'rate_limit_queue_timeout' | 'rate_limit_capacity_exceeded' | 'provider_rate_limited' | 'request_timeout' | 'idle_timeout' | 'authentication' | 'authorization' | 'not_found' | 'payload_too_large' | 'server_error' | 'empty_response' | 'connection_failed' | 'circuit_cooling_down' | 'circuit_trial_in_flight' | 'fallback_exhausted' | 'tool_arguments_parse_failed' | 'stream_frame_invalid';
+/**
+ * Tool contract codes: a model or provider response defect, not a
+ * transient provider fault. Deterministic on the wire request, so
+ * retrying can't change the outcome and it shouldn't count toward the
+ * circuit breaker either. Shared by `LLMError.retryable` below and by
+ * `CallExecutor`'s own retry/breaker accounting, so the two can't drift
+ * apart.
+ */
+
 /** One tool call's contract failure, used to report every bad call in a response at once. */
 interface ToolIssue {
   name: string;
@@ -89,23 +24,219 @@ interface ToolIssue {
   code: LLMErrorCode;
   detail?: unknown;
 }
+/**
+ * The specific values behind a `duplicate_tool_names` failure: the
+ * offending call's `tools` array had more than one entry sharing a name.
+ */
+interface DuplicateToolNamesIssue {
+  names: string[];
+}
+/**
+ * The specific values behind an `unknown_tool_choice` failure: `toolChoice`
+ * named a tool that wasn't in the call's own `tools` array.
+ */
+interface UnknownToolChoiceIssue {
+  requested: string;
+  available: string[];
+}
+/**
+ * The specific values behind a `duplicate_tool_result_ids` /
+ * `unknown_tool_result_ids` / `missing_tool_results` failure: which
+ * `history` turn was affected, and which `toolCallId`s were the problem.
+ */
+interface HistoryToolResultIssue {
+  historyIndex: number;
+  ids: string[];
+}
+/**
+ * The specific values behind an `unsupported_capability` failure: which
+ * capability the current adapter/client/model doesn't support.
+ */
+interface UnsupportedCapabilityIssue {
+  capability: string;
+}
+/**
+ * Maps each `LLMErrorCode` that carries structured `issues` to that
+ * payload's exact shape. Not every code appears here: most `invalid_params`
+ * failures are a single deterministic fact the `message` already states in
+ * full, so adding a typed `issues` entry for them would only duplicate the
+ * message into a field, the same near-duplicate-code problem `code` itself
+ * avoids. Codes that repeat here are exactly the ones whose `message`
+ * already string-joins a list a caller might want to consume directly
+ * rather than re-parse out of prose, or that otherwise want a place to
+ * report the exact captured values of a failure.
+ *
+ * Deliberately not a mapped type over the whole `LLMErrorCode` union: a
+ * schema-validation failure's `issues` (the caller's own Zod-compatible
+ * validator's error object) has no code and no shape VernLLM could know in
+ * advance, so it stays untyped on `LLMError.issues` itself rather than
+ * forcing every code into this table.
+ */
+interface LLMErrorIssuesByCode {
+  unknown_tool: ToolIssue[];
+  duplicate_tool_call_id: ToolIssue[];
+  duplicate_tool_names: DuplicateToolNamesIssue;
+  unknown_tool_choice: UnknownToolChoiceIssue;
+  duplicate_tool_result_ids: HistoryToolResultIssue;
+  unknown_tool_result_ids: HistoryToolResultIssue;
+  missing_tool_results: HistoryToolResultIssue;
+  unsupported_capability: UnsupportedCapabilityIssue;
+}
+/**
+ * Point-in-time copy of an `LLMError`'s fields, produced by
+ * `LLMError.toSnapshot()`. This is what `RetryAttempt.error` holds
+ * instead of a live `LLMError`.
+ *
+ * A past attempt only needs to be describable (message, type, code,
+ * whether it was retryable), never thrown again. So it skips `Error`'s
+ * behavior, `instanceof` identity, and any live getter. Using the full
+ * `LLMError` class here would also make the type self referential
+ * through its own `attempts` field.
+ *
+ * Has no `cause`. `cause` is `unknown` and never validated by VernLLM,
+ * and it is meant to be read directly on the live error you just
+ * caught, not carried indefinitely inside history. `type`, `code`,
+ * `status`, and `issues` are the structured fields a snapshot carries
+ * instead.
+ *
+ * `attempts` is still present, since a recorded attempt can itself be
+ * the terminal failure of an inner retry loop with its own history (see
+ * `FallbackAttempt`). That's a tree of past data, not a cycle.
+ */
+interface LLMErrorSnapshot {
+  message: string;
+  type: LLMErrorType;
+  status?: number;
+  issues?: unknown;
+  retryAfterMs?: number;
+  code?: LLMErrorCode;
+  /** Computed once, at snapshot time, since a snapshot has no live getter. */
+  retryable: boolean;
+  /** 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
+ * every richer attempt record (e.g. `FallbackAttempt`) extends, rather
+ * than duplicates.
+ */
+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 {
+  status?: number;
+  issues?: unknown;
+  cause?: unknown;
+  retryAfterMs?: number;
+  /** Stable discriminator within `type`. Absent on errors predating it. */
+  code?: LLMErrorCode;
+  /** Every attempt made before this error was thrown, in order. Absent when nothing was retried. */
+  attempts?: RetryAttempt[];
+}
 declare class LLMError extends Error {
   type: LLMErrorType;
-  status?: number | undefined;
-  issues?: unknown | undefined;
-  cause?: unknown | undefined;
-  retryAfterMs?: number | undefined;
+  status?: number;
+  issues?: unknown;
+  cause?: unknown;
+  retryAfterMs?: number;
   /** Stable discriminator within `type`. Absent on errors predating it. */
-  code?: LLMErrorCode | undefined;
-  constructor(message: string, type: LLMErrorType, status?: number | undefined, issues?: unknown | undefined, cause?: unknown | undefined, retryAfterMs?: number | undefined, /** Stable discriminator within `type`. Absent on errors predating it. */
-  code?: LLMErrorCode | undefined);
-  /** Every tool contract failure in one response, when there is more than one. */
-  toolIssues?: ToolIssue[];
+  code?: LLMErrorCode;
+  /** Every attempt made before this error was thrown, in order. Absent when nothing was retried. */
+  attempts?: RetryAttempt[];
+  constructor(message: string, type: LLMErrorType, options?: LLMErrorOptions);
+  /**
+   * Computed purely from `type`/`code`, independent of any specific call's
+   * `nonRetryableStatus` list. False for `parse`/`validation`/
+   * `invalid_params`/`aborted` types (the caller's own input, the model's
+   * own response, or intentional cancellation, none of which are the
+   * provider being unhealthy), the tool contract codes, and the local
+   * rate limit codes. Subclasses (see `FallbackExhaustedError`) may
+   * override this when `type` alone carries no retry signal.
+   */
+  get retryable(): boolean;
+  /**
+   * Copies this error's fields into an {@link LLMErrorSnapshot}, for
+   * recording as a `RetryAttempt`/`FallbackAttempt`. `retryable` is
+   * captured here since a snapshot has no getter of its own. `cause` is
+   * not copied, see `LLMErrorSnapshot`'s own doc. `issues` and every
+   * nested `attempts` entry's own `issues` go through `safeAttempts`,
+   * since a schema validation failure's `issues` is a caller supplied
+   * value, not controlled by VernLLM, and `attempts` is itself a public
+   * constructor option a caller can hand build.
+   */
+  toSnapshot(): LLMErrorSnapshot;
+  /**
+   * Controls what `JSON.stringify(err)` produces. Omits `cause` for the
+   * same reason `toSnapshot()` does: `cause` is `unknown` and never
+   * validated by VernLLM, and some SDK errors carry circular structures
+   * `JSON.stringify` cannot serialize at all. Read `err.cause` directly
+   * instead. `issues`, including every nested `attempts` entry's own
+   * `issues`, goes through `safeAttempts` for the same reason: a schema
+   * validation failure's `issues` is caller supplied and not guaranteed
+   * circular free. Also includes `message` and `retryable`, which a
+   * plain property walk would otherwise miss: `message` is
+   * non-enumerable on `Error`, and `retryable` is a getter, not an own
+   * property.
+   */
+  toJSON(): Record<string, unknown>;
 }
 declare function isLLMError(err: unknown): err is LLMError;
-
-//#endregion
+/**
+ * Narrows `err.issues` to the exact shape {@link LLMErrorIssuesByCode} maps
+ * `code` to, for any code listed there. `code` stays the only discriminator
+ * VernLLM uses; this just gives that existing check a typed return instead
+ * of requiring a manual cast of `issues`:
+ *
+ * ```ts
+ * if (isLLMError(err) && hasIssues(err, 'duplicate_tool_names')) {
+ *   console.log(err.issues.names); // string[], no cast needed
+ * }
+ * ```
+ */
+declare function hasIssues<C extends keyof LLMErrorIssuesByCode>(err: LLMError, code: C): err is LLMError & {
+  code: C;
+  issues: LLMErrorIssuesByCode[C];
+}; //#endregion
 //#region src/types/cache.d.ts
+
 //# sourceMappingURL=errors.d.ts.map
 interface CacheAdapter<T = unknown> {
   get(key: string): Promise<{
@@ -172,8 +303,102 @@ declare class TieredCacheAdapter<T = unknown> implements CacheAdapter<T> {
 }
 
 //#endregion
-//#region src/rateLimit.d.ts
+//#region src/circuitBreaker.d.ts
 //# sourceMappingURL=cache.d.ts.map
+interface CircuitBreakerOptions {
+  /** Consecutive failures before the circuit opens, default 5 */
+  threshold?: number;
+  /** How long the circuit stays open before allowing a trial request, in ms. Default 30000 */
+  cooldownMs?: number;
+  /**
+   * Called after every real state change, never for a no-op transition
+   * (e.g. open to open). `model` is the resolved model of whichever call
+   * triggered this specific transition (the `model` passed to whichever
+   * of `assertClosed`/`recordSuccess`/`recordFailure` caused it).
+   *
+   * With `isolateByModel` off (the default), this is a label only: the
+   * breaker still counts failures across every model together, so a
+   * threshold crossing can be the sum of several different models'
+   * failures even though only the triggering call's `model` is reported
+   * here. With `isolateByModel` on, it's exact: each model has its own
+   * counter, so the transition really was caused solely by that model.
+   */
+  onStateChange?: (from: CircuitState, to: CircuitState, consecutiveFailures: number, model?: string) => void;
+  /**
+   * Track a separate circuit per resolved model instead of one shared
+   * circuit for the whole instance. A failure on one model then never
+   * opens another model's circuit, at the cost of slower detection for
+   * an outage spread across many distinct models (each model's counter
+   * must independently cross `threshold`). Default false: one shared
+   * circuit, matching every version before this option existed.
+   *
+   * A call that omits `model` (only possible calling `CircuitBreaker`
+   * directly, `VernLLM` always passes one) falls into one shared bucket
+   * alongside every other call that also omits it.
+   */
+  isolateByModel?: boolean;
+}
+type CircuitState = 'closed' | 'open' | 'half-open';
+/**
+ * Per retry VernLLM-instance circuit breaker. Tracks consecutive failures across
+ * calls. Once the threshold is hit, short-circuits new calls with an
+ * LLMError('circuit_open') instead of hitting the provider, until the
+ * cooldown elapses and a single trial call is allowed through
+ */
+declare class CircuitBreaker {
+  private readonly threshold;
+  private readonly cooldownMs;
+  private readonly onStateChange?;
+  /** Whether this breaker tracks failures per model instead of one shared circuit. Read by `CallExecutor`/`VernLLM` to report per-target in `getCircuitStates`. */
+  readonly isolateByModel: boolean;
+  private readonly sharedBucket;
+  private readonly bucketsByModel;
+  constructor(options?: CircuitBreakerOptions);
+  /** Returns the bucket for a model if one already exists, without allocating. */
+  private lookupBucket;
+  /** Creates and stores a bucket for a model when the first mutation needs one. */
+  private ensureBucketFor;
+  /** Every state mutation routes through here, so `onStateChange` fires exactly once per real change. */
+  private transition;
+  /**
+   * Throws if the circuit is open and the cooldown hasn't elapsed, or if
+   * the circuit is half-open and a trial call is already in flight.
+   * Otherwise, if the circuit just became eligible for a trial (cooldown
+   * elapsed, or half-open with no trial currently running), this call
+   * becomes that trial
+   */
+  assertClosed(model?: string): void;
+  recordSuccess(model?: string): void;
+  recordFailure(model?: string): void;
+  /**
+   * With `isolateByModel` off (the default), `model` is ignored and the
+   * one shared circuit's state is returned, unchanged from every version
+   * before this option existed. With `isolateByModel` on, returns that
+   * model's own state, `'closed'` for a model never seen yet, same as a
+   * fresh breaker.
+   */
+  getState(model?: string): CircuitState;
+  /**
+   * Manually opens the circuit, as if `threshold` consecutive failures had
+   * just happened, e.g. to pull a provider out of rotation ahead of known
+   * maintenance. Resets the cooldown window from now, same as a real
+   * threshold-crossing failure would, and clears any in-flight half-open
+   * trial since it no longer applies once the circuit is (re)opened.
+   */
+  open(model?: string): void;
+  /**
+   * Manually closes the circuit and resets its failure count, e.g. once a
+   * provider is confirmed healthy again without waiting out the cooldown.
+   * Mirrors `recordSuccess`'s bookkeeping (including dropping the
+   * per-model bucket under `isolateByModel`, once idle) but without
+   * requiring an actual successful call first.
+   */
+  close(model?: string): void;
+}
+
+//#endregion
+//#region src/rateLimit.d.ts
+//# sourceMappingURL=circuitBreaker.d.ts.map
 /** The request shape sent to `LLMClient['chat']['completions']['create']`, used for token estimation. */
 type WireRequest = Parameters<LLMClient['chat']['completions']['create']>[0];
 /** Which configured bucket is currently blocking a call. */
@@ -305,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;
@@ -331,16 +558,27 @@ interface TargetCircuitState {
   /** Position in the chain: `0` for the primary, `1`+ for fallback targets. */
   index: number;
   isFallback: boolean;
+  /** Whether this target tracks failures per model. `false` means `model` on `getCircuitStates` had no effect on this entry. */
+  isolateByModel: boolean;
   /** `undefined` if that target has no circuit breaker configured. */
   state: CircuitState | undefined;
 }
-/** One target's failure, recorded on the way to either the next target or `FallbackExhaustedError`. */
-interface FallbackAttempt {
-  /** `-1` for the primary target. */
-  index: number;
+/** Which target/model `VernLLM.getCircuitState`, `openCircuit`, and `closeCircuit` act on. */
+interface CircuitTarget {
+  /** Which target to act on. `0` is the primary, `1`+ are fallbacks. Defaults to `0`. */
+  index?: number;
+  /** Which model bucket to act on, if the resolved target isolates by model. */
+  model?: string;
+}
+/**
+ * One target's failure, recorded on the way to either the next target or
+ * `FallbackExhaustedError`. Extends `RetryAttempt`: `index` is `-1` for
+ * the primary target here (rather than a plain retry count), and
+ * `provider`/`model` identify which target failed.
+ */
+interface FallbackAttempt extends RetryAttempt {
   provider: string;
   model: string;
-  error: LLMError;
 }
 /**
  * Decides what happens after a target's own retries are exhausted or
@@ -368,7 +606,16 @@ declare const defaultFallbackOn: FallbackOn;
 declare class FallbackExhaustedError extends LLMError {
   readonly attempts: FallbackAttempt[];
   constructor(attempts: FallbackAttempt[]);
+  /**
+   * `type: 'fallback_exhausted'` by itself says nothing about whether
+   * retrying could help; the reason the last target failed does. Defers to
+   * that attempt's own `retryable` instead of anything about this class's
+   * own type.
+   */
+  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;
 
 //#endregion
 //#region src/types/schema.d.ts
@@ -505,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;
   /**
@@ -537,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`.
  *
@@ -550,7 +818,7 @@ type ConversationTurn = {
   content: string;
 } | {
   role: 'assistant';
-  content?: string;
+  content?: AssistantContent;
   toolCalls?: ToolCall[];
 } | {
   role: 'tool';
@@ -607,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.
    */
@@ -619,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. */
@@ -677,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
@@ -691,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;
@@ -698,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'>;
@@ -731,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
@@ -759,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>;
@@ -800,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`
@@ -822,6 +1154,9 @@ type WireStreamChunk = {
     prompt_tokens?: number;
     completion_tokens?: number;
     total_tokens?: number;
+    completion_tokens_details?: {
+      reasoning_tokens?: number;
+    };
   };
 } | {
   /**
@@ -857,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
@@ -905,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: {
@@ -924,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';
@@ -953,6 +1334,9 @@ interface LLMClient {
           prompt_tokens?: number;
           completion_tokens?: number;
           total_tokens?: number;
+          completion_tokens_details?: {
+            reasoning_tokens?: number;
+          };
         };
       }>;
       /**
@@ -1086,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
@@ -1177,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
@@ -1239,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
@@ -1264,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
@@ -1313,31 +1723,87 @@ 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 model With `circuitBreaker.isolateByModel` on, returns that
-   * model's own circuit state instead of the shared one. Ignored
-   * otherwise. Omit for the shared circuit (the default) or, under
-   * isolation, the state of calls that didn't resolve a model.
-   * @returns The current circuit breaker state (`'closed' | 'open' |
-   * 'half-open'`), or undefined if no circuit breaker was configured.
-   */
-  getCircuitState(model?: string): CircuitState | undefined;
-  /**
-   * @param model With `circuitBreaker.isolateByModel` on, returns each
-   * target's circuit state for that model instead of its shared state.
-   * Ignored otherwise. Omit for the shared circuit (the default) or, under
-   * isolation, the state of calls that didn't resolve a model.
-   * @returns The current circuit state for every target in declaration
-   * order, including the primary and all fallback targets. Each entry
-   * includes the target's provider name, chain index, whether it is a
-   * fallback, and its circuit state, or undefined if that target has no
-   * circuit breaker configured.
+   * @param target.index Which target to read. Defaults to the primary.
+   * @param target.model Which model bucket to read, if the target isolates by model.
+   * @returns The breaker state, or `undefined` if that target has no breaker.
+   * @throws {RangeError} If `target.index` names no target. Lets a real
+   * target with no breaker (`undefined`) stay distinguishable from a
+   * target that doesn't exist.
+   */
+  getCircuitState(target?: CircuitTarget): CircuitState | undefined;
+  /**
+   * @param model Which model bucket to read, for targets that isolate by model.
+   * @returns Every target's state, in chain order.
    */
   getCircuitStates(model?: string): TargetCircuitState[];
+  /**
+   * Manually opens a target's breaker, e.g. to pull a provider out of
+   * rotation ahead of known maintenance instead of waiting for it to fail.
+   *
+   * @param target.index Which target to open. Defaults to the primary.
+   * @param target.model Which model bucket to open, if the target isolates by model.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  openCircuit(target?: CircuitTarget): void;
+  /**
+   * Manually closes a target's breaker, e.g. once a provider is confirmed
+   * healthy again without waiting out the cooldown.
+   *
+   * @param target.index Which target to close. Defaults to the primary.
+   * @param target.model Which model bucket to close, if the target isolates by model.
+   * @throws {RangeError} If `target.index` names no target.
+   */
+  closeCircuit(target?: CircuitTarget): void;
+  /** Resolves a target index so every circuit-breaker method agrees on what counts as valid. */
+  private resolveExecutor;
+  /** 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
@@ -1394,9 +1860,10 @@ type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
 //#region src/adapters/internal/nativeStructuredOutput.d.ts
 /**
  * Validates an `ImageBlock.mimeType` against the shared supported set.
- * Throws a non-retryable `LLMError('validation')`, since an unsupported
- * mimeType is a permanent failure, retrying the same input can't fix it,
- * the same way a schema-validation or JSON-parse failure isn't retried.
+ * Throws a non-retryable `LLMError('invalid_params')`, since an unsupported
+ * mimeType is a bug in the caller's own input, deterministic before any
+ * request is built, the same class of failure as every other check in
+ * `RequestBuilder`.
  */
 
 /**
@@ -1421,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';
@@ -1493,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;
@@ -1511,6 +2024,9 @@ interface AnthropicClient {
       usage?: {
         input_tokens?: number;
         output_tokens?: number;
+        output_tokens_details?: {
+          thinking_tokens?: number;
+        } | null;
       };
     }>;
   };
@@ -1529,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`
@@ -1552,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;
 } | {
@@ -1573,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[];
@@ -1621,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<{
@@ -1633,8 +2204,8 @@ interface GeminiClient {
         parts?: Array<{
           text?: string;
           functionCall?: {
-            name: string;
-            args: unknown;
+            name?: string;
+            args?: unknown;
           };
         }>;
       };
@@ -1643,6 +2214,7 @@ interface GeminiClient {
       promptTokenCount?: number;
       candidatesTokenCount?: number;
       totalTokenCount?: number;
+      thoughtsTokenCount?: number;
     };
   }>;
   /**
@@ -1653,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;
           };
         }>;
       };
@@ -1669,6 +2241,7 @@ interface GeminiClient {
       promptTokenCount?: number;
       candidatesTokenCount?: number;
       totalTokenCount?: number;
+      thoughtsTokenCount?: number;
     };
   }>>;
 }
@@ -1679,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
@@ -1701,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
@@ -1801,7 +2403,7 @@ interface BedrockConverseClient {
      * included). There is no `strict` field here, unlike `toolSpec`.
      */
     outputConfig?: {
-      textFormat: {
+      textFormat?: {
         type: 'json_schema';
         structure: {
           jsonSchema: {
@@ -1811,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<{
@@ -1949,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`
@@ -1958,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
@@ -1979,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`.
@@ -2001,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
@@ -2212,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;
 /**
@@ -2323,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, ConsoleLogger, ContentBlock, ContentResult, ConversationTurn, FallbackAttempt, FallbackExhaustedError, FallbackOn, FallbackTarget, FetchAdapterConfig, GeminiClient, ImageBlock, InMemoryCacheAdapter, JsonSchemaSpec, LLMClient, LLMError, LLMErrorCode, LLMErrorType, Logger, NormalizedCacheAdapter, OnEvent, OnUsage, RateLimitAcquireResult, RateLimitOptions, RateLimitReason, RateLimiter, RefundUsage, ReserveUsage, SSE_PING, SchemaLike, StreamCallResult, StreamChunk, StreamEnabledCallParams, TargetCircuitState, TextBlock, TieredCacheAdapter, TokenUsage, ToolCall, ToolCallResult, ToolChoice, ToolDefinition, ToolEnabledCallParams, ToolIssue, ToolResult, ToolsDisabledCallParams, 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, 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