ai 3.0.13 → 3.0.15

package/rsc/dist/index.d.ts

@@ -3,8 +3,6 @@ import { ReactNode } from 'react';
 import OpenAI from 'openai';
 import { z } from 'zod';
 
-declare const STREAMABLE_VALUE_TYPE: unique symbol;
-
 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> = {
@@ -30,12 +28,11 @@ type MutableAIState<AIState> = {
     update: (newState: ValueOrUpdater<AIState>) => void;
     done: ((newState: AIState) => void) | (() => void);
 };
-type StreamableValue<T = any, E = any> = {
-    type?: typeof STREAMABLE_VALUE_TYPE;
-    curr?: T;
-    error?: E;
-    next?: Promise<StreamableValue<T, E>>;
-};
+/**
+ * StreamableValue is a value that can be streamed over the network via AI Actions.
+ * To read the streamed values, use the `readStreamableValue` API.
+ */
+type StreamableValue<T = any, E = any> = {};
 
 /**
  * Get the current AI state.
@@ -73,10 +70,42 @@ declare function getMutableAIState<AI extends AIProvider = any>(key: keyof Infer
  * 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;
+    /**
+     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+     */
     update(value: React.ReactNode): void;
+    /**
+     * 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>
+     * // </>
+     * ```
+     */
     append(value: React.ReactNode): void;
+    /**
+     * 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): void;
+    /**
+     * 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.
+     */
     done(...args: [] | [React.ReactNode]): void;
 };
 /**
@@ -84,7 +113,15 @@ declare function createStreamableUI(initialValue?: React.ReactNode): {
  * On the client side, the value can be accessed via the readStreamableValue() API.
  */
 declare function createStreamableValue<T = any, E = any>(initialValue?: T): {
+    /**
+     * 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` API.
+     */
     readonly value: StreamableValue<T, E>;
+    /**
+     * This method updates the current value with a new one.
+     */
     update(value: T): void;
     error(error: any): void;
     done(...args: [

package/rsc/dist/rsc-server.d.mts

@@ -3,8 +3,6 @@ import { ReactNode } from 'react';
 import OpenAI from 'openai';
 import { z } from 'zod';
 
-declare const STREAMABLE_VALUE_TYPE: unique symbol;
-
 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> = {
@@ -28,12 +26,11 @@ type MutableAIState<AIState> = {
     update: (newState: ValueOrUpdater<AIState>) => void;
     done: ((newState: AIState) => void) | (() => void);
 };
-type StreamableValue<T = any, E = any> = {
-    type?: typeof STREAMABLE_VALUE_TYPE;
-    curr?: T;
-    error?: E;
-    next?: Promise<StreamableValue<T, E>>;
-};
+/**
+ * StreamableValue is a value that can be streamed over the network via AI Actions.
+ * To read the streamed values, use the `readStreamableValue` API.
+ */
+type StreamableValue<T = any, E = any> = {};
 
 /**
  * Get the current AI state.
@@ -71,10 +68,42 @@ declare function getMutableAIState<AI extends AIProvider = any>(key: keyof Infer
  * 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;
+    /**
+     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+     */
     update(value: React.ReactNode): void;
+    /**
+     * 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>
+     * // </>
+     * ```
+     */
     append(value: React.ReactNode): void;
+    /**
+     * 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): void;
+    /**
+     * 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.
+     */
     done(...args: [] | [React.ReactNode]): void;
 };
 /**
@@ -82,7 +111,15 @@ declare function createStreamableUI(initialValue?: React.ReactNode): {
  * On the client side, the value can be accessed via the readStreamableValue() API.
  */
 declare function createStreamableValue<T = any, E = any>(initialValue?: T): {
+    /**
+     * 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` API.
+     */
     readonly value: StreamableValue<T, E>;
+    /**
+     * This method updates the current value with a new one.
+     */
     update(value: T): void;
     error(error: any): void;
     done(...args: [

package/rsc/dist/rsc-server.mjs

@@ -177,9 +177,6 @@ function getMutableAIState(...args) {
 // rsc/streamable.tsx
 import zodToJsonSchema from "zod-to-json-schema";
 
-// shared/utils.ts
-import { customAlphabet } from "nanoid/non-secure";
-
 // shared/stream-parts.ts
 var textStreamPart = {
   code: "0",
@@ -361,10 +358,6 @@ function formatStreamPart(type, value) {
 }
 
 // shared/utils.ts
-var nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
 function createChunkDecoder(complex) {
   const decoder = new TextDecoder();
   if (!complex) {
@@ -873,7 +866,13 @@ function createStreamableUI(initialValue) {
   }
   warnUnclosedStream();
   return {
+    /**
+     * The value of the streamable UI. This can be returned from a Server Action and received by the client.
+     */
     value: row,
+    /**
+     * This method updates the current UI node. It takes a new UI node and replaces the old one.
+     */
     update(value) {
       assertStream(".update()");
       if (value === currentValue) {
@@ -887,6 +886,22 @@ function createStreamableUI(initialValue) {
       reject = resolvable.reject;
       warnUnclosedStream();
     },
+    /**
+     * 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>
+     * // </>
+     * ```
+     */
     append(value) {
       assertStream(".append()");
       const resolvable = createResolvablePromise();
@@ -896,6 +911,10 @@ function createStreamableUI(initialValue) {
       reject = resolvable.reject;
       warnUnclosedStream();
     },
+    /**
+     * 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) {
       assertStream(".error()");
       if (warningTimeout) {
@@ -904,6 +923,12 @@ function createStreamableUI(initialValue) {
       closed = true;
       reject(error);
     },
+    /**
+     * 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.
+     */
     done(...args) {
       assertStream(".done()");
       if (warningTimeout) {
@@ -924,6 +949,7 @@ function createStreamableValue(initialValue) {
   let currentValue = initialValue;
   let currentError;
   let currentPromise = resolvable.promise;
+  let currentPatchValue;
   function assertStream(method) {
     if (closed) {
       throw new Error(method + ": Value stream is already closed.");
@@ -943,25 +969,53 @@ function createStreamableValue(initialValue) {
     }
   }
   warnUnclosedStream();
-  function createWrapped(withType) {
-    const init = currentError === void 0 ? { curr: currentValue } : { error: currentError };
+  function createWrapped(initialChunk) {
+    let init;
+    if (currentError !== void 0) {
+      init = { error: currentError };
+    } else {
+      if (currentPatchValue && !initialChunk) {
+        init = { diff: currentPatchValue };
+      } else {
+        init = { curr: currentValue };
+      }
+    }
     if (currentPromise) {
       init.next = currentPromise;
     }
-    if (withType) {
+    if (initialChunk) {
       init.type = STREAMABLE_VALUE_TYPE;
     }
     return init;
   }
+  function updateValueStates(value) {
+    currentPatchValue = void 0;
+    if (typeof value === "string") {
+      if (typeof currentValue === "string") {
+        if (value.startsWith(currentValue)) {
+          currentPatchValue = [0, value.slice(currentValue.length)];
+        }
+      }
+    }
+    currentValue = value;
+  }
   return {
+    /**
+     * 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` API.
+     */
     get value() {
       return createWrapped(true);
     },
+    /**
+     * This method updates the current value with a new one.
+     */
     update(value) {
       assertStream(".update()");
       const resolvePrevious = resolvable.resolve;
       resolvable = createResolvablePromise();
-      currentValue = value;
+      updateValueStates(value);
       currentPromise = resolvable.promise;
       resolvePrevious(createWrapped());
       warnUnclosedStream();
@@ -984,8 +1038,8 @@ function createStreamableValue(initialValue) {
       closed = true;
       currentPromise = void 0;
       if (args.length) {
-        currentValue = args[0];
-        resolvable.resolve({ curr: args[0] });
+        updateValueStates(args[0]);
+        resolvable.resolve(createWrapped());
         return;
       }
       resolvable.resolve({});