ai 3.0.12 → 3.0.14

package/dist/index.d.ts

@@ -1,7 +1,684 @@
+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 JsonSchema = Record<string, unknown>;
+
+type LanguageModelV1CallSettings = {
+    /**
+     * Maximum number of tokens to generate.
+     */
+    maxTokens?: number;
+    /**
+     * Temperature setting. This is a number between 0 (almost no randomness) and
+     * 1 (very random).
+     *
+     * Different LLM providers have different temperature
+     * scales, so they'd need to map it (without mapping, the same temperature has
+     * different effects on different models). The provider can also chose to map
+     * this to topP, potentially even using a custom setting on their model.
+     *
+     * Note: This is an example of a setting that requires a clear specification of
+     * the semantics.
+     */
+    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.
+     */
+    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.
+     */
+    frequencyPenalty?: number;
+    /**
+     * The seed (integer) to use for random sampling. If set and supported
+     * by the model, calls will generate deterministic results.
+     */
+    seed?: number;
+    /**
+     * Abort signal for cancelling the operation.
+     */
+    abortSignal?: AbortSignal;
+};
+
+/**
+ * A tool has a name, a description, and a set of parameters.
+ *
+ * Note: this is **not** the user-facing tool definition. The AI SDK methods will
+ * map the user-facing tool definitions to this format.
+ */
+type LanguageModelV1FunctionTool = {
+    /**
+     * The type of the tool. Only functions for now, but this gives us room to
+     * add more specific tool types in the future and use a discriminated union.
+     */
+    type: 'function';
+    /**
+     * The name of the tool. Unique within this model call.
+     */
+    name: string;
+    description?: string;
+    parameters: JsonSchema;
+};
+
+/**
+ * A prompt is a list of messages.
+ *
+ * Note: Not all models and prompt formats support multi-modal inputs and
+ * tool calls. The validation happens at runtime.
+ *
+ * Note: This is not a user-facing prompt. The AI SDK methods will map the
+ * user-facing prompt types such as chat or instruction prompts to this format.
+ */
+type LanguageModelV1Prompt = Array<LanguageModelV1Message>;
+type LanguageModelV1Message = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: Array<LanguageModelV1TextPart | LanguageModelV1ImagePart>;
+} | {
+    role: 'assistant';
+    content: Array<LanguageModelV1TextPart | LanguageModelV1ToolCallPart>;
+} | {
+    role: 'tool';
+    content: Array<LanguageModelV1ToolResultPart>;
+};
+interface LanguageModelV1TextPart {
+    type: 'text';
+    /**
+     * The text content.
+     */
+    text: string;
+}
+interface LanguageModelV1ImagePart {
+    type: 'image';
+    /**
+     * Image data as a Uint8Array (e.g. from a Blob or Buffer) or a URL.
+     */
+    image: Uint8Array | URL;
+    /**
+     * Optional mime type of the image.
+     */
+    mimeType?: string;
+}
+interface LanguageModelV1ToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+interface LanguageModelV1ToolResultPart {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+}
+
+type LanguageModelV1CallOptions = LanguageModelV1CallSettings & {
+    /**
+     * Whether the user provided the input as messages or as
+     * a prompt. This can help guide non-chat models in the
+     * expansion, bc different expansions can be needed for
+     * chat/non-chat use cases.
+     */
+    inputFormat: 'messages' | 'prompt';
+    /**
+     * The mode affects the behavior of the language model. It is required to
+     * support provider-independent streaming and generation of structured objects.
+     * The model can take this information and e.g. configure json mode, the correct
+     * low level grammar, etc. It can also be used to optimize the efficiency of the
+     * streaming, e.g. tool-delta stream parts are only needed in the
+     * object-tool mode.
+     */
+    mode: {
+        type: 'regular';
+        tools?: Array<LanguageModelV1FunctionTool>;
+    } | {
+        type: 'object-json';
+    } | {
+        type: 'object-grammar';
+        schema: JsonSchema;
+    } | {
+        type: 'object-tool';
+        tool: LanguageModelV1FunctionTool;
+    };
+    /**
+     * A language mode prompt is a standardized prompt type.
+     *
+     * Note: This is **not** the user-facing prompt. The AI SDK methods will map the
+     * user-facing prompt types such as chat or instruction prompts to this format.
+     * That approach allows us to evolve the user  facing prompts without breaking
+     * the language model interface.
+     */
+    prompt: LanguageModelV1Prompt;
+};
+
+/**
+ * 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 LanguageModelV1CallWarning = {
+    type: 'unsupported-setting';
+    setting: keyof LanguageModelV1CallSettings;
+} | {
+    type: 'other';
+    message: string;
+};
+
+type LanguageModelV1FinishReason = 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other';
+
+type LanguageModelV1FunctionToolCall = {
+    toolCallType: 'function';
+    toolCallId: string;
+    toolName: string;
+    /**
+     * Stringified JSON object with the tool call arguments. Must match the
+     * parameters schema of the tool.
+     */
+    args: string;
+};
+
+type LanguageModelV1 = {
+    /**
+     * The language model must specify which language model interface
+     * version it implements. This will allow us to evolve the language
+     * model interface and retain backwards compatibility. The different
+     * implementation versions can be handled as a discriminated union
+     * on our side.
+     */
+    readonly specificationVersion: 'v1';
+    /**
+     * Name of the provider for logging purposes.
+     */
+    readonly provider: string;
+    /**
+     * Provider-specific model ID for logging purposes.
+     */
+    readonly modelId: string;
+    /**
+     * Default object generation mode that should be used with this model when
+     * no mode is specified. Should be the mode with the best results for this
+     * model. `undefined` can be returned if object generation is not supported.
+     *
+     * This is needed to generate the best objects possible w/o requiring the
+     * user to explicitly specify the object generation mode.
+     */
+    readonly defaultObjectGenerationMode: 'json' | 'tool' | 'grammar' | undefined;
+    /**
+     * Generates a language model output (non-streaming).
+     *
+     * Naming: "do" prefix to prevent accidental direct usage of the method
+     * by the user.
+     */
+    doGenerate(options: LanguageModelV1CallOptions): PromiseLike<{
+        /**
+         * Text that the model has generated. Can be undefined if the model
+         * has only generated tool calls.
+         */
+        text?: string;
+        /**
+         * Tool calls that the model has generated. Can be undefined if the
+         * model has only generated text.
+         */
+        toolCalls?: Array<LanguageModelV1FunctionToolCall>;
+        /**
+         * Finish reason.
+         */
+        finishReason: LanguageModelV1FinishReason;
+        /**
+         * Usage information.
+         */
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+        };
+        /**
+         * Raw prompt and setting information for observability provider integration.
+         */
+        rawCall: {
+            /**
+             * Raw prompt after expansion and conversion to the format that the
+             * provider uses to send the information to their API.
+             */
+            rawPrompt: unknown;
+            /**
+             * Raw settings that are used for the API call. Includes provider-specific
+             * settings.
+             */
+            rawSettings: Record<string, unknown>;
+        };
+        warnings?: LanguageModelV1CallWarning[];
+    }>;
+    /**
+     * Generates a language model output (streaming).
+     *
+     * Naming: "do" prefix to prevent accidental direct usage of the method
+     * by the user.
+     *
+     * @return A stream of higher-level language model output parts.
+     */
+    doStream(options: LanguageModelV1CallOptions): PromiseLike<{
+        stream: ReadableStream<LanguageModelV1StreamPart>;
+        /**
+         * Raw prompt and setting information for observability provider integration.
+         */
+        rawCall: {
+            /**
+             * Raw prompt after expansion and conversion to the format that the
+             * provider uses to send the information to their API.
+             */
+            rawPrompt: unknown;
+            /**
+             * Raw settings that are used for the API call. Includes provider-specific
+             * settings.
+             */
+            rawSettings: Record<string, unknown>;
+        };
+        warnings?: LanguageModelV1CallWarning[];
+    }>;
+};
+type LanguageModelV1StreamPart = {
+    type: 'text-delta';
+    textDelta: string;
+} | ({
+    type: 'tool-call';
+} & LanguageModelV1FunctionToolCall) | {
+    type: 'tool-call-delta';
+    toolCallType: 'function';
+    toolCallId: string;
+    toolName: string;
+    argsTextDelta: string;
+} | {
+    type: 'finish';
+    finishReason: LanguageModelV1FinishReason;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+} | {
+    type: 'error';
+    error: unknown;
+};
+
+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;
+declare function convertDataContentToBase64String(content: DataContent): string;
+declare function convertDataContentToUint8Array(content: DataContent): Uint8Array;
+
+interface TextPart$1 {
+    type: 'text';
+    /**
+     * The text content.
+     */
+    text: string;
+}
+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;
+}
+interface ToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+interface ToolResultPart {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+}
+
+type ExperimentalMessage = ExperimentalUserMessage | ExperimentalAssistantMessage | ExperimentalToolMessage;
+type ExperimentalUserMessage = {
+    role: 'user';
+    content: UserContent;
+};
+type ExperimentalAssistantMessage = {
+    role: 'assistant';
+    content: AssistantContent;
+};
+type ExperimentalToolMessage = {
+    role: 'tool';
+    content: ToolContent;
+};
+type UserContent = string | Array<TextPart$1 | ImagePart>;
+type AssistantContent = string | Array<TextPart$1 | ToolCallPart>;
+type ToolContent = Array<ToolResultPart>;
+
+type Prompt = {
+    system?: string;
+    prompt?: string;
+    messages?: Array<ExperimentalMessage>;
+};
+
+/**
+ * Generate a structured, typed object using a language model.
+ */
+declare function experimental_generateObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    model: LanguageModelV1;
+    schema: z.Schema<T>;
+    mode?: 'auto' | 'json' | 'tool' | 'grammar';
+}): Promise<GenerateObjectResult<T>>;
+declare class GenerateObjectResult<T> {
+    readonly object: T;
+    readonly finishReason: LanguageModelV1FinishReason;
+    readonly usage: TokenUsage;
+    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]>;
+};
+
+/**
+ * Stream an object as a partial object stream.
+ */
+declare function experimental_streamObject<T>({ model, schema, mode, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    model: LanguageModelV1;
+    schema: z.Schema<T>;
+    mode?: 'auto' | 'json' | 'tool' | 'grammar';
+}): Promise<StreamObjectResult<T>>;
+declare class StreamObjectResult<T> {
+    private readonly originalStream;
+    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> {
+    /**
+     * A 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]: {
+        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]: {
+        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 using a language model.
+ */
+declare function experimental_generateText<TOOLS extends Record<string, ExperimentalTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    model: LanguageModelV1;
+    tools?: TOOLS;
+}): Promise<GenerateTextResult<TOOLS>>;
+declare class GenerateTextResult<TOOLS extends Record<string, ExperimentalTool>> {
+    readonly text: string;
+    readonly toolCalls: ToToolCallArray<TOOLS>;
+    readonly toolResults: ToToolResultArray<TOOLS>;
+    readonly finishReason: LanguageModelV1FinishReason;
+    readonly usage: TokenUsage;
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor(options: {
+        text: string;
+        toolCalls: ToToolCallArray<TOOLS>;
+        toolResults: ToToolResultArray<TOOLS>;
+        finishReason: LanguageModelV1FinishReason;
+        usage: TokenUsage;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+}
+
+/**
+ * Stream text generated by a language model.
+ */
+declare function experimental_streamText<TOOLS extends Record<string, ExperimentalTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, ...settings }: CallSettings & Prompt & {
+    model: LanguageModelV1;
+    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;
+    };
+};
+declare class StreamTextResult<TOOLS extends Record<string, ExperimentalTool>> {
+    private readonly originalStream;
+    readonly warnings: LanguageModelV1CallWarning[] | undefined;
+    constructor({ stream, warnings, }: {
+        stream: ReadableStream<TextStreamPart<TOOLS>>;
+        warnings: LanguageModelV1CallWarning[] | undefined;
+    });
+    get textStream(): AsyncIterableStream<string>;
+    get fullStream(): AsyncIterableStream<TextStreamPart<TOOLS>>;
+    toAIStream(callbacks?: AIStreamCallbacksAndOptions): ReadableStream<any>;
+}
+
 interface FunctionCall {
     /**
      * The arguments to call the function with, as generated by the model in JSON
@@ -341,7 +1018,11 @@ declare const StreamStringPrefixes: {
     readonly message_annotations: "8";
 };
 
-declare const nanoid: (size?: number | undefined) => string;
+/**
+ * Generates a 7-character random string to use for IDs. Not secure.
+ */
+declare const generateId: (size?: number | undefined) => string;
+
 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[];
@@ -805,7 +1486,7 @@ type AssistantResponseCallback = (options: {
     messageId: string;
     sendMessage: (message: AssistantMessage) => void;
     sendDataMessage: (message: DataMessage) => void;
-    forwardStream: (stream: AssistantStream) => Promise<any>;
+    forwardStream: (stream: AssistantStream) => Promise<Run | undefined>;
 }) => Promise<void>;
 declare function experimental_AssistantResponse({ threadId, messageId }: AssistantResponseSettings, process: AssistantResponseCallback): Response;
 
@@ -816,6 +1497,7 @@ interface AWSBedrockResponse {
         };
     }>;
 }
