@ai-sdk/provider-utils 5.0.0-beta.9 → 5.0.0-canary.32

package/dist/index.d.ts

@@ -1,10 +1,22 @@
-import { LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, ImageModelV4File, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, JSONValue, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, SharedV4ProviderOptions, TypeValidationContext } from '@ai-sdk/provider';
+import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, SharedV4ProviderMetadata, LanguageModelV4FilePart, JSONObject, LanguageModelV4StreamPart, TypeValidationContext } from '@ai-sdk/provider';
+export { getErrorMessage } from '@ai-sdk/provider';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
 export * from '@standard-schema/spec';
 import * as z3 from 'zod/v3';
 import * as z4 from 'zod/v4';
+export { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
 export { EventSourceMessage, EventSourceParserStream } from 'eventsource-parser/stream';
 
+/**
+ * A value that can be provided either as a single item, an array of items,
+ * or be left undefined.
+ */
+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>;
 
 /**
@@ -17,795 +29,310 @@ declare function combineHeaders(...headers: Array<Record<string, string | undefi
 declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
 
 /**
- * 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;
-}
-/**
- * @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>;
-}): ToolNameMapping;
-
-/**
- * Creates a Promise that resolves after a specified delay
- * @param delayInMs - The delay duration in milliseconds. If null or undefined, resolves immediately.
- * @param signal - Optional AbortSignal to cancel the delay
- * @returns A Promise that resolves after the specified delay
- * @throws {DOMException} When the signal is aborted
+ * Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
  */
-declare function delay(delayInMs?: number | null, options?: {
-    abortSignal?: AbortSignal;
-}): Promise<void>;
+type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
 
 /**
- * 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.
+ * File data variant containing raw bytes (`Uint8Array`, `ArrayBuffer`, or
+ * `Buffer`) or a base64-encoded string.
+ *
+ * This is slightly more permissive than `SharedV4FileDataData`.
  */
-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;
+interface FileDataData {
+    type: 'data';
+    data: DataContent;
 }
-
 /**
- * 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.
+ * File data variant containing a URL that points to the file.
  */
-declare function extractResponseHeaders(response: Response): {
-    [k: string]: string;
-};
-
+type FileDataUrl = SharedV4FileDataUrl;
 /**
- * Convert an ImageModelV4File to a URL or data URI string.
- *
- * If the file is a URL, it returns the URL as-is.
- * 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.
+ * File data variant containing a provider reference (`{ [provider]: id }`).
  */
-declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
-
+type FileDataReference = SharedV4FileDataReference;
 /**
- * Converts an input object to FormData for multipart/form-data requests.
- *
- * Handles the following cases:
- * - `null` or `undefined` values are skipped
- * - Arrays with a single element are appended as a single value
- * - Arrays with multiple elements are appended with `[]` suffix (e.g., `image[]`)
- *   unless `useArrayBrackets` is set to `false`
- * - All other values are appended directly
- *
- * @param input - The input object to convert. Use a generic type for type validation.
- * @param options - Optional configuration object.
- * @param options.useArrayBrackets - Whether to add `[]` suffix for multi-element arrays.
- *   Defaults to `true`. Set to `false` for APIs that expect repeated keys without brackets.
- * @returns A FormData object containing the input values.
- *
- * @example
- * ```ts
- * type MyInput = {
- *   model: string;
- *   prompt: string;
- *   images: Blob[];
- * };
- *
- * const formData = convertToFormData<MyInput>({
- *   model: 'gpt-image-1',
- *   prompt: 'A cat',
- *   images: [blob1, blob2],
- * });
- * ```
+ * File data variant containing inline text content (e.g. an inline text
+ * document).
  */
-declare function convertToFormData<T extends Record<string, unknown>>(input: T, options?: {
-    useArrayBrackets?: boolean;
-}): FormData;
-
+type FileDataText = SharedV4FileDataText;
 /**
- * Download a file from a URL and return it as a Blob.
- *
- * @param url - The URL to download from.
- * @param options - Optional settings for the download.
- * @param options.maxBytes - Maximum allowed download size in bytes. Defaults to 100 MiB.
- * @param options.abortSignal - An optional abort signal to cancel the download.
- * @returns A Promise that resolves to the downloaded Blob.
+ * File data as a tagged discriminated union:
  *
- * @throws DownloadError if the download fails or exceeds maxBytes.
+ * - `{ type: 'data', data }`: raw bytes (`Uint8Array`, `ArrayBuffer`, or
+ *   `Buffer`) or a base64-encoded string.
+ * - `{ type: 'url', url }`: a URL that points to the file.
+ * - `{ type: 'reference', reference }`: a provider reference (`{ [provider]: id }`).
+ * - `{ type: 'text', text }`: inline text content (e.g. an inline text document).
  */
-declare function downloadBlob(url: string, options?: {
-    maxBytes?: number;
-    abortSignal?: AbortSignal;
-}): Promise<Blob>;
-
-declare const symbol: unique symbol;
-declare class DownloadError extends AISDKError {
-    private readonly [symbol];
-    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;
-}
+type FileData = FileDataData | FileDataUrl | FileDataReference | FileDataText;
 
 /**
- * Default maximum download size: 2 GiB.
- *
- * `fetch().arrayBuffer()` has ~2x peak memory overhead (undici buffers the
- * body internally, then creates the JS ArrayBuffer), so very large downloads
- * risk exceeding the default V8 heap limit on 64-bit systems and terminating
- * the process with an out-of-memory error.
+ * Additional provider-specific options.
  *
- * Setting this limit converts an unrecoverable OOM crash into a catchable
- * `DownloadError`.
+ * They are passed through to the provider from the AI SDK and enable
+ * provider-specific functionality that can be fully encapsulated in the provider.
  */
-declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
+type ProviderOptions = SharedV4ProviderOptions;
+
 /**
- * Reads a fetch Response body with a size limit to prevent memory exhaustion.
- *
- * Checks the Content-Length header for early rejection, then reads the body
- * incrementally via ReadableStream and aborts with a DownloadError when the
- * limit is exceeded.
+ * A mapping of provider names to provider-specific file identifiers.
  *
- * @param response - The fetch Response to read.
- * @param url - The URL being downloaded (used in error messages).
- * @param maxBytes - Maximum allowed bytes. Defaults to DEFAULT_MAX_DOWNLOAD_SIZE.
- * @returns A Uint8Array containing the response body.
- * @throws DownloadError if the response exceeds maxBytes.
+ * Provider references allow files to be identified across different
+ * providers without re-uploading, by storing each provider's own
+ * identifier for the same logical file.
  */
-declare function readResponseWithSizeLimit({ response, url, maxBytes, }: {
-    response: Response;
-    url: string;
-    maxBytes?: number;
-}): Promise<Uint8Array>;
+type ProviderReference = SharedV4ProviderReference;
 
 /**
- * Fetch function type (standardizes the version of fetch used).
+ * Text content part of a prompt. It contains a string of text.
  */
-type FetchFunction = typeof globalThis.fetch;
-
+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;
+}
 /**
- * Creates an ID generator.
- * The total length of the ID is the sum of the prefix, separator, and random part length.
- * Not cryptographically secure.
+ * Image content part of a prompt. It contains an image.
  *
- * @param alphabet - The alphabet to use for the ID. Default: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
- * @param prefix - The prefix of the ID to generate. Optional.
- * @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;
-}) => IdGenerator;
-/**
- * A function that generates an ID.
- */
-type IdGenerator = () => string;
-/**
- * Generates a 16-character random string to use for IDs.
- * Not cryptographically secure.
- */
-declare const generateId: IdGenerator;
-
-declare function getErrorMessage(error: unknown | undefined): string;
-
-/**
- * Used to mark schemas so we can support both Zod and custom schemas.
+ * @deprecated Use `FilePart` with `mediaType: 'image'` instead:
+ * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
  */
