ai 3.0.13 → 3.0.15

package/dist/index.d.mts

@@ -1,8 +1,999 @@
+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;
+};
+
+/**
+ * Experimental: Specification for a language model that implements the language model
+ * interface version 1.
+ */
+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;
+/**
+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;
+}
+
+/**
+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 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 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]: {
+        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 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>;
+}
+
 interface FunctionCall {
     /**
      * The arguments to call the function with, as generated by the model in JSON
@@ -342,7 +1333,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[];
@@ -817,6 +1812,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;
@@ -998,4 +1994,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 };