ai 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ToolResultContent, Schema, ToolCall, ToolResult, Validator, StandardSchemaV1, IdGenerator, InferSchema, FetchFunction } from '@ai-sdk/provider-utils';
+import { ToolResultContent, Schema, IdGenerator, Validator, StandardSchemaV1, ToolCall, FetchFunction, InferSchema } from '@ai-sdk/provider-utils';
 export { IdGenerator, Schema, ToolCall, ToolResult, asSchema, createIdGenerator, generateId, jsonSchema } from '@ai-sdk/provider-utils';
 import { AISDKError, SharedV2ProviderMetadata, SharedV2ProviderOptions, EmbeddingModelV2, EmbeddingModelV2Embedding, ImageModelV2, ImageModelV2CallWarning, ImageModelV2ProviderMetadata, JSONValue as JSONValue$1, LanguageModelV2, LanguageModelV2FinishReason, LanguageModelV2CallWarning, LanguageModelV2Source, SpeechModelV1, SpeechModelV1CallWarning, TranscriptionModelV1, TranscriptionModelV1CallWarning, LanguageModelV2Usage, JSONObject, LanguageModelV2ToolCall, JSONSchema7, LanguageModelV2CallOptions, JSONParseError, TypeValidationError, LanguageModelV2Middleware, ProviderV2, NoSuchModelError } from '@ai-sdk/provider';
 export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, JSONSchema7, LoadAPIKeyError, NoContentGeneratedError, NoSuchModelError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
@@ -1974,6 +1974,9 @@ type SingleRequestTextStreamPart<TOOLS extends ToolSet> = ContentPart<TOOLS> | {
 } | {
     type: 'error';
     error: unknown;
+} | {
+    type: 'raw';
+    rawValue: unknown;
 };
 
 declare const symbol$c: unique symbol;
@@ -2127,29 +2130,34 @@ declare class InvalidMessageRoleError extends AISDKError {
 }
 
 /**
-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.
+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.
 
-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.
+Adopted from [type-fest](https://github.com/sindresorhus/type-fest/tree/main) PartialDeep.
  */
-type ToolInvocation = ({
-    state: 'partial-call';
-} & ToolCall<string, any>) | ({
-    state: 'call';
-} & ToolCall<string, any>) | ({
-    state: 'result';
-} & ToolResult<string, any, any>);
+type DeepPartial<T> = T extends z3.ZodTypeAny ? DeepPartialInternal<z3.infer<T>> : T extends z4.$ZodType ? DeepPartialInternal<z4.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]>;
+};
+
 /**
 The data types that can be used in the UI message for the UI message data parts.
  */
 type UIDataTypes = Record<string, unknown>;
+type UITools = Record<string, {
+    args: unknown;
+    result: unknown | undefined;
+}>;
 /**
 AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
  */
-interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes> {
+interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataTypes, TOOLS extends UITools = UITools> {
     /**
   A unique identifier for the message.
      */
@@ -2172,20 +2180,9 @@ interface UIMessage<METADATA = unknown, DATA_PARTS extends UIDataTypes = UIDataT
   
   Assistant messages can have text, reasoning, tool invocation, and file parts.
      */
-    parts: Array<UIMessagePart<DATA_PARTS>>;
+    parts: Array<UIMessagePart<DATA_PARTS, TOOLS>>;
 }
-type UIMessagePart<DATA_TYPES extends UIDataTypes> = TextUIPart | ReasoningUIPart | ToolInvocationUIPart | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
-type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
-    [NAME in keyof DATA_TYPES & string]: {
-        type: `data-${NAME}`;
-        id?: string;
-        data: DATA_TYPES[NAME];
-    };
-}>;
-type UIDataPartSchemas = Record<string, Validator<any> | StandardSchemaV1<any>>;
-type InferUIDataParts<T extends UIDataPartSchemas> = {
-    [K in keyof T]: T[K] extends Validator<infer U> ? U : T[K] extends StandardSchemaV1<infer U> ? U : unknown;
-};
+type UIMessagePart<DATA_TYPES extends UIDataTypes, TOOLS extends UITools> = TextUIPart | ReasoningUIPart | ToolUIPart<TOOLS> | SourceUrlUIPart | SourceDocumentUIPart | FileUIPart | DataUIPart<DATA_TYPES> | StepStartUIPart;
 /**
  * A text part of a message.
  */
@@ -2210,16 +2207,6 @@ type ReasoningUIPart = {
      */
     providerMetadata?: Record<string, any>;
 };
-/**
- * A tool invocation part of a message.
- */
-type ToolInvocationUIPart = {
-    type: 'tool-invocation';
-    /**
-     * The tool invocation.
-     */
-    toolInvocation: ToolInvocation;
-};
 /**
  * A source part of a message.
  */
