ai 5.0.0-canary.3 → 5.0.0-canary.5

package/{rsc/dist/rsc-server.d.mts → dist/internal/index.d.mts}

@@ -1,244 +1,246 @@
-import { LanguageModelV2FinishReason, LanguageModelV2CallWarning, LanguageModelV2ProviderMetadata, LanguageModelV2 } from '@ai-sdk/provider';
-import { ReactNode } from 'react';
 import { z } from 'zod';
-import { Message } from '@ai-sdk/ui-utils';
+import { ToolCall, ToolResult, Validator } from '@ai-sdk/provider-utils';
+import { JSONSchema7 } from 'json-schema';
+import { LanguageModelV2ProviderMetadata, LanguageModelV2Source, LanguageModelV2FunctionTool, LanguageModelV2ProviderDefinedTool, LanguageModelV2ToolChoice, LanguageModelV2Prompt } from '@ai-sdk/provider';
 
-type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
-type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
-type AIProviderProps<AIState = any, UIState = any, Actions = any> = {
-    children: React.ReactNode;
-    initialAIState?: AIState;
-    initialUIState?: UIState;
-    /** $ActionTypes is only added for type inference and is never used at runtime **/
-    $ActionTypes?: Actions;
-};
-type AIProvider<AIState = any, UIState = any, Actions = any> = (props: AIProviderProps<AIState, UIState, Actions>) => Promise<React.ReactElement>;
-type InferAIState<T, Fallback> = T extends AIProvider<infer AIState, any, any> ? AIState : Fallback;
-type OnSetAIState<S> = ({ key, state, done, }: {
-    key: string | number | symbol | undefined;
-    state: S;
-    done: boolean;
-}) => void | Promise<void>;
-type OnGetUIState<S> = AIAction<void, S | undefined>;
-type ValueOrUpdater<T> = T | ((current: T) => T);
-type MutableAIState<AIState> = {
-    get: () => AIState;
-    update: (newState: ValueOrUpdater<AIState>) => void;
-    done: ((newState: AIState) => void) | (() => void);
+/**
+Tool choice for the generation. It supports the following settings:
+
+- `auto` (default): the model can choose whether and which tools to call.
+- `required`: the model must call a tool. It can choose which tool to call.
+- `none`: the model must not call tools
+- `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ */
+type ToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
+    type: 'tool';
+    toolName: keyof TOOLS;
 };
 
 /**
- * Get the current AI state.
- * If `key` is provided, it will return the value of the specified key in the
- * AI state, if it's an object. If it's not an object, it will throw an error.
- *
- * @example const state = getAIState() // Get the entire AI state
- * @example const field = getAIState('key') // Get the value of the key
- */
-declare function getAIState<AI extends AIProvider = any>(): Readonly<InferAIState<AI, any>>;
-declare function getAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): Readonly<InferAIState<AI, any>[typeof key]>;
-/**
- * Get the mutable AI state. Note that you must call `.done()` when finishing
- * updating the AI state.
- *
- * @example
- * ```tsx
- * const state = getMutableAIState()
- * state.update({ ...state.get(), key: 'value' })
- * state.update((currentState) => ({ ...currentState, key: 'value' }))
- * state.done()
- * ```
- *
- * @example
- * ```tsx
- * const state = getMutableAIState()
- * state.done({ ...state.get(), key: 'value' }) // Done with a new state
- * ```
- */
-declare function getMutableAIState<AI extends AIProvider = any>(): MutableAIState<InferAIState<AI, any>>;
-declare function getMutableAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): MutableAIState<InferAIState<AI, any>[typeof key]>;
+Additional provider-specific metadata that is returned from the provider.
+
+This is needed to enable provider-specific functionality that can be
+fully encapsulated in the provider.
+ */
+type ProviderMetadata = LanguageModelV2ProviderMetadata;
+/**
+Additional provider-specific options.
 
-declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, onSetAIState, onGetUIState, }: {
-    actions: Actions;
-    initialAIState?: AIState;
-    initialUIState?: UIState;
+They are passed through to the provider from the AI SDK and enable
+provider-specific functionality that can be fully encapsulated in the provider.
+ */
+type ProviderOptions = LanguageModelV2ProviderMetadata;
+
+/**
+Represents the number of tokens used in a prompt and completion.
+ */
+type LanguageModelUsage = {
     /**
-     * This function is called whenever the AI state is updated by an Action.
-     * You can use this to persist the AI state to a database, or to send it to a
-     * logging service.
+  The number of tokens used in the prompt.
      */
-    onSetAIState?: OnSetAIState<AIState>;
+    promptTokens: number;
     /**
-     * This function is used to retrieve the UI state based on the AI state.
-     * For example, to render the initial UI state based on a given AI state, or
-     * to sync the UI state when the application is already loaded.
-     *
-     * If returning `undefined`, the client side UI state will not be updated.
-     *
-     * This function must be annotated with the `"use server"` directive.
-     *
-     * @example
-     * ```tsx
-     * onGetUIState: async () => {
-     *   'use server';
-     *
-     *   const currentAIState = getAIState();
-     *   const externalAIState = await loadAIStateFromDatabase();
-     *
-     *   if (currentAIState === externalAIState) return undefined;
-     *
-     *   // Update current AI state and return the new UI state
-     *   const state = getMutableAIState()
-     *   state.done(externalAIState)
-     *
-     *   return <div>...</div>;
-     * }
-     * ```
+  The number of tokens used in the completion.
+   */
+    completionTokens: number;
+    /**
+  The total number of tokens used (promptTokens + completionTokens).
      */
-    onGetUIState?: OnGetUIState<UIState>;
-}): AIProvider<AIState, UIState, Actions>;
+    totalTokens: number;
+};
+declare function calculateLanguageModelUsage({ promptTokens, completionTokens, }: {
+    promptTokens: number;
+    completionTokens: number;
+}): LanguageModelUsage;
 
