ai 5.0.0-beta.11 → 5.0.0-beta.12

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ModelMessage, Tool, InferToolInput, InferToolOutput, AssistantModelMessage, ToolModelMessage, ReasoningPart, Schema, SystemModelMessage, UserModelMessage, ProviderOptions, IdGenerator, Validator, StandardSchemaV1, ToolCall, FetchFunction, InferSchema, FlexibleSchema, DataContent } from '@ai-sdk/provider-utils';
+import { ModelMessage, Tool, InferToolInput, InferToolOutput, AssistantModelMessage, ToolModelMessage, ReasoningPart, Schema, SystemModelMessage, UserModelMessage, ProviderOptions, IdGenerator, InferSchema, FlexibleSchema, DataContent, Validator, StandardSchemaV1, ToolCall, Resolvable, FetchFunction } from '@ai-sdk/provider-utils';
 export { AssistantContent, AssistantModelMessage, DataContent, FilePart, IdGenerator, ImagePart, InferToolInput, InferToolOutput, ModelMessage, Schema, SystemModelMessage, TextPart, Tool, ToolCallOptions, ToolCallPart, ToolContent, ToolExecuteFunction, ToolModelMessage, ToolResultPart, UserContent, UserModelMessage, asSchema, createIdGenerator, generateId, jsonSchema, tool } from '@ai-sdk/provider-utils';
 import { AttributeValue, Tracer } from '@opentelemetry/api';
 import { EmbeddingModelV2, EmbeddingModelV2Embedding, ImageModelV2, ImageModelV2CallWarning, ImageModelV2ProviderMetadata, JSONValue as JSONValue$1, LanguageModelV2, LanguageModelV2FinishReason, LanguageModelV2CallWarning, LanguageModelV2Source, SharedV2ProviderMetadata, SpeechModelV2, SpeechModelV2CallWarning, TranscriptionModelV2, TranscriptionModelV2CallWarning, LanguageModelV2Usage, LanguageModelV2CallOptions, AISDKError, LanguageModelV2ToolCall, JSONSchema7, JSONParseError, TypeValidationError, LanguageModelV2Middleware, ProviderV2, NoSuchModelError, JSONObject } from '@ai-sdk/provider';
@@ -717,12 +717,14 @@ type PrepareStepFunction<TOOLS extends Record<string, Tool> = Record<string, Too
     steps: Array<StepResult<NoInfer<TOOLS>>>;
     stepNumber: number;
     model: LanguageModel;
+    messages: Array<ModelMessage>;
 }) => PromiseLike<PrepareStepResult<TOOLS>> | PrepareStepResult<TOOLS>;
 type PrepareStepResult<TOOLS extends Record<string, Tool> = Record<string, Tool>> = {
     model?: LanguageModel;
     toolChoice?: ToolChoice<NoInfer<TOOLS>>;
     activeTools?: Array<keyof NoInfer<TOOLS>>;
     system?: string;
+    messages?: Array<ModelMessage>;
 } | undefined;
 
 type StopCondition<TOOLS extends ToolSet> = (options: {
@@ -948,6 +950,236 @@ A function that attempts to repair a tool call that failed to parse.
     };
 }): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
 
+/**
+ * Detects the first chunk in a buffer.
+ *
+ * @param buffer - The buffer to detect the first chunk in.
+ *
+ * @returns The first detected chunk, or `undefined` if no chunk was detected.
+ */
+type ChunkDetector = (buffer: string) => string | undefined | null;
+/**
+ * Smooths text streaming output.
+ *
+ * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
+ * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, or provide a custom RegExp pattern for custom chunking.
+ *
+ * @returns A transform stream that smooths text streaming output.
+ */
+declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay }, }?: {
+    delayInMs?: number | null;
+    chunking?: 'word' | 'line' | RegExp | ChunkDetector;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        delay?: (delayInMs: number | null) => Promise<void>;
+    };
+}): (options: {
+    tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+
+/**
+A transformation that is applied to the stream.
+
+@param stopStream - A function that stops the source stream.
+@param tools - The tools that are accessible to and can be called by the model. The model needs to support calling tools.
+ */
+type StreamTextTransform<TOOLS extends ToolSet> = (options: {
+    tools: TOOLS;
+    stopStream: () => void;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+/**
+Callback that is set using the `onError` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnErrorCallback = (event: {
+    error: unknown;
+}) => Promise<void> | void;
+/**
+Callback that is set using the `onStepFinish` option.
+
+@param stepResult - The result of the step.
+ */
+type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
+/**
+Callback that is set using the `onChunk` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
+    chunk: Extract<TextStreamPart<TOOLS>, {
+        type: 'text' | 'reasoning' | 'source' | 'tool-call' | 'tool-input-start' | 'tool-input-delta' | 'tool-result' | 'raw';
+    }>;
+}) => Promise<void> | void;
+/**
+Callback that is set using the `onFinish` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
+    /**
+Details for all steps.
+   */
+    readonly steps: StepResult<TOOLS>[];
+    /**
+Total usage for all steps. This is the sum of the usage of all steps.
+     */
+    readonly totalUsage: LanguageModelUsage;
+}) => Promise<void> | void;
+/**
+Generate a text and call tools for a given prompt using a language model.
+
+This function streams the output. If you do not want to stream the output, use `generateText` 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.
+
+@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 maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
+
+@param onChunk - Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
+@param onError - Callback that is called when an error occurs during streaming. You can use it to log errors.
+@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+@param onFinish - Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
+@return
+A result object for accessing different stream types and additional information.
+ */
+declare function streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, stopWhen, experimental_output: output, experimental_telemetry: telemetry, prepareStep, providerOptions, experimental_activeTools, activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, includeRawChunks, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModel;
+    /**
+The tools that the model can call. The model needs to support calling tools.
+    */
+    tools?: TOOLS;
+    /**
+The tool choice strategy. Default: 'auto'.
+     */
+    toolChoice?: ToolChoice<TOOLS>;
+    /**
+Condition for stopping the generation when there are tool results in the last step.
+When the condition is an array, any of the conditions can be met to stop the generation.
+
+@default stepCountIs(1)
+     */
+    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
+    /**
+Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+ */
+    providerOptions?: ProviderOptions;
+    /**
+     * @deprecated Use `activeTools` instead.
+     */
+    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
+    /**
+   Limits the tools that are available for the model to call without
+   changing the tool call and result types in the result.
+        */
+    activeTools?: Array<keyof NoInfer<TOOLS>>;
+    /**
+Optional specification for parsing structured outputs from the LLM response.
+     */
+    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
+    /**
+Optional function that you can use to provide different settings for a step.
+
+@param options - The options for the step.
+@param options.steps - The steps that have been executed so far.
+@param options.stepNumber - The number of the step that is being executed.
+@param options.model - The model that is being used.
+
+@returns An object that contains the settings for the step.
+If you return undefined (or for undefined settings), the settings from the outer level will be used.
+    */
+    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
+    /**
+A function that attempts to repair a tool call that failed to parse.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    /**
+Optional stream transformations.
+They are applied in the order they are provided.
+The stream transformations must maintain the stream structure for streamText to work correctly.
+     */
+    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
+    /**
+Whether to include raw chunks from the provider in the stream.
+When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
+This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
+Defaults to false.
+     */
+    includeRawChunks?: boolean;
+    /**
+Callback that is called for each chunk of the stream.
+The stream processing will pause until the callback promise is resolved.
+     */
+    onChunk?: StreamTextOnChunkCallback<TOOLS>;
+    /**
+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?: StreamTextOnErrorCallback;
+    /**
+Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
+The usage is the combined usage of all steps.
+     */
+    onFinish?: StreamTextOnFinishCallback<TOOLS>;
+    /**
+Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
+    /**
+Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        now?: () => number;
+        generateId?: IdGenerator;
+        currentDate?: () => Date;
+    };
+}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+
 /**
 The data types that can be used in the UI message for the UI message data parts.
  */
@@ -956,10 +1188,19 @@ type UITool = {
     input: unknown;
     output: unknown | undefined;
 };
+/**
+ * Infer the input and output types of a tool so it can be used as a UI tool.
+ */
 type InferUITool<TOOL extends Tool> = {
     input: InferToolInput<TOOL>;
     output: InferToolOutput<TOOL>;
 };
+/**
+ * Infer the input and output types of a tool set so it can be used as a UI tool set.
+ */
+type InferUITools<TOOLS extends ToolSet> = {
+    [NAME in keyof TOOLS & string]: InferUITool<TOOLS[NAME]>;
+};
 type UITools = Record<string, UITool>;
 /**
 AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
@@ -1625,26 +1866,196 @@ declare class Agent<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = neve
     }): StreamTextResult<TOOLS, OUTPUT_PARTIAL>;
 }
 
-declare const symbol$c: unique symbol;
-declare class InvalidArgumentError extends AISDKError {
-    private readonly [symbol$c];
-    readonly parameter: string;
-    readonly value: unknown;
-    constructor({ parameter, value, message, }: {
-        parameter: string;
-        value: unknown;
-        message: string;
-    });
-    static isInstance(error: unknown): error is InvalidArgumentError;
-}
-
-type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-start';
-    providerMetadata?: ProviderMetadata;
-    id: string;
-} | {
-    type: 'text-delta';
-    id: string;
+/**
+The result of an `embed` call.
+It contains the embedding, the value, and additional information.
+ */
+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;
+    /**
+    Optional response data.
+       */
+    readonly response?: {
+        /**
+      Response headers.
+           */
+        headers?: Record<string, string>;
+        /**
+        The response body.
+        */
+        body?: 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.
+ */
+declare function embed<VALUE>({ model, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
+    /**
+  The embedding model to use.
+       */
+    model: EmbeddingModel<VALUE>;
+    /**
+  The value that should be embedded.
+     */
+    value: VALUE;
+    /**
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+    /**
+    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).
+     */
+    experimental_telemetry?: TelemetrySettings;
+}): Promise<EmbedResult<VALUE>>;
+
+/**
+The result of a `embedMany` call.
+It contains the embeddings, the values, and additional information.
+ */
+interface EmbedManyResult<VALUE> {
+    /**
+    The values that were embedded.
+       */
+    readonly values: Array<VALUE>;
+    /**
+    The embeddings. They are in the same order as the values.
+      */
+    readonly embeddings: Array<Embedding>;
+    /**
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingModelUsage;
+    /**
+    Optional raw response data.
+       */
+    readonly responses?: Array<{
+        /**
+  Response headers.
+       */
+        headers?: Record<string, string>;
+        /**
+    The response body.
+    */
+        body?: unknown;
+    } | undefined>;
+}
+
+/**
+Embed several values using an embedding model. The type of the value is defined
+by the embedding model.
+
+`embedMany` automatically splits large requests into smaller chunks if the model
+has a limit on how many embeddings can be generated in a single call.
+
+@param model - The embedding model to use.
+@param values - The values that should be embedded.
+
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the embeddings, the value, and additional information.
+ */
+declare function embedMany<VALUE>({ model, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
+    /**
+  The embedding model to use.
+       */
+    model: EmbeddingModel<VALUE>;
+    /**
+  The values that should be embedded.
+     */
+    values: Array<VALUE>;
+    /**
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+    Additional provider-specific options. They are passed through
+    to the provider from the AI SDK and enable provider-specific
+    functionality that can be fully encapsulated in the provider.
+    */
+    providerOptions?: ProviderOptions;
+    /**
+     * Maximum number of concurrent requests.
+     *
+     * @default Infinity
+     */
+    maxParallelCalls?: number;
+}): Promise<EmbedManyResult<VALUE>>;
+
+declare const symbol$c: unique symbol;
+declare class InvalidArgumentError extends AISDKError {
+    private readonly [symbol$c];
+    readonly parameter: string;
+    readonly value: unknown;
+    constructor({ parameter, value, message, }: {
+        parameter: string;
+        value: unknown;
+        message: string;
+    });
+    static isInstance(error: unknown): error is InvalidArgumentError;
+}
+
+type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
+    type: 'text-start';
+    providerMetadata?: ProviderMetadata;
+    id: string;
+} | {
+    type: 'text-delta';
+    id: string;
     providerMetadata?: ProviderMetadata;
     delta: string;
 } | {
@@ -1889,480 +2300,299 @@ declare class RetryError extends AISDKError {
     static isInstance(error: unknown): error is RetryError;
 }
 
-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 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>;
-
-interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
+/**
+The result of a `generateImage` call.
+It contains the images and additional information.
+ */
+interface GenerateImageResult {
     /**
-     * Appends a data stream part to the stream.
+  The first image that was generated.
      */
-    write(part: InferUIMessageChunk<UI_MESSAGE>): void;
+    readonly image: GeneratedFile;
     /**
-     * Merges the contents of another stream to this stream.
+  The images that were generated.
+       */
+    readonly images: Array<GeneratedFile>;
+    /**
+  Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<ImageGenerationWarning>;
+    /**
+  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
      */
-    merge(stream: ReadableStream<InferUIMessageChunk<UI_MESSAGE>>): void;
+    readonly responses: Array<ImageModelResponseMetadata>;
     /**
-     * Error handler that is used by the data stream writer.
-     * This is intended for forwarding when merging streams
-     * to prevent duplicated error masking.
+     * 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.
      */
-    onError: ErrorHandler | undefined;
+    readonly providerMetadata: ImageModelProviderMetadata;
 }
 
-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?: (options: {
-        /**
-         * The updates list of UI messages.
-         */
-        messages: UI_MESSAGE[];
-        /**
-         * Indicates whether the response message is a continuation of the last original message,
-         * or if a new message was created.
-         */
-        isContinuation: boolean;
-        /**
-         * The message that was sent to the client as a response
-         * (including the original message if it was extended).
-         */
-        responseMessage: UI_MESSAGE;
-    }) => void;
-    generateId?: IdGenerator;
-}): ReadableStream<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;
-
 /**
- * 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.
- *
- * @returns An `AsyncIterableStream` of `UIMessage`s. Each stream part is a different state of the same message
- * as it is being completed.
- */
-declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({ message, stream, }: {
-    message?: UI_MESSAGE;
-    stream: ReadableStream<UIMessageChunk>;
-}): 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;
-};
+Generates images using an image model.
 
