ai 0.0.0-156c9f7b-20250115085202 → 0.0.0-677c097b-20250505090413

package/dist/index.d.ts

@@ -1,14 +1,67 @@
-import { DataStreamString, ToolInvocation, Attachment, 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, UseAssistantOptions, formatAssistantStreamPart, formatDataStreamPart, jsonSchema, parseAssistantStreamPart, parseDataStreamPart, processDataStream, processTextStream } from '@ai-sdk/ui-utils';
-export { ToolCall as CoreToolCall, ToolResult as CoreToolResult, generateId } from '@ai-sdk/provider-utils';
-import { JSONValue, EmbeddingModelV1, EmbeddingModelV1Embedding, ImageModelV1, ImageModelV1CallWarning, LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning, LanguageModelV1ProviderMetadata, LanguageModelV1CallOptions, AISDKError, LanguageModelV1FunctionToolCall, JSONSchema7, NoSuchModelError } from '@ai-sdk/provider';
+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, TranscriptionModelV1, TranscriptionModelV1CallWarning, SpeechModelV1, SpeechModelV1CallWarning, 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';
 
+/**
+Language model that is used by the AI SDK Core functions.
+*/
+type LanguageModel = LanguageModelV1;
+/**
+Reason why a language model finished generating a response.
+
+Can be one of the following:
+- `stop`: model generated stop sequence
+- `length`: model generated maximum number of tokens
+- `content-filter`: content filter violation stopped the model
+- `tool-calls`: model triggered tool calls
+- `error`: model stopped because of an error
+- `other`: model stopped for other reasons
+*/
+type FinishReason = LanguageModelV1FinishReason;
+/**
+Log probabilities for each token and its top log probabilities.
+
+@deprecated Will become a provider extension in the future.
+ */
+type LogProbs = LanguageModelV1LogProbs;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+*/
+type CallWarning = LanguageModelV1CallWarning;
+/**
+A source that has been used as input to generate the response.
+*/
+type Source = LanguageModelV1Source;
+/**
+Tool choice for the generation. It supports the following settings:
+
+- `auto` (default): the model can choose whether and which tools to call.
+- `required`: the model must call a tool. It can choose which tool to call.
+- `none`: the model must not call tools
+- `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ */
+type ToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
+    type: 'tool';
+    toolName: keyof TOOLS;
+};
+/**
+ * @deprecated Use `ToolChoice` instead.
+ */
+type CoreToolChoice<TOOLS extends Record<string, unknown>> = ToolChoice<TOOLS>;
+
 interface DataStreamWriter {
+    /**
+     * Appends a data part to the stream.
+     */
+    write(data: DataStreamString): void;
     /**
      * Appends a data part to the stream.
      */
@@ -17,6 +70,10 @@ interface DataStreamWriter {
      * Appends a message annotation to the stream.
      */
     writeMessageAnnotation(value: JSONValue): void;
+    /**
+     * Appends a source part to the stream.
+     */
+    writeSource(source: Source): void;
     /**
      * Merges the contents of another stream to this stream.
      */
@@ -99,44 +156,19 @@ some settings might not be supported, which can lead to suboptimal results.
   */
 type ImageGenerationWarning = ImageModelV1CallWarning;
 
-/**
-Language model that is used by the AI SDK Core functions.
-*/
-type LanguageModel = LanguageModelV1;
-/**
-Reason why a language model finished generating a response.
-
-Can be one of the following:
-- `stop`: model generated stop sequence
-- `length`: model generated maximum number of tokens
-- `content-filter`: content filter violation stopped the model
-- `tool-calls`: model triggered tool calls
-- `error`: model stopped because of an error
-- `other`: model stopped for other reasons
-*/
-type FinishReason = LanguageModelV1FinishReason;
-/**
-Log probabilities for each token and its top log probabilities.
-
-@deprecated Will become a provider extension in the future.
- */
-type LogProbs = LanguageModelV1LogProbs;
-/**
-Warning from the model provider for this call. The call will proceed, but e.g.
-some settings might not be supported, which can lead to suboptimal results.
-*/
-type CallWarning = LanguageModelV1CallWarning;
-/**
-Tool choice for the generation. It supports the following settings:
-
-- `auto` (default): the model can choose whether and which tools to call.
-- `required`: the model must call a tool. It can choose which tool to call.
-- `none`: the model must not call tools
-- `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
- */
-type CoreToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
-    type: 'tool';
-    toolName: keyof TOOLS;
+type ImageModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
 };
 
 type LanguageModelRequestMetadata = {
@@ -160,13 +192,13 @@ type LanguageModelResponseMetadata = {
     */
     modelId: string;
     /**
-  Response headers.
+  Response headers (available only for providers that use HTTP requests).
        */
     headers?: Record<string, string>;
 };
 
 /**
- * Provider for language and text embedding models.
+ * Provider for language, text embedding, and image models.
  */
 type Provider = {
     /**
@@ -191,14 +223,31 @@ type Provider = {
     @throws {NoSuchModelError} If no such model exists.
        */
     textEmbeddingModel(modelId: string): EmbeddingModel<string>;
+    /**
+    Returns the image model with the given id.
+    The model id is then passed to the provider function to get the model.
+  
+    @param {string} id - The id of the model to return.
+  
+    @returns {ImageModel} The image model associated with the id
+    */
+    imageModel(modelId: string): ImageModel;
 };
 
 /**
-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.
+Additional provider-specific metadata that is returned from the provider.
+
+This is needed to enable provider-specific functionality that can be
+fully encapsulated in the provider.
  */
 type ProviderMetadata = LanguageModelV1ProviderMetadata;
+/**
+Additional provider-specific options.
+
+They are passed through to the provider from the AI SDK and enable
+provider-specific functionality that can be fully encapsulated in the provider.
+ */
+type ProviderOptions = LanguageModelV1ProviderMetadata;
 
 /**
 Represents the number of tokens used in a prompt and completion.
@@ -227,6 +276,56 @@ type EmbeddingModelUsage = {
     tokens: number;
 };
 
+/**
+Transcription model that is used by the AI SDK Core functions.
+  */
+type TranscriptionModel = TranscriptionModelV1;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+  */
+type TranscriptionWarning = TranscriptionModelV1CallWarning;
+
+type TranscriptionModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
+};
+
+/**
+Speech model that is used by the AI SDK Core functions.
+  */
+type SpeechModel = SpeechModelV1;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+  */
+type SpeechWarning = SpeechModelV1CallWarning;
+
+type SpeechModelResponseMetadata = {
+    /**
+  Timestamp for the start of the generated response.
+     */
+    timestamp: Date;
+    /**
+  The ID of the response model that was used to generate the response.
+     */
+    modelId: string;
+    /**
+  Response headers.
+     */
+    headers?: Record<string, string>;
+};
+
 /**
 The result of an `embed` call.
 It contains the embedding, the value, and additional information.
@@ -362,109 +461,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>;
-}
-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, }: {
-    /**
-  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>;
-}): Promise<GenerateImageResult>;
-
 type CallSettings = {
     /**
   Maximum number of tokens to generate.
@@ -566,6 +562,10 @@ interface TextPart {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 }
@@ -589,6 +589,10 @@ interface ImagePart {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 }
@@ -605,6 +609,10 @@ interface FilePart {
      */
     data: DataContent | URL;
     /**
+  Optional filename of the file.
+     */
+    filename?: string;
+    /**
   Mime type of the file.
      */
     mimeType: string;
@@ -612,16 +620,64 @@ interface FilePart {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 }
 /**
-Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ * Reasoning content part of a prompt. It contains a reasoning.
  */
-interface ToolCallPart {
-    type: 'tool-call';
+interface ReasoningPart {
+    type: 'reasoning';
     /**
-  ID of the tool call. This ID is used to match the tool call with the tool result.
+  The reasoning text.
+     */
+    text: string;
+    /**
+  An optional signature for verifying that the reasoning originated from the model.
+     */
+    signature?: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
+}
+/**
+Redacted reasoning content part of a prompt.
+ */
+interface RedactedReasoningPart {
+    type: 'redacted-reasoning';
+    /**
+  Redacted reasoning data.
+     */
+    data: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
+}
+/**
+Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ */
+interface ToolCallPart {
+    type: 'tool-call';
+    /**
+  ID of the tool call. This ID is used to match the tool call with the tool result.
    */
     toolCallId: string;
     /**
@@ -636,6 +692,10 @@ interface ToolCallPart {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 }
@@ -668,6 +728,10 @@ interface ToolResultPart {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 }
@@ -686,9 +750,14 @@ type CoreSystemMessage = {
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
   functionality that can be fully encapsulated in the provider.
+   */
+    providerOptions?: ProviderOptions;
+    /**
+  @deprecated Use `providerOptions` instead.
    */
     experimental_providerMetadata?: ProviderMetadata;
 };
+declare const coreSystemMessageSchema: z.ZodType<CoreSystemMessage>;
 /**
 A user message. It can contain text or a combination of text and images.
  */
@@ -700,8 +769,13 @@ type CoreUserMessage = {
   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;
 };
+declare const coreUserMessageSchema: z.ZodType<CoreUserMessage>;
 /**
 Content of a user message. It can be a string or an array of text and image parts.
  */
@@ -717,12 +791,18 @@ type CoreAssistantMessage = {
   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;
 };
+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 | ToolCallPart>;
+type AssistantContent = string | Array<TextPart | FilePart | ReasoningPart | RedactedReasoningPart | ToolCallPart>;
 /**
 A tool message. It contains the result of one or more tool calls.
  */
@@ -734,8 +814,13 @@ type CoreToolMessage = {
   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;
 };
+declare const coreToolMessageSchema: z.ZodType<CoreToolMessage>;
 /**
 Content of a tool message. It is an array of tool result parts.
  */
@@ -745,13 +830,7 @@ A message that can be used in the `messages` field of a prompt.
 It can be a user message, an assistant message, or a tool message.
  */
 type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage | CoreToolMessage;
-
-type UIMessage = {
-    role: 'system' | 'user' | 'assistant' | 'data';
-    content: string;
-    toolInvocations?: ToolInvocation[];
-    experimental_attachments?: Attachment[];
-};
+declare const coreMessageSchema: z.ZodType<CoreMessage>;
 
 /**
 Prompt part of the AI function options.
@@ -769,825 +848,1407 @@ type Prompt = {
     /**
   A list of messages. You can either use `prompt` or `messages` but not both.
      */
-    messages?: Array<CoreMessage> | Array<UIMessage>;
+    messages?: Array<CoreMessage> | Array<Omit<Message, 'id'>>;
 };
 
 /**
-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;
-    /**
-   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 experimental_providerMetadata: ProviderMetadata | undefined;
+    messages: CoreMessage[];
     /**
-    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;
+     * An optional abort signal that indicates that the overall operation should be aborted.
+     */
+    abortSignal?: AbortSignal;
 }