-type CallSettings = {
+/**
+Tool invocations are either tool calls or tool results. For each assistant tool call,
+there is one tool invocation. While the call is in progress, the invocation is a tool call.
+Once the call is complete, the invocation is a tool result.
+
+The step is used to track how to map an assistant UI message with many tool invocations
+back to a sequence of LLM assistant/tool result message pairs.
+It is optional for backwards compatibility.
+ */
+type ToolInvocation = ({
+    state: 'partial-call';
+    step?: number;
+} & ToolCall<string, any>) | ({
+    state: 'call';
+    step?: number;
+} & ToolCall<string, any>) | ({
+    state: 'result';
+    step?: number;
+} & ToolResult<string, any, any>);
+/**
+ * An attachment that can be sent along with a message.
+ */
+interface Attachment {
     /**
-  Maximum number of tokens to generate.
+     * The name of the attachment, usually the file name.
      */
-    maxTokens?: number;
+    name?: string;
     /**
-  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
+     * A string indicating the [media type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type).
+     * By default, it's extracted from the pathname's extension.
      */
-    temperature?: number;
+    contentType?: string;
     /**
-  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.
+     * The URL of the attachment. It can either be a URL to a hosted file or a [Data URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs).
      */
-    topP?: number;
+    url: string;
+}
+/**
+ * AI SDK UI Messages. They are used in the client and to communicate between the frontend and the API routes.
+ */
+interface Message {
     /**
-  Only sample from the top K options for each subsequent token.
-  
-  Used to remove "long tail" low probability responses.
-  Recommended for advanced use cases only. You usually only need to use temperature.
+  A unique identifier for the message.
      */
-    topK?: number;
+    id: string;
     /**
-  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.
+  The timestamp of the message.
      */
-    presencePenalty?: number;
+    createdAt?: Date;
     /**
-  Frequency penalty setting. It affects the likelihood of the model
-  to repeatedly use the same words or phrases.
+  Text content of the message. Use parts when possible.
+     */
+    content: string;
+    /**
+  Reasoning for the message.
   
-  The frequency penalty is a number between -1 (increase repetition)
-  and 1 (maximum penalty, decrease repetition). 0 means no penalty.
+  @deprecated Use `parts` instead.
      */
-    frequencyPenalty?: number;
+    reasoning?: string;
     /**
-  Stop sequences.
-  If set, the model will stop generating text when one of the stop sequences is generated.
-  Providers may have limits on the number of stop sequences.
+     * Additional attachments to be sent along with the message.
      */
-    stopSequences?: string[];
+    experimental_attachments?: Attachment[];
     /**
-  The seed (integer) to use for random sampling. If set and supported
-  by the model, calls will generate deterministic results.
+  The 'data' role is deprecated.
      */
-    seed?: number;
+    role: 'system' | 'user' | 'assistant' | 'data';
     /**
-  Maximum number of retries. Set to 0 to disable retries.
+  For data messages.
   
-  @default 2
+  @deprecated Data messages will be removed.
      */
-    maxRetries?: number;
+    data?: JSONValue;
     /**
-  Abort signal.
+     * Additional message-specific information added on the server via StreamData
      */
-    abortSignal?: AbortSignal;
+    annotations?: JSONValue[] | undefined;
     /**
-  Additional HTTP headers to be sent with the request.
-  Only applicable for HTTP-based providers.
+  Tool invocations (that can be tool calls or tool results, depending on whether or not the invocation has finished)
+  that the assistant made as part of this message.
+  
+  @deprecated Use `parts` instead.
      */
-    headers?: Record<string, string | undefined>;
-};
-
-/**
-Reason why a language model finished generating a response.
-
-Can be one of the following:
-- `stop`: model generated stop sequence
-- `length`: model generated maximum number of tokens
-- `content-filter`: content filter violation stopped the model
-- `tool-calls`: model triggered tool calls
-- `error`: model stopped because of an error
-- `other`: model stopped for other reasons
-*/
-type FinishReason = LanguageModelV2FinishReason;
-/**
-Warning from the model provider for this call. The call will proceed, but e.g.
-some settings might not be supported, which can lead to suboptimal results.
-*/
-type CallWarning = LanguageModelV2CallWarning;
+    toolInvocations?: Array<ToolInvocation>;
+    /**
+     * The parts of the message. Use this for rendering the message in the UI.
+     *
+     * Assistant messages can have text, reasoning and tool invocation parts.
+     * User messages can have text parts.
+     */
+    parts?: Array<TextUIPart | ReasoningUIPart | ToolInvocationUIPart | SourceUIPart | FileUIPart | StepStartUIPart>;
+}
 /**
-Tool choice for the generation. It supports the following settings:
-
-- `auto` (default): the model can choose whether and which tools to call.
-- `required`: the model must call a tool. It can choose which tool to call.
-- `none`: the model must not call tools
-- `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ * A text part of a message.
  */