-declare const schemaSymbol: unique symbol;
-type ValidationResult<OBJECT> = {
-    success: true;
-    value: OBJECT;
-} | {
-    success: false;
-    error: Error;
-};
-type Schema<OBJECT = unknown> = {
+interface ImagePart {
+    type: 'image';
     /**
-     * Used to mark schemas so we can support both Zod and custom schemas.
+     * 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`
      */
-    [schemaSymbol]: true;
+    image: DataContent | URL | ProviderReference;
     /**
-     * Schema type for inference.
+     * Optional IANA media type of the image.
+     *
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    _type: OBJECT;
+    mediaType?: string;
     /**
-     * Optional. Validates that the structure of a value matches this schema,
-     * and returns a typed version of the value if it does.
+     * 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.
      */
-    readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+    providerOptions?: ProviderOptions;
+}
+/**
+ * File content part of a prompt. It contains a file.
+ */
+interface FilePart {
+    type: 'file';
     /**
-     * The JSON Schema for the schema. It is passed to the providers.
+     * 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)
      */
-    readonly jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
-};
-/**
- * Creates a schema with deferred creation.
- * This is important to reduce the startup time of the library
- * and to avoid initializing unused validators.
- *
- * @param createValidator A function that creates a schema.
- * @returns A function that returns a schema.
- */
-declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
-type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
-type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | z4.core.$ZodType<SCHEMA, any>;
-type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & StandardJSONSchemaV1<unknown, SCHEMA>;
-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;
-/**
- * Create a schema using a JSON Schema.
- *
- * @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>>;
-}): Schema<OBJECT>;
-declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
-declare function zodSchema<OBJECT>(zodSchema: z4.core.$ZodType<OBJECT, any> | z3.Schema<OBJECT, z3.ZodTypeDef, any>, options?: {
+    data: FileData | DataContent | URL | ProviderReference;
     /**
-     * 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`.
+     * Optional filename of the file.
      */
-    useReferences?: boolean;
-}): Schema<OBJECT>;
-
+    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;
+}
 /**
- * Parses a JSON string into an unknown object.
- *
- * @param text - The JSON string to parse.
- * @returns {JSONValue} - The parsed JSON object.
+ * Reasoning content part of a prompt. It contains a reasoning.
  */
-declare function parseJSON(options: {
+interface ReasoningPart {
+    type: 'reasoning';
+    /**
+     * The reasoning text.
+     */
     text: string;
-    schema?: undefined;
-}): Promise<JSONValue>;
+    /**
+     * 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;
+}
 /**
- * Parses a JSON string into a strongly-typed object using the provided schema.
- *
- * @template T - The type of the object to parse the JSON into.
- * @param {string} text - The JSON string to parse.
- * @param {Validator<T>} schema - The schema to use for parsing the JSON.
- * @returns {Promise<T>} - The parsed object.
+ * Custom content part of a prompt. It contains no standardized payload beyond
+ * provider-specific options.
  */
-declare function parseJSON<T>(options: {
-    text: string;
-    schema: FlexibleSchema<T>;
-}): Promise<T>;
-type ParseResult<T> = {
-    success: true;
-    value: T;
-    rawValue: unknown;
-} | {
-    success: false;
-    error: JSONParseError | TypeValidationError;
-    rawValue: unknown;
-};
+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;
+}
 /**
- * Safely parses a JSON string and returns the result as an object of type `unknown`.
- *
- * @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.
+ * Reasoning file content part of a prompt. It contains a file generated as part of reasoning.
  */
-declare function safeParseJSON(options: {
-    text: string;
-    schema?: undefined;
-}): Promise<ParseResult<JSONValue>>;
+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;
+}
 /**
- * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
- *
- * @template T - The type of the object to parse the JSON into.
- * @param {string} text - The JSON string to parse.
- * @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.
+ * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
  */
-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;
-}) => PromiseLike<{
-    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;
-}) => ResponseHandler<APICallError>;
-declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
-declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
-declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
-declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
-
-declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, 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>;
-}>;
-
-declare function getRuntimeEnvironmentUserAgent(globalThisAny?: any): string;
-
-declare function injectJsonInstructionIntoMessages({ messages, schema, schemaPrefix, schemaSuffix, }: {
-    messages: LanguageModelV4Prompt;
-    schema?: JSONSchema7;
-    schemaPrefix?: string;
-    schemaSuffix?: string;
-}): LanguageModelV4Prompt;
-
-declare function isAbortError(error: unknown): error is Error;
-
+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;
+}
 /**
- * Type guard that checks whether a value is not `null` or `undefined`.
- *
- * @template T - The type of the value to check.
- * @param value - The value to check.
- * @returns `true` if the value is neither `null` nor `undefined`, otherwise `false`.
+ * Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
  */
