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

package/rsc/dist/index.d.ts

@@ -1,8 +1,7 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { LanguageModelV1FinishReason, LanguageModelV1CallWarning, LanguageModelV1ProviderMetadata, LanguageModelV1 } from '@ai-sdk/provider';
 import { ReactNode } from 'react';
-import OpenAI from 'openai';
 import { z } from 'zod';
-import { LanguageModelV1 } from '@ai-sdk/provider';
+import { ToolInvocation, Attachment } from '@ai-sdk/ui-utils';
 
 type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
 type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
@@ -29,11 +28,6 @@ type MutableAIState<AIState> = {
     update: (newState: ValueOrUpdater<AIState>) => void;
     done: ((newState: AIState) => void) | (() => void);
 };
-/**
- * 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> = {};
 
 /**
  * Get the current AI state.
@@ -43,10 +37,10 @@ type StreamableValue<T = any, E = any> = {};
  * @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>(): InferAIState<AI, any>;
-declare function getAIState<AI extends AIProvider = any>(key: keyof InferAIState<AI, any>): InferAIState<AI, any>[typeof 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 `.close()` when finishing
+ * Get the mutable AI state. Note that you must call `.done()` when finishing
  * updating the AI state.
  *
  * @example
@@ -66,160 +60,45 @@ declare function getAIState<AI extends AIProvider = any>(key: keyof InferAIState
 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]>;
 
-/**
- * Create a piece of changable 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): {
-    /**
-     * The value of the streamable UI. This can be returned from a Server Action and received by the client.
-     */
-    value: react_jsx_runtime.JSX.Element;
+declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, onSetAIState, onGetUIState, }: {
+    actions: Actions;
+    initialAIState?: AIState;
+    initialUIState?: UIState;
     /**
-     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+     * 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.
      */
-    update(value: React.ReactNode): any;
+    onSetAIState?: OnSetAIState<AIState>;
     /**
-     * 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>)
+     * 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.
      *
-     * // The UI node will be:
-     * // <>
-     * //   <div>hello</div>
-     * //   <div>world</div>
-     * // </>
-     * ```
-     */
-    append(value: React.ReactNode): any;
-    /**
-     * 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.
-     */
-    error(error: any): any;
-    /**
-     * 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.
+     * If returning `undefined`, the client side UI state will not be updated.
      *
-     * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
-     */
-    done(...args: [] | [React.ReactNode]): any;
-};
-declare const STREAMABLE_VALUE_INTERNAL_LOCK: unique symbol;
-/**
- * Create a wrapped, changable 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>): {
-    /**
-     * @internal This is an internal lock to prevent the value from being
-     * updated by the user.
-     */
-    [STREAMABLE_VALUE_INTERNAL_LOCK]: boolean;
-    /**
-     * 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.
-     */
-    readonly value: StreamableValue<T, E>;
-    /**
-     * This method updates the current value with a new one.
-     */
-    update(value: T): any;
-    /**
-     * 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.
+     * This function must be annotated with the `"use server"` directive.
      *
      * @example
-     * ```jsx
-     * const streamable = createStreamableValue('hello');
-     * streamable.append(' world');
+     * ```tsx
+     * onGetUIState: async () => {
+     *   'use server';
      *
-     * // The value will be 'hello world'
-     * ```
-     */
-    append(value: T): any;
-    /**
-     * 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`.
-     */
-    error(error: any): any;
-    /**
-     * 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.
+     *   const currentAIState = getAIState();
+     *   const externalAIState = await loadAIStateFromDatabase();
      *
-     * This method is always **required** to be called, otherwise the response
-     * will be stuck in a loading state.
-     */
-    done(...args: [] | [T]): any;
-};
-
-type Streamable$1 = ReactNode | Promise<ReactNode>;
-type Renderer$1<T> = (props: T) => Streamable$1 | Generator<Streamable$1, Streamable$1, void> | AsyncGenerator<Streamable$1, Streamable$1, void>;
-/**
- * `render` is a helper function to create a streamable UI from some LLMs.
- * This API only supports OpenAI's GPT models with Function Calling and Assistants Tools,
- * please use `streamUI` for compatibility with other providers.
- *
- * @deprecated It's recommended to use the `streamUI` API for compatibility with AI SDK Core APIs
- * and future features. This API will be removed in a future release.
- */
-declare function render<TS extends {
-    [name: string]: z.Schema;
-} = {}, FS extends {
-    [name: string]: z.Schema;
-} = {}>(options: {
-    /**
-     * The model name to use. Must be OpenAI SDK compatible. Tools and Functions are only supported
-     * GPT models (3.5/4), OpenAI Assistants, Mistral small and large, and Fireworks firefunction-v1.
+     *   if (currentAIState === externalAIState) return undefined;
      *
-     * @example "gpt-3.5-turbo"
-     */
-    model: string;
-    /**
-     * The provider instance to use. Currently the only provider available is OpenAI.
-     * This needs to match the model name.
+     *   // Update current AI state and return the new UI state
+     *   const state = getMutableAIState()
+     *   state.done(externalAIState)
+     *
+     *   return <div>...</div>;
+     * }
+     * ```
      */
-    provider: OpenAI;
-    messages: Parameters<typeof OpenAI.prototype.chat.completions.create>[0]['messages'];
-    text?: Renderer$1<{
-        /**
-         * 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;
-    }>;
-    tools?: {
-        [name in keyof TS]: {
-            description?: string;
-            parameters: TS[name];
-            render: Renderer$1<z.infer<TS[name]>>;
-        };
-    };
-    functions?: {
-        [name in keyof FS]: {
-            description?: string;
-            parameters: FS[name];
-            render: Renderer$1<z.infer<FS[name]>>;
-        };
-    };
-    initial?: ReactNode;
-    temperature?: number;
-}): ReactNode;
+    onGetUIState?: OnGetUIState<UIState>;
+}): AIProvider<AIState, UIState, Actions>;
 
 type CallSettings = {
     /**
@@ -245,13 +124,18 @@ type CallSettings = {
      */
     topP?: number;
     /**
+  Only sample from the top K options for each subsequent token.
+  
+  Used to remove "long tail" low probability responses.
+  Recommended for advanced use cases only. You usually only need to use temperature.
+     */
+    topK?: number;
+    /**
   Presence penalty setting. It affects the likelihood of the model to
   repeat information that is already in the prompt.
   
   The presence penalty is a number between -1 (increase repetition)
   and 1 (maximum penalty, decrease repetition). 0 means no penalty.
-  
-  @default 0
      */
     presencePenalty?: number;
     /**
@@ -260,11 +144,15 @@ type CallSettings = {
   
   The frequency penalty is a number between -1 (increase repetition)
   and 1 (maximum penalty, decrease repetition). 0 means no penalty.
-  
-  @default 0
      */
     frequencyPenalty?: number;
     /**
+  Stop sequences.
+  If set, the model will stop generating text when one of the stop sequences is generated.
+  Providers may have limits on the number of stop sequences.
+     */
+    stopSequences?: string[];
+    /**
   The seed (integer) to use for random sampling. If set and supported
   by the model, calls will generate deterministic results.
      */
@@ -279,6 +167,66 @@ type CallSettings = {
   Abort signal.
      */
     abortSignal?: AbortSignal;
+    /**
+  Additional HTTP headers to be sent with the request.
+  Only applicable for HTTP-based providers.
+     */
+    headers?: Record<string, string | undefined>;
+};
+
+/**
+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 = LanguageModelV1FinishReason;
+/**
+Warning from the model provider for this call. The call will proceed, but e.g.
+some settings might not be supported, which can lead to suboptimal results.
+*/
+type CallWarning = LanguageModelV1CallWarning;
+/**
+Tool choice for the generation. It supports the following settings:
+
+- `auto` (default): the model can choose whether and which tools to call.
+- `required`: the model must call a tool. It can choose which tool to call.
+- `none`: the model must not call tools
+- `{ type: 'tool', toolName: string (typed) }`: the model must call the specified tool
+ */
+type CoreToolChoice<TOOLS extends Record<string, unknown>> = 'auto' | 'none' | 'required' | {
+    type: 'tool';
+    toolName: keyof TOOLS;
+};
+
+/**
+Additional provider-specific metadata. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+ */
+type ProviderMetadata = LanguageModelV1ProviderMetadata;
+
+/**
+Represents the number of tokens used in a prompt and completion.
+ */
+type LanguageModelUsage = {
+    /**
+  The number of tokens used in the prompt.
+     */
+    promptTokens: number;
+    /**
+  The number of tokens used in the completion.
+   */
+    completionTokens: number;
+    /**
+  The total number of tokens used (promptTokens + completionTokens).
+     */
+    totalTokens: number;
 };
 
 /**
@@ -286,6 +234,15 @@ Data content. Can either be a base64-encoded string, a Uint8Array, an ArrayBuffe
  */
 type DataContent = string | Uint8Array | ArrayBuffer | Buffer;
 
+type ToolResultContent = Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType?: string;
+}>;
+
 /**
 Text content part of a prompt. It contains a string of text.
  */
@@ -295,6 +252,12 @@ interface TextPart {
   The text content.
      */
     text: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Image content part of a prompt. It contains an image.
@@ -312,6 +275,35 @@ interface ImagePart {
   Optional mime type of the image.
      */
     mimeType?: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
+}
+/**
+File content part of a prompt. It contains a file.
+ */
+interface FilePart {
+    type: 'file';
+    /**
+  File data. Can either be:
+  
+  - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+  - URL: a URL that points to the image
+     */
+    data: DataContent | URL;
+    /**
+  Mime type of the file.
+     */
+    mimeType: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Tool call content part of a prompt. It contains a tool call (usually generated by the AI model).
@@ -330,6 +322,12 @@ interface ToolCallPart {
   Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
      */
     args: unknown;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 /**
 Tool result content part of a prompt. It contains the result of the tool call with the matching ID.
@@ -349,16 +347,21 @@ interface ToolResultPart {
      */
     result: unknown;
     /**
+  Multi-part content of the tool result. Only for tools that support multipart results.
+     */
+    experimental_content?: ToolResultContent;
+    /**
   Optional flag if the result is an error or an error message.
      */
     isError?: boolean;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 }
 
-/**
-A message that can be used in the `messages` field of a prompt.
-It can be a user message, an assistant message, or a tool message.
- */
-type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage | CoreToolMessage;
 /**
  A system message. It can contain system information.
 
@@ -369,6 +372,12 @@ type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage |
 type CoreSystemMessage = {
     role: 'system';
     content: string;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 };
 /**
 A user message. It can contain text or a combination of text and images.
@@ -376,17 +385,29 @@ A user message. It can contain text or a combination of text and images.
 type CoreUserMessage = {
     role: 'user';
     content: UserContent;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 };
 /**
 Content of a user message. It can be a string or an array of text and image parts.
  */
-type UserContent = string | Array<TextPart | ImagePart>;
+type UserContent = string | Array<TextPart | ImagePart | FilePart>;
 /**
 An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
  */
 type CoreAssistantMessage = {
     role: 'assistant';
     content: AssistantContent;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 };
 /**
 Content of an assistant message. It can be a string or an array of text and tool call parts.
@@ -398,14 +419,33 @@ A tool message. It contains the result of one or more tool calls.
 type CoreToolMessage = {
     role: 'tool';
     content: ToolContent;
+    /**
+  Additional provider-specific metadata. They are passed through
+  to the provider from the AI SDK and enable provider-specific
+  functionality that can be fully encapsulated in the provider.
+   */
+    experimental_providerMetadata?: ProviderMetadata;
 };
 /**
 Content of a tool message. It is an array of tool result parts.
  */
 type ToolContent = Array<ToolResultPart>;
+/**
+A message that can be used in the `messages` field of a prompt.
+It can be a user message, an assistant message, or a tool message.
+ */
+type CoreMessage = CoreSystemMessage | CoreUserMessage | CoreAssistantMessage | CoreToolMessage;
+
+type UIMessage = {
+    role: 'system' | 'user' | 'assistant' | 'data';
+    content: string;
+    toolInvocations?: ToolInvocation[];
+    experimental_attachments?: Attachment[];
+};
 
 /**
-Prompt part of the AI function options. It contains a system message, a simple text prompt, or a list of messages.
+Prompt part of the AI function options.
+It contains a system message, a simple text prompt, or a list of messages.
  */
 type Prompt = {
     /**
@@ -417,9 +457,9 @@ type Prompt = {
    */
     prompt?: string;
     /**
-  A list of messsages. You can either use `prompt` or `messages` but not both.
+  A list of messages. You can either use `prompt` or `messages` but not both.
      */
-    messages?: Array<CoreMessage>;
+    messages?: Array<CoreMessage> | Array<UIMessage>;
 };
 
 type Streamable = ReactNode | Promise<ReactNode>;
@@ -460,7 +500,7 @@ type RenderResult = {
  */
 declare function streamUI<TOOLS extends {
     [name: string]: z.ZodTypeAny;
-} = {}>({ model, tools, system, prompt, messages, maxRetries, abortSignal, initial, text, ...settings }: CallSettings & Prompt & {
+} = {}>({ model, tools, toolChoice, system, prompt, messages, maxRetries, abortSignal, headers, initial, text, experimental_providerMetadata: providerMetadata, onFinish, ...settings }: CallSettings & Prompt & {
     /**
      * The language model to use.
      */
@@ -471,49 +511,151 @@ declare function streamUI<TOOLS extends {
     tools?: {
         [name in keyof TOOLS]: RenderTool<TOOLS[name]>;
     };
+    /**
+     * The tool choice strategy. Default: 'auto'.
+     */
+    toolChoice?: CoreToolChoice<TOOLS>;
     text?: RenderText;
     initial?: ReactNode;
+    /**
+Additional provider-specific metadata. They are passed through
+to the provider from the AI SDK and enable provider-specific
+functionality that can be fully encapsulated in the provider.
+ */
+    experimental_providerMetadata?: ProviderMetadata;
+    /**
+     * Callback that is called when the LLM response and the final object validation are finished.
+     */
+    onFinish?: (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>;
 
-declare function createAI<AIState = any, UIState = any, Actions extends AIActions = {}>({ actions, initialAIState, initialUIState, onSetAIState, onGetUIState, }: {
-    actions: Actions;
-    initialAIState?: AIState;
-    initialUIState?: UIState;
+type StreamableUIWrapper = {
     /**
-     * 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 value of the streamable UI. This can be returned from a Server Action and received by the client.
      */
-    onSetAIState?: OnSetAIState<AIState>;
+    readonly value: React.ReactNode;
     /**
-     * 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.
+     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+     */
+    update(value: React.ReactNode): StreamableUIWrapper;
+    /**
+     * 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
-     * ```tsx
-     * onGetUIState: async () => {
-     *   'use server';
+     * ```jsx
+     * const ui = createStreamableUI(<div>hello</div>)
+     * ui.append(<div>world</div>)
      *
-     *   const currentAIState = getAIState();
-     *   const externalAIState = await loadAIStateFromDatabase();
+     * // The UI node will be:
+     * // <>
+     * //   <div>hello</div>
+     * //   <div>world</div>
+     * // </>
+     * ```
+     */
+    append(value: React.ReactNode): StreamableUIWrapper;
+    /**
+     * 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.
+     */
+    error(error: any): StreamableUIWrapper;
+    /**
+     * 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.
      *
-     *   if (currentAIState === externalAIState) return undefined;
+     * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
+     */
+    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> = {
+    /**
+     * 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.
+     */
+    readonly value: StreamableValue<T, E>;
+    /**
+     * This method updates the current value with a new one.
+     */
+    update(value: T): StreamableValueWrapper<T, E>;
+    /**
+     * 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.
      *
-     *   // Update current AI state and return the new UI state
-     *   const state = getMutableAIState()
-     *   state.done(externalAIState)
+     * @example
+     * ```jsx
+     * const streamable = createStreamableValue('hello');
+     * streamable.append(' world');
      *
-     *   return <div>...</div>;
-     * }
+     * // The value will be 'hello world'
      * ```
      */
-    onGetUIState?: OnGetUIState<UIState>;
-}): AIProvider<AIState, UIState, Actions>;
+    append(value: T): StreamableValueWrapper<T, E>;
+    /**
+     * 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`.
+     */
+    error(error: any): StreamableValueWrapper<T, E>;
+    /**
+     * 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.
+     */
+    done(...args: [T] | []): StreamableValueWrapper<T, E>;
+};
 
 /**
  * `readStreamableValue` takes a streamable value created via the `createStreamableValue().value` API,
@@ -546,6 +688,7 @@ declare function createAI<AIState = any, UIState = any, Actions extends AIAction
  * This logs out 1, 2, 3 on console.
  */
 declare function readStreamableValue<T = unknown>(streamableValue: StreamableValue<T>): AsyncIterable<T | undefined>;
+
 /**
  * `useStreamableValue` is a React hook that takes a streamable value created via the `createStreamableValue().value` API,
  * and returns the current value, error, and pending state.
@@ -577,4 +720,4 @@ declare function useAIState<AI extends AIProvider = any>(key: keyof InferAIState
 declare function useActions<AI extends AIProvider = any>(): InferActions<AI, any>;
 declare function useSyncUIState(): () => Promise<void>;
 
-export { StreamableValue, createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, readStreamableValue, render, streamUI, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };
+export { StreamableValue, createAI, createStreamableUI, createStreamableValue, getAIState, getMutableAIState, readStreamableValue, streamUI, useAIState, useActions, useStreamableValue, useSyncUIState, useUIState };