-type ToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
-    type: 'tool';
-    toolName: keyof TOOLS;
+type TextUIPart = {
+    type: 'text';
+    /**
+     * The text content.
+     */
+    text: string;
 };
-
 /**
-Additional provider-specific metadata that is returned from the provider.
-
-This is needed to enable provider-specific functionality that can be
-fully encapsulated in the provider.
+ * A reasoning part of a message.
  */
-type ProviderMetadata = LanguageModelV2ProviderMetadata;
+type ReasoningUIPart = {
+    type: 'reasoning';
+    /**
+     * The reasoning text.
+     */
+    reasoning: string;
+    details: Array<{
+        type: 'text';
+        text: string;
+        signature?: string;
+    } | {
+        type: 'redacted';
+        data: string;
+    }>;
+};
 /**
-Additional provider-specific options.
-
-They are passed through to the provider from the AI SDK and enable
-provider-specific functionality that can be fully encapsulated in the provider.
+ * A tool invocation part of a message.
  */
-type ProviderOptions = LanguageModelV2ProviderMetadata;
-
+type ToolInvocationUIPart = {
+    type: 'tool-invocation';
+    /**
+     * The tool invocation.
+     */
+    toolInvocation: ToolInvocation;
+};
 /**
-Represents the number of tokens used in a prompt and completion.
+ * A source part of a message.
  */
