ai 4.1.61 → 4.1.63

package/dist/index.d.ts

@@ -2,14 +2,12 @@ import { IDGenerator } from '@ai-sdk/provider-utils';
 export { CoreToolCall, CoreToolResult, IDGenerator, ToolCall, ToolResult, createIdGenerator, generateId } from '@ai-sdk/provider-utils';
 import { DataStreamString, Message, Schema, DeepPartial, JSONValue as JSONValue$1, AssistantMessage, DataMessage } from '@ai-sdk/ui-utils';
 export { AssistantMessage, AssistantStatus, Attachment, ChatRequest, ChatRequestOptions, CreateMessage, DataMessage, DataStreamPart, DeepPartial, IdGenerator, JSONValue, Message, RequestOptions, Schema, ToolInvocation, UIMessage, UseAssistantOptions, formatAssistantStreamPart, formatDataStreamPart, jsonSchema, parseAssistantStreamPart, parseDataStreamPart, processDataStream, processTextStream, zodSchema } from '@ai-sdk/ui-utils';
-import { LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1Source, JSONValue, EmbeddingModelV1, EmbeddingModelV1Embedding, ImageModelV1, ImageModelV1CallWarning, LanguageModelV1ProviderMetadata, JSONParseError, TypeValidationError, LanguageModelV1CallOptions, AISDKError, LanguageModelV1FunctionToolCall, JSONSchema7, ProviderV1, NoSuchModelError } from '@ai-sdk/provider';
+import { LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1Source, JSONValue, EmbeddingModelV1, EmbeddingModelV1Embedding, ImageModelV1, ImageModelV1CallWarning, LanguageModelV1ProviderMetadata, LanguageModelV1CallOptions, AISDKError, LanguageModelV1FunctionToolCall, JSONSchema7, JSONParseError, TypeValidationError, ProviderV1, NoSuchModelError } from '@ai-sdk/provider';
 export { AISDKError, APICallError, EmptyResponseBodyError, InvalidPromptError, InvalidResponseDataError, JSONParseError, LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1Prompt, LanguageModelV1StreamPart, LoadAPIKeyError, NoContentGeneratedError, NoSuchModelError, TypeValidationError, UnsupportedFunctionalityError } from '@ai-sdk/provider';
 import { ServerResponse } from 'node:http';
 import { AttributeValue, Tracer } from '@opentelemetry/api';
 import { z } from 'zod';
 import { ServerResponse as ServerResponse$1 } from 'http';
