@ai-sdk/provider-utils 5.0.0-beta.27 → 5.0.0-beta.29

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ImageModelV4File, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, JSONValue, APICallError, LanguageModelV4Prompt, LanguageModelV4FilePart, SharedV4ProviderReference, LanguageModelV4CallOptions, SharedV4Warning, SharedV4ProviderOptions, JSONObject, LanguageModelV4StreamPart, SharedV4ProviderMetadata, TypeValidationContext } from '@ai-sdk/provider';
+import { SharedV4FileDataUrl, SharedV4FileDataReference, SharedV4FileDataText, SharedV4ProviderOptions, SharedV4ProviderReference, JSONValue, ImageModelV4File, LanguageModelV4FunctionTool, LanguageModelV4ProviderTool, AISDKError, JSONSchema7, JSONParseError, TypeValidationError, APICallError, LanguageModelV4Prompt, LanguageModelV4CallOptions, SharedV4Warning, LanguageModelV4FilePart, JSONObject, LanguageModelV4StreamPart, SharedV4ProviderMetadata, TypeValidationContext } from '@ai-sdk/provider';
 export { getErrorMessage } from '@ai-sdk/provider';
 import { StandardSchemaV1, StandardJSONSchemaV1 } from '@standard-schema/spec';
 export * from '@standard-schema/spec';
@@ -29,797 +29,310 @@ declare function combineHeaders(...headers: Array<Record<string, string | undefi
 declare function convertAsyncIteratorToReadableStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
 
 /**
- * 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.
+ * Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
  */
-declare function convertImageModelFileToDataUri(file: ImageModelV4File): string;
+type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
 
 /**
- * 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
+ * File data variant containing raw bytes (`Uint8Array`, `ArrayBuffer`, or
+ * `Buffer`) or a base64-encoded string.
  *
- * @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.
+ * This is slightly more permissive than `SharedV4FileDataData`.
  */
-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;
+interface FileDataData {
+    type: 'data';
+    data: DataContent;
 }
 /**
- * @param tools - Tools that were passed to the language model.
- * @param providerToolNames - Maps the provider tool ids to the provider tool names.
+ * File data variant containing a URL that points to the file.
  */
-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;
-
+type FileDataUrl = SharedV4FileDataUrl;
 /**
- * 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
+ * File data variant containing a provider reference (`{ [provider]: id }`).
  */
-declare function delay(delayInMs?: number | null, options?: {
-    abortSignal?: AbortSignal;
-}): Promise<void>;
-
+type FileDataReference = SharedV4FileDataReference;
 /**
- * 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 inline text content (e.g. an inline text
+ * document).
  */
-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;
-}
-
+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;
 
 /**
- * Extracts the headers from a response object and returns them as a key-value object.
+ * Additional provider-specific options.
  *
- * @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).
+ * 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 FetchFunction = typeof globalThis.fetch;
+type ProviderOptions = SharedV4ProviderOptions;
 
 /**
- * Filters `null` and `undefined` values out of a list of values.
+ * A mapping of provider names to provider-specific file identifiers.
  *
- * @param values - The values to filter.
- * @returns A new array containing only non-nullish values.
+ * 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 filterNullable<T>(...values: Array<T | undefined | null>): Array<T>;
+type ProviderReference = SharedV4ProviderReference;
 
 /**
- * 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.
+ * Text content part of a prompt. It contains a string of text.
  */
-type IdGenerator = () => string;
+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;
+}
 /**
- * Generates a 16-character random string to use for IDs.
- * Not cryptographically secure.
+ * Image content part of a prompt. It contains an image.
+ *
+ * @deprecated Use `FilePart` with `mediaType: 'image'` instead:
+ * `{ type: 'file', mediaType: 'image', data: { type: 'data', data } }`.
  */