-interface ChatTransport<UI_MESSAGE extends UIMessage> {
-    sendMessages: (options: {
-        chatId: string;
-        messages: UI_MESSAGE[];
-        abortSignal: AbortSignal | undefined;
-    } & {
-        trigger: 'submit-user-message' | 'submit-tool-result' | 'regenerate-assistant-message';
-        messageId: string | undefined;
-    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
-    reconnectToStream: (options: {
-        chatId: string;
-    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
-}
+@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.
 
-type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
-    id?: UI_MESSAGE['id'];
-    role?: UI_MESSAGE['role'];
-};
-type UIDataPartSchemas = Record<string, Validator<any> | StandardSchemaV1<any>>;
-type UIDataTypesToSchemas<T extends UIDataTypes> = {
-    [K in keyof T]: Validator<T[K]> | StandardSchemaV1<T[K]>;
-};
-type InferUIDataParts<T extends UIDataPartSchemas> = {
-    [K in keyof T]: T[K] extends Validator<infer U> ? U : T[K] extends StandardSchemaV1<infer U> ? U : unknown;
-};
-type ChatRequestOptions = {
+@returns A result object that contains the generated images.
+ */
+declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-    Additional headers that should be to be passed to the API endpoint.
+  The image model to use.
+       */
+    model: ImageModelV2;
+    /**
+  The prompt that should be used to generate the image.
      */
-    headers?: Record<string, string> | Headers;
+    prompt: string;
     /**
-    Additional body JSON properties that should be sent to the API endpoint.
+  Number of images to generate.
      */
-    body?: object;
-    metadata?: unknown;
-};
-type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
-interface ChatState<UI_MESSAGE extends UIMessage> {
-    status: ChatStatus;
-    error: Error | undefined;
-    messages: UI_MESSAGE[];
-    pushMessage: (message: UI_MESSAGE) => void;
-    popMessage: () => void;
-    replaceMessage: (index: number, message: UI_MESSAGE) => void;
-    snapshot: <T>(thing: T) => T;
-}
-type ChatOnErrorCallback = (error: Error) => void;
-type ChatOnToolCallCallback = ({ toolCall, }: {
-    toolCall: ToolCall<string, unknown>;
-}) => void | Promise<unknown> | unknown;
-type ChatOnDataCallback<UI_MESSAGE extends UIMessage> = (dataPart: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => void;
-type ChatOnFinishCallback<UI_MESSAGE extends UIMessage> = (options: {
-    message: UI_MESSAGE;
-}) => void;
-interface ChatInit<UI_MESSAGE extends UIMessage> {
+    n?: number;
     /**
-     * A unique identifier for the chat. If not provided, a random one will be
-     * generated.
+  Number of images to generate.
      */
-    id?: string;
-    messageMetadataSchema?: Validator<InferUIMessageMetadata<UI_MESSAGE>> | StandardSchemaV1<InferUIMessageMetadata<UI_MESSAGE>>;
-    dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
-    messages?: UI_MESSAGE[];
+    maxImagesPerCall?: number;
     /**
-     * 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.
+  Size of the images to generate. Must have the format `{width}x{height}`. If not provided, the default size will be used.
      */
-    generateId?: IdGenerator;
-    transport?: ChatTransport<UI_MESSAGE>;
-    maxSteps?: number;
+    size?: `${number}x${number}`;
     /**
-     * Callback function to be called when an error is encountered.
+  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
      */
-    onError?: ChatOnErrorCallback;
+    aspectRatio?: `${number}:${number}`;
     /**
-    Optional callback function that is invoked when a tool call is received.
-    Intended for automatic client-side tool execution.
+  Seed for the image generation. If not provided, the default seed will be used.
+     */
+    seed?: number;
+    /**
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
   
-    You can optionally return a result for the tool call,
-    either synchronously or asynchronously.
+  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"
+    }
+  }
+  ```
        */
-    onToolCall?: ChatOnToolCallCallback;
+    providerOptions?: ProviderOptions;
     /**
-     * Optional callback function that is called when the assistant message is finished streaming.
-     *
-     * @param message The message that was streamed.
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    onFinish?: ChatOnFinishCallback<UI_MESSAGE>;
+    maxRetries?: number;
     /**
-     * Optional callback function that is called when a data part is received.
-     *
-     * @param data The data part that was received.
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<GenerateImageResult>;
+
+/**
+The result of a `generateObject` call.
+ */
+interface GenerateObjectResult<OBJECT> {
+    /**
+    The generated object (typed according to the schema).
+       */
+    readonly object: OBJECT;
+    /**
+    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.
      */
-    onData?: ChatOnDataCallback<UI_MESSAGE>;
-}
-declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
-    readonly id: string;
-    readonly generateId: IdGenerator;
-    protected state: ChatState<UI_MESSAGE>;
-    private messageMetadataSchema;
-    private dataPartSchemas;
-    private readonly transport;
-    private maxSteps;
-    private onError?;
-    private onToolCall?;
-    private onFinish?;
-    private onData?;
-    private activeResponse;
-    private jobExecutor;
-    constructor({ generateId, id, transport, maxSteps, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, onData, }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
-        state: ChatState<UI_MESSAGE>;
-    });
+    readonly request: LanguageModelRequestMetadata;
     /**
-     * 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.
+  Additional response information.
      */
-    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[]);
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    Response body (available only for providers that use HTTP requests).
+        */
+        body?: unknown;
+    };
     /**
-     * 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.
+  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.
      */
-    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>;
-    addToolResult: ({ toolCallId, output, }: {
-        toolCallId: string;
-        output: unknown;
-    }) => Promise<void>;
+    readonly providerMetadata: ProviderMetadata | undefined;
     /**
-     * Abort the current request immediately, keep the generated tokens if any.
-     */
-    stop: () => Promise<void>;
-    private makeRequest;
+    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;
 }
 
-declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
-
 /**
-Converts an array of messages from useChat into an array of CoreMessages that can be used
-with the AI core functions (e.g. `streamText`).
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
 
-@param messages - The messages to convert.
-@param options.tools - The tools to use.
-@param options.ignoreIncompleteToolCalls - Whether to ignore incomplete tool calls. Default is `false`.
- */
-declare function convertToModelMessages(messages: Array<Omit<UIMessage, 'id'>>, options?: {
-    tools?: ToolSet;
-    ignoreIncompleteToolCalls?: boolean;
-}): ModelMessage[];
+Should return the repaired text or null if the text cannot be repaired.
+     */
+type RepairTextFunction = (options: {
+    text: string;
+    error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;
 /**
-@deprecated Use `convertToModelMessages` instead.
- */
-declare const convertToCoreMessages: typeof convertToModelMessages;
+Generate a structured, typed object for a given prompt and schema using a language model.
 
-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-user-message' | 'submit-tool-result' | 'regenerate-assistant-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;
-}>;
-type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
-    api?: string;
+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.
+
+@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_repairText - A function that attempts to repair the raw output of the mode
+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.
+ */
+declare function generateObject<SCHEMA extends z3.Schema | z4$1.ZodType | Schema = z4$1.ZodType<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 credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
-     */
-    credentials?: RequestCredentials;
+The enum values that the model should use.
+  */
+    enum: Array<RESULT>;
+    mode?: 'json';
+    output: 'enum';
+} : OUTPUT extends 'no-schema' ? {} : {
     /**
-     * HTTP headers to be sent with the API request.
-     */
-    headers?: Record<string, string> | Headers;
+The schema of the object that the model should generate.
+*/
+    schema: SCHEMA;
     /**
-     * Extra body object to be sent with the API request.
-     * @example
-     * Send a `sessionId` to the API along with the messages.
-     * ```js
-     * useChat({
-     *   body: {
-     *     sessionId: '123',
-     *   }
-     * })
-     * ```
-     */
-    body?: object;
+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;
     /**
-    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;
+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;
     /**
-     * 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.
-     */
-    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
-    prepareReconnectToStreamRequest?: PrepareReconnectToStreamRequest;
-};
-declare abstract class HttpChatTransport<UI_MESSAGE extends UIMessage> implements ChatTransport<UI_MESSAGE> {
-    protected api: string;
-    protected credentials?: RequestCredentials;
-    protected headers?: Record<string, string> | Headers;
-    protected body?: object;
-    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>;
-}
+The mode to use for object generation.
 
-declare class DefaultChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
-    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
-    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
-}
+The schema is converted into a JSON schema and used in one of the following ways
 
-declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
-    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
-    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
-}
+- '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.
 
-type CompletionRequestOptions = {
+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;
     /**
-    An optional object of headers to be passed to the API endpoint.
+The language model to use.
      */
-    headers?: Record<string, string> | Headers;
+    model: LanguageModel;
     /**
-    An optional object to be passed to the API endpoint.
-       */
-    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.
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
      */
-    onError?: (error: Error) => void;
+    experimental_repairText?: RepairTextFunction;
     /**
-     * The credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
-     */
-    credentials?: RequestCredentials;
+Optional telemetry configuration (experimental).
+       */
+    experimental_telemetry?: TelemetrySettings;
     /**
-     * HTTP headers to be sent with the API request.
-     */
-    headers?: Record<string, string> | Headers;
+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;
     /**
-     * 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',
-     *   }
-     * })
-     * ```
+     * Internal. For test use only. May change without notice.
      */
-    body?: object;
-    /**
-    Streaming protocol that is used. Defaults to `data`.
-       */
-    streamProtocol?: 'data' | 'text';
-    /**
-    Custom fetch implementation. You can use it as a middleware to intercept requests,
-    or to provide a custom fetch implementation for e.g. testing.
-        */
-    fetch?: FetchFunction;
-};
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<RESULT>>;
 
 /**
  * Calculates the cosine similarity between two vectors. This is a useful metric for
@@ -2425,257 +2655,137 @@ declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDela
 }): ReadableStream<T>;
 
 /**
-The result of an `embed` call.
-It contains the embedding, the value, and additional information.
+The result of a `streamObject` call that contains the partial object stream and additional information.
  */
-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 StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
-    Optional response data.
+    Warnings from the model provider (e.g. unsupported settings)
        */