-
 /**
-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;
+type Tool<PARAMETERS extends ToolParameters = any, RESULT = any> = {
     /**
-The language model to use.
-   */
-    model: LanguageModel;
+  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;
     /**
-The schema of the object that the model should generate.
-   */
-    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+  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 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 conversion function that maps the tool result to multi-part tool content for LLMs.
+     */
+    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
     /**
-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;
+  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>;
+} & ({
     /**
-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';
+Function tool.
+     */
+    type?: undefined | 'function';
+} | {
     /**
-Optional telemetry configuration (experimental).
+Provider-defined tool.
      */
-    experimental_telemetry?: TelemetrySettings;
+    type: 'provider-defined';
     /**
-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.
-*/
-    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.
+ * @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;
+};
 
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
 
-@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.
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
 
-The schema is converted into a JSON schema and used in one of the following ways
+@example
+```
+// data.json
+{
+    'foo': 1,
+    'bar': 2,
+    'biz': 3
+}
 
-- '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.
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
 
-Please note that most providers do not support all modes.
+export function getData(name: string): ValueOf<typeof data> {
+    return data[name];
+}
 
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
-    /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-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.
-*/
-    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.
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+    return data[name];
+}
 
-This function does not stream the output.
+// file.ts
+import {getData, onlyBar} from './main';
 
-@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.
+getData('foo');
+//=> 1
 
-The schema is converted into a JSON schema and used in one of the following ways
+onlyBar('foo');
+//=> TypeError ...
 
-- '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.
+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];
 
-Please note that most providers do not support all modes.
+declare const JSONRPCRequestSchema: 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;
+}>;
+type JSONRPCRequest = z.infer<typeof JSONRPCRequestSchema>;
+declare const JSONRPCResponseSchema: 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";
+}>;
+type JSONRPCResponse = z.infer<typeof JSONRPCResponseSchema>;
+declare const JSONRPCErrorSchema: 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 JSONRPCError = z.infer<typeof JSONRPCErrorSchema>;
+declare const JSONRPCNotificationSchema: 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;
+}>;
+type JSONRPCNotification = z.infer<typeof JSONRPCNotificationSchema>;
+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>;
 
-Default and recommended: 'auto' (best mode for the model).
-   */
-    mode?: 'auto' | 'json' | 'tool';
+/**
+ * Transport interface for MCP (Model Context Protocol) communication.
+ * Maps to the `Transport` interface in the MCP spec.
+ */
+interface MCPTransport {
     /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
+     * Initialize and start the transport
+     */
+    start(): Promise<void>;
     /**
-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.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+     * Send a JSON-RPC message through the transport
+     * @param message The JSON-RPC message to send
+     */
+    send(message: JSONRPCMessage): Promise<void>;
     /**
-     * Internal. For test use only. May change without notice.
+     * Clean up and close the transport
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): Promise<GenerateObjectResult<ENUM>>;
-/**
-Generate JSON with any schema for a given prompt using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamObject` instead.
-
-@returns
-A result object that contains the generated object, the finish reason, the token usage, and additional information.
- */
-declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
-    output: 'no-schema';
+    close(): Promise<void>;
     /**
-The language model to use.
-   */
-    model: LanguageModel;
+     * Event handler for transport closure
+     */
+    onclose?: () => void;
     /**
-The mode to use for object generation. Must be "json" for no-schema output.
-   */
-    mode?: 'json';
+     * Event handler for transport errors
+     */
+    onerror?: (error: Error) => void;
     /**
-Optional telemetry configuration (experimental).
+     * Event handler for received messages
      */