-declare function isNonNullable<T>(value: T | undefined | null): value is NonNullable<T>;
-
+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;
+}
 /**
- * Checks if the given URL is supported natively by the model.
- *
- * @param mediaType - The media type of the URL. Case-sensitive.
- * @param url - The URL to check.
- * @param supportedUrls - A record where keys are case-sensitive 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.
+ * Output of a tool result.
  */
-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;
-}): string;
-
-type ReasoningLevel = Exclude<LanguageModelV4CallOptions['reasoning'], 'none' | 'provider-default' | undefined>;
-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
- * maps to a different string, or an unsupported warning if the level is not
- * present in the map.
- *
- * @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[];
-}): T | undefined;
-/**
- * Maps a top-level reasoning level to an absolute token budget by multiplying
- * the model's max output tokens by a percentage from the budget percentages
- * map. The result is clamped between `minReasoningBudget` (default 1024) and
- * `maxReasoningBudget`. Pushes an unsupported warning if the level is not
- * present in the budget percentages map.
- *
- * @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[];
-}): number | undefined;
-
-/**
- * Loads an optional `string` setting from the environment or a parameter.
- *
- * @param settingValue - The setting value.
- * @param environmentVariableName - The environment variable name.
- * @returns The setting value.
- */
-declare function loadOptionalSetting({ settingValue, environmentVariableName, }: {
-    settingValue: string | undefined;
-    environmentVariableName: string;
-}): string | undefined;
-
-/**
- * Loads a `string` setting from the environment or a parameter.
- *
- * @param settingValue - The setting value.
- * @param environmentVariableName - The environment variable name.
- * @param settingName - The setting name.
- * @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;
-}): string;
-
-type MaybePromiseLike<T> = T | PromiseLike<T>;
-
-/**
- * Maps a media type to its corresponding file extension.
- * It was originally introduced to set a filename for audio file uploads
- * in https://github.com/vercel/ai/pull/8159.
- *
- * @param mediaType The media type to map.
- * @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;
-
-/**
- * Normalizes different header inputs into a plain record with lower-case keys.
- * Entries with `undefined` or `null` values are removed.
- *
- * @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>;
-
-/**
- * Parses a JSON event stream into a stream of parsed JSON objects.
- */
-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>;
-}): Promise<OPTIONS | undefined>;
-
-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>;
-}>;
-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>;
-}>;
-declare const postToApi: <T>({ url, headers, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, }: {
-    url: string;
-    headers?: Record<string, string | undefined>;
-    body: {
-        content: string | FormData | Uint8Array;
-        values: unknown;
-    };
-    failedResponseHandler: ResponseHandler<Error>;
-    successfulResponseHandler: ResponseHandler<T>;
-    abortSignal?: AbortSignal;
-    fetch?: FetchFunction;
-}) => Promise<{
-    value: T;
-    rawValue?: unknown;
-    responseHeaders?: Record<string, string>;
-}>;
-
-/**
- * Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
- */
-type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
-
-/**
- * Additional provider-specific options.
- *
- * They are passed through to the provider from the AI SDK and enable
- * provider-specific functionality that can be fully encapsulated in the provider.
- */
-type ProviderOptions = SharedV4ProviderOptions;
-
-/**
- * Text content part of a prompt. It contains a string of text.
- */
-interface TextPart {
-    type: 'text';
+type ToolResultOutput = {
     /**
-     * The text content.
+     * Text tool output that should be directly sent to the API.
      */
-    text: string;
+    type: 'text';
+    value: 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;
-}
-/**
- * Image content part of a prompt. It contains an image.
- */
-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
-     */
-    image: DataContent | URL;
-    /**
-     * Optional IANA media type of the image.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-     */
-    mediaType?: string;
+} | {
+    type: 'json';
+    value: JSONValue;
     /**
-     * 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;
-}
-/**
- * File content part of a prompt. It contains a file.
- */
-interface FilePart {
-    type: 'file';
-    /**
-     * File data. Can either be:
-     *
-     * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
-     * - URL: a URL that points to the image
-     */
-    data: DataContent | URL;
+} | {
     /**
-     * Optional filename of the file.
+     * Type when the user has denied the execution of the tool call.
      */
-    filename?: string;
+    type: 'execution-denied';
     /**
-     * IANA media type of the file.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     * Optional reason for the execution denial.
      */
-    mediaType: string;
+    reason?: 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;
-}
-/**
- * Reasoning content part of a prompt. It contains a reasoning.
- */
-interface ReasoningPart {
-    type: 'reasoning';
+} | {
+    type: 'error-text';
+    value: string;
     /**
-     * The reasoning text.
+     * Provider-specific options.
      */
-    text: string;
+    providerOptions?: ProviderOptions;
+} | {
+    type: 'error-json';
+    value: JSONValue;
     /**
-     * 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';
-    /**
-     * File data. Can either be:
-     *
-     * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
-     * - URL: a URL that points to the file
-     */
-    data: 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.
+     * Provider-specific options.
      */
     providerOptions?: ProviderOptions;
 } | {
@@ -821,13 +348,45 @@ type ToolResultOutput = {
          */
         providerOptions?: ProviderOptions;
     } | {
+        type: 'file';
         /**
-         * @deprecated Use image-data or file-data instead.
+         * 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
          */
-        type: 'media';
-        data: string;
         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.
@@ -847,16 +406,29 @@ type ToolResultOutput = {
          */
         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.
@@ -873,7 +445,24 @@ type ToolResultOutput = {
         providerOptions?: ProviderOptions;
     } | {
         /**
-         * Images that are referenced using base64 encoded data.
+         * @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';
         /**
@@ -891,7 +480,9 @@ type ToolResultOutput = {
         providerOptions?: ProviderOptions;
     } | {
         /**
-         * Images that are referenced using a URL.
+         * @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';
         /**
@@ -904,7 +495,9 @@ type ToolResultOutput = {
         providerOptions?: ProviderOptions;
     } | {
         /**
-         * Images that are referenced using a provider file id.
+         * @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';
         /**
@@ -920,6 +513,22 @@ type ToolResultOutput = {
          * 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
@@ -933,6 +542,630 @@ type ToolResultOutput = {
     }>;
 };
 
+type InlineFileData = Extract<FilePart['data'], {
+    type: 'data';
+} | {
+    type: 'text';
+}>;
+/**
+ * Converts inline file data (a tagged `data` or `text` shape) into raw bytes.
+ *
+ * - `{ type: 'text', text }` → UTF-8 encoded bytes
+ * - `{ type: 'data', data: Uint8Array | Buffer }` → returned as-is
+ * - `{ type: 'data', data: ArrayBuffer }` → wrapped in a `Uint8Array`
+ * - `{ type: 'data', data: string }` → decoded as base64
+ */
+declare function convertInlineFileDataToUint8Array(data: InlineFileData): Uint8Array;
+
+/**
+ * Convert an ImageModelV4File to a URL or data URI string.
+ *
+ * If the file is a URL, it returns the URL as-is.
+ * 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;
+
+/**
+ * Converts an input object to FormData for multipart/form-data requests.
+ *
+ * Handles the following cases:
+ * - `null` or `undefined` values are skipped
+ * - Arrays with a single element are appended as a single value
+ * - Arrays with multiple elements are appended with `[]` suffix (e.g., `image[]`)
+ *   unless `useArrayBrackets` is set to `false`
+ * - All other values are appended directly
+ *
+ * @param input - The input object to convert. Use a generic type for type validation.
+ * @param options - Optional configuration object.
+ * @param options.useArrayBrackets - Whether to add `[]` suffix for multi-element arrays.
+ *   Defaults to `true`. Set to `false` for APIs that expect repeated keys without brackets.
+ * @returns A FormData object containing the input values.
+ *
+ * @example
+ * ```ts
+ * type MyInput = {
+ *   model: string;
+ *   prompt: string;
+ *   images: Blob[];
+ * };
+ *
+ * const formData = convertToFormData<MyInput>({
+ *   model: 'gpt-image-1',
+ *   prompt: 'A cat',
+ *   images: [blob1, blob2],
+ * });
+ * ```
+ */
+declare function convertToFormData<T extends Record<string, unknown>>(input: T, options?: {
+    useArrayBrackets?: boolean;
+}): FormData;
+
+/**
+ * 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;
+}
+/**
+ * @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>;
+}): ToolNameMapping;
+
+/**
+ * Creates a Promise that resolves after a specified delay
+ * @param delayInMs - The delay duration in milliseconds. If null or undefined, resolves immediately.
+ * @param signal - Optional AbortSignal to cancel the delay
+ * @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;
+}): Promise<void>;
+
+/**
+ * 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;
+}
+
+/**
+ * Detect the IANA media type of a file from its raw bytes or base64 string.
+ *
+ * - When `topLevelType` is omitted, every known signature is considered
+ *   (image, audio, video, and application). Returns `undefined` when the
+ *   bytes do not match any known signature.
+ * - When `topLevelType` is provided, only signatures for that top-level
+ *   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;
+}): string | undefined;
+/**
+ * Returns the top-level segment of a media type (the portion before `/`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `"image"`
+ *   - `"image/*"` -> `"image"`
+ *   - `"image"` -> `"image"`
+ *   - `"image/"` -> `"image"`
+ *   - `""` -> `""`
+ *   - `"/"` -> `""`
+ */
+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 `*`).
+ *
+ * Examples:
+ *   - `"image/png"` -> `true`
+ *   - `"image/*"` -> `false`
+ *   - `"image"` -> `false`
+ *   - `"image/"` -> `false`
+ *   - `""` -> `false`
+ *   - `"/"` -> `false`
+ */
+declare function isFullMediaType(mediaType: string): boolean;
+
+/**
+ * Download a file from a URL and return it as a Blob.
+ *
+ * @param url - The URL to download from.
+ * @param options - Optional settings for the download.
+ * @param options.maxBytes - Maximum allowed download size in bytes. Defaults to 100 MiB.
+ * @param options.abortSignal - An optional abort signal to cancel the download.
+ * @returns A Promise that resolves to the downloaded Blob.
+ *
+ * @throws DownloadError if the download fails or exceeds maxBytes.
+ */
+declare function downloadBlob(url: string, options?: {
+    maxBytes?: number;
+    abortSignal?: AbortSignal;
+}): Promise<Blob>;
+
+declare const symbol: unique symbol;
+declare class DownloadError extends AISDKError {
+    private readonly [symbol];
+    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;
+}
+
+/**
+ * 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;
+};
+
+/**
+ * Fetch function type (standardizes the version of fetch used).
+ */
+type FetchFunction = typeof globalThis.fetch;
+
+/**
+ * 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>;
+
+/**
+ * Creates an ID generator.
+ * The total length of the ID is the sum of the prefix, separator, and random part length.
+ * Not cryptographically secure.
+ *
+ * @param alphabet - The alphabet to use for the ID. Default: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.
+ * @param prefix - The prefix of the ID to generate. Optional.
+ * @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;
+}) => IdGenerator;
+/**
+ * A function that generates an ID.
+ */
+type IdGenerator = () => string;
+/**
+ * Generates a 16-character random string to use for IDs.
+ * Not cryptographically secure.
+ */
+declare const generateId: IdGenerator;
+
+/**
+ * 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: 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>;
+};
+/**
+ * Creates a schema with deferred creation.
+ * This is important to reduce the startup time of the library
+ * and to avoid initializing unused validators.
+ *
+ * @param createValidator A function that creates a schema.
+ * @returns A function that returns a schema.
+ */
+declare function lazySchema<SCHEMA>(createSchema: () => Schema<SCHEMA>): LazySchema<SCHEMA>;
+type LazySchema<SCHEMA> = () => Schema<SCHEMA>;
+type ZodSchema<SCHEMA = any> = z3.Schema<SCHEMA, z3.ZodTypeDef, any> | z4.core.$ZodType<SCHEMA, any>;
+type StandardSchema<SCHEMA = any> = StandardSchemaV1<unknown, SCHEMA> & StandardJSONSchemaV1<unknown, SCHEMA>;
+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;
+/**
+ * Create a schema using a JSON Schema.
+ *
+ * @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>>;
+}): Schema<OBJECT>;
+declare function asSchema<OBJECT>(schema: FlexibleSchema<OBJECT> | undefined): Schema<OBJECT>;
+declare function zodSchema<OBJECT>(zodSchema: z4.core.$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>;
+
+/**
+ * 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;
+}): Promise<JSONValue>;
+/**
+ * Parses a JSON string into a strongly-typed object using the provided schema.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @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>;
+}): Promise<T>;
+type ParseResult<T> = {
+    success: true;
+    value: T;
+    rawValue: unknown;
+} | {
+    success: false;
+    error: JSONParseError | TypeValidationError;
+    rawValue: unknown;
+};
+/**
+ * Safely parses a JSON string and returns the result as an object of type `unknown`.
+ *
+ * @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;
+}): Promise<ParseResult<JSONValue>>;
+/**
+ * Safely parses a JSON string into a strongly-typed object, using a provided schema to validate the object.
+ *
+ * @template T - The type of the object to parse the JSON into.
+ * @param {string} text - The JSON string to parse.
+ * @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>;
+}): Promise<ParseResult<T>>;
+declare function isParsableJson(input: string): boolean;
+
+type ResponseHandler<RETURN_TYPE> = (options: {
+    url: string;
+    requestBodyValues: unknown;
+    response: Response;
+}) => PromiseLike<{
+    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;
+}) => ResponseHandler<APICallError>;
+declare const createEventSourceResponseHandler: <T>(chunkSchema: FlexibleSchema<T>) => ResponseHandler<ReadableStream<ParseResult<T>>>;
+declare const createJsonResponseHandler: <T>(responseSchema: FlexibleSchema<T>) => ResponseHandler<T>;
+declare const createBinaryResponseHandler: () => ResponseHandler<Uint8Array>;
+declare const createStatusCodeErrorResponseHandler: () => ResponseHandler<APICallError>;
+
+declare const getFromApi: <T>({ url, headers, successfulResponseHandler, failedResponseHandler, 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>;
+}>;
+
+declare function getRuntimeEnvironmentUserAgent(globalThisAny?: any): string;
+
+/**
+ * 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;
+}): LanguageModelV4Prompt;
+
+declare function isAbortError(error: unknown): error is Error;
+
+/**
+ * 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;
+
+/**
+ * Type guard that checks whether a value is not `null` or `undefined`.
+ *
+ * @template T - The type of the value to check.
+ * @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>;
+
+/**
+ * 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;
+
+/**
+ * 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
+ *                    `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 '*')
+ *                        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[]>;
+}): boolean;
+
+declare function loadApiKey({ apiKey, environmentVariableName, apiKeyParameterName, description, }: {
+    apiKey: string | undefined;
+    environmentVariableName: string;
+    apiKeyParameterName?: string;
+    description: string;
+}): string;
+
+/**
+ * Loads an optional `string` setting from the environment or a parameter.
+ *
+ * @param settingValue - The setting value.
+ * @param environmentVariableName - The environment variable name.
+ * @returns The setting value.
+ */
+declare function loadOptionalSetting({ settingValue, environmentVariableName, }: {
+    settingValue: string | undefined;
+    environmentVariableName: string;
+}): string | undefined;
+
+/**
+ * Loads a `string` setting from the environment or a parameter.
+ *
+ * @param settingValue - The setting value.
+ * @param environmentVariableName - The environment variable name.
+ * @param settingName - The setting name.
+ * @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;
+}): string;
+
+type ReasoningLevel = Exclude<LanguageModelV4CallOptions['reasoning'], 'none' | 'provider-default' | undefined>;
+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
+ * maps to a different string, or an unsupported warning if the level is not
+ * present in the map.
+ *
+ * @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[];
+}): T | undefined;
+/**
+ * Maps a top-level reasoning level to an absolute token budget by multiplying
+ * the model's max output tokens by a percentage from the budget percentages
+ * map. The result is clamped between `minReasoningBudget` (default 1024) and
+ * `maxReasoningBudget`. Pushes an unsupported warning if the level is not
+ * present in the budget percentages map.
+ *
+ * @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[];
+}): number | undefined;
+
+/**
+ * A value that can be provided either synchronously or as a promise-like.
+ */
+type MaybePromiseLike<T> = T | PromiseLike<T>;
+
+/**
+ * Maps a media type to its corresponding file extension.
+ * It was originally introduced to set a filename for audio file uploads
+ * in https://github.com/vercel/ai/pull/8159.
+ *
+ * @param mediaType The media type to map.
+ * @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;
+
+/**
+ * Normalizes different header inputs into a plain record with lower-case keys.
+ * Entries with `undefined` or `null` values are removed.
+ *
+ * @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>;
+
+/**
+ * Parses a JSON event stream into a stream of parsed JSON objects.
+ */
+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>;
+}): Promise<OPTIONS | undefined>;
+
+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>;
+}>;
+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>;
+}>;
+declare const postToApi: <T>({ url, headers, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch, }: {
+    url: string;
+    headers?: Record<string, string | undefined>;
+    body: {
+        content: string | FormData | Uint8Array;
+        values: unknown;
+    };
+    failedResponseHandler: ResponseHandler<Error>;
+    successfulResponseHandler: ResponseHandler<T>;
+    abortSignal?: AbortSignal;
+    fetch?: FetchFunction;
+}) => Promise<{
+    value: T;
+    rawValue?: unknown;
+    responseHeaders?: Record<string, string>;
+}>;
+
+/**
+ * A context object that is passed into tool execution.
+ */
+type Context = Record<string, unknown>;
+
+type NeverOptional<N, T> = 0 extends 1 & N ? Partial<T> : [N] extends [never] ? Partial<Record<keyof T, undefined>> : T;
+
+/**
+ * Top-level context properties that contain sensitive data and should be
+ * excluded from telemetry.
+ */
+type SensitiveContext<CONTEXT extends Context | unknown | never> = {
+    [KEY in keyof CONTEXT]?: boolean;
+} | undefined;
+
 /**
  * Tool approval request prompt part.
  */