@@ -2268,10 +2255,33 @@ type FileUIPart = {
 type StepStartUIPart = {
     type: 'step-start';
 };
-type CreateUIMessage<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = Omit<UIMessage<METADATA, DATA_TYPES>, 'id' | 'role'> & {
-    id?: UIMessage<METADATA, DATA_TYPES>['id'];
-    role?: UIMessage<METADATA, DATA_TYPES>['role'];
-};
+type DataUIPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    [NAME in keyof DATA_TYPES & string]: {
+        type: `data-${NAME}`;
+        id?: string;
+        data: DATA_TYPES[NAME];
+    };
+}>;
+type ToolUIPart<TOOLS extends UITools = UITools> = ValueOf<{
+    [NAME in keyof TOOLS & string]: {
+        type: `tool-${NAME}`;
+        toolCallId: string;
+    } & ({
+        state: 'partial-call';
+        args: DeepPartial<TOOLS[NAME]['args']>;
+    } | {
+        state: 'call';
+        args: TOOLS[NAME]['args'];
+    } | {
+        state: 'result';
+        args: TOOLS[NAME]['args'];
+        result: TOOLS[NAME]['result'];
+    });
+}>;
+declare function isToolUIPart<TOOLS extends UITools>(part: UIMessagePart<UIDataTypes, TOOLS>): part is ToolUIPart<TOOLS>;
+declare function getToolName<TOOLS extends UITools>(part: ToolUIPart<TOOLS>): keyof TOOLS;
+type InferUIMessageMetadata<T extends UIMessage> = T extends UIMessage<infer METADATA> ? METADATA : unknown;
+type InferUIMessageData<T extends UIMessage> = T extends UIMessage<unknown, infer DATA_TYPES> ? DATA_TYPES : UIDataTypes;
 
 declare const symbol$3: unique symbol;
 declare class MessageConversionError extends AISDKError {
@@ -2341,300 +2351,842 @@ declare function callCompletionApi({ api, prompt, credentials, headers, body, st
     fetch: ReturnType<typeof getOriginalFetch> | undefined;
 }): Promise<string | null | undefined>;
 
-/**
-The result of an `embed` call.
-It contains the embedding, the value, and additional information.
- */
-interface EmbedResult<VALUE> {
+type DataUIMessageStreamPart<DATA_TYPES extends UIDataTypes> = ValueOf<{
+    [NAME in keyof DATA_TYPES & string]: {
+        type: `data-${NAME}`;
+        id?: string;
+        data: DATA_TYPES[NAME];
+    };
+}>;
+type UIMessageStreamPart<METADATA = unknown, DATA_TYPES extends UIDataTypes = UIDataTypes> = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'error';
+    errorText: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+    result: unknown;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'tool-call-streaming-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    argsTextDelta: string;
+} | {
+    type: 'reasoning';
+    text: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'reasoning-part-finish';
+} | {
+    type: 'source-url';
+    sourceId: string;
+    url: string;
+    title?: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'source-document';
+    sourceId: string;
+    mediaType: string;
+    title: string;
+    filename?: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'file';
+    url: string;
+    mediaType: string;
+} | DataUIMessageStreamPart<DATA_TYPES> | {
+    type: 'start-step';
+} | {
+    type: 'finish-step';
+} | {
+    type: 'start';
+    messageId?: string;
+    messageMetadata?: METADATA;
+} | {
+    type: 'finish';
+    messageMetadata?: METADATA;
+} | {
+    type: 'message-metadata';
+    messageMetadata: METADATA;
+};
+type InferUIMessageStreamPart<T extends UIMessage> = UIMessageStreamPart<InferUIMessageMetadata<T>, InferUIMessageData<T>>;
+
+interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
     /**
-    The value that was embedded.
-       */
-    readonly value: VALUE;
+     * Appends a data stream part to the stream.
+     */
+    write(part: InferUIMessageStreamPart<UI_MESSAGE>): void;
     /**
-    The embedding of the value.
-      */
-    readonly embedding: Embedding;
+     * Merges the contents of another stream to this stream.
+     */
+    merge(stream: ReadableStream<InferUIMessageStreamPart<UI_MESSAGE>>): void;
     /**
-    The embedding token usage.
-      */
-    readonly usage: EmbeddingModelUsage;
+     * 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 createUIMessageStream<UI_MESSAGE extends UIMessage>({ execute, onError, // mask error messages for safety by default
+originalMessages, onFinish, generateId, }: {
+    execute: (options: {
+        writer: UIMessageStreamWriter<UI_MESSAGE>;
+    }) => Promise<void> | void;
+    onError?: (error: unknown) => string;
     /**
-    Optional response data.
-       */
-    readonly response?: {
+     * The original messages. If they are provided, persistence mode is assumed,
+     * and a message ID is provided for the response message.
+     */
+    originalMessages?: UI_MESSAGE[];
+    onFinish?: (options: {
         /**
-      Response headers.
-           */
-        headers?: Record<string, string>;
+         * The updates list of UI messages.
+         */
+        messages: UI_MESSAGE[];
         /**
-        The response body.
-        */
-        body?: unknown;
-    };
-}
+         * Indicates whether the response message is a continuation of the last original message,
+         * or if a new message was created.
+         */
+        isContinuation: boolean;
+        /**
+         * The message that was sent to the client as a response
+         * (including the original message if it was extended).
+         */
+        responseMessage: UI_MESSAGE;
+    }) => void;
+    generateId?: IdGenerator;
+}): ReadableStream<InferUIMessageStreamPart<UI_MESSAGE>>;
 