-type LanguageModelUsage = {
+type SourceUIPart = {
+    type: 'source';
     /**
-  The number of tokens used in the prompt.
+     * The source.
      */
-    promptTokens: number;
+    source: LanguageModelV2Source;
+};
+/**
+ * A file part of a message.
+ */
+type FileUIPart = {
+    type: 'file';
     /**
-  The number of tokens used in the completion.
-   */
-    completionTokens: number;
+     * IANA media type of the file.
+     *
+     * @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType: string;
     /**
-  The total number of tokens used (promptTokens + completionTokens).
+     * The base64 encoded data.
      */
-    totalTokens: number;
+    data: string;
+};
+/**
+ * A step boundary part of a message.
+ */
+type StepStartUIPart = {
+    type: 'step-start';
 };
+/**
+A JSON value can be a string, number, boolean, object, array, or null.
+JSON values can be serialized and deserialized by the JSON.stringify and JSON.parse methods.
+ */
+type JSONValue = null | string | number | boolean | {
+    [value: string]: JSONValue;
+} | Array<JSONValue>;
 
 /**
-Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
+ * Used to mark schemas so we can support both Zod and custom schemas.
  */
-type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
+declare const schemaSymbol: unique symbol;
+type Schema<OBJECT = unknown> = Validator<OBJECT> & {
+    /**
+     * Used to mark schemas so we can support both Zod and custom schemas.
+     */
+    [schemaSymbol]: true;
+    /**
+     * Schema type for inference.
+     */
+    _type: OBJECT;
+    /**
+     * The JSON Schema for the schema. It is passed to the providers.
+     */
+    readonly jsonSchema: JSONSchema7;
+};
 
 type ToolResultContent = Array<{
     type: 'text';
@@ -246,9 +248,18 @@ type ToolResultContent = Array<{
 } | {
     type: 'image';
     data: string;
+    mediaType?: string;
+    /**
+     * @deprecated Use `mediaType` instead.
+     */
     mimeType?: string;
 }>;
 
+/**
+Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer.
+ */
+type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
+
 /**
 Text content part of a prompt. It contains a string of text.
  */
@@ -282,7 +293,13 @@ interface ImagePart {
      */
     image: DataContent | URL;
     /**
-  Optional mime type of the image.
+  Optional IANA media type of the image.
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType?: string;
+    /**
+  @deprecated Use `mediaType` instead.
      */
     mimeType?: string;
     /**
@@ -313,9 +330,15 @@ interface FilePart {
      */
     filename?: string;
     /**
-  Mime type of the file.
+  IANA media type of the file.
+  
+  @see https://www.iana.org/assignments/media-types/media-types.xhtml
      */
-    mimeType: string;
+    mediaType: string;
+    /**
+  @deprecated Use `mediaType` instead.
+     */
+    mimeType?: string;
     /**
   Additional provider-specific metadata. They are passed through
   to the provider from the AI SDK and enable provider-specific
@@ -527,6 +550,76 @@ It can be a user message, an assistant message, or a tool message.
  */
 type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage | CoreToolMessage;
 
+type ToolParameters = z.ZodTypeAny | Schema<any>;
+type inferParameters<PARAMETERS extends ToolParameters> = PARAMETERS extends Schema<any> ? PARAMETERS['_type'] : PARAMETERS extends z.ZodTypeAny ? z.infer<PARAMETERS> : never;
+interface ToolExecutionOptions {
+    /**
+     * The ID of the tool call. You can use it e.g. when sending tool-call related information with stream data.
+     */
+    toolCallId: string;
+    /**
+     * Messages that were sent to the language model to initiate the response that contained the tool call.
+     * The messages **do not** include the system prompt nor the assistant response that contained the tool call.
+     */
+    messages: CoreMessage[];
+    /**
+     * An optional abort signal that indicates that the overall operation should be aborted.
+     */
+    abortSignal?: AbortSignal;
+}
+/**
+A tool contains the description and the schema of the input that the tool expects.
+This enables the language model to generate the input.
+
+The tool can also contain an optional execute function for the actual execution function of the tool.
+ */
+type Tool<PARAMETERS extends ToolParameters = any, RESULT = any> = {
+    /**
+  The schema of the input that the tool expects. The language model will use this to generate the input.
+  It is also used to validate the output of the language model.
+  Use descriptions to make the input understandable for the language model.
+     */
+    parameters: PARAMETERS;
+    /**
+  An optional description of what the tool does.
+  Will be used by the language model to decide whether to use the tool.
+  Not used for provider-defined tools.
+     */
+    description?: string;
+    /**
+  Optional conversion function that maps the tool result to multi-part tool content for LLMs.
+     */
+    experimental_toToolResultContent?: (result: RESULT) => ToolResultContent;
+    /**
+  An async function that is called with the arguments from the tool call and produces a result.
+  If not provided, the tool will not be executed automatically.
+  
+  @args is the input of the tool call.
+  @options.abortSignal is a signal that can be used to abort the tool call.
+     */
+    execute?: (args: inferParameters<PARAMETERS>, options: ToolExecutionOptions) => PromiseLike<RESULT>;
+} & ({
+    /**
+Function tool.
+     */
+    type?: undefined | 'function';
+} | {
+    /**
+Provider-defined tool.
+     */
+    type: 'provider-defined';
+    /**
+The ID of the tool. Should follow the format `<provider-name>.<tool-name>`.
+     */
+    id: `${string}.${string}`;
+    /**
+The arguments for configuring the tool. Must match the expected arguments defined by the provider for this tool.
+     */
+    args: Record<string, unknown>;
+});
+
+type ToolSet = Record<string, Tool>;
+
 /**
 Prompt part of the AI function options.
 It contains a system message, a simple text prompt, or a list of messages.
@@ -546,203 +639,144 @@ type Prompt = {
     messages?: Array<CoreMessage> | Array<Omit<Message, 'id'>>;
 };
 
-type Streamable = ReactNode | Promise<ReactNode>;
-type Renderer<T extends Array<any>> = (...args: T) => Streamable | Generator<Streamable, Streamable, void> | AsyncGenerator<Streamable, Streamable, void>;
-type RenderTool<PARAMETERS extends z.ZodTypeAny = any> = {
-    description?: string;
-    parameters: PARAMETERS;
-    generate?: Renderer<[
-        z.infer<PARAMETERS>,
-        {
-            toolName: string;
-            toolCallId: string;
-        }
-    ]>;
-};
-type RenderText = Renderer<[
-    {
-        /**
-         * The full text content from the model so far.
-         */
-        content: string;
-        /**
-         * The new appended text content from the model since the last `text` call.
-         */
-        delta: string;
-        /**
-         * Whether the model is done generating text.
-         * If `true`, the `content` will be the final output and this call will be the last.
-         */
-        done: boolean;
-    }
-]>;
-type RenderResult = {
-    value: ReactNode;
-} & Awaited<ReturnType<LanguageModelV2['doStream']>>;
-/**
- * `streamUI` is a helper function to create a streamable UI from LLMs.
- */
-declare function streamUI<TOOLS extends {
-    [name: string]: z.ZodTypeAny;
-} = {}>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, initial, text, experimental_providerMetadata, providerOptions, onFinish, ...settings }: CallSettings & Prompt & {
-    /**
-     * The language model to use.
-     */
-    model: LanguageModelV2;
-    /**
-     * The tools that the model can call. The model needs to support calling tools.
-     */
-    tools?: {
-        [name in keyof TOOLS]: RenderTool<TOOLS[name]>;
-    };
-    /**
-     * The tool choice strategy. Default: 'auto'.
-     */
-    toolChoice?: ToolChoice<TOOLS>;
-    text?: RenderText;
-    initial?: ReactNode;
-    /**
-Additional provider-specific options. They are passed through
-to the provider from the AI SDK and enable provider-specific
-functionality that can be fully encapsulated in the provider.
- */
-    providerOptions?: ProviderOptions;
+type StandardizedPrompt = {
     /**
-@deprecated Use `providerOptions` instead.
-*/
-    experimental_providerMetadata?: ProviderMetadata;
+     * Original prompt type. This is forwarded to the providers and can be used
+     * to write send raw text to providers that support it.
+     */
+    type: 'prompt' | 'messages';
     /**
-     * Callback that is called when the LLM response and the final object validation are finished.
-     */
-    onFinish?: (event: {
-        /**
-         * The reason why the generation finished.
-         */
-        finishReason: FinishReason;
-        /**
-         * The token usage of the generated response.
-         */
-        usage: LanguageModelUsage;
-        /**
-         * The final ui node that was generated.
-         */
-        value: ReactNode;
-        /**
-         * Warnings from the model provider (e.g. unsupported settings)
-         */
-        warnings?: CallWarning[];
-        /**
-         * Optional raw response data.
-         */
-        rawResponse?: {
-            /**
-             * Response headers.
-             */
-            headers?: Record<string, string>;
-        };
-    }) => Promise<void> | void;
-}): Promise<RenderResult>;
+     * System message.
+     */
+    system?: string;
+    /**
+     * Messages.
+     */
+    messages: CoreMessage[];
+};
+declare function standardizePrompt<TOOLS extends ToolSet>({ prompt, tools, }: {
+    prompt: Prompt;
+    tools: undefined | TOOLS;
+}): StandardizedPrompt;
 