-import { IOType } from 'node:child_process';
-import { Stream } from 'node:stream';
 
 /**
 Language model that is used by the AI SDK Core functions.
@@ -413,119 +411,6 @@ declare function embedMany<VALUE>({ model, values, maxRetries: maxRetriesArg, ab
     experimental_telemetry?: TelemetrySettings;
 }): Promise<EmbedManyResult<VALUE>>;
 
-/**
-The result of a `generateImage` call.
-It contains the images and additional information.
- */
-interface GenerateImageResult {
-    /**
-  The first image that was generated.
-     */
-    readonly image: GeneratedImage;
-    /**
-  The images that were generated.
-       */
-    readonly images: Array<GeneratedImage>;
-    /**
-  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.
-     */
-    readonly responses: Array<ImageModelResponseMetadata>;
-}
-interface GeneratedImage {
-    /**
-  Image as a base64 encoded string.
-     */
-    readonly base64: string;
-    /**
-  Image as a Uint8Array.
-     */
-    readonly uint8Array: Uint8Array;
-}
-
-/**
-Generates images using an image model.
-
-@param model - The image model to use.
-@param prompt - The prompt that should be used to generate the image.
-@param n - Number of images to generate. Default: 1.
-@param size - Size of the images to generate. Must have the format `{width}x{height}`.
-@param aspectRatio - Aspect ratio of the images to generate. Must have the format `{width}:{height}`.
-@param seed - Seed for the image generation.
-@param providerOptions - Additional provider-specific options that are passed through to the provider
-as body parameters.
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
-
-@returns A result object that contains the generated images.
- */
-declare function generateImage({ model, prompt, n, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, _internal, }: {
-    /**
-  The image model to use.
-       */
-    model: ImageModelV1;
-    /**
-  The prompt that should be used to generate the image.
-     */
-    prompt: string;
-    /**
-  Number of images to generate.
-     */
-    n?: number;
-    /**
-  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}`;
-    /**
-  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
-     */
-    aspectRatio?: `${number}:${number}`;
-    /**
-  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.
-  
-  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"
-    }
-  }
-  ```
-       */
-    providerOptions?: Record<string, Record<string, JSONValue>>;
-    /**
-  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>;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateImageResult>;
-
 type CallSettings = {
     /**
   Maximum number of tokens to generate.
@@ -864,9 +749,10 @@ type CoreAssistantMessage = {
 };
 declare const coreAssistantMessageSchema: z.ZodType<CoreAssistantMessage>;
 /**
-Content of an assistant message. It can be a string or an array of text and tool call parts.
+Content of an assistant message.
+It can be a string or an array of text, image, reasoning, redacted reasoning, and tool call parts.
  */
-type AssistantContent = string | Array<TextPart | ReasoningPart | RedactedReasoningPart | ToolCallPart>;
+type AssistantContent = string | Array<TextPart | FilePart | ReasoningPart | RedactedReasoningPart | ToolCallPart>;
 /**
 A tool message. It contains the result of one or more tool calls.
  */
@@ -916,827 +802,320 @@ type Prompt = {
 };
 
 /**
-The result of a `generateObject` call.
+ * A generated file.
  */
-interface GenerateObjectResult<OBJECT> {
-    /**
-    The generated object (typed according to the schema).
-       */
-    readonly object: OBJECT;
-    /**
-    The reason why the generation finished.
-       */
-    readonly finishReason: FinishReason;
+interface GeneratedFile {
     /**
-    The token usage of the generated text.
+  File as a base64 encoded string.
        */
-    readonly usage: LanguageModelUsage;
+    readonly base64: string;
     /**
-    Warnings from the model provider (e.g. unsupported settings).
+  File as a Uint8Array.
        */
-    readonly warnings: CallWarning[] | undefined;
+    readonly uint8Array: Uint8Array;
     /**
-  Additional request information.
+  MIME type of the file
      */
-    readonly request: LanguageModelRequestMetadata;
+    readonly mimeType: string;
+}
+
+type ReasoningDetail = {
+    type: 'text';
+    text: string;
+    signature?: string;
+} | {
+    type: 'redacted';
+    data: string;
+};
+
+type ToolParameters = z.ZodTypeAny | Schema<any>;
+type inferParameters<PARAMETERS extends ToolParameters> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
+interface ToolExecutionOptions {
     /**
-  Additional response information.
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
      */
-    readonly response: LanguageModelResponseMetadata & {
-        /**
-    Response body (available only for providers that use HTTP requests).
-        */
-        body?: unknown;
-    };
-    /**
-   Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled.
-  
-  @deprecated Will become a provider extension in the future.
-       */
-    readonly logprobs: LogProbs | undefined;
+    toolCallId: string;
     /**
-  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.
+     * Messages that were sent to the language model to initiate the response that contained the tool call.
+     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
      */
-    readonly providerMetadata: ProviderMetadata | undefined;
+    messages: CoreMessage[];
     /**
-  @deprecated Use `providerMetadata` instead.
+     * An optional abort signal that indicates that the overall operation should be aborted.
      */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
-    /**
-    Converts the object to a JSON response.
-    The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
-       */
-    toJsonResponse(init?: ResponseInit): Response;
+    abortSignal?: AbortSignal;
 }
-
-/**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-
-Should return the repaired text or null if the text cannot be repaired.
-     */
-type RepairTextFunction = (options: {
-    text: string;
-    error: JSONParseError | TypeValidationError;
-}) => Promise<string | null>;
 /**
-Generate a structured, typed object for a given prompt and schema using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+A tool contains the description and the schema of the input that the tool expects.
+This enables the language model to generate the input.
 
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
+The tool can also contain an optional execute function for the actual execution function of the tool.
  */
-declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output?: 'object' | undefined;
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
+type Tool<PARAMETERS extends ToolParameters = any, RESULT = any> = {
     /**
-The schema of the object that the model should generate.
-   */
-    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+  The schema of the input that the tool expects. The language model will use this to generate the input.
+  It is also used to validate the output of the language model.
+  Use descriptions to make the input understandable for the language model.
+     */
+    parameters: PARAMETERS;
     /**
-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;
+  An optional description of what the tool does.
+  Will be used by the language model to decide whether to use the tool.
+  Not used for provider-defined tools.
+     */
+    description?: string;
     /**
-Optional 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;
+  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
+     */
+    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
     /**
-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';
+  An async function that is called with the arguments from the tool call and produces a result.
+  If not provided, the tool will not be executed automatically.
+  
+  @args is the input of the tool call.
+  @options.abortSignal is a signal that can be used to abort the tool call.
+     */
+    execute?: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+} & ({
     /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
+Function tool.
+     */
+    type?: undefined | 'function';
+} | {
     /**
-Optional telemetry configuration (experimental).
+Provider-defined tool.
      */
-    experimental_telemetry?: TelemetrySettings;
+    type: 'provider-defined';
     /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
+     */
+    id: `${string}.${string}`;
     /**
-     * Internal. For test use only. May change without notice.
+The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<OBJECT>>;
+    args: Record<string, unknown>;
+});
 /**
-Generate an array with structured, typed elements for a given prompt and element schema using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
-
-@return
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ * @deprecated Use `Tool` instead.
  */
-declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'array';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The element schema of the array that the model should generate.
-*/
-    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
-    /**
-Optional name of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-   */
-    schemaName?: string;
-    /**
-Optional description of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-*/
-    schemaDescription?: string;
-    /**
-The mode to use for object generation.
+type CoreTool<PARAMETERS extends ToolParameters = any, RESULT = any> = Tool<PARAMETERS, RESULT>;
+/**
+Helper function for inferring the execute args of a tool.
+ */
+declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
+    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+}): Tool<PARAMETERS, RESULT> & {
+    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+};
+declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
+    execute?: undefined;
+}): Tool<PARAMETERS, RESULT> & {
+    execute: undefined;
+};
 
-The schema is converted into a JSON schema and used in one of the following ways
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
 
-- '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 upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
 
-Please note that most providers do not support all modes.
+@example
+```
+// data.json
+{
+    'foo': 1,
+    'bar': 2,
+    'biz': 3
+}
 
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
-/**
-Generate a value from an enum (limited list of string values) using a language model.
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
 
-This function does not stream the output.
+export function getData(name: string): ValueOf<typeof data> {
+    return data[name];
+}
 
-@return
-A result object that contains the generated value, the finish reason, the token usage, and additional information.
- */
-declare function generateObject<ENUM extends string>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'enum';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The enum values that the model should use.
-   */
-    enum: Array<ENUM>;
-    /**
-The mode to use for object generation.
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+    return data[name];
+}
 
-The schema is converted into a JSON schema and used in one of the following ways
+// file.ts
+import {getData, onlyBar} from './main';
 
-- '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.
+getData('foo');
+//=> 1
 
-Please note that most providers do not support all modes.
+onlyBar('foo');
+//=> TypeError ...
 
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
+onlyBar('bar');
+//=> 2
+```
+* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
 */
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<ENUM>>;
-/**
-Generate JSON with any schema for a given prompt using a language model.
+type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
 
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+declare const JSONRPCMessageSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+}, {
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}>, "strict", z.ZodTypeAny, {
+    id: string | number;
+    method: string;
+    jsonrpc: "2.0";
+    params?: z.objectOutputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    id: string | number;
+    method: string;
+    jsonrpc: "2.0";
+    params?: z.objectInputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+}, {
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}>, "strict", z.ZodTypeAny, {
+    method: string;
+    jsonrpc: "2.0";
+    params?: z.objectOutputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    method: string;
+    jsonrpc: "2.0";
+    params?: z.objectInputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    result: z.ZodObject<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strict", z.ZodTypeAny, {
+    result: {
+        _meta?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    id: string | number;
+    jsonrpc: "2.0";
+}, {
+    result: {
+        _meta?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    id: string | number;
+    jsonrpc: "2.0";
+}>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        code: number;
+        message: string;
+        data?: unknown;
+    }, {
+        code: number;
+        message: string;
+        data?: unknown;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id: string | number;
+    jsonrpc: "2.0";
+}, {
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    id: string | number;
+    jsonrpc: "2.0";
+}>]>;
+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(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'no-schema';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
+interface MCPTransport {
     /**
-The mode to use for object generation. Must be "json" for no-schema output.
-   */
-    mode?: 'json';
+     * Initialize and start the transport
+     */
+    start(): Promise<void>;
     /**
-A function that attempts to repair the raw output of the mode
-to enable JSON parsing.
-   */
-    experimental_repairText?: RepairTextFunction;
+     * Send a JSON-RPC message through the transport
+     * @param message The JSON-RPC message to send
+     */
+    send(message: JSONRPCMessage): Promise<void>;
     /**
-Optional telemetry configuration (experimental).
+     * Clean up and close the transport
      */
-    experimental_telemetry?: TelemetrySettings;
+    close(): Promise<void>;
     /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
+     * Event handler for transport closure
+     */
+    onclose?: () => void;
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+     * Event handler for transport errors
+     */
+    onerror?: (error: Error) => void;
     /**
-     * Internal. For test use only. May change without notice.
+     * Event handler for received messages
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<JSONValue>>;
-
-type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+    onmessage?: (message: JSONRPCMessage) => void;
+}
+interface SSEConfig {
+    type: 'sse';
+    url: string;
+}
+type MCPTransportConfig = SSEConfig;
 
-/**
-The result of a `streamObject` call that contains the partial object stream and additional information.
- */
-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>;
-    /**
-  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: Promise<ProviderMetadata | undefined>;
-    /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
-    /**
-  Additional request information from the last step.
-   */
-    readonly request: Promise<LanguageModelRequestMetadata>;
-    /**
-  Additional response information.
-   */
-    readonly response: Promise<LanguageModelResponseMetadata>;
-    /**
-    The generated object (typed according to the schema). Resolved when the response is finished.
-       */
-    readonly object: Promise<RESULT>;
-    /**
-    Stream of partial objects. It gets more complete as the stream progresses.
-  
-    Note that the partial object is not validated.
-    If you want to be certain that the actual content matches your schema, you need to implement your own validation for partial results.
-       */
-    readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
-    /**
-     * Stream over complete array elements. Only available if the output strategy is set to `array`.
-     */
-    readonly elementStream: ELEMENT_STREAM;
-    /**
-    Text stream of the JSON representation of the generated object. It contains text chunks.
-    When the stream is finished, the object is valid JSON that can be parsed.
-       */
-    readonly textStream: AsyncIterableStream<string>;
-    /**
-    Stream of different types of events, including partial objects, errors, and finish events.
-    Only errors that stop the stream, such as network errors, are thrown.
-       */
-    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
-    /**
-    Writes text delta output to a Node.js response-like object.
-    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-    writes each text delta as a separate chunk.
-  
-    @param response A Node.js response-like object (ServerResponse).
-    @param init Optional headers, status code, and status text.
-       */
-    pipeTextStreamToResponse(response: ServerResponse$1, init?: ResponseInit): void;
-    /**
-    Creates a simple text stream response.
-    The response has a `Content-Type` header set to `text/plain; charset=utf-8`.
-    Each text delta is encoded as UTF-8 and sent as a separate chunk.
-    Non-text-delta events are ignored.
-  
-    @param init Optional headers, status code, and status text.
-       */
-    toTextStreamResponse(init?: ResponseInit): Response;
-}
-type ObjectStreamPart<PARTIAL> = {
-    type: 'object';
-    object: PARTIAL;
-} | {
-    type: 'text-delta';
-    textDelta: string;
-} | {
-    type: 'error';
-    error: unknown;
-} | {
-    type: 'finish';
-    finishReason: FinishReason;
-    logprobs?: LogProbs;
-    usage: LanguageModelUsage;
-    response: LanguageModelResponseMetadata;
-    providerMetadata?: ProviderMetadata;
-};
-
-/**
-Callback that is set using the `onError` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamObjectOnErrorCallback = (event: {
-    error: unknown;
-}) => Promise<void> | void;
-/**
-Callback that is set using the `onFinish` option.
-
-@param event - The event that is passed to the callback.
- */
-type StreamObjectOnFinishCallback<RESULT> = (event: {
-    /**
-  The token usage of the generated response.
-  */
-    usage: LanguageModelUsage;
-    /**
-  The generated object. Can be undefined if the final object does not match the schema.
-  */
-    object: RESULT | undefined;
-    /**
-  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
-  */
-    error: unknown | undefined;
-    /**
-  Response metadata.
-   */
-    response: LanguageModelResponseMetadata;
-    /**
-  Warnings from the model provider (e.g. unsupported settings).
-  */
-    warnings?: CallWarning[];
-    /**
-  Additional provider-specific metadata. They are passed through
-  to the provider from the AI SDK and enable provider-specific
-  functionality that can be fully encapsulated in the provider.
-  */
-    providerMetadata: ProviderMetadata | undefined;
-    /**
-  @deprecated Use `providerMetadata` instead.
-  */
-    experimental_providerMetadata?: ProviderMetadata;
-}) => Promise<void> | void;
-/**
-Generate a structured, typed object for a given prompt and schema using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` instead.
-
-@return
-A result object for accessing the partial object stream and additional information.
- */
-declare function streamObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output?: 'object' | undefined;
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The schema of the object that the model should generate.
-*/
-    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
-    /**
-Optional name of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-   */
-    schemaName?: string;
-    /**
-Optional description of the output that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-*/
-    schemaDescription?: string;
-    /**
-The mode to use for object generation.
-
-The schema is converted into a JSON schema and used in one of the following ways
-
-- 'auto': The provider will choose the best mode for the model.
-- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
-- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
-
-Please note that most providers do not support all modes.
-
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-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<OBJECT>;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-        now?: () => number;
-    };
-}): StreamObjectResult<DeepPartial<OBJECT>, OBJECT, never>;
-/**
-Generate an array with structured, typed elements for a given prompt and element schema using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` instead.
-
-@return
-A result object for accessing the partial object stream and additional information.
- */
-declare function streamObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'array';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The element schema of the array that the model should generate.
-*/
-    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
-    /**
-Optional name of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema name.
-   */
-    schemaName?: string;
-    /**
-Optional description of the array that should be generated.
-Used by some providers for additional LLM guidance, e.g.
-via tool or schema description.
-*/
-    schemaDescription?: string;
-    /**
-The mode to use for object generation.
-
-The schema is converted into a JSON schema and used in one of the following ways
-
-- 'auto': The provider will choose the best mode for the model.
-- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
-- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
-
-Please note that most providers do not support all modes.
-
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-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<Array<ELEMENT>>;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-        now?: () => number;
-    };
-}): StreamObjectResult<Array<ELEMENT>, Array<ELEMENT>, AsyncIterableStream<ELEMENT>>;
-/**
-Generate JSON with any schema for a given prompt using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` instead.
-
-@return
-A result object for accessing the partial object stream and additional information.
- */
-declare function streamObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'no-schema';
-    /**
-The language model to use.
-   */
-    model: LanguageModel;
-    /**
-The mode to use for object generation. Must be "json" for no-schema output.
-   */
-    mode?: 'json';
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    providerOptions?: ProviderOptions;
-    /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-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<JSONValue>;
-    /**
-     * Internal. For test use only. May change without notice.
-     */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-        now?: () => number;
-    };
-}): StreamObjectResult<JSONValue, JSONValue, never>;
-
-type ReasoningDetail = {
-    type: 'text';
-    text: string;
-    signature?: string;
-} | {
-    type: 'redacted';
-    data: string;
-};
-
-type ToolParameters = z.ZodTypeAny | Schema<any>;
-type inferParameters<PARAMETERS extends ToolParameters> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
-interface ToolExecutionOptions {
-    /**
-     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
-     */
-    toolCallId: string;
-    /**
-     * Messages that were sent to the language model to initiate the response that contained the tool call.
-     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
-     */
-    messages: CoreMessage[];
-    /**
-     * An optional abort signal that indicates that the overall operation should be aborted.
-     */
-    abortSignal?: AbortSignal;
-}
-/**
-A tool contains the description and the schema of the input that the tool expects.
-This enables the language model to generate the input.
-
-The tool can also contain an optional execute function for the actual execution function of the tool.
- */
-type Tool<PARAMETERS extends ToolParameters = any, RESULT = any> = {
-    /**
-  The schema of the input that the tool expects. The language model will use this to generate the input.
-  It is also used to validate the output of the language model.
-  Use descriptions to make the input understandable for the language model.
-     */
-    parameters: PARAMETERS;
-    /**
-  An optional description of what the tool does.
-  Will be used by the language model to decide whether to use the tool.
-  Not used for provider-defined tools.
-     */
-    description?: string;
-    /**
-  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
-     */
-    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
-    /**
-  An async function that is called with the arguments from the tool call and produces a result.
-  If not provided, the tool will not be executed automatically.
-  
-  @args is the input of the tool call.
-  @options.abortSignal is a signal that can be used to abort the tool call.
-     */
-    execute?: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-} & ({
-    /**
-Function tool.
-     */
-    type?: undefined | 'function';
-} | {
-    /**
-Provider-defined tool.
-     */
-    type: 'provider-defined';
-    /**
-The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
-     */
-    id: `${string}.${string}`;
-    /**
-The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
-     */
-    args: Record<string, unknown>;
-});
-/**
- * @deprecated Use `Tool` instead.
- */
-type CoreTool<PARAMETERS extends ToolParameters = any, RESULT = any> = Tool<PARAMETERS, RESULT>;
-/**
-Helper function for inferring the execute args of a tool.
- */
-declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-}): Tool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-};
-declare function tool<PARAMETERS extends ToolParameters, RESULT>(tool: Tool<PARAMETERS, RESULT> & {
-    execute?: undefined;
-}): Tool<PARAMETERS, RESULT> & {
-    execute: undefined;
-};
-
-/**
-Create a union of the given object's values, and optionally specify which keys to get the values from.
-
-Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
-
-@example
-```
-// data.json
-{
-    'foo': 1,
-    'bar': 2,
-    'biz': 3
-}
-
-// main.ts
-import type {ValueOf} from 'type-fest';
-import data = require('./data.json');
-
-export function getData(name: string): ValueOf<typeof data> {
-    return data[name];
-}
-
-export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
-    return data[name];
-}
-
-// file.ts
-import {getData, onlyBar} from './main';
-
-getData('foo');
-//=> 1
-
-onlyBar('foo');
-//=> TypeError ...
-
-onlyBar('bar');
-//=> 2
-```
-* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
-*/
-type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
-
-type ToolSchemas = Record<string, {
-    parameters: ToolParameters;
-}> | 'automatic' | undefined;
-type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
-    parameters: ToolParameters;
-}> ? {
-    [K in keyof TOOL_SCHEMAS]: Tool<TOOL_SCHEMAS[K]['parameters'], CallToolResult> & {
-        execute: (args: inferParameters<TOOL_SCHEMAS[K]['parameters']>, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
+type ToolSchemas = Record<string, {
+    parameters: ToolParameters;
+}> | 'automatic' | undefined;
+type McpToolSet<TOOL_SCHEMAS extends ToolSchemas = 'automatic'> = TOOL_SCHEMAS extends Record<string, {
+    parameters: ToolParameters;
+}> ? {
+    [K in keyof TOOL_SCHEMAS]: Tool<TOOL_SCHEMAS[K]['parameters'], CallToolResult> & {
+        execute: (args: inferParameters<TOOL_SCHEMAS[K]['parameters']>, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
     };
 } : {
     [k: string]: Tool<z.ZodUnknown, CallToolResult> & {
         execute: (args: unknown, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
     };
 };
-interface McpStdioServerConfig {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    stderr?: IOType | Stream | number;
-    cwd?: string;
-    type: 'stdio';
-}
-interface McpSSEServerConfig {
-    type: 'sse';
-    url: string;
-}
-type TransportConfig = McpStdioServerConfig | McpSSEServerConfig;
 declare const CallToolResultSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
     _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
 }, {
@@ -2451,736 +1830,1545 @@ declare const CallToolResultSchema: z.ZodUnion<[z.ZodObject<z.objectUtil.extendS
 }>, z.ZodTypeAny, "passthrough">>]>;
 type CallToolResult = z.infer<typeof CallToolResultSchema>;
 
-interface MCPClientConfig {
-    /** Transport configuration for connecting to the MCP server */
-    transport: TransportConfig;
-    /** Optional callback for uncaught errors */
-    onUncaughtError?: (error: unknown) => void;
-    /** Optional client name, defaults to 'ai-sdk-mcp-client' */
-    name?: string;
+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
+ *
+ * Not supported:
+ * - Client options (e.g. sampling, roots) as they are not needed for tool conversion
+ * - Accepting notifications
+ */
+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 request;
+    private listTools;
+    private callTool;
+    private notification;
+    /**
+     * Returns a set of AI SDK tools from the MCP server
+     * @returns A record of tool names to their implementations
+     */
+    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>({ schemas, }?: {
+        schemas?: TOOL_SCHEMAS;
+    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
+    private onClose;
+    private onError;
+    private onResponse;
+}
+
+type ToolSet = Record<string, Tool>;
+
+type ToolCallUnion<TOOLS extends ToolSet> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-call';
+        toolCallId: string;
+        toolName: NAME & string;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
+    };
+}>;
+/**
+ * @deprecated Use `ToolCallUnion` instead.
+ */
+type CoreToolCallUnion<TOOLS extends ToolSet> = ToolCallUnion<ToolSet>;
+type ToolCallArray<TOOLS extends ToolSet> = Array<ToolCallUnion<TOOLS>>;
+
+type ToToolsWithExecute<TOOLS extends ToolSet> = {
+    [K in keyof TOOLS as TOOLS[K] extends {
+        execute: any;
+    } ? K : never]: TOOLS[K];
+};
+type ToToolsWithDefinedExecute<TOOLS extends ToolSet> = {
+    [K in keyof TOOLS as TOOLS[K]['execute'] extends undefined ? never : K]: TOOLS[K];
+};
+type ToToolResultObject<TOOLS extends ToolSet> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-result';
+        toolCallId: string;
+        toolName: NAME & string;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
+        result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
+    };
+}>;
+type ToolResultUnion<TOOLS extends ToolSet> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
+/**
+ * @deprecated Use `ToolResultUnion` instead.
+ */
+type CoreToolResultUnion<TOOLS extends ToolSet> = ToolResultUnion<TOOLS>;
+type ToolResultArray<TOOLS extends ToolSet> = Array<ToolResultUnion<TOOLS>>;
+
+/**
+A message that was generated during the generation process.
+It can be either an assistant message or a tool message.
+ */
+type ResponseMessage = (CoreAssistantMessage | CoreToolMessage) & {
+    /**
+  Message ID generated by the AI SDK.
+     */
+    id: string;
+};
+/**
+ * The result of a single step in the generation process.
+ */
+type StepResult<TOOLS extends ToolSet> = {
+    /**
+  The generated text.
+  */
+    readonly text: string;
+    /**
+  The reasoning that was generated during the generation.
+  */
+    readonly reasoning: string | undefined;
+    readonly reasoningDetails: Array<ReasoningDetail>;
+    /**
+  The files that were generated during the generation.
+  */
+    readonly files: GeneratedFile[];
+    /**
+  The sources that were used to generate the text.
+  */
+    readonly sources: Source[];
+    /**
+  The tool calls that were made during the generation.
+  */
+    readonly toolCalls: ToolCallArray<TOOLS>;
+    /**
+  The results of the tool calls.
+  */
+    readonly toolResults: ToolResultArray<TOOLS>;
+    /**
+  The reason why the generation finished.
+  */
+    readonly finishReason: FinishReason;
+    /**
+  The token usage of the generated text.
+  */
+    readonly usage: LanguageModelUsage;
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+  Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if was not enabled.
+  */
+    readonly logprobs: LogProbs | undefined;
+    /**
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+  */
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    The response messages that were generated during the call.
+    Response messages can be either assistant messages or tool messages.
+    They contain a generated id.
+    */
+        readonly messages: Array<ResponseMessage>;
+        /**
+    Response body (available only for providers that use HTTP requests).
+         */
+        body?: unknown;
+    };
+    /**
+  Additional provider-specific metadata. They are passed through
+  from the provider to the AI SDK and enable provider-specific
+  results that can be fully encapsulated in the provider.
+     */
+    readonly providerMetadata: ProviderMetadata | undefined;
+    /**
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: ProviderMetadata | undefined;
+    /**
+  The type of step that this result is for. The first step is always
+  an "initial" step, and subsequent steps are either "continue" steps
+  or "tool-result" steps.
+     */
+    readonly stepType: 'initial' | 'continue' | 'tool-result';
+    /**
+  True when there will be a continuation step with a continuation text.
+     */
+    readonly isContinued: boolean;
+};
+
+/**
+The result of a `generateText` call.
+It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+ */
+interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
+    /**
+  The generated text.
+       */
+    readonly text: string;
+    /**
+  The reasoning text that the model has generated. Can be undefined if the model
+  has only generated text.
+     */
+    readonly reasoning: string | undefined;
+    /**
+  The files that were generated. Empty array if no files were generated.
+       */
+    readonly files: Array<GeneratedFile>;
+    /**
+  The full reasoning that the model has generated.
+     */
+    readonly reasoningDetails: Array<ReasoningDetail>;
+    /**
+  Sources that have been used as input to generate the response.
+  For multi-step generation, the sources are accumulated from all steps.
+     */
+    readonly sources: Source[];
+    /**
+  The generated structured output. It uses the `experimental_output` specification.
+     */
+    readonly experimental_output: OUTPUT;
+    /**
+    The tool calls that were made during the generation.
+     */
+    readonly toolCalls: ToolCallArray<TOOLS>;
+    /**
+    The results of the tool calls.
+     */
+    readonly toolResults: ToolResultArray<TOOLS>;
+    /**
+    The reason why the generation finished.
+     */
+    readonly finishReason: FinishReason;
+    /**
+    The token usage of the generated text.
+     */
+    readonly usage: LanguageModelUsage;
+    /**
+    Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
+     */
+    readonly steps: Array<StepResult<TOOLS>>;
+    /**
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+     */
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    The response messages that were generated during the call. It consists of an assistant message,
+    potentially containing tool calls.
+    
+    When there are tool results, there is an additional tool message with the tool results that are available.
+    If there are tools that do not have execute functions, they are not included in the tool results and
+    need to be added separately.
+           */
+        messages: Array<ResponseMessage>;
+        /**
+    Response body (available only for providers that use HTTP requests).
+         */
+        body?: unknown;
+    };
+    /**
+  Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if it was not enabled.
+  
+  @deprecated Will become a provider extension in the future.
+       */
+    readonly logprobs: LogProbs | undefined;
+    /**
+  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;
+    /**
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: ProviderMetadata | undefined;
+}
+
+interface Output<OUTPUT, PARTIAL> {
+    readonly type: 'object' | 'text';
+    injectIntoSystemPrompt(options: {
+        system: string | undefined;
+        model: LanguageModel;
+    }): string | undefined;
+    responseFormat: (options: {
+        model: LanguageModel;
+    }) => LanguageModelV1CallOptions['responseFormat'];
+    parsePartial(options: {
+        text: string;
+    }): {
+        partial: PARTIAL;
+    } | undefined;
+    parseOutput(options: {
+        text: string;
+    }, context: {
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+    }): OUTPUT;
+}
+declare const text: () => Output<string, string>;
+declare const object: <OUTPUT>({ schema: inputSchema, }: {
+    schema: z.Schema<OUTPUT, z.ZodTypeDef, any> | Schema<OUTPUT>;
+}) => Output<OUTPUT, DeepPartial<OUTPUT>>;
+
+type output_Output<OUTPUT, PARTIAL> = Output<OUTPUT, PARTIAL>;
+declare const output_object: typeof object;
+declare const output_text: typeof text;
+declare namespace output {
+  export {
+    output_Output as Output,
+    output_object as object,
+    output_text as text,
+  };
+}
+
+declare const symbol$f: unique symbol;
+declare class InvalidToolArgumentsError extends AISDKError {
+    private readonly [symbol$f];
+    readonly toolName: string;
+    readonly toolArgs: string;
+    constructor({ toolArgs, toolName, cause, message, }: {
+        message?: string;
+        toolArgs: string;
+        toolName: string;
+        cause: unknown;
+    });
+    static isInstance(error: unknown): error is InvalidToolArgumentsError;
+}
+
+declare const symbol$e: unique symbol;
+declare class NoSuchToolError extends AISDKError {
+    private readonly [symbol$e];
+    readonly toolName: string;
+    readonly availableTools: string[] | undefined;
+    constructor({ toolName, availableTools, message, }: {
+        toolName: string;
+        availableTools?: string[] | undefined;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchToolError;
+}
+
+/**
+ * Appends a client message to the messages array.
+ * If the last message in the array has the same id as the new message, it will be replaced.
+ * Otherwise, the new message will be appended.
+ */
+declare function appendClientMessage({ messages, message, }: {
+    messages: Message[];
+    message: Message;
+}): Message[];
+
+/**
+ * Appends the ResponseMessage[] from the response to a Message[] (for useChat).
+ * The messages are converted to Messages before being appended.
+ * Timestamps are generated for the new messages.
+ *
+ * @returns A new Message[] with the response messages appended.
+ */
+declare function appendResponseMessages({ messages, responseMessages, _internal: { currentDate }, }: {
+    messages: Message[];
+    responseMessages: ResponseMessage[];
+    /**
+  Internal. For test use only. May change without notice.
+       */
+    _internal?: {
+        currentDate?: () => Date;
+    };
+}): Message[];
+
+/**
+Converts an array of messages from useChat into an array of CoreMessages that can be used
+with the AI core functions (e.g. `streamText`).
+ */
+declare function convertToCoreMessages<TOOLS extends ToolSet = never>(messages: Array<Omit<Message, 'id'>>, options?: {
+    tools?: TOOLS;
+}): CoreMessage[];
+
+/**
+ * A function that attempts to repair a tool call that failed to parse.
+ *
+ * It receives the error and the context as arguments and returns the repair
+ * tool call JSON as text.
+ *
+ * @param options.system - The system prompt.
+ * @param options.messages - The messages in the current generation step.
+ * @param options.toolCall - The tool call that failed to parse.
+ * @param options.tools - The tools that are available.
+ * @param options.parameterSchema - A function that returns the JSON Schema for a tool.
+ * @param options.error - The error that occurred while parsing the tool call.
+ */
+type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
+    system: string | undefined;
+    messages: CoreMessage[];
+    toolCall: LanguageModelV1FunctionToolCall;
+    tools: TOOLS;
+    parameterSchema: (options: {
+        toolName: string;
+    }) => JSONSchema7;
+    error: NoSuchToolError | InvalidToolArgumentsError;
+}) => Promise<LanguageModelV1FunctionToolCall | null>;
+
+/**
+Callback that is set using the `onStepFinish` option.
+
+@param stepResult - The result of the step.
+ */
+type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
+/**
+Generate a text and call tools for a given prompt using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamText` 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 toolChoice - The tool choice strategy. Default: 'auto'.
+
+@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 maxTokens - 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 experimental_generateMessageId - Generate a unique ID for each message.
+
+@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+
+@returns
+A result object that contains the generated text, the results of the tool calls, and additional information.
+ */
+declare function generateText<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
+    /**
+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>;
+    /**
+Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
+
+A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+
+By default, it's set to 1, which means that only a single LLM call is made.
+     */
+    maxSteps?: number;
+    /**
+Generate a unique ID for each message.
+     */
+    experimental_generateMessageId?: IDGenerator;
+    /**
+When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+
+By default, it's set to false.
+     */
+    experimental_continueSteps?: boolean;
+    /**
+Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+ */
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+     */
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+Limits the tools that are available for the model to call without
+changing the tool call and result types in the result.
+     */
+    experimental_activeTools?: Array<keyof TOOLS>;
+    /**
+Optional specification for parsing structured outputs from the LLM response.
+     */
+    experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
+    /**
+A function that attempts to repair a tool call that failed to parse.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    /**
+    Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: IDGenerator;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
+
+/**
+ * A stream wrapper to send custom JSON-encoded data back to the client.
+ *
+ * @deprecated Please use `createDataStream`, `createDataStreamResponse`, and `pipeDataStreamToResponse` instead.
+ */
+declare class StreamData {
+    private encoder;
+    private controller;
+    stream: ReadableStream<Uint8Array>;
+    private isClosed;
+    private warningTimeout;
+    constructor();
+    close(): Promise<void>;
+    append(value: JSONValue$1): void;
+    appendMessageAnnotation(value: JSONValue$1): void;
+}
+
+type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+
+type DataStreamOptions = {
+    /**
+     * Send usage parts to the client.
+     * Default to true.
+     */
+    sendUsage?: boolean;
+    /**
+     * Send reasoning parts to the client.
+     * Default to false.
+     */
+    sendReasoning?: boolean;
+    /**
+     * Send source parts to the client.
+     * Default to false.
+     */
+    sendSources?: boolean;
+    /**
+     * Send the finish event to the client.
+     * Set to false if you are using additional streamText calls
+     * that send additional data.
+     * Default to true.
+     */
+    experimental_sendFinish?: boolean;
+    /**
+     * Send the message start event to the client.
+     * Set to false if you are using additional streamText calls
+     * and the message start event has already been sent.
+     * Default to true.
+     *
+     * Note: this setting is currently not used, but you should
+     * already set it to false if you are using additional
+     * streamText calls that send additional data to prevent
+     * the message start event from being sent multiple times.
+     */
+    experimental_sendStart?: boolean;
+};
+/**
+A result object for accessing different stream types and additional information.
+ */
+interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
+    /**
+  Warnings from the model provider (e.g. unsupported settings) for the first step.
+       */
+    readonly warnings: Promise<CallWarning[] | undefined>;
+    /**
+  The total token usage of the generated response.
+  When there are multiple steps, the usage is the sum of all step usages.
+  
+  Resolved when the response is finished.
+       */
+    readonly usage: Promise<LanguageModelUsage>;
+    /**
+  Sources that have been used as input to generate the response.
+  For multi-step generation, the sources are accumulated from all steps.
+  
+  Resolved when the response is finished.
+     */
+    readonly sources: Promise<Source[]>;
+    /**
+  Files that have been generated by the model in the last step.
+  
+  Resolved when the response is finished.
+     */
+    readonly files: Promise<GeneratedFile[]>;
+    /**
+  The reason why the generation finished. Taken from the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly finishReason: Promise<FinishReason>;
+    /**
+  Additional provider-specific metadata from the last step.
+  Metadata is passed through from the provider to the AI SDK and
+  enables provider-specific results that can be fully encapsulated in the provider.
+     */
+    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
+    /**
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
+    /**
+  The full text that has been generated by the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly text: Promise<string>;
+    /**
+  The reasoning that has been generated by the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly reasoning: Promise<string | undefined>;
+    /**
+  The full reasoning that the model has generated.
+  
+  Resolved when the response is finished.
+     */
+    readonly reasoningDetails: Promise<Array<ReasoningDetail>>;
+    /**
+  The tool calls that have been executed in the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly toolCalls: Promise<ToolCallUnion<TOOLS>[]>;
+    /**
+  The tool results that have been generated in the last step.
+  
+  Resolved when the all tool executions are finished.
+       */
+    readonly toolResults: Promise<ToolResultUnion<TOOLS>[]>;
+    /**
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
+     */
+    readonly steps: Promise<Array<StepResult<TOOLS>>>;
+    /**
+  Additional request information from the last step.
+   */
+    readonly request: Promise<LanguageModelRequestMetadata>;
+    /**
+  Additional response information from the last step.
+   */
+    readonly response: Promise<LanguageModelResponseMetadata & {
+        /**
+  The response messages that were generated during the call. It consists of an assistant message,
+  potentially containing tool calls.
+  
+  When there are tool results, there is an additional tool message with the tool results that are available.
+  If there are tools that do not have execute functions, they are not included in the tool results and
+  need to be added separately.
+         */
+        messages: Array<ResponseMessage>;
+    }>;
+    /**
+    A text stream that returns only the generated text deltas. You can use it
+    as either an AsyncIterable or a ReadableStream. When an error occurs, the
+    stream will throw the error.
+       */
+    readonly textStream: AsyncIterableStream<string>;
+    /**
+    A stream with all events, including text deltas, tool calls, tool results, and
+    errors.
+    You can use it as either an AsyncIterable or a ReadableStream.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+    /**
+  A stream of partial outputs. It uses the `experimental_output` specification.
+     */
+    readonly experimental_partialOutputStream: AsyncIterableStream<PARTIAL_OUTPUT>;
+    /**
+  Consumes the stream without processing the parts.
+  This is useful to force the stream to finish.
+  It effectively removes the backpressure and allows the stream to finish,
+  triggering the `onFinish` callback and the promise resolution.
+    */
+    consumeStream(): Promise<void>;
+    /**
+    Converts the result to a data stream.
+  
+    @param data an optional StreamData object that will be merged into the stream.
+    @param getErrorMessage an optional function that converts an error to an error message.
+    @param sendUsage whether to send the usage information to the client. Defaults to true.
+    @param sendReasoning whether to send the reasoning information to the client. Defaults to false.
+    @return A data stream.
+       */
+    toDataStream(options?: {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+    } & DataStreamOptions): ReadableStream<Uint8Array>;
+    /**
+     * Merges the result as a data stream into another data stream.
+     *
+     * @param dataStream A data stream writer.
+     * @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
+     * @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
+     */
+    mergeIntoDataStream(dataStream: DataStreamWriter, options?: DataStreamOptions): void;
+    /**
+    Writes data stream output to a Node.js response-like object.
+  
+    @param response A Node.js response-like object (ServerResponse).
+    @param options.status The status code.
+    @param options.statusText The status text.
+    @param options.headers The headers.
+    @param options.data The stream data.
+    @param options.getErrorMessage An optional function that converts an error to an error message.
+    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
+    @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
+       */
+    pipeDataStreamToResponse(response: ServerResponse, options?: ResponseInit & {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+    } & DataStreamOptions): void;
+    /**
+    Writes text delta output to a Node.js response-like object.
+    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+    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, init?: ResponseInit): void;
+    /**
+    Converts the result to a streamed response object with a stream data part stream.
+    It can be used with the `useChat` and `useCompletion` hooks.
+  
+    @param options.status The status code.
+    @param options.statusText The status text.
+    @param options.headers The headers.
+    @param options.data The stream data.
+    @param options.getErrorMessage An optional function that converts an error to an error message.
+    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
+    @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
+  
+    @return A response object.
+       */
+    toDataStreamResponse(options?: ResponseInit & {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+    } & DataStreamOptions): Response;
+    /**
+    Creates a simple text stream response.
+    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;
 }
-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
- *
- * Not supported:
- * - Client options (e.g. sampling, roots) as they are not needed for tool conversion
- * - Accepting notifications
- */
-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 request;
-    private listTools;
-    private callTool;
-    private notification;
+type TextStreamPart<TOOLS extends ToolSet> = {
+    type: 'text-delta';
+    textDelta: string;
+} | {
+    type: 'reasoning';
+    textDelta: string;
+} | {
+    type: 'reasoning-signature';
+    signature: string;
+} | {
+    type: 'redacted-reasoning';
+    data: string;
+} | {
+    type: 'source';
+    source: Source;
+} | ({
+    type: 'file';
+} & GeneratedFile) | ({
+    type: 'tool-call';
+} & ToolCallUnion<TOOLS>) | {
+    type: 'tool-call-streaming-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+} | ({
+    type: 'tool-result';
+} & ToolResultUnion<TOOLS>) | {
+    type: 'step-start';
+    messageId: string;
+    request: LanguageModelRequestMetadata;
+    warnings: CallWarning[];
+} | {
+    type: 'step-finish';
+    messageId: string;
+    logprobs?: LogProbs;
+    request: LanguageModelRequestMetadata;
+    warnings: CallWarning[] | undefined;
+    response: LanguageModelResponseMetadata;
+    usage: LanguageModelUsage;
+    finishReason: FinishReason;
+    providerMetadata: ProviderMetadata | undefined;
+    /**
+     * @deprecated Use `providerMetadata` instead.
+     */
+    experimental_providerMetadata?: ProviderMetadata;
+    isContinued: boolean;
+} | {
+    type: 'finish';
+    finishReason: FinishReason;
+    usage: LanguageModelUsage;
+    providerMetadata: ProviderMetadata | undefined;
+    /**
+     * @deprecated Use `providerMetadata` instead.
+     */
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * @deprecated will be moved into provider metadata
+     */
+    logprobs?: LogProbs;
+    /**
+     * @deprecated use response on step-finish instead
+     */
+    response: LanguageModelResponseMetadata;
+} | {
+    type: 'error';
+    error: unknown;
+};
+
+/**
+ * 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;
     /**
-     * Returns a set of AI SDK tools from the MCP server
-     * @returns A record of tool names to their implementations
+     * Internal. For test use only. May change without notice.
      */