-/**
-Embed a value using an embedding model. The type of the value is defined by the embedding model.
+declare function createUIMessageStreamResponse({ status, statusText, headers, stream, }: ResponseInit & {
+    stream: ReadableStream<UIMessageStreamPart>;
+}): Response;
 
-@param model - The embedding model to use.
-@param value - The value that should be embedded.
+declare function pipeUIMessageStreamToResponse({ response, status, statusText, headers, stream, }: {
+    response: ServerResponse;
+    stream: ReadableStream<UIMessageStreamPart>;
+} & ResponseInit): void;
 
-@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.
+declare class JsonToSseTransformStream extends TransformStream<unknown, string> {
+    constructor();
+}
 
-@returns A result object that contains the embedding, the value, and additional information.
- */
-declare function embed<VALUE>({ model, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
+interface ChatTransport<UI_MESSAGE extends UIMessage> {
+    submitMessages: (options: {
+        chatId: string;
+        messages: UI_MESSAGE[];
+        abortSignal: AbortSignal | undefined;
+        requestType: 'generate' | 'resume';
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageStreamPart>>;
+}
+
+type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
+    id?: UI_MESSAGE['id'];
+    role?: UI_MESSAGE['role'];
+};
+type UIDataPartSchemas = Record<string, Validator<any> | StandardSchemaV1<any>>;
+type UIDataTypesToSchemas<T extends UIDataTypes> = {
+    [K in keyof T]: Validator<T[K]> | StandardSchemaV1<T[K]>;
+};
+type InferUIDataParts<T extends UIDataPartSchemas> = {
+    [K in keyof T]: T[K] extends Validator<infer U> ? U : T[K] extends StandardSchemaV1<infer U> ? U : unknown;
+};
+type ChatRequestOptions = {
     /**
-  The embedding model to use.
-       */
-    model: EmbeddingModel<VALUE>;
+    Additional headers that should be to be passed to the API endpoint.
+     */
+    headers?: Record<string, string> | Headers;
     /**
-  The value that should be embedded.
+    Additional body JSON properties that should be sent to the API endpoint.
      */
-    value: VALUE;
+    body?: object;
+    metadata?: unknown;
+};
+type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
+interface ChatState<UI_MESSAGE extends UIMessage> {
+    status: ChatStatus;
+    error: Error | undefined;
+    messages: UI_MESSAGE[];
+    pushMessage: (message: UI_MESSAGE) => void;
+    popMessage: () => void;
+    replaceMessage: (index: number, message: UI_MESSAGE) => void;
+    snapshot: <T>(thing: T) => T;
+}
+interface ChatInit<UI_MESSAGE extends UIMessage> {
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
+     * A unique identifier for the chat. If not provided, a random one will be
+     * generated.
      */
-    maxRetries?: number;
+    id?: string;
+    messageMetadataSchema?: Validator<InferUIMessageMetadata<UI_MESSAGE>> | StandardSchemaV1<InferUIMessageMetadata<UI_MESSAGE>>;
+    dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
+    messages?: UI_MESSAGE[];
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+     * 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;
+    transport?: ChatTransport<UI_MESSAGE>;
+    maxSteps?: number;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
     /**
-    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 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;
     /**
-     * Optional telemetry configuration (experimental).
+     * Optional callback function that is called when the assistant message is finished streaming.
+     *
+     * @param message The message that was streamed.
      */
-    experimental_telemetry?: TelemetrySettings;
-}): Promise<EmbedResult<VALUE>>;
-
-/**
-The result of a `embedMany` call.
-It contains the embeddings, the values, and additional information.
- */
-interface EmbedManyResult<VALUE> {
+    onFinish?: (options: {
+        message: UI_MESSAGE;
+    }) => void;
+}
+declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
+    readonly id: string;
+    readonly generateId: IdGenerator;
+    protected state: ChatState<UI_MESSAGE>;
+    private messageMetadataSchema;
+    private dataPartSchemas;
+    private readonly transport;
+    private maxSteps;
+    private onError?;
+    private onToolCall?;
+    private onFinish?;
+    private activeResponse;
+    private jobExecutor;
+    constructor({ generateId, id, transport, maxSteps, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
+        state: ChatState<UI_MESSAGE>;
+    });
     /**
-    The values that were embedded.
-       */
-    readonly values: Array<VALUE>;
+     * Hook status:
+     *
+     * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
+     * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
+     * - `ready`: The full response has been received and processed; a new user message can be submitted.
+     * - `error`: An error occurred during the API request, preventing successful completion.
+     */
+    get status(): ChatStatus;
+    protected setStatus({ status, error, }: {
+        status: ChatStatus;
+        error?: Error;
+    }): void;
+    get error(): Error | undefined;
+    get messages(): UI_MESSAGE[];
+    get lastMessage(): UI_MESSAGE | undefined;
+    set messages(messages: UI_MESSAGE[]);
+    removeAssistantResponse: () => void;
     /**
-    The embeddings. They are in the same order as the values.
-      */
-    readonly embeddings: Array<Embedding>;
+     * Append a user message to the chat list. This triggers the API call to fetch
+     * the assistant's response.
+     */
+    sendMessage: (message: (CreateUIMessage<UI_MESSAGE> & {
+        text?: never;
+        files?: never;
+    }) | {
+        text: string;
+        files?: FileList | FileUIPart[];
+        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
+        parts?: never;
+    } | {
+        files: FileList | FileUIPart[];
+        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
+        parts?: never;
+    }, options?: ChatRequestOptions) => Promise<void>;
     /**
-    The embedding token usage.
-      */
-    readonly usage: EmbeddingModelUsage;
+     * Regenerate the last assistant message.
+     */
+    reload: (options?: ChatRequestOptions) => Promise<void>;
     /**
-    Optional raw response data.
-       */
-    readonly responses?: Array<{
-        /**
-  Response headers.
-       */
-        headers?: Record<string, string>;
-        /**
-    The response body.
-    */
-        body?: unknown;
-    } | undefined>;
+     * Resume an ongoing chat generation stream. This does not resume an aborted generation.
+     */
+    experimental_resume: (options?: ChatRequestOptions) => Promise<void>;
+    addToolResult: ({ toolCallId, result, }: {
+        toolCallId: string;
+        result: unknown;
+    }) => Promise<void>;
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => Promise<void>;
+    private triggerRequest;
 }
 
+declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
+
 /**
-Embed several values using an embedding model. The type of the value is defined
-by the embedding model.
+Converts an array of messages from useChat into an array of CoreMessages that can be used
+with the AI core functions (e.g. `streamText`).
+ */
+declare function convertToModelMessages<TOOLS extends ToolSet = never>(messages: Array<Omit<UIMessage, 'id'>>, options?: {
+    tools?: TOOLS;
+}): ModelMessage[];
+/**
+@deprecated Use `convertToModelMessages` instead.
+ */
+declare const convertToCoreMessages: typeof convertToModelMessages;
 
-`embedMany` automatically splits large requests into smaller chunks if the model
-has a limit on how many embeddings can be generated in a single call.
+type PrepareRequest<UI_MESSAGE extends UIMessage> = (options: {
+    id: string;
+    messages: UI_MESSAGE[];
+    requestMetadata: unknown;
+    body: Record<string, any> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+}) => {
+    body: object;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+};
 
-@param model - The embedding model to use.
-@param values - The values that should be embedded.
+declare class DefaultChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
+    private api;
+    private credentials?;
+    private headers?;
+    private body?;
+    private fetch?;
+    private prepareRequest?;
+    constructor({ api, credentials, headers, body, fetch, prepareRequest, }?: {
+        api?: string;
+        /**
+         * 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;
+        /**
+      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;
+        /**
+         * When a function is provided, it will be used
+         * to prepare the request body for the chat API. This can be useful for
+         * customizing the request body based on the messages and data in the chat.
+         *
+         * @param id The id of the chat.
+         * @param messages The current messages in the chat.
+         * @param requestBody The request body object passed in the chat request.
+         */
+        prepareRequest?: PrepareRequest<UI_MESSAGE>;
+    });
+    submitMessages({ chatId, messages, abortSignal, metadata, headers, body, requestType, }: Parameters<ChatTransport<UI_MESSAGE>['submitMessages']>[0]): Promise<ReadableStream<UIMessageStreamPart>>;
+}
 
-@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.
+declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
+    private api;
+    private credentials?;
+    private headers?;
+    private body?;
+    private fetch?;
+    private prepareRequest?;
+    constructor({ api, credentials, headers, body, fetch, prepareRequest, }: {
+        api: string;
+        /**
+         * 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;
+        /**
+      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;
+        /**
+         * When a function is provided, it will be used
+         * to prepare the request body for the chat API. This can be useful for
+         * customizing the request body based on the messages and data in the chat.
+         *
+         * @param id The id of the chat.
+         * @param messages The current messages in the chat.
+         * @param requestBody The request body object passed in the chat request.
+         */
+        prepareRequest?: NoInfer<PrepareRequest<UI_MESSAGE>>;
+    });
+    submitMessages({ chatId, messages, abortSignal, metadata, headers, body, requestType, }: Parameters<ChatTransport<UI_MESSAGE>['submitMessages']>[0]): Promise<ReadableStream<UIMessageStreamPart<never, never>>>;
+}
 
