eve 0.71.3 → 0.72.0

package/dist/src/compiled/@ai-sdk/provider-utils/index.d.ts

@@ -1,12 +1,11 @@
-import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4ResponseMetadata, LanguageModelV4Usage, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, JSONSchema7, JSONParseError, TypeValidationError, APICallError, AISDKError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, Experimental_BatchV4Status, JSONObject, LanguageModelV4FilePart, LanguageModelV4StreamPart, SharedV4ProviderMetadata, Experimental_TranscriptionModelV4StreamPart, TypeValidationContext } from '#compiled/@ai-sdk/provider/index.js';
-export { getErrorMessage } from '#compiled/@ai-sdk/provider/index.js';
-import { StandardSchemaV1, StandardJSONSchemaV1 } from '#compiled/@standard-schema/spec/index.js';
-export * from '#compiled/@standard-schema/spec/index.js';
-import * as z3 from '#compiled/zod/index.js';
-import { $ZodType } from 'zod/v4/core';
-export { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '#compiled/@workflow/serde/index.js';
-export { EventSourceMessage, EventSourceParserStream } from '#compiled/eventsource-parser/stream/index.js';
-
+import { AISDKError, APICallError, Experimental_BatchV4Status, Experimental_TranscriptionModelV4StreamPart, ImageModelV4File, JSONObject, JSONParseError, JSONSchema7, JSONValue, LanguageModelV4CallOptions, LanguageModelV4FilePart, LanguageModelV4FunctionTool, LanguageModelV4Prompt, LanguageModelV4ProviderTool, LanguageModelV4ResponseMetadata, LanguageModelV4StreamPart, LanguageModelV4Usage, SharedV4FileDataReference, SharedV4FileDataText, SharedV4FileDataUrl, SharedV4ProviderMetadata, SharedV4ProviderOptions, SharedV4ProviderReference, SharedV4Warning, TypeValidationContext, TypeValidationError, getErrorMessage } from "#compiled/@ai-sdk/provider/index.js";
+import { $ZodType } from "zod/v4/core";
+import { EventSourceMessage, EventSourceParserStream } from "#compiled/eventsource-parser/stream/index.js";
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "#compiled/@workflow/serde/index.js";
+import { StandardJSONSchemaV1, StandardSchemaV1 } from "#compiled/@standard-schema/spec/index.js";
+import * as z3 from "#compiled/zod/index.js";
+export type * from "#compiled/@standard-schema/spec/index.js";
+//#region src/as-array.d.ts
 /**
  * A value that can be provided either as a single item, an array of items,
  * or be left undefined.
@@ -15,36 +14,38 @@ type Arrayable<T> = T | T[] | undefined;
 /**
  * Normalizes a possibly undefined or non-array value into an array.
  */
-declare function asArray<T>(value: Arrayable<T>): T[];
-
-declare function combineHeaders(...headers: Array<Record<string, string | undefined> | undefined>): Record<string, string | undefined>;
-
+export declare function asArray<T>(value: Arrayable<T>): T[];
+//#endregion
+//#region src/combine-headers.d.ts
+export declare function combineHeaders(...headers: Array<Record<string, string | undefined> | undefined>): Record<string, string | undefined>;
+//#endregion
+//#region src/websocket.d.ts
 type WebSocketLike = {
-    readyState: number;
-    /** Bytes queued by `send` but not yet transmitted (native + `ws`). */
-    readonly bufferedAmount?: number;
-    send(data: string | Uint8Array | ArrayBuffer): void;
-    close(code?: number, reason?: string): void;
-    onopen: ((event: unknown) => void) | null;
-    onmessage: ((event: {
-        data: unknown;
-    }) => void) | null;
-    onerror: ((event: unknown) => void) | null;
-    onclose: ((event: unknown) => void) | null;
+  readyState: number;
+  /** Bytes queued by `send` but not yet transmitted (native + `ws`). */
+  readonly bufferedAmount?: number;
+  send(data: string | Uint8Array | ArrayBuffer): void;
+  close(code?: number, reason?: string): void;
+  onopen: ((event: unknown) => void) | null;
+  onmessage: ((event: {
+    data: unknown;
+  }) => void) | null;
+  onerror: ((event: unknown) => void) | null;
+  onclose: ((event: unknown) => void) | null;
 };
 type WebSocketConstructor = new (url: string | URL, protocols?: string | string[], options?: {
-    headers?: Record<string, string | undefined>;
+  headers?: Record<string, string | undefined>;
 }) => WebSocketLike;
-declare function getWebSocketConstructor(webSocket: WebSocketConstructor | undefined): WebSocketConstructor;
+export declare function getWebSocketConstructor(webSocket: WebSocketConstructor | undefined): WebSocketConstructor;
 /**
  * Converts an http(s) URL to the corresponding ws(s) URL.
  */
-declare function toWebSocketUrl(url: string | URL): URL;
+export declare function toWebSocketUrl(url: string | URL): URL;
 /**
  * Reads WebSocket message data as text, handling string, binary,
  * and Blob payloads.
  */
-declare function readWebSocketMessageText(data: unknown): Promise<string>;
+export declare function readWebSocketMessageText(data: unknown): Promise<string>;
 /**
  * Waits until the socket's send buffer drains below `highWaterMark` bytes.
  * No-op for implementations that do not expose `bufferedAmount`. There is no
@@ -52,20 +53,21 @@ declare function readWebSocketMessageText(data: unknown): Promise<string>;
  * longer open or the signal aborts — `bufferedAmount` never drains on a
  * closed socket, so waiting on would poll forever.
  */
-declare function waitForWebSocketBufferDrain(socket: WebSocketLike, { highWaterMark, pollIntervalMs, abortSignal, }?: {
-    highWaterMark?: number;
-    pollIntervalMs?: number;
-    abortSignal?: AbortSignal;
+export declare function waitForWebSocketBufferDrain(socket: WebSocketLike, { highWaterMark, pollIntervalMs, abortSignal }?: {
+  highWaterMark?: number;
+  pollIntervalMs?: number;
+  abortSignal?: AbortSignal;
 }): Promise<void>;
-
+//#endregion
+//#region src/connect-to-websocket.d.ts
 interface WebSocketConnection {
-    /** Undefined when the constructor threw or the signal was already aborted. */
-    socket: WebSocketLike | undefined;
-    /**
-     * Unregisters the abort listener and closes the socket. Never throws.
-     * Handlers stay attached; callers guard their own terminal state.
-     */
-    close: (code?: number) => void;
+  /** Undefined when the constructor threw or the signal was already aborted. */
+  socket: WebSocketLike | undefined;
+  /**
+   * Unregisters the abort listener and closes the socket. Never throws.
+   * Handlers stay attached; callers guard their own terminal state.
+   */
+  close: (code?: number) => void;
 }
 /**
  * Opens a WebSocket for a provider model, owning the transport-generic layer
@@ -73,30 +75,31 @@ interface WebSocketConnection {
  * abort wiring, and message decoding. Callers own the URL, the auth channel
  * (subprotocols vs headers), and the wire protocol.
  */
-declare function connectToWebSocket({ url, protocols, headers, webSocket, abortSignal, onOpen, onMessageText, onProcessingError, onSocketError, onClose, onAbort, }: {
-    url: string | URL;
-    protocols?: string | string[];
-    headers?: Record<string, string | undefined>;
-    webSocket?: WebSocketConstructor;
-    abortSignal?: AbortSignal;
-    onOpen?: (socket: WebSocketLike) => void;
-    /** One decoded message. Throws and rejections go to `onProcessingError`. */
-    onMessageText: (text: string) => void | PromiseLike<void>;
-    /** Constructor throws and message decoding/processing failures. */
-    onProcessingError: (error: unknown) => void;
-    onSocketError?: () => void;
-    /**
-     * Receives the close code and reason when the transport provides them
-     * (native `CloseEvent` / `ws` close event).
-     */
-    onClose?: (info: {
-        code?: number;
-        reason?: string;
-    }) => void;
-    /** Also called (without opening a socket) when the signal is already aborted. */
-    onAbort?: (reason: unknown) => void;
+export declare function connectToWebSocket({ url, protocols, headers, webSocket, abortSignal, onOpen, onMessageText, onProcessingError, onSocketError, onClose, onAbort }: {
+  url: string | URL;
+  protocols?: string | string[];
+  headers?: Record<string, string | undefined>;
+  webSocket?: WebSocketConstructor;
+  abortSignal?: AbortSignal;
+  onOpen?: (socket: WebSocketLike) => void;
+  /** One decoded message. Throws and rejections go to `onProcessingError`. */
+  onMessageText: (text: string) => void | PromiseLike<void>;
+  /** Constructor throws and message decoding/processing failures. */
+  onProcessingError: (error: unknown) => void;
+  onSocketError?: () => void;
+  /**
+   * Receives the close code and reason when the transport provides them
+   * (native `CloseEvent` / `ws` close event).
+   */
+  onClose?: (info: {
+    code?: number;
+    reason?: string;
+  }) => void;
+  /** Also called (without opening a socket) when the signal is already aborted. */
+  onAbort?: (reason: unknown) => void;
 }): WebSocketConnection;
-
+//#endregion
+//#region src/convert-async-iterator-to-readable-stream.d.ts
 /**
  * Converts an AsyncIterator to a ReadableStream.
  *
@@ -104,13 +107,15 @@ declare function connectToWebSocket({ url, protocols, headers, webSocket, abortS
  * @param { <T>} iterator - The AsyncIterator to convert.
  * @returns {ReadableStream<T>} - A ReadableStream that provides the same data as the AsyncIterator.
  */
-declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
-
+export declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
+//#endregion
+//#region src/types/data-content.d.ts
 /**
  * Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
  */
 type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
-
+//#endregion
+//#region src/types/file-data.d.ts
 /**
  * File data variant containing raw bytes (`Uint8Array`, `ArrayBuffer`, or
  * `Buffer`) or a base64-encoded string.
@@ -118,8 +123,8 @@ type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
  * This is slightly more permissive than `SharedV4FileDataData`.
  */
 interface FileDataData {
-    type: 'data';
-    data: DataContent;
+  type: 'data';
+  data: DataContent;
 }
 /**
  * File data variant containing a URL that points to the file.
@@ -144,7 +149,8 @@ type FileDataText = SharedV4FileDataText;
  * - `{ type: 'text', text }`: inline text content (e.g. an inline text document).
  */
 type FileData = FileDataData | FileDataUrl | FileDataReference | FileDataText;
-
+//#endregion
+//#region src/types/provider-options.d.ts
 /**
  * Additional provider-specific options.
  *
@@ -152,7 +158,8 @@ type FileData = FileDataData | FileDataUrl | FileDataReference | FileDataText;
  * provider-specific functionality that can be fully encapsulated in the provider.
  */
 type ProviderOptions = SharedV4ProviderOptions;
-
+//#endregion
+//#region src/types/provider-reference.d.ts
 /**
  * A mapping of provider names to provider-specific file identifiers.
  *
@@ -161,22 +168,23 @@ type ProviderOptions = SharedV4ProviderOptions;
  * identifier for the same logical file.
  */
 type ProviderReference = SharedV4ProviderReference;
-
+//#endregion
+//#region src/types/content-part.d.ts
 /**
  * Text content part of a prompt. It contains a string of text.
  */
 interface TextPart {
-    type: 'text';
-    /**
-     * The text content.
-     */
-    text: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  type: 'text';
+  /**
+   * The text content.
+   */
+  text: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 }
 /**
  * Image content part of a prompt. It contains an image.
@@ -185,48 +193,260 @@ interface TextPart {
  * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
  */
 interface ImagePart {
-    type: 'image';
-    /**
-     * Image data. Can either be:
-     *
-     * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
-     * - URL: a URL that points to the image
-     * - ProviderReference: a provider reference from `uploadFile`
-     */
-    image: DataContent | URL | ProviderReference;
-    /**
-     * Optional IANA media type of the image.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-     */
-    mediaType?: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  type: 'image';
+  /**
+   * Image data. Can either be:
+   *
+   * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+   * - URL: a URL that points to the image
+   * - ProviderReference: a provider reference from `uploadFile`
+   */
+  image: DataContent | URL | ProviderReference;
+  /**
+   * Optional IANA media type of the image.
+   *
+   * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+   */
+  mediaType?: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 }
 /**
  * File content part of a prompt. It contains a file.
  */
 interface FilePart {
+  type: 'file';
+  /**
+   * File data. Either a tagged shape or a bare shorthand:
+   *
+   * - `{ type: 'data', data }` or bare `DataContent`: raw bytes
+   *   (base64 string, Uint8Array, ArrayBuffer, Buffer)
+   * - `{ type: 'url', url }` or bare `URL`: a URL that points to the file
+   * - `{ type: 'reference', reference }` or bare `ProviderReference`:
+   *   a provider reference from `uploadFile`
+   * - `{ type: 'text', text }`: inline text content (tagged only)
+   */
+  data: FileData | DataContent | URL | ProviderReference;
+  /**
+   * Optional filename of the file.
+   */
+  filename?: string;
+  /**
+   * Either a full IANA media type (`type/subtype`, e.g. `image/png`) or just
+   * the top-level IANA segment (e.g. `image`, `audio`, `video`, `text`).
+   *
+   * `*`-subtype wildcards (e.g. `image/*`) are normalized as equivalent to the
+   * top-level segment alone (e.g. `image`). Providers can use the helpers in
+   * `@ai-sdk/provider-utils` (`isFullMediaType`, `getTopLevelMediaType`,
+   * `detectMediaType`) to resolve the field according to their API
+   * requirements.
+   *
+   * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+   */
+  mediaType: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+/**
+ * Reasoning content part of a prompt. It contains a reasoning.
+ */
+interface ReasoningPart {
+  type: 'reasoning';
+  /**
+   * The reasoning text.
+   */
+  text: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+/**
+ * Custom content part of a prompt. It contains no standardized payload beyond
+ * provider-specific options.
+ */
+interface CustomPart {
+  type: 'custom';
+  /**
+   * The kind of custom content, in the format `{provider}.{provider-type}`.
+   */
+  kind: `${string}.${string}`;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+/**
+ * Reasoning file content part of a prompt. It contains a file generated as part of reasoning.
+ */
+interface ReasoningFilePart {
+  type: 'reasoning-file';
+  /**
+   * Reasoning file data.
+   *
+   * Reasoning files originate from a model's reasoning output and are always
+   * raw bytes or a fetchable URL. Unlike `FilePart.data`, the `reference` and
+   * `text` shapes are not supported here: provider references describe files
+   * uploaded by the user (not produced as model output), and reasoning text is
+   * carried by `ReasoningPart` rather than as a file.
+   *
+   * Either a tagged shape or a bare shorthand:
+   *
+   * - `{ type: 'data', data }` or bare `DataContent`: raw bytes
+   *   (base64 string, Uint8Array, ArrayBuffer, Buffer)
+   * - `{ type: 'url', url }` or bare `URL`: a URL that points to the file
+   */
+  data: FileDataData | FileDataUrl | DataContent | URL;
+  /**
+   * IANA media type of the file.
+   *
+   * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+   */
+  mediaType: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+/**
+ * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ */
+interface ToolCallPart {
+  type: 'tool-call';
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+  /**
+   * Name of the tool that is being called.
+   */
+  toolName: string;
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: unknown;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+  /**
+   * Whether the tool call was executed by the provider.
+   */
+  providerExecuted?: boolean;
+}
+/**
+ * Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
+ */
+interface ToolResultPart {
+  type: 'tool-result';
+  /**
+   * ID of the tool call that this result is associated with.
+   */
+  toolCallId: string;
+  /**
+   * Name of the tool that generated this result.
+   */
+  toolName: string;
+  /**
+   * Result of the tool call. This is a JSON-serializable object.
+   */
+  output: ToolResultOutput;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+}
+/**
+ * Output of a tool result.
+ */
+type ToolResultOutput = {
+  /**
+   * Text tool output that should be directly sent to the API.
+   */
+  type: 'text';
+  value: string;
+  /**
+   * Provider-specific options.
+   */
+  providerOptions?: ProviderOptions;
+} | {
+  type: 'json';
+  value: JSONValue;
+  /**
+   * Provider-specific options.
+   */
+  providerOptions?: ProviderOptions;
+} | {
+  /**
+   * Type when the user has denied the execution of the tool call.
+   */
+  type: 'execution-denied';
+  /**
+   * Optional reason for the execution denial.
+   */
+  reason?: string;
+  /**
+   * Provider-specific options.
+   */
+  providerOptions?: ProviderOptions;
+} | {
+  type: 'error-text';
+  value: string;
+  /**
+   * Provider-specific options.
+   */
+  providerOptions?: ProviderOptions;
+} | {
+  type: 'error-json';
+  value: JSONValue;
+  /**
+   * Provider-specific options.
+   */
+  providerOptions?: ProviderOptions;
+} | {
+  type: 'content';
+  value: Array<{
+    type: 'text';
+    /**
+     * Text content.
+     */
+    text: string;
+    /**
+     * Provider-specific options.
+     */
+    providerOptions?: ProviderOptions;
+  } | {
     type: 'file';
     /**
-     * File data. Either a tagged shape or a bare shorthand:
+     * File data as a tagged discriminated union:
      *
-     * - `{ type: 'data', data }` or bare `DataContent`: raw bytes
+     * - `{ type: 'data', data }`: raw bytes
      *   (base64 string, Uint8Array, ArrayBuffer, Buffer)
-     * - `{ type: 'url', url }` or bare `URL`: a URL that points to the file
-     * - `{ type: 'reference', reference }` or bare `ProviderReference`:
-     *   a provider reference from `uploadFile`
-     * - `{ type: 'text', text }`: inline text content (tagged only)
-     */
-    data: FileData | DataContent | URL | ProviderReference;
-    /**
-     * Optional filename of the file.
+     * - `{ type: 'url', url }`: a URL that points to the file
+     * - `{ type: 'reference', reference }`: a provider reference
+     *   from `uploadFile`
+     * - `{ type: 'text', text }`: inline text content (e.g. an inline
+     *   text document)
      */
-    filename?: string;
+    data: FileData;
     /**
      * Either a full IANA media type (`type/subtype`, e.g. `image/png`) or just
      * the top-level IANA segment (e.g. `image`, `audio`, `video`, `text`).
@@ -241,389 +461,178 @@ interface FilePart {
      */
     mediaType: string;
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Optional filename of the file.
+     */
+    filename?: string;
+    /**
+     * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-}
-/**
- * Reasoning content part of a prompt. It contains a reasoning.
- */
-interface ReasoningPart {
-    type: 'reasoning';
+  } | {
     /**
-     * The reasoning text.
+     * @deprecated Use 'file' with mediaType + tagged data instead:
+     * `{ type: 'file', mediaType, data: { type: 'data', data } }`.
      */
-    text: string;
+    type: 'file-data';
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Base-64 encoded media data.
      */
-    providerOptions?: ProviderOptions;
-}
-/**
- * Custom content part of a prompt. It contains no standardized payload beyond
- * provider-specific options.
- */
-interface CustomPart {
-    type: 'custom';
+    data: string;
     /**
-     * The kind of custom content, in the format `{provider}.{provider-type}`.
+     * IANA media type.
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    kind: `${string}.${string}`;
+    mediaType: string;
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Optional filename of the file.
+     */
+    filename?: string;
+    /**
+     * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-}
-/**
- * Reasoning file content part of a prompt. It contains a file generated as part of reasoning.
- */
-interface ReasoningFilePart {
-    type: 'reasoning-file';
+  } | {
     /**
-     * Reasoning file data.
-     *
-     * Reasoning files originate from a model's reasoning output and are always
-     * raw bytes or a fetchable URL. Unlike `FilePart.data`, the `reference` and
-     * `text` shapes are not supported here: provider references describe files
-     * uploaded by the user (not produced as model output), and reasoning text is
-     * carried by `ReasoningPart` rather than as a file.
-     *
-     * Either a tagged shape or a bare shorthand:
-     *
-     * - `{ type: 'data', data }` or bare `DataContent`: raw bytes
-     *   (base64 string, Uint8Array, ArrayBuffer, Buffer)
-     * - `{ type: 'url', url }` or bare `URL`: a URL that points to the file
+     * @deprecated Use 'file' with mediaType and tagged data instead:
+     * `{ type: 'file', mediaType, data: { type: 'url', url: new URL(url) } }`.
      */
-    data: FileDataData | FileDataUrl | DataContent | URL;
+    type: 'file-url';
     /**
-     * IANA media type of the file.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     * URL of the file.
      */
-    mediaType: string;
+    url: string;
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * IANA media type.
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    providerOptions?: ProviderOptions;
-}
-/**
- * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
- */
-interface ToolCallPart {
-    type: 'tool-call';
+    mediaType?: string;
     /**
-     * ID of the tool call. This ID is used to match the tool call with the tool result.
+     * Provider-specific options.
      */
-    toolCallId: string;
+    providerOptions?: ProviderOptions;
+  } | {
     /**
-     * Name of the tool that is being called.
+     * @deprecated Use 'file' with tagged data instead:
+     * `{ type: 'file', mediaType, data: { type: 'reference', reference } }`.
      */
-    toolName: string;
+    type: 'file-id';
     /**
-     * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+     * ID of the file.
+     *
+     * If you use multiple providers, you need to
+     * specify the provider specific ids using
+     * the Record option. The key is the provider
+     * name, e.g. 'openai' or 'anthropic'.
      */
-    input: unknown;
+    fileId: string | Record<string, string>;
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
+  } | {
     /**
-     * Whether the tool call was executed by the provider.
+     * @deprecated Use 'file' with tagged data instead:
+     * `{ type: 'file', mediaType, data: { type: 'reference', reference } }`.
      */
-    providerExecuted?: boolean;
-}
-/**
- * Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
- */
-interface ToolResultPart {
-    type: 'tool-result';
+    type: 'file-reference';
     /**
-     * ID of the tool call that this result is associated with.
+     * Provider-specific references for the file.
+     * The key is the provider name, e.g. 'openai' or 'anthropic'.
      */
-    toolCallId: string;
+    providerReference: ProviderReference;
     /**
-     * Name of the tool that generated this result.
+     * Provider-specific options.
      */
-    toolName: string;
+    providerOptions?: ProviderOptions;
+  } | {
     /**
-     * Result of the tool call. This is a JSON-serializable object.
+     * @deprecated Use 'file' with mediaType (e.g. 'image' or a specific
+     * `image/*` subtype) and tagged data instead:
+     * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
      */
-    output: ToolResultOutput;
+    type: 'image-data';
     /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
+     * Base-64 encoded image data.
      */
-    providerOptions?: ProviderOptions;
-}
-/**
- * Output of a tool result.
- */
-type ToolResultOutput = {
+    data: string;
     /**
-     * Text tool output that should be directly sent to the API.
+     * IANA media type.
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    type: 'text';
-    value: string;
+    mediaType: string;
     /**
      * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-} | {
-    type: 'json';
-    value: JSONValue;
+  } | {
+    /**
+     * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
+     * `image/*` subtype) and tagged data instead:
+     * `{ type: 'file', mediaType: 'image', data: { type: 'url', url: new URL(url) } }`.
+     */
+    type: 'image-url';
+    /**
+     * URL of the image.
+     */
+    url: string;
     /**
      * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-} | {
+  } | {
     /**
-     * Type when the user has denied the execution of the tool call.
+     * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
+     * `image/*` subtype) and tagged data instead:
+     * `{ type: 'file', mediaType: 'image', data: { type: 'reference', reference } }`.
      */
-    type: 'execution-denied';
+    type: 'image-file-id';
     /**
-     * Optional reason for the execution denial.
+     * Image that is referenced using a provider file id.
+     *
+     * If you use multiple providers, you need to
+     * specify the provider specific ids using
+     * the Record option. The key is the provider
+     * name, e.g. 'openai' or 'anthropic'.
      */
-    reason?: string;
+    fileId: string | Record<string, string>;
     /**
      * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-} | {
-    type: 'error-text';
-    value: string;
+  } | {
+    /**
+     * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
+     * `image/*` subtype) and tagged data instead:
+     * `{ type: 'file', mediaType: 'image', data: { type: 'reference', reference } }`.
+     */
+    type: 'image-file-reference';
+    /**
+     * Provider-specific references for the image file.
+     * The key is the provider name, e.g. 'openai' or 'anthropic'.
+     */
+    providerReference: ProviderReference;
     /**
      * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-} | {
-    type: 'error-json';
-    value: JSONValue;
+  } | {
+    /**
+     * Custom content part. This can be used to implement
+     * provider-specific content parts.
+     */
+    type: 'custom';
     /**
      * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
-} | {
-    type: 'content';
-    value: Array<{
-        type: 'text';
-        /**
-         * Text content.
-         */
-        text: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        type: 'file';
-        /**
-         * File data as a tagged discriminated union:
-         *
-         * - `{ type: 'data', data }`: raw bytes
-         *   (base64 string, Uint8Array, ArrayBuffer, Buffer)
-         * - `{ type: 'url', url }`: a URL that points to the file
-         * - `{ type: 'reference', reference }`: a provider reference
-         *   from `uploadFile`
-         * - `{ type: 'text', text }`: inline text content (e.g. an inline
-         *   text document)
-         */
-        data: FileData;
-        /**
-         * Either a full IANA media type (`type/subtype`, e.g. `image/png`) or just
-         * the top-level IANA segment (e.g. `image`, `audio`, `video`, `text`).
-         *
-         * `*`-subtype wildcards (e.g. `image/*`) are normalized as equivalent to the
-         * top-level segment alone (e.g. `image`). Providers can use the helpers in
-         * `@ai-sdk/provider-utils` (`isFullMediaType`, `getTopLevelMediaType`,
-         * `detectMediaType`) to resolve the field according to their API
-         * requirements.
-         *
-         * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-         */
-        mediaType: string;
-        /**
-         * Optional filename of the file.
-         */
-        filename?: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with mediaType + tagged data instead:
-         * `{ type: 'file', mediaType, data: { type: 'data', data } }`.
-         */
-        type: 'file-data';
-        /**
-         * Base-64 encoded media data.
-         */
-        data: string;
-        /**
-         * IANA media type.
-         * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-         */
-        mediaType: string;
-        /**
-         * Optional filename of the file.
-         */
-        filename?: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with mediaType and tagged data instead:
-         * `{ type: 'file', mediaType, data: { type: 'url', url: new URL(url) } }`.
-         */
-        type: 'file-url';
-        /**
-         * URL of the file.
-         */
-        url: string;
-        /**
-         * IANA media type.
-         * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-         */
-        mediaType?: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with tagged data instead:
-         * `{ type: 'file', mediaType, data: { type: 'reference', reference } }`.
-         */
-        type: 'file-id';
-        /**
-         * ID of the file.
-         *
-         * If you use multiple providers, you need to
-         * specify the provider specific ids using
-         * the Record option. The key is the provider
-         * name, e.g. 'openai' or 'anthropic'.
-         */
-        fileId: string | Record<string, string>;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with tagged data instead:
-         * `{ type: 'file', mediaType, data: { type: 'reference', reference } }`.
-         */
-        type: 'file-reference';
-        /**
-         * Provider-specific references for the file.
-         * The key is the provider name, e.g. 'openai' or 'anthropic'.
-         */
-        providerReference: ProviderReference;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with mediaType (e.g. 'image' or a specific
-         * `image/*` subtype) and tagged data instead:
-         * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
-         */
-        type: 'image-data';
-        /**
-         * Base-64 encoded image data.
-         */
-        data: string;
-        /**
-         * IANA media type.
-         * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-         */
-        mediaType: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
-         * `image/*` subtype) and tagged data instead:
-         * `{ type: 'file', mediaType: 'image', data: { type: 'url', url: new URL(url) } }`.
-         */
-        type: 'image-url';
-        /**
-         * URL of the image.
-         */
-        url: string;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
-         * `image/*` subtype) and tagged data instead:
-         * `{ type: 'file', mediaType: 'image', data: { type: 'reference', reference } }`.
-         */
-        type: 'image-file-id';
-        /**
-         * Image that is referenced using a provider file id.
-         *
-         * If you use multiple providers, you need to
-         * specify the provider specific ids using
-         * the Record option. The key is the provider
-         * name, e.g. 'openai' or 'anthropic'.
-         */
-        fileId: string | Record<string, string>;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * @deprecated Use 'file' with `mediaType: 'image'` (or a specific
-         * `image/*` subtype) and tagged data instead:
-         * `{ type: 'file', mediaType: 'image', data: { type: 'reference', reference } }`.
-         */
-        type: 'image-file-reference';
-        /**
-         * Provider-specific references for the image file.
-         * The key is the provider name, e.g. 'openai' or 'anthropic'.
-         */
-        providerReference: ProviderReference;
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    } | {
-        /**
-         * Custom content part. This can be used to implement
-         * provider-specific content parts.
-         */
-        type: 'custom';
-        /**
-         * Provider-specific options.
-         */
-        providerOptions?: ProviderOptions;
-    }>;
+  }>;
 };
-
+//#endregion
+//#region src/convert-inline-file-data-to-uint8-array.d.ts
 type InlineFileData = Extract<FilePart['data'], {
-    type: 'data';
+  type: 'data';
 } | {
-    type: 'text';
+  type: 'text';
 }>;
 /**
  * Converts inline file data (a tagged `data` or `text` shape) into raw bytes.
@@ -636,11 +645,12 @@ type InlineFileData = Extract<FilePart['data'], {
  * `{ type: 'stream' }` data is rejected: providers without streaming upload
  * support funnel here and surface a clear `UnsupportedFunctionalityError`.
  */
-declare function convertInlineFileDataToUint8Array(data: InlineFileData | {
-    type: 'stream';
-    stream: ReadableStream<Uint8Array>;
+export declare function convertInlineFileDataToUint8Array(data: InlineFileData | {
+  type: 'stream';
+  stream: ReadableStream<Uint8Array>;
 }): Uint8Array;
-
+//#endregion
+//#region src/convert-image-model-file-to-data-uri.d.ts
 /**
  * Convert an ImageModelV4File to a URL or data URI string.
  *
@@ -648,8 +658,21 @@ declare function convertInlineFileDataToUint8Array(data: InlineFileData | {
  * If the file is base64 data, it returns a data URI with the base64 data.
  * If the file is a Uint8Array, it converts it to base64 and returns a data URI.
  */
-declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
-
+export declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
+//#endregion
+//#region src/convert-json-response-tool-stream.d.ts
+/**
+ * Providers that cannot use native structured output for a request can use a
+ * JSON response tool instead. This utility converts that tool's streamed input
+ * into text events so the SDK can parse it as structured output.
+ *
+ * Conversational text is suppressed. Application tool calls pass through so the
+ * caller can execute them. A response containing only the JSON tool finishes
+ * with `stop`; a response containing application calls keeps its finish reason.
+ */
+export declare function convertJsonResponseToolStream(toolName: string): TransformStream<LanguageModelV4StreamPart, LanguageModelV4StreamPart>;
+//#endregion
+//#region src/convert-to-form-data.d.ts
 /**
  * Converts an input object to FormData for multipart/form-data requests.
  *
@@ -681,83 +704,88 @@ declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
  * });
  * ```
  */
-declare function convertToFormData<T extends Record<string, unknown>>(input: T, options?: {
-    useArrayBrackets?: boolean;
+export declare function convertToFormData<T extends Record<string, unknown>>(input: T, options?: {
+  useArrayBrackets?: boolean;
 }): FormData;
-
+//#endregion
+//#region src/create-language-model-response-metadata.d.ts
 /**
  * Converts common provider response fields into language model response
  * metadata.
  */
-declare function createLanguageModelResponseMetadata({ id, model, created, }: {
-    id?: string | null;
-    model?: string | null;
-    created?: number | null;
+export declare function createLanguageModelResponseMetadata({ id, model, created }: {
+  id?: string | null;
+  model?: string | null;
+  created?: number | null;
 }): LanguageModelV4ResponseMetadata;
-
+//#endregion
+//#region src/create-null-language-model-usage.d.ts
 /**
  * Creates an empty language model usage result for unavailable usage data.
  */
-declare function createNullLanguageModelUsage(): LanguageModelV4Usage;
-
+export declare function createNullLanguageModelUsage(): LanguageModelV4Usage;
+//#endregion
+//#region src/create-tool-name-mapping.d.ts
 /**
  * Interface for mapping between custom tool names and provider tool names.
  */
 interface ToolNameMapping {
-    /**
-     * Maps a custom tool name (used by the client) to the provider's tool name.
-     * If the custom tool name does not have a mapping, returns the input name.
-     *
-     * @param customToolName - The custom name of the tool defined by the client.
-     * @returns The corresponding provider tool name, or the input name if not mapped.
-     */
-    toProviderToolName: (customToolName: string) => string;
-    /**
-     * Maps a provider tool name to the custom tool name used by the client.
-     * If the provider tool name does not have a mapping, returns the input name.
-     *
-     * @param providerToolName - The name of the tool as understood by the provider.
-     * @returns The corresponding custom tool name, or the input name if not mapped.
-     */
-    toCustomToolName: (providerToolName: string) => string;
+  /**
+   * Maps a custom tool name (used by the client) to the provider's tool name.
+   * If the custom tool name does not have a mapping, returns the input name.
+   *
+   * @param customToolName - The custom name of the tool defined by the client.
+   * @returns The corresponding provider tool name, or the input name if not mapped.
+   */
+  toProviderToolName: (customToolName: string) => string;
+  /**
+   * Maps a provider tool name to the custom tool name used by the client.
+   * If the provider tool name does not have a mapping, returns the input name.
+   *
+   * @param providerToolName - The name of the tool as understood by the provider.
+   * @returns The corresponding custom tool name, or the input name if not mapped.
+   */
+  toCustomToolName: (providerToolName: string) => string;
 }
 /**
  * @param tools - Tools that were passed to the language model.
  * @param providerToolNames - Maps the provider tool ids to the provider tool names.
  */
-declare function createToolNameMapping({ tools, providerToolNames, }: {
-    /**
-     * Tools that were passed to the language model.
-     */
-    tools: Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool> | undefined;
-    /**
-     * Maps the provider tool ids to the provider tool names.
-     */
-    providerToolNames: Record<`${string}.${string}`, string>;
+export declare function createToolNameMapping({ tools, providerToolNames }: {
+  /**
+   * Tools that were passed to the language model.
+   */
+  tools: Array<LanguageModelV4FunctionTool | LanguageModelV4ProviderTool> | undefined;
+  /**
+   * Maps the provider tool ids to the provider tool names.
+   */
+  providerToolNames: Record<`${string}.${string}`, string>;
 }): ToolNameMapping;
-
+//#endregion
+//#region src/create-provider-stream-error.d.ts
 type ProviderStreamError = {
-    readonly message: string;
-    readonly type?: string;
-    readonly code?: string | number;
-    readonly statusCode?: number;
-    readonly isRetryable?: boolean;
-    readonly data: unknown;
+  readonly message: string;
+  readonly type?: string;
+  readonly code?: string | number;
+  readonly statusCode?: number;
+  readonly isRetryable?: boolean;
+  readonly data: unknown;
 };
 /**
  * Adds provider-owned status and retry metadata to a stream error payload
  * without requiring provider packages to depend on AI SDK Core.
  */
-declare function createProviderStreamError({ message, type, code, statusCode, isRetryable, data, }: {
-    message: string;
-    type?: string;
-    code?: string | number;
-    statusCode?: number;
-    isRetryable?: boolean;
-    data: unknown;
+export declare function createProviderStreamError({ message, type, code, statusCode, isRetryable, data }: {
+  message: string;
+  type?: string;
+  code?: string | number;
+  statusCode?: number;
+  isRetryable?: boolean;
+  data: unknown;
 }): ProviderStreamError;
-declare function isProviderStreamError(error: unknown): error is ProviderStreamError;
-
+export declare function isProviderStreamError(error: unknown): error is ProviderStreamError;
+//#endregion
+//#region src/delay.d.ts
 /**
  * Creates a Promise that resolves after a specified delay
  * @param delayInMs - The delay duration in milliseconds. If null or undefined, resolves immediately.
@@ -765,62 +793,65 @@ declare function isProviderStreamError(error: unknown): error is ProviderStreamE
  * @returns A Promise that resolves after the specified delay
  * @throws {DOMException} When the signal is aborted
  */
-declare function delay(delayInMs?: number | null, options?: {
-    abortSignal?: AbortSignal;
+export declare function delay(delayInMs?: number | null, options?: {
+  abortSignal?: AbortSignal;
 }): Promise<void>;
-
+//#endregion
+//#region src/delayed-promise.d.ts
 /**
  * Delayed promise. It is only constructed once the value is accessed.
  * This is useful to avoid unhandled promise rejections when the promise is created
  * but not accessed.
  */
-declare class DelayedPromise<T> {
-    private status;
-    private _promise;
-    private _resolve;
-    private _reject;
-    get promise(): Promise<T>;
-    resolve(value: T): void;
-    reject(error: unknown): void;
-    isResolved(): boolean;
-    isRejected(): boolean;
-    isPending(): boolean;
+export declare class DelayedPromise<T> {
+  private status;
+  private _promise;
+  private _resolve;
+  private _reject;
+  get promise(): Promise<T>;
+  resolve(value: T): void;
+  reject(error: unknown): void;
+  isResolved(): boolean;
+  isRejected(): boolean;
+  isPending(): boolean;
 }
-
+//#endregion
+//#region src/fetch-function.d.ts
 /**
  * Fetch function type (standardizes the version of fetch used).
  */
-type FetchFunction = typeof globalThis.fetch;
-
+export type FetchFunction = typeof globalThis.fetch;
+//#endregion
+//#region src/schema.d.ts
 /**
  * Used to mark schemas so we can support both Zod and custom schemas.
  */
 declare const schemaSymbol: unique symbol;
 type ValidationResult<OBJECT> = {
-    success: true;
-    value: OBJECT;
+  success: true;
+  value: OBJECT;
 } | {
-    success: false;
-    error: Error;
+  success: false;
+  error: Error;
 };
 type Schema<OBJECT = unknown> = {
-    /**
-     * Used to mark schemas so we can support both Zod and custom schemas.
-     */
-    [schemaSymbol]: true;
-    /**
-     * Schema type for inference.
-     */
-    _type: OBJECT;
-    /**
-     * Optional. Validates that the structure of a value matches this schema,
-     * and returns a typed version of the value if it does.
-     */
-    readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
-    /**
-     * The JSON Schema for the schema. It is passed to the providers.
-     */
-    readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
+  /**
+   * Used to mark schemas so we can support both Zod and custom schemas.
+   */
+  [schemaSymbol]: true;
+  /**
+   * Schema type for inference.
+   */
+  _type: OBJECT;
+  /**
+   * Optional. Validates that the structure of a value matches this schema,
+   * and returns a typed version of the value if it does.
+   */
+  readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+  /**
+   * The JSON Schema for the schema. It is passed to the providers.
+   */
+  readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
 };
 /**
  * Creates a schema with deferred creation.
@@ -830,13 +861,13 @@ type Schema<OBJECT = unknown> = {
  * @param createValidator A function that creates a schema.
  * @returns A function that returns a schema.
  */
-declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
+export declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
 type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
 type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | $ZodType<SCHEMA, any>;
 type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & {
-    readonly '~standard': StandardSchemaV1.Props<unknown, SCHEMA> & {
-        readonly jsonSchema?: StandardJSONSchemaV1.Converter;
-    };
+  readonly '~standard': StandardSchemaV1.Props<unknown, SCHEMA> & {
+    readonly jsonSchema?: StandardJSONSchemaV1.Converter;
+  };
 };
 type FlexibleSchema<SCHEMA = any> = Schema<SCHEMA> | LazySchema<SCHEMA> | ZodSchema<SCHEMA> | StandardSchema<SCHEMA>;
 type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extends StandardSchema<infer T> ? T : SCHEMA extends LazySchema<infer T> ? T : SCHEMA extends Schema<infer T> ? T : never;
@@ -846,29 +877,30 @@ type InferSchema<SCHEMA> = SCHEMA extends ZodSchema<infer T> ? T : SCHEMA extend
  * @param jsonSchema The JSON Schema for the schema.
  * @param options.validate Optional. A validation function for the schema.
  */
-declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7> | (() => JSONSchema7 | PromiseLike<JSONSchema7>), { validate, }?: {
-    validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+export declare function jsonSchema<OBJECT = unknown>(jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7> | (() => JSONSchema7 | PromiseLike<JSONSchema7>), { validate }?: {
+  validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
 }): Schema<OBJECT>;
-declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
-declare function zodSchema<OBJECT>(zodSchema: $ZodType<OBJECT, any> | z3.Schema<OBJECT, z3.ZodTypeDef, any>, options?: {
-    /**
-     * Enables support for references in the schema.
-     * This is required for recursive schemas, e.g. with `z.lazy`.
-     * However, not all language models and providers support such references.
-     * Defaults to `false`.
-     */
-    useReferences?: boolean;
+export declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
+export declare function zodSchema<OBJECT>(zodSchema: $ZodType<OBJECT, any> | z3.Schema<OBJECT, z3.ZodTypeDef, any>, options?: {
+  /**
+   * Enables support for references in the schema.
+   * This is required for recursive schemas, e.g. with `z.lazy`.
+   * However, not all language models and providers support such references.
+   * Defaults to `false`.
+   */
+  useReferences?: boolean;
 }): Schema<OBJECT>;
-
+//#endregion
+//#region src/parse-json.d.ts
 /**
  * Parses a JSON string into an unknown object.
  *
  * @param text - The JSON string to parse.
  * @returns {JSONValue} - The parsed JSON object.
  */
-declare function parseJSON(options: {
-    text: string;
-    schema?: undefined;
+export declare function parseJSON(options: {
+  text: string;
+  schema?: undefined;
 }): Promise<JSONValue>;
 /**
  * Parses a JSON string into a strongly-typed object using the provided schema.
@@ -878,18 +910,18 @@ declare function parseJSON(options: {
  * @param {Validator<T>} schema - The schema to use for parsing the JSON.
  * @returns {Promise<T>} - The parsed object.
  */
-declare function parseJSON<T>(options: {
-    text: string;
-    schema: FlexibleSchema<T>;
+export declare function parseJSON<T>(options: {
+  text: string;
+  schema: FlexibleSchema<T>;
 }): Promise<T>;
-type ParseResult<T> = {
-    success: true;
-    value: T;
-    rawValue: unknown;
+export type ParseResult<T> = {
+  success: true;
+  value: T;
+  rawValue: unknown;
 } | {
-    success: false;
-    error: JSONParseError | TypeValidationError;
-    rawValue: unknown;
+  success: false;
+  error: JSONParseError | TypeValidationError;
+  rawValue: unknown;
 };
 /**
  * Safely parses a JSON string and returns the result as an object of type `unknown`.
@@ -897,9 +929,9 @@ type ParseResult<T> = {
  * @param text - The JSON string to parse.
  * @returns {Promise<object>} Either an object with `success: true` and the parsed data, or an object with `success: false` and the error that occurred.
  */
-declare function safeParseJSON(options: {
-    text: string;
-    schema?: undefined;
+export declare function safeParseJSON(options: {
+  text: string;
+  schema?: undefined;
 }): Promise<ParseResult<JSONValue>>;
 /**
  * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
@@ -909,56 +941,59 @@ declare function safeParseJSON(options: {
  * @param {Validator<T>} schema - The schema to use for parsing the JSON.
  * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
  */
-declare function safeParseJSON<T>(options: {
-    text: string;
-    schema: FlexibleSchema<T>;
+export declare function safeParseJSON<T>(options: {
+  text: string;
+  schema: FlexibleSchema<T>;
 }): Promise<ParseResult<T>>;
-declare function isParsableJson(input: string): boolean;
-
-type ResponseHandler<RETURN_TYPE> = (options: {
-    url: string;
-    requestBodyValues: unknown;
-    response: Response;
+export declare function isParsableJson(input: string): boolean;
+//#endregion
+//#region src/response-handler.d.ts
+export type ResponseHandler<RETURN_TYPE> = (options: {
+  url: string;
+  requestBodyValues: unknown;
+  response: Response;
 }) => PromiseLike<{
-    value: RETURN_TYPE;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: RETURN_TYPE;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable, }: {
-    errorSchema: FlexibleSchema<T>;
-    errorToMessage: (error: T) => string;
-    isRetryable?: (response: Response, error?: T) => boolean;
+export declare const createJsonErrorResponseHandler: <T>({ errorSchema, errorToMessage, isRetryable }: {
+  errorSchema: FlexibleSchema<T>;
+  errorToMessage: (error: T) => string;
+  isRetryable?: (response: Response, error?: T) => boolean;
 }) => ResponseHandler<APICallError>;
-declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
-declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
-declare const createJsonLinesResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<AsyncGenerator<T>>;
-declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
+export declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
+export declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
+export declare const createJsonLinesResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<AsyncGenerator<T>>;
+export declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
 /**
  * Passes the response body through as a `ReadableStream<Uint8Array>` without
  * buffering it (unlike `createBinaryResponseHandler`). The consumer is
  * responsible for draining or cancelling the stream.
  */
-declare const createBinaryStreamResponseHandler: () => ResponseHandler<ReadableStream<Uint8Array>>;
-declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
-
+export declare const createBinaryStreamResponseHandler: () => ResponseHandler<ReadableStream<Uint8Array>>;
+export declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
+//#endregion
+//#region src/delete-from-api.d.ts
 /**
  * Sends a DELETE request. For URLs built from developer-configured endpoints
  * only — there is no untrusted-URL validation path (use `getFromApi` with
  * `validateUrl` for response-supplied URLs).
  */
-declare const deleteFromApi: <T>({ url, headers, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    failedResponseHandler: ResponseHandler<Error>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
+export declare const deleteFromApi: <T>({ url, headers, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-
+//#endregion
+//#region src/detect-media-type.d.ts
 /**
  * Detect the IANA media type of a file from its raw bytes or base64 string.
  *
@@ -969,9 +1004,9 @@ declare const deleteFromApi: <T>({ url, headers, failedResponseHandler, successf
  *   segment are considered. Returns `undefined` for unsupported segments
  *   (e.g. `"text"`) or when no signature matches.
  */
-declare function detectMediaType({ data, topLevelType, }: {
-    data: Uint8Array | string;
-    topLevelType?: string;
+export declare function detectMediaType({ data, topLevelType }: {
+  data: Uint8Array | string;
+  topLevelType?: string;
 }): string | undefined;
 /**
  * Returns the top-level segment of a media type (the portion before `/`).
@@ -984,7 +1019,7 @@ declare function detectMediaType({ data, topLevelType, }: {
  *   - `""` -> `""`
  *   - `"/"` -> `""`
  */
-declare function getTopLevelMediaType(mediaType: string): string;
+export declare function getTopLevelMediaType(mediaType: string): string;
 /**
  * Returns `true` only when the given media type has a non-empty, non-wildcard
  * subtype (i.e. matches the form `type/subtype`, and `subtype` is not `*`).
@@ -997,8 +1032,9 @@ declare function getTopLevelMediaType(mediaType: string): string;
  *   - `""` -> `false`
  *   - `"/"` -> `false`
  */
-declare function isFullMediaType(mediaType: string): boolean;
-
+export declare function isFullMediaType(mediaType: string): boolean;
+//#endregion
+//#region src/download-blob.d.ts
 /**
  * Download a file from a URL and return it as a Blob.
  *
@@ -1010,27 +1046,29 @@ declare function isFullMediaType(mediaType: string): boolean;
  *
  * @throws DownloadError if the download fails or exceeds maxBytes.
  */
-declare function downloadBlob(url: string, options?: {
-    maxBytes?: number;
-    abortSignal?: AbortSignal;
+export declare function downloadBlob(url: string, options?: {
+  maxBytes?: number;
+  abortSignal?: AbortSignal;
 }): Promise<Blob>;
-
+//#endregion
+//#region src/download-error.d.ts
 declare const symbol$1: unique symbol;
-declare class DownloadError extends AISDKError {
-    private readonly [symbol$1];
-    readonly url: string;
-    readonly statusCode?: number;
-    readonly statusText?: string;
-    constructor({ url, statusCode, statusText, cause, message, }: {
-        url: string;
-        statusCode?: number;
-        statusText?: string;
-        message?: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is DownloadError;
+export declare class DownloadError extends AISDKError {
+  private readonly [symbol$1];
+  readonly url: string;
+  readonly statusCode?: number;
+  readonly statusText?: string;
+  constructor({ url, statusCode, statusText, cause, message }: {
+    url: string;
+    statusCode?: number;
+    statusText?: string;
+    message?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is DownloadError;
 }
-
+//#endregion
+//#region src/embedding-model-capabilities.d.ts
 /**
  * Symbol for exposing the UTF-8 input byte budget of an embedding model.
  *
@@ -1038,7 +1076,22 @@ declare class DownloadError extends AISDKError {
  * embedding model specification.
  */
 declare const EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL: unique symbol;
-
+/**
+ * Symbol for transforming provider options for an automatically batched
+ * embedding model call.
+ *
+ * This capability is experimental and intentionally lives outside the versioned
+ * embedding model specification.
+ */
+declare const EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER: unique symbol;
+type EmbeddingModelProviderOptionsTransformer = (options: {
+  providerOptions: SharedV4ProviderOptions | undefined;
+  values: Array<string>;
+  startIndex: number;
+  endIndex: number;
+}) => SharedV4ProviderOptions | undefined | PromiseLike<SharedV4ProviderOptions | undefined>;
+//#endregion
+//#region src/fetch-with-validated-redirects.d.ts
 /**
  * Fetches one validated URL without following redirects.
  *
@@ -1047,16 +1100,16 @@ declare const EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL: unique symbol;
  * Redirects are rejected by default. Callers using `redirect: 'manual'` must
  * validate the Location target before issuing another request.
  */
-declare function fetchWithValidatedEndpoint({ url, init, fetch: customFetch, trustedOrigin, redirect, }: {
-    url: string | URL;
-    init?: RequestInit;
-    fetch?: FetchFunction;
-    /**
-     * A developer-configured origin that may legitimately resolve to a private
-     * address. This must never be derived from untrusted response data.
-     */
-    trustedOrigin?: string;
-    redirect?: 'error' | 'manual';
+export declare function fetchWithValidatedEndpoint({ url, init, fetch: customFetch, trustedOrigin, redirect }: {
+  url: string | URL;
+  init?: RequestInit;
+  fetch?: FetchFunction;
+  /**
+   * A developer-configured origin that may legitimately resolve to a private
+   * address. This must never be derived from untrusted response data.
+   */
+  trustedOrigin?: string;
+  redirect?: 'error' | 'manual';
 }): Promise<Response>;
 /**
  * Fetches a URL while enforcing the download guard on every hop.
@@ -1070,6 +1123,9 @@ declare function fetchWithValidatedEndpoint({ url, init, fetch: customFetch, tru
  * Request headers are also protected: {@link sanitizeRequestHeaders} strips
  * proxy/metadata/cookie/hop-by-hop headers before the first request, and all
  * caller headers except `User-Agent` are dropped on a cross-origin redirect.
+ * Credentials and custom headers are preserved on the first hop for backwards
+ * compatibility. The caller must ensure that the initial URL may receive them.
+ * Use `fetchUntrustedUrl` for URLs that require first-hop credential isolation.
  * The fetch spec only strips `Authorization` on cross-origin redirects because
  * in a browser, CORS preflighting protects custom headers; there is no CORS on
  * the server, so provider API keys carried in custom headers (e.g. `x-key`)
@@ -1102,19 +1158,20 @@ declare function fetchWithValidatedEndpoint({ url, init, fetch: customFetch, tru
  * @throws DownloadError if a hop is unsafe, the redirect limit is exceeded, or
  * a redirect cannot be validated on a non-browser runtime.
  */
-declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects, fetch: customFetch, trustedOrigin, }: {
-    url: string;
-    headers?: HeadersInit;
-    abortSignal?: AbortSignal;
-    maxRedirects?: number;
-    fetch?: FetchFunction;
-    /**
-     * A developer-configured origin (e.g. the provider's `baseURL`) whose hops
-     * skip target validation. Must never be derived from response data.
-     */
-    trustedOrigin?: string;
+export declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRedirects, fetch: customFetch, trustedOrigin }: {
+  url: string;
+  headers?: HeadersInit;
+  abortSignal?: AbortSignal;
+  maxRedirects?: number;
+  fetch?: FetchFunction;
+  /**
+   * A developer-configured origin (e.g. the provider's `baseURL`) whose hops
+   * skip target validation. Must never be derived from response data.
+   */
+  trustedOrigin?: string;
 }): Promise<Response>;
-
+//#endregion
+//#region src/extract-lines.d.ts
 /**
  * Extracts a 1-based inclusive line range from `text`, auto-detecting the
  * file's line ending (`\r\n`, `\n`, or `\r`, in that priority).
@@ -1124,30 +1181,69 @@ declare function fetchWithValidatedRedirects({ url, headers, abortSignal, maxRed
  * cleanly. When neither `startLine` nor `endLine` is provided, the input is
  * returned unchanged. `endLine` past EOF clamps to the last line.
  */
-declare function extractLines({ text, startLine, endLine, }: {
-    text: string;
-    startLine?: number;
-    endLine?: number;
+export declare function extractLines({ text, startLine, endLine }: {
+  text: string;
+  startLine?: number;
+  endLine?: number;
 }): string;
-
+//#endregion
+//#region src/extract-response-headers.d.ts
 /**
  * Extracts the headers from a response object and returns them as a key-value object.
  *
  * @param response - The response object to extract headers from.
  * @returns The headers as a key-value object.
  */
-declare function extractResponseHeaders(response: Response): {
-    [k: string]: string;
+export declare function extractResponseHeaders(response: Response): {
+  [k: string]: string;
 };
-
+//#endregion
+//#region src/fetch-untrusted-url.d.ts
+/**
+ * Fetches an untrusted URL with first-hop credential isolation and validated
+ * redirects. Uses the URL validation, DNS-pinned Node.js transport, redirect
+ * limits, and cross-origin header stripping of {@link fetchWithValidatedRedirects}.
+ * An injected fetch must provide equivalent connect-time DNS validation.
+ *
+ * Without a matching `credentialedOrigin` (or `trustedOrigin` when it is
+ * omitted), only allowlisted request metadata is sent on the first hop.
+ * Arbitrary caller headers require an explicit matching origin because vendor
+ * credential names cannot be inferred safely. Proxy, metadata, cookie, and
+ * hop-by-hop headers are sanitized even for a matching origin.
+ *
+ * `trustedOrigin` also exempts same-origin hops from URL validation, allowing
+ * developer-configured private endpoints. Both origin options must come from
+ * developer configuration, never from untrusted response data.
+ *
+ * This is an opt-in alternative to `fetchWithValidatedRedirects`, whose
+ * existing first-hop header behavior is preserved for compatibility.
+ */
+export declare function fetchUntrustedUrl({ headers, credentialedOrigin, untrustedFirstHopHeaders, ...options }: Parameters<typeof fetchWithValidatedRedirects>[0] & {
+  /**
+   * The developer-configured origin allowed to receive arbitrary caller
+   * headers on the first hop. Defaults to `trustedOrigin` when omitted.
+   * An explicit value takes precedence over `trustedOrigin` and does not
+   * exempt the URL from validation.
+   */
+  credentialedOrigin?: string;
+  /**
+   * Additional sanitized header names safe to disclose to an untrusted first
+   * hop. Use only for non-credential protocol metadata. Credentials require
+   * a matching `credentialedOrigin` instead. Names are case-insensitive.
+   */
+  untrustedFirstHopHeaders?: readonly string[];
+}): Promise<Response>;
+//#endregion
+//#region src/filter-nullable.d.ts
 /**
  * Filters `null` and `undefined` values out of a list of values.
  *
  * @param values - The values to filter.
  * @returns A new array containing only non-nullish values.
  */
-declare function filterNullable<T>(...values: Array<T | undefined | null>): Array<T>;
-
+export declare function filterNullable<T>(...values: Array<T | undefined | null>): Array<T>;
+//#endregion
+//#region src/generate-id.d.ts
 /**
  * Creates an ID generator.
  * The total length of the ID is the sum of the prefix, separator, and random part length.
@@ -1158,11 +1254,11 @@ declare function filterNullable<T>(...values: Array<T | undefined | null>): Arra
  * @param separator - The separator between the prefix and the random part of the ID. Default: '-'.
  * @param size - The size of the random part of the ID to generate. Default: 16.
  */
-declare const createIdGenerator: ({ prefix, size, alphabet, separator, }?: {
-    prefix?: string;
-    separator?: string;
-    size?: number;
-    alphabet?: string;
+export declare const createIdGenerator: ({ prefix, size, alphabet, separator }?: {
+  prefix?: string;
+  separator?: string;
+  size?: number;
+  alphabet?: string;
 }) => IdGenerator;
 /**
  * A function that generates an ID.
@@ -1172,72 +1268,78 @@ type IdGenerator = () => string;
  * Generates a 16-character random string to use for IDs.
  * Not cryptographically secure.
  */
-declare const generateId: IdGenerator;
-
-declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, validateUrl, credentialedOrigin, trustedOrigin, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    failedResponseHandler: ResponseHandler<Error>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
-    /**
-     * Set `true` when `url` is untrusted (e.g. taken from a provider response
-     * body): it is routed through {@link fetchWithValidatedRedirects}, which
-     * rejects private/loopback/link-local targets and re-validates redirect
-     * hops; blocked URLs throw `DownloadError`. Set `false` only for URLs built
-     * from a developer-configured endpoint.
-     *
-     * Optional for backwards compatibility with existing callers; omitting it
-     * behaves like `false` (no validation). Provider code in this repository
-     * must always pass it explicitly so every call site makes a visible trust
-     * decision — see `contributing/secure-url-handling.md`.
-     */
-    validateUrl?: boolean;
-    /**
-     * When set, `headers` are sent only if `url` is same-origin with this origin
-     * (the user-agent suffix is always kept). Pass the provider's configured
-     * base URL alongside `validateUrl: true` so credentials never ride a request
-     * to a response-supplied host on a different origin (e.g. a CDN). Redirects
-     * that later cross origin drop all caller headers regardless (see
-     * {@link fetchWithValidatedRedirects}).
-     */
-    credentialedOrigin?: string;
-    /**
-     * A developer-configured origin (e.g. the provider's `baseURL`) that is
-     * exempt from URL validation when `validateUrl` is `true`. A response URL
-     * (or redirect hop) that is same-origin with it is fetched without target
-     * validation — it points at exactly the host a config-derived
-     * `validateUrl: false` request would fetch anyway, so blocking it would
-     * only break legitimate self-hosted / localhost deployments whose response
-     * URLs point back at the configured host. Hops on any other origin are
-     * still validated. Must never be derived from response data.
-     */
-    trustedOrigin?: string;
+export declare const generateId: IdGenerator;
+//#endregion
+//#region src/get-from-api.d.ts
+export declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, validateUrl, credentialedOrigin, trustedOrigin }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
+  /**
+   * Set `true` when `url` is untrusted (e.g. taken from a provider response
+   * body): it is routed through {@link fetchWithValidatedRedirects}, which
+   * rejects private/loopback/link-local targets and re-validates redirect
+   * hops; blocked URLs throw `DownloadError`. Set `false` only for URLs built
+   * from a developer-configured endpoint.
+   *
+   * Optional for backwards compatibility with existing callers; omitting it
+   * behaves like `false` (no validation). Provider code in this repository
+   * must always pass it explicitly so every call site makes a visible trust
+   * decision — see `contributing/secure-url-handling.md`.
+   */
+  validateUrl?: boolean;
+  /**
+   * When set, `headers` are sent only if `url` is same-origin with this origin
+   * (the user-agent suffix is always kept). Pass the provider's configured
+   * base URL alongside `validateUrl: true` so credentials never ride a request
+   * to a response-supplied host on a different origin (e.g. a CDN). Redirects
+   * that later cross origin drop all caller headers regardless (see
+   * {@link fetchWithValidatedRedirects}).
+   */
+  credentialedOrigin?: string;
+  /**
+   * A developer-configured origin (e.g. the provider's `baseURL`) that is
+   * exempt from URL validation when `validateUrl` is `true`. A response URL
+   * (or redirect hop) that is same-origin with it is fetched without target
+   * validation — it points at exactly the host a config-derived
+   * `validateUrl: false` request would fetch anyway, so blocking it would
+   * only break legitimate self-hosted / localhost deployments whose response
+   * URLs point back at the configured host. Hops on any other origin are
+   * still validated. Must never be derived from response data.
+   */
+  trustedOrigin?: string;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-
-declare function getRuntimeEnvironmentUserAgent(globalThisAny?: any): string;
-
+//#endregion
+//#region src/get-runtime-environment-user-agent.d.ts
+export declare function getRuntimeEnvironmentUserAgent(globalThisAny?: any): string;
+//#endregion
+//#region src/has-required-key.d.ts
 /**
  * Checks if an object has required keys.
  * @param OBJECT - The object to check.
  * @returns True if the object has required keys, false otherwise.
  */
 type HasRequiredKey<OBJECT> = {} extends OBJECT ? false : true;
-
-declare function injectJsonInstructionIntoMessages({ messages, schema, schemaPrefix, schemaSuffix, }: {
-    messages: LanguageModelV4Prompt;
-    schema?: JSONSchema7;
-    schemaPrefix?: string;
-    schemaSuffix?: string;
+//#endregion
+//#region src/inject-json-instruction.d.ts
+export declare function injectJsonInstructionIntoMessages({ messages, schema, schemaPrefix, schemaSuffix }: {
+  messages: LanguageModelV4Prompt;
+  schema?: JSONSchema7;
+  schemaPrefix?: string;
+  schemaSuffix?: string;
 }): LanguageModelV4Prompt;
-
-declare function isAbortError(error: unknown): error is Error;
-
+//#endregion
+//#region src/is-abort-error.d.ts
+export declare function isAbortError(error: unknown): error is Error;
+//#endregion
+//#region src/is-browser-runtime.d.ts
 /**
  * Returns `true` when running in a browser.
  *
@@ -1246,16 +1348,18 @@ declare function isAbortError(error: unknown): error is Error;
  * so the SDK has a single, consistent definition of "browser". Server runtimes
  * (Node.js, Deno, Bun, edge/workers) do not define `window`.
  */
-declare function isBrowserRuntime(globalThisAny?: any): boolean;
-
+export declare function isBrowserRuntime(globalThisAny?: any): boolean;
+//#endregion
+//#region src/is-buffer.d.ts
 /**
  * Type-guard for Node.js `Buffer` instances.
  *
  * Uses optional chaining on `globalThis.Buffer` so it returns `false` in
  * runtimes where `Buffer` is not available (e.g. CloudFlare Workers).
  */
-declare function isBuffer(value: unknown): value is Buffer;
-
+export declare function isBuffer(value: unknown): value is Buffer;
+//#endregion
+//#region src/is-same-origin.d.ts
 /**
  * Returns true when `url` has the same origin (scheme + host + port) as
  * `baseUrl`.
@@ -1268,8 +1372,9 @@ declare function isBuffer(value: unknown): value is Buffer;
  *
  * Returns false if either value is not a valid absolute URL (fail-closed).
  */
-declare function isSameOrigin(url: string, baseUrl: string): boolean;
-
+export declare function isSameOrigin(url: string, baseUrl: string): boolean;
+//#endregion
+//#region src/is-non-nullable.d.ts
 /**
  * Type guard that checks whether a value is not `null` or `undefined`.
  *
@@ -1277,46 +1382,62 @@ declare function isSameOrigin(url: string, baseUrl: string): boolean;
  * @param value - The value to check.
  * @returns `true` if the value is neither `null` nor `undefined`, otherwise `false`.
  */
-declare function isNonNullable<T>(value: T | undefined | null): value is NonNullable<T>;
-
+export declare function isNonNullable<T>(value: T | undefined | null): value is NonNullable<T>;
+//#endregion
+//#region src/is-provider-reference.d.ts
 /**
  * Checks whether a value is a provider reference (a mapping of provider names
  * to provider-specific identifiers) as opposed to raw bytes, a URL, or a
  * tagged `{ type: ... }` object.
  */
-declare function isProviderReference(data: unknown): data is SharedV4ProviderReference;
-
+export declare function isProviderReference(data: unknown): data is SharedV4ProviderReference;
+//#endregion
+//#region src/is-record.d.ts
 /**
  * Checks whether a value is a non-null, non-array object.
  */
-declare function isRecord(value: unknown): value is Record<string, unknown>;
-
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//#endregion
+//#region src/is-url-supported.d.ts
 /**
  * Checks if the given URL is supported natively by the model.
  *
- * @param mediaType - The media type of the URL. Case-sensitive. May be a full
+ * @param mediaType - The media type of the URL. Case-insensitive. May be a full
  *                    `type/subtype`, a wildcard `type/*`, or just the
  *                    top-level segment (e.g. `image`).
  * @param url - The URL to check.
- * @param supportedUrls - A record where keys are case-sensitive media types (or '*')
+ * @param supportedUrls - A record where keys are case-insensitive media types (or '*')
  *                        and values are arrays of RegExp patterns for URLs.
  *
  * @returns `true` if the URL matches a pattern under the specific media type
  *          or the wildcard '*', `false` otherwise.
  */
-declare function isUrlSupported({ mediaType, url, supportedUrls, }: {
-    mediaType: string;
-    url: string;
-    supportedUrls: Record<string, RegExp[]>;
+export declare function isUrlSupported({ mediaType, url, supportedUrls }: {
+  mediaType: string;
+  url: string;
+  supportedUrls: Record<string, RegExp[]>;
 }): boolean;
-
-declare function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName, description, }: {
-    apiKey: string | undefined;
-    environmentVariableName: string;
-    apiKeyParameterName?: string;
-    description: string;
+//#endregion
+//#region src/is-valid-hostname-part.d.ts
+/**
+ * Checks whether a value is a valid ASCII hostname part: 1–63 letters, digits,
+ * or hyphens, without a leading or trailing hyphen.
+ *
+ * Use this before inserting a resource name, region, or location into a
+ * generated hostname. Rejects values such as `evil.example.com/#` and
+ * `user@localhost:8080/#` that could change the request destination.
+ */
+export declare function isValidHostnamePart(value: string): boolean;
+//#endregion
+//#region src/load-api-key.d.ts
+export declare function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName, description }: {
+  apiKey: string | undefined;
+  environmentVariableName: string;
+  apiKeyParameterName?: string;
+  description: string;
 }): string;
-
+//#endregion
+//#region src/load-optional-setting.d.ts
 /**
  * Loads an optional `string` setting from the environment or a parameter.
  *
@@ -1324,11 +1445,12 @@ declare function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterNa
  * @param environmentVariableName - The environment variable name.
  * @returns The setting value.
  */
-declare function loadOptionalSetting({ settingValue, environmentVariableName, }: {
-    settingValue: string | undefined;
-    environmentVariableName: string;
+export declare function loadOptionalSetting({ settingValue, environmentVariableName }: {
+  settingValue: string | undefined;
+  environmentVariableName: string;
 }): string | undefined;
-
+//#endregion
+//#region src/load-setting.d.ts
 /**
  * Loads a `string` setting from the environment or a parameter.
  *
@@ -1338,15 +1460,16 @@ declare function loadOptionalSetting({ settingValue, environmentVariableName, }:
  * @param description - The description of the setting.
  * @returns The setting value.
  */
-declare function loadSetting({ settingValue, environmentVariableName, settingName, description, }: {
-    settingValue: string | undefined;
-    environmentVariableName: string;
-    settingName: string;
-    description: string;
+export declare function loadSetting({ settingValue, environmentVariableName, settingName, description }: {
+  settingValue: string | undefined;
+  environmentVariableName: string;
+  settingName: string;
+  description: string;
 }): string;
-
+//#endregion
+//#region src/map-reasoning-to-provider.d.ts
 type ReasoningLevel = Exclude<LanguageModelV4CallOptions['reasoning'], 'none' | 'provider-default' | undefined>;
-declare function isCustomReasoning(reasoning: LanguageModelV4CallOptions['reasoning']): reasoning is Exclude<LanguageModelV4CallOptions['reasoning'], 'provider-default' | undefined>;
+export declare function isCustomReasoning(reasoning: LanguageModelV4CallOptions['reasoning']): reasoning is Exclude<LanguageModelV4CallOptions['reasoning'], 'provider-default' | undefined>;
 /**
  * Maps a top-level reasoning level to a provider-specific effort string using
  * the given effort map. Pushes a compatibility warning if the reasoning level
@@ -1356,10 +1479,10 @@ declare function isCustomReasoning(reasoning: LanguageModelV4CallOptions['reason
  * @returns The mapped effort string, or `undefined` if the level is not
  *   supported.
  */
-declare function mapReasoningToProviderEffort<T extends string>({ reasoning, effortMap, warnings, }: {
-    reasoning: ReasoningLevel;
-    effortMap: Partial<Record<ReasoningLevel, T>>;
-    warnings: SharedV4Warning[];
+export declare function mapReasoningToProviderEffort<T extends string>({ reasoning, effortMap, warnings }: {
+  reasoning: ReasoningLevel;
+  effortMap: Partial<Record<ReasoningLevel, T>>;
+  warnings: SharedV4Warning[];
 }): T | undefined;
 /**
  * Maps a top-level reasoning level to an absolute token budget by multiplying
@@ -1371,20 +1494,22 @@ declare function mapReasoningToProviderEffort<T extends string>({ reasoning, eff
  * @returns The computed token budget, or `undefined` if the level is not
  *   supported.
  */
-declare function mapReasoningToProviderBudget({ reasoning, maxOutputTokens, maxReasoningBudget, minReasoningBudget, budgetPercentages, warnings, }: {
-    reasoning: ReasoningLevel;
-    maxOutputTokens: number;
-    maxReasoningBudget: number;
-    minReasoningBudget?: number;
-    budgetPercentages?: Partial<Record<ReasoningLevel, number>>;
-    warnings: SharedV4Warning[];
+export declare function mapReasoningToProviderBudget({ reasoning, maxOutputTokens, maxReasoningBudget, minReasoningBudget, budgetPercentages, warnings }: {
+  reasoning: ReasoningLevel;
+  maxOutputTokens: number;
+  maxReasoningBudget: number;
+  minReasoningBudget?: number;
+  budgetPercentages?: Partial<Record<ReasoningLevel, number>>;
+  warnings: SharedV4Warning[];
 }): number | undefined;
-
+//#endregion
+//#region src/maybe-promise-like.d.ts
 /**
  * A value that can be provided either synchronously or as a promise-like.
  */
 type MaybePromiseLike<T> = T | PromiseLike<T>;
-
+//#endregion
+//#region src/media-type-to-extension.d.ts
 /**
  * Maps a media type to its corresponding file extension.
  * It was originally introduced to set a filename for audio file uploads
@@ -1394,8 +1519,9 @@ type MaybePromiseLike<T> = T | PromiseLike<T>;
  * @returns The corresponding file extension
  * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types
  */
-declare function mediaTypeToExtension(mediaType: string): string;
-
+export declare function mediaTypeToExtension(mediaType: string): string;
+//#endregion
+//#region src/normalize-headers.d.ts
 /**
  * Normalizes different header inputs into a plain record with lower-case keys.
  * Entries with `undefined` or `null` values are removed.
@@ -1403,51 +1529,55 @@ declare function mediaTypeToExtension(mediaType: string): string;
  * @param headers - Input headers (`Headers`, tuples array, plain record) to normalize.
  * @returns A record containing the normalized header entries.
  */
-declare function normalizeHeaders(headers: HeadersInit | Record<string, string | undefined> | Array<[string, string | undefined]> | undefined): Record<string, string>;
-
+export declare function normalizeHeaders(headers: HeadersInit | Record<string, string | undefined> | Array<[string, string | undefined]> | undefined): Record<string, string>;
+//#endregion
+//#region src/normalize-batch-request-counts.d.ts
 /**
  * Normalizes complete batch request counts.
  *
  * Returns `undefined` when any count is missing, is not a non-negative safe
  * integer, or when the item counts do not add up to the total.
  */
-declare function normalizeBatchRequestCounts({ total, pending, completed, failed, }: {
-    total: number | null | undefined;
-    pending: number | null | undefined;
-    completed: number | null | undefined;
-    failed: number | null | undefined;
+export declare function normalizeBatchRequestCounts({ total, pending, completed, failed }: {
+  total: number | null | undefined;
+  pending: number | null | undefined;
+  completed: number | null | undefined;
+  failed: number | null | undefined;
 }): Experimental_BatchV4Status['requestCounts'] | undefined;
-
+//#endregion
+//#region src/parse-json-event-stream.d.ts
 /**
  * Parses a JSON event stream into a stream of parsed JSON objects.
  */
-declare function parseJsonEventStream<T>({ stream, schema, }: {
-    stream: ReadableStream<Uint8Array>;
-    schema: FlexibleSchema<T>;
+export declare function parseJsonEventStream<T>({ stream, schema }: {
+  stream: ReadableStream<Uint8Array>;
+  schema: FlexibleSchema<T>;
 }): ReadableStream<ParseResult<T>>;
-
-declare function parseProviderOptions<OPTIONS>({ provider, providerOptions, schema, }: {
-    provider: string;
-    providerOptions: Record<string, unknown> | undefined;
-    schema: FlexibleSchema<OPTIONS>;
+//#endregion
+//#region src/parse-provider-options.d.ts
+export declare function parseProviderOptions<OPTIONS>({ provider, providerOptions, schema }: {
+  provider: string;
+  providerOptions: Record<string, unknown> | undefined;
+  schema: FlexibleSchema<OPTIONS>;
 }): Promise<OPTIONS | undefined>;
-
+//#endregion
+//#region src/post-multipart-stream-to-api.d.ts
 /**
  * A part of a streaming multipart/form-data request body.
  *
  * Parts are emitted in array order, which providers may depend on
  * (e.g. xAI requires expiry fields to precede the file part).
  */
-type MultipartStreamPart = {
-    type: 'field';
-    name: string;
-    value: string;
+export type MultipartStreamPart = {
+  type: 'field';
+  name: string;
+  value: string;
 } | {
-    type: 'file';
-    name: string;
-    filename?: string;
-    mediaType?: string;
-    content: ReadableStream<Uint8Array> | Uint8Array;
+  type: 'file';
+  name: string;
+  filename?: string;
+  mediaType?: string;
+  content: ReadableStream<Uint8Array> | Uint8Array;
 };
 /**
  * POSTs a multipart/form-data body as a request stream, so file parts backed
@@ -1457,130 +1587,144 @@ type MultipartStreamPart = {
  * (`duplex: 'half'`). Callers with fully buffered payloads can keep using
  * `postFormDataToApi`.
  */
-declare const postMultipartStreamToApi: <T>({ url, headers, parts, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    parts: Array<MultipartStreamPart>;
-    failedResponseHandler: ResponseHandler<Error>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
+export declare const postMultipartStreamToApi: <T>({ url, headers, parts, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  parts: Array<MultipartStreamPart>;
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-
-declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    body: unknown;
-    failedResponseHandler: ResponseHandler<APICallError>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
+//#endregion
+//#region src/post-to-api.d.ts
+export declare const postJsonToApi: <T>({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  body: unknown;
+  failedResponseHandler: ResponseHandler<APICallError>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-declare const postFormDataToApi: <T>({ url, headers, formData, failedResponseHandler, successfulResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    formData: FormData;
-    failedResponseHandler: ResponseHandler<APICallError>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
+export declare const postFormDataToApi: <T>({ url, headers, formData, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  formData: FormData;
+  failedResponseHandler: ResponseHandler<APICallError>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-declare const postToApi: <T>({ url, headers, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    body: {
-        content: string | FormData | Uint8Array | Blob;
-        values: unknown;
-    };
-    failedResponseHandler: ResponseHandler<Error>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
+export declare const postToApi: <T>({ url, headers, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch }: {
+  url: string;
+  headers?: Record<string, string | undefined>;
+  body: {
+    content: string | FormData | Uint8Array | Blob;
+    values: unknown;
+  };
+  failedResponseHandler: ResponseHandler<Error>;
+  successfulResponseHandler: ResponseHandler<T>;
+  abortSignal?: AbortSignal;
+  fetch?: FetchFunction;
 }) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
+  value: T;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
 }>;
-
+//#endregion
+//#region src/types/context.d.ts
 /**
  * A context object that is passed into tool execution.
  */
 type Context = Record<string, unknown>;
-
+//#endregion
+//#region src/types/executable-tool.d.ts
 /**
  * A tool that is guaranteed to expose an execute function.
  */
 type ExecutableTool<TOOL extends Tool = Tool> = TOOL & {
-    execute: NonNullable<TOOL['execute']>;
+  execute: NonNullable<TOOL['execute']>;
 };
 /**
  * Checks whether a tool exposes an execute function.
  */
-declare function isExecutableTool<TOOL extends Tool>(tool: TOOL | undefined): tool is ExecutableTool<TOOL>;
-
+export declare function isExecutableTool<TOOL extends Tool>(tool: TOOL | undefined): tool is ExecutableTool<TOOL>;
+//#endregion
+//#region src/types/never-optional.d.ts
 type NeverOptional<N, T> = 0 extends 1 & N ? Partial<T> : [N] extends [never] ? Partial<Record<keyof T, undefined>> : T;
-
+//#endregion
+//#region src/types/tool-approval-request.d.ts
 /**
  * Tool approval request prompt part.
  */
 type ToolApprovalRequest = {
-    type: 'tool-approval-request';
-    /**
-     * ID of the tool approval.
-     */
-    approvalId: string;
-    /**
-     * ID of the tool call that the approval request is for.
-     */
-    toolCallId: string;
-    /**
-     * Reason why the tool call requires approval.
-     */
-    reason?: string;
-    /**
-     * Flag indicating whether the tool was automatically approved or denied.
-     *
-     * @default false
-     */
-    isAutomatic?: boolean;
-    /**
-     * HMAC-SHA256 signature binding this approval to its tool call.
-     * Present only when `experimental_toolApprovalSecret` is configured.
-     */
-    signature?: string;
+  type: 'tool-approval-request';
+  /**
+   * ID of the tool approval.
+   */
+  approvalId: string;
+  /**
+   * ID of the tool call that the approval request is for.
+   */
+  toolCallId: string;
+  /**
+   * Reason why the tool call requires approval.
+   */
+  reason?: string;
+  /**
+   * Flag indicating whether the tool was automatically approved or denied.
+   *
+   * @default false
+   */
+  isAutomatic?: boolean;
+  /**
+   * HMAC-SHA256 signature binding this approval to its tool call.
+   * Present only when `experimental_toolApprovalSecret` is configured.
+   */
+  signature?: string;
+  /**
+   * Tool input before input schema validation and transformation.
+   *
+   * This is included when it differs from the validated tool input so that
+   * approved tool calls can be safely revalidated before execution.
+   */
+  inputSchemaInput?: unknown;
 };
-
+//#endregion
+//#region src/types/assistant-model-message.d.ts
 /**
  * An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
  */
 type AssistantModelMessage = {
-    role: 'assistant';
-    content: AssistantContent;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  role: 'assistant';
+  content: AssistantContent;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 };
 /**
  * Content of an assistant message.
  * It can be a string or an array of text, image, reasoning, redacted reasoning, and tool call parts.
  */
 type AssistantContent = string | Array<TextPart | CustomPart | FilePart | ReasoningPart | ReasoningFilePart | ToolCallPart | ToolResultPart | ToolApprovalRequest>;
-
+//#endregion
+//#region src/types/system-model-message.d.ts
 /**
  * A system message. It can contain system information.
  *
@@ -1589,496 +1733,502 @@ type AssistantContent = string | Array<TextPart | CustomPart | FilePart | Reason
  * and because not all providers support several system messages.
  */
 type SystemModelMessage = {
-    role: 'system';
-    content: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  role: 'system';
+  content: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 };
-
+//#endregion
+//#region src/types/tool-approval-response.d.ts
 /**
  * Tool approval response prompt part.
  */
 type ToolApprovalResponse = {
-    type: 'tool-approval-response';
-    /**
-     * ID of the tool approval.
-     */
-    approvalId: string;
-    /**
-     * Flag indicating whether the approval was granted or denied.
-     */
-    approved: boolean;
-    /**
-     * Optional reason for the approval or denial.
-     */
-    reason?: string;
-    /**
-     * Flag indicating whether the tool call is provider-executed.
-     * Only provider-executed tool approval responses should be sent to the model.
-     */
-    providerExecuted?: boolean;
+  type: 'tool-approval-response';
+  /**
+   * ID of the tool approval.
+   */
+  approvalId: string;
+  /**
+   * Flag indicating whether the approval was granted or denied.
+   */
+  approved: boolean;
+  /**
+   * Optional reason for the approval or denial.
+   */
+  reason?: string;
+  /**
+   * Flag indicating whether the tool call is provider-executed.
+   * Only provider-executed tool approval responses should be sent to the model.
+   */
+  providerExecuted?: boolean;
 };
-
+//#endregion
+//#region src/types/tool-model-message.d.ts
 /**
  * A tool message. It contains the result of one or more tool calls.
  */
 type ToolModelMessage = {
-    role: 'tool';
-    content: ToolContent;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  role: 'tool';
+  content: ToolContent;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 };
 /**
  * Content of a tool message. It is an array of tool result parts.
  */
 type ToolContent = Array<ToolResultPart | ToolApprovalResponse>;
-
+//#endregion
+//#region src/types/user-model-message.d.ts
 /**
  * A user message. It can contain text or a combination of text and images.
  */
 type UserModelMessage = {
-    role: 'user';
-    content: UserContent;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
+  role: 'user';
+  content: UserContent;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
 };
 /**
  * Content of a user message. It can be a string or an array of text and image parts.
  */
 type UserContent = string | Array<TextPart | ImagePart | FilePart>;
-
+//#endregion
+//#region src/types/model-message.d.ts
 /**
  * A message that can be used in the `messages` field of a prompt.
  * It can be a user message, an assistant message, or a tool message.
  */
 type ModelMessage = SystemModelMessage | UserModelMessage | AssistantModelMessage | ToolModelMessage;
-
+//#endregion
+//#region src/types/sandbox.d.ts
 /**
  * Options for executing a command in the sandbox via `run` or `spawn`.
  */
 type SandboxProcessOptions = {
-    /**
-     * Command to execute in the sandbox.
-     */
-    command: string;
-    /**
-     * Working directory to execute the command in.
-     */
-    workingDirectory?: string;
-    /**
-     * Environment variables to set for this command. Merged with the
-     * sandbox's default environment; values here take precedence.
-     * Supporting environment variables as an option is preferable from a
-     * security perspective, e.g. to avoid them leaking in logs.
-     */
-    env?: Record<string, string>;
-    /**
-     * Signal that can be used to abort the command. When aborted, the running
-     * process is killed; for `spawn`, `wait()` rejects with the abort reason.
-     */
-    abortSignal?: AbortSignal;
+  /**
+   * Command to execute in the sandbox.
+   */
+  command: string;
+  /**
+   * Working directory to execute the command in.
+   */
+  workingDirectory?: string;
+  /**
+   * Environment variables to set for this command. Merged with the
+   * sandbox's default environment; values here take precedence.
+   * Supporting environment variables as an option is preferable from a
+   * security perspective, e.g. to avoid them leaking in logs.
+   */
+  env?: Record<string, string>;
+  /**
+   * Signal that can be used to abort the command. When aborted, the running
+   * process is killed; for `spawn`, `wait()` rejects with the abort reason.
+   */
+  abortSignal?: AbortSignal;
 };
 /**
  * Options for reading a file from the sandbox.
  */
 type ReadFileOptions = {
-    /**
-     * Path of the file to read.
-     */
-    path: string;
-    /**
-     * Signal that can be used to abort the read.
-     */
-    abortSignal?: AbortSignal;
+  /**
+   * Path of the file to read.
+   */
+  path: string;
+  /**
+   * Signal that can be used to abort the read.
+   */
+  abortSignal?: AbortSignal;
 };
 /**
  * Options for writing a file to the sandbox. `CONTENT` is the payload written
  * to the file: a byte stream, raw bytes, or a string.
  */
 type WriteFileOptions<CONTENT> = {
-    /**
-     * Path of the file to write.
-     */
-    path: string;
-    /**
-     * Content to write to the file.
-     */
-    content: CONTENT;
-    /**
-     * Signal that can be used to abort the write.
-     */
-    abortSignal?: AbortSignal;
+  /**
+   * Path of the file to write.
+   */
+  path: string;
+  /**
+   * Content to write to the file.
+   */
+  content: CONTENT;
+  /**
+   * Signal that can be used to abort the write.
+   */
+  abortSignal?: AbortSignal;
 };
 /**
  * Sandbox session that can execute commands and read/write files.
  */
 type SandboxSession = {
-    /**
-     * Description of the sandbox environment that can be added to the agent's instructions
-     * so that the agent knows about relevant details such as the root directory, exposed
-     * ports, the public hostname, etc.
-     */
-    readonly description: string;
-    /**
-     * Read one file from the sandbox as a stream of bytes. Resolves to `null`
-     * when the file does not exist.
-     *
-     * Relative path handling is implementation-defined. This is the lowest-level
-     * read primitive; prefer `readBinaryFile` or `readTextFile` unless you need
-     * to stream bytes.
+  /**
+   * Description of the sandbox environment that can be added to the agent's instructions
+   * so that the agent knows about relevant details such as the root directory, exposed
+   * ports, the public hostname, etc.
+   */
+  readonly description: string;
+  /**
+   * Read one file from the sandbox as a stream of bytes. Resolves to `null`
+   * when the file does not exist.
+   *
+   * Relative path handling is implementation-defined. This is the lowest-level
+   * read primitive; prefer `readBinaryFile` or `readTextFile` unless you need
+   * to stream bytes.
+   */
+  readonly readFile: (options: ReadFileOptions) => PromiseLike<ReadableStream<Uint8Array> | null>;
+  /**
+   * Read one file from the sandbox as raw bytes. Resolves to `null` when the
+   * file does not exist.
+   */
+  readonly readBinaryFile: (options: ReadFileOptions) => PromiseLike<Uint8Array | null>;
+  /**
+   * Read one text file from the sandbox, decoded using the requested encoding.
+   * Resolves to `null` when the file does not exist.
+   *
+   * Line ranges are 1-based and inclusive. When `endLine` is past EOF the read
+   * returns through EOF without error.
+   */
+  readonly readTextFile: (options: ReadFileOptions & {
+    /**
+     * Text encoding used to decode the file bytes. Defaults to `"utf-8"`.
+     */
+    encoding?: string;
+    /**
+     * 1-based inclusive start line. Defaults to 1.
      */
-    readonly readFile: (options: ReadFileOptions) => PromiseLike<ReadableStream<Uint8Array> | null>;
-    /**
-     * Read one file from the sandbox as raw bytes. Resolves to `null` when the
-     * file does not exist.
-     */
-    readonly readBinaryFile: (options: ReadFileOptions) => PromiseLike<Uint8Array | null>;
+    startLine?: number;
     /**
-     * Read one text file from the sandbox, decoded using the requested encoding.
-     * Resolves to `null` when the file does not exist.
-     *
-     * Line ranges are 1-based and inclusive. When `endLine` is past EOF the read
+     * 1-based inclusive end line. When past the file's line count, the read
      * returns through EOF without error.
      */
-    readonly readTextFile: (options: ReadFileOptions & {
-        /**
-         * Text encoding used to decode the file bytes. Defaults to `"utf-8"`.
-         */
-        encoding?: string;
-        /**
-         * 1-based inclusive start line. Defaults to 1.
-         */
-        startLine?: number;
-        /**
-         * 1-based inclusive end line. When past the file's line count, the read
-         * returns through EOF without error.
-         */
-        endLine?: number;
-    }) => PromiseLike<string | null>;
-    /**
-     * Write one file to the sandbox from a stream of bytes. Creates parent
-     * directories recursively and overwrites any existing file.
-     *
-     * This is the lowest-level write primitive; prefer `writeBinaryFile` or
-     * `writeTextFile` when the full content is already materialized in memory.
-     */
-    readonly writeFile: (options: WriteFileOptions<ReadableStream<Uint8Array>>) => PromiseLike<void>;
-    /**
-     * Write one file to the sandbox from raw bytes. Creates parent directories
-     * recursively and overwrites any existing file.
-     */
-    readonly writeBinaryFile: (options: WriteFileOptions<Uint8Array>) => PromiseLike<void>;
-    /**
-     * Write one file to the sandbox from a string, encoded using the requested
-     * encoding. Creates parent directories recursively and overwrites any
-     * existing file.
-     */
-    readonly writeTextFile: (options: WriteFileOptions<string> & {
-        /**
-         * Text encoding used to encode the string to bytes. Defaults to `"utf-8"`.
-         */
-        encoding?: string;
-    }) => PromiseLike<void>;
-    /**
-     * Spawn a long-running process in the sandbox. Returns immediately with a
-     * handle that streams stdout/stderr, can be waited on, and can be killed.
-     *
-     * `run` is conceptually a thin wrapper over this primitive: spawn,
-     * collect both streams to strings, await `wait()`, return the result.
-     */
-    readonly spawn: (options: SandboxProcessOptions) => PromiseLike<SandboxProcess>;
-    /**
-     * Run a command in the sandbox.
-     */
-    readonly run: (options: SandboxProcessOptions) => PromiseLike<{
-        /**
-         * Exit code returned by the command.
-         */
-        exitCode: number;
-        /**
-         * Standard output produced by the command.
-         */
-        stdout: string;
-        /**
-         * Standard error produced by the command.
-         */
-        stderr: string;
-    }>;
+    endLine?: number;
+  }) => PromiseLike<string | null>;
+  /**
+   * Write one file to the sandbox from a stream of bytes. Creates parent
+   * directories recursively and overwrites any existing file.
+   *
+   * This is the lowest-level write primitive; prefer `writeBinaryFile` or
+   * `writeTextFile` when the full content is already materialized in memory.
+   */
+  readonly writeFile: (options: WriteFileOptions<ReadableStream<Uint8Array>>) => PromiseLike<void>;
+  /**
+   * Write one file to the sandbox from raw bytes. Creates parent directories
+   * recursively and overwrites any existing file.
+   */
+  readonly writeBinaryFile: (options: WriteFileOptions<Uint8Array>) => PromiseLike<void>;
+  /**
+   * Write one file to the sandbox from a string, encoded using the requested
+   * encoding. Creates parent directories recursively and overwrites any
+   * existing file.
+   */
+  readonly writeTextFile: (options: WriteFileOptions<string> & {
+    /**
+     * Text encoding used to encode the string to bytes. Defaults to `"utf-8"`.
+     */
+    encoding?: string;
+  }) => PromiseLike<void>;
+  /**
+   * Spawn a long-running process in the sandbox. Returns immediately with a
+   * handle that streams stdout/stderr, can be waited on, and can be killed.
+   *
+   * `run` is conceptually a thin wrapper over this primitive: spawn,
+   * collect both streams to strings, await `wait()`, return the result.
+   */
+  readonly spawn: (options: SandboxProcessOptions) => PromiseLike<SandboxProcess>;
+  /**
+   * Run a command in the sandbox.
+   */
+  readonly run: (options: SandboxProcessOptions) => PromiseLike<{
+    /**
+     * Exit code returned by the command.
+     */
+    exitCode: number;
+    /**
+     * Standard output produced by the command.
+     */
+    stdout: string;
+    /**
+     * Standard error produced by the command.
+     */
+    stderr: string;
+  }>;
 };
 /**
  * Handle to a long-running process started via `SandboxSession.spawn`.
  */
 type SandboxProcess = {
-    /**
-     * Process identifier, if the sandbox implementation exposes one.
-     */
-    readonly pid?: number;
-    /**
-     * Stream of bytes written by the process to standard output.
-     */
-    readonly stdout: ReadableStream<Uint8Array>;
-    /**
-     * Stream of bytes written by the process to standard error.
-     */
-    readonly stderr: ReadableStream<Uint8Array>;
-    /**
-     * Resolve when the process exits, yielding its exit code.
-     */
-    wait(): PromiseLike<{
-        exitCode: number;
-    }>;
-    /**
-     * Terminate the process. Idempotent.
-     */
-    kill(): PromiseLike<void>;
+  /**
+   * Process identifier, if the sandbox implementation exposes one.
+   */
+  readonly pid?: number;
+  /**
+   * Stream of bytes written by the process to standard output.
+   */
+  readonly stdout: ReadableStream<Uint8Array>;
+  /**
+   * Stream of bytes written by the process to standard error.
+   */
+  readonly stderr: ReadableStream<Uint8Array>;
+  /**
+   * Resolve when the process exits, yielding its exit code.
+   */
+  wait(): PromiseLike<{
+    exitCode: number;
+  }>;
+  /**
+   * Terminate the process. Idempotent.
+   */
+  kill(): PromiseLike<void>;
 };
-
+//#endregion
+//#region src/types/tool-execute-function.d.ts
 /**
  * Additional options that are sent into each tool execution.
  */
 interface ToolExecutionOptions<CONTEXT extends Context | unknown | never> {
-    /**
-     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
-     */
-    toolCallId: string;
-    /**
-     * Messages that were sent to the language model to initiate the response that contained the tool call.
-     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
-     */
-    messages: ModelMessage[];
-    /**
-     * An optional abort signal that indicates that the overall operation should be aborted.
-     */
-    abortSignal?: AbortSignal;
-    /**
-     * Tool context as defined by the tool's context schema.
-     * The tool context is specific to the tool and is passed to the tool execution.
-     *
-     * Treat the context object as immutable inside tools.
-     * Mutating the context object can lead to race conditions and unexpected results
-     * when tools are called in parallel.
-     *
-     * If you need to mutate the context, analyze the tool calls and results
-     * in `prepareStep` and update it there.
-     */
-    context: CONTEXT;
-    /**
-     * The sandbox environment that the tool is operating in.
-     */
-    experimental_sandbox?: SandboxSession;
+  /**
+   * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+   */
+  toolCallId: string;
+  /**
+   * Messages that were sent to the language model to initiate the response that contained the tool call.
+   * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+   */
+  messages: ModelMessage[];
+  /**
+   * An optional abort signal that indicates that the overall operation should be aborted.
+   */
+  abortSignal?: AbortSignal;
+  /**
+   * Tool context as defined by the tool's context schema.
+   * The tool context is specific to the tool and is passed to the tool execution.
+   *
+   * Treat the context object as immutable inside tools.
+   * Mutating the context object can lead to race conditions and unexpected results
+   * when tools are called in parallel.
+   *
+   * If you need to mutate the context, analyze the tool calls and results
+   * in `prepareStep` and update it there.
+   */
+  context: CONTEXT;
+  /**
+   * The sandbox environment that the tool is operating in.
+   */
+  experimental_sandbox?: SandboxSession;
 }
 /**
  * Function that executes the tool and returns either a single result or a stream of results.
  */
 type ToolExecuteFunction<INPUT, OUTPUT, CONTEXT extends Context | unknown | never> = (input: INPUT, options: ToolExecutionOptions<CONTEXT>) => AsyncIterable<OUTPUT> | PromiseLike<OUTPUT> | OUTPUT;
-
+//#endregion
+//#region src/types/tool-needs-approval-function.d.ts
 /**
  * Function that is called to determine if the tool needs approval before it can be executed.
  *
  * @deprecated Tool approval is handled on a `generateText` / `streamText` level now.
  */
 type ToolNeedsApprovalFunction<INPUT, CONTEXT extends Context | unknown | never> = (input: INPUT, options: {
-    /**
-     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
-     */
-    toolCallId: string;
-    /**
-     * Messages that were sent to the language model to initiate the response that contained the tool call.
-     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
-     */
-    messages: ModelMessage[];
-    /**
-     * Tool context as defined by the tool's context schema.
-     * The tool context is specific to the tool and is passed to the tool execution.
-     *
-     * Treat the context object as immutable inside tools.
-     * Mutating the context object can lead to race conditions and unexpected results
-     * when tools are called in parallel.
-     *
-     * If you need to mutate the context, analyze the tool calls and results
-     * in `prepareStep` and update it there.
-     */
-    context: CONTEXT;
+  /**
+   * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+   */
+  toolCallId: string;
+  /**
+   * Messages that were sent to the language model to initiate the response that contained the tool call.
+   * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+   */
+  messages: ModelMessage[];
+  /**
+   * Tool context as defined by the tool's context schema.
+   * The tool context is specific to the tool and is passed to the tool execution.
+   *
+   * Treat the context object as immutable inside tools.
+   * Mutating the context object can lead to race conditions and unexpected results
+   * when tools are called in parallel.
+   *
+   * If you need to mutate the context, analyze the tool calls and results
+   * in `prepareStep` and update it there.
+   */
+  context: CONTEXT;
 }) => boolean | PromiseLike<boolean>;
-
+//#endregion
+//#region src/types/tool.d.ts
 /**
  * Helper type to determine the outputSchema and execute function properties of a tool.
  */
 type ToolOutputProperties<INPUT, OUTPUT, CONTEXT extends Context | unknown | never> = NeverOptional<OUTPUT, {
-    /**
-     * The optional schema of the output that the tool produces.
-     *
-     * If not provided, the output shape will be inferred from the execute function.
-     */
-    outputSchema?: FlexibleSchema<OUTPUT>;
-    /**
-     * An async function that is called with the arguments from the tool call and produces a result.
-     * If not provided, the tool will not be executed automatically.
-     *
-     * @args is the input of the tool call.
-     * @options.abortSignal is a signal that can be used to abort the tool call.
-     */
-    execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+  /**
+   * The optional schema of the output that the tool produces.
+   *
+   * If not provided, the output shape will be inferred from the execute function.
+   */
+  outputSchema?: FlexibleSchema<OUTPUT>;
+  /**
+   * An async function that is called with the arguments from the tool call and produces a result.
+   * If not provided, the tool will not be executed automatically.
+   *
+   * @args is the input of the tool call.
+   * @options.abortSignal is a signal that can be used to abort the tool call.
+   */
+  execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
 } | {
-    /**
-     * The schema of the output that the tool produces.
-     *
-     * Required when no execute function is provided.
-     */
-    outputSchema: FlexibleSchema<OUTPUT>;
-    execute?: never;
+  /**
+   * The schema of the output that the tool produces.
+   *
+   * Required when no execute function is provided.
+   */
+  outputSchema: FlexibleSchema<OUTPUT>;
+  execute?: never;
 }>;
 /**
  * Common properties shared by all tool kinds.
  */
 type BaseTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = {
+  /**
+   * Defer exposing this tool until it is discovered by `toolSearch`.
+   * Supports direct calls and local callers that announce tools in conversation
+   * messages (code mode with `toolDiscovery: 'conversation'`). Discovered tools
+   * become available on the next model step.
+   */
+  deferLoading?: boolean;
+  /**
+   * An optional title of the tool.
+   *
+   * @deprecated Use `providerMetadata` for source-specific tool display metadata.
+   */
+  title?: string;
+  /**
+   * Additional provider-specific metadata. They are passed through
+   * to the provider from the AI SDK and enable provider-specific
+   * functionality that can be fully encapsulated in the provider.
+   */
+  providerOptions?: ProviderOptions;
+  /**
+   * Optional metadata about the tool itself (e.g. its source).
+   *
+   * Unlike `providerOptions`, this metadata is not sent to the language
+   * model. Instead, it is propagated onto the resulting tool call's
+   * `toolMetadata` so consumers can read it from tool call / result parts
+   * and UI message parts. This is useful for sources of dynamic tools (e.g.
+   * an MCP server) to identify themselves.
+   */
+  metadata?: JSONObject;
+  /**
+   * The schema of the input that the tool expects.
+   * The language model will use this to generate the input.
+   * It is also used to validate the output of the language model.
+   *
+   * You can use descriptions on the schema properties to make the input understandable for the language model.
+   */
+  inputSchema: FlexibleSchema<INPUT>;
+  /**
+   * An optional schema describing the context that the tool expects.
+   *
+   * The context is passed to execute function as part of the execution options.
+   */
+  contextSchema?: FlexibleSchema<CONTEXT>;
+  /**
+   * Whether the tool needs approval before it can be executed.
+   *
+   * @deprecated Tool approval is handled on a `generateText` / `streamText` level now.
+   */
+  needsApproval?: boolean | ToolNeedsApprovalFunction<[INPUT] extends [never] ? unknown : INPUT, NoInfer<CONTEXT>>;
+  /**
+   * Optional function that is called when the model starts generating the tool input.
+   * In non-streaming contexts, it is called immediately before `onInputAvailable`.
+   */
+  onInputStart?: (options: ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
+  /**
+   * Optional function that is called when an argument streaming delta is available.
+   * Only called when the tool is used in a streaming context.
+   */
+  onInputDelta?: (options: {
+    inputTextDelta: string;
+  } & ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
+  /**
+   * Optional function that is called when a tool call can be started,
+   * even if the execute function is not provided.
+   */
+  onInputAvailable?: (options: {
+    input: [INPUT] extends [never] ? unknown : INPUT;
+  } & ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
+  /**
+   * Optional conversion function that maps the tool result to an output that can be used by the language model.
+   *
+   * If not provided, the tool result will be sent as a JSON object.
+   *
+   * This function is invoked on the server by `convertToModelMessages`, so ensure that you pass the same "tools" (ToolSet) to both "convertToModelMessages" and "streamText" (or other generation APIs).
+   */
+  toModelOutput?: (options: {
     /**
-     * Defer exposing this tool until it is discovered by `toolSearch`.
-     * Supports direct calls and local callers that announce tools in conversation
-     * messages (code mode with `toolDiscovery: 'conversation'`). Discovered tools
-     * become available on the next model step.
-     */
-    deferLoading?: boolean;
-    /**
-     * An optional title of the tool.
-     *
-     * @deprecated Use `providerMetadata` for source-specific tool display metadata.
-     */
-    title?: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
-    /**
-     * Optional metadata about the tool itself (e.g. its source).
-     *
-     * Unlike `providerOptions`, this metadata is not sent to the language
-     * model. Instead, it is propagated onto the resulting tool call's
-     * `toolMetadata` so consumers can read it from tool call / result parts
-     * and UI message parts. This is useful for sources of dynamic tools (e.g.
-     * an MCP server) to identify themselves.
-     */
-    metadata?: JSONObject;
-    /**
-     * The schema of the input that the tool expects.
-     * The language model will use this to generate the input.
-     * It is also used to validate the output of the language model.
-     *
-     * You can use descriptions on the schema properties to make the input understandable for the language model.
-     */
-    inputSchema: FlexibleSchema<INPUT>;
-    /**
-     * An optional schema describing the context that the tool expects.
-     *
-     * The context is passed to execute function as part of the execution options.
-     */
-    contextSchema?: FlexibleSchema<CONTEXT>;
-    /**
-     * Whether the tool needs approval before it can be executed.
-     *
-     * @deprecated Tool approval is handled on a `generateText` / `streamText` level now.
-     */
-    needsApproval?: boolean | ToolNeedsApprovalFunction<[
-        INPUT
-    ] extends [never] ? unknown : INPUT, NoInfer<CONTEXT>>;
-    /**
-     * Optional function that is called when the model starts generating the tool input.
-     * In non-streaming contexts, it is called immediately before `onInputAvailable`.
-     */
-    onInputStart?: (options: ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
-    /**
-     * Optional function that is called when an argument streaming delta is available.
-     * Only called when the tool is used in a streaming context.
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
      */
-    onInputDelta?: (options: {
-        inputTextDelta: string;
-    } & ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
+    toolCallId: string;
     /**
-     * Optional function that is called when a tool call can be started,
-     * even if the execute function is not provided.
+     * The input of the tool call.
      */
-    onInputAvailable?: (options: {
-        input: [INPUT] extends [never] ? unknown : INPUT;
-    } & ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
+    input: [INPUT] extends [never] ? unknown : INPUT;
     /**
-     * Optional conversion function that maps the tool result to an output that can be used by the language model.
-     *
-     * If not provided, the tool result will be sent as a JSON object.
-     *
-     * This function is invoked on the server by `convertToModelMessages`, so ensure that you pass the same "tools" (ToolSet) to both "convertToModelMessages" and "streamText" (or other generation APIs).
+     * The output of the tool call.
      */
-    toModelOutput?: (options: {
-        /**
-         * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
-         */
-        toolCallId: string;
-        /**
-         * The input of the tool call.
-         */
-        input: [INPUT] extends [never] ? unknown : INPUT;
-        /**
-         * The output of the tool call.
-         */
-        output: 0 extends 1 & OUTPUT ? any : [OUTPUT] extends [never] ? any : NoInfer<OUTPUT>;
-    }) => ToolResultOutput | PromiseLike<ToolResultOutput>;
+    output: 0 extends 1 & OUTPUT ? any : [OUTPUT] extends [never] ? any : NoInfer<OUTPUT>;
+  }) => ToolResultOutput | PromiseLike<ToolResultOutput>;
 } & ToolOutputProperties<INPUT, OUTPUT, NoInfer<CONTEXT>>;
 /**
  * Common properties shared by function-style tools.
  */
 type BaseFunctionTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseTool<INPUT, OUTPUT, CONTEXT> & {
-    /**
-     * Optional description of what the tool does.
-     *
-     * Included in the tool definition sent to the language model so it can
-     * decide when and how to call the tool.
-     *
-     * Provide a string for a fixed description, or a function that returns a
-     * string from the current `context` (and optional `experimental_sandbox`) when the
-     * description should vary per call.
-     */
-    description?: string | ((options: {
-        context: NoInfer<CONTEXT>;
-        experimental_sandbox?: SandboxSession;
-    }) => string);
-    /**
-     * Strict mode setting for the tool.
-     *
-     * Providers that support strict mode will use this setting to determine
-     * how the input should be generated. Strict mode will always produce
-     * valid inputs, but it might limit what input schemas are supported.
-     */
-    strict?: boolean;
-    /**
-     * An optional list of input examples that show the language
-     * model what the input should look like.
-     */
-    inputExamples?: Array<{
-        input: NoInfer<INPUT>;
-    }>;
-    id?: never;
-    isProviderExecuted?: never;
-    args?: never;
-    supportsDeferredResults?: never;
+  /**
+   * Optional description of what the tool does.
+   *
+   * Included in the tool definition sent to the language model so it can
+   * decide when and how to call the tool.
+   *
+   * Provide a string for a fixed description, or a function that returns a
+   * string from the current `context` (and optional `experimental_sandbox`) when the
+   * description should vary per call.
+   */
+  description?: string | ((options: {
+    context: NoInfer<CONTEXT>;
+    experimental_sandbox?: SandboxSession;
+  }) => string);
+  /**
+   * Strict mode setting for the tool.
+   *
+   * Providers that support strict mode will use this setting to determine
+   * how the input should be generated. Strict mode will always produce
+   * valid inputs, but it might limit what input schemas are supported.
+   */
+  strict?: boolean;
+  /**
+   * An optional list of input examples that show the language
+   * model what the input should look like.
+   */
+  inputExamples?: Array<{
+    input: NoInfer<INPUT>;
+  }>;
+  id?: never;
+  isProviderExecuted?: never;
+  args?: never;
+  supportsDeferredResults?: never;
 };
 /**
  * Tool with user-defined input and output schemas that is executed by the AI SDK.
  */
 type FunctionTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseFunctionTool<INPUT, OUTPUT, CONTEXT> & {
-    type?: undefined | 'function';
+  type?: undefined | 'function';
 };
 /**
  * Tool that is defined at runtime.
@@ -2087,24 +2237,24 @@ type FunctionTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extend
  * For example, MCP tools that are not known at development time.
  */
 type DynamicTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseFunctionTool<INPUT, OUTPUT, CONTEXT> & {
-    type: 'dynamic';
+  type: 'dynamic';
 };
 /**
  * Common properties shared by provider tools.
  */
 type BaseProviderTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseTool<INPUT, OUTPUT, CONTEXT> & {
-    type: 'provider';
-    /**
-     * The ID of the tool. Must follow the format `<provider-name>.<unique-tool-name>`.
-     */
-    id: `${string}.${string}`;
-    /**
-     * The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
-     */
-    args: Record<string, unknown>;
-    description?: never;
-    strict?: never;
-    inputExamples?: never;
+  type: 'provider';
+  /**
+   * The ID of the tool. Must follow the format `<provider-name>.<unique-tool-name>`.
+   */
+  id: `${string}.${string}`;
+  /**
+   * The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+   */
+  args: Record<string, unknown>;
+  description?: never;
+  strict?: never;
+  inputExamples?: never;
 };
 /**
  * Tool with provider-defined input and output schemas that is executed by the
@@ -2113,11 +2263,11 @@ type BaseProviderTool<INPUT extends JSONValue | unknown | never = any, OUTPUT ex
  * For example, shell tools that are executed in a local shell, but have provider-defined input and output schemas.
  */
 type ProviderDefinedTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseProviderTool<INPUT, OUTPUT, CONTEXT> & {
-    /**
-     * Flag that indicates whether the tool is executed by the provider.
-     */
-    isProviderExecuted: false;
-    supportsDeferredResults?: never;
+  /**
+   * Flag that indicates whether the tool is executed by the provider.
+   */
+  isProviderExecuted: false;
+  supportsDeferredResults?: never;
 };
 /**
  * Tool with provider-defined input and output schemas that is executed by the
@@ -2126,24 +2276,24 @@ type ProviderDefinedTool<INPUT extends JSONValue | unknown | never = any, OUTPUT
  * For example, web search tools and code execution tools that are executed by the provider itself.
  */
 type ProviderExecutedTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseProviderTool<INPUT, OUTPUT, CONTEXT> & {
-    /**
-     * Flag that indicates whether the tool is executed by the provider.
-     */
-    isProviderExecuted: true;
-    /**
-     * Whether this provider-executed tool supports deferred results.
-     *
-     * When true, the tool result may not be returned in the same turn as the
-     * tool call (e.g., when using programmatic tool calling where a server tool
-     * triggers a client-executed tool, and the server tool's result is deferred
-     * until the client tool is resolved).
-     *
-     * This flag allows the AI SDK to handle tool results that arrive without
-     * a matching tool call in the current response.
-     *
-     * @default false
-     */
-    supportsDeferredResults?: boolean;
+  /**
+   * Flag that indicates whether the tool is executed by the provider.
+   */
+  isProviderExecuted: true;
+  /**
+   * Whether this provider-executed tool supports deferred results.
+   *
+   * When true, the tool result may not be returned in the same turn as the
+   * tool call (e.g., when using programmatic tool calling where a server tool
+   * triggers a client-executed tool, and the server tool's result is deferred
+   * until the client tool is resolved).
+   *
+   * This flag allows the AI SDK to handle tool results that arrive without
+   * a matching tool call in the current response.
+   *
+   * @default false
+   */
+  supportsDeferredResults?: boolean;
 };
 /**
  * A tool can either be user-defined or provider-defined.
@@ -2162,73 +2312,76 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
  * `ExecutableTool<Tool<...>>` so that `.execute` is non-nullable without
  * needing `isExecutableTool` or a `!` assertion at the call site.
  */
-declare function tool<INPUT, OUTPUT, CONTEXT extends Context>(tool: Tool<INPUT, OUTPUT, CONTEXT> & {
-    execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+declare function tool$1<INPUT, OUTPUT, CONTEXT extends Context>(tool: Tool<INPUT, OUTPUT, CONTEXT> & {
+  execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
 }): ExecutableTool<Tool<INPUT, OUTPUT, CONTEXT>>;
-declare function tool<INPUT, OUTPUT, CONTEXT extends Context>(tool: Tool<INPUT, OUTPUT, CONTEXT>): Tool<INPUT, OUTPUT, CONTEXT>;
-declare function tool<INPUT, CONTEXT extends Context>(tool: Tool<INPUT, never, CONTEXT>): Tool<INPUT, never, CONTEXT>;
-declare function tool<OUTPUT, CONTEXT extends Context>(tool: Tool<never, OUTPUT, CONTEXT>): Tool<never, OUTPUT, CONTEXT>;
-declare function tool<CONTEXT extends Context>(tool: Tool<never, never, CONTEXT>): Tool<never, never, CONTEXT>;
+declare function tool$1<INPUT, OUTPUT, CONTEXT extends Context>(tool: Tool<INPUT, OUTPUT, CONTEXT>): Tool<INPUT, OUTPUT, CONTEXT>;
+declare function tool$1<INPUT, CONTEXT extends Context>(tool: Tool<INPUT, never, CONTEXT>): Tool<INPUT, never, CONTEXT>;
+declare function tool$1<OUTPUT, CONTEXT extends Context>(tool: Tool<never, OUTPUT, CONTEXT>): Tool<never, OUTPUT, CONTEXT>;
+declare function tool$1<CONTEXT extends Context>(tool: Tool<never, never, CONTEXT>): Tool<never, never, CONTEXT>;
 /**
  * Define a dynamic tool.
  */
-declare function dynamicTool(tool: Omit<DynamicTool<unknown, unknown, Context>, 'type'>): DynamicTool<unknown, unknown, Context>;
-
+export declare function dynamicTool(tool: Omit<DynamicTool<unknown, unknown, Context>, 'type'>): DynamicTool<unknown, unknown, Context>;
+//#endregion
+//#region src/provider-defined-tool-factory.d.ts
 /**
  * A provider-defined tool is a tool for which the provider defines the input
  * and output schemas, but does not execute the tool.
  */
 type ProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}> = <OUTPUT>(options: ARGS & {
-    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
-    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
-    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
-    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
-    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+  needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+  toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+  onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+  onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+  onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
 }) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
-declare function createProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, }: {
-    id: `${string}.${string}`;
-    inputSchema: FlexibleSchema<INPUT>;
+export declare function createProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
 }): ProviderDefinedToolFactory<INPUT, ARGS, CONTEXT>;
 type ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}> = (options: ARGS & {
-    execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-    needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
-    toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
-    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
-    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
-    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  execute?: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
+  needsApproval?: Tool<INPUT, OUTPUT, CONTEXT>['needsApproval'];
+  toModelOutput?: Tool<INPUT, OUTPUT, CONTEXT>['toModelOutput'];
+  onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+  onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+  onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
 }) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
-declare function createProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema, }: {
-    id: `${string}.${string}`;
-    inputSchema: FlexibleSchema<INPUT>;
-    outputSchema: FlexibleSchema<OUTPUT>;
+export declare function createProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
 }): ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT>;
-
+//#endregion
+//#region src/provider-executed-tool-factory.d.ts
 /**
  * A provider-executed tool is a tool for which the provider executes the tool.
  */
 type ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}> = (options: ARGS & {
-    onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
-    onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
-    onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
+  onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
+  onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
+  onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
 }) => ProviderExecutedTool<INPUT, OUTPUT, CONTEXT>;
-declare function createProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema, supportsDeferredResults, }: {
-    id: `${string}.${string}`;
-    inputSchema: FlexibleSchema<INPUT>;
-    outputSchema: FlexibleSchema<OUTPUT>;
-    /**
-     * Whether this provider-executed tool supports deferred results.
-     *
-     * When true, the tool result may not be returned in the same turn as the
-     * tool call (e.g., when using programmatic tool calling where a server tool
-     * triggers a client-executed tool, and the server tool's result is deferred
-     * until the client tool is resolved).
-     *
-     * @default false
-     */
-    supportsDeferredResults?: boolean;
+export declare function createProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema, supportsDeferredResults }: {
+  id: `${string}.${string}`;
+  inputSchema: FlexibleSchema<INPUT>;
+  outputSchema: FlexibleSchema<OUTPUT>;
+  /**
+   * Whether this provider-executed tool supports deferred results.
+   *
+   * When true, the tool result may not be returned in the same turn as the
+   * tool call (e.g., when using programmatic tool calling where a server tool
+   * triggers a client-executed tool, and the server tool's result is deferred
+   * until the client tool is resolved).
+   *
+   * @default false
+   */
+  supportsDeferredResults?: boolean;
 }): ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS, CONTEXT>;
-
+//#endregion
+//#region src/cancel-response-body.d.ts
 /**
  * Cancels a response body to release the underlying connection.
  *
@@ -2241,8 +2394,9 @@ declare function createProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends o
  * Errors thrown while cancelling are ignored: the body may already be locked,
  * disturbed, or absent, none of which should mask the original rejection.
  */
-declare function cancelResponseBody(response: Response): Promise<void>;
-
+export declare function cancelResponseBody(response: Response): Promise<void>;
+//#endregion
+//#region src/read-response-with-size-limit.d.ts
 /**
  * Default maximum download size: 2 GiB.
  *
@@ -2254,7 +2408,7 @@ declare function cancelResponseBody(response: Response): Promise<void>;
  * Setting this limit converts an unrecoverable OOM crash into a catchable
  * `DownloadError`.
  */
-declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
+export declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
 /**
  * Reads a fetch Response body with a size limit to prevent memory exhaustion.
  *
@@ -2268,19 +2422,21 @@ declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
  * @returns A Uint8Array containing the response body.
  * @throws DownloadError if the response exceeds maxBytes.
  */
-declare function readResponseWithSizeLimit({ response, url, maxBytes, }: {
-    response: Response;
-    url: string;
-    maxBytes?: number;
+export declare function readResponseWithSizeLimit({ response, url, maxBytes }: {
+  response: Response;
+  url: string;
+  maxBytes?: number;
 }): Promise<Uint8Array>;
-
+//#endregion
+//#region src/remove-undefined-entries.d.ts
 /**
  * Removes entries from a record where the value is null or undefined.
  * @param record - The input object whose entries may be null or undefined.
  * @returns A new object containing only entries with non-null and non-undefined values.
  */
-declare function removeUndefinedEntries<T>(record: Record<string, T | undefined>): Record<string, T>;
-
+export declare function removeUndefinedEntries<T>(record: Record<string, T | undefined>): Record<string, T>;
+//#endregion
+//#region src/resolve.d.ts
 /**
  * A value or a lazy provider of a value, each of which may be synchronous or asynchronous.
  *
@@ -2296,13 +2452,14 @@ declare function removeUndefinedEntries<T>(record: Record<string, T | undefined>
  * a {@link T} that happens to be a function—callers should wrap function values if disambiguation
  * is required.
  */
-type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
+export type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
 /**
  * Resolves a value that could be a raw value, a Promise, a function returning a value,
  * or a function returning a Promise.
  */
-declare function resolve<T>(value: Resolvable<T>): Promise<T>;
-
+export declare function resolve<T>(value: Resolvable<T>): Promise<T>;
+//#endregion
+//#region src/resolve-full-media-type.d.ts
 /**
  * Resolves a file part's media type to a full `type/subtype` form required by
  * providers whose API demands the full IANA media type.
@@ -2315,45 +2472,48 @@ declare function resolve<T>(value: Resolvable<T>): Promise<T>;
  * - When neither applies (e.g. top-level-only with a URL source, or bytes that
  *   cannot be detected), an `UnsupportedFunctionalityError` is thrown.
  */
-declare function resolveFullMediaType({ part, }: {
-    part: LanguageModelV4FilePart;
+export declare function resolveFullMediaType({ part }: {
+  part: LanguageModelV4FilePart;
 }): string;
-
+//#endregion
+//#region src/resolve-provider-reference.d.ts
 /**
  * Resolves a provider reference to the provider-specific identifier for the
  * given provider. Throws `NoSuchProviderReferenceError` if the provider is not
  * found in the reference mapping.
  */
-declare function resolveProviderReference({ reference, provider, }: {
-    reference: SharedV4ProviderReference;
-    provider: string;
+export declare function resolveProviderReference({ reference, provider }: {
+  reference: SharedV4ProviderReference;
+  provider: string;
 }): string;
-
-type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
-type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable';
-type RetryErrorFactory = ({ message, reason, errors, }: {
-    message: string;
-    reason: RetryErrorReason;
-    errors: Array<unknown>;
+//#endregion
+//#region src/retry-with-exponential-backoff.d.ts
+export type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
+export type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable';
+export type RetryErrorFactory = ({ message, reason, errors }: {
+  message: string;
+  reason: RetryErrorReason;
+  errors: Array<unknown>;
 }) => unknown;
-type RetryDelayProvider = ({ error, exponentialBackoffDelay, }: {
-    error: unknown;
-    exponentialBackoffDelay: number;
+export type RetryDelayProvider = ({ error, exponentialBackoffDelay }: {
+  error: unknown;
+  exponentialBackoffDelay: number;
 }) => number;
-type ShouldRetryFunction = (error: unknown) => boolean | Promise<boolean>;
+export type ShouldRetryFunction = (error: unknown) => boolean | Promise<boolean>;
 /**
  * Retries a failed operation with exponential backoff.
  */
-declare const retryWithExponentialBackoff: ({ maxRetries, initialDelayInMs, backoffFactor, abortSignal, shouldRetry, getDelayInMs, createRetryError, }: {
-    maxRetries?: number;
-    initialDelayInMs?: number;
-    backoffFactor?: number;
-    abortSignal?: AbortSignal;
-    shouldRetry: ShouldRetryFunction;
-    getDelayInMs?: RetryDelayProvider;
-    createRetryError?: RetryErrorFactory;
+export declare const retryWithExponentialBackoff: ({ maxRetries, initialDelayInMs, backoffFactor, abortSignal, shouldRetry, getDelayInMs, createRetryError }: {
+  maxRetries?: number;
+  initialDelayInMs?: number;
+  backoffFactor?: number;
+  abortSignal?: AbortSignal;
+  shouldRetry: ShouldRetryFunction;
+  getDelayInMs?: RetryDelayProvider;
+  createRetryError?: RetryErrorFactory;
 }) => RetryFunction;
-
+//#endregion
+//#region src/serialize-model-options.d.ts
 /**
  * Serializes a model instance for workflow step boundaries.
  * Returns the `modelId` plus the JSON-serializable config properties.
@@ -2374,66 +2534,70 @@ declare const retryWithExponentialBackoff: ({ maxRetries, initialDelayInMs, back
  * }
  * ```
  */
-declare function serializeModelOptions<CONFIG extends {
-    headers?: Resolvable<Record<string, string | undefined>>;
+export declare function serializeModelOptions<CONFIG extends {
+  headers?: Resolvable<Record<string, string | undefined>>;
 }>(options: {
-    modelId: string;
-    config: CONFIG;
+  modelId: string;
+  config: CONFIG;
 }): {
-    modelId: string;
-    config: JSONObject;
+  modelId: string;
+  config: JSONObject;
 };
-
+//#endregion
+//#region src/serialization-error.d.ts
 declare const symbol: unique symbol;
-declare class SerializationError extends AISDKError {
-    private readonly [symbol];
-    constructor({ message, cause, }?: {
-        message?: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is SerializationError;
+export declare class SerializationError extends AISDKError {
+  private readonly [symbol];
+  constructor({ message, cause }?: {
+    message?: string;
+    cause?: unknown;
+  });
+  static isInstance(error: unknown): error is SerializationError;
 }
-
-declare function secureJsonParse(text: string): any;
-
+//#endregion
+//#region src/secure-json-parse.d.ts
+export declare function secureJsonParse(text: string): any;
+//#endregion
+//#region src/streaming-tool-call-tracker.d.ts
 /**
  * Minimal interface for a streaming tool call delta from an OpenAI-compatible API.
  */
 interface StreamingToolCallDelta {
-    index?: number | null;
-    id?: string | null;
-    type?: string | null;
-    function?: {
-        name?: string | null;
-        arguments?: string | null;
-    } | null;
+  index?: number | null;
+  id?: string | null;
+  type?: string | null;
+  function?: {
+    name?: string | null;
+    arguments?: string | null;
+  } | null;
 }
 interface StreamingToolCallTrackerOptions<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
-    /**
-     * ID generator function for tool call IDs.
-     * Defaults to the standard generateId.
-     */
-    generateId?: () => string;
-    /**
-     * How to validate the `type` field on new tool call deltas.
-     * - `'none'`: no validation (default)
-     * - `'if-present'`: throw if type is present and not `'function'`
-     * - `'required'`: throw if type is not exactly `'function'`
-     */
-    typeValidation?: 'none' | 'if-present' | 'required';
-    /**
-     * Extract provider-specific metadata from a tool call delta.
-     * Called once when a new tool call is detected.
-     * The returned metadata is stored on the tool call and passed to
-     * `buildToolCallProviderMetadata` when the tool call is finalized.
-     */
-    extractMetadata?: (delta: DELTA) => SharedV4ProviderMetadata | undefined;
-    /**
-     * Build the `providerMetadata` object for a `tool-call` event.
-     * Receives the metadata previously extracted via `extractMetadata`.
-     * If `undefined` is returned, no `providerMetadata` is included in the event.
-     */
-    buildToolCallProviderMetadata?: (metadata: SharedV4ProviderMetadata | undefined) => SharedV4ProviderMetadata | undefined;
+  /**
+   * ID generator function for tool call IDs.
+   * Blank or repeated outputs are converted to usable unique IDs.
+   * Defaults to the standard generateId.
+   */
+  generateId?: () => string;
+  /**
+   * How to validate the `type` field on new tool call deltas.
+   * - `'none'`: no validation (default)
+   * - `'if-present'`: throw if type is present and not `'function'`
+   * - `'required'`: throw if type is not exactly `'function'`
+   */
+  typeValidation?: 'none' | 'if-present' | 'required';
+  /**
+   * Extract provider-specific metadata from a tool call delta.
+   * Called once when a new tool call is detected.
+   * The returned metadata is stored on the tool call and passed to
+   * `buildToolCallProviderMetadata` when the tool call is finalized.
+   */
+  extractMetadata?: (delta: DELTA) => SharedV4ProviderMetadata | undefined;
+  /**
+   * Build the `providerMetadata` object for a `tool-call` event.
+   * Receives the metadata previously extracted via `extractMetadata`.
+   * If `undefined` is returned, no `providerMetadata` is included in the event.
+   */
+  buildToolCallProviderMetadata?: (metadata: SharedV4ProviderMetadata | undefined) => SharedV4ProviderMetadata | undefined;
 }
 type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<LanguageModelV4StreamPart>, 'enqueue'>;
 /**
@@ -2442,35 +2606,58 @@ type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<
  * emits tool-input-start/delta/end and tool-call events, and finalizes
  * unfinished tool calls on flush.
  *
- * Used by openai, openai-compatible, groq, deepseek, and alibaba providers.
- */
-declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
-    private toolCalls;
-    private toolCallsById;
-    private toolCallsByIndex;
-    private latestToolCall;
-    private readonly controller;
-    private readonly _generateId;
-    private readonly typeValidation;
-    private readonly extractMetadata?;
-    private readonly buildToolCallProviderMetadata?;
-    constructor(controller: StreamingToolCallTrackerController, options?: StreamingToolCallTrackerOptions<DELTA>);
-    /**
-     * Process a tool call delta from a streaming response chunk.
-     * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
-     * events as appropriate.
-     */
-    processDelta(toolCallDelta: DELTA): void;
-    /**
-     * Finalize any unfinished tool calls. Should be called during the stream's
-     * flush handler to ensure all tool calls are properly completed.
-     */
-    flush(): void;
-    private processNewToolCall;
-    private processExistingToolCall;
-    private finishToolCall;
+ * Used by openai, openai-compatible, groq, deepseek, alibaba, mistral, and
+ * moonshotai providers.
+ */
+export declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = StreamingToolCallDelta> {
+  private toolCalls;
+  private toolCallsById;
+  private toolCallsByIndex;
+  private usedToolCallIds;
+  private nextGeneratedIdSuffixes;
+  private readonly controller;
+  private readonly _generateId;
+  private readonly typeValidation;
+  private readonly extractMetadata?;
+  private readonly buildToolCallProviderMetadata?;
+  constructor(controller: StreamingToolCallTrackerController, options?: StreamingToolCallTrackerOptions<DELTA>);
+  /**
+   * Process a tool call delta from a streaming response chunk.
+   * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
+   * events as appropriate.
+   */
+  processDelta(toolCallDelta: DELTA): void;
+  /**
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
+   */
+  flush(): void;
+  /**
+   * Correlation precedence for streamed deltas:
+   *
+   * | ID evidence | index/name evidence | start evidence | resolution |
+   * | --- | --- | --- | --- |
+   * | known | matching | any | matching call, new call, or ambiguity |
+   * | known | conflicting | named | new call |
+   * | unseen | matching | structured start | new call |
+   * | unseen | matching | continuation | matching call or ambiguity |
+   * | absent | matching | any | matching call, new call, or ambiguity |
+   * | absent | absent | named | new call |
+   * | absent | absent | unnamed | sole unfinished call, new call, or ambiguity |
+   */
+  private resolveToolCall;
+  private filterToolCallsByName;
+  private resolveMatchingToolCall;
+  private processNewToolCall;
+  private associateWireId;
+  private associateIndex;
+  private createToolCallId;
+  private getNonBlankString;
+  private processExistingToolCall;
+  private finishToolCall;
 }
-
+//#endregion
+//#region src/strip-file-extension.d.ts
 /**
  * Strips file extension segments from a filename.
  *
@@ -2479,8 +2666,9 @@ declare class StreamingToolCallTracker<DELTA extends StreamingToolCallDelta = St
  * - "archive.tar.gz" -> "archive"
  * - "filename" -> "filename"
  */
-declare function stripFileExtension(filename: string): string;
-
+export declare function stripFileExtension(filename: string): string;
+//#endregion
+//#region src/transcription-stream-envelope.d.ts
 /**
  * Experimental transcription-stream WebSocket envelope (v1): the standard
  * serialization of `TranscriptionModelV4.doStream` over a WebSocket. Clients
@@ -2526,30 +2714,30 @@ declare const TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE = "transcription-stream
  * The client's session start frame. Optional keys are omitted when undefined.
  */
 type TranscriptionStreamStartFrame = {
-    type: typeof TRANSCRIPTION_STREAM_START_FRAME_TYPE;
-    /** Audio format of the binary audio frames, e.g. `{ type: 'audio/pcm', rate: 16000 }`. */
-    inputAudioFormat: {
-        type: string;
-        rate?: number;
-    };
-    /** Provider-specific options, passed through verbatim. */
-    providerOptions?: Record<string, JSONObject>;
-    /** When true, the server should include `raw` parts in the stream. */
-    includeRawChunks?: boolean;
+  type: typeof TRANSCRIPTION_STREAM_START_FRAME_TYPE;
+  /** Audio format of the binary audio frames, e.g. `{ type: 'audio/pcm', rate: 16000 }`. */
+  inputAudioFormat: {
+    type: string;
+    rate?: number;
+  };
+  /** Provider-specific options, passed through verbatim. */
+  providerOptions?: Record<string, JSONObject>;
+  /** When true, the server should include `raw` parts in the stream. */
+  includeRawChunks?: boolean;
 };
 /** Server-side classification of a client TEXT frame. */
 type TranscriptionStreamClientFrame = {
-    type: 'start';
-    frame: TranscriptionStreamStartFrame;
+  type: 'start';
+  frame: TranscriptionStreamStartFrame;
 } | {
-    type: 'audio-done';
+  type: 'audio-done';
 } | {
-    /** Malformed JSON or a recognized frame with an invalid shape. */
-    type: 'invalid';
-    message: string;
+  /** Malformed JSON or a recognized frame with an invalid shape. */
+  type: 'invalid';
+  message: string;
 } | {
-    /** Unrecognized frame type; ignore for forward compatibility. */
-    type: 'unknown';
+  /** Unrecognized frame type; ignore for forward compatibility. */
+  type: 'unknown';
 };
 /**
  * Server-side: parse a client TEXT frame. Validates envelope shape only and
@@ -2576,13 +2764,16 @@ declare function serializeTranscriptionStreamPart(part: Experimental_Transcripti
  * Revives `response-metadata.timestamp` to a `Date`.
  */
 declare function parseTranscriptionStreamPart(text: string): Experimental_TranscriptionModelV4StreamPart | undefined;
-
-declare function convertBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;
-declare function convertUint8ArrayToBase64(array: Uint8Array): string;
-declare function convertToBase64(value: string | Uint8Array): string;
-
-declare function validateBaseURL(baseURL: string | undefined): string | undefined;
-
+//#endregion
+//#region src/uint8-utils.d.ts
+export declare function convertBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;
+export declare function convertUint8ArrayToBase64(array: Uint8Array): string;
+export declare function convertToBase64(value: string | Uint8Array): string;
+//#endregion
+//#region src/validate-base-url.d.ts
+export declare function validateBaseURL(baseURL: string | undefined): string | undefined;
+//#endregion
+//#region src/validate-download-url.d.ts
 /**
  * Validates that a URL is safe to download from, blocking private/internal addresses
  * to prevent SSRF attacks.
@@ -2593,8 +2784,9 @@ declare function validateBaseURL(baseURL: string | undefined): string | undefine
  * @param url - The URL string to validate.
  * @throws DownloadError if the URL is unsafe.
  */
-declare function validateDownloadUrl(url: string): void;
-
+export declare function validateDownloadUrl(url: string): void;
+//#endregion
+//#region src/validate-types.d.ts
 /**
  * Validates the types of an unknown object using a schema and
  * return a strongly-typed object.
@@ -2605,10 +2797,10 @@ declare function validateDownloadUrl(url: string): void;
  * @param {TypeValidationContext} options.context - Optional context about what is being validated.
  * @returns {Promise<T>} - The typed object.
  */
-declare function validateTypes<OBJECT>({ value, schema, context, }: {
-    value: unknown;
-    schema: FlexibleSchema<OBJECT>;
-    context?: TypeValidationContext;
+export declare function validateTypes<OBJECT>({ value, schema, context }: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+  context?: TypeValidationContext;
 }): Promise<OBJECT>;
 /**
  * Safely validates the types of an unknown object using a schema and
@@ -2620,22 +2812,24 @@ declare function validateTypes<OBJECT>({ value, schema, context, }: {
  * @param {TypeValidationContext} options.context - Optional context about what is being validated.
  * @returns An object with either a `success` flag and the parsed and typed data, or a `success` flag and an error object.
  */
-declare function safeValidateTypes<OBJECT>({ value, schema, context, }: {
-    value: unknown;
-    schema: FlexibleSchema<OBJECT>;
-    context?: TypeValidationContext;
+export declare function safeValidateTypes<OBJECT>({ value, schema, context }: {
+  value: unknown;
+  schema: FlexibleSchema<OBJECT>;
+  context?: TypeValidationContext;
 }): Promise<{
-    success: true;
-    value: OBJECT;
-    rawValue: unknown;
+  success: true;
+  value: OBJECT;
+  rawValue: unknown;
 } | {
-    success: false;
-    error: TypeValidationError;
-    rawValue: unknown;
+  success: false;
+  error: TypeValidationError;
+  rawValue: unknown;
 }>;
-
-declare const VERSION: string;
-
+//#endregion
+//#region src/version.d.ts
+export declare const VERSION: string;
+//#endregion
+//#region src/with-user-agent-suffix.d.ts
 /**
  * Appends suffix parts to the `user-agent` header.
  * If a `user-agent` header already exists, the suffix parts are appended to it.
@@ -2646,10 +2840,12 @@ declare const VERSION: string;
  * @param userAgentSuffixParts - The parts to append to the `user-agent` header.
  * @returns The new headers with the `user-agent` header set or updated.
  */
-declare function withUserAgentSuffix(headers: HeadersInit | Record<string, string | undefined> | undefined, ...userAgentSuffixParts: string[]): Record<string, string>;
-
-declare function withoutTrailingSlash(url: string | undefined): string | undefined;
-
+export declare function withUserAgentSuffix(headers: HeadersInit | Record<string, string | undefined> | undefined, ...userAgentSuffixParts: string[]): Record<string, string>;
+//#endregion
+//#region src/without-trailing-slash.d.ts
+export declare function withoutTrailingSlash(url: string | undefined): string | undefined;
+//#endregion
+//#region src/types/infer-tool-context.d.ts
 /**
  * Detects the `any` type so untyped tools can be treated as having no explicit
  * context type.
@@ -2669,17 +2865,20 @@ type IsUntypedContext<CONTEXT> = IsAny<CONTEXT> extends true ? true : unknown ex
  * Infer the context type of a tool.
  */
 type InferToolContext<TOOL extends Tool> = TOOL extends Tool<any, any, infer CONTEXT> ? IsUntypedContext<CONTEXT> extends true ? never : CONTEXT : never;
-
+//#endregion
+//#region src/types/infer-tool-input.d.ts
 /**
  * Infer the input type of a tool.
  */
 type InferToolInput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<infer INPUT, any, any> ? INPUT : never;
-
+//#endregion
+//#region src/types/infer-tool-output.d.ts
 /**
  * Infer the output type of a tool.
  */
 type InferToolOutput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<any, infer OUTPUT, any> ? OUTPUT : never;
-
+//#endregion
+//#region src/types/execute-tool.d.ts
 /**
  * Executes a tool function and normalizes its results into a stream of outputs.
  *
@@ -2694,44 +2893,40 @@ type InferToolOutput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<any,
  * @yields A preliminary output for each streamed value, followed by a final output, or a single final
  * output for non-streaming tools.
  */
-declare function executeTool<TOOL extends Tool>({ tool, input, options, }: {
-    tool: ExecutableTool<TOOL>;
-    input: InferToolInput<TOOL>;
-    options: ToolExecutionOptions<InferToolContext<TOOL>>;
+export declare function executeTool<TOOL extends Tool>({ tool, input, options }: {
+  tool: ExecutableTool<TOOL>;
+  input: InferToolInput<TOOL>;
+  options: ToolExecutionOptions<InferToolContext<TOOL>>;
 }): AsyncGenerator<{
-    type: 'preliminary';
-    output: InferToolOutput<TOOL>;
+  type: 'preliminary';
+  output: InferToolOutput<TOOL>;
 } | {
-    type: 'final';
-    output: InferToolOutput<TOOL>;
+  type: 'final';
+  output: InferToolOutput<TOOL>;
 }>;
-
+//#endregion
+//#region src/types/tool-set.d.ts
 /**
  * A mapping of tool names to tool definitions.
  */
 type ToolSet = Record<string, (Tool<never, never, any> | Tool<any, any, any> | Tool<any, never, any> | Tool<never, any, any>) & Pick<Tool<any, any, any>, 'execute' | 'onInputAvailable' | 'onInputStart' | 'onInputDelta' | 'needsApproval'>>;
-
+//#endregion
+//#region src/types/infer-tool-set-context.d.ts
 /**
  * Builds the required portion of the tool context map for tools whose context
  * type does not include `undefined`.
  */
-type RequiredToolSetContext<TOOLS extends ToolSet> = {
-    [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? never : K]: InferToolContext<NoInfer<TOOLS[K]>>;
-};
+type RequiredToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? never : K]: InferToolContext<NoInfer<TOOLS[K]>>; };
 /**
  * Builds the optional portion of the tool context map for tools whose context
  * object itself may be `undefined`.
  */
-type OptionalToolSetContext<TOOLS extends ToolSet> = {
-    [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? K : never]?: InferToolContext<NoInfer<TOOLS[K]>>;
-};
+type OptionalToolSetContext<TOOLS extends ToolSet> = { [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : undefined extends InferToolContext<NoInfer<TOOLS[K]>> ? K : never]?: InferToolContext<NoInfer<TOOLS[K]>>; };
 /**
  * Flattens intersected mapped types so type equality assertions and editor
  * hovers show the resulting object shape.
  */
-type Normalize<OBJECT> = {
-    [KEY in keyof OBJECT]: OBJECT[KEY];
-};
+type Normalize<OBJECT> = { [KEY in keyof OBJECT]: OBJECT[KEY]; };
 /**
  * Infer the context type for a tool set.
  *
@@ -2741,85 +2936,89 @@ type Normalize<OBJECT> = {
  * `undefined` are represented as optional properties.
  */
 type InferToolSetContext<TOOLS extends ToolSet> = Normalize<RequiredToolSetContext<TOOLS> & OptionalToolSetContext<TOOLS>>;
-
+//#endregion
+//#region src/types/tool-call.d.ts
 /**
  * Typed tool call that is returned by generateText and streamText.
  * It contains the tool call ID, the tool name, and the tool arguments.
  */
 interface ToolCall<NAME extends string, INPUT> {
-    /**
-     * ID of the tool call. This ID is used to match the tool call with the tool result.
-     */
-    toolCallId: string;
-    /**
-     * Name of the tool that is being called.
-     */
-    toolName: NAME;
-    /**
-     * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
-     */
-    input: INPUT;
-    /**
-     * Whether the tool call will be executed by the provider.
-     * If this flag is not set or is false, the tool call will be executed by the client.
-     */
-    providerExecuted?: boolean;
-    /**
-     * Whether the tool is dynamic.
-     */
-    dynamic?: boolean;
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+  /**
+   * Name of the tool that is being called.
+   */
+  toolName: NAME;
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: INPUT;
+  /**
+   * Whether the tool call will be executed by the provider.
+   * If this flag is not set or is false, the tool call will be executed by the client.
+   */
+  providerExecuted?: boolean;
+  /**
+   * Whether the tool is dynamic.
+   */
+  dynamic?: boolean;
 }
-
+//#endregion
+//#region src/types/tool-caller.d.ts
 type ToolCallerDefinition = {
-    type: 'local';
-    bind: (tools: ToolSet) => Tool;
-    /**
-     * Creates a provider-agnostic user message that describes the tools
-     * available through this caller. When present, the unbound caller tool
-     * remains model-visible so its definition stays stable, while the
-     * returned message is added to the conversation when its content has
-     * not already been announced.
-     */
-    prepareModelMessage?: (tools: ToolSet) => string | undefined;
+  type: 'local';
+  bind: (tools: ToolSet) => Tool;
+  /**
+   * Creates a provider-agnostic user message that describes the tools
+   * available through this caller. When present, the unbound caller tool
+   * remains model-visible so its definition stays stable, while the
+   * returned message is added to the conversation when its content has
+   * not already been announced.
+   */
+  prepareModelMessage?: (tools: ToolSet) => string | undefined;
 } | {
-    type: 'provider';
-    prepareProviderOptions: (providerOptions: ProviderOptions | undefined) => ProviderOptions;
+  type: 'provider';
+  prepareProviderOptions: (providerOptions: ProviderOptions | undefined) => ProviderOptions;
 };
 type ToolCallerTool<TOOL extends Tool = Tool> = TOOL & {
-    readonly experimental_toolCaller: ToolCallerDefinition;
+  readonly experimental_toolCaller: ToolCallerDefinition;
 };
 declare function toolCaller<TOOL extends Tool>(tool: TOOL, definition: ToolCallerDefinition): ToolCallerTool<TOOL>;
 declare function getToolCaller(tool: Tool | undefined): ToolCallerDefinition | undefined;
-
+//#endregion
+//#region src/types/tool-result.d.ts
 /**
  * Typed tool result that is returned by `generateText` and `streamText`.
  * It contains the tool call ID, the tool name, the tool arguments, and the tool result.
  */
 interface ToolResult<NAME extends string, INPUT, OUTPUT> {
-    /**
-     * ID of the tool call. This ID is used to match the tool call with the tool result.
-     */
-    toolCallId: string;
-    /**
-     * Name of the tool that was called.
-     */
-    toolName: NAME;
-    /**
-     * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
-     */
-    input: INPUT;
-    /**
-     * Result of the tool call. This is the result of the tool's execution.
-     */
-    output: OUTPUT;
-    /**
-     * Whether the tool result has been executed by the provider.
-     */
-    providerExecuted?: boolean;
-    /**
-     * Whether the tool is dynamic.
-     */
-    dynamic?: boolean;
+  /**
+   * ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+  toolCallId: string;
+  /**
+   * Name of the tool that was called.
+   */
+  toolName: NAME;
+  /**
+   * Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+   */
+  input: INPUT;
+  /**
+   * Result of the tool call. This is the result of the tool's execution.
+   */
+  output: OUTPUT;
+  /**
+   * Whether the tool result has been executed by the provider.
+   */
+  providerExecuted?: boolean;
+  /**
+   * Whether the tool is dynamic.
+   */
+  dynamic?: boolean;
 }
-
-export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type DynamicTool, EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, TRANSCRIPTION_STREAM_START_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, type ExecutableTool, type SandboxProcess as Experimental_SandboxProcess, type SandboxSession as Experimental_SandboxSession, type ToolCallerDefinition as Experimental_ToolCallerDefinition, type ToolCallerTool as Experimental_ToolCallerTool, type TranscriptionStreamClientFrame as Experimental_TranscriptionStreamClientFrame, type TranscriptionStreamStartFrame as Experimental_TranscriptionStreamStartFrame, type FetchFunction, type FileData, type FileDataData, type FileDataReference, type FileDataText, type FileDataUrl, type FilePart, type FlexibleSchema, type FunctionTool, type HasRequiredKey, type IdGenerator, type ImagePart, type InferSchema, type InferToolContext, type InferToolInput, type InferToolOutput, type InferToolSetContext, type LazySchema, type MaybePromiseLike, type ModelMessage, type MultipartStreamPart, type ParseResult, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ProviderStreamError, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type RetryDelayProvider, type RetryErrorFactory, type RetryErrorReason, type RetryFunction, type Schema, SerializationError, type ShouldRetryFunction, type StreamingToolCallDelta, StreamingToolCallTracker, type StreamingToolCallTrackerOptions, type SystemModelMessage, type TextPart, type Tool, type ToolApprovalRequest, type ToolApprovalResponse, type ToolCall, type ToolCallPart, type ToolContent, type ToolExecuteFunction, type ToolExecutionOptions, type ToolModelMessage, type ToolNameMapping, type ToolNeedsApprovalFunction, type ToolResult, type ToolResultOutput, type ToolResultPart, type ToolSet, type UserContent, type UserModelMessage, VERSION, type ValidationResult, type WebSocketConnection, type WebSocketConstructor, type WebSocketLike, asArray, asSchema, cancelResponseBody, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createBinaryStreamResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, deleteFromApi, detectMediaType, downloadBlob, dynamicTool, executeTool, getToolCaller as experimental_getToolCaller, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, toolCaller as experimental_toolCaller, extractLines, extractResponseHeaders, fetchWithValidatedEndpoint, fetchWithValidatedRedirects, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, getWebSocketConstructor, injectJsonInstructionIntoMessages, isAbortError, isBrowserRuntime, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isProviderStreamError, isRecord, isSameOrigin, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeBatchRequestCounts, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postMultipartStreamToApi, postToApi, readResponseWithSizeLimit, readWebSocketMessageText, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, retryWithExponentialBackoff, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stripFileExtension, toWebSocketUrl, tool, validateBaseURL, validateDownloadUrl, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema };
+//#endregion
+export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, type DataContent, type DynamicTool, EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL as EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER as EXPERIMENTAL_EMBEDDING_MODEL_PROVIDER_OPTIONS_TRANSFORMER, TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_AUDIO_DONE_FRAME_TYPE, TRANSCRIPTION_STREAM_START_FRAME_TYPE as EXPERIMENTAL_TRANSCRIPTION_STREAM_START_FRAME_TYPE, type EmbeddingModelProviderOptionsTransformer, type EventSourceMessage, EventSourceParserStream, type ExecutableTool, type SandboxProcess as Experimental_SandboxProcess, type SandboxSession as Experimental_SandboxSession, type ToolCallerDefinition as Experimental_ToolCallerDefinition, type ToolCallerTool as Experimental_ToolCallerTool, type TranscriptionStreamClientFrame as Experimental_TranscriptionStreamClientFrame, type TranscriptionStreamStartFrame as Experimental_TranscriptionStreamStartFrame, type FileData, type FileDataData, type FileDataReference, type FileDataText, type FileDataUrl, type FilePart, type FlexibleSchema, type FunctionTool, type HasRequiredKey, type IdGenerator, type ImagePart, type InferSchema, type InferToolContext, type InferToolInput, type InferToolOutput, type InferToolSetContext, type LazySchema, type MaybePromiseLike, type ModelMessage, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ProviderStreamError, type ReasoningFilePart, type ReasoningPart, type Schema, type StreamingToolCallDelta, type StreamingToolCallTrackerOptions, type SystemModelMessage, type TextPart, type Tool, type ToolApprovalRequest, type ToolApprovalResponse, type ToolCall, type ToolCallPart, type ToolContent, type ToolExecuteFunction, type ToolExecutionOptions, type ToolModelMessage, type ToolNameMapping, type ToolNeedsApprovalFunction, type ToolResult, type ToolResultOutput, type ToolResultPart, type ToolSet, type UserContent, type UserModelMessage, type ValidationResult, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, type WebSocketConnection, type WebSocketConstructor, type WebSocketLike, getToolCaller as experimental_getToolCaller, parseTranscriptionStreamClientFrame as experimental_parseTranscriptionStreamClientFrame, parseTranscriptionStreamPart as experimental_parseTranscriptionStreamPart, serializeTranscriptionStreamPart as experimental_serializeTranscriptionStreamPart, toolCaller as experimental_toolCaller, getErrorMessage, tool$1 as tool };
+//# sourceMappingURL=index.d.ts.map