-    tools<TOOL_SCHEMAS extends ToolSchemas = 'automatic'>({ schemas, }?: {
-        schemas?: TOOL_SCHEMAS;
-    }): Promise<McpToolSet<TOOL_SCHEMAS>>;
-    private onClose;
-    private onError;
-    private onResponse;
-}
+    _internal?: {
+        delay?: (delayInMs: number | null) => Promise<void>;
+    };
+}): (options: {
+    tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
 
-type ToolSet = Record<string, Tool>;
+/**
+A transformation that is applied to the stream.
 
-type ToolCallUnion<TOOLS extends ToolSet> = ValueOf<{
-    [NAME in keyof TOOLS]: {
-        type: 'tool-call';
-        toolCallId: string;
-        toolName: NAME & string;
-        args: inferParameters<TOOLS[NAME]['parameters']>;
-    };
-}>;
+@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>>;
 /**
- * @deprecated Use `ToolCallUnion` instead.
+Callback that is set using the `onError` option.
+
+@param event - The event that is passed to the callback.
  */
-type CoreToolCallUnion<TOOLS extends ToolSet> = ToolCallUnion<ToolSet>;
-type ToolCallArray<TOOLS extends ToolSet> = Array<ToolCallUnion<TOOLS>>;
+type StreamTextOnErrorCallback = (event: {
+    error: unknown;
+}) => Promise<void> | void;
+/**
+Callback that is set using the `onStepFinish` option.
 
-type ToToolsWithExecute<TOOLS extends ToolSet> = {
-    [K in keyof TOOLS as TOOLS[K] extends {
-        execute: any;
-    } ? K : never]: TOOLS[K];
-};
-type ToToolsWithDefinedExecute<TOOLS extends ToolSet> = {
-    [K in keyof TOOLS as TOOLS[K]['execute'] extends undefined ? never : K]: TOOLS[K];
-};
-type ToToolResultObject<TOOLS extends ToolSet> = ValueOf<{
-    [NAME in keyof TOOLS]: {
-        type: 'tool-result';
-        toolCallId: string;
-        toolName: NAME & string;
-        args: inferParameters<TOOLS[NAME]['parameters']>;
-        result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
-    };
-}>;
-type ToolResultUnion<TOOLS extends ToolSet> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
+@param stepResult - The result of the step.
+ */
+type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
 /**
- * @deprecated Use `ToolResultUnion` instead.
+Callback that is set using the `onChunk` option.
+
+@param event - The event that is passed to the callback.
  */
-type CoreToolResultUnion<TOOLS extends ToolSet> = ToolResultUnion<TOOLS>;
-type ToolResultArray<TOOLS extends ToolSet> = Array<ToolResultUnion<TOOLS>>;
+type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
+    chunk: Extract<TextStreamPart<TOOLS>, {
+        type: 'text-delta' | 'reasoning' | 'source' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
+    }>;
+}) => 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: Omit<StepResult<TOOLS>, 'stepType' | 'isContinued'> & {
+    /**
+Details for all steps.
+   */
+    readonly steps: StepResult<TOOLS>[];
+}) => Promise<void> | void;
 /**
-A message that was generated during the generation process.
-It can be either an assistant message or a tool message.
+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 maxTokens - 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 experimental_generateMessageId - Generate a unique ID for each message.
+
+@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.
  */