@@ -946,6 +1179,12 @@ type ToolApprovalRequest = {
      * ID of the tool call that the approval request is for.
      */
     toolCallId: string;
+    /**
+     * Flag indicating whether the tool was automatically approved or denied.
+     *
+     * @default false
+     */
+    isAutomatic?: boolean;
 };
 
 /**
@@ -1051,15 +1290,10 @@ type UserContent = string | Array<TextPart | ImagePart | FilePart>;
  */
 type ModelMessage = SystemModelMessage | UserModelMessage | AssistantModelMessage | ToolModelMessage;
 
-/**
- * A context object that is passed into tool execution.
- */
-type Context = Record<string, unknown>;
-
 /**
  * Additional options that are sent into each tool execution.
  */
-interface ToolExecutionOptions<CONTEXT extends Context> {
+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.
      */
@@ -1074,7 +1308,8 @@ interface ToolExecutionOptions<CONTEXT extends Context> {
      */
     abortSignal?: AbortSignal;
     /**
-     * User-defined context.
+     * 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
@@ -1082,15 +1317,20 @@ interface ToolExecutionOptions<CONTEXT extends Context> {
      *
      * If you need to mutate the context, analyze the tool calls and results
      * in `prepareStep` and update it there.
-     *
-     * Experimental (can break in patch releases).
      */
-    experimental_context: CONTEXT;
+    context: CONTEXT;
 }
+/**
+ * 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;
+
 /**
  * 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> = (input: INPUT, options: {
+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.
      */
@@ -1101,21 +1341,29 @@ type ToolNeedsApprovalFunction<INPUT, CONTEXT extends Context> = (input: INPUT,
      */
     messages: ModelMessage[];
     /**
-     * Additional context.
+     * 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.
      *
-     * Experimental (can break in patch releases).
+     * If you need to mutate the context, analyze the tool calls and results
+     * in `prepareStep` and update it there.
      */
-    experimental_context: CONTEXT;
+    context: CONTEXT;
 }) => boolean | PromiseLike<boolean>;