+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;
@@ -976,7 +1658,7 @@ declare class experimental_StreamingReactResponse {
     constructor(res: ReadableStream, options?: {
         ui?: (message: {
             content: string;
-            data?: JSONValue[] | undefined;
+            data?: JSONValue[];
         }) => UINode | Promise<UINode>;
         data?: experimental_StreamData;
         generateId?: IdGenerator;
@@ -997,4 +1679,4 @@ declare function streamToResponse(res: ReadableStream, response: ServerResponse,
     status?: number;
 }): void;
 
-export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantMessage, COMPLEX_HEADER, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, DataMessage, Function, FunctionCall, FunctionCallHandler, FunctionCallPayload, GoogleGenerativeAIStream, HuggingFaceStream, IdGenerator, InkeepAIStreamCallbacksAndOptions, InkeepChatResultCallbacks, InkeepOnFinalMetadata, InkeepStream, JSONValue, LangChainStream, Message$1 as Message, MistralStream, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamString, StreamingTextResponse, Tool, ToolCall, ToolCallHandler, ToolCallPayload, ToolChoice, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_AssistantResponse, experimental_StreamData, experimental_StreamingReactResponse, isStreamStringEqualToType, nanoid, readableFromAsyncIterable, streamToResponse, trimStartOfStreamHelper };
+export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AIStreamParserOptions, AWSBedrockAnthropicMessagesStream, AWSBedrockAnthropicStream, AWSBedrockCohereStream, AWSBedrockLlama2Stream, AWSBedrockStream, AnthropicStream, AssistantContent, AssistantMessage, COMPLEX_HEADER, 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, StreamObjectResult, 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, generateId, isStreamStringEqualToType, generateId as nanoid, readableFromAsyncIterable, streamToResponse, tool, trimStartOfStreamHelper };