ai 0.0.0-85f9a635-20240518005312 → 0.0.0-8777c42a-20250115032312

package/dist/index.d.ts

@@ -1,9 +1,84 @@
-import { EmbeddingModelV1, EmbeddingModelV1Embedding, LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1LogProbs, LanguageModelV1CallWarning } from '@ai-sdk/provider';
-export { APICallError, EmptyResponseBodyError, InvalidArgumentError, InvalidDataContentError, InvalidPromptError, InvalidResponseDataError, InvalidToolArgumentsError, JSONParseError, LoadAPIKeyError, NoObjectGeneratedError, NoSuchToolError, RetryError, ToolCallParseError, TypeValidationError, UnsupportedFunctionalityError, UnsupportedJSONSchemaError } from '@ai-sdk/provider';
-import { z } from 'zod';
+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';
+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 { AssistantStream } from 'openai/lib/AssistantStream';
-import { Run } from 'openai/resources/beta/threads/runs/runs';
+import { AttributeValue, Tracer } from '@opentelemetry/api';
+import { z } from 'zod';
+import { ServerResponse as ServerResponse$1 } from 'http';
+
+interface DataStreamWriter {
+    /**
+     * Appends a data part to the stream.
+     */
+    writeData(value: JSONValue): void;
+    /**
+     * Appends a message annotation to the stream.
+     */
+    writeMessageAnnotation(value: JSONValue): void;
+    /**
+     * Merges the contents of another stream to this stream.
+     */
+    merge(stream: ReadableStream<DataStreamString>): void;
+    /**
+     * Error handler that is used by the data stream writer.
+     * This is intended for forwarding when merging streams
+     * to prevent duplicated error masking.
+     */
+    onError: ((error: unknown) => string) | undefined;
+}
+
+declare function createDataStream({ execute, onError, }: {
+    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): ReadableStream<DataStreamString>;
+
+declare function createDataStreamResponse({ status, statusText, headers, execute, onError, }: ResponseInit & {
+    execute: (dataStream: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): Response;
+
+declare function pipeDataStreamToResponse(response: ServerResponse, { status, statusText, headers, execute, onError, }: ResponseInit & {
+    execute: (writer: DataStreamWriter) => Promise<void> | void;
+    onError?: (error: unknown) => string;
+}): void;
+
+/**
+ * Telemetry configuration.
+ */
+type TelemetrySettings = {
+    /**
+     * Enable or disable telemetry. Disabled by default while experimental.
+     */
+    isEnabled?: boolean;
+    /**
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
+    /**
+     * Additional information to include in the telemetry data.
+     */
+    metadata?: Record<string, AttributeValue>;
+    /**
+     * A custom tracer to use for the telemetry data.
+     */
+    tracer?: Tracer;
+};
 
 /**
 Embedding model that is used by the AI SDK Core functions.
@@ -14,6 +89,16 @@ Embedding.
  */
 type Embedding = EmbeddingModelV1Embedding;
 
+/**
+Image model that is used by the AI SDK Core functions.
+  */
+type ImageModel = ImageModelV1;
+/**
+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 ImageGenerationWarning = ImageModelV1CallWarning;
+
 /**
 Language model that is used by the AI SDK Core functions.
 */
@@ -32,6 +117,8 @@ Can be one of the following:
 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;
 /**
@@ -39,6 +126,134 @@ 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 LanguageModelRequestMetadata = {
+    /**
+    Raw request HTTP body that was sent to the provider API as a string (JSON should be stringified).
+       */
+    body?: string;
+};
+
+type LanguageModelResponseMetadata = {
+    /**
+    ID for the generated response.
+       */
+    id: string;
+    /**
+    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>;
+};
+
+/**
+ * Provider for language and text embedding models.
+ */
+type Provider = {
+    /**
+    Returns the language 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 {LanguageModel} The language model associated with the id
+  
+    @throws {NoSuchModelError} If no such model exists.
+       */
+    languageModel(modelId: string): LanguageModel;
+    /**
+    Returns the text embedding 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 {LanguageModel} The language model associated with the id
+  
+    @throws {NoSuchModelError} If no such model exists.
+       */
+    textEmbeddingModel(modelId: string): EmbeddingModel<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.
+ */
+type ProviderMetadata = LanguageModelV1ProviderMetadata;
+
+/**
+Represents the number of tokens used in a prompt and completion.
+ */
+type LanguageModelUsage = {
+    /**
+  The number of tokens used in the prompt.
+     */
+    promptTokens: number;
+    /**
+  The number of tokens used in the completion.
+   */
+    completionTokens: number;
+    /**
+  The total number of tokens used (promptTokens + completionTokens).
+     */
+    totalTokens: number;
+};
+/**
+Represents the number of tokens used in an embedding.
+ */
+type EmbeddingModelUsage = {
+    /**
+  The number of tokens used in the embedding.
+     */
+    tokens: number;
+};
+
+/**
+The result of an `embed` call.
+It contains the embedding, the value, and additional information.
+ */
+interface EmbedResult<VALUE> {
+    /**
+    The value that was embedded.
+       */
+    readonly value: VALUE;
+    /**
+    The embedding of the value.
+      */
+    readonly embedding: Embedding;
+    /**
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingModelUsage;
+    /**
+    Optional raw response data.
+       */
+    readonly rawResponse?: {
+        /**
+      Response headers.
+           */
+        headers?: Record<string, string>;
+    };
+}
 
 /**
 Embed a value using an embedding model. The type of the value is defined by the embedding model.
@@ -48,10 +263,11 @@ Embed a value using an embedding model. The type of the value is defined by the
 
 @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 @param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
 
 @returns A result object that contains the embedding, the value, and additional information.
  */
-declare function embed<VALUE>({ model, value, maxRetries, abortSignal, }: {
+declare function embed<VALUE>({ model, value, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
   The embedding model to use.
        */
@@ -70,36 +286,34 @@ declare function embed<VALUE>({ model, value, maxRetries, abortSignal, }: {
   Abort signal.
    */
     abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
 }): Promise<EmbedResult<VALUE>>;
+
 /**
-The result of a `embed` call.
-It contains the embedding, the value, and additional information.
+The result of a `embedMany` call.
+It contains the embeddings, the values, and additional information.
  */
-declare class EmbedResult<VALUE> {
+interface EmbedManyResult<VALUE> {
     /**
-  The value that was embedded.
-     */
-    readonly value: VALUE;
+    The values that were embedded.
+       */
+    readonly values: Array<VALUE>;
     /**
-  The embedding of the value.
-    */
-    readonly embedding: Embedding;
+    The embeddings. They are in the same order as the values.
+      */
+    readonly embeddings: Array<Embedding>;
     /**
-  Optional raw response data.
-     */
-    readonly rawResponse?: {
-        /**
-    Response headers.
-         */
-        headers?: Record<string, string>;
-    };
-    constructor(options: {
-        value: VALUE;
-        embedding: Embedding;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-    });
+    The embedding token usage.
+      */
+    readonly usage: EmbeddingModelUsage;
 }
 
 /**
@@ -114,10 +328,11 @@ has a limit on how many embeddings can be generated in a single call.
 
 @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 @param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
 
 @returns A result object that contains the embeddings, the value, and additional information.
  */
-declare function embedMany<VALUE>({ model, values, maxRetries, abortSignal, }: {
+declare function embedMany<VALUE>({ model, values, maxRetries: maxRetriesArg, abortSignal, headers, experimental_telemetry: telemetry, }: {
     /**
   The embedding model to use.
        */
@@ -136,31 +351,119 @@ declare function embedMany<VALUE>({ model, values, maxRetries, abortSignal, }: {
   Abort signal.
    */
     abortSignal?: AbortSignal;
+    /**
+  Additional headers to include in the request.
+  Only applicable for HTTP-based providers.
+   */
+    headers?: Record<string, string>;
+    /**
+     * Optional telemetry configuration (experimental).
+     */
+    experimental_telemetry?: TelemetrySettings;
 }): Promise<EmbedManyResult<VALUE>>;
+
 /**
-The result of a `embedMany` call.
-It contains the embeddings, the values, and additional information.
+The result of a `generateImage` call.
+It contains the images and additional information.
  */
-declare class EmbedManyResult<VALUE> {
+interface GenerateImageResult {
     /**
-  The values that were embedded.
+  The first image that was generated.
      */
-    readonly values: Array<VALUE>;
+    readonly image: GeneratedImage;
     /**
-  The embeddings. They are in the same order as the values.
-    */
-    readonly embeddings: Array<Embedding>;
-    constructor(options: {
-        values: Array<VALUE>;
-        embeddings: Array<Embedding>;
-    });
+  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;
 }
 
-type TokenUsage = {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-};
+/**
+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 = {
     /**
@@ -186,13 +489,18 @@ type CallSettings = {
      */
     topP?: number;
     /**
+  Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
+     */
+    topK?: number;
+    /**
   Presence penalty setting. It affects the likelihood of the model to
   repeat information that is already in the prompt.
   
   The presence penalty is a number between -1 (increase repetition)
   and 1 (maximum penalty, decrease repetition). 0 means no penalty.
-  
-  @default 0
      */
     presencePenalty?: number;
     /**
@@ -201,11 +509,15 @@ type CallSettings = {
   
   The frequency penalty is a number between -1 (increase repetition)
   and 1 (maximum penalty, decrease repetition). 0 means no penalty.
-  
-  @default 0
      */
     frequencyPenalty?: number;
     /**
+  Stop sequences.
+  If set, the model will stop generating text when one of the stop sequences is generated.
+  Providers may have limits on the number of stop sequences.
+     */
+    stopSequences?: string[];
+    /**
   The seed (integer) to use for random sampling. If set and supported
   by the model, calls will generate deterministic results.
      */
@@ -220,36 +532,42 @@ type CallSettings = {
   Abort signal.
      */
     abortSignal?: AbortSignal;
+    /**
+  Additional HTTP headers to be sent with the request.
+  Only applicable for HTTP-based providers.
+     */
+    headers?: Record<string, string | undefined>;
 };
 
 /**
 Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
  */
 type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
-/**
-Converts data content to a base64-encoded string.
-
-@param content - Data content to convert.
-@returns Base64-encoded string.
-*/
-declare function convertDataContentToBase64String(content: DataContent): string;
-/**
-Converts data content to a Uint8Array.
 
-@param content - Data content to convert.
-@returns Uint8Array.
- */
-declare function convertDataContentToUint8Array(content: DataContent): Uint8Array;
+type ToolResultContent = Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType?: string;
+}>;
 
 /**
 Text content part of a prompt. It contains a string of text.
  */
-interface TextPart$1 {
+interface TextPart {
     type: 'text';
     /**
   The text content.
      */
     text: 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.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Image content part of a prompt. It contains an image.
@@ -267,6 +585,35 @@ interface ImagePart {
   Optional mime type of the image.
      */
     mimeType?: 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.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
+}
+/**
+File content part of a prompt. It contains a file.
+ */
+interface FilePart {
+    type: 'file';
+    /**
+  File data. Can either be:
+  
+  - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+  - URL: a URL that points to the image
+     */
+    data: DataContent | URL;
+    /**
+  Mime type of the file.
+     */
+    mimeType: 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.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
@@ -285,6 +632,12 @@ interface ToolCallPart {
   Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
      */
     args: unknown;
+    /**
+  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;
 }
 /**
 Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
@@ -304,16 +657,21 @@ interface ToolResultPart {
      */
     result: unknown;
     /**
+  Multi-part content of the tool result. Only for tools that support multipart results.
+     */
+    experimental_content?: ToolResultContent;
+    /**
   Optional flag if the result is an error or an error message.
      */
     isError?: boolean;
+    /**
+  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;
 }
 
-/**
-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;
 /**
  A system message. It can contain system information.
 
@@ -324,59 +682,80 @@ type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage |
 type CoreSystemMessage = {
     role: 'system';
     content: 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.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 };
-/**
- * @deprecated Use `CoreMessage` instead.
- */
-type ExperimentalMessage = CoreMessage;
 /**
 A user message. It can contain text or a combination of text and images.
  */
 type CoreUserMessage = {
     role: 'user';
     content: UserContent;
+    /**
+  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 `CoreUserMessage` instead.
- */
-type ExperimentalUserMessage = CoreUserMessage;
 /**
 Content of a user message. It can be a string or an array of text and image parts.
  */
-type UserContent = string | Array<TextPart$1 | ImagePart>;
+type UserContent = string | Array<TextPart | ImagePart | FilePart>;
 /**
 An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
  */
 type CoreAssistantMessage = {
     role: 'assistant';
     content: AssistantContent;
+    /**
+  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 `CoreAssistantMessage` instead.
- */
-type ExperimentalAssistantMessage = CoreAssistantMessage;
 /**
 Content of an assistant message. It can be a string or an array of text and tool call parts.
  */
-type AssistantContent = string | Array<TextPart$1 | ToolCallPart>;
+type AssistantContent = string | Array<TextPart | ToolCallPart>;
 /**
 A tool message. It contains the result of one or more tool calls.
  */
 type CoreToolMessage = {
     role: 'tool';
     content: ToolContent;
-};
-/**
- * @deprecated Use `CoreToolMessage` instead.
- */
-type ExperimentalToolMessage = CoreToolMessage;
+    /**
+  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;
+};
 /**
 Content of a tool message. It is an array of tool result parts.
  */
 type ToolContent = Array<ToolResultPart>;
+/**
+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[];
+};
 
 /**
-Prompt part of the AI function options. It contains a system message, a simple text prompt, or a list of messages.
+Prompt part of the AI function options.
+It contains a system message, a simple text prompt, or a list of messages.
  */
 type Prompt = {
     /**
@@ -388,291 +767,650 @@ type Prompt = {
    */
     prompt?: string;
     /**
-  A list of messsages. You can either use `prompt` or `messages` but not both.
+  A list of messages. You can either use `prompt` or `messages` but not both.
      */
-    messages?: Array<CoreMessage>;
+    messages?: Array<CoreMessage> | Array<UIMessage>;
 };
 
+/**
+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;
+    /**
+   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 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;
+}
+
 /**
 Generate a structured, typed object for a given prompt and schema using a language model.
 
 This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-@param model - The language model to use.
-
-@param schema - The schema of the object that the model should generate.
-@param mode - The mode to use for object generation. Not all models support all modes. Defaults to 'auto'.
-
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
-
-@param maxTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
-
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-
 @returns
 A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-declare function generateObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+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<T>;
+   */
+    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 Zod schema is converted in a JSON schema and used in one of the following ways
+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 is provided and the provider is instructed to use it.
-- 'json': The JSON schema and a instruction is injected into the prompt. If the provider supports JSON mode, it is enabled.
-- 'grammar': The provider is instructed to converted the JSON schema into a provider specific grammar and use it to select the output tokens.
+- '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' | 'grammar';
-}): Promise<GenerateObjectResult<T>>;
-/**
-The result of a `generateObject` call.
- */
-declare class GenerateObjectResult<T> {
-    /**
-  The generated object (typed according to the schema).
-     */
-    readonly object: T;
-    /**
-  The reason why the generation finished.
-     */
-    readonly finishReason: FinishReason;
+   */
+    mode?: 'auto' | 'json' | 'tool';
     /**
-  The token usage of the generated text.
+Optional telemetry configuration (experimental).
      */
-    readonly usage: TokenUsage;
+    experimental_telemetry?: TelemetrySettings;
     /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | 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;
     /**
-  Optional raw response data.
-     */
-    rawResponse?: {
-        /**
-    Response headers.
+     * Internal. For test use only. May change without notice.
      */
-        headers?: Record<string, string>;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
     };
-    /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled
-     */
-    readonly logprobs: LogProbs | undefined;
-    constructor(options: {
-        object: T;
-        finishReason: FinishReason;
-        usage: TokenUsage;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-        logprobs: LogProbs | undefined;
-    });
-}
+}): Promise<GenerateObjectResult<OBJECT>>;
 /**
- * @deprecated Use `generateObject` instead.
- */
-declare const experimental_generateObject: typeof generateObject;
-
-type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+Generate an array with structured, typed elements for a given prompt and element schema using a language model.
 
-/**
-Create a type from an object with all keys and nested keys set to optional.
-The helper supports normal objects and Zod schemas (which are resolved automatically).
-It always recurses into arrays.
+This function does not stream the output. If you want to stream the output, use `streamObject` instead.
 
-Adopted from [type-fest](https://github.com/sindresorhus/type-fest/tree/main) PartialDeep.
+@return
+A result object that contains the generated object, the finish reason, the token usage, and additional information.
  */
-type DeepPartial<T> = T extends null | undefined | string | number | boolean | symbol | bigint | void | Date | RegExp | ((...arguments_: any[]) => unknown) | (new (...arguments_: any[]) => unknown) ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMap<KeyType, ValueType> : T extends Set<infer ItemType> ? PartialSet<ItemType> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMap<KeyType, ValueType> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySet<ItemType> : T extends z.Schema<any> ? DeepPartial<T['_type']> : T extends object ? T extends ReadonlyArray<infer ItemType> ? ItemType[] extends T ? readonly ItemType[] extends T ? ReadonlyArray<DeepPartial<ItemType | undefined>> : Array<DeepPartial<ItemType | undefined>> : PartialObject<T> : PartialObject<T> : unknown;
-type PartialMap<KeyType, ValueType> = {} & Map<DeepPartial<KeyType>, DeepPartial<ValueType>>;
-type PartialSet<T> = {} & Set<DeepPartial<T>>;
-type PartialReadonlyMap<KeyType, ValueType> = {} & ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>>;
-type PartialReadonlySet<T> = {} & ReadonlySet<DeepPartial<T>>;
-type PartialObject<ObjectType extends object> = {
-    [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;
-};
-
-/**
-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.
+declare function generateObject<ELEMENT>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'array';
+    /**
+The language model to use.
+   */
+    model: LanguageModel;
+    /**
+The element schema of the array that the model should generate.
+*/
+    schema: z.Schema<ELEMENT, z.ZodTypeDef, any> | Schema<ELEMENT>;
+    /**
+Optional name of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema name.
+   */
+    schemaName?: string;
+    /**
+Optional description of the array that should be generated.
+Used by some providers for additional LLM guidance, e.g.
+via tool or schema description.
+*/
+    schemaDescription?: string;
+    /**
+The mode to use for object generation.
 
-@param model - The language model to use.
+The schema is converted into a JSON schema and used in one of the following ways
 
-@param schema - The schema of the object that the model should generate.
-@param mode - The mode to use for object generation. Not all models support all modes. Defaults to 'auto'.
+- 'auto': The provider will choose the best mode for the model.
+- 'tool': A tool with the JSON schema as parameters is provided and the provider is instructed to use it.
+- 'json': The JSON schema and an instruction are injected into the prompt. If the provider supports JSON mode, it is enabled. If the provider supports JSON grammars, the grammar is used.
 
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
+Please note that most providers do not support all modes.
 
-@param maxTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
+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.
 
-@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.
+This function does not stream the output.
 
 @return
-A result object for accessing the partial object stream and additional information.
+A result object that contains the generated value, the finish reason, the token usage, and additional information.
  */
-declare function streamObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+declare function generateObject<ENUM extends string>(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'enum';
     /**
 The language model to use.
-     */
+   */
     model: LanguageModel;
     /**
-The schema of the object that the model should generate.
- */
-    schema: z.Schema<T>;
+The enum values that the model should use.
+   */
+    enum: Array<ENUM>;
     /**
 The mode to use for object generation.
 
-The Zod schema is converted in a JSON schema and used in one of the following ways
+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 is provided and the provider is instructed to use it.
-- 'json': The JSON schema and a instruction is injected into the prompt. If the provider supports JSON mode, it is enabled.
-- 'grammar': The provider is instructed to converted the JSON schema into a provider specific grammar and use it to select the output tokens.
+- '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;
+    /**
+     * Internal. For test use only. May change without notice.
      */
-    mode?: 'auto' | 'json' | 'tool' | 'grammar';
-}): Promise<StreamObjectResult<T>>;
-type ObjectStreamPartInput = {
-    type: 'error';
-    error: unknown;
-} | {
-    type: 'finish';
-    finishReason: FinishReason;
-    logprobs?: LogProbs;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
     };
-};
-type ObjectStreamPart<T> = ObjectStreamPartInput | {
-    type: 'object';
-    object: DeepPartial<T>;
-};
+}): Promise<GenerateObjectResult<ENUM>>;
 /**
-The result of a `streamObject` call that contains the partial object stream and additional information.
+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 class StreamObjectResult<T> {
-    private readonly originalStream;
+declare function generateObject(options: Omit<CallSettings, 'stopSequences'> & Prompt & {
+    output: 'no-schema';
     /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
-    readonly warnings: CallWarning[] | undefined;
+The language model to use.
+   */
+    model: LanguageModel;
     /**
-  Optional raw response data.
+The mode to use for object generation. Must be "json" for no-schema output.
+   */
+    mode?: 'json';
+    /**
+Optional telemetry configuration (experimental).
      */
-    rawResponse?: {
-        /**
-    Response headers.
+    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.
      */
-        headers?: Record<string, string>;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
     };
-    constructor({ stream, warnings, rawResponse, }: {
-        stream: ReadableStream<string | ObjectStreamPartInput>;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-    });
-    get partialObjectStream(): AsyncIterableStream<DeepPartial<T>>;
-    get fullStream(): AsyncIterableStream<ObjectStreamPart<T>>;
-}
-/**
- * @deprecated Use `streamObject` instead.
- */
-declare const experimental_streamObject: typeof streamObject;
+}): Promise<GenerateObjectResult<JSONValue>>;
 
-/**
-A tool contains the description and the schema of the input that the tool expects.
-This enables the language model to generate the input.
+type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
 
-The tool can also contain an optional execute function for the actual execution function of the tool.
+/**
+The result of a `streamObject` call that contains the partial object stream and additional information.
  */
-interface CoreTool<PARAMETERS extends z.ZodTypeAny = any, RESULT = any> {
+interface StreamObjectResult<PARTIAL, RESULT, ELEMENT_STREAM> {
     /**
-  An optional description of what the tool does. Will be used by the language model to decide whether to use the tool.
-     */
-    description?: string;
+    Warnings from the model provider (e.g. unsupported settings)
+       */
+    readonly warnings: Promise<CallWarning[] | undefined>;
     /**
-  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.
+    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.
      */
-    parameters: PARAMETERS;
+    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-  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.
+  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`.
      */
-    execute?: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+    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;
 }
-/**
-Helper function for inferring the execute args of a tool.
- */
-declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
-}): CoreTool<PARAMETERS, RESULT> & {
-    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
-};
-declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: CoreTool<PARAMETERS, RESULT> & {
-    execute?: undefined;
-}): CoreTool<PARAMETERS, RESULT> & {
-    execute: undefined;
+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;
+    /**
+  Warnings from the model provider (e.g. unsupported settings).
+  */
+    warnings?: CallWarning[];
+    /**
+  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;
+    /**
+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;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: OnFinishCallback<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 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;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: OnFinishCallback<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 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;
+    /**
+Callback that is called when the LLM response and the final object validation are finished.
+   */
+    onFinish?: OnFinishCallback<JSONValue>;
+    /**
+     * Internal. For test use only. May change without notice.
+     */
+    _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 {
+    /**
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+     */
+    toolCallId: string;
+    /**
+     * Messages that were sent to the language model to initiate the response that contained the tool call.
+     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+     */
+    messages: CoreMessage[];
+    /**
+     * An optional abort signal that indicates that the overall operation should be aborted.
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+A tool contains the description and the schema of the input that the tool expects.
+This enables the language model to generate the input.
+
+The tool can also contain an optional execute function for the actual execution function of the tool.
+ */
+type CoreTool<PARAMETERS extends Parameters = any, RESULT = any> = {
+    /**
+  The schema of the input that the tool expects. The language model will use this to generate the input.
+  It is also used to validate the output of the language model.
+  Use descriptions to make the input understandable for the language model.
+     */
+    parameters: PARAMETERS;
+    /**
+  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
+     */
+    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
+    /**
+  An async function that is called with the arguments from the tool call and produces a result.
+  If not provided, the tool will not be executed automatically.
+  
+  @args is the input of the tool call.
+  @options.abortSignal is a signal that can be used to abort the tool call.
+     */
+    execute?: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+} & ({
+    /**
+Function tool.
+     */
+    type?: undefined | 'function';
+    /**
+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;
+};
+
 /**
- * @deprecated Use `CoreTool` instead.
+Converts an array of messages from useChat into an array of CoreMessages that can be used
+with the AI core functions (e.g. `streamText`).
  */
-type ExperimentalTool = CoreTool;
+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.
@@ -716,56 +1454,16 @@ onlyBar('bar');
 */
 type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
 
-/**
-Typed tool call that is returned by generateText and streamText.
-It contains the tool call ID, the tool name, and the tool arguments.
- */
-interface ToolCall$1<NAME extends string, ARGS> {
-    /**
-  ID of the tool call. This ID is used to match the tool call with the tool result.
-   */
-    toolCallId: string;
-    /**
-  Name of the tool that is being called.
-   */
-    toolName: NAME;
-    /**
-  Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
-     */
-    args: ARGS;
-}
-type ToToolCall<TOOLS extends Record<string, CoreTool>> = ValueOf<{
+type ToolCallUnion<TOOLS extends Record<string, CoreTool>> = ValueOf<{
     [NAME in keyof TOOLS]: {
         type: 'tool-call';
         toolCallId: string;
         toolName: NAME & string;
-        args: z.infer<TOOLS[NAME]['parameters']>;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
     };
 }>;
-type ToToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToToolCall<TOOLS>>;
+type ToolCallArray<TOOLS extends Record<string, CoreTool>> = Array<ToolCallUnion<TOOLS>>;
 
-/**
-Typed tool result that is returned by generateText and streamText.
-It contains the tool call ID, the tool name, the tool arguments, and the tool result.
- */
-interface ToolResult<NAME extends string, ARGS, RESULT> {
-    /**
-  ID of the tool call. This ID is used to match the tool call with the tool result.
-   */
-    toolCallId: string;
-    /**
-  Name of the tool that was called.
-   */
-    toolName: NAME;
-    /**
-  Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
-     */
-    args: ARGS;
-    /**
-  Result of the tool call. This is the result of the tool's execution.
-     */
-    result: RESULT;
-}
 type ToToolsWithExecute<TOOLS extends Record<string, CoreTool>> = {
     [K in keyof TOOLS as TOOLS[K] extends {
         execute: any;
@@ -779,125 +1477,247 @@ type ToToolResultObject<TOOLS extends Record<string, CoreTool>> = ValueOf<{
         type: 'tool-result';
         toolCallId: string;
         toolName: NAME & string;
-        args: z.infer<TOOLS[NAME]['parameters']>;
+        args: inferParameters<TOOLS[NAME]['parameters']>;
         result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
     };
 }>;
-type ToToolResult<TOOLS extends Record<string, CoreTool>> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
-type ToToolResultArray<TOOLS extends Record<string, CoreTool>> = Array<ToToolResult<TOOLS>>;
-
-/**
-Generate a text and call tools for a given prompt using a language model.
-
-This function does not stream the output. If you want to stream the output, use `streamText` instead.
+type ToolResultUnion<TOOLS extends Record<string, CoreTool>> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
+type ToolResultArray<TOOLS extends Record<string, CoreTool>> = Array<ToolResultUnion<TOOLS>>;
 
-@param model - The language model to use.
-@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
-
-@param system - A system message that will be part of the prompt.
-@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
-@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
-
-@param maxTokens - Maximum number of tokens to generate.
-@param temperature - Temperature setting.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param topP - Nucleus sampling.
-The value is passed through to the provider. The range depends on the provider and model.
-It is recommended to set either `temperature` or `topP`, but not both.
-@param presencePenalty - Presence penalty setting.
-It affects the likelihood of the model to repeat information that is already in the prompt.
-The value is passed through to the provider. The range depends on the provider and model.
-@param frequencyPenalty - Frequency penalty setting.
-It affects the likelihood of the model to repeatedly use the same words or phrases.
-The value is passed through to the provider. The range depends on the provider and model.
-@param seed - The seed (integer) to use for random sampling.
-If set and supported by the model, calls will generate deterministic results.
-
-@param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
-@param abortSignal - An optional abort signal that can be used to cancel the call.
-
-@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>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
-    /**
-The language model to use.
-     */
-    model: LanguageModel;
-    /**
-The tools that the model can call. The model needs to support calling tools.
-*/
-    tools?: TOOLS;
-}): Promise<GenerateTextResult<TOOLS>>;
 /**
-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.
+ * The result of a single step in the generation process.
  */
-declare class GenerateTextResult<TOOLS extends Record<string, CoreTool>> {
+type StepResult<TOOLS extends Record<string, CoreTool>> = {
     /**
   The generated text.
-     */
+  */
     readonly text: string;
     /**
   The tool calls that were made during the generation.
-     */
-    readonly toolCalls: ToToolCallArray<TOOLS>;
+  */
+    readonly toolCalls: ToolCallArray<TOOLS>;
     /**
   The results of the tool calls.
-     */
-    readonly toolResults: ToToolResultArray<TOOLS>;
+  */
+    readonly toolResults: ToolResultArray<TOOLS>;
     /**
   The reason why the generation finished.
-     */
+  */
     readonly finishReason: FinishReason;
     /**
   The token usage of the generated text.
-     */
-    readonly usage: TokenUsage;
+  */
+    readonly usage: LanguageModelUsage;
     /**
-  Warnings from the model provider (e.g. unsupported settings)
-     */
+  Warnings from the model provider (e.g. unsupported settings).
+  */
     readonly warnings: CallWarning[] | undefined;
     /**
-  Optional raw response data.
+  Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if was not enabled.
+  */
+    readonly logprobs: LogProbs | undefined;
+    /**
+  Additional request information.
      */
-    rawResponse?: {
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+  */
+    readonly response: LanguageModelResponseMetadata & {
         /**
-    Response headers.
-       */
-        headers?: Record<string, string>;
+    The response messages that were generated during the call. It consists of an assistant message,
+    potentially containing tool calls.
+    */
+        readonly messages: Array<CoreAssistantMessage | CoreToolMessage>;
     };
     /**
-  Logprobs for the completion.
-  `undefined` if the mode does not support logprobs or if was not enabled
+  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 logprobs: LogProbs | undefined;
-    constructor(options: {
-        text: string;
-        toolCalls: ToToolCallArray<TOOLS>;
-        toolResults: ToToolResultArray<TOOLS>;
-        finishReason: FinishReason;
-        usage: TokenUsage;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-        logprobs: LogProbs | undefined;
-    });
-}
+    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;
+};
+
 /**
- * @deprecated Use `generateText` instead.
+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 const experimental_generateText: typeof generateText;
+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>>;
+    /**
+  Additional request information.
+     */
+    readonly request: LanguageModelRequestMetadata;
+    /**
+  Additional response information.
+     */
+    readonly response: LanguageModelResponseMetadata & {
+        /**
+    The response messages that were generated during the call. It consists of an assistant message,
+    potentially containing tool calls.
+    
+    When there are tool results, there is an additional tool message with the tool results that are available.
+    If there are tools that do not have execute functions, they are not included in the tool results and
+    need to be added separately.
+           */
+        messages: Array<CoreAssistantMessage | CoreToolMessage>;
+    };
+    /**
+  Logprobs for the completion.
+  `undefined` if the mode does not support logprobs or if it was not enabled.
+  
+  @deprecated Will become a provider extension in the future.
+       */
+    readonly logprobs: LogProbs | undefined;
+    /**
+  Additional provider-specific metadata. They are passed through
+  from the provider to the AI SDK and enable provider-specific
+  results that can be fully encapsulated in the provider.
+     */
+    readonly experimental_providerMetadata: ProviderMetadata | undefined;
+}
+
+interface Output<OUTPUT, PARTIAL> {
+    readonly type: 'object' | 'text';
+    injectIntoSystemPrompt(options: {
+        system: string | undefined;
+        model: LanguageModel;
+    }): string | undefined;
+    responseFormat: (options: {
+        model: LanguageModel;
+    }) => LanguageModelV1CallOptions['responseFormat'];
+    parsePartial(options: {
+        text: string;
+    }): {
+        partial: PARTIAL;
+    } | undefined;
+    parseOutput(options: {
+        text: string;
+    }, context: {
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+    }): OUTPUT;
+}
+declare const text: () => Output<string, string>;
+declare const object: <OUTPUT>({ schema: inputSchema, }: {
+    schema: z.Schema<OUTPUT, z.ZodTypeDef, any> | Schema<OUTPUT>;
+}) => Output<OUTPUT, DeepPartial<OUTPUT>>;
+
+type output_Output<OUTPUT, PARTIAL> = Output<OUTPUT, PARTIAL>;
+declare const output_object: typeof object;
+declare const output_text: typeof text;
+declare namespace output {
+  export {
+    output_Output as Output,
+    output_object as object,
+    output_text as text,
+  };
+}
+
+declare const symbol$c: unique symbol;
+declare class InvalidToolArgumentsError extends AISDKError {
+    private readonly [symbol$c];
+    readonly toolName: string;
+    readonly toolArgs: string;
+    constructor({ toolArgs, toolName, cause, message, }: {
+        message?: string;
+        toolArgs: string;
+        toolName: string;
+        cause: unknown;
+    });
+    static isInstance(error: unknown): error is InvalidToolArgumentsError;
+}
+
+declare const symbol$b: unique symbol;
+declare class NoSuchToolError extends AISDKError {
+    private readonly [symbol$b];
+    readonly toolName: string;
+    readonly availableTools: string[] | undefined;
+    constructor({ toolName, availableTools, message, }: {
+        toolName: string;
+        availableTools?: string[] | undefined;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchToolError;
+}
+
+/**
+ * A function that attempts to repair a tool call that failed to parse.
+ *
+ * It receives the error and the context as arguments and returns the repair
+ * tool call JSON as text.
+ *
+ * @param options.system - The system prompt.
+ * @param options.messages - The messages in the current generation step.
+ * @param options.toolCall - The tool call that failed to parse.
+ * @param options.tools - The tools that are available.
+ * @param options.parameterSchema - A function that returns the JSON Schema for a tool.
+ * @param options.error - The error that occurred while parsing the tool call.
+ */
+type ToolCallRepairFunction<TOOLS extends Record<string, CoreTool>> = (options: {
+    system: string | undefined;
+    messages: CoreMessage[];
+    toolCall: LanguageModelV1FunctionToolCall;
+    tools: TOOLS;
+    parameterSchema: (options: {
+        toolName: string;
+    }) => JSONSchema7;
+    error: NoSuchToolError | InvalidToolArgumentsError;
+}) => Promise<LanguageModelV1FunctionToolCall | null>;
 
 /**
 Generate a text and call tools for a given prompt using a language model.
 
-This function streams the output. If you do not want to stream the output, use `generateText` instead.
+This function does not stream the output. If you want to stream the output, use `streamText` instead.
 
 @param model - The language model to use.
+
 @param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
+@param toolChoice - The tool choice strategy. Default: 'auto'.
 
 @param system - A system message that will be part of the prompt.
 @param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
@@ -910,1072 +1730,759 @@ It is recommended to set either `temperature` or `topP`, but not both.
 @param topP - Nucleus sampling.
 The value is passed through to the provider. The range depends on the provider and model.
 It is recommended to set either `temperature` or `topP`, but not both.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
 @param presencePenalty - Presence penalty setting.
 It affects the likelihood of the model to repeat information that is already in the prompt.
 The value is passed through to the provider. The range depends on the provider and model.
 @param frequencyPenalty - Frequency penalty setting.
 It affects the likelihood of the model to repeatedly use the same words or phrases.
 The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
 @param seed - The seed (integer) to use for random sampling.
 If set and supported by the model, calls will generate deterministic results.
 
 @param maxRetries - Maximum number of retries. Set to 0 to disable retries. Default: 2.
 @param abortSignal - An optional abort signal that can be used to cancel the call.
+@param headers - Additional HTTP headers to be sent with the request. Only applicable for HTTP-based providers.
 
-@return
-A result object for accessing different stream types and additional information.
+@param maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
+
+@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 streamText<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+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 & {
     /**
 The language model to use.
      */
     model: LanguageModel;
     /**
 The tools that the model can call. The model needs to support calling tools.
-    */
+*/
     tools?: TOOLS;
-}): Promise<StreamTextResult<TOOLS>>;
-declare function streamResponse<TOOLS extends Record<string, CoreTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
     /**
-The language model to use.
+The tool choice strategy. Default: 'auto'.
      */
-    model: LanguageModel;
+    toolChoice?: CoreToolChoice<TOOLS>;
     /**
-The tools that the model can call. The model needs to support calling tools.
-    */
-    tools?: TOOLS;
-}): Promise<{
-    stream: ReadableStream;
-    warnings: LanguageModelV1CallWarning[] | undefined;
-    rawResponse: {
-        headers?: Record<string, string>;
-    } | undefined;
-}>;
-type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
-    type: 'text-delta';
-    textDelta: string;
-} | ({
-    type: 'tool-call';
-} & ToToolCall<TOOLS>) | {
-    type: 'error';
-    error: unknown;
-} | ({
-    type: 'tool-result';
-} & ToToolResult<TOOLS>) | {
-    type: 'finish';
-    finishReason: FinishReason;
-    logprobs?: LogProbs;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-};
-/**
-A result object for accessing different stream types and additional information.
- */
-declare class StreamTextResult<TOOLS extends Record<string, CoreTool>> {
-    private originalStream;
-    /**
-  Warnings from the model provider (e.g. unsupported settings).
-     */
-    readonly warnings: CallWarning[] | undefined;
-    /**
-  The token usage of the generated text. Resolved when the response is finished.
-     */
-    readonly usage: Promise<TokenUsage>;
-    /**
-  The reason why the generation finished. Resolved when the response is finished.
-     */
-    readonly finishReason: Promise<FinishReason>;
-    /**
-  Optional raw response data.
-     */
-    rawResponse?: {
-        /**
-    Response headers.
-         */
-        headers?: Record<string, string>;
-    };
-    constructor({ stream, warnings, rawResponse, }: {
-        stream: ReadableStream<TextStreamPart<TOOLS>>;
-        warnings: CallWarning[] | undefined;
-        rawResponse?: {
-            headers?: Record<string, string>;
-        };
-    });
-    /**
-  Split out a new stream from the original stream.
-  The original stream is replaced to allow for further splitting,
-  since we do not know how many times the stream will be split.
-  
-  Note: this leads to buffering the stream content on the server.
-  However, the LLM results are expected to be small enough to not cause issues.
-     */
-    private teeStream;
-    /**
-  A text stream that returns only the generated text deltas. You can use it
-  as either an AsyncIterable or a ReadableStream. When an error occurs, the
-  stream will throw the error.
-     */
-    get textStream(): AsyncIterableStream<string>;
-    /**
-  A stream with all events, including text deltas, tool calls, tool results, and
-  errors.
-  You can use it as either an AsyncIterable or a ReadableStream. When an error occurs, the
-  stream will throw the error.
-     */
-    get fullStream(): AsyncIterableStream<TextStreamPart<TOOLS>>;
-    /**
-  Converts the result to an `AIStream` object that is compatible with `StreamingTextResponse`.
-  It can be used with the `useChat` and `useCompletion` hooks.
-  
-  @param callbacks
-  Stream callbacks that will be called when the stream emits events.
-  
-  @returns an `AIStream` object.
-     */
-    toAIStream(callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
-    /**
-  Writes stream data output to a Node.js response-like object.
-  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-  writes each stream data part as a separate chunk.
-  
-  @param response A Node.js response-like object (ServerResponse).
-  @param init Optional headers and status code.
-     */
-    pipeAIStreamToResponse(response: ServerResponse, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    /**
-  Writes text delta output to a Node.js response-like object.
-  It sets a `Content-Type` header to `text/plain; charset=utf-8` and
-  writes each text delta as a separate chunk.
-  
-  @param response A Node.js response-like object (ServerResponse).
-  @param init Optional headers and status code.
-     */
-    pipeTextStreamToResponse(response: ServerResponse, init?: {
-        headers?: Record<string, string>;
-        status?: number;
-    }): void;
-    /**
-  Converts the result to a streamed response object with a stream data part stream.
-  It can be used with the `useChat` and `useCompletion` hooks.
-  
-  @param init Optional headers.
-  
-  @return A response object.
-     */
-    toAIStreamResponse(init?: ResponseInit): Response;
-    /**
-  Creates a simple text stream response.
-  Each text delta is encoded as UTF-8 and sent as a separate chunk.
-  Non-text-delta events are ignored.
-  
-  @param init Optional headers and status code.
-     */
-    toTextStreamResponse(init?: ResponseInit): Response;
-}
-/**
- * @deprecated Use `streamText` instead.
- */
-declare const experimental_streamText: typeof streamText;
+Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
 
-/**
-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(messages: Array<{
-    role: 'user' | 'assistant';
-    content: string;
-    toolInvocations?: Array<ToolResult<string, unknown, unknown>>;
-}>): CoreMessage[];
+A maximum number is required to prevent infinite loops in the case of misconfigured tools.
 
-type AssistantStatus = 'in_progress' | 'awaiting_message';
-type UseAssistantOptions = {
-    /**
-     * The API endpoint that accepts a `{ threadId: string | null; message: string; }` object and returns an `AssistantResponse` stream.
-     * The threadId refers to an existing thread with messages (or is `null` to create a new thread).
-     * The message is the next message that should be appended to the thread and sent to the assistant.
+By default, it's set to 1, which means that only a single LLM call is made.
      */
-    api: string;
+    maxSteps?: number;
     /**
-     * An optional string that represents the ID of an existing thread.
-     * If not provided, a new thread will be created.
+When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+
+By default, it's set to false.
      */
-    threadId?: string;
+    experimental_continueSteps?: boolean;
     /**
-     * An optional literal that sets the mode of credentials to be used on the request.
-     * Defaults to "same-origin".
+Optional telemetry configuration (experimental).
      */
-    credentials?: RequestCredentials;
+    experimental_telemetry?: TelemetrySettings;
     /**
-     * An optional object of headers to be passed to the API endpoint.
-     */
-    headers?: Record<string, string> | Headers;
+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;
     /**
-     * An optional, additional body object to be passed to the API endpoint.
+Limits the tools that are available for the model to call without
+changing the tool call and result types in the result.
      */
-    body?: object;
+    experimental_activeTools?: Array<keyof TOOLS>;
     /**
-     * An optional callback that will be called when the assistant encounters an error.
+Optional specification for parsing structured outputs from the LLM response.
      */
-    onError?: (error: Error) => void;
-};
-
-interface FunctionCall$1 {
+    experimental_output?: Output<OUTPUT, OUTPUT_PARTIAL>;
     /**
-     * The arguments to call the function with, as generated by the model in JSON
-     * format. Note that the model does not always generate valid JSON, and may
-     * hallucinate parameters not defined by your function schema. Validate the
-     * arguments in your code before calling your function.
+A function that attempts to repair a tool call that failed to parse.
      */
-    arguments?: string;
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
     /**
-     * The name of the function to call.
+    Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: (event: StepResult<TOOLS>) => Promise<void> | void;
+    /**
+     * Internal. For test use only. May change without notice.
      */
-    name?: string;
-}
-/**
- * The tool calls generated by the model, such as function calls.
- */
-interface ToolCall {
-    id: string;
-    type: string;
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-/**
- * Controls which (if any) function is called by the model.
- * - none means the model will not call a function and instead generates a message.
- * - auto means the model can pick between generating a message or calling a function.
- * - Specifying a particular function via {"type: "function", "function": {"name": "my_function"}} forces the model to call that function.
- * none is the default when no functions are present. auto is the default if functions are present.
- */
-type ToolChoice = 'none' | 'auto' | {
-    type: 'function';
-    function: {
-        name: string;
+    _internal?: {
+        generateId?: () => string;
+        currentDate?: () => Date;
     };
-};
+}): Promise<GenerateTextResult<TOOLS, OUTPUT>>;
+
 /**
- * A list of tools the model may call. Currently, only functions are supported as a tool.
- * Use this to provide a list of functions the model may generate JSON inputs for.
+ * A stream wrapper to send custom JSON-encoded data back to the client.
+ *
+ * @deprecated Please use `createDataStream`, `createDataStreamResponse`, and `pipeDataStreamToResponse` instead.
  */
-interface Tool {
-    type: 'function';
-    function: Function;
-}
-interface Function {
-    /**
-     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
-     * underscores and dashes, with a maximum length of 64.
-     */
-    name: string;
-    /**
-     * The parameters the functions accepts, described as a JSON Schema object. See the
-     * [guide](/docs/guides/gpt/function-calling) for examples, and the
-     * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
-     * documentation about the format.
-     *
-     * To describe a function that accepts no parameters, provide the value
-     * `{"type": "object", "properties": {}}`.
-     */
-    parameters: Record<string, unknown>;
-    /**
-     * A description of what the function does, used by the model to choose when and
-     * how to call the function.
-     */
-    description?: string;
+declare class StreamData {
+    private encoder;
+    private controller;
+    stream: ReadableStream<Uint8Array>;
+    private isClosed;
+    private warningTimeout;
+    constructor();
+    close(): Promise<void>;
+    append(value: JSONValue$1): void;
+    appendMessageAnnotation(value: JSONValue$1): void;
 }
-type IdGenerator = () => string;
-/**
-Tool invocations are either tool calls or tool results. For each assistant tool call,
-there is one tool invocation. While the call is in progress, the invocation is a tool call.
-Once the call is complete, the invocation is a tool result.
- */
-type ToolInvocation = ToolCall$1<string, any> | ToolResult<string, any, any>;
+
 /**
- * Shared types between the API and UI packages.
+A result object for accessing different stream types and additional information.
  */
-interface Message$1 {
-    id: string;
-    tool_call_id?: string;
-    createdAt?: Date;
-    content: string;
-    /**
-  @deprecated Use AI SDK RSC instead: https://sdk.vercel.ai/docs/ai-sdk-rsc
-   */
-    ui?: string | JSX.Element | JSX.Element[] | null | undefined;
-    role: 'system' | 'user' | 'assistant' | 'function' | 'data' | 'tool';
-    /**
-     *
-     * If the message has a role of `function`, the `name` field is the name of the function.
-     * Otherwise, the name field should not be set.
-     */
-    name?: string;
-    /**
-     * If the assistant role makes a function call, the `function_call` field
-     * contains the function call name and arguments. Otherwise, the field should
-     * not be set. (Deprecated and replaced by tool_calls.)
-     */
-    function_call?: string | FunctionCall$1;
-    data?: JSONValue;
-    /**
-     * If the assistant role makes a tool call, the `tool_calls` field contains
-     * the tool call name and arguments. Otherwise, the field should not be set.
-     */
-    tool_calls?: string | ToolCall[];
-    /**
-     * Additional message-specific information added on the server via StreamData
-     */
-    annotations?: JSONValue[] | undefined;
-    /**
-  Tool invocations (that can be tool calls or tool results, depending on whether or not the invocation has finished)
-  that the assistant made as part of this message.
-     */
-    toolInvocations?: Array<ToolInvocation>;
-}
-type CreateMessage = Omit<Message$1, 'id'> & {
-    id?: Message$1['id'];
-};
-type ChatRequest = {
-    messages: Message$1[];
-    options?: RequestOptions;
-    functions?: Array<Function>;
-    function_call?: FunctionCall$1;
-    data?: Record<string, string>;
-    tools?: Array<Tool>;
-    tool_choice?: ToolChoice;
-};
-type FunctionCallHandler = (chatMessages: Message$1[], functionCall: FunctionCall$1) => Promise<ChatRequest | void>;
-type ToolCallHandler = (chatMessages: Message$1[], toolCalls: ToolCall[]) => Promise<ChatRequest | void>;
-type RequestOptions = {
-    headers?: Record<string, string> | Headers;
-    body?: object;
-};
-type ChatRequestOptions = {
-    options?: RequestOptions;
-    functions?: Array<Function>;
-    function_call?: FunctionCall$1;
-    tools?: Array<Tool>;
-    tool_choice?: ToolChoice;
-    data?: Record<string, string>;
-};
-type UseChatOptions = {
-    /**
-     * The API endpoint that accepts a `{ messages: Message[] }` object and returns
-     * a stream of tokens of the AI chat response. Defaults to `/api/chat`.
-     */
-    api?: string;
-    /**
-     * A unique identifier for the chat. If not provided, a random one will be
-     * generated. When provided, the `useChat` hook with the same `id` will
-     * have shared states across components.
-     */
-    id?: string;
+interface StreamTextResult<TOOLS extends Record<string, CoreTool>, PARTIAL_OUTPUT> {
     /**
-     * Initial messages of the chat. Useful to load an existing chat history.
-     */
-    initialMessages?: Message$1[];
-    /**
-     * Initial input of the chat.
-     */
-    initialInput?: string;
-    /**
-     * Callback function to be called when a function call is received.
-     * If the function returns a `ChatRequest` object, the request will be sent
-     * automatically to the API and will be used to update the chat.
-     */
-    experimental_onFunctionCall?: FunctionCallHandler;
-    /**
-     * Callback function to be called when a tool call is received.
-     * If the function returns a `ChatRequest` object, the request will be sent
-     * automatically to the API and will be used to update the chat.
-     */
-    experimental_onToolCall?: ToolCallHandler;
+  Warnings from the model provider (e.g. unsupported settings) for the first step.
+       */
+    readonly warnings: Promise<CallWarning[] | undefined>;
     /**
-     * Callback function to be called when the API response is received.
-     */
-    onResponse?: (response: Response) => void | Promise<void>;
+  The total token usage of the generated response.
+  When there are multiple steps, the usage is the sum of all step usages.
+  
+  Resolved when the response is finished.
+       */
+    readonly usage: Promise<LanguageModelUsage>;
     /**
-     * Callback function to be called when the chat is finished streaming.
-     */
-    onFinish?: (message: Message$1) => void;
+  The reason why the generation finished. Taken from the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly finishReason: Promise<FinishReason>;
     /**
-     * Callback function to be called when an error is encountered.
+  Additional provider-specific metadata from the last step.
+  Metadata is passed through from the provider to the AI SDK and
+  enables provider-specific results that can be fully encapsulated in the provider.
      */
-    onError?: (error: Error) => void;
+    readonly experimental_providerMetadata: Promise<ProviderMetadata | undefined>;
     /**
-     * A way to provide a function that is going to be used for ids for messages.
-     * If not provided nanoid is used by default.
-     */
-    generateId?: IdGenerator;
+  The full text that has been generated by the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly text: Promise<string>;
     /**
-     * The credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
-     */
-    credentials?: RequestCredentials;
+  The tool calls that have been executed in the last step.
+  
+  Resolved when the response is finished.
+       */
+    readonly toolCalls: Promise<ToolCallUnion<TOOLS>[]>;
     /**
-     * HTTP headers to be sent with the API request.
-     */
-    headers?: Record<string, string> | Headers;
+  The tool results that have been generated in the last step.
+  
+  Resolved when the all tool executions are finished.
+       */
+    readonly toolResults: Promise<ToolResultUnion<TOOLS>[]>;
     /**
-     * Extra body object to be sent with the API request.
-     * @example
-     * Send a `sessionId` to the API along with the messages.
-     * ```js
-     * useChat({
-     *   body: {
-     *     sessionId: '123',
-     *   }
-     * })
-     * ```
+  Details for all steps.
+  You can use this to get information about intermediate steps,
+  such as the tool calls or the response headers.
      */
-    body?: object;
+    readonly steps: Promise<Array<StepResult<TOOLS>>>;
     /**
-     * Whether to send extra message fields such as `message.id` and `message.createdAt` to the API.
-     * Defaults to `false`. When set to `true`, the API endpoint might need to
-     * handle the extra fields before forwarding the request to the AI service.
-     */
-    sendExtraMessageFields?: boolean;
-    /** Stream mode (default to "stream-data") */
-    streamMode?: 'stream-data' | 'text';
-};
-type UseCompletionOptions = {
+  Additional request information from the last step.
+   */
+    readonly request: Promise<LanguageModelRequestMetadata>;
     /**
-     * The API endpoint that accepts a `{ prompt: string }` object and returns
-     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
-     */
-    api?: string;
+  Additional response information from the last step.
+   */
+    readonly response: Promise<LanguageModelResponseMetadata & {
+        /**
+  The response messages that were generated during the call. It consists of an assistant message,
+  potentially containing tool calls.
+  
+  When there are tool results, there is an additional tool message with the tool results that are available.
+  If there are tools that do not have execute functions, they are not included in the tool results and
+  need to be added separately.
+         */
+        messages: Array<CoreAssistantMessage | CoreToolMessage>;
+    }>;
     /**
-     * An unique identifier for the chat. If not provided, a random one will be
-     * generated. When provided, the `useChat` hook with the same `id` will
-     * have shared states across components.
-     */
-    id?: string;
+    A text stream that returns only the generated text deltas. You can use it
+    as either an AsyncIterable or a ReadableStream. When an error occurs, the
+    stream will throw the error.
+       */
+    readonly textStream: AsyncIterableStream<string>;
     /**
-     * Initial prompt input of the completion.
-     */
-    initialInput?: string;
+    A stream with all events, including text deltas, tool calls, tool results, and
+    errors.
+    You can use it as either an AsyncIterable or a ReadableStream.
+    Only errors that stop the stream, such as network errors, are thrown.
+       */
+    readonly fullStream: AsyncIterableStream<TextStreamPart<TOOLS>>;
     /**
-     * Initial completion result. Useful to load an existing history.
+  A stream of partial outputs. It uses the `experimental_output` specification.
      */
-    initialCompletion?: string;
+    readonly experimental_partialOutputStream: AsyncIterableStream<PARTIAL_OUTPUT>;
     /**
-     * Callback function to be called when the API response is received.
-     */
-    onResponse?: (response: Response) => void | 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.
+  
+    @return A data stream.
+       */
+    toDataStream(options?: {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+        sendUsage?: boolean;
+    }): ReadableStream<Uint8Array>;
     /**
-     * Callback function to be called when the completion is finished streaming.
+     * Merges the result as a data stream into another data stream.
+     *
+     * @param dataStream A data stream writer.
      */
-    onFinish?: (prompt: string, completion: string) => void;
+    mergeIntoDataStream(dataStream: DataStreamWriter): void;
     /**
-     * Callback function to be called when an error is encountered.
-     */
-    onError?: (error: Error) => void;
+    Writes data stream output to a Node.js response-like object.
+  
+    @param response A Node.js response-like object (ServerResponse).
+    @param options.status The status code.
+    @param options.statusText The status text.
+    @param options.headers The headers.
+    @param options.data The stream data.
+    @param options.getErrorMessage An optional function that converts an error to an error message.
+    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
+       */
+    pipeDataStreamToResponse(response: ServerResponse, options?: ResponseInit & {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+        sendUsage?: boolean;
+    }): void;
     /**
-     * The credentials mode to be used for the fetch request.
-     * Possible values are: 'omit', 'same-origin', 'include'.
-     * Defaults to 'same-origin'.
-     */
-    credentials?: RequestCredentials;
+    Writes text delta output to a Node.js response-like object.
+    It sets a `Content-Type` header to `text/plain; charset=utf-8` and
+    writes each text delta as a separate chunk.
+  
+    @param response A Node.js response-like object (ServerResponse).
+    @param init Optional headers, status code, and status text.
+       */
+    pipeTextStreamToResponse(response: ServerResponse, init?: ResponseInit): void;
     /**
-     * HTTP headers to be sent with the API request.
-     */
-    headers?: Record<string, string> | Headers;
+    Converts the result to a streamed response object with a stream data part stream.
+    It can be used with the `useChat` and `useCompletion` hooks.
+  
+    @param options.status The status code.
+    @param options.statusText The status text.
+    @param options.headers The headers.
+    @param options.data The stream data.
+    @param options.getErrorMessage An optional function that converts an error to an error message.
+    @param options.sendUsage Whether to send the usage information to the client. Defaults to true.
+  
+    @return A response object.
+       */
+    toDataStreamResponse(options?: ResponseInit & {
+        data?: StreamData;
+        getErrorMessage?: (error: unknown) => string;
+        sendUsage?: boolean;
+    }): Response;
     /**
-     * Extra body object to be sent with the API request.
-     * @example
-     * Send a `sessionId` to the API along with the prompt.
-     * ```js
-     * useChat({
-     *   body: {
-     *     sessionId: '123',
-     *   }
-     * })
-     * ```
-     */
-    body?: object;
-    /** Stream mode (default to "stream-data") */
-    streamMode?: 'stream-data' | 'text';
-};
-type JSONValue = null | string | number | boolean | {
-    [x: string]: JSONValue;
-} | Array<JSONValue>;
-type AssistantMessage = {
-    id: string;
-    role: 'assistant';
-    content: Array<{
-        type: 'text';
-        text: {
-            value: string;
-        };
-    }>;
-};
-type DataMessage = {
-    id?: string;
-    role: 'data';
-    data: JSONValue;
-};
-
-interface StreamPart<CODE extends string, NAME extends string, TYPE> {
-    code: CODE;
-    name: NAME;
-    parse: (value: JSONValue) => {
-        type: NAME;
-        value: TYPE;
-    };
+    Creates a simple text stream response.
+    Each text delta is encoded as UTF-8 and sent as a separate chunk.
+    Non-text-delta events are ignored.
+  
+    @param init Optional headers, status code, and status text.
+       */
+    toTextStreamResponse(init?: ResponseInit): Response;
 }
-declare const textStreamPart: StreamPart<'0', 'text', string>;
-declare const functionCallStreamPart: StreamPart<'1', 'function_call', {
-    function_call: FunctionCall$1;
-}>;
-declare const dataStreamPart: StreamPart<'2', 'data', Array<JSONValue>>;
-declare const errorStreamPart: StreamPart<'3', 'error', string>;
-declare const assistantMessageStreamPart: StreamPart<'4', 'assistant_message', AssistantMessage>;
-declare const assistantControlDataStreamPart: StreamPart<'5', 'assistant_control_data', {
-    threadId: string;
-    messageId: string;
-}>;
-declare const dataMessageStreamPart: StreamPart<'6', 'data_message', DataMessage>;
-declare const toolCallsStreamPart: StreamPart<'7', 'tool_calls', {
-    tool_calls: ToolCall[];
-}>;
-declare const messageAnnotationsStreamPart: StreamPart<'8', 'message_annotations', Array<JSONValue>>;
-declare const toolCallStreamPart: StreamPart<'9', 'tool_call', ToolCall$1<string, any>>;
-declare const toolResultStreamPart: StreamPart<'a', 'tool_result', ToolResult<string, any, any>>;
-type StreamParts = typeof textStreamPart | typeof functionCallStreamPart | typeof dataStreamPart | typeof errorStreamPart | typeof assistantMessageStreamPart | typeof assistantControlDataStreamPart | typeof dataMessageStreamPart | typeof toolCallsStreamPart | typeof messageAnnotationsStreamPart | typeof toolCallStreamPart | typeof toolResultStreamPart;
-/**
- * Maps the type of a stream part to its value type.
- */
-type StreamPartValueType = {
-    [P in StreamParts as P['name']]: ReturnType<P['parse']>['value'];
-};
-type StreamPartType = ReturnType<typeof textStreamPart.parse> | ReturnType<typeof functionCallStreamPart.parse> | ReturnType<typeof dataStreamPart.parse> | ReturnType<typeof errorStreamPart.parse> | ReturnType<typeof assistantMessageStreamPart.parse> | ReturnType<typeof assistantControlDataStreamPart.parse> | ReturnType<typeof dataMessageStreamPart.parse> | ReturnType<typeof toolCallsStreamPart.parse> | ReturnType<typeof messageAnnotationsStreamPart.parse> | ReturnType<typeof toolCallStreamPart.parse> | ReturnType<typeof toolResultStreamPart.parse>;
-/**
- * The map of prefixes for data in the stream
- *
- * - 0: Text from the LLM response
- * - 1: (OpenAI) function_call responses
- * - 2: custom JSON added by the user using `Data`
- * - 6: (OpenAI) tool_call responses
- *
- * Example:
- * ```
- * 0:Vercel
- * 0:'s
- * 0: AI
- * 0: AI
- * 0: SDK
- * 0: is great
- * 0:!
- * 2: { "someJson": "value" }
- * 1: {"function_call": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}
- * 6: {"tool_call": {"id": "tool_0", "type": "function", "function": {"name": "get_current_weather", "arguments": "{\\n\\"location\\": \\"Charlottesville, Virginia\\",\\n\\"format\\": \\"celsius\\"\\n}"}}}
- *```
- */
-declare const StreamStringPrefixes: {
-    readonly text: "0";
-    readonly function_call: "1";
-    readonly data: "2";
-    readonly error: "3";
-    readonly assistant_message: "4";
-    readonly assistant_control_data: "5";
-    readonly data_message: "6";
-    readonly tool_calls: "7";
-    readonly message_annotations: "8";
-    readonly tool_call: "9";
-    readonly tool_result: "a";
+type TextStreamPart<TOOLS extends Record<string, CoreTool>> = {
+    type: 'text-delta';
+    textDelta: string;
+} | ({
+    type: 'tool-call';
+} & ToolCallUnion<TOOLS>) | {
+    type: 'tool-call-streaming-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-call-delta';
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+} | ({
+    type: 'tool-result';
+} & ToolResultUnion<TOOLS>) | {
+    type: 'step-finish';
+    finishReason: FinishReason;
+    logprobs?: LogProbs;
+    usage: LanguageModelUsage;
+    request: LanguageModelRequestMetadata;
+    response: LanguageModelResponseMetadata;
+    warnings: CallWarning[] | undefined;
+    experimental_providerMetadata?: ProviderMetadata;
+    isContinued: boolean;
+} | {
+    type: 'finish';
+    finishReason: FinishReason;
+    logprobs?: LogProbs;
+    usage: LanguageModelUsage;
+    response: LanguageModelResponseMetadata;
+    experimental_providerMetadata?: ProviderMetadata;
+} | {
+    type: 'error';
+    error: unknown;
 };
-/**
-Parses a stream part from a string.
 
-@param line The string to parse.
-@returns The parsed stream part.
-@throws An error if the string cannot be parsed.
- */
-declare const parseStreamPart: (line: string) => StreamPartType;
 /**
-Prepends a string with a prefix from the `StreamChunkPrefixes`, JSON-ifies it,
-and appends a new line.
+Generate a text and call tools for a given prompt using a language model.
+
+This function streams the output. If you do not want to stream the output, use `generateText` instead.
+
+@param model - The language model to use.
+@param tools - Tools that are accessible to and can be called by the model. The model needs to support calling tools.
+
+@param system - A system message that will be part of the prompt.
+@param prompt - A simple text prompt. You can either use `prompt` or `messages` but not both.
+@param messages - A list of messages. You can either use `prompt` or `messages` but not both.
+
+@param maxTokens - Maximum number of tokens to generate.
+@param temperature - Temperature setting.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling.
+The value is passed through to the provider. The range depends on the provider and model.
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topK - Only sample from the top K options for each subsequent token.
+Used to remove "long tail" low probability responses.
+Recommended for advanced use cases only. You usually only need to use temperature.
+@param presencePenalty - Presence penalty setting.
+It affects the likelihood of the model to repeat information that is already in the prompt.
+The value is passed through to the provider. The range depends on the provider and model.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The value is passed through to the provider. The range depends on the provider and model.
+@param stopSequences - Stop sequences.
+If set, the model will stop generating text when one of the stop sequences is generated.
+@param seed - The seed (integer) to use for random sampling.
+If set and supported by the model, calls will generate deterministic results.
 
-It ensures type-safety for the part type and value.
- */
-declare function formatStreamPart<T extends keyof StreamPartValueType>(type: T, value: StreamPartValueType[T]): StreamString;
+@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.
 
-/**
- * Generates a 7-character random string to use for IDs. Not secure.
- */
-declare const generateId: (size?: number | undefined) => string;
+@param maxSteps - Maximum number of sequential LLM calls (steps), e.g. when you use tool calls.
 
-/**
-Converts a ReadableStreamDefaultReader into an async generator that yields
-StreamPart objects.
+@param onChunk - Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
+@param onStepFinish - Callback that is called when each step (LLM call) is finished, including intermediate steps.
+@param onFinish - Callback that is called when the LLM response and all request tool executions
+(for tools that have an `execute` function) are finished.
 
-@param reader
-       Reader for the stream to read from.
-@param isAborted
-       Optional function that returns true if the request has been aborted.
-       If the function returns true, the generator will stop reading the stream.
-       If the function is not provided, the generator will not stop reading the stream.
+@return
+A result object for accessing different stream types and additional information.
  */
-declare function readDataStream(reader: ReadableStreamDefaultReader<Uint8Array>, { isAborted, }?: {
-    isAborted?: () => boolean;
-}): AsyncGenerator<StreamPartType>;
-
-declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: false): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: true): (chunk: Uint8Array | undefined) => StreamPartType[];
-declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | undefined) => StreamPartType[] | string;
-
-declare const isStreamStringEqualToType: (type: keyof typeof StreamStringPrefixes, value: string) => value is `0:${string}\n` | `1:${string}\n` | `2:${string}\n` | `3:${string}\n` | `4:${string}\n` | `5:${string}\n` | `6:${string}\n` | `7:${string}\n` | `8:${string}\n` | `9:${string}\n` | `a:${string}\n`;
-type StreamString = `${(typeof StreamStringPrefixes)[keyof typeof StreamStringPrefixes]}:${string}\n`;
-
-declare interface AzureChatCompletions {
-    id: string;
-    created: Date;
-    choices: AzureChatChoice[];
-    systemFingerprint?: string;
-    usage?: AzureCompletionsUsage;
-    promptFilterResults: any[];
-}
-declare interface AzureChatChoice {
-    message?: AzureChatResponseMessage;
-    index: number;
-    finishReason: string | null;
-    delta?: AzureChatResponseMessage;
-}
-declare interface AzureChatResponseMessage {
-    role: string;
-    content: string | null;
-    toolCalls: AzureChatCompletionsFunctionToolCall[];
-    functionCall?: AzureFunctionCall;
-}
-declare interface AzureCompletionsUsage {
-    completionTokens: number;
-    promptTokens: number;
-    totalTokens: number;
-}
-declare interface AzureFunctionCall {
-    name: string;
-    arguments: string;
-}
-declare interface AzureChatCompletionsFunctionToolCall {
-    type: 'function';
-    function: AzureFunctionCall;
-    id: string;
-}
-
-type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
-    /**
-     * @example
-     * ```js
-     * const response = await openai.chat.completions.create({
-     *   model: 'gpt-3.5-turbo-0613',
-     *   stream: true,
-     *   messages,
-     *   functions,
-     * })
-     *
-     * const stream = OpenAIStream(response, {
-     *   experimental_onFunctionCall: async (functionCallPayload, createFunctionCallMessages) => {
-     *     // ... run your custom logic here
-     *     const result = await myFunction(functionCallPayload)
-     *
-     *     // Ask for another completion, or return a string to send to the client as an assistant message.
-     *     return await openai.chat.completions.create({
-     *       model: 'gpt-3.5-turbo-0613',
-     *       stream: true,
-     *       // Append the relevant "assistant" and "function" call messages
-     *       messages: [...messages, ...createFunctionCallMessages(result)],
-     *       functions,
-     *     })
-     *   }
-     * })
-     * ```
-     */
-    experimental_onFunctionCall?: (functionCallPayload: FunctionCallPayload, createFunctionCallMessages: (functionCallResult: JSONValue) => CreateMessage[]) => Promise<Response | undefined | void | string | AsyncIterableOpenAIStreamReturnTypes>;
-    /**
-     * @example
-     * ```js
-     * const response = await openai.chat.completions.create({
-     *   model: 'gpt-3.5-turbo-1106', // or gpt-4-1106-preview
-     *   stream: true,
-     *   messages,
-     *   tools,
-     *   tool_choice: "auto", // auto is default, but we'll be explicit
-     * })
-     *
-     * const stream = OpenAIStream(response, {
-     *   experimental_onToolCall: async (toolCallPayload, appendToolCallMessages) => {
-     *    let messages: CreateMessage[] = []
-     *    //   There might be multiple tool calls, so we need to iterate through them
-     *    for (const tool of toolCallPayload.tools) {
-     *     // ... run your custom logic here
-     *     const result = await myFunction(tool.function)
-     *    // Append the relevant "assistant" and "tool" call messages
-     *     appendToolCallMessage({tool_call_id:tool.id, function_name:tool.function.name, tool_call_result:result})
-     *    }
-     *     // Ask for another completion, or return a string to send to the client as an assistant message.
-     *     return await openai.chat.completions.create({
-     *       model: 'gpt-3.5-turbo-1106', // or gpt-4-1106-preview
-     *       stream: true,
-     *       // Append the results messages, calling appendToolCallMessage without
-     *       // any arguments will jsut return the accumulated messages
-     *       messages: [...messages, ...appendToolCallMessage()],
-     *       tools,
-     *        tool_choice: "auto", // auto is default, but we'll be explicit
-     *     })
-     *   }
-     * })
-     * ```
-     */
-    experimental_onToolCall?: (toolCallPayload: ToolCallPayload, appendToolCallMessage: (result?: {
-        tool_call_id: string;
-        function_name: string;
-        tool_call_result: JSONValue;
-    }) => CreateMessage[]) => Promise<Response | undefined | void | string | AsyncIterableOpenAIStreamReturnTypes>;
-};
-interface ChatCompletionChunk {
-    id: string;
-    choices: Array<ChatCompletionChunkChoice>;
-    created: number;
-    model: string;
-    object: string;
-}
-interface ChatCompletionChunkChoice {
-    delta: ChoiceDelta;
-    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call' | null;
-    index: number;
-}
-interface ChoiceDelta {
-    /**
-     * The contents of the chunk message.
-     */
-    content?: string | null;
+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 & {
     /**
-     * The name and arguments of a function that should be called, as generated by the
-     * model.
+The language model to use.
      */
-    function_call?: FunctionCall$1;
+    model: LanguageModel;
     /**
-     * The role of the author of this message.
-     */
-    role?: 'system' | 'user' | 'assistant' | 'tool';
-    tool_calls?: Array<DeltaToolCall>;
-}
-interface DeltaToolCall {
-    index: number;
+The tools that the model can call. The model needs to support calling tools.
+    */
+    tools?: TOOLS;
     /**
-     * The ID of the tool call.
+The tool choice strategy. Default: 'auto'.
      */
-    id?: string;
+    toolChoice?: CoreToolChoice<TOOLS>;
     /**
-     * The function that the model called.
-     */
-    function?: ToolCallFunction;
+Maximum number of sequential LLM calls (steps), e.g. when you use tool calls. Must be at least 1.
+
+A maximum number is required to prevent infinite loops in the case of misconfigured tools.
+
+By default, it's set to 1, which means that only a single LLM call is made.
+ */
+    maxSteps?: number;
     /**
-     * The type of the tool. Currently, only `function` is supported.
+When enabled, the model will perform additional steps if the finish reason is "length" (experimental).
+
+By default, it's set to false.
      */
-    type?: 'function';
-}
-interface ToolCallFunction {
+    experimental_continueSteps?: boolean;
     /**
-     * The arguments to call the function with, as generated by the model in JSON
-     * format. Note that the model does not always generate valid JSON, and may
-     * hallucinate parameters not defined by your function schema. Validate the
-     * arguments in your code before calling your function.
+Optional telemetry configuration (experimental).
      */
-    arguments?: string;
+    experimental_telemetry?: TelemetrySettings;
     /**
-     * The name of the function to call.
-     */
-    name?: string;
-}
-/**
- * https://github.com/openai/openai-node/blob/3ec43ee790a2eb6a0ccdd5f25faa23251b0f9b8e/src/resources/completions.ts#L28C1-L64C1
- * Completions API. Streamed and non-streamed responses are the same.
+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.
  */
-interface Completion {
+    experimental_providerMetadata?: ProviderMetadata;
     /**
-     * A unique identifier for the completion.
+Limits the tools that are available for the model to call without
+changing the tool call and result types in the result.
      */
-    id: string;
-    /**
-     * The list of completion choices the model generated for the input prompt.
-     */
-    choices: Array<CompletionChoice>;
-    /**
-     * The Unix timestamp of when the completion was created.
-     */
-    created: number;
+    experimental_activeTools?: Array<keyof TOOLS>;
     /**
-     * The model used for completion.
+Optional specification for parsing structured outputs from the LLM response.
      */
-    model: string;
+    experimental_output?: Output<OUTPUT, PARTIAL_OUTPUT>;
     /**
-     * The object type, which is always "text_completion"
+A function that attempts to repair a tool call that failed to parse.
      */
-    object: string;
+    experimental_repairToolCall?: ToolCallRepairFunction<TOOLS>;
     /**
-     * Usage statistics for the completion request.
+Enable streaming of tool call deltas as they are generated. Disabled by default.
      */
-    usage?: CompletionUsage;
-}
-interface CompletionChoice {
+    experimental_toolCallStreaming?: boolean;
     /**
-     * The reason the model stopped generating tokens. This will be `stop` if the model
-     * hit a natural stop point or a provided stop sequence, or `length` if the maximum
-     * number of tokens specified in the request was reached.
+Optional 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.
      */
-    finish_reason: 'stop' | 'length' | 'content_filter';
-    index: number;
-    logprobs: any | null;
-    text: string;
-}
-interface CompletionUsage {
+    experimental_transform?: (options: {
+        tools: TOOLS;
+        stopStream: () => void;
+    }) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
     /**
-     * Usage statistics for the completion request.
+Callback that is called for each chunk of the stream. The stream processing will pause until the callback promise is resolved.
      */
+    onChunk?: (event: {
+        chunk: Extract<TextStreamPart<TOOLS>, {
+            type: 'text-delta' | 'tool-call' | 'tool-call-streaming-start' | 'tool-call-delta' | 'tool-result';
+        }>;
+    }) => Promise<void> | void;
     /**
-     * Number of tokens in the generated completion.
+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.
      */
-    completion_tokens: number;
+    onFinish?: (event: Omit<StepResult<TOOLS>, 'stepType' | 'isContinued'> & {
+        /**
+Details for all steps.
+       */
+        readonly steps: StepResult<TOOLS>[];
+    }) => Promise<void> | void;
     /**
-     * Number of tokens in the prompt.
-     */
-    prompt_tokens: number;
+    Callback that is called when each step (LLM call) is finished, including intermediate steps.
+    */
+    onStepFinish?: (event: StepResult<TOOLS>) => Promise<void> | void;
     /**
-     * Total number of tokens used in the request (prompt + completion).
+     * Internal. For test use only. May change without notice.
      */
-    total_tokens: number;
-}
-type AsyncIterableOpenAIStreamReturnTypes = AsyncIterable<ChatCompletionChunk> | AsyncIterable<Completion> | AsyncIterable<AzureChatCompletions>;
-declare function OpenAIStream(res: Response | AsyncIterableOpenAIStreamReturnTypes, callbacks?: OpenAIStreamCallbacks): ReadableStream;
+    _internal?: {
+        now?: () => number;
+        generateId?: () => string;
+        currentDate?: () => Date;
+    };
+}): StreamTextResult<TOOLS, PARTIAL_OUTPUT>;
 
-interface FunctionCallPayload {
-    name: string;
-    arguments: Record<string, unknown>;
-}
-interface ToolCallPayload {
-    tools: {
-        id: string;
-        type: 'function';
-        func: {
-            name: string;
-            arguments: Record<string, unknown>;
-        };
-    }[];
-}
 /**
- * Configuration options and helper callback methods for AIStream stream lifecycle events.
- * @interface
+ * 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.
  */
-interface AIStreamCallbacksAndOptions {
-    /** `onStart`: Called once when the stream is initialized. */
-    onStart?: () => Promise<void> | void;
-    /** `onCompletion`: Called for each tokenized message. */
-    onCompletion?: (completion: string) => Promise<void> | void;
-    /** `onFinal`: Called once when the stream is closed with the final completion message. */
-    onFinal?: (completion: string) => Promise<void> | void;
-    /** `onToken`: Called for each tokenized message. */
-    onToken?: (token: string) => Promise<void> | void;
-    /** `onText`: Called for each text chunk. */
-    onText?: (text: string) => Promise<void> | void;
+declare function smoothStream<TOOLS extends Record<string, CoreTool>>({ delayInMs, chunking, _internal: { delay }, }?: {
+    delayInMs?: number | null;
+    chunking?: 'word' | 'line' | RegExp;
     /**
-     * @deprecated This flag is no longer used and only retained for backwards compatibility.
-     * You can remove it from your code.
+     * Internal. For test use only. May change without notice.
      */
-    experimental_streamData?: boolean;
-}
-/**
- * Options for the AIStreamParser.
- * @interface
- * @property {string} event - The event (type) from the server side event stream.
- */
-interface AIStreamParserOptions {
-    event?: string;
-}
-/**
- * Custom parser for AIStream data.
- * @interface
- * @param {string} data - The data to be parsed.
- * @param {AIStreamParserOptions} options - The options for the parser.
- * @returns {string | void} The parsed data or void.
- */
-interface AIStreamParser {
-    (data: string, options: AIStreamParserOptions): string | void | {
-        isText: false;
-        content: string;
+    _internal?: {
+        delay?: (delayInMs: number | null) => Promise<void>;
     };
-}
-/**
- * Creates a TransformStream that parses events from an EventSource stream using a custom parser.
- * @param {AIStreamParser} customParser - Function to handle event data.
- * @returns {TransformStream<Uint8Array, string>} TransformStream parsing events.
- */
-declare function createEventStreamTransformer(customParser?: AIStreamParser): TransformStream<Uint8Array, string | {
-    isText: false;
-    content: string;
-}>;
+}): (options: {
+    tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>;
+
+/**
+ * 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 = {
+    /**
+     * Transforms the parameters before they are passed to the language model.
+     * @param options - Object containing the type of operation and the parameters.
+     * @param options.type - The type of operation ('generate' or 'stream').
+     * @param options.params - The original parameters for the language model call.
+     * @returns A promise that resolves to the transformed parameters.
+     */
+    transformParams?: (options: {
+        type: 'generate' | 'stream';
+        params: LanguageModelV1CallOptions;
+    }) => PromiseLike<LanguageModelV1CallOptions>;
+    /**
+     * 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.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.
+     * @returns A promise that resolves to the result of the generate operation.
+     */
+    wrapGenerate?: (options: {
+        doGenerate: () => ReturnType<LanguageModelV1['doGenerate']>;
+        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.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.
+     * @param options.model - The language model instance.
+     * @returns A promise that resolves to the result of the stream operation.
+     */
+    wrapStream?: (options: {
+        doStream: () => ReturnType<LanguageModelV1['doStream']>;
+        params: LanguageModelV1CallOptions;
+        model: LanguageModelV1;
+    }) => PromiseLike<Awaited<ReturnType<LanguageModelV1['doStream']>>>;
+};
+
 /**
- * Creates a transform stream that encodes input messages and invokes optional callback functions.
- * The transform stream uses the provided callbacks to execute custom logic at different stages of the stream's lifecycle.
- * - `onStart`: Called once when the stream is initialized.
- * - `onToken`: Called for each tokenized message.
- * - `onCompletion`: Called every time an AIStream completion message is received. This can occur multiple times when using e.g. OpenAI functions
- * - `onFinal`: Called once when the stream is closed with the final completion message.
+ * Wraps a LanguageModelV1 instance with middleware functionality.
+ * This function allows you to apply middleware to transform parameters,
+ * wrap generate operations, and wrap stream operations of a language model.
  *
- * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
+ * @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.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, }: {
+    model: LanguageModelV1;
+    middleware: Experimental_LanguageModelV1Middleware;
+    modelId?: string;
+    providerId?: string;
+}) => LanguageModelV1;
+
+/**
+ * Creates a custom provider with specified language models, text embedding models, and an optional fallback provider.
  *
- * @param {AIStreamCallbacksAndOptions} [callbacks] - An object containing the callback functions.
- * @return {TransformStream<string, Uint8Array>} A transform stream that encodes input messages as Uint8Array and allows the execution of custom logic through callbacks.
+ * @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 {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.
  *
- * @example
- * const callbacks = {
- *   onStart: async () => console.log('Stream started'),
- *   onToken: async (token) => console.log(`Token: ${token}`),
- *   onCompletion: async (completion) => console.log(`Completion: ${completion}`)
- *   onFinal: async () => data.close()
- * };
- * const transformer = createCallbacksTransformer(callbacks);
- */
-declare function createCallbacksTransformer(cb: AIStreamCallbacksAndOptions | OpenAIStreamCallbacks | undefined): TransformStream<string | {
-    isText: false;
-    content: string;
-}, Uint8Array>;
+ * @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 const symbol$a: unique symbol;
+declare class NoSuchProviderError extends NoSuchModelError {
+    private readonly [symbol$a];
+    readonly providerId: string;
+    readonly availableProviders: string[];
+    constructor({ modelId, modelType, providerId, availableProviders, message, }: {
+        modelId: string;
+        modelType: 'languageModel' | 'textEmbeddingModel';
+        providerId: string;
+        availableProviders: string[];
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoSuchProviderError;
+}
+
 /**
- * Returns a stateful function that, when invoked, trims leading whitespace
- * from the input text. The trimming only occurs on the first invocation, ensuring that
- * subsequent calls do not alter the input text. This is particularly useful in scenarios
- * where a text stream is being processed and only the initial whitespace should be removed.
- *
- * @return {function(string): string} A function that takes a string as input and returns a string
- * with leading whitespace removed if it is the first invocation; otherwise, it returns the input unchanged.
- *
- * @example
- * const trimStart = trimStartOfStreamHelper();
- * const output1 = trimStart("   text"); // "text"
- * const output2 = trimStart("   text"); // "   text"
- *
+ * Creates a registry for the given providers.
  */
-declare function trimStartOfStreamHelper(): (text: string) => string;
+declare function experimental_createProviderRegistry(providers: Record<string, Provider>): Provider;
+
 /**
- * Returns a ReadableStream created from the response, parsed and handled with custom logic.
- * The stream goes through two transformation stages, first parsing the events and then
- * invoking the provided callbacks.
+ * Calculates the cosine similarity between two vectors. This is a useful metric for
+ * comparing the similarity of two vectors such as embeddings.
  *
- * For 2xx HTTP responses:
- * - The function continues with standard stream processing.
+ * @param vector1 - The first vector.
+ * @param vector2 - The second vector.
  *
- * For non-2xx HTTP responses:
- * - If the response body is defined, it asynchronously extracts and decodes the response body.
- * - It then creates a custom ReadableStream to propagate a detailed error message.
- *
- * @param {Response} response - The response.
- * @param {AIStreamParser} customParser - The custom parser function.
- * @param {AIStreamCallbacksAndOptions} callbacks - The callbacks.
- * @return {ReadableStream} The AIStream.
- * @throws Will throw an error if the response is not OK.
+ * @returns The cosine similarity between vector1 and vector2.
+ * @throws {Error} If the vectors do not have the same length.
  */
-declare function AIStream(response: Response, customParser?: AIStreamParser, callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
+declare function cosineSimilarity(vector1: number[], vector2: number[]): number;
+
 /**
- * Implements ReadableStream.from(asyncIterable), which isn't documented in MDN and isn't implemented in node.
- * https://github.com/whatwg/streams/commit/8d7a0bf26eb2cc23e884ddbaac7c1da4b91cf2bc
- */
-declare function readableFromAsyncIterable<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
+ * Creates a ReadableStream that emits the provided values with an optional delay between each value.
+ *
+ * @param options - The configuration options
+ * @param options.chunks - Array of values to be emitted by the stream
+ * @param options.initialDelayInMs - Optional initial delay in milliseconds before emitting the first value (default: 0). Can be set to `null` to skip the initial delay. The difference between `initialDelayInMs: null` and `initialDelayInMs: 0` is that `initialDelayInMs: null` will emit the values without any delay, while `initialDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @returns A ReadableStream that emits the provided values
+ */
+declare function simulateReadableStream<T>({ chunks, initialDelayInMs, chunkDelayInMs, _internal, }: {
+    chunks: T[];
+    initialDelayInMs?: number | null;
+    chunkDelayInMs?: number | null;
+    _internal?: {
+        delay?: (ms: number | null) => Promise<void>;
+    };
+}): ReadableStream<T>;
+
+declare const symbol$9: unique symbol;
+declare class InvalidArgumentError extends AISDKError {
+    private readonly [symbol$9];
+    readonly parameter: string;
+    readonly value: unknown;
+    constructor({ parameter, value, message, }: {
+        parameter: string;
+        value: unknown;
+        message: string;
+    });
+    static isInstance(error: unknown): error is InvalidArgumentError;
+}
 
-interface CompletionChunk {
-    /**
-     * Unique object identifier.
-     *
-     * The format and length of IDs may change over time.
-     */
-    id: string;
-    /**
-     * The resulting completion up to and excluding the stop sequences.
-     */
-    completion: string;
+declare const symbol$8: unique symbol;
+/**
+Thrown when no object could be generated. This can have several causes:
+
+- The model failed to generate a response.
+- The model generated a response that could not be parsed.
+- The model generated a response that could not be validated against the schema.
+
+The error contains the following properties:
+
+- `text`: The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
+ */
+declare class NoObjectGeneratedError extends AISDKError {
+    private readonly [symbol$8];
     /**
-     * The model that handled the request.
+    The text that was generated by the model. This can be the raw text or the tool call text, depending on the model.
      */
-    model: string;
+    readonly text: string | undefined;
     /**
-     * The reason that we stopped.
-     *
-     * This may be one the following values:
-     *
-     * - `"stop_sequence"`: we reached a stop sequence — either provided by you via the
-     *   `stop_sequences` parameter, or a stop sequence built into the model
-     * - `"max_tokens"`: we exceeded `max_tokens_to_sample` or the model's maximum
+    The response metadata.
      */
-    stop_reason: string | null;
+    readonly response: LanguageModelResponseMetadata | undefined;
     /**
-     * Object type.
-     *
-     * For Text Completions, this is always `"completion"`.
+    The usage of the model.
      */
-    type: 'completion';
-}
-interface Message {
-    id: string;
-    content: Array<ContentBlock>;
-    model: string;
-    role: 'assistant';
-    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | null;
-    stop_sequence: string | null;
-    type: 'message';
-}
-interface ContentBlock {
-    text: string;
-    type: 'text';
-}
-interface TextDelta {
-    text: string;
-    type: 'text_delta';
-}
-interface ContentBlockDeltaEvent {
-    delta: TextDelta;
-    index: number;
-    type: 'content_block_delta';
+    readonly usage: LanguageModelUsage | undefined;
+    constructor({ message, cause, text, response, usage, }: {
+        message?: string;
+        cause?: Error;
+        text?: string;
+        response: LanguageModelResponseMetadata;
+        usage: LanguageModelUsage;
+    });
+    static isInstance(error: unknown): error is NoObjectGeneratedError;
 }
-interface ContentBlockStartEvent {
-    content_block: ContentBlock;
-    index: number;
-    type: 'content_block_start';
+
+declare const symbol$7: unique symbol;
+/**
+Thrown when no output type is specified and output-related methods are called.
+ */
+declare class NoOutputSpecifiedError extends AISDKError {
+    private readonly [symbol$7];
+    constructor({ message }?: {
+        message?: string;
+    });
+    static isInstance(error: unknown): error is NoOutputSpecifiedError;
 }
-interface ContentBlockStopEvent {
-    index: number;
-    type: 'content_block_stop';
+
+declare const symbol$6: unique symbol;
+declare class ToolCallRepairError extends AISDKError {
+    private readonly [symbol$6];
+    readonly originalError: NoSuchToolError | InvalidToolArgumentsError;
+    constructor({ cause, originalError, message, }: {
+        message?: string;
+        cause: unknown;
+        originalError: NoSuchToolError | InvalidToolArgumentsError;
+    });
+    static isInstance(error: unknown): error is ToolCallRepairError;
+}
+
+declare const symbol$5: unique symbol;
+declare class ToolExecutionError extends AISDKError {
+    private readonly [symbol$5];
+    readonly toolName: string;
+    readonly toolArgs: JSONValue;
+    readonly toolCallId: string;
+    constructor({ toolArgs, toolName, toolCallId, cause, message, }: {
+        message?: string;
+        toolArgs: JSONValue;
+        toolName: string;
+        toolCallId: string;
+        cause: unknown;
+    });
+    static isInstance(error: unknown): error is ToolExecutionError;
 }
-interface MessageDeltaEventDelta {
-    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | null;
-    stop_sequence: string | null;
+
+declare const symbol$4: unique symbol;
+declare class InvalidDataContentError extends AISDKError {
+    private readonly [symbol$4];
+    readonly content: unknown;
+    constructor({ content, cause, message, }: {
+        content: unknown;
+        cause?: unknown;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is InvalidDataContentError;
 }
-interface MessageDeltaEvent {
-    delta: MessageDeltaEventDelta;
-    type: 'message_delta';
+
+declare const symbol$3: unique symbol;
+declare class InvalidMessageRoleError extends AISDKError {
+    private readonly [symbol$3];
+    readonly role: string;
+    constructor({ role, message, }: {
+        role: string;
+        message?: string;
+    });
+    static isInstance(error: unknown): error is InvalidMessageRoleError;
 }
-type MessageStreamEvent = MessageStartEvent | MessageDeltaEvent | MessageStopEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockStopEvent;
-interface MessageStartEvent {
-    message: Message;
-    type: 'message_start';
+
+declare const symbol$2: unique symbol;
+declare class MessageConversionError extends AISDKError {
+    private readonly [symbol$2];
+    readonly originalMessage: UIMessage;
+    constructor({ originalMessage, message, }: {
+        originalMessage: UIMessage;
+        message: string;
+    });
+    static isInstance(error: unknown): error is MessageConversionError;
 }
-interface MessageStopEvent {
-    type: 'message_stop';
+
+declare const symbol$1: unique symbol;
+declare class DownloadError extends AISDKError {
+    private readonly [symbol$1];
+    readonly url: string;
+    readonly statusCode?: number;
+    readonly statusText?: string;
+    constructor({ url, statusCode, statusText, cause, message, }: {
+        url: string;
+        statusCode?: number;
+        statusText?: string;
+        message?: string;
+        cause?: unknown;
+    });
+    static isInstance(error: unknown): error is DownloadError;
+}
+
+declare const symbol: unique symbol;
+type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable' | 'abort';
+declare class RetryError extends AISDKError {
+    private readonly [symbol];
+    readonly reason: RetryErrorReason;
+    readonly lastError: unknown;
+    readonly errors: Array<unknown>;
+    constructor({ message, reason, errors, }: {
+        message: string;
+        reason: RetryErrorReason;
+        errors: Array<unknown>;
+    });
+    static isInstance(error: unknown): error is RetryError;
 }
-/**
- * Accepts either a fetch Response from the Anthropic `POST /v1/complete` endpoint,
- * or the return value of `await client.completions.create({ stream: true })`
- * from the `@anthropic-ai/sdk` package.
- */
-declare function AnthropicStream(res: Response | AsyncIterable<CompletionChunk> | AsyncIterable<MessageStreamEvent>, cb?: AIStreamCallbacksAndOptions): ReadableStream;
 
 /**
 You can pass the thread and the latest message into the `AssistantResponse`. This establishes the context for the response.
@@ -1995,14 +2502,6 @@ The process parameter is a callback in which you can run the assistant on thread
  */
 type AssistantResponseCallback = (options: {
     /**
-  @deprecated use variable from outer scope instead.
-     */
-    threadId: string;
-    /**
-  @deprecated use variable from outer scope instead.
-     */
-    messageId: string;
-    /**
   Forwards an assistant message (non-streaming) to the client.
      */
     sendMessage: (message: AssistantMessage) => void;
@@ -2013,7 +2512,7 @@ type AssistantResponseCallback = (options: {
     /**
   Forwards the assistant response stream to the client. Returns the `Run` object after it completes, or when it requires an action.
      */
-    forwardStream: (stream: AssistantStream) => Promise<Run | undefined>;
+    forwardStream: (stream: any) => Promise<any | undefined>;
 }) => Promise<void>;
 /**
 The `AssistantResponse` allows you to send a stream of assistant update to `useAssistant`.
@@ -2021,65 +2520,26 @@ It is designed to facilitate streaming assistant responses to the `useAssistant`
 It receives an assistant thread and a current message, and can send messages and data messages to the client.
  */
 declare function AssistantResponse({ threadId, messageId }: AssistantResponseSettings, process: AssistantResponseCallback): Response;
+
 /**
-@deprecated Use `AssistantResponse` instead.
+ * Configuration options and helper callback methods for stream lifecycle events.
  */
-declare const experimental_AssistantResponse: typeof AssistantResponse;
-
-interface AWSBedrockResponse {
-    body?: AsyncIterable<{
-        chunk?: {
-            bytes?: Uint8Array;
-        };
-    }>;
-}
-declare function AWSBedrockAnthropicMessagesStream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-declare function AWSBedrockAnthropicStream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-declare function AWSBedrockCohereStream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-declare function AWSBedrockLlama2Stream(response: AWSBedrockResponse, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-declare function AWSBedrockStream(response: AWSBedrockResponse, callbacks: AIStreamCallbacksAndOptions | undefined, extractTextDeltaFromChunk: (chunk: any) => string): ReadableStream<any>;
-
-interface StreamChunk {
-    text?: string;
-    eventType: 'stream-start' | 'search-queries-generation' | 'search-results' | 'text-generation' | 'citation-generation' | 'stream-end';
-}
-declare function CohereStream(reader: Response | AsyncIterable<StreamChunk>, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-
-interface GenerateContentResponse {
-    candidates?: GenerateContentCandidate[];
-}
-interface GenerateContentCandidate {
-    index: number;
-    content: Content;
-}
-interface Content {
-    role: string;
-    parts: Part[];
-}
-type Part = TextPart | InlineDataPart;
-interface InlineDataPart {
-    text?: never;
-}
-interface TextPart {
-    text: string;
-    inlineData?: never;
+interface StreamCallbacks {
+    /** `onStart`: Called once when the stream is initialized. */
+    onStart?: () => Promise<void> | void;
+    /**
+     * `onCompletion`: Called for each tokenized message.
+     *
+     * @deprecated Use `onFinal` instead.
+     */
+    onCompletion?: (completion: string) => Promise<void> | void;
+    /** `onFinal`: Called once when the stream is closed with the final completion message. */
+    onFinal?: (completion: string) => Promise<void> | void;
+    /** `onToken`: Called for each tokenized message. */
+    onToken?: (token: string) => Promise<void> | void;
+    /** `onText`: Called for each text chunk. */
+    onText?: (text: string) => Promise<void> | void;
 }
-declare function GoogleGenerativeAIStream(response: {
-    stream: AsyncIterable<GenerateContentResponse>;
-}, cb?: AIStreamCallbacksAndOptions): ReadableStream;
-
-declare function HuggingFaceStream(res: AsyncGenerator<any>, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-
-type InkeepOnFinalMetadata = {
-    chat_session_id: string;
-    records_cited: any;
-};
-type InkeepChatResultCallbacks = {
-    onFinal?: (completion: string, metadata?: InkeepOnFinalMetadata) => Promise<void> | void;
-    onRecordsCited?: (records_cited: InkeepOnFinalMetadata['records_cited']) => void;
-};
-type InkeepAIStreamCallbacksAndOptions = AIStreamCallbacksAndOptions & InkeepChatResultCallbacks;
-declare function InkeepStream(res: Response, callbacks?: InkeepAIStreamCallbacksAndOptions): ReadableStream;
 
 type LangChainImageDetail = 'auto' | 'low' | 'high';
 type LangChainMessageContentText = {
@@ -2102,186 +2562,59 @@ type LangChainMessageContent = string | LangChainMessageContentComplex[];
 type LangChainAIMessageChunk = {
     content: LangChainMessageContent;
 };
+type LangChainStreamEvent = {
+    event: string;
+    data: any;
+};
 /**
-Converts the result of a LangChain Expression Language stream invocation to an AIStream.
+Converts LangChain output streams to an AI SDK Data Stream.
+
+The following streams are supported:
+- `LangChainAIMessageChunk` streams (LangChain `model.stream` output)
+- `string` streams (LangChain `StringOutputParser` output)
  */
-declare function toAIStream(stream: ReadableStream<LangChainAIMessageChunk>, callbacks?: AIStreamCallbacksAndOptions): ReadableStream<any>;
+declare function toDataStream$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array>;
+declare function toDataStreamResponse$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, options?: {
+    init?: ResponseInit;
+    data?: StreamData;
+    callbacks?: StreamCallbacks;
+}): Response;
+declare function mergeIntoDataStream$1(stream: ReadableStream<LangChainStreamEvent> | ReadableStream<LangChainAIMessageChunk> | ReadableStream<string>, options: {
+    dataStream: DataStreamWriter;
+    callbacks?: StreamCallbacks;
+}): void;
 
-declare const langchainAdapter_toAIStream: typeof toAIStream;
 declare namespace langchainAdapter {
   export {
-    langchainAdapter_toAIStream as toAIStream,
+    mergeIntoDataStream$1 as mergeIntoDataStream,
+    toDataStream$1 as toDataStream,
+    toDataStreamResponse$1 as toDataStreamResponse,
   };
 }
 
-/**
-@deprecated Use LangChainAdapter.toAIStream() instead.
- */
-declare function LangChainStream(callbacks?: AIStreamCallbacksAndOptions): {
-    stream: ReadableStream<any>;
-    writer: WritableStreamDefaultWriter<any>;
-    handlers: {
-        handleLLMNewToken: (token: string) => Promise<void>;
-        handleLLMStart: (_llm: any, _prompts: string[], runId: string) => Promise<void>;
-        handleLLMEnd: (_output: any, runId: string) => Promise<void>;
-        handleLLMError: (e: Error, runId: string) => Promise<void>;
-        handleChainStart: (_chain: any, _inputs: any, runId: string) => Promise<void>;
-        handleChainEnd: (_outputs: any, runId: string) => Promise<void>;
-        handleChainError: (e: Error, runId: string) => Promise<void>;
-        handleToolStart: (_tool: any, _input: string, runId: string) => Promise<void>;
-        handleToolEnd: (_output: string, runId: string) => Promise<void>;
-        handleToolError: (e: Error, runId: string) => Promise<void>;
-    };
-};
-
-interface ChatCompletionResponseChunk {
-    id: string;
-    object: 'chat.completion.chunk';
-    created: number;
-    model: string;
-    choices: ChatCompletionResponseChunkChoice[];
-}
-interface ChatCompletionResponseChunkChoice {
-    index: number;
-    delta: {
-        role?: string;
-        content?: string;
-        tool_calls?: ToolCalls[];
-    };
-    finish_reason: string;
-}
-interface FunctionCall {
-    name: string;
-    arguments: string;
-}
-interface ToolCalls {
-    id: 'null';
-    type: 'function';
-    function: FunctionCall;
-}
-declare function MistralStream(response: AsyncGenerator<ChatCompletionResponseChunk, void, unknown>, callbacks?: AIStreamCallbacksAndOptions): ReadableStream;
-
-interface Prediction {
-    id: string;
-    status: 'starting' | 'processing' | 'succeeded' | 'failed' | 'canceled';
-    version: string;
-    input: object;
-    output?: any;
-    source: 'api' | 'web';
-    error?: any;
-    logs?: string;
-    metrics?: {
-        predict_time?: number;
-    };
-    webhook?: string;
-    webhook_events_filter?: ('start' | 'output' | 'logs' | 'completed')[];
-    created_at: string;
-    updated_at?: string;
-    completed_at?: string;
-    urls: {
-        get: string;
-        cancel: string;
-        stream?: string;
-    };
-}
-/**
- * Stream predictions from Replicate.
- * Only certain models are supported and you must pass `stream: true` to
- * replicate.predictions.create().
- * @see https://github.com/replicate/replicate-javascript#streaming
- *
- * @example
- * const response = await replicate.predictions.create({
- *  stream: true,
- *  input: {
- *    prompt: messages.join('\n')
- *  },
- *  version: '2c1608e18606fad2812020dc541930f2d0495ce32eee50074220b87300bc16e1'
- * })
- *
- * const stream = await ReplicateStream(response)
- * return new StreamingTextResponse(stream)
- *
- */
-declare function ReplicateStream(res: Prediction, cb?: AIStreamCallbacksAndOptions, options?: {
-    headers?: Record<string, string>;
-}): Promise<ReadableStream>;
-
-/**
- * A stream wrapper to send custom JSON-encoded data back to the client.
- */
-declare class StreamData {
-    private encoder;
-    private controller;
-    stream: ReadableStream<Uint8Array>;
-    private isClosed;
-    private warningTimeout;
-    constructor();
-    close(): Promise<void>;
-    append(value: JSONValue): void;
-    appendMessageAnnotation(value: JSONValue): void;
-}
-/**
- * A TransformStream for LLMs that do not have their own transform stream handlers managing encoding (e.g. OpenAIStream has one for function call handling).
- * This assumes every chunk is a 'text' chunk.
- */
-declare function createStreamDataTransformer(): TransformStream<any, any>;
-/**
-@deprecated Use `StreamData` instead.
- */
-declare class experimental_StreamData extends StreamData {
-}
-
-/**
- * A utility function to stream a ReadableStream to a Node.js response-like object.
- */
-declare function streamToResponse(res: ReadableStream, response: ServerResponse, init?: {
-    headers?: Record<string, string>;
-    status?: number;
-}, data?: StreamData): void;
-
-/**
- * This is a naive implementation of the streaming React response API.
- * Currently, it can carry the original raw content, data payload and a special
- * UI payload and stream them via "rows" (nested promises).
- * It must be used inside Server Actions so Flight can encode the React elements.
- *
- * It is naive as unlike the StreamingTextResponse, it does not send the diff
- * between the rows, but flushing the full payload on each row.
- */
-
-type UINode = string | JSX.Element | JSX.Element[] | null | undefined;
-type Payload = {
-    ui: UINode | Promise<UINode>;
-    content: string;
-};
-/**
- @deprecated Use AI SDK RSC instead: https://sdk.vercel.ai/docs/ai-sdk-rsc
- */
-type ReactResponseRow = Payload & {
-    next: null | Promise<ReactResponseRow>;
+type EngineResponse = {
+    delta: string;
 };
-/**
-A utility class for streaming React responses.
-
-@deprecated Use AI SDK RSC instead: https://sdk.vercel.ai/docs/ai-sdk-rsc
- */
-declare class experimental_StreamingReactResponse {
-    constructor(res: ReadableStream, options?: {
-        ui?: (message: {
-            content: string;
-            data?: JSONValue[];
-        }) => UINode | Promise<UINode>;
-        data?: StreamData;
-        generateId?: IdGenerator;
-    });
-}
-
-/**
- * A utility class for streaming text responses.
- */
-declare class StreamingTextResponse extends Response {
-    constructor(res: ReadableStream, init?: ResponseInit, data?: StreamData);
+declare function toDataStream(stream: AsyncIterable<EngineResponse>, callbacks?: StreamCallbacks): ReadableStream<Uint8Array>;
+declare function toDataStreamResponse(stream: AsyncIterable<EngineResponse>, options?: {
+    init?: ResponseInit;
+    data?: StreamData;
+    callbacks?: StreamCallbacks;
+}): Response;
+declare function mergeIntoDataStream(stream: AsyncIterable<EngineResponse>, options: {
+    dataStream: DataStreamWriter;
+    callbacks?: StreamCallbacks;
+}): void;
+
+declare const llamaindexAdapter_mergeIntoDataStream: typeof mergeIntoDataStream;
+declare const llamaindexAdapter_toDataStream: typeof toDataStream;
+declare const llamaindexAdapter_toDataStreamResponse: typeof toDataStreamResponse;
+declare namespace llamaindexAdapter {
+  export {
+    llamaindexAdapter_mergeIntoDataStream as mergeIntoDataStream,
+    llamaindexAdapter_toDataStream as toDataStream,
+    llamaindexAdapter_toDataStreamResponse as toDataStreamResponse,
+  };
 }
 
-export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicMessagesStream, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantContent, AssistantMessage, AssistantResponse, AssistantStatus, CallWarning, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CoreAssistantMessage, CoreMessage, CoreSystemMessage, CoreTool, CoreToolMessage, CoreUserMessage, CreateMessage, DataContent, DataMessage, DeepPartial, EmbedManyResult, EmbedResult, Embedding, EmbeddingModel, ExperimentalAssistantMessage, ExperimentalMessage, ExperimentalTool, ExperimentalToolMessage, ExperimentalUserMessage, FinishReason, Function, FunctionCall$1 as FunctionCall, FunctionCallHandler, FunctionCallPayload, GenerateObjectResult, GenerateTextResult, GoogleGenerativeAIStream, HuggingFaceStream, IdGenerator, ImagePart, InkeepAIStreamCallbacksAndOptions, InkeepChatResultCallbacks, InkeepOnFinalMetadata, InkeepStream, JSONValue, langchainAdapter as LangChainAdapter, LangChainStream, LanguageModel, LogProbs, Message$1 as Message, MistralStream, ObjectStreamPart, ObjectStreamPartInput, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamData, StreamObjectResult, StreamPart, StreamString, StreamTextResult, StreamingTextResponse, TextPart$1 as TextPart, TextStreamPart, Tool, ToolCall, ToolCallHandler, ToolCallPart, ToolCallPayload, ToolChoice, ToolContent, ToolInvocation, ToolResultPart, UseAssistantOptions, UseChatOptions, UseCompletionOptions, UserContent, convertDataContentToBase64String, convertDataContentToUint8Array, convertToCoreMessages, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, embed, embedMany, experimental_AssistantResponse, experimental_StreamData, experimental_StreamingReactResponse, experimental_generateObject, experimental_generateText, experimental_streamObject, experimental_streamText, formatStreamPart, generateId, generateObject, generateText, isStreamStringEqualToType, generateId as nanoid, parseStreamPart, readDataStream, readableFromAsyncIterable, streamObject, streamResponse, streamText, streamToResponse, tool, trimStartOfStreamHelper };
+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 };