-type StreamableUIWrapper = {
+type CallSettings = {
+    /**
+  Maximum number of tokens to generate.
+     */
+    maxTokens?: number;
     /**
-     * The value of the streamable UI. This can be returned from a Server Action and received by the client.
+  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
      */
-    readonly value: React.ReactNode;
+    temperature?: number;
     /**
-     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+  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.
      */
-    update(value: React.ReactNode): StreamableUIWrapper;
+    topP?: number;
     /**
-     * This method is used to append a new UI node to the end of the old one.
-     * Once appended a new UI node, the previous UI node cannot be updated anymore.
-     *
-     * @example
-     * ```jsx
-     * const ui = createStreamableUI(<div>hello</div>)
-     * ui.append(<div>world</div>)
-     *
-     * // The UI node will be:
-     * // <>
-     * //   <div>hello</div>
-     * //   <div>world</div>
-     * // </>
-     * ```
+  Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
      */
-    append(value: React.ReactNode): StreamableUIWrapper;
+    topK?: number;
     /**
-     * This method is used to signal that there is an error in the UI stream.
-     * It will be thrown on the client side and caught by the nearest error boundary component.
+  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.
      */
-    error(error: any): StreamableUIWrapper;
+    presencePenalty?: number;
     /**
-     * This method marks the UI node as finalized. You can either call it without any parameters or with a new UI node as the final state.
-     * Once called, the UI node cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
+  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.
      */
-    done(...args: [React.ReactNode] | []): StreamableUIWrapper;
-};
-/**
- * Create a piece of changeable UI that can be streamed to the client.
- * On the client side, it can be rendered as a normal React node.
- */
-declare function createStreamableUI(initialValue?: React.ReactNode): StreamableUIWrapper;
-
-declare const __internal_curr: unique symbol;
-declare const __internal_error: unique symbol;
-/**
- * StreamableValue is a value that can be streamed over the network via AI Actions.
- * To read the streamed values, use the `readStreamableValue` or `useStreamableValue` APIs.
- */
-type StreamableValue<T = any, E = any> = {
-    [__internal_curr]?: T;
-    [__internal_error]?: E;
-};
-
-/**
- * Create a wrapped, changeable value that can be streamed to the client.
- * On the client side, the value can be accessed via the readStreamableValue() API.
- */
-declare function createStreamableValue<T = any, E = any>(initialValue?: T | ReadableStream<T>): StreamableValueWrapper<T, E>;
-type StreamableValueWrapper<T, E> = {
+    frequencyPenalty?: number;
     /**
-     * The value of the streamable. This can be returned from a Server Action and
-     * received by the client. To read the streamed values, use the
-     * `readStreamableValue` or `useStreamableValue` APIs.
+  Stop sequences.
+  If set, the model will stop generating text when one of the stop sequences is generated.
+  Providers may have limits on the number of stop sequences.
      */
-    readonly value: StreamableValue<T, E>;
+    stopSequences?: string[];
     /**
-     * This method updates the current value with a new one.
+  The seed (integer) to use for random sampling. If set and supported
+  by the model, calls will generate deterministic results.
      */
-    update(value: T): StreamableValueWrapper<T, E>;
+    seed?: number;
     /**
-     * This method is used to append a delta string to the current value. It
-     * requires the current value of the streamable to be a string.
-     *
-     * @example
-     * ```jsx
-     * const streamable = createStreamableValue('hello');
-     * streamable.append(' world');
-     *
-     * // The value will be 'hello world'
-     * ```
+  Maximum number of retries. Set to 0 to disable retries.
+  
+  @default 2
      */
-    append(value: T): StreamableValueWrapper<T, E>;
+    maxRetries?: number;
     /**
-     * This method is used to signal that there is an error in the value stream.
-     * It will be thrown on the client side when consumed via
-     * `readStreamableValue` or `useStreamableValue`.
+  Abort signal.
      */
-    error(error: any): StreamableValueWrapper<T, E>;
+    abortSignal?: AbortSignal;
     /**
-     * This method marks the value as finalized. You can either call it without
-     * any parameters or with a new value as the final state.
-     * Once called, the value cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response
-     * will be stuck in a loading state.
+  Additional HTTP headers to be sent with the request.
+  Only applicable for HTTP-based providers.
      */
-    done(...args: [T] | []): StreamableValueWrapper<T, E>;
+    headers?: Record<string, string | undefined>;
+};
+
+declare function prepareToolsAndToolChoice<TOOLS extends ToolSet>({ tools, toolChoice, activeTools, }: {
+    tools: TOOLS | undefined;
+    toolChoice: ToolChoice<TOOLS> | undefined;
+    activeTools: Array<keyof TOOLS> | undefined;
+}): {
+    tools: Array<LanguageModelV2FunctionTool | LanguageModelV2ProviderDefinedTool> | undefined;
+    toolChoice: LanguageModelV2ToolChoice | undefined;
+};
+
+type RetryFunction = <OUTPUT>(fn: () => PromiseLike<OUTPUT>) => PromiseLike<OUTPUT>;
+
+/**
+ * Validate and prepare retries.
+ */
+declare function prepareRetries({ maxRetries, }: {
+    maxRetries: number | undefined;
+}): {
+    maxRetries: number;
+    retry: RetryFunction;
 };
 
-export { createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, streamUI };
+/**
+ * Validates call settings and sets default values.
+ */
+declare function prepareCallSettings({ maxTokens, temperature, topP, topK, presencePenalty, frequencyPenalty, stopSequences, seed, }: Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries'>): Omit<CallSettings, 'abortSignal' | 'headers' | 'maxRetries'>;
+
+declare function download({ url }: {
+    url: URL;
+}): Promise<{
+    data: Uint8Array;
+    mediaType: string | undefined;
+}>;
+
+declare function convertToLanguageModelPrompt({ prompt, modelSupportsImageUrls, modelSupportsUrl, downloadImplementation, }: {
+    prompt: StandardizedPrompt;
+    modelSupportsImageUrls: boolean | undefined;
+    modelSupportsUrl: undefined | ((url: URL) => boolean);
+    downloadImplementation?: typeof download;
+}): Promise<LanguageModelV2Prompt>;
+
+/**
+ * Warning time for notifying developers that a stream is hanging in dev mode
+ * using a console.warn.
+ */
+declare const HANGING_STREAM_WARNING_TIME_MS: number;
+
+export { HANGING_STREAM_WARNING_TIME_MS, calculateLanguageModelUsage, convertToLanguageModelPrompt, prepareCallSettings, prepareRetries, prepareToolsAndToolChoice, standardizePrompt };