ai 6.0.0-beta.61 → 6.0.0-beta.63

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { createGateway, gateway } from '@ai-sdk/gateway';
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
-import { Tool, InferToolInput, InferToolOutput, AssistantModelMessage, ToolModelMessage, ReasoningPart, ModelMessage, FlexibleSchema, InferSchema, SystemModelMessage, UserModelMessage, ProviderOptions, IdGenerator, ToolCall, DataContent, Resolvable, FetchFunction } from '@ai-sdk/provider-utils';
+import { Tool, InferToolInput, InferToolOutput, AssistantModelMessage, ToolModelMessage, ReasoningPart, FlexibleSchema, InferSchema, ModelMessage, SystemModelMessage, UserModelMessage, ProviderOptions, IdGenerator, ToolCall, Resolvable, FetchFunction, DataContent } from '@ai-sdk/provider-utils';
 export { AssistantContent, AssistantModelMessage, DataContent, FilePart, FlexibleSchema, IdGenerator, ImagePart, InferSchema, InferToolInput, InferToolOutput, ModelMessage, Schema, SystemModelMessage, TextPart, Tool, ToolApprovalRequest, ToolApprovalResponse, ToolCallOptions, ToolCallPart, ToolContent, ToolExecuteFunction, ToolModelMessage, ToolResultPart, UserContent, UserModelMessage, asSchema, createIdGenerator, dynamicTool, generateId, jsonSchema, parseJsonEventStream, tool, zodSchema } from '@ai-sdk/provider-utils';
 import * as _ai_sdk_provider from '@ai-sdk/provider';
 import { EmbeddingModelV3, EmbeddingModelV2, EmbeddingModelV3Embedding, ImageModelV3, ImageModelV3CallWarning, ImageModelV3ProviderMetadata, JSONValue as JSONValue$1, LanguageModelV3, LanguageModelV2, LanguageModelV3FinishReason, LanguageModelV3CallWarning, LanguageModelV3Source, LanguageModelV3Middleware, SharedV3ProviderMetadata, SpeechModelV3, SpeechModelV2, SpeechModelV3CallWarning, TranscriptionModelV3, TranscriptionModelV2, TranscriptionModelV3CallWarning, LanguageModelV3Usage, LanguageModelV3CallOptions, AISDKError, LanguageModelV3ToolCall, JSONSchema7, JSONParseError, TypeValidationError, ProviderV3, ProviderV2, NoSuchModelError, JSONObject } from '@ai-sdk/provider';