-    experimental_telemetry?: TelemetrySettings;
+    onmessage?: (message: JSONRPCMessage) => void;
+}
+type MCPTransportConfig = {
+    type: 'sse';
     /**
-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.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+     * The URL of the MCP server.
+     */
+    url: string;
     /**
-     * Internal. For test use only. May change without notice.
+     * Additional HTTP headers to be sent with requests.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
+    headers?: Record<string, string>;
+};
+
+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>;
     };
-}): Promise<GenerateObjectResult<JSONValue>>;
+} : {
+    [k: string]: Tool<z.ZodUnknown, CallToolResult> & {
+        execute: (args: unknown, options: ToolExecutionOptions) => PromiseLike<CallToolResult>;
+    };
+};
+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">>>;
+}, {
+    content: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    isError: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, {
+    content: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    isError: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, {
+    content: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"image">;
+        data: z.ZodString;
+        mimeType: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodLiteral<"resource">;
+        resource: z.ZodUnion<[z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            text: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+            /**
+             * The URI of this resource.
+             */
+            uri: z.ZodString;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            mimeType: z.ZodOptional<z.ZodString>;
+        }, {
+            blob: z.ZodString;
+        }>, z.ZodTypeAny, "passthrough">>]>;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    isError: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}>, z.ZodTypeAny, "passthrough">>, z.ZodObject<z.objectUtil.extendShape<{
+    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, {
+    toolResult: z.ZodUnknown;
+}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, {
+    toolResult: z.ZodUnknown;
+}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+    _meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+}, {
+    toolResult: z.ZodUnknown;
+}>, z.ZodTypeAny, "passthrough">>]>;
+type CallToolResult = z.infer<typeof CallToolResultSchema>;
+
+interface MCPClientConfig {
+    /** Transport configuration for connecting to the MCP server */
+    transport: MCPTransportConfig | MCPTransport;
+    /** Optional callback for uncaught errors */
+    onUncaughtError?: (error: unknown) => void;
+    /** Optional client name, defaults to 'ai-sdk-mcp-client' */
+    name?: string;
+}
+declare function createMCPClient(config: MCPClientConfig): Promise<MCPClient>;
+/**
+ * A lightweight MCP Client implementation
+ *
+ * The primary purpose of this client is tool conversion between MCP<>AI SDK
+ * but can later be extended to support other MCP features
+ *
+ * Tool parameters are automatically inferred from the server's JSON schema
+ * if not explicitly provided in the tools configuration
+ *
+ * This client is meant to be used to communicate with a single server. To communicate and fetch tools across multiple servers, it's recommended to create a new client instance per server.
+ *
+ * Not supported:
+ * - Client options (e.g. sampling, roots) as they are not needed for tool conversion
+ * - Accepting notifications
+ * - Session management (when passing a sessionId to an instance of the Streamable HTTP transport)
+ * - Resumable SSE streams
+ */
+declare class MCPClient {
+    private transport;
+    private onUncaughtError?;
+    private clientInfo;
+    private requestMessageId;
+    private responseHandlers;
+    private serverCapabilities;
+    private isClosed;
+    constructor({ transport: transportConfig, name, onUncaughtError, }: MCPClientConfig);
+    init(): Promise<this>;
+    close(): Promise<void>;
+    private assertCapability;
+    private request;
+    private listTools;
+    private callTool;
+    private notification;
+    /**
+     * 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 AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+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']>;
+    };
+}>;
 /**
-The result of a `streamObject` call that contains the partial object stream and additional information.
+ * @deprecated Use `ToolCallUnion` instead.
  */
-interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
+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) & {
     /**
-    Warnings from the model provider (e.g. unsupported settings)
-       */
-    readonly warnings: Promise<CallWarning[] | undefined>;
+  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 token usage of the generated response. Resolved when the response is finished.
-       */
-    readonly usage: Promise<LanguageModelUsage>;
+  The generated text.
+  */
+    readonly text: 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.
-     */
-    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
+  The reasoning that was generated during the generation.
+  */
+    readonly reasoning: string | undefined;
+    readonly reasoningDetails: Array<ReasoningDetail>;
     /**
-  Additional request information from the last step.
-   */
-    readonly request: Promise<LanguageModelRequestMetadata>;
+  The files that were generated during the generation.
+  */
+    readonly files: GeneratedFile[];
     /**
-  Additional response information.
-   */
-    readonly response: Promise<LanguageModelResponseMetadata>;
+  The sources that were used to generate the text.
+  */
+    readonly sources: Source[];
     /**
-    The generated object (typed according to the schema). Resolved when the response is finished.
-       */
-    readonly object: Promise<RESULT>;
+  The tool calls that were made during the generation.
+  */
+    readonly toolCalls: ToolCallArray<TOOLS>;
     /**
-    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>;
+  The results of the tool calls.
+  */
+    readonly toolResults: ToolResultArray<TOOLS>;
     /**
-     * Stream over complete array elements. Only available if the output strategy is set to `array`.
-     */
-    readonly elementStream: ELEMENT_STREAM;
+  The reason why the generation finished.
+  */
+    readonly finishReason: FinishReason;
     /**
-    Text stream of the JSON representation of the generated object. It contains text chunks.
-    When the stream is finished, the object is valid JSON that can be parsed.
-       */
-    readonly textStream: AsyncIterableStream<string>;
+  The token usage of the generated text.
+  */
+    readonly usage: LanguageModelUsage;
     /**
-    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>>;
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    readonly warnings: CallWarning[] | undefined;
     /**
-    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;
+  Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if was not enabled.
+  */
+    readonly logprobs: LogProbs | undefined;
     /**
-    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;
-};
-
-type OnFinishCallback<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;
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
     /**
-  Warnings from the model provider (e.g. unsupported settings).
+  Additional response information.
   */
-    warnings?: CallWarning[];
+    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.
-  */
-    experimental_providerMetadata: ProviderMetadata | undefined;
-}) => Promise<void> | void;
-/**
-Generate a structured, typed object for a given prompt and schema using a language model.
-
-This function streams the output. If you do not want to stream the output, use `generateObject` instead.
-
-@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;
+     */
+    readonly providerMetadata: ProviderMetadata | undefined;
     /**
-Additional provider-specific metadata. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+  @deprecated Use `providerMetadata` instead.
+     */
+    readonly experimental_providerMetadata: ProviderMetadata | undefined;
     /**
-Callback that is called when the LLM response and the final object validation are finished.
-   */
-    onFinish?: OnFinishCallback<OBJECT>;
+  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';
     /**
-     * Internal. For test use only. May change without notice.
+  True when there will be a continuation step with a continuation text.
      */
-    _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.
+    readonly isContinued: boolean;
+};
 
-@return
-A result object for accessing the partial object stream and additional information.
+/**
+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.
  */
-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 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.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+interface GenerateTextResult<TOOLS extends ToolSet, OUTPUT> {
     /**
-Callback that is called when the LLM response and the final object validation are finished.
-   */
-    onFinish?: OnFinishCallback<Array<ELEMENT>>;
+  The generated text.
+       */
+    readonly text: string;
     /**
-     * Internal. For test use only. May change without notice.
+  The reasoning text that the model has generated. Can be undefined if the model
+  has only generated text.
      */
-    _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;
+    readonly reasoning: string | undefined;
     /**
-The mode to use for object generation. Must be "json" for no-schema output.
-   */
-    mode?: 'json';
+  The files that were generated. Empty array if no files were generated.
+       */
+    readonly files: Array<GeneratedFile>;
     /**
-Optional telemetry configuration (experimental).
-   */
-    experimental_telemetry?: TelemetrySettings;
+  The full reasoning that the model has generated.
+     */
+    readonly reasoningDetails: Array<ReasoningDetail>;
     /**
-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.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+  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[];
     /**
-Callback that is called when the LLM response and the final object validation are finished.
-   */
-    onFinish?: OnFinishCallback<JSONValue>;
+  The generated structured output. It uses the `experimental_output` specification.
+     */
+    readonly experimental_output: OUTPUT;
     /**
-     * Internal. For test use only. May change without notice.
+    The tool calls that were made during the generation.
      */
-    _internal?: {
-        generateId?: () => string;
-        currentDate?: () => Date;
-        now?: () => number;
-    };
-}): StreamObjectResult<JSONValue, JSONValue, never>;
-
-type Parameters = z.ZodTypeAny | Schema<any>;
-type inferParameters<PARAMETERS extends Parameters> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
-interface ToolExecutionOptions {
+    readonly toolCalls: ToolCallArray<TOOLS>;
     /**
-     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+    The results of the tool calls.
      */
-    toolCallId: string;
+    readonly toolResults: ToolResultArray<TOOLS>;
     /**
-     * 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.
+    The reason why the generation finished.
      */
-    messages: CoreMessage[];
+    readonly finishReason: FinishReason;
     /**
-     * An optional abort signal that indicates that the overall operation should be aborted.
+    The token usage of the generated text.
      */
-    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 CoreTool<PARAMETERS extends Parameters = any, RESULT = any> = {
+    readonly usage: LanguageModelUsage;
     /**
-  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.
+    Warnings from the model provider (e.g. unsupported settings)
      */
-    parameters: PARAMETERS;
+    readonly warnings: CallWarning[] | undefined;
     /**
-  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
      */
-    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';
-    /**
-An optional description of what the tool does. Will be used by the language model to decide whether to use the tool.
- */
-    description?: string;
-} | {
-    /**
-Provider-defined tool.
-     */
-    type: 'provider-defined';
-    /**
-The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
-     */
-    id: `${string}.${string}`;
-    /**
-The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
-     */
-    args: Record<string, unknown>;
-});
-/**
-Helper function for inferring the execute args of a tool.
- */
-declare function tool<PARAMETERS extends Parameters, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-}): CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
-};
-declare function tool<PARAMETERS extends Parameters, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
-    execute?: undefined;
-}): CoreTool<PARAMETERS, RESULT> & {
-    execute: undefined;
-};
-
-/**
-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 Record<string, CoreTool> = never>(messages: Array<UIMessage>, options?: {
-    tools?: TOOLS;
-}): CoreMessage[];
-
-/**
-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 ToolCallUnion<TOOLS extends Record<string, CoreTool>> = ValueOf<{
-    [NAME in keyof TOOLS]: {
-        type: 'tool-call';
-        toolCallId: string;
-        toolName: NAME & string;
-        args: inferParameters<TOOLS[NAME]['parameters']>;
-    };
-}>;
-type ToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToolCallUnion<TOOLS>>;
-
-type ToToolsWithExecute<TOOLS extends Record<string, CoreTool>> = {
-    [K in keyof TOOLS as TOOLS[K] extends {
-        execute: any;
-    } ? K : never]: TOOLS[K];
-};
-type ToToolsWithDefinedExecute<TOOLS extends Record<string, CoreTool>> = {
-    [K in keyof TOOLS as TOOLS[K]['execute'] extends undefined ? never : K]: TOOLS[K];
-};
-type ToToolResultObject<TOOLS extends Record<string, CoreTool>> = 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 Record<string, CoreTool>> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
-type ToolResultArray<TOOLS extends Record<string, CoreTool>> = Array<ToolResultUnion<TOOLS>>;
-
-/**
- * The result of a single step in the generation process.
- */
-type StepResult<TOOLS extends Record<string, CoreTool>> = {
-    /**
-  The generated text.
-  */
-    readonly text: string;
-    /**
-  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. It consists of an assistant message,
-    potentially containing tool calls.
-    */
-        readonly messages: Array<CoreAssistantMessage | CoreToolMessage>;
-    };
-    /**
-  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_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 Record<string, CoreTool>, OUTPUT> {
-    /**
-    The generated text.
-       */
-    readonly text: string;
-    /**
-  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>>;
+    readonly steps: Array<StepResult<TOOLS>>;
     /**
   Additional request information.
      */