-    readonly response?: {
-        /**
-      Response headers.
-           */
-        headers?: Record<string, string>;
-        /**
-        The response body.
-        */
-        body?: 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.
- */
-declare function embed<VALUE>({ model, value, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
+    readonly warnings: Promise<CallWarning[] | undefined>;
     /**
-  The embedding model to use.
+    The token usage of the generated response. Resolved when the response is finished.
        */
-    model: EmbeddingModel<VALUE>;
-    /**
-  The value that should be embedded.
-     */
-    value: VALUE;
+    readonly usage: Promise<LanguageModelUsage>;
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
+  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.
      */
-    maxRetries?: number;
+    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-  Abort signal.
+  Additional request information from the last step.
    */
-    abortSignal?: AbortSignal;
+    readonly request: Promise<LanguageModelRequestMetadata>;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
+  Additional response information.
    */
-    headers?: Record<string, string>;
+    readonly response: Promise<LanguageModelResponseMetadata>;
     /**
-    Additional provider-specific options. They are passed through
-    to the provider from the AI SDK and enable provider-specific
-    functionality that can be fully encapsulated in the provider.
-    */
-    providerOptions?: ProviderOptions;
+    The generated object (typed according to the schema). Resolved when the response is finished.
+       */
+    readonly object: Promise<RESULT>;
     /**
-     * Optional telemetry configuration (experimental).
+    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`.
      */
-    experimental_telemetry?: TelemetrySettings;
-}): Promise<EmbedResult<VALUE>>;
-
-/**
-The result of a `embedMany` call.
-It contains the embeddings, the values, and additional information.
- */
-interface EmbedManyResult<VALUE> {
+    readonly elementStream: ELEMENT_STREAM;
     /**
-    The values that were embedded.
+    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 values: Array<VALUE>;
-    /**
-    The embeddings. They are in the same order as the values.
-      */
-    readonly embeddings: Array<Embedding>;
+    readonly textStream: AsyncIterableStream<string>;
     /**
-    The embedding token usage.
-      */
-    readonly usage: EmbeddingModelUsage;
+    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>>;
     /**
-    Optional raw response data.
+    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.
        */
-    readonly responses?: Array<{
-        /**
-  Response headers.
+    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.
        */
-        headers?: Record<string, string>;
-        /**
-    The response body.
-    */
-        body?: unknown;
-    } | undefined>;
+    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;
+};
 
 /**
-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.
+Callback that is set using the `onError` option.
 
-@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 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.
 
-@returns A result object that contains the embeddings, the value, and additional information.
+@param event - The event that is passed to the callback.
  */
-declare function embedMany<VALUE>({ model, values, maxParallelCalls, maxRetries: maxRetriesArg, abortSignal, headers, providerOptions, experimental_telemetry: telemetry, }: {
-    /**
-  The embedding model to use.
-       */
-    model: EmbeddingModel<VALUE>;
+type StreamObjectOnFinishCallback<RESULT> = (event: {
     /**
-  The values that should be embedded.
-     */
-    values: Array<VALUE>;
+  The token usage of the generated response.
+  */
+    usage: LanguageModelUsage;
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
-  
-  @default 2
-     */
-    maxRetries?: number;
+  The generated object. Can be undefined if the final object does not match the schema.
+  */
+    object: RESULT | undefined;
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
+  */
+    error: unknown | undefined;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
+  Response metadata.
    */
-    headers?: Record<string, string>;
-    /**
-     * Optional telemetry configuration (experimental).
-     */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-    Additional provider-specific options. They are passed through
-    to the provider from the AI SDK and enable provider-specific
-    functionality that can be fully encapsulated in the provider.
-    */
-    providerOptions?: ProviderOptions;
-    /**
-     * Maximum number of concurrent requests.
-     *
-     * @default Infinity
-     */
-    maxParallelCalls?: number;
-}): Promise<EmbedManyResult<VALUE>>;
-
-/**
- * Detects the first chunk in a buffer.
- *
- * @param buffer - The buffer to detect the first chunk in.
- *
- * @returns The first detected chunk, or `undefined` if no chunk was detected.
- */
-type ChunkDetector = (buffer: string) => string | undefined | null;
-/**
- * Smooths text streaming output.
- *
- * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
- * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, or provide a custom RegExp pattern for custom chunking.
- *
- * @returns A transform stream that smooths text streaming output.
- */
-declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay }, }?: {
-    delayInMs?: number | null;
-    chunking?: 'word' | 'line' | RegExp | ChunkDetector;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        delay?: (delayInMs: number | null) => Promise<void>;
-    };
-}): (options: {
-    tools: TOOLS;
-}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
-
-/**
-A transformation that is applied to the stream.
-
-@param stopStream - A function that stops the source stream.
-@param tools - The tools that are accessible to and can be called by the model. The model needs to support calling tools.
- */
-type StreamTextTransform<TOOLS extends ToolSet> = (options: {
-    tools: TOOLS;
-    stopStream: () => void;
-}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
-/**
-Callback that is set using the `onError` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamTextOnErrorCallback = (event: {
-    error: unknown;
-}) => Promise<void> | void;
-/**
-Callback that is set using the `onStepFinish` option.
-
-@param stepResult - The result of the step.
- */
-type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
-/**
-Callback that is set using the `onChunk` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
-    chunk: Extract<TextStreamPart<TOOLS>, {
-        type: 'text' | 'reasoning' | 'source' | 'tool-call' | 'tool-input-start' | 'tool-input-delta' | 'tool-result' | 'raw';
-    }>;
-}) => Promise<void> | void;
-/**
-Callback that is set using the `onFinish` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamTextOnFinishCallback<TOOLS extends ToolSet> = (event: StepResult<TOOLS> & {
+    response: LanguageModelResponseMetadata;
     /**
-Details for all steps.
-   */
-    readonly steps: StepResult<TOOLS>[];
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    warnings?: CallWarning[];
     /**
-Total usage for all steps. This is the sum of the usage of all steps.
-     */
-    readonly totalUsage: LanguageModelUsage;
+  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 text and call tools for a given prompt using a language model.
+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 `generateText` instead.
+This function streams the output. If you do not want to stream the output, use `generateObject` 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.
@@ -2709,37 +2819,74 @@ If set and supported by the model, calls will generate deterministic results.
 @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 maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
+@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 onChunk - Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
-@param onError - Callback that is called when an error occurs during streaming. You can use it to log errors.
-@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
-@param onFinish - Callback that is called when the LLM response and all request tool executions
-(for tools that have an `execute` function) are finished.
+@param output - The type of the output.
 
-@return
-A result object for accessing different stream types and additional information.
+- '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 streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, stopWhen, experimental_output: output, experimental_telemetry: telemetry, prepareStep, providerOptions, experimental_activeTools, activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, includeRawChunks, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
+declare function streamObject<SCHEMA extends z3.Schema | z4$1.ZodType | Schema = z4$1.ZodType<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 language model to use.
-     */
-    model: LanguageModel;
+The enum values that the model should use.
+  */
+    enum: Array<RESULT>;
+    mode?: 'json';
+    output: 'enum';
+} : OUTPUT extends 'no-schema' ? {} : {
     /**
-The tools that the model can call. The model needs to support calling tools.
-    */
-    tools?: TOOLS;
+The schema of the object that the model should generate.
+*/
+    schema: SCHEMA;
     /**
-The tool choice strategy. Default: 'auto'.
-     */
-    toolChoice?: ToolChoice<TOOLS>;
+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;
     /**
-Condition for stopping the generation when there are tool results in the last step.
-When the condition is an array, any of the conditions can be met to stop the generation.
+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.
 
-@default stepCountIs(1)
-     */
-    stopWhen?: StopCondition<NoInfer<TOOLS>> | Array<StopCondition<NoInfer<TOOLS>>>;
+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;
     /**
 Optional telemetry configuration (experimental).
      */
@@ -2748,156 +2895,108 @@ Optional telemetry configuration (experimental).
 Additional provider-specific options. They are passed through
 to the provider from the AI SDK and enable provider-specific
 functionality that can be fully encapsulated in the provider.
- */
+*/
     providerOptions?: ProviderOptions;
     /**
-     * @deprecated Use `activeTools` instead.
-     */
-    experimental_activeTools?: Array<keyof NoInfer<TOOLS>>;
+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;
     /**
-   Limits the tools that are available for the model to call without
-   changing the tool call and result types in the result.
-        */
-    activeTools?: Array<keyof NoInfer<TOOLS>>;
+Callback that is called when the LLM response and the final object validation are finished.
+*/
+    onFinish?: StreamObjectOnFinishCallback<RESULT>;
     /**
-Optional specification for parsing structured outputs from the LLM response.
+     * Internal. For test use only. May change without notice.
      */
-    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
-    /**
-Optional function that you can use to provide different settings for a step.
-
-@param options - The options for the step.
-@param options.steps - The steps that have been executed so far.
-@param options.stepNumber - The number of the step that is being executed.
-@param options.model - The model that is being 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>;
 
-@returns An object that contains the settings for the step.
-If you return undefined (or for undefined settings), the settings from the outer level will be used.
-    */
-    prepareStep?: PrepareStepFunction<NoInfer<TOOLS>>;
+/**
+ * A generated audio file.
+ */
+interface GeneratedAudioFile extends GeneratedFile {
     /**
-A function that attempts to repair a tool call that failed to parse.
+     * Audio format of the file (e.g., 'mp3', 'wav', etc.)
      */
-    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
-    /**
-Optional stream transformations.
-They are applied in the order they are provided.
-The stream transformations must maintain the stream structure for streamText to work correctly.
-     */
-    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
-    /**
-Whether to include raw chunks from the provider in the stream.
-When enabled, you will receive raw chunks with type 'raw' that contain the unprocessed data from the provider.
-This allows access to cutting-edge provider features not yet wrapped by the AI SDK.
-Defaults to false.
-     */
-    includeRawChunks?: boolean;
-    /**
-Callback that is called for each chunk of the stream.
-The stream processing will pause until the callback promise is resolved.
-     */
-    onChunk?: StreamTextOnChunkCallback<TOOLS>;
-    /**
-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?: StreamTextOnErrorCallback;
-    /**
-Callback that is called when the LLM response and all request tool executions
-(for tools that have an `execute` function) are finished.
-
-The usage is the combined usage of all steps.
-     */
-    onFinish?: StreamTextOnFinishCallback<TOOLS>;
-    /**
-Callback that is called when each step (LLM call) is finished, including intermediate steps.
-    */
-    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
-    /**
-Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        now?: () => number;
-        generateId?: IdGenerator;
-        currentDate?: () => Date;
-    };
-}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+    readonly format: string;
+}
 
 /**
-The result of a `generateImage` call.
-It contains the images and additional information.
+The result of a `generateSpeech` call.
+It contains the audio data and additional information.
  */
-interface GenerateImageResult {
+interface SpeechResult {
     /**
-  The first image that was generated.
+     * The audio data as a base64 encoded string or binary data.
      */
-    readonly image: GeneratedFile;
-    /**
-  The images that were generated.
-       */
-    readonly images: Array<GeneratedFile>;
+    readonly audio: GeneratedAudioFile;
     /**
-  Warnings for the call, e.g. unsupported settings.
+    Warnings for the call, e.g. unsupported settings.
        */
-    readonly warnings: Array<ImageGenerationWarning>;
+    readonly warnings: Array<SpeechWarning>;
     /**
-  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
      */
-    readonly responses: Array<ImageModelResponseMetadata>;
+    readonly responses: Array<SpeechModelResponseMetadata>;
     /**
-     * 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.
+    Provider metadata from the provider.
      */
-    readonly providerMetadata: ImageModelProviderMetadata;
+    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
 }
 
 /**
-Generates images using an image model.
+Generates speech audio using a speech 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 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 images.
+@returns A result object that contains the generated audio data.
  */
-declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
+declare function generateSpeech({ model, text, voice, outputFormat, instructions, speed, language, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-  The image model to use.
+  The speech model to use.
        */
-    model: ImageModelV2;
+    model: SpeechModelV2;
     /**
-  The prompt that should be used to generate the image.
+  The text to convert to speech.
      */
-    prompt: string;
+    text: string;
     /**
-  Number of images to generate.
+  The voice to use for speech generation.
      */
-    n?: number;
+    voice?: string;
     /**
-  Number of images to generate.
+     * The desired output format for the audio e.g. "mp3", "wav", etc.
      */
-    maxImagesPerCall?: number;
+    outputFormat?: 'mp3' | 'wav' | (string & {});
     /**
-  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}`;
+      Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+    */
+    instructions?: string;
     /**
-  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
+    The speed of the speech generation.
      */
-    aspectRatio?: `${number}:${number}`;
+    speed?: number;
     /**
-  Seed for the image generation. If not provided, the default seed will be used.
+    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?: number;
+    language?: string;
     /**
   Additional provider-specific options that are passed through to the provider
   as body parameters.
@@ -2906,15 +3005,13 @@ declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspec
   record is keyed by the provider-specific metadata key.
   ```ts
   {
-    "openai": {
-      "style": "vivid"
-    }
+    "openai": {}
   }
   ```
        */
     providerOptions?: ProviderOptions;
     /**
-  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  Maximum number of retries per speech model call. Set to 0 to disable retries.
   
   @default 2
      */
@@ -2928,1009 +3025,941 @@ declare function generateImage({ model, prompt, n, maxImagesPerCall, size, aspec
   Only applicable for HTTP-based providers.
    */
     headers?: Record<string, string>;
-}): Promise<GenerateImageResult>;
+}): Promise<SpeechResult>;
 
 /**
-The result of a `generateObject` call.
+ * Applies default settings for a language model.
  */
-interface GenerateObjectResult<OBJECT> {
-    /**
-    The generated object (typed according to the schema).
-       */
-    readonly object: OBJECT;
-    /**
-    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;
-}
+declare function defaultSettingsMiddleware({ settings, }: {
+    settings: Partial<{
+        maxOutputTokens?: LanguageModelV2CallOptions['maxOutputTokens'];
+        temperature?: LanguageModelV2CallOptions['temperature'];
+        stopSequences?: LanguageModelV2CallOptions['stopSequences'];
+        topP?: LanguageModelV2CallOptions['topP'];
+        topK?: LanguageModelV2CallOptions['topK'];
+        presencePenalty?: LanguageModelV2CallOptions['presencePenalty'];
+        frequencyPenalty?: LanguageModelV2CallOptions['frequencyPenalty'];
+        responseFormat?: LanguageModelV2CallOptions['responseFormat'];
+        seed?: LanguageModelV2CallOptions['seed'];
+        tools?: LanguageModelV2CallOptions['tools'];
+        toolChoice?: LanguageModelV2CallOptions['toolChoice'];
+        headers?: LanguageModelV2CallOptions['headers'];
+        providerOptions?: LanguageModelV2CallOptions['providerOptions'];
+    }>;
+}): LanguageModelV2Middleware;
 
 /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
+ * 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;
+}): LanguageModelV2Middleware;
 
-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.
+ * Simulates streaming chunks with the response from a generate call.
+ */
+declare function simulateStreamingMiddleware(): LanguageModelV2Middleware;
 
-@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.
+/**
+ * Wraps a LanguageModelV2 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 LanguageModelV2 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.
+ * @returns A new LanguageModelV2 instance with middleware applied.
+ */
+declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
+    model: LanguageModelV2;
+    middleware: LanguageModelV2Middleware | LanguageModelV2Middleware[];
+    modelId?: string;
+    providerId?: string;
+}) => LanguageModelV2;
 
-@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.
+/**
+ * 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, LanguageModelV2>, EMBEDDING_MODELS extends Record<string, EmbeddingModelV2<string>>, IMAGE_MODELS extends Record<string, ImageModelV2>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModelV2>, SPEECH_MODELS extends Record<string, SpeechModelV2>>({ languageModels, textEmbeddingModels, imageModels, transcriptionModels, speechModels, fallbackProvider, }: {
+    languageModels?: LANGUAGE_MODELS;
+    textEmbeddingModels?: EMBEDDING_MODELS;
+    imageModels?: IMAGE_MODELS;
+    transcriptionModels?: TRANSCRIPTION_MODELS;
+    speechModels?: SPEECH_MODELS;
+    fallbackProvider?: ProviderV2;
+}): ProviderV2 & {
+    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV2;
+    textEmbeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV2<string>;
+    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV2;
+    transcriptionModel(modelId: ExtractModelId<TRANSCRIPTION_MODELS>): TranscriptionModelV2;
+    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV2;
+};
+/**
+ * @deprecated Use `customProvider` instead.
+ */
+declare const experimental_customProvider: typeof customProvider;
+type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<keyof MODELS, string>;
 
-@param output - The type of the output.
+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;
+}
 
-- '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.
+type ExtractLiteralUnion<T> = T extends string ? string extends T ? never : T : never;
+interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV2> = Record<string, ProviderV2>, SEPARATOR extends string = ':'> {
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModelV2;
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModelV2;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModelV2<string>;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV2<string>;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV2;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV2;
+    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['transcriptionModel']>>[0]>}` : never): TranscriptionModelV2;
+    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): TranscriptionModelV2;
+    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['speechModel']>>[0]>}` : never): SpeechModelV2;
+    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): SpeechModelV2;
+}
+/**
+ * Creates a registry for the given providers.
+ */
+declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV2>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, }?: {
+    separator?: SEPARATOR;
+}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
+/**
+ * @deprecated Use `createProviderRegistry` instead.
+ */
+declare const experimental_createProviderRegistry: typeof createProviderRegistry;
 