@@ -637,6 +637,61 @@ 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 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 FlexibleSchema ? DeepPartialInternal<InferSchema<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 = any, PARTIAL = any> {
+    readonly type: 'object' | 'text';
+    responseFormat: PromiseLike<LanguageModelV3CallOptions['responseFormat']>;
+    parsePartial(options: {
+        text: string;
+    }): Promise<{
+        partial: PARTIAL;
+    } | undefined>;
+    parseOutput(options: {
+        text: string;
+    }, context: {
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+        finishReason: FinishReason;
+    }): Promise<OUTPUT>;
+}
+declare const text: () => Output<string, string>;
+declare const object: <OUTPUT>({ schema: inputSchema, }: {
+    schema: FlexibleSchema<OUTPUT>;
+}) => Output<OUTPUT, DeepPartial<OUTPUT>>;
+type InferGenerateOutput<OUTPUT extends Output> = OUTPUT extends Output<infer T, any> ? T : never;
+type InferStreamOutput<OUTPUT extends Output> = OUTPUT extends Output<any, infer P> ? P : never;
+
+type output_InferGenerateOutput<OUTPUT extends Output> = InferGenerateOutput<OUTPUT>;
+type output_InferStreamOutput<OUTPUT extends Output> = InferStreamOutput<OUTPUT>;
+type output_Output<OUTPUT = any, PARTIAL = any> = Output<OUTPUT, PARTIAL>;
+declare const output_object: typeof object;
+declare const output_text: typeof text;
+declare namespace output {
+  export {
+    output_InferGenerateOutput as InferGenerateOutput,
+    output_InferStreamOutput as InferStreamOutput,
+    output_Output as Output,
+    output_object as object,
+    output_text as text,
+  };
+}
+
 type CallSettings = {
     /**
   Maximum number of tokens to generate.
@@ -806,55 +861,6 @@ type DownloadFunction = (options: Array<{
     mediaType: string | undefined;
 } | null>>;
 
-/**
-Create a type from an object with all keys and nested keys set to optional.
-The helper supports normal objects and 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 FlexibleSchema ? DeepPartialInternal<InferSchema<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: PromiseLike<LanguageModelV3CallOptions['responseFormat']>;
-    parsePartial(options: {
-        text: string;
-    }): Promise<{
-        partial: PARTIAL;
-    } | undefined>;
-    parseOutput(options: {
-        text: string;
-    }, context: {
-        response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
-        finishReason: FinishReason;
-    }): Promise<OUTPUT>;
-}
-declare const text: () => Output<string, string>;
-declare const object: <OUTPUT>({ schema: inputSchema, }: {
-    schema: FlexibleSchema<OUTPUT>;
-}) => Output<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_object as object,
-    output_text as text,
-  };
-}
-
 /**
 Function that you can use to provide different settings for a step.
 
@@ -2381,7 +2387,7 @@ type TextStreamPart<TOOLS extends ToolSet> = {
  * You can implement your own Agent by implementing the `Agent` interface,
  * or use the `ToolLoopAgent` class.
  */
-interface Agent<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PARTIAL = never> {
+interface Agent<TOOLS extends ToolSet = {}, OUTPUT extends Output = never> {
     /**
      * The specification version of the agent interface. This will enable
      * us to evolve the agent interface and retain backwards compatibility.
@@ -2398,11 +2404,11 @@ interface Agent<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PARTIAL = nev
     /**
      * Generates an output from the agent (non-streaming).
      */
-    generate(options: Prompt): PromiseLike<GenerateTextResult<TOOLS, OUTPUT>>;
+    generate(options: Prompt): PromiseLike<GenerateTextResult<TOOLS, InferGenerateOutput<OUTPUT>>>;
     /**
      * Streams an output from the agent (streaming).
      */
-    stream(options: Prompt): StreamTextResult<TOOLS, OUTPUT_PARTIAL>;
+    stream(options: Prompt): StreamTextResult<TOOLS, InferStreamOutput<OUTPUT>>;
 }
 
 /**
@@ -2431,7 +2437,7 @@ type ToolLoopAgentOnStepFinishCallback<TOOLS extends ToolSet = {}> = (stepResult
 /**
  * Configuration options for an agent.
  */
-type ToolLoopAgentSettings<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PARTIAL = never> = CallSettings & {
+type ToolLoopAgentSettings<TOOLS extends ToolSet = {}, OUTPUT extends Output = never> = CallSettings & {
     /**
      * The id of the agent.
      */
@@ -2471,7 +2477,7 @@ type ToolLoopAgentSettings<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PA
     /**
   Optional specification for parsing structured outputs from the LLM response.
      */
-    experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
+    experimental_output?: OUTPUT;
     /**
      * @deprecated Use `prepareStep` instead.
      */
@@ -2519,10 +2525,10 @@ type ToolLoopAgentSettings<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PA
  * - A tool call needs approval, or
  * - A stop condition is met (default stop condition is stepCountIs(20))
  */
-declare class ToolLoopAgent<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PARTIAL = never> implements Agent<TOOLS, OUTPUT, OUTPUT_PARTIAL> {
+declare class ToolLoopAgent<TOOLS extends ToolSet = {}, OUTPUT extends Output = never> implements Agent<TOOLS, OUTPUT> {
     readonly version = "agent-v1";
     private readonly settings;
-    constructor(settings: ToolLoopAgentSettings<TOOLS, OUTPUT, OUTPUT_PARTIAL>);
+    constructor(settings: ToolLoopAgentSettings<TOOLS, OUTPUT>);
     /**
      * The id of the agent.
      */
@@ -2534,17 +2540,17 @@ declare class ToolLoopAgent<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_P
     /**
      * Generates an output from the agent (non-streaming).
      */
-    generate(options: Prompt): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
+    generate(options: Prompt): Promise<GenerateTextResult<TOOLS, InferGenerateOutput<OUTPUT>>>;
     /**
      * Streams an output from the agent (streaming).
      */
-    stream(options: Prompt): StreamTextResult<TOOLS, OUTPUT_PARTIAL>;
+    stream(options: Prompt): StreamTextResult<TOOLS, InferStreamOutput<OUTPUT>>;
 }
 
 /**
  * Infer the type of the tools of an agent.
  */
-type InferAgentTools<AGENT> = AGENT extends Agent<infer TOOLS, any, any> ? TOOLS : never;
+type InferAgentTools<AGENT> = AGENT extends Agent<infer TOOLS, never> ? TOOLS : never;
 
 /**
  * Infer the UI message type of an agent.
@@ -2552,1244 +2558,1241 @@ type InferAgentTools<AGENT> = AGENT extends Agent<infer TOOLS, any, any> ? TOOLS
 type InferAgentUIMessage<AGENT> = UIMessage<never, never, InferUITools<InferAgentTools<AGENT>>>;
 
 /**
- * Runs the agent and stream the output as a UI message stream
- * in the response body.
+ * Runs the agent and returns a response object with a UI message stream.
  *
  * @param agent - The agent to run.
  * @param messages - The input UI messages.
  *
  * @returns The response object.
  */
-declare function createAgentUIStreamResponse<TOOLS extends ToolSet = {}, OUTPUT = never, OUTPUT_PARTIAL = never>({ agent, messages, ...options }: {
-    agent: Agent<TOOLS, OUTPUT, OUTPUT_PARTIAL>;
+declare function createAgentUIStreamResponse<TOOLS extends ToolSet = {}, OUTPUT extends Output = never>({ headers, status, statusText, consumeSseStream, ...options }: {
+    agent: Agent<TOOLS, OUTPUT>;
     messages: unknown[];
-} & UIMessageStreamOptions<UIMessage<never, never, InferUITools<TOOLS>>>): Promise<Response>;
+} & UIMessageStreamResponseInit & UIMessageStreamOptions<UIMessage<never, never, InferUITools<TOOLS>>>): Promise<Response>;
+
+declare const getOriginalFetch: () => typeof fetch;
+declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onFinish, onError, 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;
+    onFinish: ((prompt: string, completion: string) => void) | undefined;
+    onError: ((error: Error) => void) | undefined;
+    fetch: ReturnType<typeof getOriginalFetch> | undefined;
+}): Promise<string | null | undefined>;
 
 /**
-The result of an `embed` call.
-It contains the embedding, the value, and additional information.
+ * Transport interface for handling chat message communication and streaming.
+ *
+ * The `ChatTransport` interface provides fine-grained control over how messages
+ * are sent to API endpoints and how responses are processed. This enables
+ * alternative communication protocols like WebSockets, custom authentication
+ * patterns, or specialized backend integrations.
+ *
+ * @template UI_MESSAGE - The UI message type extending UIMessage
  */
-interface EmbedResult<VALUE> {
-    /**
-    The value that was embedded.
-       */
-    readonly value: VALUE;
-    /**
-    The embedding of the value.
-      */
-    readonly embedding: Embedding;
-    /**
-    The embedding token usage.
-      */
-    readonly usage: EmbeddingModelUsage;
+interface ChatTransport<UI_MESSAGE extends UIMessage> {
     /**
-    Optional provider-specific metadata.
-       */
-    readonly providerMetadata?: ProviderMetadata;
+     * Sends messages to the chat API endpoint and returns a streaming response.
+     *
+     * This method handles both new message submission and message regeneration.
+     * It supports real-time streaming of responses through UIMessageChunk events.
+     *
+     * @param options - Configuration object containing:
+     * @param options.trigger - The type of message submission:
+     *   - `'submit-message'`: Submitting a new user message
+     *   - `'regenerate-message'`: Regenerating an assistant response
+     * @param options.chatId - Unique identifier for the chat session
+     * @param options.messageId - ID of the message to regenerate (for regenerate-message trigger) or undefined for new messages
+     * @param options.messages - Array of UI messages representing the conversation history
+     * @param options.abortSignal - Signal to abort the request if needed
+     * @param options.headers - Additional HTTP headers to include in the request
+     * @param options.body - Additional JSON properties to include in the request body
+     * @param options.metadata - Custom metadata to attach to the request
+     *
+     * @returns Promise resolving to a ReadableStream of UIMessageChunk objects.
+     *   The stream emits various chunk types like:
+     *   - `text-start`, `text-delta`, `text-end`: For streaming text content
+     *   - `tool-input-start`, `tool-input-delta`, `tool-input-available`: For tool calls
+     *   - `data-part-start`, `data-part-delta`, `data-part-available`: For data parts
+     *   - `error`: For error handling
+     *
+     * @throws Error when the API request fails or response is invalid
+     */
+    sendMessages: (options: {
+        /** The type of message submission - either new message or regeneration */
+        trigger: 'submit-message' | 'regenerate-message';
+        /** Unique identifier for the chat session */
+        chatId: string;
+        /** ID of the message to regenerate, or undefined for new messages */
+        messageId: string | undefined;
+        /** Array of UI messages representing the conversation history */
+        messages: UI_MESSAGE[];
+        /** Signal to abort the request if needed */
+        abortSignal: AbortSignal | undefined;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
     /**
-    Optional response data.
-       */
-    readonly response?: {
-        /**
-      Response headers.
-           */
-        headers?: Record<string, string>;
-        /**
-        The response body.
-        */
-        body?: unknown;
-    };
+     * Reconnects to an existing streaming response for the specified chat session.
+     *
+     * This method is used to resume streaming when a connection is interrupted
+     * or when resuming a chat session. It's particularly useful for maintaining
+     * continuity in long-running conversations or recovering from network issues.
+     *
+     * @param options - Configuration object containing:
+     * @param options.chatId - Unique identifier for the chat session to reconnect to
+     * @param options.headers - Additional HTTP headers to include in the reconnection request
+     * @param options.body - Additional JSON properties to include in the request body
+     * @param options.metadata - Custom metadata to attach to the request
+     *
+     * @returns Promise resolving to:
+     *   - `ReadableStream<UIMessageChunk>`: If an active stream is found and can be resumed
+     *   - `null`: If no active stream exists for the specified chat session (e.g., response already completed)
+     *
+     * @throws Error when the reconnection request fails or response is invalid
+     */
+    reconnectToStream: (options: {
+        /** Unique identifier for the chat session to reconnect to */
+        chatId: string;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
 }
 
+type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
+    id?: UI_MESSAGE['id'];
+    role?: UI_MESSAGE['role'];
+};
+type UIDataPartSchemas = Record<string, FlexibleSchema>;
+type UIDataTypesToSchemas<T extends UIDataTypes> = {
+    [K in keyof T]: FlexibleSchema<T[K]>;
+};
+type InferUIDataParts<T extends UIDataPartSchemas> = {
+    [K in keyof T]: InferSchema<T[K]>;
+};
+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;
+};
 /**
-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.
+ * Function that can be called to add a tool approval response to the chat.
  */
-declare function embed<VALUE = string>({ model: modelArg, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
-    /**
-  The embedding model to use.
-       */
-    model: EmbeddingModel<VALUE>;
+type ChatAddToolApproveResponseFunction = ({ id, approved, reason, }: {
+    id: string;
     /**
-  The value that should be embedded.
+     * Flag indicating whether the approval was granted or denied.
      */
-    value: VALUE;
+    approved: boolean;
     /**
-  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>;
-    /**
-    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).
+     * Optional reason for the approval or denial.
      */
-    experimental_telemetry?: TelemetrySettings;
-}): Promise<EmbedResult<VALUE>>;
-
+    reason?: string;
+}) => void | PromiseLike<void>;
+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;
+}
+type ChatOnErrorCallback = (error: Error) => void;
+type ChatOnToolCallCallback<UI_MESSAGE extends UIMessage = UIMessage> = (options: {
+    toolCall: InferUIMessageToolCall<UI_MESSAGE>;
+}) => void | PromiseLike<void>;
+type ChatOnDataCallback<UI_MESSAGE extends UIMessage> = (dataPart: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => void;
 /**
-The result of a `embedMany` call.
-It contains the embeddings, the values, and additional information.
+ * Function that is called when the assistant response has finished streaming.
+ *
+ * @param message The assistant message that was streamed.
+ * @param messages The full chat history, including the assistant message.
+ *
+ * @param isAbort Indicates whether the request has been aborted.
+ * @param isDisconnect Indicates whether the request has been ended by a network error.
+ * @param isError Indicates whether the request has been ended by an error.
  */
-interface EmbedManyResult<VALUE> {
+type ChatOnFinishCallback<UI_MESSAGE extends UIMessage> = (options: {
+    message: UI_MESSAGE;
+    messages: UI_MESSAGE[];
+    isAbort: boolean;
+    isDisconnect: boolean;
+    isError: boolean;
+}) => void;
+interface ChatInit<UI_MESSAGE extends UIMessage> {
     /**
-    The values that were embedded.
-       */
-    readonly values: Array<VALUE>;
+     * A unique identifier for the chat. If not provided, a random one will be
+     * generated.
+     */
+    id?: string;
+    messageMetadataSchema?: FlexibleSchema<InferUIMessageMetadata<UI_MESSAGE>>;
+    dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
+    messages?: UI_MESSAGE[];
     /**
-    The embeddings. They are in the same order as the values.
-      */
-    readonly embeddings: Array<Embedding>;
+     * 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>;
     /**
-    The embedding token usage.
-      */
-    readonly usage: EmbeddingModelUsage;
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: ChatOnErrorCallback;
     /**
-    Optional provider-specific metadata.
+    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.
        */
-    readonly providerMetadata?: ProviderMetadata;
+    onToolCall?: ChatOnToolCallCallback<UI_MESSAGE>;
     /**
-    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 = string>({ model: modelArg, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
+     * Function that is called when the assistant response has finished streaming.
+     */
+    onFinish?: ChatOnFinishCallback<UI_MESSAGE>;
     /**
-  The embedding model to use.
-       */
-    model: EmbeddingModel<VALUE>;
+     * Optional callback function that is called when a data part is received.
+     *
+     * @param data The data part that was received.
+     */
+    onData?: ChatOnDataCallback<UI_MESSAGE>;
     /**
-  The values that should be embedded.
+     * When provided, this function will be called when the stream is finished or a tool call is added
+     * to determine if the current messages should be resubmitted.
      */
-    values: Array<VALUE>;
+    sendAutomaticallyWhen?: (options: {
+        messages: UI_MESSAGE[];
+    }) => boolean | PromiseLike<boolean>;
+}
+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 onError?;
+    private onToolCall?;
+    private onFinish?;
+    private onData?;
+    private sendAutomaticallyWhen?;
+    private activeResponse;
+    private jobExecutor;
+    constructor({ generateId, id, transport, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, onData, sendAutomaticallyWhen, }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
+        state: ChatState<UI_MESSAGE>;
+    });
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
+     * 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.
      */
-    maxRetries?: number;
+    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[]);
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+     * Appends or replaces a user message to the chat list. This triggers the API call to fetch
+     * the assistant's response.
+     *
+     * If a messageId is provided, the message will be replaced.
+     */
+    sendMessage: (message?: (CreateUIMessage<UI_MESSAGE> & {
+        text?: never;
+        files?: never;
+        messageId?: string;
+    }) | {
+        text: string;
+        files?: FileList | FileUIPart[];
+        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
+        parts?: never;
+        messageId?: string;
+    } | {
+        files: FileList | FileUIPart[];
+        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
+        parts?: never;
+        messageId?: string;
+    }, options?: ChatRequestOptions) => Promise<void>;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
+     * Regenerate the assistant message with the provided message id.
+     * If no message id is provided, the last assistant message will be regenerated.
+     */
+    regenerate: ({ messageId, ...options }?: {
+        messageId?: string;
+    } & ChatRequestOptions) => Promise<void>;
     /**
-     * Optional telemetry configuration (experimental).
+     * Attempt to resume an ongoing streaming response.
      */
-    experimental_telemetry?: TelemetrySettings;
+    resumeStream: (options?: ChatRequestOptions) => Promise<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;
+     * Clear the error state and set the status to ready if the chat is in an error state.
+     */
+    clearError: () => void;
+    addToolApprovalResponse: ChatAddToolApproveResponseFunction;
+    addToolResult: <TOOL extends keyof InferUIMessageTools<UI_MESSAGE>>({ state, tool, toolCallId, output, errorText, }: {
+        state?: "output-available";
+        tool: TOOL;
+        toolCallId: string;
+        output: InferUIMessageTools<UI_MESSAGE>[TOOL]["output"];
+        errorText?: never;
+    } | {
+        state: "output-error";
+        tool: TOOL;
+        toolCallId: string;
+        output?: never;
+        errorText: string;
+    }) => Promise<void>;
     /**
-     * Maximum number of concurrent requests.
-     *
-     * @default Infinity
+     * Abort the current request immediately, keep the generated tokens if any.
      */
-    maxParallelCalls?: number;
-}): Promise<EmbedManyResult<VALUE>>;
+    stop: () => Promise<void>;
+    private makeRequest;
+}
 
-declare const symbol$d: unique symbol;
-declare class InvalidArgumentError extends AISDKError {
-    private readonly [symbol$d];
-    readonly parameter: string;
-    readonly value: unknown;
-    constructor({ parameter, value, message, }: {
-        parameter: string;
-        value: unknown;
-        message: string;
-    });
-    static isInstance(error: unknown): error is InvalidArgumentError;
-}
+declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
 
-type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-start';
-    providerMetadata?: ProviderMetadata;
-    id: string;
-} | {
-    type: 'text-delta';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-    delta: string;
-} | {
-    type: 'text-end';
-    providerMetadata?: ProviderMetadata;
-    id: string;
-} | {
-    type: 'reasoning-start';
-    providerMetadata?: ProviderMetadata;
-    id: string;
-} | {
-    type: 'reasoning-delta';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-    delta: string;
-} | {
-    type: 'reasoning-end';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'tool-input-start';
-    id: string;
-    toolName: string;
-    providerMetadata?: ProviderMetadata;
-    dynamic?: boolean;
-} | {
-    type: 'tool-input-delta';
-    id: string;
-    delta: string;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'tool-input-end';
-    id: string;
-    providerMetadata?: ProviderMetadata;
-} | ToolApprovalRequestOutput<TOOLS> | ({
-    type: 'source';
-} & Source) | {
-    type: 'file';
-    file: GeneratedFile;
-} | ({
-    type: 'tool-call';
-} & TypedToolCall<TOOLS>) | ({
-    type: 'tool-result';
-} & TypedToolResult<TOOLS>) | ({
-    type: 'tool-error';
-} & TypedToolError<TOOLS>) | {
-    type: 'file';
-    file: GeneratedFile;
-} | {
-    type: 'stream-start';
-    warnings: LanguageModelV3CallWarning[];
-} | {
-    type: 'response-metadata';
-    id?: string;
-    timestamp?: Date;
-    modelId?: string;
-} | {
-    type: 'finish';
-    finishReason: FinishReason;
-    usage: LanguageModelUsage;
-    providerMetadata?: ProviderMetadata;
-} | {
-    type: 'error';
-    error: unknown;
-} | {
-    type: 'raw';
-    rawValue: unknown;
-};
+/**
+Converts an array of UI messages from useChat into an array of ModelMessages that can be used
+with the AI functions (e.g. `streamText`, `generateText`).
 
-declare const symbol$c: unique symbol;
-declare class InvalidStreamPartError extends AISDKError {
-    private readonly [symbol$c];
-    readonly chunk: SingleRequestTextStreamPart<any>;
-    constructor({ chunk, message, }: {
-        chunk: SingleRequestTextStreamPart<any>;
-        message: string;
-    });
-    static isInstance(error: unknown): error is InvalidStreamPartError;
-}
+@param messages - The UI messages to convert.
+@param options.tools - The tools to use.
+@param options.ignoreIncompleteToolCalls - Whether to ignore incomplete tool calls. Default is `false`.
 
-declare const symbol$b: unique symbol;
+@returns An array of ModelMessages.
+ */
+declare function convertToModelMessages(messages: Array<Omit<UIMessage, 'id'>>, options?: {
+    tools?: ToolSet;
+    ignoreIncompleteToolCalls?: boolean;
+}): ModelMessage[];
 /**
- * An error occurred with the MCP client.
+@deprecated Use `convertToModelMessages` instead.
  */
-declare class MCPClientError extends AISDKError {
-    private readonly [symbol$b];
-    readonly data?: unknown;
-    readonly code?: number;
-    constructor({ name, message, cause, data, code, }: {
-        name?: string;
-        message: string;
-        cause?: unknown;
-        data?: unknown;
-        code?: number;
-    });
-    static isInstance(error: unknown): error is MCPClientError;
-}
+declare const convertToCoreMessages: typeof convertToModelMessages;
 
-declare const symbol$a: unique symbol;
+type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (options: {
+    id: string;
+    messages: UI_MESSAGE[];
+    requestMetadata: unknown;
+    body: Record<string, any> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    api: string;
+} & {
+    trigger: 'submit-message' | 'regenerate-message';
+    messageId: string | undefined;
+}) => {
+    body: object;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+} | PromiseLike<{
+    body: object;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+}>;
+type PrepareReconnectToStreamRequest = (options: {
+    id: string;
+    requestMetadata: unknown;
+    body: Record<string, any> | undefined;
+    credentials: RequestCredentials | undefined;
+    headers: HeadersInit | undefined;
+    api: string;
+}) => {
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+} | PromiseLike<{
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    api?: string;
+}>;
 /**
-Thrown when no image could be generated. This can have multiple causes:
-
-- The model failed to generate a response.
-- The model generated a response that could not be parsed.
+ * Options for the `HttpChatTransport` class.
+ *
+ * @param UI_MESSAGE - The type of message to be used in the chat.
  */
-declare class NoImageGeneratedError extends AISDKError {
-    private readonly [symbol$a];
+type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
     /**
-  The response metadata for each call.
+     * The API URL to be used for the chat transport.
+     * Defaults to '/api/chat'.
      */
-    readonly responses: Array<ImageModelResponseMetadata> | undefined;
-    constructor({ message, cause, responses, }: {
-        message?: string;
-        cause?: Error;
-        responses?: Array<ImageModelResponseMetadata>;
-    });
-    static isInstance(error: unknown): error is NoImageGeneratedError;
-}
-
-declare const symbol$9: unique symbol;
-/**
-Thrown when no object could be generated. This can have several causes:
-
-- The model failed to generate a response.
-- The model generated a response that could not be parsed.
-- The model generated a response that could not be validated against the schema.
-
-The error contains the following properties:
-
-- `text`: The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
- */
-declare class NoObjectGeneratedError extends AISDKError {
-    private readonly [symbol$9];
+    api?: string;
     /**
-    The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
      */
-    readonly text: string | undefined;
+    credentials?: Resolvable<RequestCredentials>;
     /**
-    The response metadata.
+     * HTTP headers to be sent with the API request.
      */
-    readonly response: LanguageModelResponseMetadata | undefined;
+    headers?: Resolvable<Record<string, string> | Headers>;
     /**
-    The usage of the model.
+     * 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',
+     *   }
+     * })
+     * ```
      */
-    readonly usage: LanguageModelUsage | undefined;
+    body?: Resolvable<object>;
     /**
-    Reason why the model finished generating a response.
+    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.
      */
-    readonly finishReason: FinishReason | undefined;
-    constructor({ message, cause, text, response, usage, finishReason, }: {
-        message?: string;
-        cause?: Error;
-        text?: string;
-        response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
-        finishReason: FinishReason;
-    });
-    static isInstance(error: unknown): error is NoObjectGeneratedError;
-}
-
-declare const symbol$8: unique symbol;
-/**
-Thrown when no LLM output was generated, e.g. because of errors.
- */
-declare class NoOutputGeneratedError extends AISDKError {
-    private readonly [symbol$8];
-    constructor({ message, cause, }?: {
-        message?: string;
-        cause?: Error;
-    });
-    static isInstance(error: unknown): error is NoOutputGeneratedError;
-}
-
-declare const symbol$7: unique symbol;
-/**
-Thrown when no output type is specified and output-related methods are called.
- */
-declare class NoOutputSpecifiedError extends AISDKError {
-    private readonly [symbol$7];
-    constructor({ message }?: {
-        message?: string;
-    });
-    static isInstance(error: unknown): error is NoOutputSpecifiedError;
-}
-
-/**
-Error that is thrown when no speech audio was generated.
- */
-declare class NoSpeechGeneratedError extends AISDKError {
-    readonly responses: Array<SpeechModelResponseMetadata>;
-    constructor(options: {
-        responses: Array<SpeechModelResponseMetadata>;
-    });
+    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    /**
+     * 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.
+     */
+    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+};
+declare abstract class HttpChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
+    protected api: string;
+    protected credentials: HttpChatTransportInitOptions<UI_MESSAGE>['credentials'];
+    protected headers: HttpChatTransportInitOptions<UI_MESSAGE>['headers'];
+    protected body: HttpChatTransportInitOptions<UI_MESSAGE>['body'];
+    protected fetch?: FetchFunction;
+    protected prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    protected prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
+    constructor({ api, credentials, headers, body, fetch, prepareSendMessagesRequest, prepareReconnectToStreamRequest, }: HttpChatTransportInitOptions<UI_MESSAGE>);
+    sendMessages({ abortSignal, ...options }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream(options: Parameters<ChatTransport<UI_MESSAGE>['reconnectToStream']>[0]): Promise<ReadableStream<UIMessageChunk> | null>;
+    protected abstract processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
 }
 
-declare const symbol$6: unique symbol;
-declare class ToolCallRepairError extends AISDKError {
-    private readonly [symbol$6];
-    readonly originalError: NoSuchToolError | InvalidToolInputError;
-    constructor({ cause, originalError, message, }: {
-        message?: string;
-        cause: unknown;
-        originalError: NoSuchToolError | InvalidToolInputError;
-    });
-    static isInstance(error: unknown): error is ToolCallRepairError;
+declare class DefaultChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
+    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
+    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
 }
 
 /**
-Error that is thrown when a model with an unsupported version is used.
+Check if the last message is an assistant message with completed tool call approvals.
+The last step of the message must have at least one tool approval response and
+all tool approvals must have a response.
  */
-declare class UnsupportedModelVersionError extends AISDKError {
-    readonly version: string;
-    readonly provider: string;
-    readonly modelId: string;
-    constructor(options: {
-        version: string;
-        provider: string;
-        modelId: string;
-    });
-}
-
-declare const symbol$5: unique symbol;
-declare class InvalidDataContentError extends AISDKError {
-    private readonly [symbol$5];
-    readonly content: unknown;
-    constructor({ content, cause, message, }: {
-        content: unknown;
-        cause?: unknown;
-        message?: string;
-    });
-    static isInstance(error: unknown): error is InvalidDataContentError;
-}
-
-declare const symbol$4: unique symbol;
-declare class InvalidMessageRoleError extends AISDKError {
-    private readonly [symbol$4];
-    readonly role: string;
-    constructor({ role, message, }: {
-        role: string;
-        message?: string;
-    });
-    static isInstance(error: unknown): error is InvalidMessageRoleError;
-}
-
-declare const symbol$3: unique symbol;
-declare class MessageConversionError extends AISDKError {
-    private readonly [symbol$3];
-    readonly originalMessage: Omit<UIMessage, 'id'>;
-    constructor({ originalMessage, message, }: {
-        originalMessage: Omit<UIMessage, 'id'>;
-        message: string;
-    });
-    static isInstance(error: unknown): error is MessageConversionError;
-}
+declare function lastAssistantMessageIsCompleteWithApprovalResponses({ messages, }: {
+    messages: UIMessage[];
+}): boolean;
 
-declare const symbol$2: unique symbol;
-declare class DownloadError extends AISDKError {
-    private readonly [symbol$2];
-    readonly url: string;
-    readonly statusCode?: number;
-    readonly statusText?: string;
-    constructor({ url, statusCode, statusText, cause, message, }: {
-        url: string;
-        statusCode?: number;
-        statusText?: string;
-        message?: string;
-        cause?: unknown;
-    });
-    static isInstance(error: unknown): error is DownloadError;
-}
+/**
+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 lastAssistantMessageIsCompleteWithToolCalls({ messages, }: {
+    messages: UIMessage[];
+}): boolean;
 
-declare const symbol$1: unique symbol;
-type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable' | 'abort';
-declare class RetryError extends AISDKError {
-    private readonly [symbol$1];
-    readonly reason: RetryErrorReason;
-    readonly lastError: unknown;
-    readonly errors: Array<unknown>;
-    constructor({ message, reason, errors, }: {
-        message: string;
-        reason: RetryErrorReason;
-        errors: Array<unknown>;
-    });
-    static isInstance(error: unknown): error is RetryError;
+declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
+    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
+    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
 }
 
-/**
-The result of a `generateImage` call.
-It contains the images and additional information.
- */
-interface GenerateImageResult {
+type CompletionRequestOptions = {
     /**
-  The first image that was generated.
+    An optional object of headers to be passed to the API endpoint.
      */
-    readonly image: GeneratedFile;
-    /**
-  The images that were generated.
-       */
-    readonly images: Array<GeneratedFile>;
+    headers?: Record<string, string> | Headers;
     /**
-  Warnings for the call, e.g. unsupported settings.
+    An optional object to be passed to the API endpoint.
        */
-    readonly warnings: Array<ImageGenerationWarning>;
+    body?: object;
+};
+type UseCompletionOptions = {
     /**
-  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
      */
-    readonly responses: Array<ImageModelResponseMetadata>;
+    api?: string;
     /**
-     * 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.
+     * 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.
      */
-    readonly providerMetadata: ImageModelProviderMetadata;
-}
-
-/**
-Generates images using an image model.
-
-@param model - The image model to use.
-@param prompt - The prompt that should be used to generate the image.
-@param n - Number of images to generate. Default: 1.
-@param size - Size of the images to generate. Must have the format `{width}x{height}`.
-@param aspectRatio - Aspect ratio of the images to generate. Must have the format `{width}:{height}`.
-@param seed - Seed for the image 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 images.
- */
-declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
+    id?: string;
     /**
-  The image model to use.
-       */
-    model: ImageModelV3;
+     * Initial prompt input of the completion.
+     */
+    initialInput?: string;
     /**
-  The prompt that should be used to generate the image.
+     * Initial completion result. Useful to load an existing history.
      */
-    prompt: string;
+    initialCompletion?: string;
     /**
-  Number of images to generate.
+     * Callback function to be called when the completion is finished streaming.
      */
-    n?: number;
+    onFinish?: (prompt: string, completion: string) => void;
     /**
-  Number of images to generate.
+     * Callback function to be called when an error is encountered.
      */
-    maxImagesPerCall?: number;
+    onError?: (error: Error) => void;
     /**
-  Size of the images to generate. Must have the format `{width}x{height}`. If not provided, the default size will be used.
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
      */
-    size?: `${number}x${number}`;
+    credentials?: RequestCredentials;
     /**
-  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
+     * HTTP headers to be sent with the API request.
      */
-    aspectRatio?: `${number}:${number}`;
+    headers?: Record<string, string> | Headers;
     /**
-  Seed for the image generation. If not provided, the default seed will be used.
+     * 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',
+     *   }
+     * })
+     * ```
      */
-    seed?: number;
+    body?: object;
     /**
-  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": {
-      "style": "vivid"
-    }
-  }
-  ```
+    Streaming protocol that is used. Defaults to `data`.
        */
-    providerOptions?: ProviderOptions;
+    streamProtocol?: 'data' | 'text';
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
+    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 SafeValidateUIMessagesResult<UI_MESSAGE extends UIMessage> = {
+    success: true;
+    data: Array<UI_MESSAGE>;
+} | {
+    success: false;
+    error: Error;
+};
+/**
+ * Validates a list of UI messages like `validateUIMessages`,
+ * but instead of throwing it returns `{ success: true, data }`
+ * or `{ success: false, error }`.
+ */
+declare function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools, }: {
+    messages: unknown;
+    metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
+    dataSchemas?: {
+        [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>;
+    };
+    tools?: {
+        [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>;
+    };
+}): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>>;
+/**
+ * Validates a list of UI messages.
+ *
+ * Metadata, data parts, and generic tool call structures are only validated if
+ * the corresponding schemas are provided. Otherwise, they are assumed to be
+ * valid.
+ */
+declare function validateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools, }: {
+    messages: unknown;
+    metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
+    dataSchemas?: {
+        [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>;
+    };
+    tools?: {
+        [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>;
+    };
+}): Promise<Array<UI_MESSAGE>>;
+
+interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
+    /**
+     * Appends a data stream part to the stream.
      */
-    maxRetries?: number;
+    write(part: InferUIMessageChunk<UI_MESSAGE>): void;
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+     * Merges the contents of another stream to this stream.
+     */
+    merge(stream: ReadableStream<InferUIMessageChunk<UI_MESSAGE>>): void;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
-}): Promise<GenerateImageResult>;
+     * Error handler that is used by the data stream writer.
+     * This is intended for forwarding when merging streams
+     * to prevent duplicated error masking.
+     */
+    onError: ErrorHandler | undefined;
+}
+
+declare function createUIMessageStream<UI_MESSAGE extends UIMessage>({ execute, onError, originalMessages, onFinish, generateId, }: {
+    execute: (options: {
+        writer: UIMessageStreamWriter<UI_MESSAGE>;
+    }) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+    /**
+     * 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?: UIMessageStreamOnFinishCallback<UI_MESSAGE>;
+    generateId?: IdGenerator;
+}): ReadableStream<InferUIMessageChunk<UI_MESSAGE>>;
+
+declare function createUIMessageStreamResponse({ status, statusText, headers, stream, consumeSseStream, }: UIMessageStreamResponseInit & {
+    stream: ReadableStream<UIMessageChunk>;
+}): Response;
+
+declare class JsonToSseTransformStream extends TransformStream<unknown, string> {
+    constructor();
+}
+
+declare function pipeUIMessageStreamToResponse({ response, status, statusText, headers, stream, consumeSseStream, }: {
+    response: ServerResponse;
+    stream: ReadableStream<UIMessageChunk>;
+} & UIMessageStreamResponseInit): void;
 
 /**
-The result of a `generateObject` call.
+ * Transforms a stream of `UIMessageChunk`s into an `AsyncIterableStream` of `UIMessage`s.
+ *
+ * @param options.message - The last assistant message to use as a starting point when the conversation is resumed. Otherwise undefined.
+ * @param options.stream - The stream of `UIMessageChunk`s to read.
+ * @param options.terminateOnError - Whether to terminate the stream if an error occurs.
+ * @param options.onError - A function that is called when an error occurs.
+ *
+ * @returns An `AsyncIterableStream` of `UIMessage`s. Each stream part is a different state of the same message
+ * as it is being completed.
  */
-interface GenerateObjectResult<OBJECT> {
+declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({ message, stream, onError, terminateOnError, }: {
+    message?: UI_MESSAGE;
+    stream: ReadableStream<UIMessageChunk>;
+    onError?: (error: unknown) => void;
+    terminateOnError?: boolean;
+}): AsyncIterableStream<UI_MESSAGE>;
+
+declare const UI_MESSAGE_STREAM_HEADERS: {
+    'content-type': string;
+    'cache-control': string;
+    connection: string;
+    'x-vercel-ai-ui-message-stream': string;
+    'x-accel-buffering': string;
+};
+
+/**
+ * Runs the agent and stream the output as a UI message stream.
+ *
+ * @param agent - The agent to run.
+ * @param messages - The input UI messages.
+ *
+ * @returns The UI message stream.
+ */
+declare function createAgentUIStream<TOOLS extends ToolSet = {}, OUTPUT extends Output = never>({ agent, messages, ...uiMessageStreamOptions }: {
+    agent: Agent<TOOLS, OUTPUT>;
+    messages: unknown[];
+} & UIMessageStreamOptions<UIMessage<never, never, InferUITools<TOOLS>>>): Promise<AsyncIterableStream<InferUIMessageChunk<UIMessage<never, never, InferUITools<TOOLS>>>>>;
+
+/**
+ * Pipes the agent UI message stream to a Node.js ServerResponse object.
+ *
+ * @param agent - The agent to run.
+ * @param messages - The input UI messages.
+ */
+declare function pipeAgentUIStreamToResponse<TOOLS extends ToolSet = {}, OUTPUT extends Output = never>({ response, headers, status, statusText, consumeSseStream, ...options }: {
+    response: ServerResponse;
+    agent: Agent<TOOLS, OUTPUT>;
+    messages: unknown[];
+} & UIMessageStreamResponseInit & UIMessageStreamOptions<UIMessage<never, never, InferUITools<TOOLS>>>): Promise<void>;
+
+/**
+The result of an `embed` call.
+It contains the embedding, the value, and additional information.
+ */
+interface EmbedResult<VALUE> {
     /**
-    The generated object (typed according to the schema).
+    The value that was embedded.
        */
-    readonly object: OBJECT;
+    readonly value: VALUE;
     /**
-     * The reasoning that was used to generate the object.
-     * Concatenated from all reasoning parts.
-     */
-    readonly reasoning: string | undefined;
+    The embedding of the value.
+      */
+    readonly embedding: Embedding;
     /**
-    The reason why the generation finished.
-       */
-    readonly finishReason: FinishReason;
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingModelUsage;
     /**
-    The token usage of the generated text.
+    Optional provider-specific metadata.
        */
-    readonly usage: LanguageModelUsage;
+    readonly providerMetadata?: ProviderMetadata;
     /**
-    Warnings from the model provider (e.g. unsupported settings).
+    Optional response data.
        */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  Additional request information.
-     */
-    readonly request: LanguageModelRequestMetadata;
-    /**
-  Additional response information.
-     */
-    readonly response: LanguageModelResponseMetadata & {
+    readonly response?: {
         /**
-    Response body (available only for providers that use HTTP requests).
+      Response headers.
+           */
+        headers?: Record<string, string>;
+        /**
+        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;
-    /**
-    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 model
-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.
-
-@param model - The language model to use.
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
-
-@param system - A system message that will be part of the prompt.
-@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.
+Embed a value using an embedding model. The type of the value is defined by the embedding model.
 
-@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.
-@param topP - Nucleus sampling.
-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.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param stopSequences - Stop sequences.
-If set, the model will stop generating text when one of the stop sequences is generated.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
+@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.
 
-@param schema - The schema of the object that the model should generate.
-@param schemaName - Optional name of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-@param schemaDescription - Optional description of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-
-@param output - The type of the output.
-
-- 'object': The output is an object.
-- 'array': The output is an array.
-- 'enum': The output is an enum.
-- 'no-schema': The output is not a schema.
-
-@param experimental_repairText - A function that attempts to repair the raw output of the model
-to enable JSON parsing.
-
-@param experimental_telemetry - Optional telemetry configuration (experimental).
-
-@param providerOptions - 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.
-
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
+@returns A result object that contains the embedding, the value, and additional information.
  */
-declare function generateObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$1>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<CallSettings, 'stopSequences'> & Prompt & (OUTPUT extends 'enum' ? {
-    /**
-The enum values that the model should use.
-  */
-    enum: Array<RESULT>;
-    mode?: 'json';
-    output: 'enum';
-} : OUTPUT extends 'no-schema' ? {} : {
-    /**
-The schema of the object that the model should generate.
-*/
-    schema: SCHEMA;
-    /**
-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;
+declare function embed<VALUE = string>({ model: modelArg, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
-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';
-}) & {
-    output?: OUTPUT;
+  The embedding model to use.
+       */
+    model: EmbeddingModel<VALUE>;
     /**
-The language model to use.
+  The value that should be embedded.
      */
-    model: LanguageModel;
+    value: VALUE;
     /**
-A function that attempts to repair the raw output of the model
-to enable JSON parsing.
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    experimental_repairText?: RepairTextFunction;
+    maxRetries?: number;
     /**
-Optional telemetry configuration (experimental).
-       */
-    experimental_telemetry?: TelemetrySettings;
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
     /**
-Custom download function to use for URLs.
-
-By default, files are downloaded if the model does not support the URL for the given media type.
-     */
-    experimental_download?: DownloadFunction | undefined;
+  Additional headers to include in the request.
+  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.
- */
+    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;
     /**
-     * Internal. For test use only. May change without notice.
+     * Optional telemetry configuration (experimental).
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<RESULT>>;
-
-/**
- * Consumes a ReadableStream until it's fully read.
- *
- * This function reads the stream chunk by chunk until the stream is exhausted.
- * It doesn't process or return the data from the stream; it simply ensures
- * that the entire stream is read.
- *
- * @param {ReadableStream} stream - The ReadableStream to be consumed.
- * @returns {Promise<void>} A promise that resolves when the stream is fully consumed.
- */
-declare function consumeStream({ stream, onError, }: {
-    stream: ReadableStream;
-    onError?: (error: unknown) => void;
-}): Promise<void>;
-
-/**
- * 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;
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<EmbedResult<VALUE>>;
 
 /**
- * Converts a data URL of type text/* to a text string.
+The result of a `embedMany` call.
+It contains the embeddings, the values, and additional information.
  */
-declare function getTextFromDataUrl(dataUrl: string): string;
+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 provider-specific metadata.
+       */
+    readonly providerMetadata?: ProviderMetadata;
+    /**
+    Optional raw response data.
+       */
+    readonly responses?: Array<{
+        /**
+  Response headers.
+       */
+        headers?: Record<string, string>;
+        /**
+    The response body.
+    */
+        body?: unknown;
+    } | undefined>;
+}
 
 /**
- * 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';
-}>;
+Embed several values using an embedding model. The type of the value is defined
+by the embedding model.
 
-type Job = () => Promise<void>;
+`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.
 
-declare class SerialJobExecutor {
-    private queue;
-    private isProcessing;
-    private processQueue;
-    run(job: Job): Promise<void>;
-}
+@param model - The embedding model to use.
+@param values - The values that should be embedded.
 
-/**
- * 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>;
+@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.
 
-/**
-The result of a `streamObject` call that contains the partial object stream and additional information.
+@returns A result object that contains the embeddings, the value, and additional information.
  */
-interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
+declare function embedMany<VALUE = string>({ model: modelArg, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
     /**
-    Warnings from the model provider (e.g. unsupported settings)
+  The embedding model to use.
        */
-    readonly warnings: Promise<CallWarning[] | undefined>;
+    model: EmbeddingModel<VALUE>;
     /**
-    The token usage of the generated response. Resolved when the response is finished.
-       */
-    readonly usage: Promise<LanguageModelUsage>;
+  The values that should be embedded.
+     */
+    values: Array<VALUE>;
     /**
-  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.
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
+    maxRetries?: number;
     /**
-  Additional request information from the last step.
+  Abort signal.
    */
-    readonly request: Promise<LanguageModelRequestMetadata>;
+    abortSignal?: AbortSignal;
     /**
-  Additional response information.
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
    */
-    readonly response: Promise<LanguageModelResponseMetadata>;
+    headers?: Record<string, string>;
     /**
-  The reason why the generation finished. Taken from the last step.
-  
-  Resolved when the response is finished.
-       */
-    readonly finishReason: Promise<FinishReason>;
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
     /**
-    The generated object (typed according to the schema). Resolved when the response is finished.
-       */
-    readonly object: Promise<RESULT>;
+    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;
     /**
-    Stream of partial objects. It gets more complete as the stream progresses.
-  
-    Note that the partial object is not validated.
-    If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
-       */
-    readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
-    /**
-     * Stream over complete array elements. Only available if the output strategy is set to `array`.
+     * Maximum number of concurrent requests.
+     *
+     * @default Infinity
      */
-    readonly elementStream: ELEMENT_STREAM;
-    /**
-    Text stream of the JSON representation of the generated object. It contains text chunks.
-    When the stream is finished, the object is valid JSON that can be parsed.
-       */
-    readonly textStream: AsyncIterableStream<string>;
-    /**
-    Stream of different types of events, including partial objects, errors, and finish events.
-    Only errors that stop the stream, such as network errors, are thrown.
-       */
-    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
-    /**
-    Writes text delta output to a Node.js response-like object.
-    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-    writes each text delta as a separate chunk.
-  
-    @param response A Node.js response-like object (ServerResponse).
-    @param init Optional headers, status code, and status text.
-       */
-    pipeTextStreamToResponse(response: ServerResponse$1, init?: ResponseInit): void;
-    /**
-    Creates a simple text stream response.
-    The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
-    Each text delta is encoded as UTF-8 and sent as a separate chunk.
-    Non-text-delta events are ignored.
-  
-    @param init Optional headers, status code, and status text.
-       */
-    toTextStreamResponse(init?: ResponseInit): Response;
+    maxParallelCalls?: number;
+}): Promise<EmbedManyResult<VALUE>>;
+
+declare const symbol$d: unique symbol;
+declare class InvalidArgumentError extends AISDKError {
+    private readonly [symbol$d];
+    readonly parameter: string;
+    readonly value: unknown;
+    constructor({ parameter, value, message, }: {
+        parameter: string;
+        value: unknown;
+        message: string;
+    });
+    static isInstance(error: unknown): error is InvalidArgumentError;
 }
-type ObjectStreamPart<PARTIAL> = {
-    type: 'object';
-    object: PARTIAL;
+
+type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
+    type: 'text-start';
+    providerMetadata?: ProviderMetadata;
+    id: string;
 } | {
     type: 'text-delta';
-    textDelta: string;
+    id: string;
+    providerMetadata?: ProviderMetadata;
+    delta: string;
 } | {
-    type: 'error';
-    error: unknown;
+    type: 'text-end';
+    providerMetadata?: ProviderMetadata;
+    id: string;
+} | {
+    type: 'reasoning-start';
+    providerMetadata?: ProviderMetadata;
+    id: string;
+} | {
+    type: 'reasoning-delta';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+    delta: string;
+} | {
+    type: 'reasoning-end';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'tool-input-start';
+    id: string;
+    toolName: string;
+    providerMetadata?: ProviderMetadata;
+    dynamic?: boolean;
+} | {
+    type: 'tool-input-delta';
+    id: string;
+    delta: string;
+    providerMetadata?: ProviderMetadata;
+} | {
+    type: 'tool-input-end';
+    id: string;
+    providerMetadata?: ProviderMetadata;
+} | ToolApprovalRequestOutput<TOOLS> | ({
+    type: 'source';
+} & Source) | {
+    type: 'file';
+    file: GeneratedFile;
+} | ({
+    type: 'tool-call';
+} & TypedToolCall<TOOLS>) | ({
+    type: 'tool-result';
+} & TypedToolResult<TOOLS>) | ({
+    type: 'tool-error';
+} & TypedToolError<TOOLS>) | {
+    type: 'file';
+    file: GeneratedFile;
+} | {
+    type: 'stream-start';
+    warnings: LanguageModelV3CallWarning[];
+} | {
+    type: 'response-metadata';
+    id?: string;
+    timestamp?: Date;
+    modelId?: string;
 } | {
     type: 'finish';
     finishReason: FinishReason;
     usage: LanguageModelUsage;
-    response: LanguageModelResponseMetadata;
     providerMetadata?: ProviderMetadata;
+} | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'raw';
+    rawValue: unknown;
 };
 
-/**
-Callback that is set using the `onError` option.
+declare const symbol$c: unique symbol;
+declare class InvalidStreamPartError extends AISDKError {
+    private readonly [symbol$c];
+    readonly chunk: SingleRequestTextStreamPart<any>;
+    constructor({ chunk, message, }: {
+        chunk: SingleRequestTextStreamPart<any>;
+        message: string;
+    });
+    static isInstance(error: unknown): error is InvalidStreamPartError;
+}
 
-@param event - The event that is passed to the callback.
+declare const symbol$b: unique symbol;
+/**
+ * An error occurred with the MCP client.
  */
-type StreamObjectOnErrorCallback = (event: {
-    error: unknown;
-}) => Promise<void> | void;
+declare class MCPClientError extends AISDKError {
+    private readonly [symbol$b];
+    readonly data?: unknown;
+    readonly code?: number;
+    constructor({ name, message, cause, data, code, }: {
+        name?: string;
+        message: string;
+        cause?: unknown;
+        data?: unknown;
+        code?: number;
+    });
+    static isInstance(error: unknown): error is MCPClientError;
+}
+
+declare const symbol$a: unique symbol;
 /**
-Callback that is set using the `onFinish` option.
+Thrown when no image could be generated. This can have multiple causes:
 
-@param event - The event that is passed to the callback.
+- The model failed to generate a response.
+- The model generated a response that could not be parsed.
  */
-type StreamObjectOnFinishCallback<RESULT> = (event: {
-    /**
-  The token usage of the generated response.
-  */
-    usage: LanguageModelUsage;
+declare class NoImageGeneratedError extends AISDKError {
+    private readonly [symbol$a];
     /**
-  The generated object. Can be undefined if the final object does not match the schema.
-  */
-    object: RESULT | undefined;
+  The response metadata for each call.
+     */
+    readonly responses: Array<ImageModelResponseMetadata> | undefined;
+    constructor({ message, cause, responses, }: {
+        message?: string;
+        cause?: Error;
+        responses?: Array<ImageModelResponseMetadata>;
+    });
+    static isInstance(error: unknown): error is NoImageGeneratedError;
+}
+
+declare const symbol$9: unique symbol;
+/**
+Thrown when no object could be generated. This can have several causes:
+
+- The model failed to generate a response.
+- The model generated a response that could not be parsed.
+- The model generated a response that could not be validated against the schema.
+
+The error contains the following properties:
+
+- `text`: The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+ */
+declare class NoObjectGeneratedError extends AISDKError {
+    private readonly [symbol$9];
     /**
-  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
-  */
-    error: unknown | undefined;
+    The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+     */
+    readonly text: string | undefined;
     /**
-  Response metadata.
-   */
-    response: LanguageModelResponseMetadata;
+    The response metadata.
+     */
+    readonly response: LanguageModelResponseMetadata | undefined;
     /**
-  Warnings from the model provider (e.g. unsupported settings).
-  */
-    warnings?: CallWarning[];
+    The usage of the model.
+     */
+    readonly usage: LanguageModelUsage | undefined;
     /**
-  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.
-  */
-    providerMetadata: ProviderMetadata | undefined;
-}) => Promise<void> | void;
-/**
-Generate a structured, typed object for a given prompt and schema using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` instead.
+    Reason why the model finished generating a response.
+     */
+    readonly finishReason: FinishReason | undefined;
+    constructor({ message, cause, text, response, usage, finishReason, }: {
+        message?: string;
+        cause?: Error;
+        text?: string;
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+        finishReason: FinishReason;
+    });
+    static isInstance(error: unknown): error is NoObjectGeneratedError;
+}
 
-@param model - The language model to use.
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
+declare const symbol$8: unique symbol;
+/**
+Thrown when no LLM output was generated, e.g. because of errors.
+ */
+declare class NoOutputGeneratedError extends AISDKError {
+    private readonly [symbol$8];
+    constructor({ message, cause, }?: {
+        message?: string;
+        cause?: Error;
+    });
+    static isInstance(error: unknown): error is NoOutputGeneratedError;
+}
 
-@param system - A system message that will be part of the prompt.
-@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.
+declare const symbol$7: unique symbol;
+/**
+Thrown when no output type is specified and output-related methods are called.
+ */
+declare class NoOutputSpecifiedError extends AISDKError {
+    private readonly [symbol$7];
+    constructor({ message }?: {
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoOutputSpecifiedError;
+}
 
-@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.
-@param topP - Nucleus sampling.
-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.
-@param topK - Only sample from the top K options for each subsequent token.
-Used to remove "long tail" low probability responses.
-Recommended for advanced use cases only. You usually only need to use temperature.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param stopSequences - Stop sequences.
-If set, the model will stop generating text when one of the stop sequences is generated.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
+/**
+Error that is thrown when no speech audio was generated.
+ */
+declare class NoSpeechGeneratedError extends AISDKError {
+    readonly responses: Array<SpeechModelResponseMetadata>;
+    constructor(options: {
+        responses: Array<SpeechModelResponseMetadata>;
+    });
+}
 
-@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 const symbol$6: unique symbol;
+declare class ToolCallRepairError extends AISDKError {
+    private readonly [symbol$6];
+    readonly originalError: NoSuchToolError | InvalidToolInputError;
+    constructor({ cause, originalError, message, }: {
+        message?: string;
+        cause: unknown;
+        originalError: NoSuchToolError | InvalidToolInputError;
+    });
+    static isInstance(error: unknown): error is ToolCallRepairError;
+}
 
-@param schema - The schema of the object that the model should generate.
-@param schemaName - Optional name of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-@param schemaDescription - Optional description of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
+/**
+Error that is thrown when a model with an unsupported version is used.
+ */
+declare class UnsupportedModelVersionError extends AISDKError {
+    readonly version: string;
+    readonly provider: string;
+    readonly modelId: string;
+    constructor(options: {
+        version: string;
+        provider: string;
+        modelId: string;
+    });
+}
 
-@param output - The type of the output.
+declare const symbol$5: unique symbol;
+declare class InvalidDataContentError extends AISDKError {
+    private readonly [symbol$5];
+    readonly content: unknown;
+    constructor({ content, cause, message, }: {
+        content: unknown;
+        cause?: unknown;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is InvalidDataContentError;
+}
 
-- 'object': The output is an object.
-- 'array': The output is an array.
-- 'enum': The output is an enum.
-- 'no-schema': The output is not a schema.
+declare const symbol$4: unique symbol;
+declare class InvalidMessageRoleError extends AISDKError {
+    private readonly [symbol$4];
+    readonly role: string;
+    constructor({ role, message, }: {
+        role: string;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is InvalidMessageRoleError;
+}
 
-@param experimental_telemetry - Optional telemetry configuration (experimental).
+declare const symbol$3: unique symbol;
+declare class MessageConversionError extends AISDKError {
+    private readonly [symbol$3];
+    readonly originalMessage: Omit<UIMessage, 'id'>;
+    constructor({ originalMessage, message, }: {
+        originalMessage: Omit<UIMessage, 'id'>;
+        message: string;
+    });
+    static isInstance(error: unknown): error is MessageConversionError;
+}
 
-@param providerOptions - 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.
+declare const symbol$2: unique symbol;
+declare class DownloadError extends AISDKError {
+    private readonly [symbol$2];
+    readonly url: string;
+    readonly statusCode?: number;
+    readonly statusText?: string;
+    constructor({ url, statusCode, statusText, cause, message, }: {
+        url: string;
+        statusCode?: number;
+        statusText?: string;
+        message?: string;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is DownloadError;
+}
 
-@returns
-A result object for accessing the partial object stream and additional information.
+declare const symbol$1: unique symbol;
+type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable' | 'abort';
+declare class RetryError extends AISDKError {
+    private readonly [symbol$1];
+    readonly reason: RetryErrorReason;
+    readonly lastError: unknown;
+    readonly errors: Array<unknown>;
+    constructor({ message, reason, errors, }: {
+        message: string;
+        reason: RetryErrorReason;
+        errors: Array<unknown>;
+    });
+    static isInstance(error: unknown): error is RetryError;
+}
+
+/**
+The result of a `generateImage` call.
+It contains the images and additional information.
  */
-declare function streamObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$1>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<CallSettings, 'stopSequences'> & Prompt & (OUTPUT extends 'enum' ? {
+interface GenerateImageResult {
     /**
-The enum values that the model should use.
-  */
-    enum: Array<RESULT>;
-    mode?: 'json';
-    output: 'enum';
-} : OUTPUT extends 'no-schema' ? {} : {
+  The first image that was generated.
+     */
+    readonly image: GeneratedFile;
     /**
-The schema of the object that the model should generate.
-*/
-    schema: SCHEMA;
+  The images that were generated.
+       */
+    readonly images: Array<GeneratedFile>;
     /**
-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;
+  Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<ImageGenerationWarning>;
     /**
-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;
+  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<ImageModelResponseMetadata>;
     /**
-The mode to use for object generation.
-
-The schema is converted into a JSON schema and used in one of the following ways
+     * 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: ImageModelProviderMetadata;
+}
 
-- '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.
+/**
+Generates images using an image model.
 
-Please note that most providers do not support all modes.
+@param model - The image model to use.
+@param prompt - The prompt that should be used to generate the image.
+@param n - Number of images to generate. Default: 1.
+@param size - Size of the images to generate. Must have the format `{width}x{height}`.
+@param aspectRatio - Aspect ratio of the images to generate. Must have the format `{width}:{height}`.
+@param seed - Seed for the image 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.
 
-Default and recommended: 'auto' (best mode for the model).
-*/
-    mode?: 'auto' | 'json' | 'tool';
-}) & {
-    output?: OUTPUT;
+@returns A result object that contains the generated images.
+ */
+declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-The language model to use.
-   */
-    model: LanguageModel;
+  The image model to use.
+       */
+    model: ImageModelV3;
     /**
-A function that attempts to repair the raw output of the model
-to enable JSON parsing.
+  The prompt that should be used to generate the image.
      */
-    experimental_repairText?: RepairTextFunction;
+    prompt: string;
     /**
-Optional telemetry configuration (experimental).
+  Number of images to generate.
      */
-    experimental_telemetry?: TelemetrySettings;
+    n?: number;
     /**
-Custom download function to use for URLs.
-
-By default, files are downloaded if the model does not support the URL for the given media type.
+  Number of images to generate.
      */
-    experimental_download?: DownloadFunction | undefined;
-    /**
-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 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.
-   */
-    onError?: StreamObjectOnErrorCallback;
+    maxImagesPerCall?: number;
     /**
-Callback that is called when the LLM response and the final object validation are finished.
-*/
-    onFinish?: StreamObjectOnFinishCallback<RESULT>;
+  Size of the images to generate. Must have the format `{width}x{height}`. If not provided, the default size will be used.
+     */
+    size?: `${number}x${number}`;
     /**
-     * Internal. For test use only. May change without notice.
+  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-        now?: () => number;
-    };
-}): StreamObjectResult<OUTPUT extends 'enum' ? string : OUTPUT extends 'array' ? RESULT : DeepPartial<RESULT>, OUTPUT extends 'array' ? RESULT : RESULT, OUTPUT extends 'array' ? RESULT extends Array<infer U> ? AsyncIterableStream<U> : never : 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, language, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
-    /**
-  The speech model to use.
-       */
-    model: SpeechModel;
-    /**
-  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;
+    aspectRatio?: `${number}:${number}`;
     /**
-    The language for speech generation. This should be an ISO 639-1 language code (e.g. "en", "es", "fr")
-    or "auto" for automatic language detection. Provider support varies.
+  Seed for the image generation. If not provided, the default seed will be used.
      */
-    language?: string;
+    seed?: number;
     /**
   Additional provider-specific options that are passed through to the provider
   as body parameters.
@@ -3798,13 +3801,15 @@ declare function generateSpeech({ model, text, voice, outputFormat, instructions
   record is keyed by the provider-specific metadata key.
   ```ts
   {
-    "openai": {}
+    "openai": {
+      "style": "vivid"
+    }
   }
   ```
        */
     providerOptions?: ProviderOptions;
     /**
-  Maximum number of retries per speech model call. Set to 0 to disable retries.
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
   
   @default 2
      */
@@ -3818,1086 +3823,1111 @@ declare function generateSpeech({ model, text, voice, outputFormat, instructions
   Only applicable for HTTP-based providers.
    */
     headers?: Record<string, string>;
-}): Promise<SpeechResult>;
-
-type Warning = LanguageModelV3CallWarning | ImageModelV3CallWarning | SpeechModelV3CallWarning | TranscriptionModelV3CallWarning;
-type LogWarningsFunction = (warnings: Warning[]) => void;
+}): Promise<GenerateImageResult>;
 
 /**
- * Applies default settings for a language model.
+The result of a `generateObject` call.
  */
-declare function defaultSettingsMiddleware({ settings, }: {
-    settings: Partial<{
-        maxOutputTokens?: LanguageModelV3CallOptions['maxOutputTokens'];
-        temperature?: LanguageModelV3CallOptions['temperature'];
-        stopSequences?: LanguageModelV3CallOptions['stopSequences'];
-        topP?: LanguageModelV3CallOptions['topP'];
-        topK?: LanguageModelV3CallOptions['topK'];
-        presencePenalty?: LanguageModelV3CallOptions['presencePenalty'];
-        frequencyPenalty?: LanguageModelV3CallOptions['frequencyPenalty'];
-        responseFormat?: LanguageModelV3CallOptions['responseFormat'];
-        seed?: LanguageModelV3CallOptions['seed'];
-        tools?: LanguageModelV3CallOptions['tools'];
-        toolChoice?: LanguageModelV3CallOptions['toolChoice'];
-        headers?: LanguageModelV3CallOptions['headers'];
-        providerOptions?: LanguageModelV3CallOptions['providerOptions'];
-    }>;
-}): LanguageModelMiddleware;
+interface GenerateObjectResult<OBJECT> {
+    /**
+    The generated object (typed according to the schema).
+       */
+    readonly object: OBJECT;
+    /**
+     * The reasoning that was used to generate the object.
+     * Concatenated from all reasoning parts.
+     */
+    readonly reasoning: string | undefined;
+    /**
+    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 & {
+        /**
+    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;
+    /**
+    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;
+}
 
 /**
- * Extract an XML-tagged reasoning section from the generated text and exposes it
- * as a `reasoning` property on the result.
- *
- * @param tagName - The name of the XML tag to extract reasoning from.
- * @param separator - The separator to use between reasoning and text sections.
- * @param startWithReasoning - Whether to start with reasoning tokens.
- */
-declare function extractReasoningMiddleware({ tagName, separator, startWithReasoning, }: {
-    tagName: string;
-    separator?: string;
-    startWithReasoning?: boolean;
-}): LanguageModelMiddleware;
+A function that attempts to repair the raw output of the model
+to enable JSON parsing.
 
-/**
- * Simulates streaming chunks with the response from a generate call.
- */
-declare function simulateStreamingMiddleware(): LanguageModelMiddleware;
+Should return the repaired text or null if the text cannot be repaired.
+     */
+type RepairTextFunction = (options: {
+    text: string;
+    error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;
 
 /**
- * Wraps a LanguageModelV3 instance with middleware functionality.
- * This function allows you to apply middleware to transform parameters,
- * wrap generate operations, and wrap stream operations of a language model.
- *
- * @param options - Configuration options for wrapping the language model.
- * @param options.model - The original LanguageModelV3 instance to be wrapped.
- * @param options.middleware - The middleware to be applied to the language model. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
- * @param options.modelId - Optional custom model ID to override the original model's ID.
- * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
- * @returns A new LanguageModelV3 instance with middleware applied.
- */
-declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
-    model: LanguageModelV3;
-    middleware: LanguageModelMiddleware | LanguageModelMiddleware[];
-    modelId?: string;
-    providerId?: string;
-}) => LanguageModelV3;
+Generate a structured, typed object for a given prompt and schema using a language model.
 
-/**
- * Wraps a ProviderV3 instance with middleware functionality.
- * This function allows you to apply middleware to all language models
- * from the provider, enabling you to transform parameters, wrap generate
- * operations, and wrap stream operations for every language model.
- *
- * @param options - Configuration options for wrapping the provider.
- * @param options.provider - The original ProviderV3 instance to be wrapped.
- * @param options.languageModelMiddleware - The middleware to be applied to all language models from the provider. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
- * @returns A new ProviderV3 instance with middleware applied to all language models.
- */
-declare function wrapProvider({ provider, languageModelMiddleware, }: {
-    provider: ProviderV3 | ProviderV2;
-    languageModelMiddleware: LanguageModelMiddleware | LanguageModelMiddleware[];
-}): ProviderV3;
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-/**
- * Creates a custom provider with specified language models, text embedding models, image models, transcription models, speech models, and an optional fallback provider.
- *
- * @param {Object} options - The options for creating the custom provider.
- * @param {Record<string, LanguageModel>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModel instances.
- * @param {Record<string, EmbeddingModel<string>>} [options.textEmbeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModel<string> instances.
- * @param {Record<string, ImageModel>} [options.imageModels] - A record of image models, where keys are model IDs and values are ImageModel instances.
- * @param {Record<string, TranscriptionModel>} [options.transcriptionModels] - A record of transcription models, where keys are model IDs and values are TranscriptionModel instances.
- * @param {Record<string, SpeechModel>} [options.speechModels] - A record of speech models, where keys are model IDs and values are SpeechModel instances.
- * @param {Provider} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
- * @returns {Provider} A Provider object with languageModel, textEmbeddingModel, imageModel, transcriptionModel, and speechModel methods.
- *
- * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
- */
-declare function customProvider<LANGUAGE_MODELS extends Record<string, LanguageModelV3>, EMBEDDING_MODELS extends Record<string, EmbeddingModelV3<string>>, IMAGE_MODELS extends Record<string, ImageModelV3>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModelV3>, SPEECH_MODELS extends Record<string, SpeechModelV3>>({ languageModels, textEmbeddingModels, imageModels, transcriptionModels, speechModels, fallbackProvider, }: {
-    languageModels?: LANGUAGE_MODELS;
-    textEmbeddingModels?: EMBEDDING_MODELS;
-    imageModels?: IMAGE_MODELS;
-    transcriptionModels?: TRANSCRIPTION_MODELS;
-    speechModels?: SPEECH_MODELS;
-    fallbackProvider?: ProviderV3 | ProviderV2;
-}): ProviderV3 & {
-    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV3;
-    textEmbeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV3<string>;
-    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV3;
-    transcriptionModel(modelId: ExtractModelId<TRANSCRIPTION_MODELS>): TranscriptionModelV3;
-    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV3;
-};
-/**
- * @deprecated Use `customProvider` instead.
- */
-declare const experimental_customProvider: typeof customProvider;
-type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<keyof MODELS, string>;
+@param model - The language model to use.
+@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
 
-declare const symbol: unique symbol;
-declare class NoSuchProviderError extends NoSuchModelError {
-    private readonly [symbol];
-    readonly providerId: string;
-    readonly availableProviders: string[];
-    constructor({ modelId, modelType, providerId, availableProviders, message, }: {
-        modelId: string;
-        modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel';
-        providerId: string;
-        availableProviders: string[];
-        message?: string;
-    });
-    static isInstance(error: unknown): error is NoSuchProviderError;
-}
+@param system - A system message that will be part of the prompt.
+@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.
 
-type ExtractLiteralUnion<T> = T extends string ? string extends T ? never : T : never;
-interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV3> = Record<string, ProviderV3>, SEPARATOR extends string = ':'> {
-    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModelV3;
-    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModelV3;
-    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModelV3<string>;
-    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV3<string>;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV3;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV3;
-    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['transcriptionModel']>>[0]>}` : never): TranscriptionModelV3;
-    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): TranscriptionModelV3;
-    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['speechModel']>>[0]>}` : never): SpeechModelV3;
-    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): SpeechModelV3;
-}
-/**
- * Creates a registry for the given providers with optional middleware functionality.
- * This function allows you to register multiple providers and optionally apply middleware
- * to all language models from the registry, enabling you to transform parameters, wrap generate
- * operations, and wrap stream operations for every language model accessed through the registry.
- *
- * @param providers - A record of provider instances to be registered in the registry.
- * @param options - Configuration options for the provider registry.
- * @param options.separator - The separator used between provider ID and model ID in the combined identifier. Defaults to ':'.
- * @param options.languageModelMiddleware - Optional middleware to be applied to all language models from the registry. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
- * @returns A new ProviderRegistryProvider instance that provides access to all registered providers with optional middleware applied to language models.
- */
-declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV3>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, languageModelMiddleware, }?: {
-    separator?: SEPARATOR;
-    languageModelMiddleware?: LanguageModelMiddleware | LanguageModelMiddleware[];
-}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
-/**
- * @deprecated Use `createProviderRegistry` instead.
- */
-declare const experimental_createProviderRegistry: typeof createProviderRegistry;
+@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.
+@param topP - Nucleus sampling.
+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.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+@param presencePenalty - Presence penalty setting.
+It affects the likelihood of the model to repeat information that is already in the prompt.
+The value is passed through to the provider. The range depends on the provider and model.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+@param seed - The seed (integer) to use for random sampling.
+If set and supported by the model, calls will generate deterministic results.
 
-declare function createTextStreamResponse({ status, statusText, headers, textStream, }: ResponseInit & {
-    textStream: ReadableStream<string>;
-}): Response;
+@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 function pipeTextStreamToResponse({ response, status, statusText, headers, textStream, }: {
-    response: ServerResponse;
-    textStream: ReadableStream<string>;
-} & ResponseInit): void;
+@param schema - The schema of the object that the model should generate.
+@param schemaName - Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+@param schemaDescription - Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
 
-declare const JSONRPCRequestSchema: z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    method: z.ZodString;
-    params: z.ZodOptional<z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>>;
-}, z.core.$strict>;
-type JSONRPCRequest = z.infer<typeof JSONRPCRequestSchema>;
-declare const JSONRPCResponseSchema: z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    result: z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>;
-}, z.core.$strict>;
-type JSONRPCResponse = z.infer<typeof JSONRPCResponseSchema>;
-declare const JSONRPCErrorSchema: z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    error: z.ZodObject<{
-        code: z.ZodNumber;
-        message: z.ZodString;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>;
-}, z.core.$strict>;
-type JSONRPCError = z.infer<typeof JSONRPCErrorSchema>;
-declare const JSONRPCNotificationSchema: z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodString;
-    params: z.ZodOptional<z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>>;
-}, z.core.$strict>;
-type JSONRPCNotification = z.infer<typeof JSONRPCNotificationSchema>;
-declare const JSONRPCMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    method: z.ZodString;
-    params: z.ZodOptional<z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>>;
-}, z.core.$strict>, z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    method: z.ZodString;
-    params: z.ZodOptional<z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>>;
-}, z.core.$strict>, z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    result: z.ZodObject<{
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    }, z.core.$loose>;
-}, z.core.$strict>, z.ZodObject<{
-    jsonrpc: z.ZodLiteral<"2.0">;
-    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-    error: z.ZodObject<{
-        code: z.ZodNumber;
-        message: z.ZodString;
-        data: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>;
-}, z.core.$strict>]>;
-type JSONRPCMessage = z.infer<typeof JSONRPCMessageSchema>;
+@param output - The type of the output.
 
-/**
- * Transport interface for MCP (Model Context Protocol) communication.
- * Maps to the `Transport` interface in the MCP spec.
+- 'object': The output is an object.
+- 'array': The output is an array.
+- 'enum': The output is an enum.
+- 'no-schema': The output is not a schema.
+
+@param experimental_repairText - A function that attempts to repair the raw output of the model
+to enable JSON parsing.
+
+@param experimental_telemetry - Optional telemetry configuration (experimental).
+
+@param providerOptions - 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.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-interface MCPTransport {
+declare function generateObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$1>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<CallSettings, 'stopSequences'> & Prompt & (OUTPUT extends 'enum' ? {
     /**
-     * Initialize and start the transport
-     */
-    start(): Promise<void>;
+The enum values that the model should use.
+  */
+    enum: Array<RESULT>;
+    mode?: 'json';
+    output: 'enum';
+} : OUTPUT extends 'no-schema' ? {} : {
     /**
-     * Send a JSON-RPC message through the transport
-     * @param message The JSON-RPC message to send
-     */
-    send(message: JSONRPCMessage): Promise<void>;
+The schema of the object that the model should generate.
+*/
+    schema: SCHEMA;
     /**
-     * Clean up and close the transport
-     */
-    close(): Promise<void>;
+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;
     /**
-     * Event handler for transport closure
-     */
-    onclose?: () => void;
+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;
     /**
-     * Event handler for transport errors
+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';
+}) & {
+    output?: OUTPUT;
+    /**
+The language model to use.
      */
-    onerror?: (error: Error) => void;
+    model: LanguageModel;
     /**
-     * Event handler for received messages
+A function that attempts to repair the raw output of the model
+to enable JSON parsing.
      */
-    onmessage?: (message: JSONRPCMessage) => void;
-}
-type MCPTransportConfig = {
-    type: 'sse';
+    experimental_repairText?: RepairTextFunction;
     /**
-     * The URL of the MCP server.
+Optional telemetry configuration (experimental).
+       */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Custom download function to use for URLs.
+
+By default, files are downloaded if the model does not support the URL for the given media type.
      */
-    url: string;
+    experimental_download?: DownloadFunction | undefined;
     /**
-     * Additional HTTP headers to be sent with requests.
+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;
+    /**
+     * Internal. For test use only. May change without notice.
      */
-    headers?: Record<string, string>;
-};
-
-type ToolSchemas = Record<string, {
-    inputSchema: FlexibleSchema<JSONObject | unknown>;
-}> | 'automatic' | undefined;
-type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
-    inputSchema: FlexibleSchema<any>;
-}> ? {
-    [K in keyof TOOL_SCHEMAS]: TOOL_SCHEMAS[K] extends {
-        inputSchema: FlexibleSchema<infer INPUT>;
-    } ? Tool<INPUT, CallToolResult> & Required<Pick<Tool<INPUT, CallToolResult>, 'execute'>> : never;
-} : McpToolSet<Record<string, {
-    inputSchema: FlexibleSchema<unknown>;
-}>>;
-declare const CallToolResultSchema: z.ZodUnion<[z.ZodObject<{
-    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"text">;
-        text: z.ZodString;
-    }, z.core.$loose>, z.ZodObject<{
-        type: z.ZodLiteral<"image">;
-        data: z.ZodBase64;
-        mimeType: z.ZodString;
-    }, z.core.$loose>, z.ZodObject<{
-        type: z.ZodLiteral<"resource">;
-        resource: z.ZodUnion<readonly [z.ZodObject<{
-            uri: z.ZodString;
-            mimeType: z.ZodOptional<z.ZodString>;
-            text: z.ZodString;
-        }, z.core.$loose>, z.ZodObject<{
-            uri: z.ZodString;
-            mimeType: z.ZodOptional<z.ZodString>;
-            blob: z.ZodBase64;
-        }, z.core.$loose>]>;
-    }, z.core.$loose>]>>;
-    isError: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
-}, z.core.$loose>, z.ZodObject<{
-    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-    toolResult: z.ZodUnknown;
-}, z.core.$loose>]>;
-type CallToolResult = z.infer<typeof CallToolResultSchema>;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<RESULT>>;
 
-interface MCPClientConfig {
-    /** Transport configuration for connecting to the MCP server */
-    transport: MCPTransportConfig | MCPTransport;
-    /** Optional callback for uncaught errors */
-    onUncaughtError?: (error: unknown) => void;
-    /** Optional client name, defaults to 'ai-sdk-mcp-client' */
-    name?: string;
-}
-declare function createMCPClient(config: MCPClientConfig): Promise<MCPClient>;
-interface MCPClient {
-    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>(options?: {
-        schemas?: TOOL_SCHEMAS;
-    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
-    close: () => Promise<void>;
+/**
+ * Consumes a ReadableStream until it's fully read.
+ *
+ * This function reads the stream chunk by chunk until the stream is exhausted.
+ * It doesn't process or return the data from the stream; it simply ensures
+ * that the entire stream is read.
+ *
+ * @param {ReadableStream} stream - The ReadableStream to be consumed.
+ * @returns {Promise<void>} A promise that resolves when the stream is fully consumed.
+ */
+declare function consumeStream({ stream, onError, }: {
+    stream: ReadableStream;
+    onError?: (error: unknown) => void;
+}): Promise<void>;
+
+/**
+ * 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>;
 }
 
 /**
-The result of a `transcribe` call.
-It contains the transcript and additional information.
+ * 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
  */
-interface TranscriptionResult {
+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.
+ */
+interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
-     * The complete transcribed text from the audio.
-     */
-    readonly text: string;
+    Warnings from the model provider (e.g. unsupported settings)
+       */
+    readonly warnings: Promise<CallWarning[] | undefined>;
     /**
-     * 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 token usage of the generated response. Resolved when the response is finished.
+       */
+    readonly usage: Promise<LanguageModelUsage>;
     /**
-     * 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.
+  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 language: string | undefined;
+    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-     * The total duration of the audio file in seconds.
-     * May be undefined if the duration couldn't be determined.
-     */
-    readonly durationInSeconds: number | undefined;
+  Additional request information from the last step.
+   */
+    readonly request: Promise<LanguageModelRequestMetadata>;
     /**
-    Warnings for the call, e.g. unsupported settings.
+  Additional response information.
+   */
+    readonly response: Promise<LanguageModelResponseMetadata>;
+    /**
+  The reason why the generation finished. Taken from the last step.
+  
+  Resolved when the response is finished.
        */
-    readonly warnings: Array<TranscriptionWarning>;
+    readonly finishReason: Promise<FinishReason>;
     /**
-    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
-     */
-    readonly responses: Array<TranscriptionModelResponseMetadata>;
+    The generated object (typed according to the schema). Resolved when the response is finished.
+       */
+    readonly object: Promise<RESULT>;
     /**
-    Provider metadata from the provider.
+    Stream of partial objects. It gets more complete as the stream progresses.
+  
+    Note that the partial object is not validated.
+    If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
+       */
+    readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
+    /**
+     * Stream over complete array elements. Only available if the output strategy is set to `array`.
      */
-    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, }: {
+    readonly elementStream: ELEMENT_STREAM;
     /**
-  The transcription model to use.
+    Text stream of the JSON representation of the generated object. It contains text chunks.
+    When the stream is finished, the object is valid JSON that can be parsed.
        */
-    model: TranscriptionModel;
+    readonly textStream: AsyncIterableStream<string>;
     /**
-  The audio data to transcribe.
-     */
-    audio: DataContent | URL;
+    Stream of different types of events, including partial objects, errors, and finish events.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
     /**
-  Additional provider-specific options that are passed through to the provider
-  as body parameters.
+    Writes text delta output to a Node.js response-like object.
+    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+    writes each text delta as a separate chunk.
   
-  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
-    }
-  }
-  ```
+    @param response A Node.js response-like object (ServerResponse).
+    @param init Optional headers, status code, and status text.
        */
-    providerOptions?: ProviderOptions;
+    pipeTextStreamToResponse(response: ServerResponse$1, init?: ResponseInit): void;
     /**
-  Maximum number of retries per transcript model call. Set to 0 to disable retries.
+    Creates a simple text stream response.
+    The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
+    Each text delta is encoded as UTF-8 and sent as a separate chunk.
+    Non-text-delta events are ignored.
   
-  @default 2
-     */
-    maxRetries?: number;
+    @param init Optional headers, status code, and status text.
+       */
+    toTextStreamResponse(init?: ResponseInit): Response;
+}
+type ObjectStreamPart<PARTIAL> = {
+    type: 'object';
+    object: PARTIAL;
+} | {
+    type: 'text-delta';
+    textDelta: string;
+} | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'finish';
+    finishReason: FinishReason;
+    usage: LanguageModelUsage;
+    response: LanguageModelResponseMetadata;
+    providerMetadata?: ProviderMetadata;
+};
+
+/**
+Callback that is set using the `onError` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamObjectOnErrorCallback = (event: {
+    error: unknown;
+}) => Promise<void> | void;
+/**
+Callback that is set using the `onFinish` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamObjectOnFinishCallback<RESULT> = (event: {
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+  The token usage of the generated response.
+  */
+    usage: LanguageModelUsage;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
+  The generated object. Can be undefined if the final object does not match the schema.
+  */
+    object: RESULT | undefined;
+    /**
+  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
+  */
+    error: unknown | undefined;
+    /**
+  Response metadata.
    */
-    headers?: Record<string, string>;
-}): Promise<TranscriptionResult>;
+    response: LanguageModelResponseMetadata;
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    warnings?: CallWarning[];
+    /**
+  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.
+  */
+    providerMetadata: ProviderMetadata | undefined;
+}) => Promise<void> | void;
+/**
+Generate a structured, typed object for a given prompt and schema using a language model.
 
-declare const getOriginalFetch: () => typeof fetch;
-declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onFinish, onError, 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;
-    onFinish: ((prompt: string, completion: string) => void) | undefined;
-    onError: ((error: Error) => void) | undefined;
-    fetch: ReturnType<typeof getOriginalFetch> | undefined;
-}): Promise<string | null | undefined>;
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
 
-interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
+@param model - The language model to use.
+@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
+
+@param system - A system message that will be part of the prompt.
+@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 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.
+@param topP - Nucleus sampling.
+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.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+@param presencePenalty - Presence penalty setting.
+It affects the likelihood of the model to repeat information that is already in the prompt.
+The value is passed through to the provider. The range depends on the provider and model.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+@param seed - The seed (integer) to use for random sampling.
+If set and supported by the model, calls will generate deterministic results.
+
+@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.
+
+@param schema - The schema of the object that the model should generate.
+@param schemaName - Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+@param schemaDescription - Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+
+@param output - The type of the output.
+
+- 'object': The output is an object.
+- 'array': The output is an array.
+- 'enum': The output is an enum.
+- 'no-schema': The output is not a schema.
+
+@param experimental_telemetry - Optional telemetry configuration (experimental).
+
+@param providerOptions - 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.
+
+@returns
+A result object for accessing the partial object stream and additional information.
+ */
+declare function streamObject<SCHEMA extends FlexibleSchema<unknown> = FlexibleSchema<JSONValue$1>, OUTPUT extends 'object' | 'array' | 'enum' | 'no-schema' = InferSchema<SCHEMA> extends string ? 'enum' : 'object', RESULT = OUTPUT extends 'array' ? Array<InferSchema<SCHEMA>> : InferSchema<SCHEMA>>(options: Omit<CallSettings, 'stopSequences'> & Prompt & (OUTPUT extends 'enum' ? {
     /**
-     * Appends a data stream part to the stream.
-     */
-    write(part: InferUIMessageChunk<UI_MESSAGE>): void;
+The enum values that the model should use.
+  */
+    enum: Array<RESULT>;
+    mode?: 'json';
+    output: 'enum';
+} : OUTPUT extends 'no-schema' ? {} : {
     /**
-     * Merges the contents of another stream to this stream.
+The schema of the object that the model should generate.
+*/
+    schema: SCHEMA;
+    /**
+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';
+}) & {
+    output?: OUTPUT;
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+A function that attempts to repair the raw output of the model
+to enable JSON parsing.
      */
-    merge(stream: ReadableStream<InferUIMessageChunk<UI_MESSAGE>>): void;
+    experimental_repairText?: RepairTextFunction;
     /**
-     * Error handler that is used by the data stream writer.
-     * This is intended for forwarding when merging streams
-     * to prevent duplicated error masking.
+Optional telemetry configuration (experimental).
      */
-    onError: ErrorHandler | undefined;
-}
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Custom download function to use for URLs.
 
-declare function createUIMessageStream<UI_MESSAGE extends UIMessage>({ execute, onError, originalMessages, onFinish, generateId, }: {
-    execute: (options: {
-        writer: UIMessageStreamWriter<UI_MESSAGE>;
-    }) => Promise<void> | void;
-    onError?: (error: unknown) => string;
+By default, files are downloaded if the model does not support the URL for the given media type.
+     */
+    experimental_download?: DownloadFunction | undefined;
     /**
-     * The original messages. If they are provided, persistence mode is assumed,
-     * and a message ID is provided for the response message.
+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 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.
+   */
+    onError?: StreamObjectOnErrorCallback;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+*/
+    onFinish?: StreamObjectOnFinishCallback<RESULT>;
+    /**
+     * Internal. For test use only. May change without notice.
      */
-    originalMessages?: UI_MESSAGE[];
-    onFinish?: UIMessageStreamOnFinishCallback<UI_MESSAGE>;
-    generateId?: IdGenerator;
-}): ReadableStream<InferUIMessageChunk<UI_MESSAGE>>;
-
-declare function createUIMessageStreamResponse({ status, statusText, headers, stream, consumeSseStream, }: UIMessageStreamResponseInit & {
-    stream: ReadableStream<UIMessageChunk>;
-}): Response;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+        now?: () => number;
+    };
+}): StreamObjectResult<OUTPUT extends 'enum' ? string : OUTPUT extends 'array' ? RESULT : DeepPartial<RESULT>, OUTPUT extends 'array' ? RESULT : RESULT, OUTPUT extends 'array' ? RESULT extends Array<infer U> ? AsyncIterableStream<U> : never : never>;
 