-@returns A result object that contains the embeddings, the value, and additional information.
- */
-declare function embedMany<VALUE>({ model, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
+type CompletionRequestOptions = {
     /**
-  The embedding model to use.
+    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.
        */
-    model: EmbeddingModel<VALUE>;
+    body?: object;
+};
+type UseCompletionOptions = {
     /**
-  The values that should be embedded.
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
      */
-    values: Array<VALUE>;
+    api?: string;
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
+     * 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.
      */
-    maxRetries?: number;
+    id?: string;
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+     * Initial prompt input of the completion.
+     */
+    initialInput?: string;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
+     * Initial completion result. Useful to load an existing history.
+     */
+    initialCompletion?: string;
     /**
-     * Optional telemetry configuration (experimental).
+     * Callback function to be called when the completion is finished streaming.
      */
-    experimental_telemetry?: TelemetrySettings;
+    onFinish?: (prompt: string, completion: string) => void;
     /**
-    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;
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
     /**
-     * Maximum number of concurrent requests.
-     *
-     * @default Infinity
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
      */
-    maxParallelCalls?: number;
-}): Promise<EmbedManyResult<VALUE>>;
+    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 message that was generated during the generation process.
-It can be either an assistant message or a tool message.
+ * Calculates the cosine similarity between two vectors. This is a useful metric for
+ * comparing the similarity of two vectors such as embeddings.
+ *
+ * @param vector1 - The first vector.
+ * @param vector2 - The second vector.
+ *
+ * @returns The cosine similarity between vector1 and vector2.
+ * @returns 0 if either vector is the zero vector.
+ *
+ * @throws {InvalidArgumentError} If the vectors do not have the same length.
  */
-type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
 
 /**
- * The result of a single step in the generation process.
+ * Converts a data URL of type text/* to a text string.
  */
-type StepResult<TOOLS extends ToolSet> = {
-    /**
-  The content that was generated in the last step.
-     */
-    readonly content: Array<ContentPart<TOOLS>>;
-    /**
-  The generated text.
-  */
-    readonly text: string;
-    /**
-  The reasoning that was generated during the generation.
-  */
-    readonly reasoning: Array<ReasoningPart>;
-    /**
-  The reasoning text that was generated during the generation.
-  */
-    readonly reasoningText: string | undefined;
-    /**
-  The files that were generated during the generation.
-  */
-    readonly files: Array<GeneratedFile>;
-    /**
-  The sources that were used to generate the text.
-  */
-    readonly sources: Array<Source>;
-    /**
-  The tool calls that were made during the generation.
-  */
-    readonly toolCalls: ToolCallArray<TOOLS>;
-    /**
-  The results of the tool calls.
-  */
-    readonly toolResults: ToolResultArray<TOOLS>;
-    /**
-  The reason why the generation finished.
-  */
-    readonly finishReason: FinishReason;
+declare function getTextFromDataUrl(dataUrl: string): string;
+
+/**
+ * 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): Promise<{
+    value: JSONValue$1 | undefined;
+    state: 'undefined-input' | 'successful-parse' | 'repaired-parse' | 'failed-parse';
+}>;
+
+type Job = () => Promise<void>;
+
+declare class SerialJobExecutor {
+    private queue;
+    private isProcessing;
+    private processQueue;
+    run(job: Job): Promise<void>;
+}
+
+/**
+ * Creates a ReadableStream that emits the provided values with an optional delay between each value.
+ *
+ * @param options - The configuration options
+ * @param options.chunks - Array of values to be emitted by the stream
+ * @param options.initialDelayInMs - Optional initial delay in milliseconds before emitting the first value (default: 0). Can be set to `null` to skip the initial delay. The difference between `initialDelayInMs: null` and `initialDelayInMs: 0` is that `initialDelayInMs: null` will emit the values without any delay, while `initialDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @returns A ReadableStream that emits the provided values
+ */
+declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDelayInMs, _internal, }: {
+    chunks: T[];
+    initialDelayInMs?: number | null;
+    chunkDelayInMs?: number | null;
+    _internal?: {
+        delay?: (ms: number | null) => Promise<void>;
+    };
+}): ReadableStream<T>;
+
+/**
+The result of an `embed` call.
+It contains the embedding, the value, and additional information.
+ */
+interface EmbedResult<VALUE> {
     /**
-  The token usage of the generated text.
-  */
-    readonly usage: LanguageModelUsage;
+    The value that was embedded.
+       */
+    readonly value: VALUE;
     /**
-  Warnings from the model provider (e.g. unsupported settings).
-  */
-    readonly warnings: CallWarning[] | undefined;
+    The embedding of the value.
+      */
+    readonly embedding: Embedding;
     /**
-  Additional request information.
-     */
-    readonly request: LanguageModelRequestMetadata;
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingModelUsage;
     /**
-  Additional response information.
-  */
-    readonly response: LanguageModelResponseMetadata & {
+    Optional response data.
+       */
+    readonly response?: {
         /**
-    The response messages that were generated during the call.
-    Response messages can be either assistant messages or tool messages.
-    They contain a generated id.
-    */
-        readonly messages: Array<ResponseMessage>;
+      Response headers.
+           */
+        headers?: Record<string, string>;
         /**
-    Response body (available only for providers that use HTTP requests).
-         */
+        The response body.
+        */
         body?: unknown;
     };
-    /**
-  Additional provider-specific metadata. They are passed through
-  from the provider to the AI SDK and enable provider-specific
-  results that can be fully encapsulated in the provider.
-     */
-    readonly providerMetadata: ProviderMetadata | undefined;
-};
+}
 
 /**
-The result of a `generateText` call.
-It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+Embed a value using an embedding model. The type of the value is defined by the embedding model.
+
+@param model - The embedding model to use.
+@param value - The value that should be embedded.
+
+@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 embedding, the value, and additional information.
  */
-interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
-    /**
-  The content that was generated in the last step.
-     */
-    readonly content: Array<ContentPart<TOOLS>>;
+declare function embed<VALUE>({ model, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
-  The text that was generated in the last step.
+  The embedding model to use.
        */
-    readonly text: string;
+    model: EmbeddingModel<VALUE>;
     /**
-  The full reasoning that the model has generated in the last step.
+  The value that should be embedded.
      */
-    readonly reasoning: Array<ReasoningPart>;
+    value: VALUE;
     /**
-  The reasoning text that the model has generated in the last step. Can be undefined if the model
-  has only generated text.
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    readonly reasoningText: string | undefined;
-    /**
-  The files that were generated in the last step.
-  Empty array if no files were generated.
-       */
-    readonly files: Array<GeneratedFile>;
+    maxRetries?: number;
     /**
-  Sources that have been used as references in the last step.
-     */
-    readonly sources: Array<Source>;
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
     /**
-  The tool calls that were made in the last step.
-     */
-    readonly toolCalls: ToolCallArray<TOOLS>;
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
     /**
-  The results of the tool calls from the last step.
-     */
-    readonly toolResults: ToolResultArray<TOOLS>;
+    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;
     /**
-  The reason why the generation finished.
+     * Optional telemetry configuration (experimental).
      */
-    readonly finishReason: FinishReason;
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<EmbedResult<VALUE>>;
+
+/**
+The result of a `embedMany` call.
+It contains the embeddings, the values, and additional information.
+ */
+interface EmbedManyResult<VALUE> {
+    /**
+    The values that were embedded.
+       */
+    readonly values: Array<VALUE>;
+    /**
+    The embeddings. They are in the same order as the values.
+      */
+    readonly embeddings: Array<Embedding>;
+    /**
+    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>;
+}
+
+/**
+Embed several values using an embedding model. The type of the value is defined
+by the embedding model.
+
+`embedMany` automatically splits large requests into smaller chunks if the model
+has a limit on how many embeddings can be generated in a single call.
+
+@param model - The embedding model to use.
+@param values - The values that should be embedded.
+
+@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 embeddings, the value, and additional information.
+ */
+declare function embedMany<VALUE>({ model, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
+    /**
+  The embedding model to use.
+       */
+    model: EmbeddingModel<VALUE>;
+    /**
+  The values that should be embedded.
+     */
+    values: Array<VALUE>;
+    /**
+  Maximum number of retries per embedding 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>;
+    /**
+     * 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;
+    /**
+     * Maximum number of concurrent requests.
+     *
+     * @default Infinity
+     */
+    maxParallelCalls?: number;
+}): Promise<EmbedManyResult<VALUE>>;
+
+/**
+A message that was generated during the generation process.
+It can be either an assistant message or a tool message.
+ */
+type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+
+/**
+ * The result of a single step in the generation process.
+ */
+type StepResult<TOOLS extends ToolSet> = {
+    /**
+  The content that was generated in the last step.
+     */
+    readonly content: Array<ContentPart<TOOLS>>;
+    /**
+  The generated text.
+  */
+    readonly text: string;
+    /**
+  The reasoning that was generated during the generation.
+  */
+    readonly reasoning: Array<ReasoningPart>;
+    /**
+  The reasoning text that was generated during the generation.
+  */
+    readonly reasoningText: string | undefined;
+    /**
+  The files that were generated during the generation.
+  */
+    readonly files: Array<GeneratedFile>;
+    /**
+  The sources that were used to generate the text.
+  */
+    readonly sources: Array<Source>;
+    /**
+  The tool calls that were made during the generation.
+  */
+    readonly toolCalls: ToolCallArray<TOOLS>;
+    /**
+  The results of the tool calls.
+  */
+    readonly toolResults: ToolResultArray<TOOLS>;
+    /**
+  The reason why the generation finished.
+  */
+    readonly finishReason: FinishReason;
+    /**
+  The token usage of the generated text.
+  */
+    readonly usage: LanguageModelUsage;
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+  */
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    The response messages that were generated during the call.
+    Response messages can be either assistant messages or tool messages.
+    They contain a generated id.
+    */
+        readonly messages: Array<ResponseMessage>;
+        /**
+    Response body (available only for providers that use HTTP requests).
+         */
+        body?: unknown;
+    };
+    /**
+  Additional provider-specific metadata. They are passed through
+  from the provider to the AI SDK and enable provider-specific
+  results that can be fully encapsulated in the provider.
+     */
+    readonly providerMetadata: ProviderMetadata | undefined;
+};
+
+/**
+The result of a `generateText` call.
+It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+ */
+interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
+    /**
+  The content that was generated in the last step.
+     */
+    readonly content: Array<ContentPart<TOOLS>>;
+    /**
+  The text that was generated in the last step.
+       */
+    readonly text: string;
+    /**
+  The full reasoning that the model has generated in the last step.
+     */
+    readonly reasoning: Array<ReasoningPart>;
+    /**
+  The reasoning text that the model has generated in the last step. Can be undefined if the model
+  has only generated text.
+     */
+    readonly reasoningText: string | undefined;
+    /**
+  The files that were generated in the last step.
+  Empty array if no files were generated.
+       */
+    readonly files: Array<GeneratedFile>;
+    /**
+  Sources that have been used as references in the last step.
+     */
+    readonly sources: Array<Source>;
+    /**
+  The tool calls that were made in the last step.
+     */
+    readonly toolCalls: ToolCallArray<TOOLS>;
+    /**
+  The results of the tool calls from the last step.
+     */
+    readonly toolResults: ToolResultArray<TOOLS>;
+    /**
+  The reason why the generation finished.
+     */
+    readonly finishReason: FinishReason;
     /**
   The token usage of the last step.
      */
@@ -2688,23 +3240,6 @@ interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
     readonly experimental_output: OUTPUT;
 }
 
-/**
-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 z3.ZodTypeAny ? DeepPartialInternal<z3.infer<T>> : T extends z4.$ZodType ? DeepPartialInternal<z4.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]>;
-};
-
 interface Output<OUTPUT, PARTIAL> {
     readonly type: 'object' | 'text';
     responseFormat: LanguageModelV2CallOptions['responseFormat'];
@@ -2888,23 +3423,17 @@ A function that attempts to repair a tool call that failed to parse.
 
 type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
 
-type UIMessageStreamOptions = {
-    /**
-     * Message ID that is sent to the client if a new message is created.
-     * This is intended to be used for the UI message,
-     * if the last original message is not an assistant message
-     * (in which case that message ID is used).
-     */
-    newMessageId?: string;
+type UIMessageStreamOptions<UI_MESSAGE extends UIMessage> = {
     /**
-     * The original messages.
+     * The original messages. If they are provided, persistence mode is assumed,
+     * and a message ID is provided for the response message.
      */
-    originalMessages?: UIMessage[];
+    originalMessages?: UI_MESSAGE[];
     onFinish?: (options: {
         /**
          * The updates list of UI messages.
          */
-        messages: UIMessage[];
+        messages: UI_MESSAGE[];
         /**
          * Indicates whether the response message is a continuation of the last original message,
          * or if a new message was created.
@@ -2914,7 +3443,7 @@ type UIMessageStreamOptions = {
          * The message that was sent to the client as a response
          * (including the original message if it was extended).
          */
-        responseMessage: UIMessage;
+        responseMessage: UI_MESSAGE;
     }) => void;
     /**
      * Extracts message metadata that will be send to the client.
@@ -2922,13 +3451,11 @@ type UIMessageStreamOptions = {
      * Called on `start` and `finish` events.
      */
     messageMetadata?: (options: {
-        part: TextStreamPart<ToolSet> & {
-            type: 'start' | 'finish' | 'start-step' | 'finish-step';
-        };
-    }) => unknown;
+        part: TextStreamPart<ToolSet>;
+    }) => InferUIMessageMetadata<UI_MESSAGE> | undefined;
     /**
      * Send reasoning parts to the client.
-     * Default to false.
+     * Default to true.
      */
     sendReasoning?: boolean;
     /**
@@ -3108,7 +3635,7 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
   
     @return A UI message stream.
        */
-    toUIMessageStream(options?: UIMessageStreamOptions): ReadableStream<UIMessageStreamPart>;
+    toUIMessageStream<UI_MESSAGE extends UIMessage>(options?: UIMessageStreamOptions<UI_MESSAGE>): ReadableStream<InferUIMessageStreamPart<UI_MESSAGE>>;
     /**
     Writes UI message stream output to a Node.js response-like object.
     @param response A Node.js response-like object (ServerResponse).
@@ -3119,7 +3646,7 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
     @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
     @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
        */
-    pipeUIMessageStreamToResponse(response: ServerResponse, options?: ResponseInit & UIMessageStreamOptions): void;
+    pipeUIMessageStreamToResponse<UI_MESSAGE extends UIMessage>(response: ServerResponse, options?: ResponseInit & UIMessageStreamOptions<UI_MESSAGE>): void;
     /**
     Writes text delta output to a Node.js response-like object.
     It sets a `Content-Type` header to `text/plain; charset=utf-8` and
@@ -3139,7 +3666,7 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
     @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
     @return A response object.
        */