-type ResponseMessage = (CoreAssistantMessage | CoreToolMessage) & {
+declare function streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_toolCallStreaming, toolCallStreaming, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
     /**
-  Message ID generated by the AI SDK.
+The language model to use.
      */
-    id: string;
-};
-/**
- * The result of a single step in the generation process.
+    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>;
+    /**
+Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
+
+A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+
+By default, it's set to 1, which means that only a single LLM call is made.
  */
-type StepResult<TOOLS extends ToolSet> = {
+    maxSteps?: number;
     /**
-  The generated text.
-  */
-    readonly text: string;
+Generate a unique ID for each message.
+     */
+    experimental_generateMessageId?: IDGenerator;
     /**
-  The reasoning that was generated during the generation.
-  */
-    readonly reasoning: string | undefined;
-    readonly reasoningDetails: Array<ReasoningDetail>;
+When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+
+By default, it's set to false.
+     */
+    experimental_continueSteps?: boolean;
     /**
-  The sources that were used to generate the text.
-  */
-    readonly sources: Source[];
+Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
     /**
-  The tool calls that were made during the generation.
-  */
-    readonly toolCalls: ToolCallArray<TOOLS>;
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+ */
+    providerOptions?: ProviderOptions;
     /**
-  The results of the tool calls.
-  */
-    readonly toolResults: ToolResultArray<TOOLS>;
+@deprecated Use `providerOptions` instead.
+ */
+    experimental_providerMetadata?: ProviderMetadata;
     /**
-  The reason why the generation finished.
-  */
-    readonly finishReason: FinishReason;
+Limits the tools that are available for the model to call without
+changing the tool call and result types in the result.
+     */
+    experimental_activeTools?: Array<keyof TOOLS>;
     /**
-  The token usage of the generated text.
-  */
-    readonly usage: LanguageModelUsage;
+Optional specification for parsing structured outputs from the LLM response.
+     */
+    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
     /**
-  Warnings from the model provider (e.g. unsupported settings).
-  */
-    readonly warnings: CallWarning[] | undefined;
+A function that attempts to repair a tool call that failed to parse.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
     /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled.
-  */
-    readonly logprobs: LogProbs | undefined;
+Enable streaming of tool call deltas as they are generated. Disabled by default.
+     */
+    toolCallStreaming?: boolean;
+    /**
+@deprecated Use `toolCallStreaming` instead.
+     */
+    experimental_toolCallStreaming?: boolean;
+    /**
+Optional stream transformations.
+They are applied in the order they are provided.
+The stream transformations must maintain the stream structure for streamText to work correctly.
+     */
+    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
+    /**
+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;
     /**
-  Additional request information.
+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.
      */
-    readonly request: LanguageModelRequestMetadata;
+    onFinish?: StreamTextOnFinishCallback<TOOLS>;
     /**
-  Additional response information.
-  */
-    readonly response: LanguageModelResponseMetadata & {
-        /**
-    The response messages that were generated during the call.
-    Response messages can be either assistant messages or tool messages.
-    They contain a generated id.
+Callback that is called when each step (LLM call) is finished, including intermediate steps.
     */
-        readonly messages: Array<ResponseMessage>;
-        /**
-    Response body (available only for providers that use HTTP requests).
-         */
-        body?: unknown;
-    };
+    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
     /**
-  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.
+Internal. For test use only. May change without notice.
      */
-    readonly providerMetadata: ProviderMetadata | undefined;
+    _internal?: {
+        now?: () => number;
+        generateId?: IDGenerator;
+        currentDate?: () => Date;
+    };
+}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+
+/**
+The result of a `generateImage` call.
+It contains the images and additional information.
+ */
+interface GenerateImageResult {
     /**
-  @deprecated Use `providerMetadata` instead.
+  The first image that was generated.
      */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
+    readonly image: GeneratedFile;
     /**
-  The type of step that this result is for. The first step is always
-  an "initial" step, and subsequent steps are either "continue" steps
-  or "tool-result" steps.
-     */
-    readonly stepType: 'initial' | 'continue' | 'tool-result';
+  The images that were generated.
+       */
+    readonly images: Array<GeneratedFile>;
     /**
-  True when there will be a continuation step with a continuation text.
+  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.
      */
-    readonly isContinued: boolean;
-};
+    readonly responses: Array<ImageModelResponseMetadata>;
+}
 
 /**
-The result of a `generateText` call.
-It contains the generated text, the tool calls that were made during the generation, and the results of the tool calls.
+Generates images using an image model.
+
+@param model - The image model to use.
+@param prompt - The prompt that should be used to generate the image.
+@param n - Number of images to generate. Default: 1.
+@param size - Size of the images to generate. Must have the format `{width}x{height}`.
+@param aspectRatio - Aspect ratio of the images to generate. Must have the format `{width}:{height}`.
+@param seed - Seed for the image generation.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated images.
  */
-interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
+declare function generateImage({ model, prompt, n, size, aspectRatio, seed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-  The generated text.
+  The image model to use.
        */
-    readonly text: string;
+    model: ImageModelV1;
     /**
-  The reasoning text that the model has generated. Can be undefined if the model
-  has only generated text.
+  The prompt that should be used to generate the image.
      */
-    readonly reasoning: string | undefined;
+    prompt: string;
     /**
-  The full reasoning that the model has generated.
+  Number of images to generate.
      */
-    readonly reasoningDetails: Array<ReasoningDetail>;
+    n?: number;
     /**
-  Sources that have been used as input to generate the response.
-  For multi-step generation, the sources are accumulated from all steps.
+  Size of the images to generate. Must have the format `{width}x{height}`. If not provided, the default size will be used.
      */
-    readonly sources: Source[];
+    size?: `${number}x${number}`;
     /**
-  The generated structured output. It uses the `experimental_output` specification.
+  Aspect ratio of the images to generate. Must have the format `{width}:{height}`. If not provided, the default aspect ratio will be used.
      */
-    readonly experimental_output: OUTPUT;
+    aspectRatio?: `${number}:${number}`;
     /**
-    The tool calls that were made during the generation.
+  Seed for the image generation. If not provided, the default seed will be used.
      */
-    readonly toolCalls: ToolCallArray<TOOLS>;
+    seed?: number;
     /**
-    The results of the tool calls.
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
+  
+  The outer record is keyed by the provider name, and the inner
+  record is keyed by the provider-specific metadata key.
+  ```ts
+  {
+    "openai": {
+      "style": "vivid"
+    }
+  }
+  ```
+       */
+    providerOptions?: Record<string, Record<string, JSONValue>>;
+    /**
+  Maximum number of retries per embedding model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    readonly toolResults: ToolResultArray<TOOLS>;
+    maxRetries?: number;
+    /**
+  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)
-     */
+    Warnings from the model provider (e.g. unsupported settings).
+       */
     readonly warnings: CallWarning[] | undefined;
     /**
-  Details for all steps.
-  You can use this to get information about intermediate steps,
-  such as the tool calls or the response headers.
-     */
-    readonly steps: Array<StepResult<TOOLS>>;
-    /**
   Additional request information.
      */
     readonly request: LanguageModelRequestMetadata;
     /**
   Additional response information.
      */
-    readonly response: LanguageModelResponseMetadata & {
-        /**
-    The response messages that were generated during the call. It consists of an assistant message,
-    potentially containing tool calls.
-    
-    When there are tool results, there is an additional tool message with the tool results that are available.
-    If there are tools that do not have execute functions, they are not included in the tool results and
-    need to be added separately.
-           */
-        messages: Array<ResponseMessage>;
-        /**
-    Response body (available only for providers that use HTTP requests).
-         */
-        body?: unknown;
-    };
-    /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if it was not enabled.
-  
-  @deprecated Will become a provider extension in the future.
-       */
-    readonly logprobs: LogProbs | undefined;
-    /**
-  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;
-    /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: ProviderMetadata | undefined;
-}
-
-interface Output<OUTPUT, PARTIAL> {
-    readonly type: 'object' | 'text';
-    injectIntoSystemPrompt(options: {
-        system: string | undefined;
-        model: LanguageModel;
-    }): string | undefined;
-    responseFormat: (options: {
-        model: LanguageModel;
-    }) => LanguageModelV1CallOptions['responseFormat'];
-    parsePartial(options: {
-        text: string;
-    }): {
-        partial: PARTIAL;
-    } | undefined;
-    parseOutput(options: {
-        text: string;
-    }, context: {
-        response: LanguageModelResponseMetadata;
-        usage: LanguageModelUsage;
-    }): OUTPUT;
-}
-declare const text: () => Output<string, string>;
-declare const object: <OUTPUT>({ schema: inputSchema, }: {
-    schema: z.Schema<OUTPUT, z.ZodTypeDef, any> | Schema<OUTPUT>;
-}) => Output<OUTPUT, DeepPartial<OUTPUT>>;
-
-type output_Output<OUTPUT, PARTIAL> = Output<OUTPUT, PARTIAL>;
-declare const output_object: typeof object;
-declare const output_text: typeof text;
-declare namespace output {
-  export {
-    output_Output as Output,
-    output_object as object,
-    output_text as text,
-  };
-}
-
-declare const symbol$f: unique symbol;
-declare class InvalidToolArgumentsError extends AISDKError {
-    private readonly [symbol$f];
-    readonly toolName: string;
-    readonly toolArgs: string;
-    constructor({ toolArgs, toolName, cause, message, }: {
-        message?: string;
-        toolArgs: string;
-        toolName: string;
-        cause: unknown;
-    });
-    static isInstance(error: unknown): error is InvalidToolArgumentsError;
-}
-
-declare const symbol$e: unique symbol;
-declare class NoSuchToolError extends AISDKError {
-    private readonly [symbol$e];
-    readonly toolName: string;
-    readonly availableTools: string[] | undefined;
-    constructor({ toolName, availableTools, message, }: {
-        toolName: string;
-        availableTools?: string[] | undefined;
-        message?: string;
-    });
-    static isInstance(error: unknown): error is NoSuchToolError;
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    Response body (available only for providers that use HTTP requests).
+        */
+        body?: unknown;
+    };
+    /**
+   Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if was not enabled.
+  
+  @deprecated Will become a provider extension in the future.
+       */
+    readonly logprobs: LogProbs | undefined;
+    /**
+  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;
+    /**
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: ProviderMetadata | undefined;
+    /**
+    Converts the object to a JSON response.
+    The response will have a status code of 200 and a content type of `application/json; charset=utf-8`.
+       */
+    toJsonResponse(init?: ResponseInit): Response;
 }
 
 /**
- * Appends a client message to the messages array.
- * If the last message in the array has the same id as the new message, it will be replaced.
- * Otherwise, the new message will be appended.
- */
-declare function appendClientMessage({ messages, message, }: {
-    messages: Message[];
-    message: Message;
-}): Message[];
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
 