+
 /**
- * Function that executes the tool and returns either a single result or a stream of results.
- */
-type ToolExecuteFunction<INPUT, OUTPUT, CONTEXT extends Context> = (input: INPUT, options: ToolExecutionOptions<CONTEXT>) => AsyncIterable<OUTPUT> | PromiseLike<OUTPUT> | OUTPUT;
-type NeverOptional<N, T> = 0 extends 1 & N ? Partial<T> : [N] extends [never] ? Partial<Record<keyof T, undefined>> : T;
-/**
- * Helper type to determine the output properties of a tool.
+ * Helper type to determine the outputSchema and execute function properties of a tool.
  */
-type ToolOutputProperties<INPUT, OUTPUT, CONTEXT extends Context> = NeverOptional<OUTPUT, {
+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.
@@ -1124,24 +1372,19 @@ type ToolOutputProperties<INPUT, OUTPUT, CONTEXT extends Context> = NeverOptiona
      * @options.abortSignal is a signal that can be used to abort the tool call.
      */
     execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-    outputSchema?: FlexibleSchema<OUTPUT>;
 } | {
+    /**
+     * The schema of the output that the tool produces.
+     *
+     * Required when no execute function is provided.
+     */
     outputSchema: FlexibleSchema<OUTPUT>;
     execute?: never;
 }>;
 /**
- * A tool contains the description and the schema of the input that the tool expects.
- * This enables the language model to generate the input.
- *
- * The tool can also contain an optional execute function for the actual execution function of the tool.
+ * Common properties shared by all tool kinds.
  */
