ai 5.0.0-canary.1 → 5.0.0-canary.11

package/dist/index.d.mts

@@ -1,14 +1,47 @@
-import { IDGenerator } from '@ai-sdk/provider-utils';
-export { CoreToolCall, CoreToolResult, IDGenerator, ToolCall, ToolResult, createIdGenerator, generateId } from '@ai-sdk/provider-utils';
-import { DataStreamString, Message, Schema, DeepPartial, JSONValue as JSONValue$1 } from '@ai-sdk/ui-utils';
-export { Attachment, ChatRequest, ChatRequestOptions, CreateMessage, DataStreamPart, DeepPartial, IdGenerator, JSONValue, Message, RequestOptions, Schema, ToolInvocation, UIMessage, formatDataStreamPart, jsonSchema, parseDataStreamPart, processDataStream, processTextStream, zodSchema } from '@ai-sdk/ui-utils';
-import { LanguageModelV2, LanguageModelV2FinishReason, LanguageModelV2LogProbs, LanguageModelV2CallWarning, LanguageModelV2Source, JSONValue, EmbeddingModelV1, EmbeddingModelV1Embedding, ImageModelV1, ImageModelV1CallWarning, LanguageModelV2ProviderMetadata, LanguageModelV2CallOptions, AISDKError, LanguageModelV2FunctionToolCall, JSONSchema7, JSONParseError, TypeValidationError, LanguageModelV2Middleware, ProviderV2, NoSuchModelError } from '@ai-sdk/provider';
-export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2Prompt, LanguageModelV2StreamPart, LoadAPIKeyError, NoContentGeneratedError, NoSuchModelError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
+import { ToolCall, ToolResult, FetchFunction, Validator, IDGenerator } from '@ai-sdk/provider-utils';
+export { IDGenerator, ToolCall, ToolResult, createIdGenerator, generateId } from '@ai-sdk/provider-utils';
+import { EmbeddingModelV2, EmbeddingModelV2Embedding, ImageModelV1, ImageModelV1CallWarning, LanguageModelV2, LanguageModelV2FinishReason, LanguageModelV2LogProbs, LanguageModelV2CallWarning, LanguageModelV2Source, SharedV2ProviderMetadata, SharedV2ProviderOptions, TranscriptionModelV1, TranscriptionModelV1CallWarning, SpeechModelV1, SpeechModelV1CallWarning, JSONValue as JSONValue$1, JSONObject, LanguageModelV2CallOptions, AISDKError, LanguageModelV2ToolCall, JSONSchema7 as JSONSchema7$1, JSONParseError, TypeValidationError, LanguageModelV2Middleware, ProviderV2, NoSuchModelError } from '@ai-sdk/provider';
+export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, LoadAPIKeyError, NoContentGeneratedError, NoSuchModelError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
 import { ServerResponse } from 'node:http';
 import { AttributeValue, Tracer } from '@opentelemetry/api';
 import { z } from 'zod';
+import { JSONSchema7 } from 'json-schema';
 import { ServerResponse as ServerResponse$1 } from 'http';
 
+/**
+Embedding model that is used by the AI SDK Core functions.
+*/
+type EmbeddingModel<VALUE> = EmbeddingModelV2<VALUE>;
+/**
+Embedding.
+ */
+type Embedding = EmbeddingModelV2Embedding;
+
+/**
+Image model that is used by the AI SDK Core functions.
+  */
+type ImageModel = ImageModelV1;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+  */
+type ImageGenerationWarning = ImageModelV1CallWarning;
+
+type ImageModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
+};
+
 /**
 Language model that is used by the AI SDK Core functions.
 */
@@ -50,132 +83,14 @@ Tool choice for the generation. It supports the following settings:
  */
 type ToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
     type: 'tool';