+Should return the repaired text or null if the text cannot be repaired.
+     */
+type RepairTextFunction = (options: {
+    text: string;
+    error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;
 /**
- * Appends the ResponseMessage[] from the response to a Message[] (for useChat).
- * The messages are converted to Messages before being appended.
- * Timestamps are generated for the new messages.
- *
- * @returns A new Message[] with the response messages appended.
+Generate a structured, typed object for a given prompt and schema using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function appendResponseMessages({ messages, responseMessages, _internal: { currentDate }, }: {
-    messages: Message[];
-    responseMessages: ResponseMessage[];
+declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
     /**
-  Internal. For test use only. May change without notice.
-       */
-    _internal?: {
-        currentDate?: () => Date;
-    };
-}): Message[];
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The schema of the object that the model should generate.
+   */
+    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+    /**
+Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+   */
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-/**
-Converts an array of messages from useChat into an array of CoreMessages that can be used
-with the AI core functions (e.g. `streamText`).
- */
-declare function convertToCoreMessages<TOOLS extends ToolSet = never>(messages: Array<Omit<Message, 'id'>>, options?: {
-    tools?: TOOLS;
-}): CoreMessage[];
+The schema is converted into a JSON schema and used in one of the following ways
 
-/**
- * A function that attempts to repair a tool call that failed to parse.
- *
- * It receives the error and the context as arguments and returns the repair
- * tool call JSON as text.
- *
- * @param options.system - The system prompt.
- * @param options.messages - The messages in the current generation step.
- * @param options.toolCall - The tool call that failed to parse.
- * @param options.tools - The tools that are available.
- * @param options.parameterSchema - A function that returns the JSON Schema for a tool.
- * @param options.error - The error that occurred while parsing the tool call.
- */
-type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
-    system: string | undefined;
-    messages: CoreMessage[];
-    toolCall: LanguageModelV1FunctionToolCall;
-    tools: TOOLS;
-    parameterSchema: (options: {
-        toolName: string;
-    }) => JSONSchema7;
-    error: NoSuchToolError | InvalidToolArgumentsError;
-}) => Promise<LanguageModelV1FunctionToolCall | null>;
+- '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.
 
-/**
-Callback that is set using the `onStepFinish` option.
+Please note that most providers do not support all modes.
 
-@param stepResult - The result of the step.
- */
-type GenerateTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
+    /**
+Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<OBJECT>>;
 /**
-Generate a text and call tools for a given prompt using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamText` instead.
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
 
-@param model - The language model to use.
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
-@param toolChoice - The tool choice strategy. Default: 'auto'.
+@return
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
+    /**
+Optional name of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-@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.
+The schema is converted into a JSON schema and used in one of the following ways
 
-@param maxTokens - 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.
+- '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.
 
-@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.
+Please note that most providers do not support all modes.
 
-@param maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
-@param experimental_generateMessageId - Generate a unique ID for each message.
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
+/**
+Generate a value from an enum (limited list of string values) using a language model.
 
-@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+This function does not stream the output.
 
-@returns
-A result object that contains the generated text, the results of the tool calls, and additional information.
+@return
+A result object that contains the generated value, the finish reason, the token usage, and additional information.
  */