-type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context = Context> = {
-    /**
-     * An optional description of what the tool does.
-     * Will be used by the language model to decide whether to use the tool.
-     * Not used for provider-defined tools.
-     */
-    description?: string;
+type BaseTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = {
     /**
      * An optional title of the tool.
      */
@@ -1152,6 +1395,16 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
      * 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
+     * `providerMetadata` 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.
+     */
+    providerMetadata?: SharedV4ProviderMetadata;
     /**
      * The schema of the input that the tool expects.
      * The language model will use this to generate the input.
@@ -1160,33 +1413,25 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
      * You can use descriptions on the schema properties to make the input understandable for the language model.
      */
     inputSchema: FlexibleSchema<INPUT>;
-    /**
-     * An optional list of input examples that show the language
-     * model what the input should look like.
-     */
-    inputExamples?: Array<{
-        input: NoInfer<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>;
+    /**
+     * Marks top-level context properties that contain sensitive data and should be excluded from telemetry.
+     * Properties marked as `true` are omitted from telemetry integrations.
+     */
+    sensitiveContext?: SensitiveContext<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>>;
-    /**
-     * 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;
     /**
      * Optional function that is called when the argument streaming starts.
      * Only called when the tool is used in a streaming context.
@@ -1206,7 +1451,6 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
     onInputAvailable?: (options: {
         input: [INPUT] extends [never] ? unknown : INPUT;
     } & ToolExecutionOptions<NoInfer<CONTEXT>>) => void | PromiseLike<void>;
-} & ToolOutputProperties<INPUT, OUTPUT, NoInfer<CONTEXT>> & {
     /**
      * Optional conversion function that maps the tool result to an output that can be used by the language model.
      *
@@ -1228,21 +1472,55 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
          */
         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> & {
     /**
-     * Tool with user-defined input and output schemas.
+     * An optional description of what the tool does.
+     * Will be used by the language model to decide whether to use the tool.
      */
-    type?: undefined | 'function';
-} | {
+    description?: string;
     /**
-     * Tool that is defined at runtime (e.g. an MCP tool).
-     * The types of input and output are not known at development time.
+     * 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.
      */
-    type: 'dynamic';
-} | {
+    strict?: boolean;
     /**
-     * Tool with provider-defined input and output schemas.
+     * 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';
+};
+/**
+ * Tool that is defined at runtime.
+ * The types of input and output are not known at development time.
+ *
+ * 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';
+};
+/**
+ * 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>`.
@@ -1252,6 +1530,34 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
      * 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
+ * user.
+ *
+ * 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;
+};
+/**
+ * Tool with provider-defined input and output schemas that is executed by the
+ * provider.
+ *
+ * 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.
      *
@@ -1266,71 +1572,68 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
      * @default false
      */
     supportsDeferredResults?: boolean;
-});
+};
 /**
- * Helper function for inferring the execute args of a tool.
+ * A tool can either be user-defined or provider-defined.
+ *
+ * It contains the schemas and metadata needed for the language model to call
+ * the tool and can include an execute function for tools that are executed by
+ * the AI SDK.
+ */
+type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = FunctionTool<INPUT, OUTPUT, CONTEXT> | DynamicTool<INPUT, OUTPUT, CONTEXT> | ProviderDefinedTool<INPUT, OUTPUT, CONTEXT> | ProviderExecutedTool<INPUT, OUTPUT, CONTEXT>;
+/**
+ * Infer the tool type from a tool object.
+ *
+ * This is useful for type inference when working with tool objects.
  */
 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>;
 /**
- * Defines a dynamic tool.
+ * Define a dynamic tool.
  */
-declare function dynamicTool(tool: {
-    description?: string;
-    title?: string;
-    providerOptions?: ProviderOptions;
-    inputSchema: FlexibleSchema<unknown>;
-    execute: ToolExecuteFunction<unknown, unknown, Context>;
-    /**
-     * 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.
-     */
-    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: unknown;
-        /**
-         * The output of the tool call.
-         */
-        output: unknown;
-    }) => ToolResultOutput | PromiseLike<ToolResultOutput>;
-    /**
-     * Whether the tool needs approval before it can be executed.
-     */
-    needsApproval?: boolean | ToolNeedsApprovalFunction<unknown, Context>;
-}): Tool<unknown, unknown, Context> & {
-    type: 'dynamic';
-};
+declare function dynamicTool(tool: Omit<DynamicTool<unknown, unknown, Context>, 'type'>): DynamicTool<unknown, unknown, Context>;
 