-declare class JsonToSseTransformStream extends TransformStream<unknown, string> {
-    constructor();
+/**
+ * A generated audio file.
+ */
+interface GeneratedAudioFile extends GeneratedFile {
+    /**
+     * Audio format of the file (e.g., 'mp3', 'wav', etc.)
+     */
+    readonly format: string;
 }
 
-declare function pipeUIMessageStreamToResponse({ response, status, statusText, headers, stream, consumeSseStream, }: {
-    response: ServerResponse;
-    stream: ReadableStream<UIMessageChunk>;
-} & UIMessageStreamResponseInit): void;
-
 /**
- * Transforms a stream of `UIMessageChunk`s into an `AsyncIterableStream` of `UIMessage`s.
- *
- * @param options.message - The last assistant message to use as a starting point when the conversation is resumed. Otherwise undefined.
- * @param options.stream - The stream of `UIMessageChunk`s to read.
- * @param options.terminateOnError - Whether to terminate the stream if an error occurs.
- * @param options.onError - A function that is called when an error occurs.
- *
- * @returns An `AsyncIterableStream` of `UIMessage`s. Each stream part is a different state of the same message
- * as it is being completed.
+The result of a `generateSpeech` call.
+It contains the audio data and additional information.
  */
-declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({ message, stream, onError, terminateOnError, }: {
-    message?: UI_MESSAGE;
-    stream: ReadableStream<UIMessageChunk>;
-    onError?: (error: unknown) => void;
-    terminateOnError?: boolean;
-}): AsyncIterableStream<UI_MESSAGE>;
-
-declare const UI_MESSAGE_STREAM_HEADERS: {
-    'content-type': string;
-    'cache-control': string;
-    connection: string;
-    'x-vercel-ai-ui-message-stream': string;
-    'x-accel-buffering': string;
-};
+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>>;
+}
 
 /**
- * Transport interface for handling chat message communication and streaming.
- *
- * The `ChatTransport` interface provides fine-grained control over how messages
- * are sent to API endpoints and how responses are processed. This enables
- * alternative communication protocols like WebSockets, custom authentication
- * patterns, or specialized backend integrations.
- *
- * @template UI_MESSAGE - The UI message type extending UIMessage
+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.
  */