-declare function generateText<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
+declare function generateObject<ENUM extends string>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'enum';
     /**
 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>;
+The enum values that the model should use.
+   */
+    enum: Array<ENUM>;
     /**
-Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
+The mode to use for object generation.
 
-A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+The schema is converted into a JSON schema and used in one of the following ways
 
-By default, it's set to 1, which means that only a single LLM call is made.
-     */
-    maxSteps?: number;
-    /**
-Generate a unique ID for each message.
-     */
-    experimental_generateMessageId?: IDGenerator;
-    /**
-When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+- '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.
 
-By default, it's set to false.
-     */
-    experimental_continueSteps?: boolean;
+Please note that most providers do not support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
     /**
 Optional telemetry configuration (experimental).
-     */
+   */
     experimental_telemetry?: TelemetrySettings;
     /**
 Additional provider-specific options. They are passed through
 to the provider from the AI SDK and enable provider-specific
 functionality that can be fully encapsulated in the provider.
- */
+*/
     providerOptions?: ProviderOptions;
     /**
 @deprecated Use `providerOptions` instead.
-     */
+*/
     experimental_providerMetadata?: ProviderMetadata;
     /**
-Limits the tools that are available for the model to call without
-changing the tool call and result types in the result.
-     */
-    experimental_activeTools?: Array<keyof TOOLS>;
-    /**
-Optional specification for parsing structured outputs from the LLM response.
-     */
-    experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
-    /**
-A function that attempts to repair a tool call that failed to parse.
-     */
-    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
-    /**
-    Callback that is called when each step (LLM call) is finished, including intermediate steps.
-    */
-    onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
-    /**
      * Internal. For test use only. May change without notice.
      */
     _internal?: {
-        generateId?: IDGenerator;
+        generateId?: () => string;
         currentDate?: () => Date;
     };
-}): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
-
+}): Promise<GenerateObjectResult<ENUM>>;
 /**
- * A stream wrapper to send custom JSON-encoded data back to the client.
- *
- * @deprecated Please use `createDataStream`, `createDataStreamResponse`, and `pipeDataStreamToResponse` instead.
- */
-declare class StreamData {
-    private encoder;
-    private controller;
-    stream: ReadableStream<Uint8Array>;
-    private isClosed;
-    private warningTimeout;
-    constructor();
-    close(): Promise<void>;
-    append(value: JSONValue$1): void;
-    appendMessageAnnotation(value: JSONValue$1): void;
-}
+Generate JSON with any schema for a given prompt using a language model.
 
-type DataStreamOptions = {
-    /**
-     * Send usage parts to the client.
-     * Default to true.
-     */
-    sendUsage?: boolean;
-    /**
-     * Send reasoning parts to the client.
-     * Default to false.
-     */
-    sendReasoning?: boolean;
-    /**
-     * Send source parts to the client.
-     * Default to false.
-     */
-    sendSources?: boolean;
-    /**
-     * Send the finish event to the client.
-     * Set to false if you are using additional streamText calls
-     * that send additional data.
-     * Default to true.
-     */
-    experimental_sendFinish?: boolean;
-    /**
-     * Send the message start event to the client.
-     * Set to false if you are using additional streamText calls
-     * and the message start event has already been sent.
-     * Default to true.
-     *
-     * Note: this setting is currently not used, but you should
-     * already set it to false if you are using additional
-     * streamText calls that send additional data to prevent
-     * the message start event from being sent multiple times.
-     */
-    experimental_sendStart?: boolean;
-};
-/**
-A result object for accessing different stream types and additional information.
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
-    /**
-  Warnings from the model provider (e.g. unsupported settings) for the first step.
-       */
-    readonly warnings: Promise<CallWarning[] | undefined>;
-    /**
-  The total token usage of the generated response.
-  When there are multiple steps, the usage is the sum of all step usages.
-  
-  Resolved when the response is finished.
-       */
-    readonly usage: Promise<LanguageModelUsage>;
-    /**
-  Sources that have been used as input to generate the response.
-  For multi-step generation, the sources are accumulated from all steps.
-  
-  Resolved when the response is finished.
-     */
-    readonly sources: Promise<Source[]>;
-    /**
-  The reason why the generation finished. Taken from the last step.
-  
-  Resolved when the response is finished.
-       */
-    readonly finishReason: Promise<FinishReason>;
-    /**
-  Additional provider-specific metadata from the last step.
-  Metadata is passed through from the provider to the AI SDK and
-  enables provider-specific results that can be fully encapsulated in the provider.
-     */
-    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
+declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
     /**
-  @deprecated Use `providerMetadata` instead.
-     */
-    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
+The language model to use.
+   */
+    model: LanguageModel;
     /**
-  The full text that has been generated by the last step.
-  
-  Resolved when the response is finished.
-       */
-    readonly text: Promise<string>;
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
     /**
-  The reasoning that has been generated by the last step.
-  
-  Resolved when the response is finished.
-       */
-    readonly reasoning: Promise<string | undefined>;
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
     /**
-  The full reasoning that the model has generated.
-  
-  Resolved when the response is finished.
+Optional telemetry configuration (experimental).
      */
-    readonly reasoningDetails: Promise<Array<ReasoningDetail>>;
+    experimental_telemetry?: TelemetrySettings;
     /**
-  The tool calls that have been executed in the last step.
-  
-  Resolved when the response is finished.
-       */
-    readonly toolCalls: Promise<ToolCallUnion<TOOLS>[]>;
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
     /**
-  The tool results that have been generated in the last step.
-  
-  Resolved when the all tool executions are finished.
-       */
-    readonly toolResults: Promise<ToolResultUnion<TOOLS>[]>;
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
     /**
-  Details for all steps.
-  You can use this to get information about intermediate steps,
-  such as the tool calls or the response headers.
+     * Internal. For test use only. May change without notice.
      */
-    readonly steps: Promise<Array<StepResult<TOOLS>>>;
-    /**
-  Additional request information from the last step.
-   */
-    readonly request: Promise<LanguageModelRequestMetadata>;
-    /**
-  Additional response information from the last step.
-   */
-    readonly response: Promise<LanguageModelResponseMetadata & {
-        /**
-  The response messages that were generated during the call. It consists of an assistant message,
-  potentially containing tool calls.
-  
-  When there are tool results, there is an additional tool message with the tool results that are available.
-  If there are tools that do not have execute functions, they are not included in the tool results and
-  need to be added separately.
-         */
-        messages: Array<ResponseMessage>;
-    }>;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<JSONValue>>;
+
+/**
+The result of a `streamObject` call that contains the partial object stream and additional information.
+ */
+interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
-    A text stream that returns only the generated text deltas. You can use it
-    as either an AsyncIterable or a ReadableStream. When an error occurs, the
-    stream will throw the error.
+    Warnings from the model provider (e.g. unsupported settings)
        */
-    readonly textStream: AsyncIterableStream<string>;
+    readonly warnings: Promise<CallWarning[] | undefined>;
     /**
-    A stream with all events, including text deltas, tool calls, tool results, and
-    errors.
-    You can use it as either an AsyncIterable or a ReadableStream.
-    Only errors that stop the stream, such as network errors, are thrown.
+    The token usage of the generated response. Resolved when the response is finished.
        */
-    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
+    readonly usage: Promise<LanguageModelUsage>;
     /**
-  A stream of partial outputs. It uses the `experimental_output` specification.
+  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 experimental_partialOutputStream: AsyncIterableStream<PARTIAL_OUTPUT>;
+    readonly providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-  Consumes the stream without processing the parts.
-  This is useful to force the stream to finish.
-  It effectively removes the backpressure and allows the stream to finish,
-  triggering the `onFinish` callback and the promise resolution.
-    */
-    consumeStream(): Promise<void>;
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-    Converts the result to a data stream.
+  Additional request information from the last step.
+   */
+    readonly request: Promise<LanguageModelRequestMetadata>;
+    /**
+  Additional response information.
+   */
+    readonly response: Promise<LanguageModelResponseMetadata>;
+    /**
+    The generated object (typed according to the schema). Resolved when the response is finished.
+       */
+    readonly object: Promise<RESULT>;
+    /**
+    Stream of partial objects. It gets more complete as the stream progresses.
   
-    @param data an optional StreamData object that will be merged into the stream.
-    @param getErrorMessage an optional function that converts an error to an error message.
-    @param sendUsage whether to send the usage information to the client. Defaults to true.
-    @param sendReasoning whether to send the reasoning information to the client. Defaults to false.
-    @return A data stream.
+    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.
        */
-    toDataStream(options?: {
-        data?: StreamData;
-        getErrorMessage?: (error: unknown) => string;
-    } & DataStreamOptions): ReadableStream<Uint8Array>;
+    readonly partialObjectStream: AsyncIterableStream<PARTIAL>;
     /**
-     * Merges the result as a data stream into another data stream.
-     *
-     * @param dataStream A data stream writer.
-     * @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
-     * @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
+     * Stream over complete array elements. Only available if the output strategy is set to `array`.
      */
-    mergeIntoDataStream(dataStream: DataStreamWriter, options?: DataStreamOptions): void;
+    readonly elementStream: ELEMENT_STREAM;
     /**
-    Writes data stream output to a Node.js response-like object.
-  
-    @param response A Node.js response-like object (ServerResponse).
-    @param options.status The status code.
-    @param options.statusText The status text.
-    @param options.headers The headers.
-    @param options.data The stream data.
-    @param options.getErrorMessage An optional function that converts an error to an error message.
-    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
-    @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
+    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.
        */
-    pipeDataStreamToResponse(response: ServerResponse, options?: ResponseInit & {
-        data?: StreamData;
-        getErrorMessage?: (error: unknown) => string;
-    } & DataStreamOptions): void;
+    readonly textStream: AsyncIterableStream<string>;
+    /**
+    Stream of different types of events, including partial objects, errors, and finish events.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<ObjectStreamPart<PARTIAL>>;
     /**
     Writes text delta output to a Node.js response-like object.
     It sets a `Content-Type` header to `text/plain; charset=utf-8` and
@@ -3189,27 +3377,10 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
     @param response A Node.js response-like object (ServerResponse).
     @param init Optional headers, status code, and status text.
        */
-    pipeTextStreamToResponse(response: ServerResponse, init?: ResponseInit): void;
-    /**
-    Converts the result to a streamed response object with a stream data part stream.
-    It can be used with the `useChat` and `useCompletion` hooks.
-  
-    @param options.status The status code.
-    @param options.statusText The status text.
-    @param options.headers The headers.
-    @param options.data The stream data.
-    @param options.getErrorMessage An optional function that converts an error to an error message.
-    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
-    @param options.sendReasoning Whether to send the reasoning information to the client. Defaults to false.
-  
-    @return A response object.
-       */
-    toDataStreamResponse(options?: ResponseInit & {
-        data?: StreamData;
-        getErrorMessage?: (error: unknown) => string;
-    } & DataStreamOptions): Response;
+    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.
   
@@ -3217,294 +3388,274 @@ interface StreamTextResult<TOOLS extends ToolSet, PARTIAL_OUTPUT> {
        */
     toTextStreamResponse(init?: ResponseInit): Response;
 }