-type ProviderToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}> = <OUTPUT>(options: ARGS & {
+/**
+ * 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'];
-}) => Tool<INPUT, OUTPUT, CONTEXT>;
-declare function createProviderToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, }: {
+}) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
+declare function createProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, }: {
     id: `${string}.${string}`;
     inputSchema: FlexibleSchema<INPUT>;
-}): ProviderToolFactory<INPUT, ARGS, CONTEXT>;
-type ProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}> = (options: ARGS & {
+}): 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'];
-}) => Tool<INPUT, OUTPUT, CONTEXT>;
-declare function createProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema, supportsDeferredResults, }: {
+}) => 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>;
+}): ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT>;
+
+/**
+ * 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'];
+}) => 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>;
@@ -1345,7 +1648,38 @@ declare function createProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS e
      * @default false
      */
     supportsDeferredResults?: boolean;
-}): ProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS, CONTEXT>;
+}): ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS, CONTEXT>;
+
+/**
+ * Default maximum download size: 2 GiB.
+ *
+ * `fetch().arrayBuffer()` has ~2x peak memory overhead (undici buffers the
+ * body internally, then creates the JS ArrayBuffer), so very large downloads
+ * risk exceeding the default V8 heap limit on 64-bit systems and terminating
+ * the process with an out-of-memory error.
+ *
+ * Setting this limit converts an unrecoverable OOM crash into a catchable
+ * `DownloadError`.
+ */
+declare const DEFAULT_MAX_DOWNLOAD_SIZE: number;
+/**
+ * Reads a fetch Response body with a size limit to prevent memory exhaustion.
+ *
+ * Checks the Content-Length header for early rejection, then reads the body
+ * incrementally via ReadableStream and aborts with a DownloadError when the
+ * limit is exceeded.
+ *
+ * @param response - The fetch Response to read.
+ * @param url - The URL being downloaded (used in error messages).
+ * @param maxBytes - Maximum allowed bytes. Defaults to DEFAULT_MAX_DOWNLOAD_SIZE.
+ * @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;
+}): Promise<Uint8Array>;
 
 /**
  * Removes entries from a record where the value is null or undefined.
@@ -1354,6 +1688,21 @@ declare function createProviderToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS e
  */
 declare function removeUndefinedEntries<T>(record: Record<string, T | undefined>): Record<string, T>;
 
+/**
+ * A value or a lazy provider of a value, each of which may be synchronous or asynchronous.
+ *
+ * @template T The resolved type after {@link resolve} runs.
+ *
+ * One of:
+ * - A plain value of type {@link T}
+ * - A {@link PromiseLike} of {@link T} (e.g. a `Promise<T>`)
+ * - A zero-argument function that returns a plain {@link T}
+ * - A zero-argument function that returns a {@link PromiseLike} of {@link T}
+ *
+ * The function form is only invoked when passed to {@link resolve}; it is not distinguished from
+ * 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>);
 /**
  * Resolves a value that could be a raw value, a Promise, a function returning a value,
@@ -1361,6 +1710,134 @@ type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
  */
 declare function resolve<T>(value: Resolvable<T>): Promise<T>;
 
+/**
+ * Resolves a file part's media type to a full `type/subtype` form required by
+ * providers whose API demands the full IANA media type.
+ *
+ * - If `part.mediaType` is already a full media type (e.g. `image/png`), it is
+ *   returned as-is.
+ * - Otherwise, when inline bytes are available (`part.data.type === 'data'`),
+ *   the subtype is sniffed from the bytes using the signature table that
+ *   corresponds to the top-level segment.
+ * - 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;
+}): string;
+
+/**
+ * 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;
+}): string;
+
+/**
+ * Serializes a model instance for workflow step boundaries.
+ * Returns the `modelId` plus the JSON-serializable config properties.
+ *
+ * Non-serializable values are omitted. As a special case, a
+ * function-valued `headers` property is resolved during serialization
+ * and included if the returned value is JSON-serializable.
+ *
+ * Used as the body of `static [WORKFLOW_SERIALIZE]` in provider models.
+ *
+ * @example
+ * ```ts
+ * static [WORKFLOW_SERIALIZE](model: MyLanguageModel) {
+ *   return serializeModelOptions({
+ *     modelId: model.modelId,
+ *     config: model.config,
+ *   });
+ * }
+ * ```
+ */
+declare function serializeModelOptions<CONFIG extends {
+    headers?: Resolvable<Record<string, string | undefined>>;
+}>(options: {
+    modelId: string;
+    config: CONFIG;
+}): {
+    modelId: string;
+    config: JSONObject;
+};
+
+/**
+ * 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;
+}
+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;
+}
+type StreamingToolCallTrackerController = Pick<TransformStreamDefaultController<LanguageModelV4StreamPart>, 'enqueue'>;
+/**
+ * Tracks streaming tool call state across multiple deltas from an
+ * OpenAI-compatible chat completion stream. Handles argument accumulation,
+ * 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 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;
+}
+
 /**
  * Strips file extension segments from a filename.
  *
@@ -1440,40 +1917,20 @@ declare function withUserAgentSuffix(headers: HeadersInit | Record<string, strin
 declare function withoutTrailingSlash(url: string | undefined): string | undefined;
 
 /**
- * Executes a tool function, supporting both synchronous and streaming/asynchronous results.
- *
- * This generator yields intermediate ("preliminary") outputs as they're produced, allowing callers
- * to stream partial tool results before completion. When execution is finished, it yields a final output,
- * ensuring all consumers receive a conclusive result.
- *
- * - If the tool's `execute` function returns an `AsyncIterable`, all intermediate values are yielded
- *   as `{ type: "preliminary", output }` except the last, which is yielded as `{ type: "final", output }`.
- * - If the tool returns a direct value or Promise, a single `{ type: "final", output }` is yielded.
- *
- * @template INPUT Input type for the tool execution.
- * @template OUTPUT Output type for the tool execution.
- * @template CONTEXT Context object extension for execution (extends Context).
- * @param params.execute The tool execute function.
- * @param params.input Input value to pass to the execute function.
- * @param params.options Additional options for tool execution.
- * @yields An object containing either a preliminary or final output from the tool.
+ * A tool that is guaranteed to expose an execute function.
  */