-    toolName: keyof TOOLS;
-};
-/**
- * @deprecated Use `ToolChoice` instead.
- */
-type CoreToolChoice<TOOLS extends Record<string, unknown>> = ToolChoice<TOOLS>;
-
-interface DataStreamWriter {
-    /**
-     * Appends a data part to the stream.
-     */
-    write(data: DataStreamString): void;
-    /**
-     * Appends a data part to the stream.
-     */
-    writeData(value: JSONValue): void;
-    /**
-     * Appends a message annotation to the stream.
-     */
-    writeMessageAnnotation(value: JSONValue): void;
-    /**
-     * Appends a source part to the stream.
-     */
-    writeSource(source: Source): void;
-    /**
-     * Merges the contents of another stream to this stream.
-     */
-    merge(stream: ReadableStream<DataStreamString>): void;
-    /**
-     * Error handler that is used by the data stream writer.
-     * This is intended for forwarding when merging streams
-     * to prevent duplicated error masking.
-     */
-    onError: ((error: unknown) => string) | undefined;
-}
-
-declare function createDataStream({ execute, onError, }: {
-    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
-    onError?: (error: unknown) => string;
-}): ReadableStream<DataStreamString>;
-
-declare function createDataStreamResponse({ status, statusText, headers, execute, onError, }: ResponseInit & {
-    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
-    onError?: (error: unknown) => string;
-}): Response;
-
-declare function pipeDataStreamToResponse(response: ServerResponse, { status, statusText, headers, execute, onError, }: ResponseInit & {
-    execute: (writer: DataStreamWriter) => Promise<void> | void;
-    onError?: (error: unknown) => string;
-}): void;
-
-/**
- * Telemetry configuration.
- */
-type TelemetrySettings = {
-    /**
-     * Enable or disable telemetry. Disabled by default while experimental.
-     */
-    isEnabled?: boolean;
-    /**
-     * Enable or disable input recording. Enabled by default.
-     *
-     * You might want to disable input recording to avoid recording sensitive
-     * information, to reduce data transfers, or to increase performance.
-     */
-    recordInputs?: boolean;
-    /**
-     * Enable or disable output recording. Enabled by default.
-     *
-     * You might want to disable output recording to avoid recording sensitive
-     * information, to reduce data transfers, or to increase performance.
-     */
-    recordOutputs?: boolean;
-    /**
-     * Identifier for this function. Used to group telemetry data by function.
-     */
-    functionId?: string;
-    /**
-     * Additional information to include in the telemetry data.
-     */
-    metadata?: Record<string, AttributeValue>;
-    /**
-     * A custom tracer to use for the telemetry data.
-     */
-    tracer?: Tracer;
-};
-
-/**
-Embedding model that is used by the AI SDK Core functions.
-*/
-type EmbeddingModel<VALUE> = EmbeddingModelV1<VALUE>;
-/**
-Embedding.
- */
-type Embedding = EmbeddingModelV1Embedding;
-
-/**
-Image model that is used by the AI SDK Core functions.
-  */
-type ImageModel = ImageModelV1;
-/**
-Warning from the model provider for this call. The call will proceed, but e.g.
-some settings might not be supported, which can lead to suboptimal results.
-  */
-type ImageGenerationWarning = ImageModelV1CallWarning;
-
-type ImageModelResponseMetadata = {
-    /**
-  Timestamp for the start of the generated response.
-     */
-    timestamp: Date;
-    /**
-  The ID of the response model that was used to generate the response.
-     */
-    modelId: string;
-    /**
-  Response headers.
-     */
-    headers?: Record<string, string>;
+    toolName: Extract<keyof TOOLS, string>;
 };
 
 type LanguageModelRequestMetadata = {
     /**
-    Raw request HTTP body that was sent to the provider API as a string (JSON should be stringified).
+  Request HTTP body that was sent to the provider API.
        */
-    body?: string;
+    body?: unknown;
 };
 
 type LanguageModelResponseMetadata = {
@@ -240,40 +155,891 @@ Additional provider-specific metadata that is returned from the provider.
 This is needed to enable provider-specific functionality that can be
 fully encapsulated in the provider.
  */
-type ProviderMetadata = LanguageModelV2ProviderMetadata;
+type ProviderMetadata = SharedV2ProviderMetadata;
 /**
 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 = LanguageModelV2ProviderMetadata;
+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 = SharedV2ProviderOptions;
+
+/**
+Represents the number of tokens used in a prompt and completion.
+ */
+type LanguageModelUsage$1 = {
+    /**
+  The number of tokens used in the prompt.
+     */
+    promptTokens: number;
+    /**
+  The number of tokens used in the completion.
+   */
+    completionTokens: number;
+    /**
+  The total number of tokens used (promptTokens + completionTokens).
+     */
+    totalTokens: number;
+};
+/**
+Represents the number of tokens used in an embedding.
+ */
+type EmbeddingModelUsage = {
+    /**
+  The number of tokens used in the embedding.
+     */
+    tokens: number;
+};
+
+/**
+Represents the number of tokens used in a prompt and completion.
+ */
+type LanguageModelUsage = {
+    /**
+  The number of tokens used in the prompt.
+     */
+    promptTokens: number;
+    /**
+  The number of tokens used in the completion.
+   */
+    completionTokens: number;
+    /**
+  The total number of tokens used (promptTokens + completionTokens).
+     */
+    totalTokens: number;
+};
+
+type IdGenerator = () => string;
+/**
+Tool invocations are either tool calls or tool results. For each assistant tool call,
+there is one tool invocation. While the call is in progress, the invocation is a tool call.
+Once the call is complete, the invocation is a tool result.
+
+The step is used to track how to map an assistant UI message with many tool invocations
+back to a sequence of LLM assistant/tool result message pairs.
+It is optional for backwards compatibility.
+ */
+type ToolInvocation = ({
+    state: 'partial-call';
+    step?: number;
+} & ToolCall<string, any>) | ({
+    state: 'call';
+    step?: number;
+} & ToolCall<string, any>) | ({
+    state: 'result';
+    step?: number;
+} & ToolResult<string, any, any>);
+/**
+ * An attachment that can be sent along with a message.
+ */
+interface Attachment {
+    /**
+     * The name of the attachment, usually the file name.
+     */
+    name?: string;
+    /**
+     * A string indicating the [media type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type).
+     * By default, it's extracted from the pathname's extension.
+     */
+    contentType?: string;
+    /**
+     * The URL of the attachment. It can either be a URL to a hosted file or a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).
+     */
+    url: string;
+}
+/**
+ * AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
+ */
+interface Message {
+    /**
+  A unique identifier for the message.
+     */
+    id: string;
+    /**
+  The timestamp of the message.
+     */
+    createdAt?: Date;
+    /**
+  Text content of the message. Use parts when possible.
+     */
+    content: string;
+    /**
+  Reasoning for the message.
+  
+  @deprecated Use `parts` instead.
+     */
+    reasoning?: string;
+    /**
+     * Additional attachments to be sent along with the message.
+     */
+    experimental_attachments?: Attachment[];
+    /**
+  The 'data' role is deprecated.
+     */
+    role: 'system' | 'user' | 'assistant' | 'data';
+    /**
+  For data messages.
+  
+  @deprecated Data messages will be removed.
+     */
+    data?: JSONValue;
+    /**
+     * Additional message-specific information added on the server via StreamData
+     */
+    annotations?: JSONValue[] | undefined;
+    /**
+  Tool invocations (that can be tool calls or tool results, depending on whether or not the invocation has finished)
+  that the assistant made as part of this message.
+  
+  @deprecated Use `parts` instead.
+     */
+    toolInvocations?: Array<ToolInvocation>;
+    /**
+     * The parts of the message. Use this for rendering the message in the UI.
+     *
+     * Assistant messages can have text, reasoning and tool invocation parts.
+     * User messages can have text parts.
+     */
+    parts?: Array<TextUIPart | ReasoningUIPart | ToolInvocationUIPart | SourceUIPart | FileUIPart | StepStartUIPart>;
+}
+type UIMessage = Message & {
+    /**
+     * The parts of the message. Use this for rendering the message in the UI.
+     *
+     * Assistant messages can have text, reasoning and tool invocation parts.
+     * User messages can have text parts.
+     */
+    parts: Array<TextUIPart | ReasoningUIPart | ToolInvocationUIPart | SourceUIPart | FileUIPart | StepStartUIPart>;
+};
+/**
+ * A text part of a message.
+ */
+type TextUIPart = {
+    type: 'text';
+    /**
+     * The text content.
+     */
+    text: string;
+};
+/**
+ * A reasoning part of a message.
+ */
+type ReasoningUIPart = {
+    type: 'reasoning';
+    /**
+     * The reasoning text.
+     */
+    reasoning: string;
+    details: Array<{
+        type: 'text';
+        text: string;
+        signature?: string;
+    } | {
+        type: 'redacted';
+        data: string;
+    }>;
+};
+/**
+ * A tool invocation part of a message.
+ */
+type ToolInvocationUIPart = {
+    type: 'tool-invocation';
+    /**
+     * The tool invocation.
+     */
+    toolInvocation: ToolInvocation;
+};
+/**
+ * A source part of a message.
+ */
+type SourceUIPart = {
+    type: 'source';
+    /**
+     * The source.
+     */
+    source: LanguageModelV2Source;
+};
+/**
+ * A file part of a message.
+ */
+type FileUIPart = {
+    type: 'file';
+    /**
+     * IANA media type of the file.
+     *
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType: string;
+    /**
+     * The base64 encoded data.
+     */
+    data: string;
+};
+/**
+ * A step boundary part of a message.
+ */
+type StepStartUIPart = {
+    type: 'step-start';
+};
+type CreateMessage = Omit<Message, 'id'> & {
+    id?: Message['id'];
+};
+type ChatRequest = {
+    /**
+  An optional object of headers to be passed to the API endpoint.
+   */
+    headers?: Record<string, string> | Headers;
+    /**
+  An optional object to be passed to the API endpoint.
+  */
+    body?: object;
+    /**
+  The messages of the chat.
+     */
+    messages: Message[];
+    /**
+  Additional data to be sent to the server.
+     */
+    data?: JSONValue;
+};
+type RequestOptions = {
+    /**
+  An optional object of headers to be passed to the API endpoint.
+   */
+    headers?: Record<string, string> | Headers;
+    /**
+  An optional object to be passed to the API endpoint.
+     */
+    body?: object;
+};
+type ChatRequestOptions = {
+    /**
+  Additional headers that should be to be passed to the API endpoint.
+   */
+    headers?: Record<string, string> | Headers;
+    /**
+  Additional body JSON properties that should be sent to the API endpoint.
+   */
+    body?: object;
+    /**
+  Additional data to be sent to the API endpoint.
+     */
+    data?: JSONValue;
+    /**
+     * Additional files to be sent to the server.
+     */
+    experimental_attachments?: FileList | Array<Attachment>;
+    /**
+     * Allow submitting an empty message. Defaults to `false`.
+     */
+    allowEmptySubmit?: boolean;
+};
+type UseChatOptions = {
+    /**
+  Keeps the last message when an error happens. Defaults to `true`.
+  
+  @deprecated This option will be removed in the next major release.
+     */
+    keepLastMessageOnError?: boolean;
+    /**
+     * The API endpoint that accepts a `{ messages: Message[] }` object and returns
+     * a stream of tokens of the AI chat response. Defaults to `/api/chat`.
+     */
+    api?: string;
+    /**
+     * A unique identifier for the chat. If not provided, a random one will be
+     * generated. When provided, the `useChat` hook with the same `id` will
+     * have shared states across components.
+     */
+    id?: string;
+    /**
+     * Initial messages of the chat. Useful to load an existing chat history.
+     */
+    initialMessages?: Message[];
+    /**
+     * Initial input of the chat.
+     */
+    initialInput?: string;
+    /**
+  Optional callback function that is invoked when a tool call is received.
+  Intended for automatic client-side tool execution.
+  
+  You can optionally return a result for the tool call,
+  either synchronously or asynchronously.
+     */
+    onToolCall?: ({ toolCall, }: {
+        toolCall: ToolCall<string, unknown>;
+    }) => void | Promise<unknown> | unknown;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void | Promise<void>;
+    /**
+     * Optional callback function that is called when the assistant message is finished streaming.
+     *
+     * @param message The message that was streamed.
+     * @param options.usage The token usage of the message.
+     * @param options.finishReason The finish reason of the message.
+     */
+    onFinish?: (message: Message, options: {
+        usage: LanguageModelUsage;
+        finishReason: LanguageModelV2FinishReason;
+    }) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * A way to provide a function that is going to be used for ids for messages and the chat.
+     * If not provided the default AI SDK `generateId` is used.
+     */
+    generateId?: IdGenerator;
+    /**
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the messages.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /**
+     * Whether to send extra message fields such as `message.id` and `message.createdAt` to the API.
+     * Defaults to `false`. When set to `true`, the API endpoint might need to
+     * handle the extra fields before forwarding the request to the AI service.
+     */
+    sendExtraMessageFields?: boolean;
+    /**
+  Streaming protocol that is used. Defaults to `data`.
+     */
+    streamProtocol?: 'data' | 'text';
+    /**
+  Custom fetch implementation. You can use it as a middleware to intercept requests,
+  or to provide a custom fetch implementation for e.g. testing.
+      */
+    fetch?: FetchFunction;
+};
+type UseCompletionOptions = {
+    /**
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
+     */
+    api?: string;
+    /**
+     * An unique identifier for the chat. If not provided, a random one will be
+     * generated. When provided, the `useChat` hook with the same `id` will
+     * have shared states across components.
+     */
+    id?: string;
+    /**
+     * Initial prompt input of the completion.
+     */
+    initialInput?: string;
+    /**
+     * Initial completion result. Useful to load an existing history.
+     */
+    initialCompletion?: string;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void | Promise<void>;
+    /**
+     * Callback function to be called when the completion is finished streaming.
+     */
+    onFinish?: (prompt: string, completion: string) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the prompt.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /**
+  Streaming protocol that is used. Defaults to `data`.
+     */
+    streamProtocol?: 'data' | 'text';
+    /**
+  Custom fetch implementation. You can use it as a middleware to intercept requests,
+  or to provide a custom fetch implementation for e.g. testing.
+      */
+    fetch?: FetchFunction;
+};
+/**
+A JSON value can be a string, number, boolean, object, array, or null.
+JSON values can be serialized and deserialized by the JSON.stringify and JSON.parse methods.
+ */
+type JSONValue = null | string | number | boolean | {
+    [value: string]: JSONValue;
+} | Array<JSONValue>;
+
+/**
+Transcription model that is used by the AI SDK Core functions.
+  */
+type TranscriptionModel = TranscriptionModelV1;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+  */
+type TranscriptionWarning = TranscriptionModelV1CallWarning;
+
+type TranscriptionModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
+};
+
+/**
+Speech model that is used by the AI SDK Core functions.
+  */
+type SpeechModel = SpeechModelV1;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+  */
+type SpeechWarning = SpeechModelV1CallWarning;
+
+type SpeechModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
+    /**
+  Response body.
+     */
+    body?: unknown;
+};
+
+declare const getOriginalFetch$1: () => typeof fetch;
+declare function callChatApi({ api, body, streamProtocol, credentials, headers, abortController, restoreMessagesOnFailure, onResponse, onUpdate, onFinish, onToolCall, generateId, fetch, lastMessage, }: {
+    api: string;
+    body: Record<string, any>;
+    streamProtocol: 'data' | 'text' | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    abortController: (() => AbortController | null) | undefined;
+    restoreMessagesOnFailure: () => void;
+    onResponse: ((response: Response) => void | Promise<void>) | undefined;
+    onUpdate: (options: {
+        message: UIMessage;
+        data: JSONValue[] | undefined;
+        replaceLastMessage: boolean;
+    }) => void;
+    onFinish: UseChatOptions['onFinish'];
+    onToolCall: UseChatOptions['onToolCall'];
+    generateId: IdGenerator;
+    fetch: ReturnType<typeof getOriginalFetch$1> | undefined;
+    lastMessage: UIMessage | undefined;
+}): Promise<void>;
+
+declare const getOriginalFetch: () => typeof fetch;
+declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onResponse, onFinish, onError, onData, fetch, }: {
+    api: string;
+    prompt: string;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    body: Record<string, any>;
+    streamProtocol: 'data' | 'text' | undefined;
+    setCompletion: (completion: string) => void;
+    setLoading: (loading: boolean) => void;
+    setError: (error: Error | undefined) => void;
+    setAbortController: (abortController: AbortController | null) => void;
+    onResponse: ((response: Response) => void | Promise<void>) | undefined;
+    onFinish: ((prompt: string, completion: string) => void) | undefined;
+    onError: ((error: Error) => void) | undefined;
+    onData: ((data: JSONValue[]) => void) | undefined;
+    fetch: ReturnType<typeof getOriginalFetch> | undefined;
+}): Promise<string | null | undefined>;
+
+type DataStreamString = `${(typeof DataStreamStringPrefixes)[keyof typeof DataStreamStringPrefixes]}:${string}\n`;
+interface DataStreamPart<CODE extends string, NAME extends string, TYPE> {
+    code: CODE;
+    name: NAME;
+    parse: (value: JSONValue) => {
+        type: NAME;
+        value: TYPE;
+    };
+}
+declare const dataStreamParts: readonly [DataStreamPart<"0", "text", string>, DataStreamPart<"2", "data", JSONValue[]>, DataStreamPart<"3", "error", string>, DataStreamPart<"8", "message_annotations", JSONValue[]>, DataStreamPart<"9", "tool_call", ToolCall<string, any>>, DataStreamPart<"a", "tool_result", Omit<ToolResult<string, any, any>, "args" | "toolName">>, DataStreamPart<"b", "tool_call_streaming_start", {
+    toolCallId: string;
+    toolName: string;
+}>, DataStreamPart<"c", "tool_call_delta", {
+    toolCallId: string;
+    argsTextDelta: string;
+}>, DataStreamPart<"d", "finish_message", {
+    finishReason: LanguageModelV2FinishReason;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}>, DataStreamPart<"e", "finish_step", {
+    isContinued: boolean;
+    finishReason: LanguageModelV2FinishReason;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+}>, DataStreamPart<"f", "start_step", {
+    messageId: string;
+}>, DataStreamPart<"g", "reasoning", string>, DataStreamPart<"h", "source", LanguageModelV2Source>, DataStreamPart<"i", "redacted_reasoning", {
+    data: string;
+}>, DataStreamPart<"j", "reasoning_signature", {
+    signature: string;
+}>, DataStreamPart<"k", "file", {
+    data: string;
+    mimeType: string;
+}>];
+type DataStreamParts = (typeof dataStreamParts)[number];
+/**
+ * Maps the type of a stream part to its value type.
+ */
+type DataStreamPartValueType = {
+    [P in DataStreamParts as P['name']]: ReturnType<P['parse']>['value'];
+};
+type DataStreamPartType = ReturnType<DataStreamParts['parse']>;
+/**
+ * The map of prefixes for data in the stream
+ *
+ * - 0: Text from the LLM response
+ * - 1: (OpenAI) function_call responses
+ * - 2: custom JSON added by the user using `Data`
+ * - 6: (OpenAI) tool_call responses
+ *
+ * Example:
+ * ```
+ * 0:Vercel
+ * 0:'s
+ * 0: AI
+ * 0: AI
+ * 0: SDK
+ * 0: is great
+ * 0:!
+ * 2: { "someJson": "value" }
+ * 1: {"function_call": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}
+ * 6: {"tool_call": {"id": "tool_0", "type": "function", "function": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}}
+ *```
+ */
+declare const DataStreamStringPrefixes: { [K in DataStreamParts["name"]]: (typeof dataStreamParts)[number]["code"]; };
+/**
+Parses a stream part from a string.
+
+@param line The string to parse.
+@returns The parsed stream part.
+@throws An error if the string cannot be parsed.
+ */
+declare const parseDataStreamPart: (line: string) => DataStreamPartType;
+/**
+Prepends a string with a prefix from the `StreamChunkPrefixes`, JSON-ifies it,
+and appends a new line.
+
+It ensures type-safety for the part type and value.
+ */
+declare function formatDataStreamPart<T extends keyof DataStreamPartValueType>(type: T, value: DataStreamPartValueType[T]): DataStreamString;
+
+/**
+ * Converts a data URL of type text/* to a text string.
+ */
+declare function getTextFromDataUrl(dataUrl: string): string;
+
+/**
+Create a type from an object with all keys and nested keys set to optional.
+The helper supports normal objects and Zod schemas (which are resolved automatically).
+It always recurses into arrays.
+
+Adopted from [type-fest](https://github.com/sindresorhus/type-fest/tree/main) PartialDeep.
+ */
+type DeepPartial<T> = T extends z.ZodTypeAny ? DeepPartialInternal<z.infer<T>> : DeepPartialInternal<T>;
+type DeepPartialInternal<T> = T extends null | undefined | string | number | boolean | symbol | bigint | void | Date | RegExp | ((...arguments_: any[]) => unknown) | (new (...arguments_: any[]) => unknown) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMap<KeyType, ValueType> : T extends Set<infer ItemType> ? PartialSet<ItemType> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMap<KeyType, ValueType> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySet<ItemType> : T extends object ? T extends ReadonlyArray<infer ItemType> ? ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<DeepPartialInternal<ItemType | undefined>> : Array<DeepPartialInternal<ItemType | undefined>> : PartialObject<T> : PartialObject<T> : unknown;
+type PartialMap<KeyType, ValueType> = {} & Map<DeepPartialInternal<KeyType>, DeepPartialInternal<ValueType>>;
+type PartialSet<T> = {} & Set<DeepPartialInternal<T>>;
+type PartialReadonlyMap<KeyType, ValueType> = {} & ReadonlyMap<DeepPartialInternal<KeyType>, DeepPartialInternal<ValueType>>;
+type PartialReadonlySet<T> = {} & ReadonlySet<DeepPartialInternal<T>>;
+type PartialObject<ObjectType extends object> = {
+    [KeyType in keyof ObjectType]?: DeepPartialInternal<ObjectType[KeyType]>;
+};
+
+declare function extractMaxToolInvocationStep(toolInvocations: ToolInvocation[] | undefined): number | undefined;
+
+declare function fillMessageParts(messages: Message[]): UIMessage[];
+
+declare function getMessageParts(message: Message | CreateMessage | UIMessage): (TextUIPart | ReasoningUIPart | ToolInvocationUIPart | SourceUIPart | FileUIPart | StepStartUIPart)[];
+
+/**
+ * Performs a deep-equal comparison of two parsed JSON objects.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @returns {boolean} - Returns true if the two objects are deeply equal, false otherwise.
+ */
+declare function isDeepEqualData(obj1: any, obj2: any): boolean;
+
+declare function parsePartialJson(jsonText: string | undefined): {
+    value: JSONValue$1 | undefined;
+    state: 'undefined-input' | 'successful-parse' | 'repaired-parse' | 'failed-parse';
+};
+
+declare function prepareAttachmentsForRequest(attachmentsFromOptions: FileList | Array<Attachment> | undefined): Promise<Attachment[]>;
+
+declare function processDataStream({ stream, onTextPart, onReasoningPart, onReasoningSignaturePart, onRedactedReasoningPart, onSourcePart, onFilePart, onDataPart, onErrorPart, onToolCallStreamingStartPart, onToolCallDeltaPart, onToolCallPart, onToolResultPart, onMessageAnnotationsPart, onFinishMessagePart, onFinishStepPart, onStartStepPart, }: {
+    stream: ReadableStream<Uint8Array>;
+    onTextPart?: (streamPart: (DataStreamPartType & {
+        type: 'text';
+    })['value']) => Promise<void> | void;
+    onReasoningPart?: (streamPart: (DataStreamPartType & {
+        type: 'reasoning';
+    })['value']) => Promise<void> | void;
+    onReasoningSignaturePart?: (streamPart: (DataStreamPartType & {
+        type: 'reasoning_signature';
+    })['value']) => Promise<void> | void;
+    onRedactedReasoningPart?: (streamPart: (DataStreamPartType & {
+        type: 'redacted_reasoning';
+    })['value']) => Promise<void> | void;
+    onFilePart?: (streamPart: (DataStreamPartType & {
+        type: 'file';
+    })['value']) => Promise<void> | void;
+    onSourcePart?: (streamPart: (DataStreamPartType & {
+        type: 'source';
+    })['value']) => Promise<void> | void;
+    onDataPart?: (streamPart: (DataStreamPartType & {
+        type: 'data';
+    })['value']) => Promise<void> | void;
+    onErrorPart?: (streamPart: (DataStreamPartType & {
+        type: 'error';
+    })['value']) => Promise<void> | void;
+    onToolCallStreamingStartPart?: (streamPart: (DataStreamPartType & {
+        type: 'tool_call_streaming_start';
+    })['value']) => Promise<void> | void;
+    onToolCallDeltaPart?: (streamPart: (DataStreamPartType & {
+        type: 'tool_call_delta';
+    })['value']) => Promise<void> | void;
+    onToolCallPart?: (streamPart: (DataStreamPartType & {
+        type: 'tool_call';
+    })['value']) => Promise<void> | void;
+    onToolResultPart?: (streamPart: (DataStreamPartType & {
+        type: 'tool_result';
+    })['value']) => Promise<void> | void;
+    onMessageAnnotationsPart?: (streamPart: (DataStreamPartType & {
+        type: 'message_annotations';
+    })['value']) => Promise<void> | void;
+    onFinishMessagePart?: (streamPart: (DataStreamPartType & {
+        type: 'finish_message';
+    })['value']) => Promise<void> | void;
+    onFinishStepPart?: (streamPart: (DataStreamPartType & {
+        type: 'finish_step';
+    })['value']) => Promise<void> | void;
+    onStartStepPart?: (streamPart: (DataStreamPartType & {
+        type: 'start_step';
+    })['value']) => Promise<void> | void;
+}): Promise<void>;
+
+declare function processTextStream({ stream, onTextPart, }: {
+    stream: ReadableStream<Uint8Array>;
+    onTextPart: (chunk: string) => Promise<void> | void;
+}): Promise<void>;
+
+/**
+ * Used to mark schemas so we can support both Zod and custom schemas.
+ */
+declare const schemaSymbol: unique symbol;
+type Schema<OBJECT = unknown> = Validator<OBJECT> & {
+    /**
+     * Used to mark schemas so we can support both Zod and custom schemas.
+     */
+    [schemaSymbol]: true;
+    /**
+     * Schema type for inference.
+     */
+    _type: OBJECT;
+    /**
+     * The JSON Schema for the schema. It is passed to the providers.
+     */
+    readonly jsonSchema: JSONSchema7;
+};
+/**
+ * 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, { validate, }?: {
+    validate?: (value: unknown) => {
+        success: true;
+        value: OBJECT;
+    } | {
+        success: false;
+        error: Error;
+    };
+}): Schema<OBJECT>;
+declare function asSchema<OBJECT>(schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT> | undefined): Schema<OBJECT>;
+
+declare function shouldResubmitMessages({ originalMaxToolInvocationStep, originalMessageCount, maxSteps, messages, }: {
+    originalMaxToolInvocationStep: number | undefined;
+    originalMessageCount: number;
+    maxSteps: number;
+    messages: UIMessage[];
+}): boolean;
+/**
+Check if the message is an assistant message with completed tool calls.
+The last step of the message must have at least one tool invocation and
+all tool invocations must have a result.
+ */
+declare function isAssistantMessageWithCompletedToolCalls(message: UIMessage): message is UIMessage & {
+    role: 'assistant';
+};
+
+/**
+ * Updates the result of a specific tool invocation in the last message of the given messages array.
+ *
+ * @param {object} params - The parameters object.
+ * @param {UIMessage[]} params.messages - An array of messages, from which the last one is updated.
+ * @param {string} params.toolCallId - The unique identifier for the tool invocation to update.
+ * @param {unknown} params.toolResult - The result object to attach to the tool invocation.
+ * @returns {void} This function does not return anything.
+ */
+declare function updateToolCallResult({ messages, toolCallId, toolResult: result, }: {
+    messages: UIMessage[];
+    toolCallId: string;
+    toolResult: unknown;
+}): void;
+
+declare function zodSchema<OBJECT>(zodSchema: z.Schema<OBJECT, z.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>;
+
+interface DataStreamWriter {
+    /**
+     * Appends a data part to the stream.
+     */
+    write(data: DataStreamString): void;
+    /**
+     * Appends a data part to the stream.
+     */
+    writeData(value: JSONValue$1): void;
+    /**
+     * Appends a message annotation to the stream.
+     */
+    writeMessageAnnotation(value: JSONValue$1): void;
+    /**
+     * Appends a source part to the stream.
+     */
+    writeSource(source: Source): void;
+    /**
+     * Merges the contents of another stream to this stream.
+     */
+    merge(stream: ReadableStream<DataStreamString>): void;
+    /**
+     * Error handler that is used by the data stream writer.
+     * This is intended for forwarding when merging streams
+     * to prevent duplicated error masking.
+     */
+    onError: ((error: unknown) => string) | undefined;
+}
+
+declare function createDataStream({ execute, onError, }: {
+    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): ReadableStream<DataStreamString>;
+
+declare function createDataStreamResponse({ status, statusText, headers, execute, onError, }: ResponseInit & {
+    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): Response;
+
+declare function pipeDataStreamToResponse(response: ServerResponse, { status, statusText, headers, execute, onError, }: ResponseInit & {
+    execute: (writer: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): void;
 
 /**
-Represents the number of tokens used in a prompt and completion.
+ * Telemetry configuration.
  */
-type LanguageModelUsage = {
+type TelemetrySettings = {
     /**
-  The number of tokens used in the prompt.
+     * Enable or disable telemetry. Disabled by default while experimental.
      */
-    promptTokens: number;
+    isEnabled?: boolean;
     /**
-  The number of tokens used in the completion.
-   */
-    completionTokens: number;
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
     /**
-  The total number of tokens used (promptTokens + completionTokens).
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
      */
-    totalTokens: number;
-};
-/**
-Represents the number of tokens used in an embedding.
- */
-type EmbeddingModelUsage = {
+    recordOutputs?: boolean;
     /**
-  The number of tokens used in the embedding.
+     * Identifier for this function. Used to group telemetry data by function.
      */
-    tokens: number;
+    functionId?: string;
+    /**
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, AttributeValue>;
+    /**
+     * A custom tracer to use for the telemetry data.
+     */
+    tracer?: Tracer;
 };
 
 /**
@@ -294,13 +1060,17 @@ interface EmbedResult<VALUE> {
       */
     readonly usage: EmbeddingModelUsage;
     /**
-    Optional raw response data.
+    Optional response data.
        */
-    readonly rawResponse?: {
+    readonly response?: {
         /**
       Response headers.
            */
         headers?: Record<string, string>;
+        /**
+        The response body.
+        */
+        body?: unknown;
     };
 }
 
@@ -316,7 +1086,7 @@ Embed a value using an embedding model. The type of the value is defined by the
 
 @returns A result object that contains the embedding, the value, and additional information.
  */
-declare function embed<VALUE>({ model, value, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
+declare function embed<VALUE>({ model, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
   The embedding model to use.
        */
@@ -340,6 +1110,12 @@ declare function embed<VALUE>({ model, value, maxRetries: maxRetriesArg, abortSi
   Only applicable for HTTP-based providers.
    */
     headers?: Record<string, string>;
+    /**
+    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.
+    */
+    providerOptions?: ProviderOptions;
     /**
      * Optional telemetry configuration (experimental).
      */
@@ -363,6 +1139,19 @@ interface EmbedManyResult<VALUE> {
     The embedding token usage.
       */
     readonly usage: EmbeddingModelUsage;
+    /**
+    Optional raw response data.
+       */
+    readonly responses?: Array<{
+        /**
+  Response headers.
+       */
+        headers?: Record<string, string>;
+        /**
+    The response body.
+    */
+        body?: unknown;
+    } | undefined>;
 }
 
 /**
@@ -381,7 +1170,7 @@ has a limit on how many embeddings can be generated in a single call.
 
 @returns A result object that contains the embeddings, the value, and additional information.
  */
-declare function embedMany<VALUE>({ model, values, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
+declare function embedMany<VALUE>({ model, values, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
     /**
   The embedding model to use.
        */
@@ -409,22 +1198,29 @@ declare function embedMany<VALUE>({ model, values, maxRetries: maxRetriesArg, ab
      * Optional telemetry configuration (experimental).
      */
     experimental_telemetry?: TelemetrySettings;
+    /**
+    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.
+    */
+    providerOptions?: ProviderOptions;
 }): Promise<EmbedManyResult<VALUE>>;
 
 type CallSettings = {
     /**
   Maximum number of tokens to generate.
      */
-    maxTokens?: number;
+    maxOutputTokens?: number;
     /**
   Temperature setting. This is a number between 0 (almost no randomness) and
   1 (very random).
   
   It is recommended to set either `temperature` or `topP`, but not both.
+  Use `null` to use the provider's default temperature.
   
   @default 0
      */
-    temperature?: number;
+    temperature?: number | null;
     /**
   Nucleus sampling. This is a number between 0 and 1.
   
@@ -496,6 +1292,10 @@ type ToolResultContent = Array<{
 } | {
     type: 'image';
     data: string;
+    mediaType?: string;
+    /**
+     * @deprecated Use `mediaType` instead.
+     */
     mimeType?: string;
 }>;
 
@@ -514,10 +1314,6 @@ interface TextPart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Image content part of a prompt. It contains an image.
@@ -532,7 +1328,13 @@ interface ImagePart {
      */
     image: DataContent | URL;
     /**
-  Optional mime type of the image.
+  Optional IANA media type of the image.
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType?: string;
+    /**
+  @deprecated Use `mediaType` instead.
      */
     mimeType?: string;
     /**
@@ -541,10 +1343,6 @@ interface ImagePart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 File content part of a prompt. It contains a file.
@@ -563,19 +1361,21 @@ interface FilePart {
      */
     filename?: string;
     /**
-  Mime type of the file.
+  IANA media type of the file.
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    mimeType: string;
+    mediaType: string;
+    /**
+  @deprecated Use `mediaType` instead.
+     */
+    mimeType?: 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;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
  * Reasoning content part of a prompt. It contains a reasoning.
@@ -596,10 +1396,6 @@ interface ReasoningPart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Redacted reasoning content part of a prompt.
@@ -616,10 +1412,6 @@ interface RedactedReasoningPart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
@@ -644,10 +1436,6 @@ interface ToolCallPart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
@@ -680,10 +1468,6 @@ interface ToolResultPart {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 }
 
 /**
@@ -702,10 +1486,6 @@ type CoreSystemMessage = {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-   */
-    experimental_providerMetadata?: ProviderMetadata;
 };
 declare const coreSystemMessageSchema: z.ZodType<CoreSystemMessage>;
 /**
@@ -720,10 +1500,6 @@ type CoreUserMessage = {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-  */
-    experimental_providerMetadata?: ProviderMetadata;
 };
 declare const coreUserMessageSchema: z.ZodType<CoreUserMessage>;
 /**
@@ -742,10 +1518,6 @@ type CoreAssistantMessage = {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-  */
-    experimental_providerMetadata?: ProviderMetadata;
 };
 declare const coreAssistantMessageSchema: z.ZodType<CoreAssistantMessage>;
 /**
@@ -765,10 +1537,6 @@ type CoreToolMessage = {
   functionality that can be fully encapsulated in the provider.
    */
     providerOptions?: ProviderOptions;
-    /**
-  @deprecated Use `providerOptions` instead.
-  */
-    experimental_providerMetadata?: ProviderMetadata;
 };
 declare const coreToolMessageSchema: z.ZodType<CoreToolMessage>;
 /**
@@ -814,12 +1582,14 @@ interface GeneratedFile {
        */
     readonly uint8Array: Uint8Array;
     /**
-  MIME type of the file
+  The IANA media type of the file.
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    readonly mimeType: string;
+    readonly mediaType: string;
 }
 
-type ReasoningDetail = {
+type Reasoning = {
     type: 'text';
     text: string;
     signature?: string;
@@ -828,133 +1598,6 @@ type ReasoningDetail = {
     data: string;
 };
 
-type ToolParameters = z.ZodTypeAny | Schema<any>;
-type inferParameters<PARAMETERS extends ToolParameters> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
-interface ToolExecutionOptions {
-    /**
-     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
-     */
-    toolCallId: string;
-    /**
-     * Messages that were sent to the language model to initiate the response that contained the tool call.
-     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
-     */
-    messages: CoreMessage[];
-    /**
-     * An optional abort signal that indicates that the overall operation should be aborted.
-     */
-    abortSignal?: AbortSignal;
-}
-/**
-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.
- */
-type Tool<PARAMETERS extends ToolParameters = any, RESULT = any> = {
-    /**
-  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.
-  Use descriptions to make the input understandable for the language model.
-     */
-    parameters: PARAMETERS;
-    /**
-  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;
-    /**
-  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
-     */
-    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
-    /**
-  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?: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-} & ({
-    /**
-Function tool.
-     */
-    type?: undefined | 'function';
-} | {
-    /**
-Provider-defined tool.
-     */
-    type: 'provider-defined';
-    /**
-The ID of the tool. Should follow the format `<provider-name>.<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>;
-});
-/**
- * @deprecated Use `Tool` instead.
- */
-type CoreTool<PARAMETERS extends ToolParameters = any, RESULT = any> = Tool<PARAMETERS, RESULT>;
-/**
-Helper function for inferring the execute args of a tool.
- */
-declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-}): Tool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-};
-declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
-    execute?: undefined;
-}): Tool<PARAMETERS, RESULT> & {
-    execute: undefined;
-};
-
-/**
-Create a union of the given object's values, and optionally specify which keys to get the values from.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-    'foo': 1,
-    'bar': 2,
-    'biz': 3
-}
-
-// main.ts
-import type {ValueOf} from 'type-fest';
-import data = require('./data.json');
-
-export function getData(name: string): ValueOf<typeof data> {
-    return data[name];
-}
-
-export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
-    return data[name];
-}
-
-// file.ts
-import {getData, onlyBar} from './main';
-
-getData('foo');
-//=> 1
-
-onlyBar('foo');
-//=> TypeError ...
-
-onlyBar('bar');
-//=> 2
-```
-* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
-*/
-type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
-
 declare const JSONRPCRequestSchema: z.ZodObject<z.objectUtil.extendShape<{
     jsonrpc: z.ZodLiteral<"2.0">;
     id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -1218,25 +1861,99 @@ type MCPTransportConfig = {
      */
     url: string;
     /**
-     * Additional HTTP headers to be sent with requests.
-     */
-    headers?: Record<string, string>;
-};
+     * Additional HTTP headers to be sent with requests.
+     */
+    headers?: Record<string, string>;
+};
+
+type ToolParameters<T = JSONObject> = z.Schema<T> | Schema<T>;
+interface ToolExecutionOptions {
+    /**
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+     */
+    toolCallId: string;
+    /**
+     * Messages that were sent to the language model to initiate the response that contained the tool call.
+     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+     */
+    messages: CoreMessage[];
+    /**
+     * An optional abort signal that indicates that the overall operation should be aborted.
+     */
+    abortSignal?: AbortSignal;
+}
+type NeverOptional<N, T> = 0 extends 1 & N ? Partial<T> : [N] extends [never] ? Partial<Record<keyof T, undefined>> : T;
+/**
+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.
+ */
+type Tool<PARAMETERS extends JSONValue$1 | unknown | never = any, RESULT = 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;
+} & NeverOptional<PARAMETERS, {
+    /**
+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.
+Use descriptions to make the input understandable for the language model.
+   */
+    parameters: ToolParameters<PARAMETERS>;
+}> & NeverOptional<RESULT, {
+    /**
+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: (args: [PARAMETERS] extends [never] ? undefined : PARAMETERS, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+    /**
+Optional conversion function that maps the tool result to multi-part tool content for LLMs.
+    */
+    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
+}> & ({
+    /**
+Function tool.
+ */
+    type?: undefined | 'function';
+} | {
+    /**
+Provider-defined tool.
+ */
+    type: 'provider-defined';
+    /**
+The ID of the tool. Should follow the format `<provider-name>.<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>;
+});
+/**
+Helper function for inferring the execute args of a tool.
+ */
+declare function tool(tool: Tool<never, never>): Tool<never, never>;
+declare function tool<PARAMETERS>(tool: Tool<PARAMETERS, never>): Tool<PARAMETERS, never>;
+declare function tool<RESULT>(tool: Tool<never, RESULT>): Tool<never, RESULT>;
+declare function tool<PARAMETERS, RESULT>(tool: Tool<PARAMETERS, RESULT>): Tool<PARAMETERS, RESULT>;
+type MappedTool<T extends Tool | JSONObject, RESULT extends any> = T extends Tool<infer P> ? Tool<P, RESULT> : T extends JSONObject ? Tool<T, RESULT> : never;
 
 type ToolSchemas = Record<string, {
-    parameters: ToolParameters;
+    parameters: ToolParameters<JSONObject | unknown>;
 }> | 'automatic' | undefined;
 type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
-    parameters: ToolParameters;
+    parameters: ToolParameters<any>;
 }> ? {
-    [K in keyof TOOL_SCHEMAS]: Tool<TOOL_SCHEMAS[K]['parameters'], CallToolResult> & {
-        execute: (args: inferParameters<TOOL_SCHEMAS[K]['parameters']>, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
-    };
-} : {
-    [k: string]: Tool<z.ZodUnknown, CallToolResult> & {
-        execute: (args: unknown, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
-    };
-};
+    [K in keyof TOOL_SCHEMAS]: MappedTool<TOOL_SCHEMAS[K], CallToolResult> & Required<Pick<MappedTool<TOOL_SCHEMAS[K], CallToolResult>, 'execute'>>;
+} : McpToolSet<Record<string, {
+    parameters: ToolParameters<unknown>;
+}>>;
 declare const CallToolResultSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
     _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
 }, {
@@ -2000,27 +2717,60 @@ declare class MCPClient {
     private onResponse;
 }
 
-type ToolSet = Record<string, Tool>;
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+    'foo': 1,
+    'bar': 2,
+    'biz': 3
+}
+
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+    return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+    return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
+*/
+type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
+
+type ToolSet = Record<string, (Tool<never, never> | Tool<any, any> | Tool<any, never> | Tool<never, any>) & Pick<Tool<any, any>, 'execute'>>;
 
 type ToolCallUnion<TOOLS extends ToolSet> = ValueOf<{
     [NAME in keyof TOOLS]: {
         type: 'tool-call';
         toolCallId: string;
         toolName: NAME & string;
-        args: inferParameters<TOOLS[NAME]['parameters']>;
+        args: TOOLS[NAME] extends Tool<infer PARAMETERS> ? PARAMETERS : never;
     };
 }>;
-/**
- * @deprecated Use `ToolCallUnion` instead.
- */
-type CoreToolCallUnion<TOOLS extends ToolSet> = ToolCallUnion<ToolSet>;
 type ToolCallArray<TOOLS extends ToolSet> = Array<ToolCallUnion<TOOLS>>;
 
-type ToToolsWithExecute<TOOLS extends ToolSet> = {
-    [K in keyof TOOLS as TOOLS[K] extends {
-        execute: any;
-    } ? K : never]: TOOLS[K];
-};
 type ToToolsWithDefinedExecute<TOOLS extends ToolSet> = {
     [K in keyof TOOLS as TOOLS[K]['execute'] extends undefined ? never : K]: TOOLS[K];
 };
@@ -2029,15 +2779,11 @@ type ToToolResultObject<TOOLS extends ToolSet> = ValueOf<{
         type: 'tool-result';
         toolCallId: string;
         toolName: NAME & string;
-        args: inferParameters<TOOLS[NAME]['parameters']>;
+        args: TOOLS[NAME] extends Tool<infer P> ? P : never;
         result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
     };
 }>;
-type ToolResultUnion<TOOLS extends ToolSet> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
-/**
- * @deprecated Use `ToolResultUnion` instead.
- */
-type CoreToolResultUnion<TOOLS extends ToolSet> = ToolResultUnion<TOOLS>;
+type ToolResultUnion<TOOLS extends ToolSet> = ToToolResultObject<ToToolsWithDefinedExecute<TOOLS>>;
 type ToolResultArray<TOOLS extends ToolSet> = Array<ToolResultUnion<TOOLS>>;
 
 /**
@@ -2061,8 +2807,11 @@ type StepResult<TOOLS extends ToolSet> = {
     /**
   The reasoning that was generated during the generation.
   */
-    readonly reasoning: string | undefined;
-    readonly reasoningDetails: Array<ReasoningDetail>;
+    readonly reasoning: Array<Reasoning>;
+    /**
+  The reasoning text that was generated during the generation.
+  */
+    readonly reasoningText: string | undefined;
     /**
   The files that were generated during the generation.
   */
@@ -2086,7 +2835,7 @@ type StepResult<TOOLS extends ToolSet> = {
     /**
   The token usage of the generated text.
   */
-    readonly usage: LanguageModelUsage;
+    readonly usage: LanguageModelUsage$1;
     /**
   Warnings from the model provider (e.g. unsupported settings).
   */
@@ -2122,10 +2871,6 @@ type StepResult<TOOLS extends ToolSet> = {
      */
     readonly providerMetadata: ProviderMetadata | undefined;
     /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
-    /**
   The type of step that this result is for. The first step is always
   an "initial" step, and subsequent steps are either "continue" steps
   or "tool-result" steps.
@@ -2147,19 +2892,19 @@ interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
        */
     readonly text: string;
     /**
+  The full reasoning that the model has generated.
+     */
+    readonly reasoning: Array<Reasoning>;
+    /**
   The reasoning text that the model has generated. Can be undefined if the model
   has only generated text.
      */
-    readonly reasoning: string | undefined;
+    readonly reasoningText: string | undefined;
     /**
   The files that were generated. Empty array if no files were generated.
        */
     readonly files: Array<GeneratedFile>;
     /**
-  The full reasoning that the model has generated.
-     */
-    readonly reasoningDetails: Array<ReasoningDetail>;
-    /**
   Sources that have been used as input to generate the response.
   For multi-step generation, the sources are accumulated from all steps.
      */
@@ -2183,7 +2928,7 @@ interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
     /**
     The token usage of the generated text.
      */
-    readonly usage: LanguageModelUsage;
+    readonly usage: LanguageModelUsage$1;
     /**
     Warnings from the model provider (e.g. unsupported settings)
      */
@@ -2229,21 +2974,11 @@ interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
   results that can be fully encapsulated in the provider.
      */
     readonly providerMetadata: ProviderMetadata | undefined;
-    /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
 }
 
-interface Output<OUTPUT, PARTIAL> {
+interface Output$1<OUTPUT, PARTIAL> {
     readonly type: 'object' | 'text';
-    injectIntoSystemPrompt(options: {
-        system: string | undefined;
-        model: LanguageModel;
-    }): string | undefined;
-    responseFormat: (options: {
-        model: LanguageModel;
-    }) => LanguageModelV2CallOptions['responseFormat'];
+    responseFormat: LanguageModelV2CallOptions['responseFormat'];
     parsePartial(options: {
         text: string;
     }): {
@@ -2253,21 +2988,20 @@ interface Output<OUTPUT, PARTIAL> {
         text: string;
     }, context: {
         response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
+        usage: LanguageModelUsage$1;
         finishReason: FinishReason;
     }): OUTPUT;
 }
-declare const text: () => Output<string, string>;
+declare const text: () => Output$1<string, string>;
 declare const object: <OUTPUT>({ schema: inputSchema, }: {
     schema: z.Schema<OUTPUT, z.ZodTypeDef, any> | Schema<OUTPUT>;
-}) => Output<OUTPUT, DeepPartial<OUTPUT>>;
+}) => Output$1<OUTPUT, DeepPartial<OUTPUT>>;
 
-type output_Output<OUTPUT, PARTIAL> = Output<OUTPUT, PARTIAL>;
 declare const output_object: typeof object;
 declare const output_text: typeof text;
 declare namespace output {
   export {
-    output_Output as Output,
+    Output$1 as Output,
     output_object as object,
     output_text as text,
   };
@@ -2352,13 +3086,13 @@ declare function convertToCoreMessages<TOOLS extends ToolSet = never>(messages:
 type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
     system: string | undefined;
     messages: CoreMessage[];
-    toolCall: LanguageModelV2FunctionToolCall;
+    toolCall: LanguageModelV2ToolCall;
     tools: TOOLS;
     parameterSchema: (options: {
         toolName: string;
-    }) => JSONSchema7;
+    }) => JSONSchema7$1;
     error: NoSuchToolError | InvalidToolArgumentsError;
-}) => Promise<LanguageModelV2FunctionToolCall | null>;
+}) => Promise<LanguageModelV2ToolCall | null>;
 
 /**
 Callback that is set using the `onStepFinish` option.
@@ -2380,7 +3114,7 @@ This function does not stream the output. If you want to stream the output, use
 @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
 @param messages - A list of messages. You can either use `prompt` or `messages` but not both.
 
-@param maxTokens - Maximum number of tokens to generate.
+@param maxOutputTokens - Maximum number of tokens to generate.
 @param temperature - Temperature setting.
 The value is passed through to the provider. The range depends on the provider and model.
 It is recommended to set either `temperature` or `topP`, but not both.
@@ -2413,7 +3147,7 @@ If set and supported by the model, calls will generate deterministic results.
 @returns
 A result object that contains the generated text, the results of the tool calls, and additional information.
  */
-declare function generateText<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
+declare function generateText<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, providerOptions, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -2455,10 +3189,6 @@ functionality that can be fully encapsulated in the provider.
  */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
-     */
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
 Limits the tools that are available for the model to call without
 changing the tool call and result types in the result.
      */
@@ -2466,7 +3196,7 @@ changing the tool call and result types in the result.
     /**
 Optional specification for parsing structured outputs from the LLM response.
      */
-    experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
+    experimental_output?: Output$1<OUTPUT, OUTPUT_PARTIAL>;
     /**
 A function that attempts to repair a tool call that failed to parse.
      */
@@ -2497,8 +3227,8 @@ declare class StreamData {
     private warningTimeout;
     constructor();
     close(): Promise<void>;
-    append(value: JSONValue$1): void;
-    appendMessageAnnotation(value: JSONValue$1): void;
+    append(value: JSONValue): void;
+    appendMessageAnnotation(value: JSONValue): void;
 }
 
 type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
@@ -2539,6 +3269,9 @@ type DataStreamOptions = {
      */
     experimental_sendStart?: boolean;
 };
+type ConsumeStreamOptions = {
+    onError?: (error: unknown) => void;
+};
 /**
 A result object for accessing different stream types and additional information.
  */
@@ -2553,7 +3286,7 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
   
   Resolved when the response is finished.
        */
-    readonly usage: Promise<LanguageModelUsage>;
+    readonly usage: Promise<LanguageModelUsage$1>;
     /**
   Sources that have been used as input to generate the response.
   For multi-step generation, the sources are accumulated from all steps.
@@ -2580,27 +3313,23 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
      */
     readonly providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
-    /**
   The full text that has been generated by the last step.
   
   Resolved when the response is finished.
        */
     readonly text: Promise<string>;
     /**
-  The reasoning that has been generated by the last step.
+  The full reasoning that the model has generated.
   
   Resolved when the response is finished.
-       */
-    readonly reasoning: Promise<string | undefined>;
+     */
+    readonly reasoning: Promise<Array<Reasoning>>;
     /**
-  The full reasoning that the model has generated.
+  The reasoning that has been generated by the last step.
   
   Resolved when the response is finished.
-     */
-    readonly reasoningDetails: Promise<Array<ReasoningDetail>>;
+       */
+    readonly reasoningText: Promise<string | undefined>;
     /**
   The tool calls that have been executed in the last step.
   
@@ -2659,8 +3388,10 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
   This is useful to force the stream to finish.
   It effectively removes the backpressure and allows the stream to finish,
   triggering the `onFinish` callback and the promise resolution.
+  
+  If an error occurs, it is passed to the optional `onError` callback.
     */
-    consumeStream(): Promise<void>;
+    consumeStream(options?: ConsumeStreamOptions): Promise<void>;
     /**
     Converts the result to a data stream.
   
@@ -2735,23 +3466,26 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
     toTextStreamResponse(init?: ResponseInit): Response;
 }
 type TextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-delta';
-    textDelta: string;
+    type: 'text';
+    text: string;
 } | {
     type: 'reasoning';
-    textDelta: string;
+    reasoningType: 'text';
+    text: string;
 } | {
-    type: 'reasoning-signature';
+    type: 'reasoning';
+    reasoningType: 'signature';
     signature: string;
 } | {
-    type: 'redacted-reasoning';
+    type: 'reasoning';
+    reasoningType: 'redacted';
     data: string;
-} | {
-    type: 'source';
-    source: Source;
 } | ({
+    type: 'source';
+} & Source) | {
     type: 'file';
-} & GeneratedFile) | ({
+    file: GeneratedFile;
+} | ({
     type: 'tool-call';
 } & ToolCallUnion<TOOLS>) | {
     type: 'tool-call-streaming-start';
@@ -2776,23 +3510,15 @@ type TextStreamPart<TOOLS extends ToolSet> = {
     request: LanguageModelRequestMetadata;
     warnings: CallWarning[] | undefined;
     response: LanguageModelResponseMetadata;
-    usage: LanguageModelUsage;
+    usage: LanguageModelUsage$1;
     finishReason: FinishReason;
     providerMetadata: ProviderMetadata | undefined;
-    /**
-     * @deprecated Use `providerMetadata` instead.
-     */
-    experimental_providerMetadata?: ProviderMetadata;
     isContinued: boolean;
 } | {
     type: 'finish';
     finishReason: FinishReason;
-    usage: LanguageModelUsage;
+    usage: LanguageModelUsage$1;
     providerMetadata: ProviderMetadata | undefined;
-    /**
-     * @deprecated Use `providerMetadata` instead.
-     */
-    experimental_providerMetadata?: ProviderMetadata;
     /**
      * @deprecated will be moved into provider metadata
      */
@@ -2866,7 +3592,7 @@ Callback that is set using the `onChunk` option.
  */
 type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
     chunk: Extract<TextStreamPart<TOOLS>, {
-        type: 'text-delta' | 'reasoning' | 'source' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
+        type: 'text' | 'reasoning' | 'source' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
     }>;
 }) => Promise<void> | void;
 /**
@@ -2892,7 +3618,7 @@ This function streams the output. If you do not want to stream the output, use `
 @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
 @param messages - A list of messages. You can either use `prompt` or `messages` but not both.
 
-@param maxTokens - Maximum number of tokens to generate.
+@param maxOutputTokens - Maximum number of tokens to generate.
 @param temperature - Temperature setting.
 The value is passed through to the provider. The range depends on the provider and model.
 It is recommended to set either `temperature` or `topP`, but not both.
@@ -2929,7 +3655,7 @@ If set and supported by the model, calls will generate deterministic results.
 @return
 A result object for accessing different stream types and additional information.
  */
-declare function streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_toolCallStreaming, toolCallStreaming, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
+declare function streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, providerOptions, experimental_toolCallStreaming, toolCallStreaming, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -2971,10 +3697,6 @@ functionality that can be fully encapsulated in the provider.
  */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
- */
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
 Limits the tools that are available for the model to call without
 changing the tool call and result types in the result.
      */
@@ -2982,7 +3704,7 @@ changing the tool call and result types in the result.
     /**
 Optional specification for parsing structured outputs from the LLM response.
      */
-    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
+    experimental_output?: Output$1<OUTPUT, PARTIAL_OUTPUT>;
     /**
 A function that attempts to repair a tool call that failed to parse.
      */
@@ -3112,7 +3834,7 @@ declare function generateImage({ model, prompt, n, size, aspectRatio, seed, prov
   }
   ```
        */
-    providerOptions?: Record<string, Record<string, JSONValue>>;
+    providerOptions?: Record<string, Record<string, JSONValue$1>>;
     /**
   Maximum number of retries per embedding model call. Set to 0 to disable retries.
   
@@ -3145,7 +3867,7 @@ interface GenerateObjectResult<OBJECT> {
     /**
     The token usage of the generated text.
        */
-    readonly usage: LanguageModelUsage;
+    readonly usage: LanguageModelUsage$1;
     /**
     Warnings from the model provider (e.g. unsupported settings).
        */
@@ -3177,186 +3899,54 @@ interface GenerateObjectResult<OBJECT> {
      */
     readonly providerMetadata: ProviderMetadata | undefined;
     /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
-    /**
-    Converts the object to a JSON response.
-    The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
-       */
-    toJsonResponse(init?: ResponseInit): Response;
-}
-
-/**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-
-Should return the repaired text or null if the text cannot be repaired.
-     */
-type RepairTextFunction = (options: {
-    text: string;
-    error: JSONParseError | TypeValidationError;
-}) => Promise<string | null>;
-/**
-Generate a structured, typed object for a given prompt and schema using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
-
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
- */
-declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output?: 'object' | undefined;
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The schema of the object that the model should generate.
-   */
-    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
-    /**
-Optional name of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-   */
-    schemaName?: string;
-    /**
-Optional description of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-   */
-    schemaDescription?: string;
-    /**
-The mode to use for object generation.
-
-The schema is converted into a JSON schema and used in one of the following ways
-
-- 'auto': The provider will choose the best mode for the model.
-- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
-- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
-
-Please note that most providers do not support all modes.
-
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
-    /**
-Optional telemetry configuration (experimental).
-     */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-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.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<OBJECT>>;
-/**
-Generate an array with structured, typed elements for a given prompt and element schema using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
-
-@return
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
- */
-declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'array';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The element schema of the array that the model should generate.
-*/
-    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
-    /**
-Optional name of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-   */
-    schemaName?: string;
-    /**
-Optional description of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-*/
-    schemaDescription?: string;
-    /**
-The mode to use for object generation.
-
-The schema is converted into a JSON schema and used in one of the following ways
-
-- 'auto': The provider will choose the best mode for the model.
-- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
-- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
-
-Please note that most providers do not support all modes.
-
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-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.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * Internal. For test use only. May change without notice.
+    Converts the object to a JSON response.
+    The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
+       */
+    toJsonResponse(init?: ResponseInit): Response;
+}
+
+/**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+
+Should return the repaired text or null if the text cannot be repaired.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
+type RepairTextFunction = (options: {
+    text: string;
+    error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;
 /**
-Generate a value from an enum (limited list of string values) using a language model.
+Generate a structured, typed object for a given prompt and schema using a language model.
 
-This function does not stream the output.
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-@return
-A result object that contains the generated value, the finish reason, the token usage, and additional information.
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function generateObject<ENUM extends string>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+declare function generateObject<TYPE extends SCHEMA extends z.Schema ? Output extends 'array' ? Array<z.infer<SCHEMA>> : z.infer<SCHEMA> : SCHEMA extends Schema<infer T> ? Output extends 'array' ? Array<T> : T : never, SCHEMA extends z.Schema | Schema = z.Schema<JSONValue$1>, Output extends 'object' | 'array' | 'enum' | 'no-schema' = TYPE extends string ? 'enum' : 'object'>(options: Omit<CallSettings, 'stopSequences'> & Prompt & (Output extends 'enum' ? {
+    /**
+The enum values that the model should use.
+    */
+    enum: Array<TYPE>;
+    mode?: 'json';
     output: 'enum';
+} : Output extends 'no-schema' ? {} : {
     /**
-The language model to use.
-   */
-    model: LanguageModel;
+The schema of the object that the model should generate.
+    */
+    schema: SCHEMA;
     /**
-The enum values that the model should use.
-   */
-    enum: Array<ENUM>;
+Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+    */
+    schemaName?: string;
+    /**
+Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+    */
+    schemaDescription?: string;
     /**
 The mode to use for object generation.
 
@@ -3369,54 +3959,15 @@ The schema is converted into a JSON schema and used in one of the following ways
 Please note that most providers do not support all modes.
 
 Default and recommended: 'auto' (best mode for the model).
-   */
+    */
     mode?: 'auto' | 'json' | 'tool';
-    /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-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.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<ENUM>>;
-/**
-Generate JSON with any schema for a given prompt using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
-
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
- */
-declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'no-schema';
+}) & {
+    output?: Output;
     /**
 The language model to use.
    */
     model: LanguageModel;
     /**
-The mode to use for object generation. Must be "json" for no-schema output.
-   */
-    mode?: 'json';
-    /**
 A function that attempts to repair the raw output of the mode
 to enable JSON parsing.
    */
@@ -3432,17 +3983,13 @@ functionality that can be fully encapsulated in the provider.
 */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
      * Internal. For test use only. May change without notice.
      */
     _internal?: {
         generateId?: () => string;
         currentDate?: () => Date;
     };
-}): Promise<GenerateObjectResult<JSONValue>>;
+}): Promise<GenerateObjectResult<TYPE>>;
 
 /**
 The result of a `streamObject` call that contains the partial object stream and additional information.
@@ -3455,7 +4002,7 @@ interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
     The token usage of the generated response. Resolved when the response is finished.
        */
-    readonly usage: Promise<LanguageModelUsage>;
+    readonly usage: Promise<LanguageModelUsage$1>;
     /**
   Additional provider-specific metadata. They are passed through
   from the provider to the AI SDK and enable provider-specific
@@ -3463,10 +4010,6 @@ interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
      */
     readonly providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
-    /**
   Additional request information from the last step.
    */
     readonly request: Promise<LanguageModelRequestMetadata>;
@@ -3531,7 +4074,7 @@ type ObjectStreamPart<PARTIAL> = {
     type: 'finish';
     finishReason: FinishReason;
     logprobs?: LogProbs;
-    usage: LanguageModelUsage;
+    usage: LanguageModelUsage$1;
     response: LanguageModelResponseMetadata;
     providerMetadata?: ProviderMetadata;
 };
@@ -3553,7 +4096,7 @@ type StreamObjectOnFinishCallback<RESULT> = (event: {
     /**
   The token usage of the generated response.
   */
-    usage: LanguageModelUsage;
+    usage: LanguageModelUsage$1;
     /**
   The generated object. Can be undefined if the final object does not match the schema.
   */
@@ -3576,10 +4119,6 @@ type StreamObjectOnFinishCallback<RESULT> = (event: {
   functionality that can be fully encapsulated in the provider.
   */
     providerMetadata: ProviderMetadata | undefined;
-    /**
-  @deprecated Use `providerMetadata` instead.
-  */
-    experimental_providerMetadata?: ProviderMetadata;
 }) => Promise<void> | void;
 /**
 Generate a structured, typed object for a given prompt and schema using a language model.
@@ -3636,10 +4175,6 @@ functionality that can be fully encapsulated in the provider.
 */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
 Callback that is invoked when an error occurs during streaming.
 You can use it to log errors.
 The stream processing will pause until the callback promise is resolved.
@@ -3713,10 +4248,6 @@ functionality that can be fully encapsulated in the provider.
 */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
 Callback that is invoked when an error occurs during streaming.
 You can use it to log errors.
 The stream processing will pause until the callback promise is resolved.
@@ -3764,10 +4295,6 @@ functionality that can be fully encapsulated in the provider.
 */
     providerOptions?: ProviderOptions;
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
 Callback that is invoked when an error occurs during streaming.
 You can use it to log errors.
 The stream processing will pause until the callback promise is resolved.
@@ -3776,7 +4303,7 @@ The stream processing will pause until the callback promise is resolved.
     /**
 Callback that is called when the LLM response and the final object validation are finished.
    */
-    onFinish?: StreamObjectOnFinishCallback<JSONValue>;
+    onFinish?: StreamObjectOnFinishCallback<JSONValue$1>;
     /**
      * Internal. For test use only. May change without notice.
      */
@@ -3785,14 +4312,236 @@ Callback that is called when the LLM response and the final object validation ar
         currentDate?: () => Date;
         now?: () => number;
     };
-}): StreamObjectResult<JSONValue, JSONValue, never>;
+}): StreamObjectResult<JSONValue$1, JSONValue$1, never>;
+
+/**
+ * A generated audio file.
+ */
+interface GeneratedAudioFile extends GeneratedFile {
+    /**
+     * Audio format of the file (e.g., 'mp3', 'wav', etc.)
+     */
+    readonly format: string;
+}
+
+/**
+The result of a `generateSpeech` call.
+It contains the audio data and additional information.
+ */
+interface SpeechResult {
+    /**
+     * The audio data as a base64 encoded string or binary data.
+     */
+    readonly audio: GeneratedAudioFile;
+    /**
+    Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<SpeechWarning>;
+    /**
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<SpeechModelResponseMetadata>;
+    /**
+    Provider metadata from the provider.
+     */
+    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
+}
+
+/**
+Generates speech audio using a speech model.
+
+@param model - The speech model to use.
+@param text - The text to convert to speech.
+@param voice - The voice to use for speech generation.
+@param outputFormat - The output format to use for speech generation e.g. "mp3", "wav", etc.
+@param instructions - Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+@param speed - The speed of the speech generation.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated audio data.
+ */
+declare function generateSpeech({ model, text, voice, outputFormat, instructions, speed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
+    /**
+  The speech model to use.
+       */
+    model: SpeechModelV1;
+    /**
+  The text to convert to speech.
+     */
+    text: string;
+    /**
+  The voice to use for speech generation.
+     */
+    voice?: string;
+    /**
+     * The desired output format for the audio e.g. "mp3", "wav", etc.
+     */
+    outputFormat?: 'mp3' | 'wav' | (string & {});
+    /**
+      Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+    */
+    instructions?: string;
+    /**
+    The speed of the speech generation.
+     */
+    speed?: number;
+    /**
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
+  
+  The outer record is keyed by the provider name, and the inner
+  record is keyed by the provider-specific metadata key.
+  ```ts
+  {
+    "openai": {}
+  }
+  ```
+       */
+    providerOptions?: ProviderOptions;
+    /**
+  Maximum number of retries per speech model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<SpeechResult>;
+
+/**
+The result of a `transcribe` call.
+It contains the transcript and additional information.
+ */
+interface TranscriptionResult {
+    /**
+     * The complete transcribed text from the audio.
+     */
+    readonly text: string;
+    /**
+     * Array of transcript segments with timing information.
+     * Each segment represents a portion of the transcribed text with start and end times.
+     */
+    readonly segments: Array<{
+        /**
+         * The text content of this segment.
+         */
+        readonly text: string;
+        /**
+         * The start time of this segment in seconds.
+         */
+        readonly startSecond: number;
+        /**
+         * The end time of this segment in seconds.
+         */
+        readonly endSecond: number;
+    }>;
+    /**
+     * The detected language of the audio content, as an ISO-639-1 code (e.g., 'en' for English).
+     * May be undefined if the language couldn't be detected.
+     */
+    readonly language: string | undefined;
+    /**
+     * The total duration of the audio file in seconds.
+     * May be undefined if the duration couldn't be determined.
+     */
+    readonly durationInSeconds: number | undefined;
+    /**
+    Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<TranscriptionWarning>;
+    /**
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<TranscriptionModelResponseMetadata>;
+    /**
+    Provider metadata from the provider.
+     */
+    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
+}
+
+/**
+Generates transcripts using a transcription model.
+
+@param model - The transcription model to use.
+@param audio - The audio data to transcribe as DataContent (string | Uint8Array | ArrayBuffer | Buffer) or a URL.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated transcript.
+ */
+declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
+    /**
+  The transcription model to use.
+       */
+    model: TranscriptionModelV1;
+    /**
+  The audio data to transcribe.
+     */
+    audio: DataContent | URL;
+    /**
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
+  
+  The outer record is keyed by the provider name, and the inner
+  record is keyed by the provider-specific metadata key.
+  ```ts
+  {
+    "openai": {
+      "temperature": 0
+    }
+  }
+  ```
+       */
+    providerOptions?: ProviderOptions;
+    /**
+  Maximum number of retries per transcript model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<TranscriptionResult>;
 
 /**
  * Applies default settings for a language model.
  */
 declare function defaultSettingsMiddleware({ settings, }: {
-    settings: Partial<LanguageModelV2CallOptions & {
-        providerMetadata?: LanguageModelV2ProviderMetadata;
+    settings: Partial<{
+        maxOutputTokens?: LanguageModelV2CallOptions['maxOutputTokens'] | null;
+        temperature?: LanguageModelV2CallOptions['temperature'] | null;
+        stopSequences?: LanguageModelV2CallOptions['stopSequences'] | null;
+        topP?: LanguageModelV2CallOptions['topP'] | null;
+        topK?: LanguageModelV2CallOptions['topK'] | null;
+        presencePenalty?: LanguageModelV2CallOptions['presencePenalty'] | null;
+        frequencyPenalty?: LanguageModelV2CallOptions['frequencyPenalty'] | null;
+        responseFormat?: LanguageModelV2CallOptions['responseFormat'] | null;
+        seed?: LanguageModelV2CallOptions['seed'] | null;
+        tools?: LanguageModelV2CallOptions['tools'] | null;
+        toolChoice?: LanguageModelV2CallOptions['toolChoice'] | null;
+        headers?: LanguageModelV2CallOptions['headers'];
+        providerOptions?: LanguageModelV2CallOptions['providerOptions'];
     }>;
 }): LanguageModelV2Middleware;
 
@@ -3833,15 +4582,6 @@ declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, p
     modelId?: string;
     providerId?: string;
 }) => LanguageModelV2;
-/**
- * @deprecated Use `wrapLanguageModel` instead.
- */
-declare const experimental_wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
-    model: LanguageModelV2;
-    middleware: LanguageModelV2Middleware | LanguageModelV2Middleware[];
-    modelId?: string;
-    providerId?: string;
-}) => LanguageModelV2;
 
 /**
  * Creates a custom provider with specified language models, text embedding models, and an optional fallback provider.
@@ -3912,21 +4652,13 @@ declare const experimental_createProviderRegistry: typeof createProviderRegistry
  *
  * @param vector1 - The first vector.
  * @param vector2 - The second vector.
- * @param options - Optional configuration.
- * @param options.throwErrorForEmptyVectors - If true, throws an error for empty vectors. Default: false.
  *
  * @returns The cosine similarity between vector1 and vector2.
  * @returns 0 if either vector is the zero vector.
  *
- * @throws {InvalidArgumentError} If throwErrorForEmptyVectors is true and vectors are empty.
  * @throws {InvalidArgumentError} If the vectors do not have the same length.
  */
-declare function cosineSimilarity(vector1: number[], vector2: number[], options?: {
-    /**
-     * @deprecated will be removed in 5.0
-     */
-    throwErrorForEmptyVectors?: boolean;
-}): number;
+declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
 
 /**
  * Creates a ReadableStream that emits the provided values with an optional delay between each value.
@@ -3960,23 +4692,29 @@ declare class InvalidArgumentError extends AISDKError {
 }
 
 type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-delta';
-    textDelta: string;
+    type: 'stream-start';
+    warnings: LanguageModelV2CallWarning[];
+} | {
+    type: 'text';
+    text: string;
 } | {
     type: 'reasoning';
-    textDelta: string;
+    reasoningType: 'text';
+    text: string;
 } | {
-    type: 'reasoning-signature';
+    type: 'reasoning';
+    reasoningType: 'signature';
     signature: string;
 } | {
-    type: 'redacted-reasoning';
+    type: 'reasoning';
+    reasoningType: 'redacted';
     data: string;
-} | ({
+} | {
     type: 'file';
-} & GeneratedFile) | {
-    type: 'source';
-    source: Source;
+    file: GeneratedFile;
 } | ({
+    type: 'source';
+} & Source) | ({
     type: 'tool-call';
 } & ToolCallUnion<TOOLS>) | {
     type: 'tool-call-streaming-start';
@@ -3998,8 +4736,8 @@ type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
     type: 'finish';
     finishReason: FinishReason;
     logprobs?: LogProbs;
-    usage: LanguageModelUsage;
-    experimental_providerMetadata?: ProviderMetadata;
+    usage: LanguageModelUsage$1;
+    providerMetadata?: ProviderMetadata;
 } | {
     type: 'error';
     error: unknown;
@@ -4062,7 +4800,7 @@ declare class NoObjectGeneratedError extends AISDKError {
     /**
     The usage of the model.
      */
-    readonly usage: LanguageModelUsage | undefined;
+    readonly usage: LanguageModelUsage$1 | undefined;
     /**
     Reason why the model finished generating a response.
      */
@@ -4072,7 +4810,7 @@ declare class NoObjectGeneratedError extends AISDKError {
         cause?: Error;
         text?: string;
         response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
+        usage: LanguageModelUsage$1;
         finishReason: FinishReason;
     });
     static isInstance(error: unknown): error is NoObjectGeneratedError;
@@ -4106,11 +4844,11 @@ declare const symbol$6: unique symbol;
 declare class ToolExecutionError extends AISDKError {
     private readonly [symbol$6];
     readonly toolName: string;
-    readonly toolArgs: JSONValue;
+    readonly toolArgs: JSONValue$1 | unknown;
     readonly toolCallId: string;
     constructor({ toolArgs, toolName, toolCallId, cause, message, }: {
         message?: string;
-        toolArgs: JSONValue;
+        toolArgs: JSONValue$1 | unknown;
         toolName: string;
         toolCallId: string;
         cause: unknown;
@@ -4249,7 +4987,7 @@ The following streams are supported:
 - `LangChainAIMessageChunk` streams (LangChain `model.stream` output)
 - `string` streams (LangChain `StringOutputParser` output)
  */
-declare function toDataStream$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array>;
+declare function toDataStream$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array<ArrayBufferLike>>;
 declare function toDataStreamResponse$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, options?: {
     init?: ResponseInit;
     data?: StreamData;
@@ -4271,7 +5009,7 @@ declare namespace langchainAdapter {
 type EngineResponse = {
     delta: string;
 };
-declare function toDataStream(stream: AsyncIterable<EngineResponse>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array>;
+declare function toDataStream(stream: AsyncIterable<EngineResponse>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array<ArrayBufferLike>>;
 declare function toDataStreamResponse(stream: AsyncIterable<EngineResponse>, options?: {
     init?: ResponseInit;
     data?: StreamData;
@@ -4293,4 +5031,4 @@ declare namespace llamaindexAdapter {
   };
 }
 
-export { AssistantContent, CallWarning, ChunkDetector, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolCallUnion, CoreToolChoice, CoreToolMessage, CoreToolResultUnion, CoreUserMessage, DataContent, DataStreamOptions, DataStreamWriter, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, FilePart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedFile, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelResponseMetadata, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, langchainAdapter as LangChainAdapter, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, llamaindexAdapter as LlamaIndexAdapter, LogProbs, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, Provider, ProviderMetadata, ProviderRegistryProvider, RepairTextFunction, RetryError, StepResult, StreamData, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextPart, TextStreamPart, Tool, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolExecutionOptions, ToolResultPart, ToolResultUnion, ToolSet, UserContent, appendClientMessage, appendResponseMessages, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createDataStream, createDataStreamResponse, createProviderRegistry, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, experimental_wrapLanguageModel, extractReasoningMiddleware, generateObject, generateText, pipeDataStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, tool, wrapLanguageModel };
+export { AssistantContent, Attachment, CallSettings, CallWarning, ChatRequest, ChatRequestOptions, ChunkDetector, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateMessage, DataContent, DataStreamOptions, DataStreamPart, DataStreamString, DataStreamWriter, DeepPartial, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, FilePart, FileUIPart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, IdGenerator, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelResponseMetadata, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, langchainAdapter as LangChainAdapter, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage$1 as LanguageModelUsage, llamaindexAdapter as LlamaIndexAdapter, LogProbs, MCPClientError, MCPTransport, Message, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, Prompt, Provider, ProviderMetadata, ProviderOptions, ProviderRegistryProvider, ReasoningUIPart, RepairTextFunction, RequestOptions, RetryError, Schema, SourceUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StepResult, StepStartUIPart, StreamData, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextPart, TextStreamPart, TextUIPart, Tool, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolExecutionOptions, ToolInvocation, ToolInvocationUIPart, ToolResultPart, ToolResultUnion, ToolSet, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UIMessage, UseChatOptions, UseCompletionOptions, UserContent, appendClientMessage, appendResponseMessages, asSchema, callChatApi, callCompletionApi, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createDataStream, createDataStreamResponse, createProviderRegistry, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, extractMaxToolInvocationStep, extractReasoningMiddleware, fillMessageParts, formatDataStreamPart, generateObject, generateText, getMessageParts, getTextFromDataUrl, isAssistantMessageWithCompletedToolCalls, isDeepEqualData, jsonSchema, parseDataStreamPart, parsePartialJson, pipeDataStreamToResponse, prepareAttachmentsForRequest, processDataStream, processTextStream, shouldResubmitMessages, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, tool, updateToolCallResult, wrapLanguageModel, zodSchema };