-type TextStreamPart<TOOLS extends ToolSet> = {
-    type: 'text-delta';
-    textDelta: string;
+type ObjectStreamPart<PARTIAL> = {
+    type: 'object';
+    object: PARTIAL;
 } | {
-    type: 'reasoning';
+    type: 'text-delta';
     textDelta: string;
 } | {
-    type: 'reasoning-signature';
-    signature: string;
-} | {
-    type: 'redacted-reasoning';
-    data: string;
-} | {
-    type: 'source';
-    source: Source;
-} | ({
-    type: 'tool-call';
-} & ToolCallUnion<TOOLS>) | {
-    type: 'tool-call-streaming-start';
-    toolCallId: string;
-    toolName: string;
-} | {
-    type: 'tool-call-delta';
-    toolCallId: string;
-    toolName: string;
-    argsTextDelta: string;
-} | ({
-    type: 'tool-result';
-} & ToolResultUnion<TOOLS>) | {
-    type: 'step-start';
-    messageId: string;
-    request: LanguageModelRequestMetadata;
-    warnings: CallWarning[];
-} | {
-    type: 'step-finish';
-    messageId: string;
-    logprobs?: LogProbs;
-    request: LanguageModelRequestMetadata;
-    warnings: CallWarning[] | undefined;
-    response: LanguageModelResponseMetadata;
-    usage: LanguageModelUsage;
-    finishReason: FinishReason;
-    providerMetadata: ProviderMetadata | undefined;
-    /**
-     * @deprecated Use `providerMetadata` instead.
-     */
-    experimental_providerMetadata?: ProviderMetadata;
-    isContinued: boolean;
+    type: 'error';
+    error: unknown;
 } | {
     type: 'finish';
     finishReason: FinishReason;
-    usage: LanguageModelUsage;
-    providerMetadata: ProviderMetadata | undefined;
-    /**
-     * @deprecated Use `providerMetadata` instead.
-     */
-    experimental_providerMetadata?: ProviderMetadata;
-    /**
-     * @deprecated will be moved into provider metadata
-     */
     logprobs?: LogProbs;
-    /**
-     * @deprecated use response on step-finish instead
-     */
+    usage: LanguageModelUsage;
     response: LanguageModelResponseMetadata;
-} | {
-    type: 'error';
-    error: unknown;
+    providerMetadata?: ProviderMetadata;
 };
 
-/**
- * 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;
-    /**
-     * 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: {
+type StreamObjectOnErrorCallback = (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.
+Callback that is set using the `onFinish` option.
 
 @param event - The event that is passed to the callback.
  */
-type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
-    chunk: Extract<TextStreamPart<TOOLS>, {
-        type: 'text-delta' | 'reasoning' | 'source' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
-    }>;
+type StreamObjectOnFinishCallback<RESULT> = (event: {
+    /**
+  The token usage of the generated response.
+  */
+    usage: LanguageModelUsage;
+    /**
+  The generated object. Can be undefined if the final object does not match the schema.
+  */
+    object: RESULT | undefined;
+    /**
+  Optional error object. This is e.g. a TypeValidationError when the final object does not match the schema.
+  */
+    error: unknown | undefined;
+    /**
+  Response metadata.
+   */
+    response: LanguageModelResponseMetadata;
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    warnings?: CallWarning[];
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+  */
+    providerMetadata: ProviderMetadata | undefined;
+    /**
+  @deprecated Use `providerMetadata` instead.
+  */
+    experimental_providerMetadata?: ProviderMetadata;
 }) => Promise<void> | void;
 /**
-Callback that is set using the `onFinish` option.
+Generate a structured, typed object for a given prompt and schema using a language model.
 
-@param event - The event that is passed to the callback.
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
+
+@return
+A result object for accessing the partial object stream and additional information.
  */
-type StreamTextOnFinishCallback<TOOLS extends ToolSet> = (event: Omit<StepResult<TOOLS>, 'stepType' | 'isContinued'> & {
+declare function streamObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
     /**
-Details for all steps.
+The schema of the object that the model should generate.
+*/
+    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+    /**
+Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
    */
-    readonly steps: StepResult<TOOLS>[];
-}) => 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.
+    schemaName?: string;
+    /**
+Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-@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.
+The schema is converted into a JSON schema and used in one of the following ways
 
-@param maxTokens - 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.
+- '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.
 
-@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.
+Please note that most providers do not support all modes.
 
-@param maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
-@param experimental_generateMessageId - Generate a unique ID for each message.
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+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<OBJECT>;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+        now?: () => number;
+    };
+}): StreamObjectResult<DeepPartial<OBJECT>, OBJECT, never>;
+/**
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
 
-@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.
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
 
 @return
-A result object for accessing different stream types and additional information.
+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, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_toolCallStreaming, toolCallStreaming, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, onChunk, onError, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
+declare function streamObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
     /**
 The language model to use.
-     */
+   */
     model: LanguageModel;
     /**
-The tools that the model can call. The model needs to support calling tools.
-    */
-    tools?: TOOLS;
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
     /**
-The tool choice strategy. Default: 'auto'.
-     */
-    toolChoice?: ToolChoice<TOOLS>;
+Optional name of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
     /**
-Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
+Optional description of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+The schema is converted into a JSON schema and used in one of the following ways
 
-By default, it's set to 1, which means that only a single LLM call is made.
- */
-    maxSteps?: number;
-    /**
-Generate a unique ID for each message.
-     */
-    experimental_generateMessageId?: IDGenerator;
-    /**
-When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+- '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.
 
-By default, it's set to false.
-     */
-    experimental_continueSteps?: boolean;
+Please note that most providers do not support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
     /**
 Optional telemetry configuration (experimental).
-     */
+   */
     experimental_telemetry?: TelemetrySettings;
     /**
 Additional provider-specific options. They are passed through
 to the provider from the AI SDK and enable provider-specific
 functionality that can be fully encapsulated in the provider.
- */
+*/
     providerOptions?: ProviderOptions;
     /**
 @deprecated Use `providerOptions` instead.
- */
+*/
     experimental_providerMetadata?: ProviderMetadata;
     /**
-Limits the tools that are available for the model to call without
-changing the tool call and result types in the result.
-     */
-    experimental_activeTools?: Array<keyof 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;
     /**
-Optional specification for parsing structured outputs from the LLM response.
-     */
-    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: StreamObjectOnFinishCallback<Array<ELEMENT>>;
     /**
-A function that attempts to repair a tool call that failed to parse.
+     * Internal. For test use only. May change without notice.
      */
-    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+        now?: () => number;
+    };
+}): StreamObjectResult<Array<ELEMENT>, Array<ELEMENT>, AsyncIterableStream<ELEMENT>>;
+/**
+Generate JSON with any schema for a given prompt using a language model.
+
+This function streams the output. If you do not want to stream the output, use `generateObject` instead.
+
+@return
+A result object for accessing the partial object stream and additional information.
+ */
+declare function streamObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
     /**
-Enable streaming of tool call deltas as they are generated. Disabled by default.
-     */
-    toolCallStreaming?: boolean;
+The language model to use.
+   */
+    model: LanguageModel;
     /**
-@deprecated Use `toolCallStreaming` instead.
-     */
-    experimental_toolCallStreaming?: boolean;
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
     /**
-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>>;
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
     /**
-Callback that is called for each chunk of the stream.
-The stream processing will pause until the callback promise is resolved.
-     */
-    onChunk?: StreamTextOnChunkCallback<TOOLS>;
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
     /**
 Callback that is invoked when an error occurs during streaming.
 You can use it to log errors.
 The stream processing will pause until the callback promise is resolved.
-     */
-    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>;
+   */
+    onError?: StreamObjectOnErrorCallback;
     /**
-Callback that is called when each step (LLM call) is finished, including intermediate steps.
-    */
-    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: StreamObjectOnFinishCallback<JSONValue>;
     /**
-Internal. For test use only. May change without notice.
+     * Internal. For test use only. May change without notice.
      */
     _internal?: {
-        now?: () => number;
-        generateId?: IDGenerator;
+        generateId?: () => string;
         currentDate?: () => Date;
+        now?: () => number;
     };
-}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+}): StreamObjectResult<JSONValue, JSONValue, never>;
 
 /**
  * Experimental middleware for LanguageModelV1.
@@ -3731,7 +3882,9 @@ type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
 } | {
     type: 'redacted-reasoning';
     data: string;
-} | {
+} | ({
+    type: 'file';
+} & GeneratedFile) | {
     type: 'source';
     source: Source;
 } | ({
@@ -4083,4 +4236,4 @@ declare namespace llamaindexAdapter {
   };
 }
 
-export { AssistantContent, AssistantResponse, CallWarning, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolCallUnion, CoreToolChoice, CoreToolMessage, CoreToolResultUnion, CoreUserMessage, DataContent, DataStreamOptions, DataStreamWriter, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedImage as Experimental_GeneratedImage, Experimental_LanguageModelV1Middleware, FilePart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelResponseMetadata, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, langchainAdapter as LangChainAdapter, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, LanguageModelV1Middleware, llamaindexAdapter as LlamaIndexAdapter, LogProbs, MCPClientError, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, Provider, ProviderMetadata, RepairTextFunction, RetryError, StepResult, StreamData, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextPart, TextStreamPart, Tool, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolExecutionOptions, ToolResultPart, ToolResultUnion, ToolSet, UserContent, appendClientMessage, appendResponseMessages, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createDataStream, createDataStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, experimental_wrapLanguageModel, extractReasoningMiddleware, generateObject, generateText, pipeDataStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, tool, wrapLanguageModel };
+export { AssistantContent, AssistantResponse, CallWarning, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolCallUnion, CoreToolChoice, CoreToolMessage, CoreToolResultUnion, CoreUserMessage, DataContent, DataStreamOptions, DataStreamWriter, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, Experimental_LanguageModelV1Middleware, FilePart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedFile, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelResponseMetadata, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, langchainAdapter as LangChainAdapter, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, LanguageModelV1Middleware, llamaindexAdapter as LlamaIndexAdapter, LogProbs, MCPClientError, MCPTransport, MessageConversionError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, Provider, ProviderMetadata, RepairTextFunction, RetryError, StepResult, StreamData, StreamObjectOnFinishCallback, StreamObjectResult, StreamTextOnChunkCallback, StreamTextOnErrorCallback, StreamTextOnFinishCallback, StreamTextOnStepFinishCallback, StreamTextResult, StreamTextTransform, TelemetrySettings, TextPart, TextStreamPart, Tool, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolCallUnion, ToolChoice, ToolContent, ToolExecutionError, ToolExecutionOptions, ToolResultPart, ToolResultUnion, ToolSet, UserContent, appendClientMessage, appendResponseMessages, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createDataStream, createDataStreamResponse, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, experimental_wrapLanguageModel, extractReasoningMiddleware, generateObject, generateText, pipeDataStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, tool, wrapLanguageModel };