@@ -1604,7 +2265,11 @@ interface GenerateTextResult<TOOLS extends Record<string, CoreTool>, OUTPUT> {
     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<CoreAssistantMessage | CoreToolMessage>;
+        messages: Array<ResponseMessage>;
+        /**
+    Response body (available only for providers that use HTTP requests).
+         */
+        body?: unknown;
     };
     /**
   Logprobs for the completion.
@@ -1618,6 +2283,10 @@ interface GenerateTextResult<TOOLS extends Record<string, CoreTool>, OUTPUT> {
   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;
 }
 
@@ -1640,6 +2309,7 @@ interface Output<OUTPUT, PARTIAL> {
     }, context: {
         response: LanguageModelResponseMetadata;
         usage: LanguageModelUsage;
+        finishReason: FinishReason;
     }): OUTPUT;
 }
 declare const text: () => Output<string, string>;
@@ -1658,9 +2328,9 @@ declare namespace output {
   };
 }
 
-declare const symbol$c: unique symbol;
+declare const symbol$f: unique symbol;
 declare class InvalidToolArgumentsError extends AISDKError {
-    private readonly [symbol$c];
+    private readonly [symbol$f];
     readonly toolName: string;
     readonly toolArgs: string;
     constructor({ toolArgs, toolName, cause, message, }: {
@@ -1672,9 +2342,9 @@ declare class InvalidToolArgumentsError extends AISDKError {
     static isInstance(error: unknown): error is InvalidToolArgumentsError;
 }
 
-declare const symbol$b: unique symbol;
+declare const symbol$e: unique symbol;
 declare class NoSuchToolError extends AISDKError {
-    private readonly [symbol$b];
+    private readonly [symbol$e];
     readonly toolName: string;
     readonly availableTools: string[] | undefined;
     constructor({ toolName, availableTools, message, }: {
@@ -1685,6 +2355,42 @@ declare class NoSuchToolError extends AISDKError {
     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.
  *
@@ -1698,7 +2404,7 @@ declare class NoSuchToolError extends AISDKError {
  * @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 Record<string, CoreTool>> = (options: {
+type ToolCallRepairFunction<TOOLS extends ToolSet> = (options: {
     system: string | undefined;
     messages: CoreMessage[];
     toolCall: LanguageModelV1FunctionToolCall;
@@ -1709,6 +2415,12 @@ type ToolCallRepairFunction<TOOLS extends Record<string, CoreTool>> = (options:
     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.
 
@@ -1749,13 +2461,14 @@ If set and supported by the model, calls will generate deterministic results.
 @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 Record<string, CoreTool>, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata: providerMetadata, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
+declare function generateText<TOOLS extends ToolSet, OUTPUT = never, OUTPUT_PARTIAL = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries: maxRetriesArg, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata, providerOptions, experimental_activeTools: activeTools, experimental_prepareStep: prepareStep, experimental_repairToolCall: repairToolCall, _internal: { generateId, currentDate, }, onStepFinish, ...settings }: CallSettings & Prompt & {
     /**
 The language model to use.
      */
@@ -1767,7 +2480,7 @@ The tools that the model can call. The model needs to support calling tools.
     /**
 The tool choice strategy. Default: 'auto'.
      */
-    toolChoice?: CoreToolChoice<TOOLS>;
+    toolChoice?: ToolChoice<TOOLS>;
     /**
 Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
 
@@ -1777,6 +2490,10 @@ 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.
@@ -1787,10 +2504,14 @@ Optional telemetry configuration (experimental).
      */
     experimental_telemetry?: TelemetrySettings;
     /**
-Additional provider-specific metadata. They are passed through
+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
@@ -1802,18 +2523,40 @@ Optional specification for parsing structured outputs from the LLM response.
      */
     experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
     /**
+Optional function that you can use to provide different settings for a step.
+
+@param options - The options for the step.
+@param options.steps - The steps that have been executed so far.
+@param options.stepNumber - The number of the step that is being executed.
+@param options.maxSteps - The maximum number of steps.
+@param options.model - The model that is being used.
+
+@returns An object that contains the settings for the step.
+If you return undefined (or for undefined settings), the settings from the outer level will be used.
+    */
+    experimental_prepareStep?: (options: {
+        steps: Array<StepResult<TOOLS>>;
+        stepNumber: number;
+        maxSteps: number;
+        model: LanguageModel;
+    }) => PromiseLike<{
+        model?: LanguageModel;
+        toolChoice?: ToolChoice<TOOLS>;
+        experimental_activeTools?: Array<keyof TOOLS>;
+    } | undefined>;
+    /**
 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?: (event: StepResult<TOOLS>) => Promise<void> | void;
+    onStepFinish?: GenerateTextOnStepFinishCallback<TOOLS>;
     /**
      * Internal. For test use only. May change without notice.
      */
     _internal?: {
-        generateId?: () => string;
+        generateId?: IDGenerator;
         currentDate?: () => Date;
     };
 }): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
@@ -1835,10 +2578,51 @@ declare class StreamData {
     appendMessageAnnotation(value: JSONValue$1): void;
 }
 
-/**
-A result object for accessing different stream types and additional information.
- */
-interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPUT> {
+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;
+};
+type ConsumeStreamOptions = {
+    onError?: (error: unknown) => void;
+};
+/**
+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.
        */
@@ -1851,6 +2635,19 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
        */
     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.
@@ -1861,6 +2658,10 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
   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.
@@ -1869,6 +2670,18 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
        */
     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.
@@ -1902,7 +2715,7 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
   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<CoreAssistantMessage | CoreToolMessage>;
+        messages: Array<ResponseMessage>;
     }>;
     /**
     A text stream that returns only the generated text deltas. You can use it
@@ -1922,25 +2735,35 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
      */
     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.
+  
+  If an error occurs, it is passed to the optional `onError` callback.
+    */
+    consumeStream(options?: ConsumeStreamOptions): 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;
-        sendUsage?: boolean;
-    }): ReadableStream<Uint8Array>;
+    } & 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): void;
+    mergeIntoDataStream(dataStream: DataStreamWriter, options?: DataStreamOptions): void;
     /**
     Writes data stream output to a Node.js response-like object.
   
@@ -1951,12 +2774,12 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
     @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;
-        sendUsage?: boolean;
-    }): void;
+    } & 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
@@ -1976,14 +2799,14 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
     @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;
-        sendUsage?: boolean;
-    }): Response;
+    } & DataStreamOptions): Response;
     /**
     Creates a simple text stream response.
     Each text delta is encoded as UTF-8 and sent as a separate chunk.
@@ -1993,10 +2816,24 @@ interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPU
        */
     toTextStreamResponse(init?: ResponseInit): Response;
 }
-type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
+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';
@@ -2010,27 +2847,121 @@ type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
 } | ({
     type: 'tool-result';
 } & ToolResultUnion<TOOLS>) | {
+    type: 'step-start';
+    messageId: string;
+    request: LanguageModelRequestMetadata;
+    warnings: CallWarning[];
+} | {
     type: 'step-finish';
-    finishReason: FinishReason;
+    messageId: string;
     logprobs?: LogProbs;
-    usage: LanguageModelUsage;
     request: LanguageModelRequestMetadata;
-    response: LanguageModelResponseMetadata;
     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;
-    logprobs?: LogProbs;
     usage: LanguageModelUsage;
-    response: LanguageModelResponseMetadata;
+    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;
 };
 
