ai 0.0.0-e27b4ed4-20240419203611

package/dist/index.d.mts

@@ -0,0 +1,1770 @@
+import { LanguageModelV1, LanguageModelV1FinishReason, LanguageModelV1CallWarning } from '@ai-sdk/provider';
+import { z } from 'zod';
+import { AssistantStream } from 'openai/lib/AssistantStream';
+import { Run } from 'openai/resources/beta/threads/runs/runs';
+import { ChatCompletionResponseChunk } from '@mistralai/mistralai';
+import { ServerResponse } from 'node:http';
+
+type TokenUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+};
+
+type CallSettings = {
+    /**
+  Maximum number of tokens to generate.
+     */
+    maxTokens?: number;
+    /**
+  Temperature setting. This is a number between 0 (almost no randomness) and
+  1 (very random).
+  
+  It is recommended to set either `temperature` or `topP`, but not both.
+  
+  @default 0
+     */
+    temperature?: number;
+    /**
+  Nucleus sampling. This is a number between 0 and 1.
+  
+  E.g. 0.1 would mean that only tokens with the top 10% probability mass
+  are considered.
+  
+  It is recommended to set either `temperature` or `topP`, but not both.
+     */
+    topP?: 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;
+    /**
+  Frequency penalty setting. It affects the likelihood of the model
+  to repeatedly use the same words or phrases.
+  
+  The frequency penalty is a number between -1 (increase repetition)
+  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+  
+  @default 0
+     */
+    frequencyPenalty?: number;
+    /**
+  The seed (integer) to use for random sampling. If set and supported
+  by the model, calls will generate deterministic results.
+     */
+    seed?: number;
+    /**
+  Maximum number of retries. Set to 0 to disable retries.
+  
+  @default 2
+     */
+    maxRetries?: number;
+    /**
+  Abort signal.
+     */
+    abortSignal?: AbortSignal;
+};
+
+/**
+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;
+
+/**
+Text content part of a prompt. It contains a string of text.
+ */
+interface TextPart$1 {
+    type: 'text';
+    /**
+  The text content.
+     */
+    text: string;
+}
+/**
+Image content part of a prompt. It contains an image.
+ */
+interface ImagePart {
+    type: 'image';
+    /**
+  Image data. Can either be:
+  
+  - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+  - URL: a URL that points to the image
+     */
+    image: DataContent | URL;
+    /**
+  Optional mime type of the image.
+     */
+    mimeType?: string;
+}
+/**
+Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
+ */
+interface ToolCallPart {
+    type: 'tool-call';
+    /**
+  ID of the tool call. This ID is used to match the tool call with the tool result.
+   */
+    toolCallId: string;
+    /**
+  Name of the tool that is being called.
+   */
+    toolName: string;
+    /**
+  Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+     */
+    args: unknown;
+}
+/**
+Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
+ */
+interface ToolResultPart {
+    type: 'tool-result';
+    /**
+  ID of the tool call that this result is associated with.
+   */
+    toolCallId: string;
+    /**
+  Name of the tool that generated this result.
+    */
+    toolName: string;
+    /**
+  Result of the tool call. This is a JSON-serializable object.
+     */
+    result: unknown;
+    /**
+  Optional flag if the result is an error or an error message.
+     */
+    isError?: boolean;
+}
+
+/**
+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 ExperimentalMessage = ExperimentalUserMessage | ExperimentalAssistantMessage | ExperimentalToolMessage;
+/**
+A user message. It can contain text or a combination of text and images.
+ */
+type ExperimentalUserMessage = {
+    role: 'user';
+    content: UserContent;
+};
+/**
+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>;
+/**
+An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
+ */
+type ExperimentalAssistantMessage = {
+    role: 'assistant';
+    content: AssistantContent;
+};
+/**
+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>;
+/**
+A tool message. It contains the result of one or more tool calls.
+ */
+type ExperimentalToolMessage = {
+    role: 'tool';
+    content: ToolContent;
+};
+/**
+Content of a tool message. It is an array of tool result parts.
+ */
+type ToolContent = Array<ToolResultPart>;
+
+/**
+Prompt part of the AI function options. It contains a system message, a simple text prompt, or a list of messages.
+ */
+type Prompt = {
+    /**
+  System message to include in the prompt. Can be used with `prompt` or `messages`.
+     */
+    system?: string;
+    /**
+  A simple text prompt. You can either use `prompt` or `messages` but not both.
+   */
+    prompt?: string;
+    /**
+  A list of messsages. You can either use `prompt` or `messages` but not both.
+     */
+    messages?: Array<ExperimentalMessage>;
+};
+
+/**
+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 `experimental_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.
+This is a number between 0 (almost no randomness) and 1 (very random).
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling. This is a number between 0 and 1.
+E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered.
+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 presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@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 experimental_generateObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModelV1;
+    /**
+The schema of the object that the model should generate.
+     */
+    schema: z.Schema<T>;
+    /**
+The mode to use for object generation. Not all models 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: LanguageModelV1FinishReason;
+    /**
+  The token usage of the generated text.
+     */
+    readonly usage: TokenUsage;
+    /**
+  Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor(options: {
+        object: T;
+        finishReason: LanguageModelV1FinishReason;
+        usage: TokenUsage;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+}
+
+type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+
+/**
+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.
+
+Adopted from [type-fest](https://github.com/sindresorhus/type-fest/tree/main) PartialDeep.
+ */
+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 `experimental_generateObject` 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.
+This is a number between 0 (almost no randomness) and 1 (very random).
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling. This is a number between 0 and 1.
+E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered.
+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 presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@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.
+
+@return
+A result object for accessing the partial object stream and additional information.
+ */
+declare function experimental_streamObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModelV1;
+    /**
+The schema of the object that the model should generate.
+ */
+    schema: z.Schema<T>;
+    /**
+The mode to use for object generation. Not all models support all modes.
+
+Default and recommended: 'auto' (best mode for the model).
+ */
+    mode?: 'auto' | 'json' | 'tool' | 'grammar';
+}): Promise<StreamObjectResult<T>>;
+/**
+The result of a `streamObject` call that contains the partial object stream and additional information.
+ */
+declare class StreamObjectResult<T> {
+    private readonly originalStream;
+    /**
+  Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor({ stream, warnings, }: {
+        stream: ReadableStream<string | ErrorStreamPart>;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+    get partialObjectStream(): AsyncIterableStream<DeepPartial<T>>;
+}
+type ErrorStreamPart = {
+    type: 'error';
+    error: unknown;
+};
+
+/**
+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.
+ */
+interface ExperimentalTool<PARAMETERS extends z.ZodTypeAny = any, RESULT = any> {
+    /**
+  An optional description of what the tool does. Will be used by the language model to decide whether to use the tool.
+     */
+    description?: string;
+    /**
+  The schema of the input that the tool expects. The language model will use this to generate the input.
+  Use descriptions to make the input understandable for the language model.
+     */
+    parameters: PARAMETERS;
+    /**
+  An optional execute function for the actual execution function of the tool.
+  If not provided, the tool will not be executed automatically.
+     */
+    execute?: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+}
+/**
+Helper function for inferring the execute args of a tool.
+ */
+declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: ExperimentalTool<PARAMETERS, RESULT> & {
+    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+}): ExperimentalTool<PARAMETERS, RESULT> & {
+    execute: (args: z.infer<PARAMETERS>) => PromiseLike<RESULT>;
+};
+declare function tool<PARAMETERS extends z.ZodTypeAny, RESULT>(tool: ExperimentalTool<PARAMETERS, RESULT> & {
+    execute?: undefined;
+}): ExperimentalTool<PARAMETERS, RESULT> & {
+    execute: undefined;
+};
+
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+    'foo': 1,
+    'bar': 2,
+    'biz': 3
+}
+
+// main.ts
+import type {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+    return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+    return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+* @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
+*/
+type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
+
+type ToToolCall<TOOLS extends Record<string, ExperimentalTool>> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-call';
+        toolCallId: string;
+        toolName: NAME & string;
+        args: z.infer<TOOLS[NAME]['parameters']>;
+    };
+}>;
+type ToToolCallArray<TOOLS extends Record<string, ExperimentalTool>> = Array<ToToolCall<TOOLS>>;
+
+type ToToolsWithExecute<TOOLS extends Record<string, ExperimentalTool>> = {
+    [K in keyof TOOLS as TOOLS[K] extends {
+        execute: any;
+    } ? K : never]: TOOLS[K];
+};
+type ToToolsWithDefinedExecute<TOOLS extends Record<string, ExperimentalTool>> = {
+    [K in keyof TOOLS as TOOLS[K]['execute'] extends undefined ? never : K]: TOOLS[K];
+};
+type ToToolResultObject<TOOLS extends Record<string, ExperimentalTool>> = ValueOf<{
+    [NAME in keyof TOOLS]: {
+        type: 'tool-result';
+        toolCallId: string;
+        toolName: NAME & string;
+        args: z.infer<TOOLS[NAME]['parameters']>;
+        result: Awaited<ReturnType<Exclude<TOOLS[NAME]['execute'], undefined>>>;
+    };
+}>;
+type ToToolResult<TOOLS extends Record<string, ExperimentalTool>> = ToToolResultObject<ToToolsWithDefinedExecute<ToToolsWithExecute<TOOLS>>>;
+type ToToolResultArray<TOOLS extends Record<string, ExperimentalTool>> = 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 `experimental_streamText` instead.
+
+@param model - The language model to use.
+@param tools - The tools that the model can call. 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.
+This is a number between 0 (almost no randomness) and 1 (very random).
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling. This is a number between 0 and 1.
+E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered.
+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 presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@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 experimental_generateText<TOOLS extends Record<string, ExperimentalTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModelV1;
+    /**
+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.
+ */
+declare class GenerateTextResult<TOOLS extends Record<string, ExperimentalTool>> {
+    /**
+  The generated text.
+     */
+    readonly text: string;
+    /**
+  The tool calls that were made during the generation.
+     */
+    readonly toolCalls: ToToolCallArray<TOOLS>;
+    /**
+  The results of the tool calls.
+     */
+    readonly toolResults: ToToolResultArray<TOOLS>;
+    /**
+  The reason why the generation finished.
+     */
+    readonly finishReason: LanguageModelV1FinishReason;
+    /**
+  The token usage of the generated text.
+     */
+    readonly usage: TokenUsage;
+    /**
+  Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor(options: {
+        text: string;
+        toolCalls: ToToolCallArray<TOOLS>;
+        toolResults: ToToolResultArray<TOOLS>;
+        finishReason: LanguageModelV1FinishReason;
+        usage: TokenUsage;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+}
+
+/**
+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 `experimental_generateText` instead.
+
+@param model - The language model to use.
+@param tools - The tools that the model can call. 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.
+This is a number between 0 (almost no randomness) and 1 (very random).
+It is recommended to set either `temperature` or `topP`, but not both.
+@param topP - Nucleus sampling. This is a number between 0 and 1.
+E.g. 0.1 would mean that only tokens with the top 10% probability mass are considered.
+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 presence penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@param frequencyPenalty - Frequency penalty setting.
+It affects the likelihood of the model to repeatedly use the same words or phrases.
+The frequency penalty is a number between -1 (increase repetition) and 1 (maximum penalty, decrease repetition).
+0 means no penalty.
+@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.
+
+@return
+A result object for accessing different stream types and additional information.
+ */
+declare function experimental_streamText<TOOLS extends Record<string, ExperimentalTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    /**
+The language model to use.
+     */
+    model: LanguageModelV1;
+    /**
+The tools that the model can call. The model needs to support calling tools.
+    */
+    tools?: TOOLS;
+}): Promise<StreamTextResult<TOOLS>>;
+type TextStreamPart<TOOLS extends Record<string, ExperimentalTool>> = {
+    type: 'text-delta';
+    textDelta: string;
+} | ({
+    type: 'tool-call';
+} & ToToolCall<TOOLS>) | {
+    type: 'error';
+    error: unknown;
+} | ({
+    type: 'tool-result';
+} & ToToolResult<TOOLS>) | {
+    type: 'finish';
+    finishReason: LanguageModelV1FinishReason;
+    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, ExperimentalTool>> {
+    private readonly originalStream;
+    /**
+  Warnings from the model provider (e.g. unsupported settings)
+     */
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor({ stream, warnings, }: {
+        stream: ReadableStream<TextStreamPart<TOOLS>>;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+    /**
+  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<any>;
+    /**
+  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.
+     */
+    toTextStreamResponse(init?: ResponseInit): Response;
+}
+
+interface FunctionCall {
+    /**
+     * 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.
+     */
+    arguments?: string;
+    /**
+     * The name of the function to call.
+     */
+    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;
+    };
+};
+/**
+ * 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.
+ */
+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;
+}
+type IdGenerator = () => string;
+/**
+ * Shared types between the API and UI packages.
+ */
+interface Message$1 {
+    id: string;
+    tool_call_id?: string;
+    createdAt?: Date;
+    content: string;
+    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;
+    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;
+}
+type CreateMessage = Omit<Message$1, 'id'> & {
+    id?: Message$1['id'];
+};
+type ChatRequest = {
+    messages: Message$1[];
+    options?: RequestOptions;
+    functions?: Array<Function>;
+    function_call?: FunctionCall;
+    data?: Record<string, string>;
+    tools?: Array<Tool>;
+    tool_choice?: ToolChoice;
+};
+type FunctionCallHandler = (chatMessages: Message$1[], functionCall: FunctionCall) => 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;
+    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;
+    /**
+     * 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;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void | Promise<void>;
+    /**
+     * Callback function to be called when the chat is finished streaming.
+     */
+    onFinish?: (message: Message$1) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * 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 credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the messages.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /**
+     * 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 = {
+    /**
+     * The API endpoint that accepts a `{ prompt: string }` object and returns
+     * a stream of tokens of the AI completion response. Defaults to `/api/completion`.
+     */
+    api?: string;
+    /**
+     * An unique identifier for the chat. If not provided, a random one will be
+     * generated. When provided, the `useChat` hook with the same `id` will
+     * have shared states across components.
+     */
+    id?: string;
+    /**
+     * Initial prompt input of the completion.
+     */
+    initialInput?: string;
+    /**
+     * Initial completion result. Useful to load an existing history.
+     */
+    initialCompletion?: string;
+    /**
+     * Callback function to be called when the API response is received.
+     */
+    onResponse?: (response: Response) => void | Promise<void>;
+    /**
+     * Callback function to be called when the completion is finished streaming.
+     */
+    onFinish?: (prompt: string, completion: string) => void;
+    /**
+     * Callback function to be called when an error is encountered.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * The credentials mode to be used for the fetch request.
+     * Possible values are: 'omit', 'same-origin', 'include'.
+     * Defaults to 'same-origin'.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * HTTP headers to be sent with the API request.
+     */
+    headers?: Record<string, string> | Headers;
+    /**
+     * Extra body object to be sent with the API request.
+     * @example
+     * Send a `sessionId` to the API along with the prompt.
+     * ```js
+     * useChat({
+     *   body: {
+     *     sessionId: '123',
+     *   }
+     * })
+     * ```
+     */
+    body?: object;
+    /** 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;
+    };
+}
+declare const textStreamPart: StreamPart<'0', 'text', string>;
+declare const functionCallStreamPart: StreamPart<'1', 'function_call', {
+    function_call: FunctionCall;
+}>;
+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 toolCallStreamPart: StreamPart<'7', 'tool_calls', {
+    tool_calls: ToolCall[];
+}>;
+declare const messageAnnotationsStreamPart: StreamPart<'8', 'message_annotations', Array<JSONValue>>;
+type StreamParts = typeof textStreamPart | typeof functionCallStreamPart | typeof dataStreamPart | typeof errorStreamPart | typeof assistantMessageStreamPart | typeof assistantControlDataStreamPart | typeof dataMessageStreamPart | typeof toolCallStreamPart | typeof messageAnnotationsStreamPart;
+/**
+ * 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 toolCallStreamPart.parse> | ReturnType<typeof messageAnnotationsStreamPart.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";
+};
+/**
+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.
+
+It ensures type-safety for the part type and value.
+ */
+declare function formatStreamPart<T extends keyof StreamPartValueType>(type: T, value: StreamPartValueType[T]): StreamString;
+
+/**
+ * Generates a 7-character random string to use for IDs. Not secure.
+ */
+declare const generateId: (size?: number | undefined) => string;
+
+/**
+Converts a ReadableStreamDefaultReader into an async generator that yields
+StreamPart objects.
+
+@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.
+ */
+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`;
+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;
+    /**
+     * The name and arguments of a function that should be called, as generated by the
+     * model.
+     */
+    function_call?: FunctionCall;
+    /**
+     * The role of the author of this message.
+     */
+    role?: 'system' | 'user' | 'assistant' | 'tool';
+    tool_calls?: Array<DeltaToolCall>;
+}
+interface DeltaToolCall {
+    index: number;
+    /**
+     * The ID of the tool call.
+     */
+    id?: string;
+    /**
+     * The function that the model called.
+     */
+    function?: ToolCallFunction;
+    /**
+     * The type of the tool. Currently, only `function` is supported.
+     */
+    type?: 'function';
+}
+interface ToolCallFunction {
+    /**
+     * 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.
+     */
+    arguments?: string;
+    /**
+     * 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.
+ */
+interface Completion {
+    /**
+     * A unique identifier for the completion.
+     */
+    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;
+    /**
+     * The model used for completion.
+     */
+    model: string;
+    /**
+     * The object type, which is always "text_completion"
+     */
+    object: string;
+    /**
+     * Usage statistics for the completion request.
+     */
+    usage?: CompletionUsage;
+}
+interface CompletionChoice {
+    /**
+     * 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.
+     */
+    finish_reason: 'stop' | 'length' | 'content_filter';
+    index: number;
+    logprobs: any | null;
+    text: string;
+}
+interface CompletionUsage {
+    /**
+     * Usage statistics for the completion request.
+     */
+    /**
+     * Number of tokens in the generated completion.
+     */
+    completion_tokens: number;
+    /**
+     * Number of tokens in the prompt.
+     */
+    prompt_tokens: number;
+    /**
+     * Total number of tokens used in the request (prompt + completion).
+     */
+    total_tokens: number;
+}
+type AsyncIterableOpenAIStreamReturnTypes = AsyncIterable<ChatCompletionChunk> | AsyncIterable<Completion> | AsyncIterable<AzureChatCompletions>;
+declare function OpenAIStream(res: Response | AsyncIterableOpenAIStreamReturnTypes, callbacks?: OpenAIStreamCallbacks): ReadableStream;
+
+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
+ */
+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;
+    /**
+     * @deprecated This flag is no longer used and only retained for backwards compatibility.
+     * You can remove it from your code.
+     */
+    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;
+    };
+}
+/**
+ * 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;
+}>;
+/**
+ * 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.
+ *
+ * This function is useful when you want to process a stream of messages and perform specific actions during the stream's lifecycle.
+ *
+ * @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.
+ *
+ * @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>;
+/**
+ * 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"
+ *
+ */
+declare function trimStartOfStreamHelper(): (text: string) => string;
+/**
+ * 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.
+ *
+ * For 2xx HTTP responses:
+ * - The function continues with standard stream processing.
+ *
+ * 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.
+ */
+declare function AIStream(response: Response, customParser?: AIStreamParser, callbacks?: AIStreamCallbacksAndOptions): ReadableStream<Uint8Array>;
+/**
+ * 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>;
+
+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;
+    /**
+     * The model that handled the request.
+     */
+    model: string;
+    /**
+     * 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
+     */
+    stop_reason: string | null;
+    /**
+     * Object type.
+     *
+     * For Text Completions, this is always `"completion"`.
+     */
+    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';
+}
+interface ContentBlockStartEvent {
+    content_block: ContentBlock;
+    index: number;
+    type: 'content_block_start';
+}
+interface ContentBlockStopEvent {
+    index: number;
+    type: 'content_block_stop';
+}
+interface MessageDeltaEventDelta {
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | null;
+    stop_sequence: string | null;
+}
+interface MessageDeltaEvent {
+    delta: MessageDeltaEventDelta;
+    type: 'message_delta';
+}
+type MessageStreamEvent = MessageStartEvent | MessageDeltaEvent | MessageStopEvent | ContentBlockStartEvent | ContentBlockDeltaEvent | ContentBlockStopEvent;
+interface MessageStartEvent {
+    message: Message;
+    type: 'message_start';
+}
+interface MessageStopEvent {
+    type: 'message_stop';
+}
+/**
+ * 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.
+ */
+type AssistantResponseSettings = {
+    /**
+  The thread ID that the response is associated with.
+     */
+    threadId: string;
+    /**
+  The ID of the latest message that the response is associated with.
+   */
+    messageId: string;
+};
+/**
+The process parameter is a callback in which you can run the assistant on threads, and send messages and data messages to the client.
+ */
+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;
+    /**
+  Send a data message to the client. You can use this to provide information for rendering custom UIs while the assistant is processing the thread.
+   */
+    sendDataMessage: (message: DataMessage) => void;
+    /**
+  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>;
+}) => Promise<void>;
+/**
+The `AssistantResponse` allows you to send a stream of assistant update to `useAssistant`.
+It is designed to facilitate streaming assistant responses to the `useAssistant` hook.
+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.
+ */
+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;
+}
+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;
+
+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>;
+    };
+};
+
+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: TransformStream<Uint8Array, Uint8Array>;
+    private isClosedPromise;
+    private isClosedPromiseResolver;
+    private isClosed;
+    private data;
+    private messageAnnotations;
+    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 {
+}
+
+/**
+ * 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;
+};
+type ReactResponseRow = Payload & {
+    next: null | Promise<ReactResponseRow>;
+};
+/**
+ * A utility class for streaming React responses.
+ */
+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);
+}
+/**
+ * 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;
+}): void;
+
+export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicMessagesStream, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantContent, AssistantMessage, AssistantResponse, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, DataContent, DataMessage, DeepPartial, ErrorStreamPart, ExperimentalAssistantMessage, ExperimentalMessage, ExperimentalTool, ExperimentalToolMessage, ExperimentalUserMessage, Function, FunctionCall, FunctionCallHandler, FunctionCallPayload, GenerateObjectResult, GenerateTextResult, GoogleGenerativeAIStream, HuggingFaceStream, IdGenerator, ImagePart, InkeepAIStreamCallbacksAndOptions, InkeepChatResultCallbacks, InkeepOnFinalMetadata, InkeepStream, JSONValue, LangChainStream, Message$1 as Message, MistralStream, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamData, StreamObjectResult, StreamPart, StreamString, StreamTextResult, StreamingTextResponse, TextPart$1 as TextPart, TextStreamPart, Tool, ToolCall, ToolCallHandler, ToolCallPart, ToolCallPayload, ToolChoice, ToolContent, ToolResultPart, UseChatOptions, UseCompletionOptions, UserContent, convertDataContentToBase64String, convertDataContentToUint8Array, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_AssistantResponse, experimental_StreamData, experimental_StreamingReactResponse, experimental_generateObject, experimental_generateText, experimental_streamObject, experimental_streamText, formatStreamPart, generateId, isStreamStringEqualToType, generateId as nanoid, parseStreamPart, readDataStream, readableFromAsyncIterable, streamToResponse, tool, trimStartOfStreamHelper };