-declare function executeTool<INPUT, OUTPUT, CONTEXT extends Context>({ execute, input, options, }: {
-    execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-    input: INPUT;
-    options: ToolExecutionOptions<NoInfer<CONTEXT>>;
-}): AsyncGenerator<{
-    type: 'preliminary';
-    output: OUTPUT;
-} | {
-    type: 'final';
-    output: OUTPUT;
-}>;
+type ExecutableTool<TOOL extends Tool = Tool> = TOOL & {
+    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>;
 
 /**
  * Infer the context type of a tool.
  */
-type InferToolContext<TOOL extends Tool<any, any, any>> = TOOL extends Tool<any, any, infer CONTEXT> ? CONTEXT : never;
+type InferToolContext<TOOL extends Tool> = TOOL extends Tool<any, any, infer CONTEXT> ? HasRequiredKey<CONTEXT> extends true ? CONTEXT : never : never;
 
 /**
  * Infer the input type of a tool.
@@ -1486,35 +1943,46 @@ type InferToolInput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<infer
 type InferToolOutput<TOOL extends Tool<any, any, any>> = TOOL extends Tool<any, infer OUTPUT, any> ? OUTPUT : never;
 
 /**
- * A mapping of tool names to tool definitions.
+ * Executes a tool function and normalizes its results into a stream of outputs.
+ *
+ * - If the tool's `execute` function returns an `AsyncIterable`, each yielded value is emitted as
+ *   `{ type: "preliminary", output }`. After iteration completes, the last yielded value is emitted
+ *   again as `{ type: "final", output }`.
+ * - If the tool returns a direct value or Promise, a single `{ type: "final", output }` is yielded.
+ *
+ * @param params.tool The tool whose `execute` function should be invoked.
+ * @param params.input The input value to pass to the tool.
+ * @param params.options Additional options for tool execution.
+ * @yields A preliminary output for each streamed value, followed by a final output, or a single final
+ * output for non-streaming tools.
  */
-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'>>;
+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: 'final';
+    output: InferToolOutput<TOOL>;
+}>;
 
 /**
- * Converts a union type `U` into an intersection type.
- *
- * For example:
- *   type A = { a: number };
- *   type B = { b: string };
- *   type Union = A | B;
- *   type Intersection = UnionToIntersection<Union>;
- *   // Intersection is: { a: number } & { b: string }
- *
- * This is useful when you have a union of object types and need a type with all possible properties.
+ * A mapping of tool names to tool definitions.
  */
-type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
+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'>>;
 
 /**
  * Infer the context type for a tool set.
  *
- * The inferred type contains all properties required by the contexts of the
- * tools in the set.
+ * The inferred type maps each tool name to its required context type.
  *
- * If there are incompatible properties, they will be of type `never`.
+ * Tools without required context properties are omitted from the result.
  */
-type InferToolSetContext<TOOLS extends ToolSet> = UnionToIntersection<{
-    [K in keyof TOOLS]: InferToolContext<NoInfer<TOOLS[K]>>;
-}[keyof TOOLS]>;
+type InferToolSetContext<TOOLS extends ToolSet> = {
+    [K in keyof TOOLS as InferToolContext<NoInfer<TOOLS[K]>> extends never ? never : K]: InferToolContext<NoInfer<TOOLS[K]>>;
+};
 
 /**
  * Typed tool call that is returned by generateText and streamText.
@@ -1575,4 +2043,4 @@ interface ToolResult<NAME extends string, INPUT, OUTPUT> {
     dynamic?: boolean;
 }
 
-export { type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type FetchFunction, type FilePart, type FlexibleSchema, type IdGenerator, type ImagePart, type InferSchema, type InferToolContext, type InferToolInput, type InferToolOutput, type InferToolSetContext, type LazySchema, type MaybePromiseLike, type ModelMessage, type ParseResult, type ProviderOptions, type ProviderToolFactory, type ProviderToolFactoryWithOutputSchema, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type Schema, 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, asSchema, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderToolFactory, createProviderToolFactoryWithOutputSchema, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, downloadBlob, dynamicTool, executeTool, extractResponseHeaders, generateId, getErrorMessage, getFromApi, getRuntimeEnvironmentUserAgent, injectJsonInstructionIntoMessages, isAbortError, isCustomReasoning, isNonNullable, isParsableJson, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, removeUndefinedEntries, resolve, safeParseJSON, safeValidateTypes, stripFileExtension, tool, validateDownloadUrl, validateTypes, withUserAgentSuffix, withoutTrailingSlash, zodSchema };
+export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type DynamicTool, type ExecutableTool, 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 ParseResult, type ProviderDefinedTool, type ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, type ProviderExecutedTool, type ProviderExecutedToolFactory, type ProviderOptions, type ProviderReference, type ReasoningFilePart, type ReasoningPart, type Resolvable, type ResponseHandler, type Schema, type SensitiveContext, 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, asArray, asSchema, combineHeaders, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertImageModelFileToDataUri, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, detectMediaType, downloadBlob, dynamicTool, executeTool, extractResponseHeaders, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, getTopLevelMediaType, injectJsonInstructionIntoMessages, isAbortError, isBuffer, isCustomReasoning, isExecutableTool, isFullMediaType, isNonNullable, isParsableJson, isProviderReference, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, safeParseJSON, safeValidateTypes, serializeModelOptions, stripFileExtension, tool, validateDownloadUrl, validateTypes, withUserAgentSuffix, withoutTrailingSlash, zodSchema };