+/**
+ * Detects the first chunk in a buffer.
+ *
+ * @param buffer - The buffer to detect the first chunk in.
+ *
+ * @returns The first detected chunk, or `undefined` if no chunk was detected.
+ */
+type ChunkDetector = (buffer: string) => string | undefined | null;
+/**
+ * Smooths text streaming output.
+ *
+ * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
+ * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, or provide a custom RegExp pattern for custom chunking.
+ *
+ * @returns A transform stream that smooths text streaming output.
+ */
+declare function smoothStream<TOOLS extends ToolSet>({ delayInMs, chunking, _internal: { delay }, }?: {
+    delayInMs?: number | null;
+    chunking?: 'word' | 'line' | RegExp | ChunkDetector;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        delay?: (delayInMs: number | null) => Promise<void>;
+    };
+}): (options: {
+    tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+
+/**
+A transformation that is applied to the stream.
+
+@param stopStream - A function that stops the source stream.
+@param tools - The tools that are accessible to and can be called by the model. The model needs to support calling tools.
+ */
+type StreamTextTransform<TOOLS extends ToolSet> = (options: {
+    tools: TOOLS;
+    stopStream: () => void;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+/**
+Callback that is set using the `onError` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnErrorCallback = (event: {
+    error: unknown;
+}) => Promise<void> | void;
+/**
+Callback that is set using the `onStepFinish` option.
+
+@param stepResult - The result of the step.
+ */
+type StreamTextOnStepFinishCallback<TOOLS extends ToolSet> = (stepResult: StepResult<TOOLS>) => Promise<void> | void;
+/**
+Callback that is set using the `onChunk` option.
+
+@param event - The event that is passed to the callback.
+ */
+type StreamTextOnChunkCallback<TOOLS extends ToolSet> = (event: {
+    chunk: Extract<TextStreamPart<TOOLS>, {
+        type: 'text-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;
 /**
 Generate a text and call tools for a given prompt using a language model.
 
@@ -2069,8 +3000,10 @@ If set and supported by the model, calls will generate deterministic results.
 @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.
@@ -2078,7 +3011,7 @@ If set and supported by the model, calls will generate deterministic results.
 @return
 A result object for accessing different stream types and additional information.
  */
-declare function streamText<TOOLS extends Record<string, CoreTool>, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, maxSteps, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, experimental_providerMetadata: providerMetadata, experimental_toolCallStreaming: toolCallStreaming, experimental_activeTools: activeTools, experimental_repairToolCall: repairToolCall, experimental_transform: transform, onChunk, onFinish, onStepFinish, _internal: { now, generateId, currentDate, }, ...settings }: CallSettings & Prompt & {
+declare function streamText<TOOLS extends ToolSet, OUTPUT = never, PARTIAL_OUTPUT = never>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, maxSteps, experimental_generateMessageId: generateMessageId, experimental_output: output, experimental_continueSteps: continueSteps, experimental_telemetry: telemetry, 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 & {
     /**
 The language model to use.
      */
@@ -2090,119 +3023,1072 @@ The tools that the model can call. The model needs to support calling tools.
     /**
 The tool choice strategy. Default: 'auto'.
      */
-    toolChoice?: CoreToolChoice<TOOLS>;
+    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.
+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, PARTIAL_OUTPUT>;
+    /**
+A function that attempts to repair a tool call that failed to parse.
+     */
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    /**
+Enable streaming of tool call deltas as they are generated. Disabled by default.
+     */
+    toolCallStreaming?: boolean;
+    /**
+@deprecated Use `toolCallStreaming` instead.
+     */
+    experimental_toolCallStreaming?: boolean;
+    /**
+Optional stream transformations.
+They are applied in the order they are provided.
+The stream transformations must maintain the stream structure for streamText to work correctly.
+     */
+    experimental_transform?: StreamTextTransform<TOOLS> | Array<StreamTextTransform<TOOLS>>;
+    /**
+Callback that is called for each chunk of the stream.
+The stream processing will pause until the callback promise is resolved.
+     */
+    onChunk?: StreamTextOnChunkCallback<TOOLS>;
+    /**
+Callback that is invoked when an error occurs during streaming.
+You can use it to log errors.
+The stream processing will pause until the callback promise is resolved.
+     */
+    onError?: StreamTextOnErrorCallback;
+    /**
+Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
+
+The usage is the combined usage of all steps.
+     */
+    onFinish?: StreamTextOnFinishCallback<TOOLS>;
+    /**
+Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: StreamTextOnStepFinishCallback<TOOLS>;
+    /**
+Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        now?: () => number;
+        generateId?: IDGenerator;
+        currentDate?: () => Date;
+    };
+}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+
+/**
+The result of a `generateImage` call.
+It contains the images and additional information.
+ */
+interface GenerateImageResult {
+    /**
+  The first image that was generated.
+     */
+    readonly image: GeneratedFile;
+    /**
+  The images that were generated.
+       */
+    readonly images: Array<GeneratedFile>;
+    /**
+  Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<ImageGenerationWarning>;
+    /**
+  Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<ImageModelResponseMetadata>;
+}
+
+/**
+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, }: {
+    /**
+  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>;
+}): Promise<GenerateImageResult>;
+
+/**
+The result of a `generateObject` call.
+ */
+interface GenerateObjectResult<OBJECT> {
+    /**
+    The generated object (typed according to the schema).
+       */
+    readonly object: OBJECT;
+    /**
+    The reason why the generation finished.
+       */
+    readonly finishReason: FinishReason;
+    /**
+    The token usage of the generated text.
+       */
+    readonly usage: LanguageModelUsage;
+    /**
+    Warnings from the model provider (e.g. unsupported settings).
+       */
+    readonly warnings: CallWarning[] | undefined;
+    /**
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+     */
+    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;
+}
+
+/**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+
+Should return the repaired text or null if the text cannot be repaired.
+     */
+type RepairTextFunction = (options: {
+    text: string;
+    error: JSONParseError | TypeValidationError;
+}) => Promise<string | null>;
+/**
+Generate a structured, typed object for a given prompt and schema using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject<OBJECT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output?: 'object' | undefined;
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The schema of the object that the model should generate.
+   */
+    schema: z.Schema<OBJECT, z.ZodTypeDef, any> | Schema<OBJECT>;
+    /**
+Optional name of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the output that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+   */
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
+
+The schema is converted into a JSON schema and used in one of the following ways
+
+- 'auto': The provider will choose the best mode for the model.
+- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
+- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
+
+Please note that most providers do not support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
+    /**
+Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<OBJECT>>;
+/**
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@return
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
+    /**
+Optional name of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
+
+The schema is converted into a JSON schema and used in one of the following ways
+
+- 'auto': The provider will choose the best mode for the model.
+- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
+- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
+
+Please note that most providers do not support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<Array<ELEMENT>>>;
+/**
+Generate a value from an enum (limited list of string values) using a language model.
+
+This function does not stream the output.
+
+@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.
+
+The schema is converted into a JSON schema and used in one of the following ways
+
+- 'auto': The provider will choose the best mode for the model.
+- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
+- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
+
+Please note that most providers do not support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+   */
+    mode?: 'auto' | 'json' | 'tool';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    experimental_repairText?: RepairTextFunction;
+    /**
+Optional telemetry configuration (experimental).
+   */
+    experimental_telemetry?: TelemetrySettings;
+    /**
+Additional provider-specific options. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+*/
+    providerOptions?: ProviderOptions;
+    /**
+@deprecated Use `providerOptions` instead.
+*/
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): Promise<GenerateObjectResult<ENUM>>;
+/**
+Generate JSON with any schema for a given prompt using a language model.
+
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
+
+@returns
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
+ */
+declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
+    /**
+A function that attempts to repair the raw output of the mode
+to enable JSON parsing.
+   */
+    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<JSONValue>>;
+
+/**
+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>;
+
+/**
+ * A generated audio file.
+ */
+interface GeneratedAudioFile extends GeneratedFile {
+    /**
+     * Audio format of the file (e.g., 'mp3', 'wav', etc.)
+     */
+    readonly format: string;
+}
+
+/**
+The result of a `generateSpeech` call.
+It contains the audio data and additional information.
+ */
+interface SpeechResult {
+    /**
+     * The audio data as a base64 encoded string or binary data.
+     */
+    readonly audio: GeneratedAudioFile;
+    /**
+    Warnings for the call, e.g. unsupported settings.
+       */
+    readonly warnings: Array<SpeechWarning>;
+    /**
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<SpeechModelResponseMetadata>;
+    /**
+    Provider metadata from the provider.
+     */
+    readonly providerMetadata: Record<string, Record<string, JSONValue>>;
+}
+
+/**
+Generates speech audio using a speech model.
+
+@param model - The speech model to use.
+@param text - The text to convert to speech.
+@param voice - The voice to use for speech generation.
+@param outputFormat - The output format to use for speech generation e.g. "mp3", "wav", etc.
+@param instructions - Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+@param speed - The speed of the speech generation.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated audio data.
  */
-    maxSteps?: number;
+declare function generateSpeech({ model, text, voice, outputFormat, instructions, speed, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-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 speech model to use.
+       */
+    model: SpeechModelV1;
     /**
-Optional telemetry configuration (experimental).
+  The text to convert to speech.
      */
-    experimental_telemetry?: TelemetrySettings;
-    /**
-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.
- */
-    experimental_providerMetadata?: ProviderMetadata;
+    text: string;
     /**
-Limits the tools that are available for the model to call without
-changing the tool call and result types in the result.
+  The voice to use for speech generation.
      */
-    experimental_activeTools?: Array<keyof TOOLS>;
+    voice?: string;
     /**
-Optional specification for parsing structured outputs from the LLM response.
+     * The desired output format for the audio e.g. "mp3", "wav", etc.
      */
-    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
+    outputFormat?: 'mp3' | 'wav' | (string & {});
     /**
-A function that attempts to repair a tool call that failed to parse.
+      Instructions for the speech generation e.g. "Speak in a slow and steady tone".
+    */
+    instructions?: string;
+    /**
+    The speed of the speech generation.
      */
-    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
+    speed?: number;
     /**
-Enable streaming of tool call deltas as they are generated. Disabled by default.
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
+  
+  The outer record is keyed by the provider name, and the inner
+  record is keyed by the provider-specific metadata key.
+  ```ts
+  {
+    "openai": {}
+  }
+  ```
+       */
+    providerOptions?: ProviderOptions;
+    /**
+  Maximum number of retries per speech model call. Set to 0 to disable retries.
+  
+  @default 2
      */
-    experimental_toolCallStreaming?: boolean;
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
     /**
-Optional transformation that is applied to the stream.
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<SpeechResult>;
 
-@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.
-     */
-    experimental_transform?: (options: {
-        tools: TOOLS;
-        stopStream: () => void;
-    }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+/**
+The result of a `transcribe` call.
+It contains the transcript and additional information.
+ */
+interface TranscriptionResult {
     /**
-Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
+     * The complete transcribed text from the audio.
      */
-    onChunk?: (event: {
-        chunk: Extract<TextStreamPart<TOOLS>, {
-            type: 'text-delta' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
-        }>;
-    }) => Promise<void> | void;
+    readonly text: string;
     /**
-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.
+     * Array of transcript segments with timing information.
+     * Each segment represents a portion of the transcribed text with start and end times.
      */
-    onFinish?: (event: Omit<StepResult<TOOLS>, 'stepType' | 'isContinued'> & {
+    readonly segments: Array<{
         /**
-Details for all steps.
+         * The text content of this segment.
+         */
+        readonly text: string;
+        /**
+         * The start time of this segment in seconds.
+         */
+        readonly startSecond: number;
+        /**
+         * The end time of this segment in seconds.
+         */
+        readonly endSecond: number;
+    }>;
+    /**
+     * The detected language of the audio content, as an ISO-639-1 code (e.g., 'en' for English).
+     * May be undefined if the language couldn't be detected.
+     */
+    readonly language: string | undefined;
+    /**
+     * The total duration of the audio file in seconds.
+     * May be undefined if the duration couldn't be determined.
+     */
+    readonly durationInSeconds: number | undefined;
+    /**
+    Warnings for the call, e.g. unsupported settings.
        */
-        readonly steps: StepResult<TOOLS>[];
-    }) => Promise<void> | void;
+    readonly warnings: Array<TranscriptionWarning>;
     /**
-    Callback that is called when each step (LLM call) is finished, including intermediate steps.
-    */
-    onStepFinish?: (event: StepResult<TOOLS>) => Promise<void> | void;
+    Response metadata from the provider. There may be multiple responses if we made multiple calls to the model.
+     */
+    readonly responses: Array<TranscriptionModelResponseMetadata>;
     /**
-     * Internal. For test use only. May change without notice.
+    Provider metadata from the provider.
      */
-    _internal?: {
-        now?: () => number;
-        generateId?: () => string;
-        currentDate?: () => Date;
-    };
-}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
+    readonly providerMetadata: Record<string, Record<string, JSONValue>>;
+}
 
 /**
- * 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.
+Generates transcripts using a transcription model.
+
+@param model - The transcription model to use.
+@param audio - The audio data to transcribe as DataContent (string | Uint8Array | ArrayBuffer | Buffer) or a URL.
+@param providerOptions - Additional provider-specific options that are passed through to the provider
+as body parameters.
+@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
+@param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
+
+@returns A result object that contains the generated transcript.
  */
-declare function smoothStream<TOOLS extends Record<string, CoreTool>>({ delayInMs, chunking, _internal: { delay }, }?: {
-    delayInMs?: number | null;
-    chunking?: 'word' | 'line' | RegExp;
+declare function transcribe({ model, audio, providerOptions, maxRetries: maxRetriesArg, abortSignal, headers, }: {
     /**
-     * Internal. For test use only. May change without notice.
+  The transcription model to use.
+       */
+    model: TranscriptionModelV1;
+    /**
+  The audio data to transcribe.
      */
-    _internal?: {
-        delay?: (delayInMs: number | null) => Promise<void>;
-    };
-}): (options: {
-    tools: TOOLS;
-}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+    audio: DataContent | URL;
+    /**
+  Additional provider-specific options that are passed through to the provider
+  as body parameters.
+  
+  The outer record is keyed by the provider name, and the inner
+  record is keyed by the provider-specific metadata key.
+  ```ts
+  {
+    "openai": {
+      "temperature": 0
+    }
+  }
+  ```
+       */
+    providerOptions?: ProviderOptions;
+    /**
+  Maximum number of retries per transcript model call. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+   */
+    abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+}): Promise<TranscriptionResult>;
 
 /**
  * Experimental middleware for LanguageModelV1.
  * This type defines the structure for middleware that can be used to modify
  * the behavior of LanguageModelV1 operations.
  */
-type Experimental_LanguageModelV1Middleware = {
+type LanguageModelV1Middleware = {
+    /**
+     * Middleware specification version. Use `v1` for the current version.
+     */
+    middlewareVersion?: 'v1' | undefined;
     /**
      * Transforms the parameters before they are passed to the language model.
      * @param options - Object containing the type of operation and the parameters.
@@ -2218,6 +4104,7 @@ type Experimental_LanguageModelV1Middleware = {
      * Wraps the generate operation of the language model.
      * @param options - Object containing the generate function, parameters, and model.
      * @param options.doGenerate - The original generate function.
+     * @param options.doStream - The original stream function.
      * @param options.params - The parameters for the generate call. If the
      * `transformParams` middleware is used, this will be the transformed parameters.
      * @param options.model - The language model instance.
@@ -2225,12 +4112,15 @@ type Experimental_LanguageModelV1Middleware = {
      */
     wrapGenerate?: (options: {
         doGenerate: () => ReturnType<LanguageModelV1['doGenerate']>;
+        doStream: () => ReturnType<LanguageModelV1['doStream']>;
         params: LanguageModelV1CallOptions;
         model: LanguageModelV1;
     }) => Promise<Awaited<ReturnType<LanguageModelV1['doGenerate']>>>;
     /**
      * Wraps the stream operation of the language model.
+     *
      * @param options - Object containing the stream function, parameters, and model.
+     * @param options.doGenerate - The original generate function.
      * @param options.doStream - The original stream function.
      * @param options.params - The parameters for the stream call. If the
      * `transformParams` middleware is used, this will be the transformed parameters.
@@ -2238,11 +4128,44 @@ type Experimental_LanguageModelV1Middleware = {
      * @returns A promise that resolves to the result of the stream operation.
      */
     wrapStream?: (options: {
+        doGenerate: () => ReturnType<LanguageModelV1['doGenerate']>;
         doStream: () => ReturnType<LanguageModelV1['doStream']>;
         params: LanguageModelV1CallOptions;
         model: LanguageModelV1;
     }) => PromiseLike<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
 };
+/**
+ * @deprecated Use `LanguageModelV1Middleware` instead.
+ */
+type Experimental_LanguageModelV1Middleware = LanguageModelV1Middleware;
+
+/**
+ * Applies default settings for a language model.
+ */
+declare function defaultSettingsMiddleware({ settings, }: {
+    settings: Partial<LanguageModelV1CallOptions & {
+        providerMetadata?: LanguageModelV1ProviderMetadata;
+    }>;
+}): LanguageModelV1Middleware;
+
+/**
+ * Extract an XML-tagged reasoning section from the generated text and exposes it
+ * as a `reasoning` property on the result.
+ *
+ * @param tagName - The name of the XML tag to extract reasoning from.
+ * @param separator - The separator to use between reasoning and text sections.
+ * @param startWithReasoning - Whether to start with reasoning tokens.
+ */
+declare function extractReasoningMiddleware({ tagName, separator, startWithReasoning, }: {
+    tagName: string;
+    separator?: string;
+    startWithReasoning?: boolean;
+}): LanguageModelV1Middleware;
+
+/**
+ * Simulates streaming chunks with the response from a generate call.
+ */
+declare function simulateStreamingMiddleware(): LanguageModelV1Middleware;
 
 /**
  * Wraps a LanguageModelV1 instance with middleware functionality.
@@ -2251,14 +4174,23 @@ type Experimental_LanguageModelV1Middleware = {
  *
  * @param options - Configuration options for wrapping the language model.
  * @param options.model - The original LanguageModelV1 instance to be wrapped.
- * @param options.middleware - The middleware to be applied to the language model.
+ * @param options.middleware - The middleware to be applied to the language model. When multiple middlewares are provided, the first middleware will transform the input first, and the last middleware will be wrapped directly around the model.
  * @param options.modelId - Optional custom model ID to override the original model's ID.
  * @param options.providerId - Optional custom provider ID to override the original model's provider.
  * @returns A new LanguageModelV1 instance with middleware applied.
  */
-declare const experimental_wrapLanguageModel: ({ model, middleware: { transformParams, wrapGenerate, wrapStream }, modelId, providerId, }: {
+declare const wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
+    model: LanguageModelV1;
+    middleware: LanguageModelV1Middleware | LanguageModelV1Middleware[];
+    modelId?: string;
+    providerId?: string;
+}) => LanguageModelV1;
+/**
+ * @deprecated Use `wrapLanguageModel` instead.
+ */
+declare const experimental_wrapLanguageModel: ({ model, middleware: middlewareArg, modelId, providerId, }: {
     model: LanguageModelV1;
-    middleware: Experimental_LanguageModelV1Middleware;
+    middleware: LanguageModelV1Middleware | LanguageModelV1Middleware[];
     modelId?: string;
     providerId?: string;
 }) => LanguageModelV1;
@@ -2267,22 +4199,33 @@ declare const experimental_wrapLanguageModel: ({ model, middleware: { transformP
  * Creates a custom provider with specified language models, text embedding models, and an optional fallback provider.
  *
  * @param {Object} options - The options for creating the custom provider.
- * @param {Record<string, LanguageModelV1>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModelV1 instances.
- * @param {Record<string, EmbeddingModelV1<string>>} [options.textEmbeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModelV1<string> instances.
+ * @param {Record<string, LanguageModel>} [options.languageModels] - A record of language models, where keys are model IDs and values are LanguageModel instances.
+ * @param {Record<string, EmbeddingModel<string>>} [options.textEmbeddingModels] - A record of text embedding models, where keys are model IDs and values are EmbeddingModel<string> instances.
+ * @param {Record<string, ImageModel>} [options.imageModels] - A record of image models, where keys are model IDs and values are ImageModel instances.
  * @param {Provider} [options.fallbackProvider] - An optional fallback provider to use when a requested model is not found in the custom provider.
- * @returns {Provider} A Provider object with languageModel and textEmbeddingModel methods.
+ * @returns {Provider} A Provider object with languageModel, textEmbeddingModel, and imageModel methods.
  *
  * @throws {NoSuchModelError} Throws when a requested model is not found and no fallback provider is available.
  */
-declare function experimental_customProvider({ languageModels, textEmbeddingModels, fallbackProvider, }: {
-    languageModels?: Record<string, LanguageModelV1>;
-    textEmbeddingModels?: Record<string, EmbeddingModelV1<string>>;
-    fallbackProvider?: Provider;
-}): Provider;
+declare function customProvider<LANGUAGE_MODELS extends Record<string, LanguageModel>, EMBEDDING_MODELS extends Record<string, EmbeddingModel<string>>, IMAGE_MODELS extends Record<string, ImageModel>>({ languageModels, textEmbeddingModels, imageModels, fallbackProvider, }: {
+    languageModels?: LANGUAGE_MODELS;
+    textEmbeddingModels?: EMBEDDING_MODELS;
+    imageModels?: IMAGE_MODELS;
+    fallbackProvider?: ProviderV1;
+}): Provider & {
+    languageModel(modelId: ExtractModelId<LANGUAGE_MODELS>): LanguageModel;
+    textEmbeddingModel(modelId: ExtractModelId<EMBEDDING_MODELS>): EmbeddingModel<string>;
+    imageModel(modelId: ExtractModelId<IMAGE_MODELS>): ImageModel;
+};
+/**
+ * @deprecated Use `customProvider` instead.
+ */
+declare const experimental_customProvider: typeof customProvider;
+type ExtractModelId<MODELS extends Record<string, unknown>> = Extract<keyof MODELS, string>;
 
-declare const symbol$a: unique symbol;
+declare const symbol$d: unique symbol;
 declare class NoSuchProviderError extends NoSuchModelError {
-    private readonly [symbol$a];
+    private readonly [symbol$d];
     readonly providerId: string;
     readonly availableProviders: string[];
     constructor({ modelId, modelType, providerId, availableProviders, message, }: {
@@ -2295,10 +4238,25 @@ declare class NoSuchProviderError extends NoSuchModelError {
     static isInstance(error: unknown): error is NoSuchProviderError;
 }
 
+type ExtractLiteralUnion<T> = T extends string ? string extends T ? never : T : never;
+interface ProviderRegistryProvider<PROVIDERS extends Record<string, ProviderV1> = Record<string, ProviderV1>, SEPARATOR extends string = ':'> {
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['languageModel']>>[0]>}` : never): LanguageModel;
+    languageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): LanguageModel;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['textEmbeddingModel']>>[0]>}` : never): EmbeddingModel<string>;
+    textEmbeddingModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): EmbeddingModel<string>;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${ExtractLiteralUnion<Parameters<NonNullable<PROVIDERS[KEY]['imageModel']>>[0]>}` : never): ImageModel;
+    imageModel<KEY extends keyof PROVIDERS>(id: KEY extends string ? `${KEY & string}${SEPARATOR}${string}` : never): ImageModel;
+}
 /**
  * Creates a registry for the given providers.
  */
-declare function experimental_createProviderRegistry(providers: Record<string, Provider>): Provider;
+declare function createProviderRegistry<PROVIDERS extends Record<string, ProviderV1>, SEPARATOR extends string = ':'>(providers: PROVIDERS, { separator, }?: {
+    separator?: SEPARATOR;
+}): ProviderRegistryProvider<PROVIDERS, SEPARATOR>;
+/**
+ * @deprecated Use `createProviderRegistry` instead.
+ */
+declare const experimental_createProviderRegistry: typeof createProviderRegistry;
 
 /**
  * Calculates the cosine similarity between two vectors. This is a useful metric for
@@ -2306,11 +4264,21 @@ declare function experimental_createProviderRegistry(providers: Record<string, P
  *
  * @param vector1 - The first vector.
  * @param vector2 - The second vector.
+ * @param options - Optional configuration.
+ * @param options.throwErrorForEmptyVectors - If true, throws an error for empty vectors. Default: false.
  *
  * @returns The cosine similarity between vector1 and vector2.
- * @throws {Error} If the vectors do not have the same length.
+ * @returns 0 if either vector is the zero vector.
+ *
+ * @throws {InvalidArgumentError} If throwErrorForEmptyVectors is true and vectors are empty.
+ * @throws {InvalidArgumentError} If the vectors do not have the same length.
  */
-declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
+declare function cosineSimilarity(vector1: number[], vector2: number[], options?: {
+    /**
+     * @deprecated will be removed in 5.0
+     */
+    throwErrorForEmptyVectors?: boolean;
+}): number;
 
 /**
  * Creates a ReadableStream that emits the provided values with an optional delay between each value.
@@ -2330,9 +4298,9 @@ declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDela
     };
 }): ReadableStream<T>;
 
-declare const symbol$9: unique symbol;
+declare const symbol$c: unique symbol;
 declare class InvalidArgumentError extends AISDKError {
-    private readonly [symbol$9];
+    private readonly [symbol$c];
     readonly parameter: string;
     readonly value: unknown;
     constructor({ parameter, value, message, }: {
@@ -2343,7 +4311,85 @@ declare class InvalidArgumentError extends AISDKError {
     static isInstance(error: unknown): error is InvalidArgumentError;
 }
 
-declare const symbol$8: unique symbol;
+type SingleRequestTextStreamPart<TOOLS extends ToolSet> = {
+    type: 'text-delta';
+    textDelta: string;
+} | {
+    type: 'reasoning';
+    textDelta: string;
+} | {
+    type: 'reasoning-signature';
+    signature: string;
+} | {
+    type: 'redacted-reasoning';
+    data: string;
+} | ({
+    type: 'file';
+} & GeneratedFile) | {
+    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: 'response-metadata';
+    id?: string;
+    timestamp?: Date;
+    modelId?: string;
+} | {
+    type: 'finish';
+    finishReason: FinishReason;
+    logprobs?: LogProbs;
+    usage: LanguageModelUsage;
+    experimental_providerMetadata?: ProviderMetadata;
+} | {
+    type: 'error';
+    error: unknown;
+};
+
+declare const symbol$b: unique symbol;
+declare class InvalidStreamPartError extends AISDKError {
+    private readonly [symbol$b];
+    readonly chunk: SingleRequestTextStreamPart<any>;
+    constructor({ chunk, message, }: {
+        chunk: SingleRequestTextStreamPart<any>;
+        message: string;
+    });
+    static isInstance(error: unknown): error is InvalidStreamPartError;
+}
+
+declare const symbol$a: unique symbol;
+/**
+Thrown when no image could be generated. This can have multiple causes:
+
+- The model failed to generate a response.
+- The model generated a response that could not be parsed.
+ */
+declare class NoImageGeneratedError extends AISDKError {
+    private readonly [symbol$a];
+    /**
+  The response metadata for each call.
+     */
+    readonly responses: Array<ImageModelResponseMetadata> | undefined;
+    constructor({ message, cause, responses, }: {
+        message?: string;
+        cause?: Error;
+        responses?: Array<ImageModelResponseMetadata>;
+    });
+    static isInstance(error: unknown): error is NoImageGeneratedError;
+}
+
+declare const symbol$9: unique symbol;
 /**
 Thrown when no object could be generated. This can have several causes:
 
@@ -2356,7 +4402,7 @@ The error contains the following properties:
 - `text`: The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
  */
 declare class NoObjectGeneratedError extends AISDKError {
-    private readonly [symbol$8];
+    private readonly [symbol$9];
     /**
     The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
      */
@@ -2369,31 +4415,36 @@ declare class NoObjectGeneratedError extends AISDKError {
     The usage of the model.
      */
     readonly usage: LanguageModelUsage | undefined;
-    constructor({ message, cause, text, response, usage, }: {
+    /**
+    Reason why the model finished generating a response.
+     */
+    readonly finishReason: FinishReason | undefined;
+    constructor({ message, cause, text, response, usage, finishReason, }: {
         message?: string;
         cause?: Error;
         text?: string;
         response: LanguageModelResponseMetadata;
         usage: LanguageModelUsage;
+        finishReason: FinishReason;
     });
     static isInstance(error: unknown): error is NoObjectGeneratedError;
 }
 
-declare const symbol$7: unique symbol;
+declare const symbol$8: unique symbol;
 /**
 Thrown when no output type is specified and output-related methods are called.
  */
 declare class NoOutputSpecifiedError extends AISDKError {
-    private readonly [symbol$7];
+    private readonly [symbol$8];
     constructor({ message }?: {
         message?: string;
     });
     static isInstance(error: unknown): error is NoOutputSpecifiedError;
 }
 
-declare const symbol$6: unique symbol;
+declare const symbol$7: unique symbol;
 declare class ToolCallRepairError extends AISDKError {
-    private readonly [symbol$6];
+    private readonly [symbol$7];
     readonly originalError: NoSuchToolError | InvalidToolArgumentsError;
     constructor({ cause, originalError, message, }: {
         message?: string;
@@ -2403,9 +4454,9 @@ declare class ToolCallRepairError extends AISDKError {
     static isInstance(error: unknown): error is ToolCallRepairError;
 }
 
-declare const symbol$5: unique symbol;
+declare const symbol$6: unique symbol;
 declare class ToolExecutionError extends AISDKError {
-    private readonly [symbol$5];
+    private readonly [symbol$6];
     readonly toolName: string;
     readonly toolArgs: JSONValue;
     readonly toolCallId: string;
@@ -2419,6 +4470,20 @@ declare class ToolExecutionError extends AISDKError {
     static isInstance(error: unknown): error is ToolExecutionError;
 }
 
+declare const symbol$5: unique symbol;
+/**
+ * An error occurred with the MCP client.
+ */
+declare class MCPClientError extends AISDKError {
+    private readonly [symbol$5];
+    constructor({ name, message, cause, }: {
+        name?: string;
+        message: string;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is MCPClientError;
+}
+
 declare const symbol$4: unique symbol;
 declare class InvalidDataContentError extends AISDKError {
     private readonly [symbol$4];
@@ -2445,9 +4510,9 @@ declare class InvalidMessageRoleError extends AISDKError {
 declare const symbol$2: unique symbol;
 declare class MessageConversionError extends AISDKError {
     private readonly [symbol$2];
-    readonly originalMessage: UIMessage;
+    readonly originalMessage: Omit<Message, 'id'>;
     constructor({ originalMessage, message, }: {
-        originalMessage: UIMessage;
+        originalMessage: Omit<Message, 'id'>;
         message: string;
     });
     static isInstance(error: unknown): error is MessageConversionError;
@@ -2617,4 +4682,4 @@ declare namespace llamaindexAdapter {
   };
 }
 
-export { AssistantContent, AssistantResponse, CallWarning, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, ToolCallUnion as CoreToolCallUnion, CoreToolChoice, CoreToolMessage, ToolResultUnion as CoreToolResultUnion, CoreUserMessage, DataContent, DataStreamWriter, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedImage as Experimental_GeneratedImage, Experimental_LanguageModelV1Middleware, FilePart, FinishReason, GenerateObjectResult, GenerateTextResult, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidToolArgumentsError, langchainAdapter as LangChainAdapter, LanguageModel, LanguageModelRequestMetadata, LanguageModelResponseMetadata, LanguageModelUsage, llamaindexAdapter as LlamaIndexAdapter, LogProbs, MessageConversionError, NoObjectGeneratedError, NoOutputSpecifiedError, NoSuchProviderError, NoSuchToolError, ObjectStreamPart, output as Output, Provider, ProviderMetadata, RetryError, StepResult, StreamData, StreamObjectResult, StreamTextResult, TextPart, TextStreamPart, ToolCallPart, ToolCallRepairError, ToolCallRepairFunction, ToolContent, ToolExecutionError, ToolExecutionOptions, ToolResultPart, UserContent, convertToCoreMessages, cosineSimilarity, createDataStream, createDataStreamResponse, embed, embedMany, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, experimental_wrapLanguageModel, generateObject, generateText, pipeDataStreamToResponse, simulateReadableStream, smoothStream, streamObject, streamText, tool };
+export { AssistantContent, AssistantResponse, CallWarning, ChunkDetector, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolCallUnion, CoreToolChoice, CoreToolMessage, CoreToolResultUnion, CoreUserMessage, DataContent, DataStreamOptions, DataStreamWriter, DownloadError, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, EmbeddingModelUsage, GenerateImageResult as Experimental_GenerateImageResult, GeneratedFile as Experimental_GeneratedImage, Experimental_LanguageModelV1Middleware, SpeechResult as Experimental_SpeechResult, TranscriptionResult as Experimental_TranscriptionResult, FilePart, FinishReason, GenerateObjectResult, GenerateTextOnStepFinishCallback, GenerateTextResult, GeneratedAudioFile, GeneratedFile, ImageModel, ImageGenerationWarning as ImageModelCallWarning, ImageModelResponseMetadata, ImagePart, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidStreamPartError, InvalidToolArgumentsError, JSONRPCError, JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse, 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, ProviderRegistryProvider, RepairTextFunction, RetryError, SpeechModel, SpeechModelResponseMetadata, SpeechWarning, 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, TranscriptionModel, TranscriptionModelResponseMetadata, TranscriptionWarning, UserContent, appendClientMessage, appendResponseMessages, convertToCoreMessages, coreAssistantMessageSchema, coreMessageSchema, coreSystemMessageSchema, coreToolMessageSchema, coreUserMessageSchema, cosineSimilarity, createDataStream, createDataStreamResponse, createProviderRegistry, customProvider, defaultSettingsMiddleware, embed, embedMany, createMCPClient as experimental_createMCPClient, experimental_createProviderRegistry, experimental_customProvider, generateImage as experimental_generateImage, generateSpeech as experimental_generateSpeech, transcribe as experimental_transcribe, experimental_wrapLanguageModel, extractReasoningMiddleware, generateObject, generateText, pipeDataStreamToResponse, simulateReadableStream, simulateStreamingMiddleware, smoothStream, streamObject, streamText, tool, wrapLanguageModel };