-interface ChatTransport<UI_MESSAGE extends UIMessage> {
+declare function generateSpeech({ model, text, voice, outputFormat, instructions, speed, language, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-     * Sends messages to the chat API endpoint and returns a streaming response.
-     *
-     * This method handles both new message submission and message regeneration.
-     * It supports real-time streaming of responses through UIMessageChunk events.
-     *
-     * @param options - Configuration object containing:
-     * @param options.trigger - The type of message submission:
-     *   - `'submit-message'`: Submitting a new user message
-     *   - `'regenerate-message'`: Regenerating an assistant response
-     * @param options.chatId - Unique identifier for the chat session
-     * @param options.messageId - ID of the message to regenerate (for regenerate-message trigger) or undefined for new messages
-     * @param options.messages - Array of UI messages representing the conversation history
-     * @param options.abortSignal - Signal to abort the request if needed
-     * @param options.headers - Additional HTTP headers to include in the request
-     * @param options.body - Additional JSON properties to include in the request body
-     * @param options.metadata - Custom metadata to attach to the request
-     *
-     * @returns Promise resolving to a ReadableStream of UIMessageChunk objects.
-     *   The stream emits various chunk types like:
-     *   - `text-start`, `text-delta`, `text-end`: For streaming text content
-     *   - `tool-input-start`, `tool-input-delta`, `tool-input-available`: For tool calls
-     *   - `data-part-start`, `data-part-delta`, `data-part-available`: For data parts
-     *   - `error`: For error handling
-     *
-     * @throws Error when the API request fails or response is invalid
+  The speech model to use.
+       */
+    model: SpeechModel;
+    /**
+  The text to convert to speech.
      */
-    sendMessages: (options: {
-        /** The type of message submission - either new message or regeneration */
-        trigger: 'submit-message' | 'regenerate-message';
-        /** Unique identifier for the chat session */
-        chatId: string;
-        /** ID of the message to regenerate, or undefined for new messages */
-        messageId: string | undefined;
-        /** Array of UI messages representing the conversation history */
-        messages: UI_MESSAGE[];
-        /** Signal to abort the request if needed */
-        abortSignal: AbortSignal | undefined;
-    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
+    text: string;
     /**
-     * Reconnects to an existing streaming response for the specified chat session.
-     *
-     * This method is used to resume streaming when a connection is interrupted
-     * or when resuming a chat session. It's particularly useful for maintaining
-     * continuity in long-running conversations or recovering from network issues.
-     *
-     * @param options - Configuration object containing:
-     * @param options.chatId - Unique identifier for the chat session to reconnect to
-     * @param options.headers - Additional HTTP headers to include in the reconnection request
-     * @param options.body - Additional JSON properties to include in the request body
-     * @param options.metadata - Custom metadata to attach to the request
-     *
-     * @returns Promise resolving to:
-     *   - `ReadableStream<UIMessageChunk>`: If an active stream is found and can be resumed
-     *   - `null`: If no active stream exists for the specified chat session (e.g., response already completed)
-     *
-     * @throws Error when the reconnection request fails or response is invalid
+  The voice to use for speech generation.
      */
-    reconnectToStream: (options: {
-        /** Unique identifier for the chat session to reconnect to */
-        chatId: string;
-    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
-}
-
-type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
-    id?: UI_MESSAGE['id'];
-    role?: UI_MESSAGE['role'];
-};
-type UIDataPartSchemas = Record<string, FlexibleSchema>;
-type UIDataTypesToSchemas<T extends UIDataTypes> = {
-    [K in keyof T]: FlexibleSchema<T[K]>;
-};
-type InferUIDataParts<T extends UIDataPartSchemas> = {
-    [K in keyof T]: InferSchema<T[K]>;
-};
-type ChatRequestOptions = {
+    voice?: string;
     /**
-    Additional headers that should be to be passed to the API endpoint.
+     * The desired output format for the audio e.g. "mp3", "wav", etc.
      */
-    headers?: Record<string, string> | Headers;
+    outputFormat?: 'mp3' | 'wav' | (string & {});
     /**
-    Additional body JSON properties that should be sent to the API endpoint.
+      Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+    */
+    instructions?: string;
+    /**
+    The speed of the speech generation.
      */
-    body?: object;
-    metadata?: unknown;
-};
-/**
- * Function that can be called to add a tool approval response to the chat.
- */
-type ChatAddToolApproveResponseFunction = ({ id, approved, reason, }: {
-    id: string;
+    speed?: number;
     /**
-     * Flag indicating whether the approval was granted or denied.
+    The language for speech generation. This should be an ISO 639-1 language code (e.g. "en", "es", "fr")
+    or "auto" for automatic language detection. Provider support varies.
      */
-    approved: boolean;
+    language?: string;
     /**
-     * Optional reason for the approval or denial.
+  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
      */
-    reason?: string;
-}) => void | PromiseLike<void>;
-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;
-}
-type ChatOnErrorCallback = (error: Error) => void;
-type ChatOnToolCallCallback<UI_MESSAGE extends UIMessage = UIMessage> = (options: {
-    toolCall: InferUIMessageToolCall<UI_MESSAGE>;
-}) => void | PromiseLike<void>;
-type ChatOnDataCallback<UI_MESSAGE extends UIMessage> = (dataPart: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => void;
+    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>;
+
+type Warning = LanguageModelV3CallWarning | ImageModelV3CallWarning | SpeechModelV3CallWarning | TranscriptionModelV3CallWarning;
+type LogWarningsFunction = (warnings: Warning[]) => void;
+
 /**
- * Function that is called when the assistant response has finished streaming.
+ * Applies default settings for a language model.
+ */
+declare function defaultSettingsMiddleware({ settings, }: {
+    settings: Partial<{
+        maxOutputTokens?: LanguageModelV3CallOptions['maxOutputTokens'];
+        temperature?: LanguageModelV3CallOptions['temperature'];
+        stopSequences?: LanguageModelV3CallOptions['stopSequences'];
+        topP?: LanguageModelV3CallOptions['topP'];
+        topK?: LanguageModelV3CallOptions['topK'];
+        presencePenalty?: LanguageModelV3CallOptions['presencePenalty'];
+        frequencyPenalty?: LanguageModelV3CallOptions['frequencyPenalty'];
+        responseFormat?: LanguageModelV3CallOptions['responseFormat'];
+        seed?: LanguageModelV3CallOptions['seed'];
+        tools?: LanguageModelV3CallOptions['tools'];
+        toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+        headers?: LanguageModelV3CallOptions['headers'];
+        providerOptions?: LanguageModelV3CallOptions['providerOptions'];
+    }>;
+}): LanguageModelMiddleware;
+
+/**
+ * Extract an XML-tagged reasoning section from the generated text and exposes it
+ * as a `reasoning` property on the result.
  *
- * @param message The assistant message that was streamed.
- * @param messages The full chat history, including the assistant message.
+ * @param tagName - The name of the XML tag to extract reasoning from.
+ * @param separator - The separator to use between reasoning and text sections.
+ * @param startWithReasoning - Whether to start with reasoning tokens.
+ */
+declare function extractReasoningMiddleware({ tagName, separator, startWithReasoning, }: {
+    tagName: string;
+    separator?: string;
+    startWithReasoning?: boolean;
+}): LanguageModelMiddleware;
+
+/**
+ * Simulates streaming chunks with the response from a generate call.
+ */
+declare function simulateStreamingMiddleware(): LanguageModelMiddleware;
+
+/**
+ * Wraps a LanguageModelV3 instance with middleware functionality.
+ * This function allows you to apply middleware to transform parameters,
+ * wrap generate operations, and wrap stream operations of a language model.
  *
- * @param isAbort Indicates whether the request has been aborted.
- * @param isDisconnect Indicates whether the request has been ended by a network error.
- * @param isError Indicates whether the request has been ended by an error.
+ * @param options - Configuration options for wrapping the language model.
+ * @param options.model - The original LanguageModelV3 instance to be wrapped.
+ * @param options.middleware - The middleware to be applied to the language model. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
+ * @param options.modelId - Optional custom model ID to override the original model's ID.
+ * @param options.providerId - Optional custom provider ID to override the original model's provider ID.
+ * @returns A new LanguageModelV3 instance with middleware applied.
  */
-type ChatOnFinishCallback<UI_MESSAGE extends UIMessage> = (options: {
-    message: UI_MESSAGE;
-    messages: UI_MESSAGE[];
-    isAbort: boolean;
-    isDisconnect: boolean;
-    isError: boolean;
-}) => void;
-interface ChatInit<UI_MESSAGE extends UIMessage> {
+declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
+    model: LanguageModelV3;
+    middleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+    modelId?: string;
+    providerId?: string;
+}) => LanguageModelV3;
+
+/**
+ * Wraps a ProviderV3 instance with middleware functionality.
+ * This function allows you to apply middleware to all language models
+ * from the provider, enabling you to transform parameters, wrap generate
+ * operations, and wrap stream operations for every language model.
+ *
+ * @param options - Configuration options for wrapping the provider.
+ * @param options.provider - The original ProviderV3 instance to be wrapped.
+ * @param options.languageModelMiddleware - The middleware to be applied to all language models from the provider. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
+ * @returns A new ProviderV3 instance with middleware applied to all language models.
+ */
+declare function wrapProvider({ provider, languageModelMiddleware, }: {
+    provider: ProviderV3 | ProviderV2;
+    languageModelMiddleware: LanguageModelMiddleware | LanguageModelMiddleware[];
+}): ProviderV3;
+
+/**
+ * Creates a custom provider with specified language models, text embedding models, image models, transcription models, speech models, and an optional fallback provider.
+ *
+ * @param {Object} options - The options for creating the custom provider.
+ * @param {Record<string, LanguageModel>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModel instances.
+ * @param {Record<string, EmbeddingModel<string>>} [options.textEmbeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModel<string> instances.
+ * @param {Record<string, ImageModel>} [options.imageModels] - A record of image models, where keys are model IDs and values are ImageModel instances.
+ * @param {Record<string, TranscriptionModel>} [options.transcriptionModels] - A record of transcription models, where keys are model IDs and values are TranscriptionModel instances.
+ * @param {Record<string, SpeechModel>} [options.speechModels] - A record of speech models, where keys are model IDs and values are SpeechModel instances.
+ * @param {Provider} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
+ * @returns {Provider} A Provider object with languageModel, textEmbeddingModel, imageModel, transcriptionModel, and speechModel methods.
+ *
+ * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
+ */
+declare function customProvider<LANGUAGE_MODELS extends Record<string, LanguageModelV3>, EMBEDDING_MODELS extends Record<string, EmbeddingModelV3<string>>, IMAGE_MODELS extends Record<string, ImageModelV3>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModelV3>, SPEECH_MODELS extends Record<string, SpeechModelV3>>({ languageModels, textEmbeddingModels, imageModels, transcriptionModels, speechModels, fallbackProvider, }: {
+    languageModels?: LANGUAGE_MODELS;
+    textEmbeddingModels?: EMBEDDING_MODELS;
+    imageModels?: IMAGE_MODELS;
+    transcriptionModels?: TRANSCRIPTION_MODELS;
+    speechModels?: SPEECH_MODELS;
+    fallbackProvider?: ProviderV3 | ProviderV2;
+}): ProviderV3 & {
+    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV3;
+    textEmbeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV3<string>;
+    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV3;
+    transcriptionModel(modelId: ExtractModelId<TRANSCRIPTION_MODELS>): TranscriptionModelV3;
+    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV3;
+};
+/**
+ * @deprecated Use `customProvider` instead.
+ */
+declare const experimental_customProvider: typeof customProvider;
+type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<keyof MODELS, string>;
+
+declare const symbol: unique symbol;
+declare class NoSuchProviderError extends NoSuchModelError {
+    private readonly [symbol];
+    readonly providerId: string;
+    readonly availableProviders: string[];
+    constructor({ modelId, modelType, providerId, availableProviders, message, }: {
+        modelId: string;
+        modelType: 'languageModel' | 'textEmbeddingModel' | 'imageModel' | 'transcriptionModel' | 'speechModel';
+        providerId: string;
+        availableProviders: string[];
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchProviderError;
+}
+
+type ExtractLiteralUnion<T> = T extends string ? string extends T ? never : T : never;
+interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV3> = Record<string, ProviderV3>, SEPARATOR extends string = ':'> {
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModelV3;
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModelV3;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModelV3<string>;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV3<string>;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV3;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV3;
+    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['transcriptionModel']>>[0]>}` : never): TranscriptionModelV3;
+    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): TranscriptionModelV3;
+    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['speechModel']>>[0]>}` : never): SpeechModelV3;
+    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): SpeechModelV3;
+}
+/**
+ * Creates a registry for the given providers with optional middleware functionality.
+ * This function allows you to register multiple providers and optionally apply middleware
+ * to all language models from the registry, enabling you to transform parameters, wrap generate
+ * operations, and wrap stream operations for every language model accessed through the registry.
+ *
+ * @param providers - A record of provider instances to be registered in the registry.
+ * @param options - Configuration options for the provider registry.
+ * @param options.separator - The separator used between provider ID and model ID in the combined identifier. Defaults to ':'.
+ * @param options.languageModelMiddleware - Optional middleware to be applied to all language models from the registry. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
+ * @returns A new ProviderRegistryProvider instance that provides access to all registered providers with optional middleware applied to language models.
+ */
+declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV3>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, languageModelMiddleware, }?: {
+    separator?: SEPARATOR;
+    languageModelMiddleware?: LanguageModelMiddleware | LanguageModelMiddleware[];
+}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
+/**
+ * @deprecated Use `createProviderRegistry` instead.
+ */
+declare const experimental_createProviderRegistry: typeof createProviderRegistry;
+
+declare function createTextStreamResponse({ status, statusText, headers, textStream, }: ResponseInit & {
+    textStream: ReadableStream<string>;
+}): Response;
+
+declare function pipeTextStreamToResponse({ response, status, statusText, headers, textStream, }: {
+    response: ServerResponse;
+    textStream: ReadableStream<string>;
+} & ResponseInit): void;
+
+declare const JSONRPCRequestSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+type JSONRPCRequest = z.infer<typeof JSONRPCRequestSchema>;
+declare const JSONRPCResponseSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+type JSONRPCResponse = z.infer<typeof JSONRPCResponseSchema>;
+declare const JSONRPCErrorSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+type JSONRPCError = z.infer<typeof JSONRPCErrorSchema>;
+declare const JSONRPCNotificationSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+type JSONRPCNotification = z.infer<typeof JSONRPCNotificationSchema>;
+declare const JSONRPCMessageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strict>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strict>]>;
+type JSONRPCMessage = z.infer<typeof JSONRPCMessageSchema>;
+
+/**
+ * Transport interface for MCP (Model Context Protocol) communication.
+ * Maps to the `Transport` interface in the MCP spec.
+ */
+interface MCPTransport {
     /**
-     * A unique identifier for the chat. If not provided, a random one will be
-     * generated.
+     * Initialize and start the transport
      */
-    id?: string;
-    messageMetadataSchema?: FlexibleSchema<InferUIMessageMetadata<UI_MESSAGE>>;
-    dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
-    messages?: UI_MESSAGE[];
+    start(): Promise<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.
+     * Send a JSON-RPC message through the transport
+     * @param message The JSON-RPC message to send
      */
-    generateId?: IdGenerator;
-    transport?: ChatTransport<UI_MESSAGE>;
+    send(message: JSONRPCMessage): Promise<void>;
     /**
-     * Callback function to be called when an error is encountered.
+     * Clean up and close the transport
      */
-    onError?: ChatOnErrorCallback;
-    /**
-    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?: ChatOnToolCallCallback<UI_MESSAGE>;
+    close(): Promise<void>;
     /**
-     * Function that is called when the assistant response has finished streaming.
+     * Event handler for transport closure
      */
-    onFinish?: ChatOnFinishCallback<UI_MESSAGE>;
+    onclose?: () => void;
     /**
-     * Optional callback function that is called when a data part is received.
-     *
-     * @param data The data part that was received.
+     * Event handler for transport errors
      */
-    onData?: ChatOnDataCallback<UI_MESSAGE>;
+    onerror?: (error: Error) => void;
     /**
-     * When provided, this function will be called when the stream is finished or a tool call is added
-     * to determine if the current messages should be resubmitted.
+     * Event handler for received messages
      */
-    sendAutomaticallyWhen?: (options: {
-        messages: UI_MESSAGE[];
-    }) => boolean | PromiseLike<boolean>;
+    onmessage?: (message: JSONRPCMessage) => 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 onError?;
-    private onToolCall?;
-    private onFinish?;
-    private onData?;
-    private sendAutomaticallyWhen?;
-    private activeResponse;
-    private jobExecutor;
-    constructor({ generateId, id, transport, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, onData, sendAutomaticallyWhen, }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
-        state: ChatState<UI_MESSAGE>;
-    });
-    /**
-     * 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[]);
-    /**
-     * Appends or replaces a user message to the chat list. This triggers the API call to fetch
-     * the assistant's response.
-     *
-     * If a messageId is provided, the message will be replaced.
-     */
-    sendMessage: (message?: (CreateUIMessage<UI_MESSAGE> & {
-        text?: never;
-        files?: never;
-        messageId?: string;
-    }) | {
-        text: string;
-        files?: FileList | FileUIPart[];
-        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
-        parts?: never;
-        messageId?: string;
-    } | {
-        files: FileList | FileUIPart[];
-        metadata?: InferUIMessageMetadata<UI_MESSAGE>;
-        parts?: never;
-        messageId?: string;
-    }, options?: ChatRequestOptions) => Promise<void>;
-    /**
-     * Regenerate the assistant message with the provided message id.
-     * If no message id is provided, the last assistant message will be regenerated.
-     */
-    regenerate: ({ messageId, ...options }?: {
-        messageId?: string;
-    } & ChatRequestOptions) => Promise<void>;
-    /**
-     * Attempt to resume an ongoing streaming response.
-     */
-    resumeStream: (options?: ChatRequestOptions) => Promise<void>;
+type MCPTransportConfig = {
+    type: 'sse';
     /**
-     * Clear the error state and set the status to ready if the chat is in an error state.
+     * The URL of the MCP server.
      */
-    clearError: () => void;
-    addToolApprovalResponse: ChatAddToolApproveResponseFunction;
-    addToolResult: <TOOL extends keyof InferUIMessageTools<UI_MESSAGE>>({ state, tool, toolCallId, output, errorText, }: {
-        state?: "output-available";
-        tool: TOOL;
-        toolCallId: string;
-        output: InferUIMessageTools<UI_MESSAGE>[TOOL]["output"];
-        errorText?: never;
-    } | {
-        state: "output-error";
-        tool: TOOL;
-        toolCallId: string;
-        output?: never;
-        errorText: string;
-    }) => Promise<void>;
+    url: string;
     /**
-     * Abort the current request immediately, keep the generated tokens if any.
+     * Additional HTTP headers to be sent with requests.
      */
-    stop: () => Promise<void>;
-    private makeRequest;
-}
-
-declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
-
-/**
-Converts an array of UI messages from useChat into an array of ModelMessages that can be used
-with the AI functions (e.g. `streamText`, `generateText`).
+    headers?: Record<string, string>;
+};
 
-@param messages - The UI messages to convert.
-@param options.tools - The tools to use.
-@param options.ignoreIncompleteToolCalls - Whether to ignore incomplete tool calls. Default is `false`.
+type ToolSchemas = Record<string, {
+    inputSchema: FlexibleSchema<JSONObject | unknown>;
+}> | 'automatic' | undefined;
+type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
+    inputSchema: FlexibleSchema<any>;
+}> ? {
+    [K in keyof TOOL_SCHEMAS]: TOOL_SCHEMAS[K] extends {
+        inputSchema: FlexibleSchema<infer INPUT>;
+    } ? Tool<INPUT, CallToolResult> & Required<Pick<Tool<INPUT, CallToolResult>, 'execute'>> : never;
+} : McpToolSet<Record<string, {
+    inputSchema: FlexibleSchema<unknown>;
+}>>;
+declare const CallToolResultSchema: z.ZodUnion<[z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodBase64;
+        mimeType: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<readonly [z.ZodObject<{
+            uri: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+        }, z.core.$loose>, z.ZodObject<{
+            uri: z.ZodString;
+            mimeType: z.ZodOptional<z.ZodString>;
+            blob: z.ZodBase64;
+        }, z.core.$loose>]>;
+    }, z.core.$loose>]>>;
+    isError: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$loose>, z.ZodObject<{
+    _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    toolResult: z.ZodUnknown;
+}, z.core.$loose>]>;
+type CallToolResult = z.infer<typeof CallToolResultSchema>;
 
-@returns An array of ModelMessages.
- */
-declare function convertToModelMessages(messages: Array<Omit<UIMessage, 'id'>>, options?: {
-    tools?: ToolSet;
-    ignoreIncompleteToolCalls?: boolean;
-}): ModelMessage[];
-/**
-@deprecated Use `convertToModelMessages` instead.
- */
-declare const convertToCoreMessages: typeof convertToModelMessages;
+interface MCPClientConfig {
+    /** Transport configuration for connecting to the MCP server */
+    transport: MCPTransportConfig | MCPTransport;
+    /** Optional callback for uncaught errors */
+    onUncaughtError?: (error: unknown) => void;
+    /** Optional client name, defaults to 'ai-sdk-mcp-client' */
+    name?: string;
+}
+declare function createMCPClient(config: MCPClientConfig): Promise<MCPClient>;
+interface MCPClient {
+    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>(options?: {
+        schemas?: TOOL_SCHEMAS;
+    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
+    close: () => Promise<void>;
+}
 
-type PrepareSendMessagesRequest<UI_MESSAGE extends UIMessage> = (options: {
-    id: string;
-    messages: UI_MESSAGE[];
-    requestMetadata: unknown;
-    body: Record<string, any> | undefined;
-    credentials: RequestCredentials | undefined;
-    headers: HeadersInit | undefined;
-    api: string;
-} & {
-    trigger: 'submit-message' | 'regenerate-message';
-    messageId: string | undefined;
-}) => {
-    body: object;
-    headers?: HeadersInit;
-    credentials?: RequestCredentials;
-    api?: string;
-} | PromiseLike<{
-    body: object;
-    headers?: HeadersInit;
-    credentials?: RequestCredentials;
-    api?: string;
-}>;
-type PrepareReconnectToStreamRequest = (options: {
-    id: string;
-    requestMetadata: unknown;
-    body: Record<string, any> | undefined;
-    credentials: RequestCredentials | undefined;
-    headers: HeadersInit | undefined;
-    api: string;
-}) => {
-    headers?: HeadersInit;
-    credentials?: RequestCredentials;
-    api?: string;
-} | PromiseLike<{
-    headers?: HeadersInit;
-    credentials?: RequestCredentials;
-    api?: string;
-}>;
 /**
- * Options for the `HttpChatTransport` class.
- *
- * @param UI_MESSAGE - The type of message to be used in the chat.
+The result of a `transcribe` call.
+It contains the transcript and additional information.
  */
-type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
+interface TranscriptionResult {
     /**
-     * The API URL to be used for the chat transport.
-     * Defaults to '/api/chat'.
+     * The complete transcribed text from the audio.
      */
-    api?: string;
+    readonly text: string;
     /**
-     * The credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
+     * Array of transcript segments with timing information.
+     * Each segment represents a portion of the transcribed text with start and end times.
      */
-    credentials?: Resolvable<RequestCredentials>;
+    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;
+    }>;
     /**
-     * HTTP headers to be sent with the API request.
+     * 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.
      */
-    headers?: Resolvable<Record<string, string> | Headers>;
+    readonly language: string | undefined;
     /**
-     * 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 total duration of the audio file in seconds.
+     * May be undefined if the duration couldn't be determined.
      */
-    body?: Resolvable<object>;
+    readonly durationInSeconds: number | undefined;
     /**
-    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;
+    Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<TranscriptionWarning>;
     /**
-     * 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.
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
      */
-    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
+    readonly responses: Array<TranscriptionModelResponseMetadata>;
     /**
-     * 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.
+    Provider metadata from the provider.
      */
-    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
-};
-declare abstract class HttpChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
-    protected api: string;
-    protected credentials: HttpChatTransportInitOptions<UI_MESSAGE>['credentials'];
-    protected headers: HttpChatTransportInitOptions<UI_MESSAGE>['headers'];
-    protected body: HttpChatTransportInitOptions<UI_MESSAGE>['body'];
-    protected fetch?: FetchFunction;
-    protected prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
-    protected prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
-    constructor({ api, credentials, headers, body, fetch, prepareSendMessagesRequest, prepareReconnectToStreamRequest, }: HttpChatTransportInitOptions<UI_MESSAGE>);
-    sendMessages({ abortSignal, ...options }: Parameters<ChatTransport<UI_MESSAGE>['sendMessages']>[0]): Promise<ReadableStream<UIMessageChunk>>;
-    reconnectToStream(options: Parameters<ChatTransport<UI_MESSAGE>['reconnectToStream']>[0]): Promise<ReadableStream<UIMessageChunk> | null>;
-    protected abstract processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
-}
-
-declare class DefaultChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
-    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
-    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
+    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
 }
 
 /**
-Check if the last message is an assistant message with completed tool call approvals.
-The last step of the message must have at least one tool approval response and
-all tool approvals must have a response.
- */
-declare function lastAssistantMessageIsCompleteWithApprovalResponses({ messages, }: {
-    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 lastAssistantMessageIsCompleteWithToolCalls({ messages, }: {
-    messages: UIMessage[];
-}): boolean;
+Generates transcripts using a transcription model.
 
-declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
-    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
-    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
-}
+@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.
 
-type CompletionRequestOptions = {
-    /**
-    An optional object of headers to be passed to the API endpoint.
-     */
-    headers?: Record<string, string> | Headers;
+@returns A result object that contains the generated transcript.
+ */
+declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-    An optional object to be passed to the API endpoint.
+  The transcription model to use.
        */
-    body?: object;
-};
-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 completion is finished streaming.
-     */
-    onFinish?: (prompt: string, completion: string) => void;
-    /**
-     * Callback function to be called when an error is encountered.
-     */
-    onError?: (error: Error) => void;
+    model: TranscriptionModel;
     /**
-     * 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;
-};
-
-type SafeValidateUIMessagesResult<UI_MESSAGE extends UIMessage> = {
-    success: true;
-    data: Array<UI_MESSAGE>;
-} | {
-    success: false;
-    error: Error;
-};
-/**
- * Validates a list of UI messages like `validateUIMessages`,
- * but instead of throwing it returns `{ success: true, data }`
- * or `{ success: false, error }`.
- */
-declare function safeValidateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools, }: {
-    messages: unknown;
-    metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
-    dataSchemas?: {
-        [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>;
-    };
-    tools?: {
-        [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>;
-    };
-}): Promise<SafeValidateUIMessagesResult<UI_MESSAGE>>;
-/**
- * Validates a list of UI messages.
- *
- * Metadata, data parts, and generic tool call structures are only validated if
- * the corresponding schemas are provided. Otherwise, they are assumed to be
- * valid.
- */
-declare function validateUIMessages<UI_MESSAGE extends UIMessage>({ messages, metadataSchema, dataSchemas, tools, }: {
-    messages: unknown;
-    metadataSchema?: FlexibleSchema<UIMessage['metadata']>;
-    dataSchemas?: {
-        [NAME in keyof InferUIMessageData<UI_MESSAGE> & string]?: FlexibleSchema<InferUIMessageData<UI_MESSAGE>[NAME]>;
-    };
-    tools?: {
-        [NAME in keyof InferUIMessageTools<UI_MESSAGE> & string]?: Tool<InferUIMessageTools<UI_MESSAGE>[NAME]['input'], InferUIMessageTools<UI_MESSAGE>[NAME]['output']>;
-    };
-}): Promise<Array<UI_MESSAGE>>;
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<TranscriptionResult>;
 
 declare global {
     /**
@@ -4919,4 +4949,4 @@ declare global {
     var AI_SDK_LOG_WARNINGS: LogWarningsFunction | undefined | false;
 }
 
-export { AbstractChat, Agent, AsyncIterableStream, CallSettings, CallWarning, ChatAddToolApproveResponseFunction, ChatInit, ChatOnDataCallback, ChatOnErrorCallback, ChatOnFinishCallback, ChatOnToolCallCallback, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataUIPart, DeepPartial, DefaultChatTransport, DownloadError, DynamicToolCall, DynamicToolError, DynamicToolResult, DynamicToolUIPart, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, ErrorHandler, ToolLoopAgent as Experimental_Agent, ToolLoopAgentSettings as Experimental_AgentSettings, DownloadFunction as Experimental_DownloadFunction, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, InferAgentUIMessage as Experimental_InferAgentUIMessage, LogWarningsFunction as Experimental_LogWarningsFunction, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, Warning as Experimental_Warning, FileUIPart, FinishReason, GenerateObjectResult, GenerateTextOnFinishCallback, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, HttpChatTransport, HttpChatTransportInitOptions, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, InferAgentUIMessage, InferUIDataParts, InferUIMessageChunk, InferUITool, InferUITools, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolInputError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelMiddleware, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputGeneratedError, NoOutputSpecifiedError, NoSpeechGeneratedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareReconnectToStreamRequest, PrepareSendMessagesRequest, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderRegistryProvider, ReasoningOutput, ReasoningUIPart, RepairTextFunction, RetryError, SafeValidateUIMessagesResult, SerialJobExecutor, SourceDocumentUIPart, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StaticToolCall, StaticToolError, StaticToolOutputDenied, StaticToolResult, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextStreamChatTransport, TextStreamPart, TextUIPart, ToolApprovalRequestOutput, ToolCallRepairError, ToolCallRepairFunction, ToolChoice, ToolLoopAgent, ToolLoopAgentOnFinishCallback, ToolLoopAgentOnStepFinishCallback, ToolLoopAgentSettings, ToolSet, ToolUIPart, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, TypedToolCall, TypedToolError, TypedToolOutputDenied, TypedToolResult, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessageChunk, UIMessagePart, UIMessageStreamOnFinishCallback, UIMessageStreamOptions, UIMessageStreamWriter, UITool, UIToolInvocation, UITools, UI_MESSAGE_STREAM_HEADERS, UnsupportedModelVersionError, UseCompletionOptions, assistantModelMessageSchema, callCompletionApi, consumeStream, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createAgentUIStreamResponse, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, MCPClient as experimental_MCPClient, MCPClientConfig as experimental_MCPClientConfig, 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, getToolOrDynamicToolName, hasToolCall, isDataUIPart, isDeepEqualData, isToolOrDynamicToolUIPart, isToolUIPart, lastAssistantMessageIsCompleteWithApprovalResponses, lastAssistantMessageIsCompleteWithToolCalls, modelMessageSchema, parsePartialJson, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, pruneMessages, readUIMessageStream, safeValidateUIMessages, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, toolModelMessageSchema, uiMessageChunkSchema, userModelMessageSchema, validateUIMessages, wrapLanguageModel, wrapProvider };
+export { AbstractChat, Agent, AsyncIterableStream, CallSettings, CallWarning, ChatAddToolApproveResponseFunction, ChatInit, ChatOnDataCallback, ChatOnErrorCallback, ChatOnFinishCallback, ChatOnToolCallCallback, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataUIPart, DeepPartial, DefaultChatTransport, DownloadError, DynamicToolCall, DynamicToolError, DynamicToolResult, DynamicToolUIPart, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, ErrorHandler, ToolLoopAgent as Experimental_Agent, ToolLoopAgentSettings as Experimental_AgentSettings, DownloadFunction as Experimental_DownloadFunction, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, InferAgentUIMessage as Experimental_InferAgentUIMessage, LogWarningsFunction as Experimental_LogWarningsFunction, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, Warning as Experimental_Warning, FileUIPart, FinishReason, GenerateObjectResult, GenerateTextOnFinishCallback, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, HttpChatTransport, HttpChatTransportInitOptions, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, InferAgentUIMessage, InferUIDataParts, InferUIMessageChunk, InferUITool, InferUITools, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolInputError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelMiddleware, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputGeneratedError, NoOutputSpecifiedError, NoSpeechGeneratedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareReconnectToStreamRequest, PrepareSendMessagesRequest, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderRegistryProvider, ReasoningOutput, ReasoningUIPart, RepairTextFunction, RetryError, SafeValidateUIMessagesResult, SerialJobExecutor, SourceDocumentUIPart, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StaticToolCall, StaticToolError, StaticToolOutputDenied, StaticToolResult, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextStreamChatTransport, TextStreamPart, TextUIPart, ToolApprovalRequestOutput, ToolCallRepairError, ToolCallRepairFunction, ToolChoice, ToolLoopAgent, ToolLoopAgentOnFinishCallback, ToolLoopAgentOnStepFinishCallback, ToolLoopAgentSettings, ToolSet, ToolUIPart, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, TypedToolCall, TypedToolError, TypedToolOutputDenied, TypedToolResult, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessageChunk, UIMessagePart, UIMessageStreamOnFinishCallback, UIMessageStreamOptions, UIMessageStreamWriter, UITool, UIToolInvocation, UITools, UI_MESSAGE_STREAM_HEADERS, UnsupportedModelVersionError, UseCompletionOptions, assistantModelMessageSchema, callCompletionApi, consumeStream, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createAgentUIStream, createAgentUIStreamResponse, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, MCPClient as experimental_MCPClient, MCPClientConfig as experimental_MCPClientConfig, 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, getToolOrDynamicToolName, hasToolCall, isDataUIPart, isDeepEqualData, isToolOrDynamicToolUIPart, isToolUIPart, lastAssistantMessageIsCompleteWithApprovalResponses, lastAssistantMessageIsCompleteWithToolCalls, modelMessageSchema, parsePartialJson, pipeAgentUIStreamToResponse, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, pruneMessages, readUIMessageStream, safeValidateUIMessages, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, toolModelMessageSchema, uiMessageChunkSchema, userModelMessageSchema, validateUIMessages, wrapLanguageModel, wrapProvider };