-@param experimental_repairText - A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
+declare function createTextStreamResponse({ status, statusText, headers, textStream, }: ResponseInit & {
+    textStream: ReadableStream<string>;
+}): Response;
 
-@param experimental_telemetry - Optional telemetry configuration (experimental).
+declare function pipeTextStreamToResponse({ response, status, statusText, headers, textStream, }: {
+    response: ServerResponse;
+    textStream: ReadableStream<string>;
+} & ResponseInit): void;
 
-@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 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>;
 
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
+/**
+ * Transport interface for MCP (Model Context Protocol) communication.
+ * Maps to the `Transport` interface in the MCP spec.
  */
-declare function generateObject<SCHEMA extends z3.Schema | z4$1.ZodType | Schema = z4$1.ZodType<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;
+interface MCPTransport {
     /**
-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;
+     * Initialize and start the transport
+     */
+    start(): Promise<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;
+     * Send a JSON-RPC message through the transport
+     * @param message The JSON-RPC message to send
+     */
+    send(message: JSONRPCMessage): Promise<void>;
     /**
-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;
+     * Clean up and close the transport
+     */
+    close(): Promise<void>;
     /**
-The language model to use.
+     * Event handler for transport closure
      */
-    model: LanguageModel;
+    onclose?: () => void;
     /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
+     * Event handler for transport errors
      */
-    experimental_repairText?: RepairTextFunction;
+    onerror?: (error: Error) => void;
     /**
-Optional telemetry configuration (experimental).
-       */
-    experimental_telemetry?: TelemetrySettings;
+     * Event handler for received messages
+     */
+    onmessage?: (message: JSONRPCMessage) => void;
+}
+type MCPTransportConfig = {
+    type: 'sse';
     /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
- */
-    providerOptions?: ProviderOptions;
+     * The URL of the MCP server.
+     */
+    url: string;
     /**
-     * Internal. For test use only. May change without notice.
+     * Additional HTTP headers to be sent with requests.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<RESULT>>;
+    headers?: Record<string, string>;
+};
+
+type ToolSchemas = Record<string, {
+    inputSchema: FlexibleSchema<JSONObject | unknown>;
+}> | 'automatic' | undefined;
+type MappedTool<T extends Tool | JSONObject, OUTPUT extends any> = T extends Tool<infer INPUT> ? Tool<INPUT, OUTPUT> : T extends JSONObject ? Tool<T, OUTPUT> : never;
+type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
+    inputSchema: FlexibleSchema<unknown>;
+}> ? {
+    [K in keyof TOOL_SCHEMAS]: MappedTool<TOOL_SCHEMAS[K], CallToolResult> & Required<Pick<MappedTool<TOOL_SCHEMAS[K], CallToolResult>, 'execute'>>;
+} : 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.ZodString;
+        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.ZodString;
+        }, 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>;
 
+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>;
 /**
-The result of a `streamObject` call that contains the partial object stream and additional information.
+ * A lightweight MCP Client implementation
+ *
+ * The primary purpose of this client is tool conversion between MCP<>AI SDK
+ * but can later be extended to support other MCP features
+ *
+ * Tool parameters are automatically inferred from the server's JSON schema
+ * if not explicitly provided in the tools configuration
+ *
+ * This client is meant to be used to communicate with a single server. To communicate and fetch tools across multiple servers, it's recommended to create a new client instance per server.
+ *
+ * Not supported:
+ * - Client options (e.g. sampling, roots) as they are not needed for tool conversion
+ * - Accepting notifications
+ * - Session management (when passing a sessionId to an instance of the Streamable HTTP transport)
+ * - Resumable SSE streams
  */
-interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
-    /**
-    Warnings from the model provider (e.g. unsupported settings)
-       */
-    readonly warnings: Promise<CallWarning[] | undefined>;
-    /**
-    The token usage of the generated response. Resolved when the response is finished.
-       */
-    readonly usage: Promise<LanguageModelUsage>;
+declare class MCPClient {
+    private transport;
+    private onUncaughtError?;
+    private clientInfo;
+    private requestMessageId;
+    private responseHandlers;
+    private serverCapabilities;
+    private isClosed;
+    constructor({ transport: transportConfig, name, onUncaughtError, }: MCPClientConfig);
+    init(): Promise<this>;
+    close(): Promise<void>;
+    private assertCapability;
+    private request;
+    private listTools;
+    private callTool;
+    private notification;
     /**
-  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.
+     * Returns a set of AI SDK tools from the MCP server
+     * @returns A record of tool names to their implementations
      */
-    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
-    /**
-  Additional request information from the last step.
-   */
-    readonly request: Promise<LanguageModelRequestMetadata>;
-    /**
-  Additional response information.
-   */
-    readonly response: Promise<LanguageModelResponseMetadata>;
+    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>({ schemas, }?: {
+        schemas?: TOOL_SCHEMAS;
+    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
+    private onClose;
+    private onError;
+    private onResponse;
+}
+
+/**
+The result of a `transcribe` call.
+It contains the transcript and additional information.
+ */
+interface TranscriptionResult {
     /**
-    The generated object (typed according to the schema). Resolved when the response is finished.
-       */
-    readonly object: Promise<RESULT>;
+     * The complete transcribed text from the audio.
+     */
+    readonly text: string;
     /**
-    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>;
+     * 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;
+    }>;
     /**
-     * Stream over complete array elements. Only available if the output strategy is set to `array`.
+     * The detected language of the audio content, as an ISO-639-1 code (e.g., 'en' for English).
+     * May be undefined if the language couldn't be detected.
      */
-    readonly elementStream: ELEMENT_STREAM;
+    readonly language: string | undefined;
     /**
-    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>;
+     * The total duration of the audio file in seconds.
+     * May be undefined if the duration couldn't be determined.
+     */
+    readonly durationInSeconds: number | undefined;
     /**
-    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.
+    Warnings for the call, e.g. unsupported settings.
        */
-    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
+    readonly warnings: Array<TranscriptionWarning>;
     /**
-    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;
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<TranscriptionModelResponseMetadata>;
     /**
-    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;
+    Provider metadata from the provider.
+     */
+    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
 }
-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.
+Generates transcripts using a transcription model.
 
-@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 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.
 
-@param event - The event that is passed to the callback.
+@returns A result object that contains the generated transcript.
  */
-type StreamObjectOnFinishCallback<RESULT> = (event: {
-    /**
-  The token usage of the generated response.
-  */
-    usage: LanguageModelUsage;
+declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-  The generated object. Can be undefined if the final object does not match the schema.
-  */
-    object: RESULT | undefined;
+  The transcription model to use.
+       */
+    model: TranscriptionModelV2;
     /**
-  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
-  */
-    error: unknown | undefined;
+  The audio data to transcribe.
+     */
+    audio: DataContent | URL;
     /**
-  Response metadata.
-   */
-    response: LanguageModelResponseMetadata;
+  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;
     /**
-  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.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` 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.
-
-@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 z3.Schema | z4$1.ZodType | Schema = z4$1.ZodType<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;
+  Maximum number of retries per transcript model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
     /**
-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;
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
     /**
-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.
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<TranscriptionResult>;
 
-Please note that most providers do not support all modes.
+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>;
 
-Default and recommended: 'auto' (best mode for the model).
-*/
-    mode?: 'auto' | 'json' | 'tool';
-}) & {
-    output?: OUTPUT;
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
+interface UIMessageStreamWriter<UI_MESSAGE extends UIMessage = UIMessage> {
     /**
-Optional telemetry configuration (experimental).
+     * Appends a data stream part to the stream.
      */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-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>;
+    write(part: InferUIMessageChunk<UI_MESSAGE>): void;
     /**
-     * Internal. For test use only. May change without notice.
+     * Merges the contents of another stream to this stream.
      */
-    _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 {
+    merge(stream: ReadableStream<InferUIMessageChunk<UI_MESSAGE>>): void;
     /**
-     * Audio format of the file (e.g., 'mp3', 'wav', etc.)
+     * Error handler that is used by the data stream writer.
+     * This is intended for forwarding when merging streams
+     * to prevent duplicated error masking.
      */
-    readonly format: string;
+    onError: ErrorHandler | undefined;
 }
 
-/**
-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>;
+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;
     /**
-    Provider metadata from the provider.
+     * The original messages. If they are provided, persistence mode is assumed,
+     * and a message ID is provided for the response message.
      */
-    readonly providerMetadata: Record<string, Record<string, JSONValue$1>>;
+    originalMessages?: UI_MESSAGE[];
+    onFinish?: (options: {
+        /**
+         * The updates list of UI messages.
+         */
+        messages: UI_MESSAGE[];
+        /**
+         * Indicates whether the response message is a continuation of the last original message,
+         * or if a new message was created.
+         */
+        isContinuation: boolean;
+        /**
+         * The message that was sent to the client as a response
+         * (including the original message if it was extended).
+         */
+        responseMessage: UI_MESSAGE;
+    }) => void;
+    generateId?: IdGenerator;
+}): ReadableStream<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;
+
 /**
-Generates speech audio using a speech model.
+ * 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.
+ *
+ * @returns An `AsyncIterableStream` of `UIMessage`s. Each stream part is a different state of the same message
+ * as it is being completed.
+ */
+declare function readUIMessageStream<UI_MESSAGE extends UIMessage>({ message, stream, }: {
+    message?: UI_MESSAGE;
+    stream: ReadableStream<UIMessageChunk>;
+}): AsyncIterableStream<UI_MESSAGE>;
 
-@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: SpeechModelV2;
-    /**
-  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;
-    /**
-    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.
-     */
-    language?: string;
-    /**
-  Additional provider-specific options that are passed through to the provider
-  as body parameters.
-  
-  The outer record is keyed by the provider name, and the inner
-  record is keyed by the provider-specific metadata key.
-  ```ts
-  {
-    "openai": {}
-  }
-  ```
-       */
-    providerOptions?: ProviderOptions;
-    /**
-  Maximum number of retries per speech model call. Set to 0 to disable retries.
-  
-  @default 2
-     */
-    maxRetries?: number;
-    /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
-    /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
-}): Promise<SpeechResult>;
-
-/**
- * Applies default settings for a language model.
- */
-declare function defaultSettingsMiddleware({ settings, }: {
-    settings: Partial<{
-        maxOutputTokens?: LanguageModelV2CallOptions['maxOutputTokens'];
-        temperature?: LanguageModelV2CallOptions['temperature'];
-        stopSequences?: LanguageModelV2CallOptions['stopSequences'];
-        topP?: LanguageModelV2CallOptions['topP'];
-        topK?: LanguageModelV2CallOptions['topK'];
-        presencePenalty?: LanguageModelV2CallOptions['presencePenalty'];
-        frequencyPenalty?: LanguageModelV2CallOptions['frequencyPenalty'];
-        responseFormat?: LanguageModelV2CallOptions['responseFormat'];
-        seed?: LanguageModelV2CallOptions['seed'];
-        tools?: LanguageModelV2CallOptions['tools'];
-        toolChoice?: LanguageModelV2CallOptions['toolChoice'];
-        headers?: LanguageModelV2CallOptions['headers'];
-        providerOptions?: LanguageModelV2CallOptions['providerOptions'];
-    }>;
-}): LanguageModelV2Middleware;
-
-/**
- * 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;
-}): LanguageModelV2Middleware;
-
-/**
- * Simulates streaming chunks with the response from a generate call.
- */
-declare function simulateStreamingMiddleware(): LanguageModelV2Middleware;
-
-/**
- * Wraps a LanguageModelV2 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 LanguageModelV2 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.
- * @returns A new LanguageModelV2 instance with middleware applied.
- */
-declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
-    model: LanguageModelV2;
-    middleware: LanguageModelV2Middleware | LanguageModelV2Middleware[];
-    modelId?: string;
-    providerId?: string;
-}) => LanguageModelV2;
-
-/**
- * Creates a custom provider with specified language models, text embedding models, 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, LanguageModelV2>, EMBEDDING_MODELS extends Record<string, EmbeddingModelV2<string>>, IMAGE_MODELS extends Record<string, ImageModelV2>, TRANSCRIPTION_MODELS extends Record<string, TranscriptionModelV2>, SPEECH_MODELS extends Record<string, SpeechModelV2>>({ languageModels, textEmbeddingModels, imageModels, transcriptionModels, speechModels, fallbackProvider, }: {
-    languageModels?: LANGUAGE_MODELS;
-    textEmbeddingModels?: EMBEDDING_MODELS;
-    imageModels?: IMAGE_MODELS;
-    transcriptionModels?: TRANSCRIPTION_MODELS;
-    speechModels?: SPEECH_MODELS;
-    fallbackProvider?: ProviderV2;
-}): ProviderV2 & {
-    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModelV2;
-    textEmbeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModelV2<string>;
-    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModelV2;
-    transcriptionModel(modelId: ExtractModelId<TRANSCRIPTION_MODELS>): TranscriptionModelV2;
-    speechModel(modelId: ExtractModelId<SPEECH_MODELS>): SpeechModelV2;
+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;
 };
-/**
- * @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, ProviderV2> = Record<string, ProviderV2>, SEPARATOR extends string = ':'> {
-    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModelV2;
-    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModelV2;
-    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModelV2<string>;
-    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModelV2<string>;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModelV2;
-    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModelV2;
-    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['transcriptionModel']>>[0]>}` : never): TranscriptionModelV2;
-    transcriptionModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): TranscriptionModelV2;
-    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['speechModel']>>[0]>}` : never): SpeechModelV2;
-    speechModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): SpeechModelV2;
-}
-/**
- * Creates a registry for the given providers.
- */
-declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV2>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, }?: {
-    separator?: SEPARATOR;
-}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
-/**
- * @deprecated Use `createProviderRegistry` instead.
- */
-declare const experimental_createProviderRegistry: typeof createProviderRegistry;
 