-    toUIMessageStreamResponse(options?: ResponseInit & UIMessageStreamOptions): Response;
+    toUIMessageStreamResponse<UI_MESSAGE extends UIMessage>(options?: ResponseInit & UIMessageStreamOptions<UI_MESSAGE>): Response;
     /**
     Creates a simple text stream response.
     Each text delta is encoded as UTF-8 and sent as a separate chunk.
@@ -3178,6 +3705,9 @@ type TextStreamPart<TOOLS extends ToolSet> = ContentPart<TOOLS> | {
 } | {
     type: 'error';
     error: unknown;
+} | {
+    type: 'raw';
+    rawValue: unknown;
 };
 
 /**
@@ -3240,7 +3770,7 @@ Callback that is set using the `onChunk` option.
  */
 type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
     chunk: Extract<TextStreamPart<TOOLS>, {
-        type: 'text' | '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' | 'raw';
     }>;
 }) => Promise<void> | void;
 /**
@@ -3306,7 +3836,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, stopWhen, experimental_output: output, experimental_telemetry: telemetry, prepareStep, 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, stopWhen, experimental_output: output, experimental_telemetry: telemetry, prepareStep, providerOptions, experimental_activeTools, activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, includeRawChunks, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -3366,20 +3896,19 @@ A function that attempts to repair a tool call that failed to parse.
      */
     experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
     /**
-Enable streaming of tool call deltas as they are generated. Disabled by default.
-     */
-    toolCallStreaming?: boolean;
-    /**
-@deprecated Use `toolCallStreaming` instead.
-     */
-    experimental_toolCallStreaming?: boolean;
-    /**
 Optional stream transformations.
 They are applied in the order they are provided.
 The stream transformations must maintain the stream structure for streamText to work correctly.
      */
     experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
     /**
+Whether to include raw chunks from the provider in the stream.
+When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
+This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
+Defaults to false.
+     */
+    includeRawChunks?: boolean;
+    /**
 Callback that is called for each chunk of the stream.
 The stream processing will pause until the callback promise is resolved.
      */
@@ -3706,67 +4235,7 @@ functionality that can be fully encapsulated in the provider.
 }): Promise<GenerateObjectResult<RESULT>>;
 
 /**
- * Calculates the cosine similarity between two vectors. This is a useful metric for
- * comparing the similarity of two vectors such as embeddings.
- *
- * @param vector1 - The first vector.
- * @param vector2 - The second vector.
- *
- * @returns The cosine similarity between vector1 and vector2.
- * @returns 0 if either vector is the zero vector.
- *
- * @throws {InvalidArgumentError} If the vectors do not have the same length.
- */
-declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
-
-/**
- * Converts a data URL of type text/* to a text string.
- */
-declare function getTextFromDataUrl(dataUrl: string): string;
-
-/**
- * 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): Promise<{
-    value: JSONValue$1 | undefined;
-    state: 'undefined-input' | 'successful-parse' | 'repaired-parse' | 'failed-parse';
-}>;
-
-type Job = () => Promise<void>;
-
-declare class SerialJobExecutor {
-    private queue;
-    private isProcessing;
-    private processQueue;
-    run(job: Job): Promise<void>;
-}
-
-/**
- * Creates a ReadableStream that emits the provided values with an optional delay between each value.
- *
- * @param options - The configuration options
- * @param options.chunks - Array of values to be emitted by the stream
- * @param options.initialDelayInMs - Optional initial delay in milliseconds before emitting the first value (default: 0). Can be set to `null` to skip the initial delay. The difference between `initialDelayInMs: null` and `initialDelayInMs: 0` is that `initialDelayInMs: null` will emit the values without any delay, while `initialDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
- * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
- * @returns A ReadableStream that emits the provided values
- */
-declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDelayInMs, _internal, }: {
-    chunks: T[];
-    initialDelayInMs?: number | null;
-    chunkDelayInMs?: number | null;
-    _internal?: {
-        delay?: (ms: number | null) => Promise<void>;
-    };
-}): ReadableStream<T>;
-
-/**
-The result of a `streamObject` call that contains the partial object stream and additional information.
+The result of a `streamObject` call that contains the partial object stream and additional information.
  */
 interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
@@ -4240,603 +4709,124 @@ interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV2>
     languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModelV2;
     languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModelV2;
     textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModelV2<string>;