-declare const generateId: IdGenerator;
-
+interface ImagePart {
+    type: 'image';
+    /**
+     * Image data. Can either be:
+     *
+     * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+     * - URL: a URL that points to the image
+     * - ProviderReference: a provider reference from `uploadFile`
+     */
+    image: DataContent | URL | ProviderReference;
+    /**
+     * Optional IANA media type of the image.
+     *
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType?: string;
+    /**
+     * Additional provider-specific metadata. They are passed through
+     * to the provider from the AI SDK and enable provider-specific
+     * functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
 /**
- * Used to mark schemas so we can support both Zod and custom schemas.
+ * File content part of a prompt. It contains a file.
  */
-declare const schemaSymbol: unique symbol;
-type ValidationResult<OBJECT> = {
-    success: true;
-    value: OBJECT;
-} | {
-    success: false;
-    error: Error;
-};
-type Schema<OBJECT = unknown> = {
+interface FilePart {
+    type: 'file';
     /**
-     * Used to mark schemas so we can support both Zod and custom schemas.
+     * 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)
      */
-    [schemaSymbol]: true;
+    data: FileData | DataContent | URL | ProviderReference;
     /**
-     * Schema type for inference.
+     * Optional filename of the file.
      */
-    _type: OBJECT;
+    filename?: string;
     /**
-     * Optional. Validates that the structure of a value matches this schema,
-     * and returns a typed version of the value if it does.
+     * 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
      */
-    readonly validate?: (value: unknown) => ValidationResult<OBJECT> | PromiseLike<ValidationResult<OBJECT>>;
+    mediaType: string;
     /**
-     * The JSON Schema for the schema. It is passed to the providers.
+     * 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 jsonSchema: JSONSchema7 | PromiseLike<JSONSchema7>;
-};
+    providerOptions?: ProviderOptions;
+}
 /**
- * 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.
+ * Reasoning content part of a prompt. It contains a reasoning.
  */
-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?: {
+interface ReasoningPart {
+    type: 'reasoning';
     /**
-     * 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`.
+     * The reasoning text.
      */
-    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;
-
+    /**
+     * 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 an object has required keys.
- * @param OBJECT - The object to check.
- * @returns True if the object has required keys, false otherwise.
+ * Custom content part of a prompt. It contains no standardized payload beyond
+ * provider-specific options.
  */
-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;
-
+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;
+}
 /**
- * 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`.
+ * Reasoning file content part of a prompt. It contains a file generated as part of reasoning.
  */
-declare function isNonNullable<T>(value: T | undefined | null): value is NonNullable<T>;
-
+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;
+}
 /**
- * Checks whether file part data is a provider reference (a mapping of provider
- * names to provider-specific identifiers) as opposed to raw bytes or a URL.
+ * Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
  */
-declare function isProviderReference(data: LanguageModelV4FilePart['data']): data is SharedV4ProviderReference;
-
+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;
+}
 /**
- * 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.
+ * Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
  */
-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;
-
+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;
+}
 /**
- * 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.
+ * Output of a tool result.
  */
-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>;
-}>;
-
-/**
- * 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;
-
-/**
- * A mapping of provider names to provider-specific file identifiers.
- *
- * 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.
- */
-type ProviderReference = SharedV4ProviderReference;
-
-/**
- * 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
-     * - ProviderReference: a provider reference from `uploadFile`
-     */
-    image: DataContent | URL | ProviderReference;
-    /**
-     * Optional IANA media type of the image.
-     *
-     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
-     */
-    mediaType?: string;
+} | {
+    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 file
-     * - ProviderReference: a provider reference from `uploadFile`
-     */
-    data: DataContent | URL | ProviderReference;
+} | {
     /**
-     * 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';
-    /**
-     * The reasoning text.
-     */
-    text: string;
+} | {
+    type: 'error-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;
-}
-/**
- * Custom content part of a prompt. It contains no standardized payload beyond
- * provider-specific options.
- */
-interface CustomPart {
-    type: 'custom';
+} | {
+    type: 'error-json';
+    value: JSONValue;
     /**
-     * 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;
 } | {
@@ -973,11 +486,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.
  */
@@ -1102,14 +1234,6 @@ type UserContent = string | Array<TextPart | ImagePart | FilePart>;
  */
 type ModelMessage = SystemModelMessage | UserModelMessage | AssistantModelMessage | ToolModelMessage;
 
-/**
- * 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;
-
 /**
  * Additional options that are sent into each tool execution.
  */
@@ -1140,6 +1264,11 @@ interface ToolExecutionOptions<CONTEXT extends Context | unknown | never> {
      */
     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.
  *
@@ -1168,15 +1297,17 @@ type ToolNeedsApprovalFunction<INPUT, CONTEXT extends Context | unknown | never>
      */
     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 | unknown | never> = (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 | 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.
@@ -1185,30 +1316,19 @@ type ToolOutputProperties<INPUT, OUTPUT, CONTEXT extends Context | unknown | nev
      * @options.abortSignal is a signal that can be used to abort the tool call.
      */
     execute: ToolExecuteFunction<INPUT, OUTPUT, CONTEXT>;
-    /**
-     * The schema of the output that the tool produces.
-     */
-    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 | unknown | never = any> = {
-    /**
-     * 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.
      */
@@ -1227,13 +1347,6 @@ 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.
      *
@@ -1253,14 +1366,6 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
     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.
@@ -1280,7 +1385,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.
      *
@@ -1302,34 +1406,86 @@ 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.
+ */
+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 (e.g. an MCP tool).
+ * The types of input and output 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>`.
      */
     id: `${string}.${string}`;
+    /**
+     * The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+     */
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+};
+/**
+ * Tool with provider-defined input and output schemas that is executed by the
+ * user.
+ */
+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: boolean;
+    isProviderExecuted: false;
+    supportsDeferredResults?: never;
+};
+/**
+ * Tool with provider-defined input and output schemas that is executed by the
+ * provider.
+ */
+type ProviderExecutedTool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONValue | unknown | never = any, CONTEXT extends Context | unknown | never = any> = BaseProviderTool<INPUT, OUTPUT, CONTEXT> & {
     /**
-     * The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+     * Flag that indicates whether the tool is executed by the provider.
      */
-    args: Record<string, unknown>;
+    isProviderExecuted: true;
     /**
      * Whether this provider-executed tool supports deferred results.
      *
@@ -1344,76 +1500,28 @@ type Tool<INPUT extends JSONValue | unknown | never = any, OUTPUT extends JSONVa
      * @default false
      */
     supportsDeferredResults?: boolean;
-});
+};
+/**
+ * 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>;
 /**
- * Helper function for inferring the execute args of a tool.
+ * 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: {
-    /**
-     * 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;
-    /**
-     * An optional title of the tool.
-     */
-    title?: string;
-    /**
-     * Additional provider-specific metadata. They are passed through
-     * to the provider from the AI SDK and enable provider-specific
-     * functionality that can be fully encapsulated in the provider.
-     */
-    providerOptions?: ProviderOptions;
-    /**
-     * The schema of the input that the tool expects.
-     * The language model will use this to generate the input.
-     * It is also used to validate the output of the language model.
-     *
-     * You can use descriptions on the schema properties to make the input understandable for the language model.
-     */
-    inputSchema: FlexibleSchema<unknown>;
-    /**
-     * An async function that is called with the arguments from the tool call and produces a result.
-     * If not provided, the tool will not be executed automatically.
-     *
-     * @args is the input of the tool call.
-     * @options.abortSignal is a signal that can be used to abort the tool call.
-     */
-    execute: ToolExecuteFunction<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>;
 
 /**
  * A provider-defined tool is a tool for which the provider defines the input
@@ -1426,7 +1534,7 @@ type ProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Cont
     onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
-}) => Tool<INPUT, OUTPUT, CONTEXT>;
+}) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
 declare function createProviderDefinedToolFactory<INPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, }: {
     id: `${string}.${string}`;
     inputSchema: FlexibleSchema<INPUT>;
@@ -1438,7 +1546,7 @@ type ProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends obje
     onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
-}) => Tool<INPUT, OUTPUT, CONTEXT>;
+}) => ProviderDefinedTool<INPUT, OUTPUT, CONTEXT>;
 declare function createProviderDefinedToolFactoryWithOutputSchema<INPUT, OUTPUT, ARGS extends object, CONTEXT extends Context = {}>({ id, inputSchema, outputSchema, }: {
     id: `${string}.${string}`;
     inputSchema: FlexibleSchema<INPUT>;
@@ -1452,7 +1560,7 @@ type ProviderExecutedToolFactory<INPUT, OUTPUT, ARGS extends object, CONTEXT ext
     onInputStart?: Tool<INPUT, OUTPUT, CONTEXT>['onInputStart'];
     onInputDelta?: Tool<INPUT, OUTPUT, CONTEXT>['onInputDelta'];
     onInputAvailable?: Tool<INPUT, OUTPUT, CONTEXT>['onInputAvailable'];
-}) => Tool<INPUT, OUTPUT, CONTEXT>;
+}) => 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>;
@@ -1530,6 +1638,22 @@ 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
@@ -1847,4 +1971,4 @@ interface ToolResult<NAME extends string, INPUT, OUTPUT> {
     dynamic?: boolean;
 }
 
-export { type Arrayable, type AssistantContent, type AssistantModelMessage, type Context, type CustomPart, DEFAULT_MAX_DOWNLOAD_SIZE, type DataContent, DelayedPromise, DownloadError, type ExecutableTool, type FetchFunction, type FilePart, type FlexibleSchema, 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 ProviderDefinedToolFactory, type ProviderDefinedToolFactoryWithOutputSchema, 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, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createEventSourceResponseHandler, createIdGenerator, createJsonErrorResponseHandler, createJsonResponseHandler, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createStatusCodeErrorResponseHandler, createToolNameMapping, delay, downloadBlob, dynamicTool, executeTool, extractResponseHeaders, filterNullable, generateId, getFromApi, getRuntimeEnvironmentUserAgent, injectJsonInstructionIntoMessages, isAbortError, isCustomReasoning, isExecutableTool, isNonNullable, isParsableJson, isProviderReference, isUrlSupported, jsonSchema, lazySchema, loadApiKey, loadOptionalSetting, loadSetting, mapReasoningToProviderBudget, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeHeaders, parseJSON, parseJsonEventStream, parseProviderOptions, postFormDataToApi, postJsonToApi, postToApi, readResponseWithSizeLimit, removeUndefinedEntries, resolve, resolveProviderReference, safeParseJSON, safeValidateTypes, serializeModelOptions, 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 };