-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>;
+interface ChatTransport<UI_MESSAGE extends UIMessage> {
+    sendMessages: (options: {
+        chatId: string;
+        messages: UI_MESSAGE[];
+        abortSignal: AbortSignal | undefined;
+    } & {
+        trigger: 'submit-user-message' | 'submit-tool-result' | 'regenerate-assistant-message';
+        messageId: string | undefined;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk>>;
+    reconnectToStream: (options: {
+        chatId: string;
+    } & ChatRequestOptions) => Promise<ReadableStream<UIMessageChunk> | null>;
+}
 
-/**
- * Transport interface for MCP (Model Context Protocol) communication.
- * Maps to the `Transport` interface in the MCP spec.
- */
-interface MCPTransport {
+type CreateUIMessage<UI_MESSAGE extends UIMessage> = Omit<UI_MESSAGE, 'id' | 'role'> & {
+    id?: UI_MESSAGE['id'];
+    role?: UI_MESSAGE['role'];
+};
+type UIDataPartSchemas = Record<string, Validator<any> | StandardSchemaV1<any>>;
+type UIDataTypesToSchemas<T extends UIDataTypes> = {
+    [K in keyof T]: Validator<T[K]> | StandardSchemaV1<T[K]>;
+};
+type InferUIDataParts<T extends UIDataPartSchemas> = {
+    [K in keyof T]: T[K] extends Validator<infer U> ? U : T[K] extends StandardSchemaV1<infer U> ? U : unknown;
+};
+type ChatRequestOptions = {
     /**
-     * Initialize and start the transport
+    Additional headers that should be to be passed to the API endpoint.
      */
-    start(): Promise<void>;
+    headers?: Record<string, string> | Headers;
     /**
-     * Send a JSON-RPC message through the transport
-     * @param message The JSON-RPC message to send
+    Additional body JSON properties that should be sent to the API endpoint.
      */
-    send(message: JSONRPCMessage): Promise<void>;
+    body?: object;
+    metadata?: unknown;
+};
+type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
+interface ChatState<UI_MESSAGE extends UIMessage> {
+    status: ChatStatus;
+    error: Error | undefined;
+    messages: UI_MESSAGE[];
+    pushMessage: (message: UI_MESSAGE) => void;
+    popMessage: () => void;
+    replaceMessage: (index: number, message: UI_MESSAGE) => void;
+    snapshot: <T>(thing: T) => T;
+}
+type ChatOnErrorCallback = (error: Error) => void;
+type ChatOnToolCallCallback = ({ toolCall, }: {
+    toolCall: ToolCall<string, unknown>;
+}) => void | Promise<unknown> | unknown;
+type ChatOnDataCallback<UI_MESSAGE extends UIMessage> = (dataPart: DataUIPart<InferUIMessageData<UI_MESSAGE>>) => void;
+type ChatOnFinishCallback<UI_MESSAGE extends UIMessage> = (options: {
+    message: UI_MESSAGE;
+}) => void;
+interface ChatInit<UI_MESSAGE extends UIMessage> {
     /**
-     * Clean up and close the transport
+     * A unique identifier for the chat. If not provided, a random one will be
+     * generated.
      */
-    close(): Promise<void>;
+    id?: string;
+    messageMetadataSchema?: Validator<InferUIMessageMetadata<UI_MESSAGE>> | StandardSchemaV1<InferUIMessageMetadata<UI_MESSAGE>>;
+    dataPartSchemas?: UIDataTypesToSchemas<InferUIMessageData<UI_MESSAGE>>;
+    messages?: UI_MESSAGE[];
     /**
-     * Event handler for transport closure
+     * 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.
      */
-    onclose?: () => void;
+    generateId?: IdGenerator;
+    transport?: ChatTransport<UI_MESSAGE>;
+    maxSteps?: number;
     /**
-     * Event handler for transport errors
+     * Callback function to be called when an error is encountered.
      */
-    onerror?: (error: Error) => void;
+    onError?: ChatOnErrorCallback;
     /**
-     * Event handler for received messages
+    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;
+    /**
+     * Optional callback function that is called when the assistant message is finished streaming.
+     *
+     * @param message The message that was streamed.
      */
-    onmessage?: (message: JSONRPCMessage) => void;
+    onFinish?: ChatOnFinishCallback<UI_MESSAGE>;
+    /**
+     * Optional callback function that is called when a data part is received.
+     *
+     * @param data The data part that was received.
+     */
+    onData?: ChatOnDataCallback<UI_MESSAGE>;
 }
-type MCPTransportConfig = {
-    type: 'sse';
+declare abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
+    readonly id: string;
+    readonly generateId: IdGenerator;
+    protected state: ChatState<UI_MESSAGE>;
+    private messageMetadataSchema;
+    private dataPartSchemas;
+    private readonly transport;
+    private maxSteps;
+    private onError?;
+    private onToolCall?;
+    private onFinish?;
+    private onData?;
+    private activeResponse;
+    private jobExecutor;
+    constructor({ generateId, id, transport, maxSteps, messageMetadataSchema, dataPartSchemas, state, onError, onToolCall, onFinish, onData, }: Omit<ChatInit<UI_MESSAGE>, 'messages'> & {
+        state: ChatState<UI_MESSAGE>;
+    });
     /**
-     * The URL of the MCP server.
+     * 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.
      */
-    url: string;
+    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[]);
     /**
-     * Additional HTTP headers to be sent with requests.
+     * 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.
      */
-    headers?: Record<string, string>;
-};
-
-type ToolSchemas = Record<string, {
-    inputSchema: FlexibleSchema<JSONObject | unknown>;
-}> | 'automatic' | undefined;
-type MappedTool<T extends Tool | JSONObject, OUTPUT extends any> = T extends Tool<infer INPUT> ? Tool<INPUT, OUTPUT> : T extends JSONObject ? Tool<T, OUTPUT> : never;
-type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
-    inputSchema: FlexibleSchema<unknown>;
-}> ? {
-    [K in keyof TOOL_SCHEMAS]: MappedTool<TOOL_SCHEMAS[K], CallToolResult> & Required<Pick<MappedTool<TOOL_SCHEMAS[K], CallToolResult>, 'execute'>>;
-} : 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.ZodString;
-        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.ZodString;
-        }, 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>;
-
-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>;
-/**
- * A lightweight MCP Client implementation
- *
- * The primary purpose of this client is tool conversion between MCP<>AI SDK
- * but can later be extended to support other MCP features
- *
- * Tool parameters are automatically inferred from the server's JSON schema
- * if not explicitly provided in the tools configuration
- *
- * This client is meant to be used to communicate with a single server. To communicate and fetch tools across multiple servers, it's recommended to create a new client instance per server.
- *
- * Not supported:
- * - Client options (e.g. sampling, roots) as they are not needed for tool conversion
- * - Accepting notifications
- * - Session management (when passing a sessionId to an instance of the Streamable HTTP transport)
- * - Resumable SSE streams
- */
-declare class MCPClient {
-    private transport;
-    private onUncaughtError?;
-    private clientInfo;
-    private requestMessageId;
-    private responseHandlers;
-    private serverCapabilities;
-    private isClosed;
-    constructor({ transport: transportConfig, name, onUncaughtError, }: MCPClientConfig);
-    init(): Promise<this>;
-    close(): Promise<void>;
-    private assertCapability;
-    private request;
-    private listTools;
-    private callTool;
-    private notification;
+    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>;
     /**
-     * Returns a set of AI SDK tools from the MCP server
-     * @returns A record of tool names to their implementations
+     * Regenerate the assistant message with the provided message id.
+     * If no message id is provided, the last assistant message will be regenerated.
      */
-    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>({ schemas, }?: {
-        schemas?: TOOL_SCHEMAS;
-    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
-    private onClose;
-    private onError;
-    private onResponse;
+    regenerate: ({ messageId, ...options }?: {
+        messageId?: string;
+    } & ChatRequestOptions) => Promise<void>;
+    /**
+     * Attempt to resume an ongoing streaming response.
+     */
+    resumeStream: (options?: ChatRequestOptions) => Promise<void>;
+    addToolResult: ({ toolCallId, output, }: {
+        toolCallId: string;
+        output: unknown;
+    }) => Promise<void>;
+    /**
+     * Abort the current request immediately, keep the generated tokens if any.
+     */
+    stop: () => Promise<void>;
+    private makeRequest;
 }
 
+declare function convertFileListToFileUIParts(files: FileList | undefined): Promise<Array<FileUIPart>>;
+
 /**
-The result of a `transcribe` call.
-It contains the transcript and additional information.
+Converts an array of messages from useChat into an array of CoreMessages that can be used
+with the AI core functions (e.g. `streamText`).
+
+@param messages - The messages to convert.
+@param options.tools - The tools to use.
+@param options.ignoreIncompleteToolCalls - Whether to ignore incomplete tool calls. Default is `false`.
  */
-interface TranscriptionResult {
+declare function convertToModelMessages(messages: Array<Omit<UIMessage, 'id'>>, options?: {
+    tools?: ToolSet;
+    ignoreIncompleteToolCalls?: boolean;
+}): ModelMessage[];
+/**
+@deprecated Use `convertToModelMessages` instead.
+ */
+declare const convertToCoreMessages: typeof convertToModelMessages;
+
+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-user-message' | 'submit-tool-result' | 'regenerate-assistant-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.
+ */
+type HttpChatTransportInitOptions<UI_MESSAGE extends UIMessage> = {
     /**
-     * The complete transcribed text from the audio.
+     * The API URL to be used for the chat transport.
+     * Defaults to '/api/chat'.
      */
-    readonly text: string;
+    api?: string;
     /**
-     * Array of transcript segments with timing information.
-     * Each segment represents a portion of the transcribed text with start and end times.
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
      */
-    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;
-    }>;
+    credentials?: Resolvable<RequestCredentials>;
     /**
-     * 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.
+     * HTTP headers to be sent with the API request.
      */
-    readonly language: string | undefined;
+    headers?: Resolvable<Record<string, string> | Headers>;
     /**
-     * The total duration of the audio file in seconds.
-     * May be undefined if the duration couldn't be determined.
+     * 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 durationInSeconds: number | undefined;
+    body?: Resolvable<object>;
     /**
-    Warnings for the call, e.g. unsupported settings.
-       */
-    readonly warnings: Array<TranscriptionWarning>;
+    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;
     /**
-    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     * 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 responses: Array<TranscriptionModelResponseMetadata>;
+    prepareSendMessagesRequest?: PrepareSendMessagesRequest<UI_MESSAGE>;
     /**
-    Provider metadata from the provider.
+     * 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 providerMetadata: Record<string, Record<string, JSONValue$1>>;
+    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>;
 }
 
-/**
-Generates transcripts using a transcription model.
+declare class DefaultChatTransport<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.
+declare class TextStreamChatTransport<UI_MESSAGE extends UIMessage> extends HttpChatTransport<UI_MESSAGE> {
+    constructor(options?: HttpChatTransportInitOptions<UI_MESSAGE>);
+    protected processResponseStream(stream: ReadableStream<Uint8Array<ArrayBufferLike>>): ReadableStream<UIMessageChunk>;
+}
 
-@returns A result object that contains the generated transcript.
- */
-declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
+type CompletionRequestOptions = {
     /**
-  The transcription model to use.
+    An optional object of headers to be passed to the API endpoint.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+    An optional object to be passed to the API endpoint.
        */
-    model: TranscriptionModelV2;
+    body?: object;
+};
+type UseCompletionOptions = {
     /**
-  The audio data to transcribe.
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
      */
-    audio: DataContent | URL;
+    api?: string;
     /**
-  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;
+     * 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;
     /**
-  Maximum number of retries per transcript model call. Set to 0 to disable retries.
-  
-  @default 2
+     * Initial prompt input of the completion.
      */
-    maxRetries?: number;
+    initialInput?: string;
     /**
-  Abort signal.
-   */
-    abortSignal?: AbortSignal;
+     * Initial completion result. Useful to load an existing history.
+     */
+    initialCompletion?: string;
     /**
-  Additional headers to include in the request.
-  Only applicable for HTTP-based providers.
-   */
-    headers?: Record<string, string>;
-}): Promise<TranscriptionResult>;
+     * Callback function to be called when the completion is finished streaming.
+     */
+    onFinish?: (prompt: string, completion: string) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the prompt.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /**
+    Streaming protocol that is used. Defaults to `data`.
+       */
+    streamProtocol?: 'data' | 'text';
+    /**
+    Custom fetch implementation. You can use it as a middleware to intercept requests,
+    or to provide a custom fetch implementation for e.g. testing.
+        */
+    fetch?: FetchFunction;
+};
 
 declare global {
     var AI_SDK_DEFAULT_PROVIDER: ProviderV2 | undefined;
 }
 
-export { AbstractChat, CallSettings, CallWarning, ChatInit, ChatOnDataCallback, ChatOnErrorCallback, ChatOnFinishCallback, ChatOnToolCallCallback, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataUIPart, DeepPartial, DefaultChatTransport, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, ErrorHandler, Agent as Experimental_Agent, AgentSettings as Experimental_AgentSettings, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, FileUIPart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, HttpChatTransport, HttpChatTransportInitOptions, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, InferUIDataParts, InferUITool, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolInputError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareReconnectToStreamRequest, PrepareSendMessagesRequest, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderRegistryProvider, ReasoningUIPart, RepairTextFunction, RetryError, SerialJobExecutor, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextStreamChatTransport, TextStreamPart, TextUIPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolErrorUnion, ToolResultUnion, ToolSet, ToolUIPart, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessageChunk, UIMessagePart, UIMessageStreamOptions, UIMessageStreamWriter, UITool, UITools, UI_MESSAGE_STREAM_HEADERS, UseCompletionOptions, assistantModelMessageSchema, callCompletionApi, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, extractReasoningMiddleware, generateObject, generateText, getTextFromDataUrl, getToolName, hasToolCall, isDeepEqualData, isToolUIPart, modelMessageSchema, parsePartialJson, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, readUIMessageStream, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, toolModelMessageSchema, userModelMessageSchema, wrapLanguageModel };
+export { AbstractChat, CallSettings, CallWarning, ChatInit, ChatOnDataCallback, ChatOnErrorCallback, ChatOnFinishCallback, ChatOnToolCallCallback, ChatRequestOptions, ChatState, ChatStatus, ChatTransport, ChunkDetector, CompletionRequestOptions, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreToolMessage, CoreUserMessage, CreateUIMessage, DataUIPart, DeepPartial, DefaultChatTransport, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, ErrorHandler, Agent as Experimental_Agent, AgentSettings as Experimental_AgentSettings, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, FileUIPart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, HttpChatTransport, HttpChatTransportInitOptions, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelProviderMetadata, ImageModelResponseMetadata, InferUIDataParts, InferUITool, InferUITools, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolInputError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, JSONValue, JsonToSseTransformStream, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, PrepareReconnectToStreamRequest, PrepareSendMessagesRequest, PrepareStepFunction, PrepareStepResult, Prompt, Provider, ProviderMetadata, ProviderRegistryProvider, ReasoningUIPart, RepairTextFunction, RetryError, SerialJobExecutor, SourceUrlUIPart, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, StepResult, StepStartUIPart, StopCondition, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextStreamChatTransport, TextStreamPart, TextUIPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolErrorUnion, ToolResultUnion, ToolSet, ToolUIPart, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UIDataPartSchemas, UIDataTypes, UIMessage, UIMessageChunk, UIMessagePart, UIMessageStreamOptions, UIMessageStreamWriter, UITool, UITools, UI_MESSAGE_STREAM_HEADERS, UseCompletionOptions, assistantModelMessageSchema, callCompletionApi, convertFileListToFileUIParts, convertToCoreMessages, convertToModelMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createProviderRegistry, createTextStreamResponse, createUIMessageStream, createUIMessageStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, extractReasoningMiddleware, generateObject, generateText, getTextFromDataUrl, getToolName, hasToolCall, isDeepEqualData, isToolUIPart, modelMessageSchema, parsePartialJson, pipeTextStreamToResponse, pipeUIMessageStreamToResponse, readUIMessageStream, simulateReadableStream, simulateStreamingMiddleware, smoothStream, stepCountIs, streamObject, streamText, systemModelMessageSchema, toolModelMessageSchema, userModelMessageSchema, wrapLanguageModel };