-    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV2<string>;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV2;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV2;
-}
-/**
- * Creates a registry for the given providers.
- */
-declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV2>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, }?: {
-    separator?: SEPARATOR;
-}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
-/**
- * @deprecated Use `createProviderRegistry` instead.
- */
-declare const experimental_createProviderRegistry: typeof createProviderRegistry;
-
-/**
-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>;
-
-type DataUIMessageStreamPart = {
-    type: `data-${string}`;
-    id?: string;
-    data: unknown;
-};
-type UIMessageStreamPart = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'error';
-    errorText: string;
-} | {
-    type: 'tool-call';
-    toolCallId: string;
-    toolName: string;
-    args: unknown;
-} | {
-    type: 'tool-result';
-    toolCallId: string;
-    result: unknown;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'tool-call-streaming-start';
-    toolCallId: string;
-    toolName: string;
-} | {
-    type: 'tool-call-delta';
-    toolCallId: string;
-    argsTextDelta: string;
-} | {
-    type: 'reasoning';
-    text: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'source-url';
-    sourceId: string;
-    url: string;
-    title?: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'source-document';
-    sourceId: string;
-    mediaType: string;
-    title: string;
-    filename?: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'file';
-    url: string;
-    mediaType: string;
-} | DataUIMessageStreamPart | {
-    type: 'metadata';
-    metadata: unknown;
-} | {
-    type: 'start-step';
-    metadata?: unknown;
-} | {
-    type: 'finish-step';
-    metadata?: unknown;
-} | {
-    type: 'start';
-    messageId?: string;
-    metadata?: unknown;
-} | {
-    type: 'finish';
-    metadata?: unknown;
-} | {
-    type: 'reasoning-part-finish';
-};
-
-interface UIMessageStreamWriter {
-    /**
-     * Appends a data stream part to the stream.
-     */
-    write(part: UIMessageStreamPart): void;
-    /**
-     * Merges the contents of another stream to this stream.
-     */
-    merge(stream: ReadableStream<UIMessageStreamPart>): 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 createUIMessageStream({ execute, onError, // mask error messages for safety by default
-originalMessages, onFinish, }: {
-    execute: (options: {
-        writer: UIMessageStreamWriter;
-    }) => Promise<void> | void;
-    onError?: (error: unknown) => string;
-    /**
-     * The original messages.
-     */
-    originalMessages?: UIMessage[];
-    onFinish?: (options: {
-        /**
-         * The updates list of UI messages.
-         */
-        messages: UIMessage[];
-        /**
-         * Indicates whether the response message is a continuation of the last original message,
-         * or if a new message was created.
-         */
-        isContinuation: boolean;
-        /**
-         * The message that was sent to the client as a response
-         * (including the original message if it was extended).
-         */
-        responseMessage: UIMessage;
-    }) => void;
-}): ReadableStream<UIMessageStreamPart>;
-
-declare function createUIMessageStreamResponse({ status, statusText, headers, stream, }: ResponseInit & {
-    stream: ReadableStream<UIMessageStreamPart>;
-}): Response;
-
-declare function pipeUIMessageStreamToResponse({ response, status, statusText, headers, stream, }: {
-    response: ServerResponse;
-    stream: ReadableStream<UIMessageStreamPart>;
-} & ResponseInit): void;
-
-declare class JsonToSseTransformStream extends TransformStream<unknown, string> {
-    constructor();
-}
-
-interface ChatTransport<MESSAGE_METADATA, DATA_TYPES extends UIDataTypes> {
-    submitMessages: (options: {
-        chatId: string;
-        messages: UIMessage<MESSAGE_METADATA, DATA_TYPES>[];
-        abortSignal: AbortSignal | undefined;
-        requestType: 'generate' | 'resume';
-    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageStreamPart>>;
-}
-
-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;
-    metadata?: unknown;
-};
-interface ChatSubscriber {
-    onChange: (event: ChatEvent) => void;
-}
-interface ChatEvent {
-    type: 'messages-changed' | 'status-changed';
-}
-type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
-interface ChatState<MESSAGE_METADATA, DATA_TYPES extends UIDataTypes> {
-    status: ChatStatus;
-    error: Error | undefined;
-    messages: UIMessage<MESSAGE_METADATA, DATA_TYPES>[];
-    pushMessage: (message: UIMessage<MESSAGE_METADATA, DATA_TYPES>) => void;
-    popMessage: () => void;
-    replaceMessage: (index: number, message: UIMessage<MESSAGE_METADATA, DATA_TYPES>) => void;
-    snapshot: <T>(thing: T) => T;
-}
-interface ChatInit<MESSAGE_METADATA = unknown, UI_DATA_PART_SCHEMAS extends UIDataPartSchemas = UIDataPartSchemas> {
-    /**
-     * A unique identifier for the chat. If not provided, a random one will be
-     * generated.
-     */
-    id?: string;
-    messageMetadataSchema?: Validator<MESSAGE_METADATA> | StandardSchemaV1<MESSAGE_METADATA>;
-    dataPartSchemas?: UI_DATA_PART_SCHEMAS;
-    messages?: UIMessage<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>>[];
-    /**
-     * 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;
-    transport?: ChatTransport<NoInfer<MESSAGE_METADATA>, NoInfer<InferUIDataParts<UI_DATA_PART_SCHEMAS>>>;
-    maxSteps?: number;
-    /**
-     * Callback function to be called when an error is encountered.
-     */
-    onError?: (error: Error) => void;
-    /**
-    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;
-    /**
-     * Optional callback function that is called when the assistant message is finished streaming.
-     *
-     * @param message The message that was streamed.
-     */
-    onFinish?: (options: {
-        message: UIMessage<NoInfer<MESSAGE_METADATA>, NoInfer<InferUIDataParts<UI_DATA_PART_SCHEMAS>>>;
-    }) => void;
-}
-declare abstract class AbstractChat<MESSAGE_METADATA = unknown, UI_DATA_PART_SCHEMAS extends UIDataPartSchemas = UIDataPartSchemas> {
-    readonly id: string;
-    readonly generateId: IdGenerator;
-    protected state: ChatState<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>>;
-    private readonly subscribers;
-    private messageMetadataSchema;
-    private dataPartSchemas;
-    private readonly transport;
-    private maxSteps;
-    private onError?;
-    private onToolCall?;
-    private onFinish?;
-    private activeResponse;
-    private jobExecutor;
-    constructor({ generateId, id, transport, maxSteps, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, }: Omit<ChatInit<MESSAGE_METADATA, UI_DATA_PART_SCHEMAS>, 'messages'> & {
-        state: ChatState<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>>;
-    });
-    /**
-     * Hook status:
-     *
-     * - `submitted`: The message has been sent to the API and we're awaiting the start of the response stream.
-     * - `streaming`: The response is actively streaming in from the API, receiving chunks of data.
-     * - `ready`: The full response has been received and processed; a new user message can be submitted.
-     * - `error`: An error occurred during the API request, preventing successful completion.
-     */
-    get status(): ChatStatus;
-    protected setStatus({ status, error, }: {
-        status: ChatStatus;
-        error?: Error;
-    }): void;
-    get error(): Error | undefined;
-    get messages(): UIMessage<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>>[];
-    get lastMessage(): UIMessage<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>> | undefined;
-    subscribe(subscriber: ChatSubscriber): () => void;
-    set messages(messages: UIMessage<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>>[]);
-    removeAssistantResponse: () => void;
-    /**
-     * Append a user message to the chat list. This triggers the API call to fetch
-     * the assistant's response.
-     */
-    sendMessage: (message: (CreateUIMessage<MESSAGE_METADATA, InferUIDataParts<UI_DATA_PART_SCHEMAS>> & {
-        text?: never;
-        files?: never;
-    }) | {
-        text: string;
-        files?: FileList | FileUIPart[];
-        metadata?: MESSAGE_METADATA;
-        parts?: never;
-    } | {
-        files: FileList | FileUIPart[];
-        metadata?: MESSAGE_METADATA;
-        parts?: never;
-    }, options?: ChatRequestOptions) => Promise<void>;
-    /**
-     * Regenerate the last assistant message.
-     */
-    reload: (options?: ChatRequestOptions) => Promise<void>;
-    /**
-     * Resume an ongoing chat generation stream. This does not resume an aborted generation.
-     */
-    experimental_resume: (options?: ChatRequestOptions) => Promise<void>;
-    addToolResult: ({ toolCallId, result, }: {
-        toolCallId: string;
-        result: unknown;
-    }) => Promise<void>;
-    /**
-     * Abort the current request immediately, keep the generated tokens if any.
-     */
-    stop: () => Promise<void>;
-    private emit;
-    private triggerRequest;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV2<string>;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV2;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV2;
 }
-
-declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
-
 /**
-Converts an array of messages from useChat into an array of CoreMessages that can be used
-with the AI core functions (e.g. `streamText`).
+ * Creates a registry for the given providers.
  */
-declare function convertToModelMessages<TOOLS extends ToolSet = never>(messages: Array<Omit<UIMessage, 'id'>>, options?: {
-    tools?: TOOLS;
-}): ModelMessage[];
+declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV2>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, }?: {
+    separator?: SEPARATOR;
+}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
 /**
-@deprecated Use `convertToModelMessages` instead.
+ * @deprecated Use `createProviderRegistry` instead.
  */
-declare const convertToCoreMessages: typeof convertToModelMessages;
-
-type PrepareRequest<MESSAGE_METADATA, DATA_TYPES extends UIDataTypes> = (options: {
-    id: string;
-    messages: UIMessage<MESSAGE_METADATA, DATA_TYPES>[];
-    requestMetadata: unknown;
-    body: Record<string, any> | undefined;
-    credentials: RequestCredentials | undefined;
-    headers: HeadersInit | undefined;
-}) => {
-    body: object;
-    headers?: HeadersInit;
-    credentials?: RequestCredentials;
-};
-
-declare class DefaultChatTransport<MESSAGE_METADATA, DATA_TYPES extends UIDataTypes> implements ChatTransport<MESSAGE_METADATA, DATA_TYPES> {
-    private api;
-    private credentials?;
-    private headers?;
-    private body?;
-    private fetch?;
-    private prepareRequest?;
-    constructor({ api, credentials, headers, body, fetch, prepareRequest, }?: {
-        api?: string;
-        /**
-         * 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;
-        /**
-      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;
-        /**
-         * When a function is provided, it will be used
-         * to prepare the request body for the chat API. This can be useful for
-         * customizing the request body based on the messages and data in the chat.
-         *
-         * @param id The id of the chat.
-         * @param messages The current messages in the chat.
-         * @param requestBody The request body object passed in the chat request.
-         */
-        prepareRequest?: PrepareRequest<MESSAGE_METADATA, DATA_TYPES>;
-    });
-    submitMessages({ chatId, messages, abortSignal, metadata, headers, body, requestType, }: Parameters<ChatTransport<MESSAGE_METADATA, DATA_TYPES>['submitMessages']>[0]): Promise<ReadableStream<UIMessageStreamPart>>;
-}
-
-declare function getToolInvocations(message: UIMessage): ToolInvocation[];
+declare const experimental_createProviderRegistry: typeof createProviderRegistry;
 
-declare class TextStreamChatTransport<MESSAGE_METADATA, DATA_TYPES extends UIDataTypes> implements ChatTransport<MESSAGE_METADATA, DATA_TYPES> {
-    private api;
-    private credentials?;
-    private headers?;
-    private body?;
-    private fetch?;
-    private prepareRequest?;
-    constructor({ api, credentials, headers, body, fetch, prepareRequest, }: {
-        api: string;
-        /**
-         * The credentials mode to be used for the fetch request.
-         * Possible values are: 'omit', 'same-origin', 'include'.
-         * Defaults to 'same-origin'.
-         */
-        credentials?: RequestCredentials;
+/**
+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<{
         /**
-         * HTTP headers to be sent with the API request.
+         * The text content of this segment.
          */
-        headers?: Record<string, string> | Headers;
+        readonly text: string;
         /**
-         * 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',
-         *   }
-         * })
-         * ```
+         * The start time of this segment in seconds.
          */
-        body?: object;
-        /**
-      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;
+        readonly startSecond: number;
         /**
-         * When a function is provided, it will be used
-         * to prepare the request body for the chat API. This can be useful for
-         * customizing the request body based on the messages and data in the chat.
-         *
-         * @param id The id of the chat.
-         * @param messages The current messages in the chat.
-         * @param requestBody The request body object passed in the chat request.
+         * The end time of this segment in seconds.
          */
-        prepareRequest?: NoInfer<PrepareRequest<MESSAGE_METADATA, DATA_TYPES>>;
-    });
-    submitMessages({ chatId, messages, abortSignal, metadata, headers, body, requestType, }: Parameters<ChatTransport<MESSAGE_METADATA, DATA_TYPES>['submitMessages']>[0]): Promise<ReadableStream<UIMessageStreamPart>>;
-}
-
-type CompletionRequestOptions = {
-    /**
-    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 UseCompletionOptions = {
+        readonly endSecond: number;
+    }>;
     /**
-     * The API endpoint that accepts a `{ prompt: string }` object and returns
-     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
+     * 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.
      */
-    api?: string;
+    readonly language: string | undefined;
     /**
-     * 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.
+     * The total duration of the audio file in seconds.
+     * May be undefined if the duration couldn't be determined.
      */
-    id?: string;
+    readonly durationInSeconds: number | undefined;
     /**
-     * Initial prompt input of the completion.
-     */
-    initialInput?: string;
+    Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<TranscriptionWarning>;
     /**
-     * Initial completion result. Useful to load an existing history.
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
      */
-    initialCompletion?: string;
+    readonly responses: Array<TranscriptionModelResponseMetadata>;
     /**
-     * Callback function to be called when the completion is finished streaming.
+    Provider metadata from the provider.
      */
-    onFinish?: (prompt: string, completion: string) => void;
+    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, }: {
     /**
-     * Callback function to be called when an error is encountered.
-     */
-    onError?: (error: Error) => void;
+  The transcription model to use.
+       */
+    model: TranscriptionModelV1;
     /**
-     * The credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
+  The audio data to transcribe.
      */
-    credentials?: RequestCredentials;
+    audio: DataContent | URL;
     /**
-     * HTTP headers to be sent with the API request.
-     */
-    headers?: Record<string, string> | Headers;
+  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;
     /**
-     * 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',
-     *   }
-     * })
-     * ```
+  Maximum number of retries per transcript model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    body?: object;
+    maxRetries?: number;
     /**
-    Streaming protocol that is used. Defaults to `data`.
-       */
-    streamProtocol?: 'data' | 'text';
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
     /**
-    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;
-};
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<TranscriptionResult>;
 
-export { AbstractChat, AssistantContent, AssistantModelMessage, CallSettings, CallWarning, ChatEvent, ChatInit, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataContent, DataUIPart, DeepPartial, DefaultChatTransport, 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, GLOBAL_DEFAULT_PROVIDER, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, ImagePart, InferUIDataParts, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, ModelMessage, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderOptions, ProviderRegistryProvider, ReasoningUIPart, RepairTextFunction, RetryError, SerialJobExecutor, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, SystemModelMessage, TelemetrySettings, TextPart, TextStreamChatTransport, TextStreamPart, TextUIPart, Tool, ToolCallOptions, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolInvocation, ToolInvocationUIPart, ToolModelMessage, ToolResultPart, ToolResultUnion, ToolSet, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessagePart, UIMessageStreamOptions, UIMessageStreamPart, UIMessageStreamWriter, UseCompletionOptions, UserContent, UserModelMessage, assistantModelMessageSchema, callCompletionApi, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, extractReasoningMiddleware, generateObject, generateText, getTextFromDataUrl, getToolInvocations, hasToolCall, isDeepEqualData, modelMessageSchema, parsePartialJson, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, tool, toolModelMessageSchema, userModelMessageSchema, wrapLanguageModel };
+export { AbstractChat, AssistantContent, AssistantModelMessage, CallSettings, CallWarning, ChatInit, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataContent, DataUIPart, DeepPartial, DefaultChatTransport, 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, GLOBAL_DEFAULT_PROVIDER, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, ImagePart, InferUIDataParts, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, ModelMessage, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderOptions, ProviderRegistryProvider, ReasoningUIPart, RepairTextFunction, RetryError, SerialJobExecutor, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, SystemModelMessage, TelemetrySettings, TextPart, TextStreamChatTransport, TextStreamPart, TextUIPart, Tool, ToolCallOptions, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolModelMessage, ToolResultPart, ToolResultUnion, ToolSet, ToolUIPart, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessagePart, UIMessageStreamOptions, UIMessageStreamPart, UIMessageStreamWriter, UseCompletionOptions, UserContent, UserModelMessage, assistantModelMessageSchema, callCompletionApi, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, extractReasoningMiddleware, generateObject, generateText, getTextFromDataUrl, getToolName, hasToolCall, isDeepEqualData, isToolUIPart, modelMessageSchema, parsePartialJson, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, tool, toolModelMessageSchema, userModelMessageSchema, wrapLanguageModel };