ai 3.0.34 → 3.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "3.0.34",
+  "version": "3.0.35",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -57,8 +57,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "0.0.2",
-    "@ai-sdk/provider-utils": "0.0.4",
+    "@ai-sdk/provider": "0.0.3",
+    "@ai-sdk/provider-utils": "0.0.5",
     "secure-json-parse": "2.7.0",
     "eventsource-parser": "1.1.2",
     "jsondiffpatch": "0.6.0",

package/rsc/dist/index.d.ts

@@ -109,11 +109,17 @@ declare function createStreamableUI(initialValue?: React.ReactNode): {
      */
     done(...args: [] | [React.ReactNode]): void;
 };
+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): {
+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
@@ -124,10 +130,36 @@ declare function createStreamableValue<T = any, E = any>(initialValue?: T): {
      * This method updates the current value with a new one.
      */
     update(value: T): void;
+    /**
+     * 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'
+     * ```
+     */
+    append(value: T): void;
+    /**
+     * 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): void;
-    done(...args: [
-    ] | [T]): void;
+    /**
+     * 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]): void;
 };
+
 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>;
 /**
@@ -413,7 +445,9 @@ type RenderResult = {
 /**
  * `experimental_streamUI` is a helper function to create a streamable UI from LLMs.
  */
-declare function experimental_streamUI<TOOLS extends Record<string, RenderTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, initial, text, ...settings }: CallSettings & Prompt & {
+declare function experimental_streamUI<TOOLS extends {
+    [name: string]: z.ZodTypeAny;
+} = {}>({ model, tools, system, prompt, messages, maxRetries, abortSignal, initial, text, ...settings }: CallSettings & Prompt & {
     /**
      * The language model to use.
      */
@@ -421,7 +455,9 @@ declare function experimental_streamUI<TOOLS extends Record<string, RenderTool>>
     /**
      * The tools that the model can call. The model needs to support calling tools.
      */
-    tools?: TOOLS;
+    tools?: {
+        [name in keyof TOOLS]: RenderTool<TOOLS[name]>;
+    };
     text?: RenderText;
     initial?: ReactNode;
 }): Promise<RenderResult>;

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

@@ -107,11 +107,17 @@ declare function createStreamableUI(initialValue?: React.ReactNode): {
      */
     done(...args: [] | [React.ReactNode]): void;
 };
+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): {
+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
@@ -122,10 +128,36 @@ declare function createStreamableValue<T = any, E = any>(initialValue?: T): {
      * This method updates the current value with a new one.
      */
     update(value: T): void;
+    /**
+     * 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'
+     * ```
+     */
+    append(value: T): void;
+    /**
+     * 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): void;
-    done(...args: [
-    ] | [T]): void;
+    /**
+     * 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]): void;
 };
+
 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>;
 /**
@@ -411,7 +443,9 @@ type RenderResult = {
 /**
  * `experimental_streamUI` is a helper function to create a streamable UI from LLMs.
  */
-declare function experimental_streamUI<TOOLS extends Record<string, RenderTool>>({ model, tools, system, prompt, messages, maxRetries, abortSignal, initial, text, ...settings }: CallSettings & Prompt & {
+declare function experimental_streamUI<TOOLS extends {
+    [name: string]: z.ZodTypeAny;
+} = {}>({ model, tools, system, prompt, messages, maxRetries, abortSignal, initial, text, ...settings }: CallSettings & Prompt & {
     /**
      * The language model to use.
      */
@@ -419,7 +453,9 @@ declare function experimental_streamUI<TOOLS extends Record<string, RenderTool>>
     /**
      * The tools that the model can call. The model needs to support calling tools.
      */
-    tools?: TOOLS;
+    tools?: {
+        [name in keyof TOOLS]: RenderTool<TOOLS[name]>;
+    };
     text?: RenderText;
     initial?: ReactNode;
 }): Promise<RenderResult>;

package/rsc/dist/rsc-server.mjs

@@ -1245,8 +1245,42 @@ function createStreamableUI(initialValue) {
     }
   };
 }
+var STREAMABLE_VALUE_INTERNAL_LOCK = Symbol("streamable.value.lock");
 function createStreamableValue(initialValue) {
+  const isReadableStream = initialValue instanceof ReadableStream || typeof initialValue === "object" && initialValue !== null && "getReader" in initialValue && typeof initialValue.getReader === "function" && "locked" in initialValue && typeof initialValue.locked === "boolean";
+  if (!isReadableStream) {
+    return createStreamableValueImpl(initialValue);
+  }
+  const streamableValue = createStreamableValueImpl();
+  streamableValue[STREAMABLE_VALUE_INTERNAL_LOCK] = true;
+  (async () => {
+    try {
+      const reader = initialValue.getReader();
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          break;
+        }
+        streamableValue[STREAMABLE_VALUE_INTERNAL_LOCK] = false;
+        if (typeof value === "string") {
+          streamableValue.append(value);
+        } else {
+          streamableValue.update(value);
+        }
+        streamableValue[STREAMABLE_VALUE_INTERNAL_LOCK] = true;
+      }
+      streamableValue[STREAMABLE_VALUE_INTERNAL_LOCK] = false;
+      streamableValue.done();
+    } catch (e) {
+      streamableValue[STREAMABLE_VALUE_INTERNAL_LOCK] = false;
+      streamableValue.error(e);
+    }
+  })();
+  return streamableValue;
+}
+function createStreamableValueImpl(initialValue) {
   let closed = false;
+  let locked = false;
   let resolvable = createResolvablePromise();
   let currentValue = initialValue;
   let currentError;
@@ -1256,6 +1290,11 @@ function createStreamableValue(initialValue) {
     if (closed) {
       throw new Error(method + ": Value stream is already closed.");
     }
+    if (locked) {
+      throw new Error(
+        method + ": Value stream is locked and cannot be updated."
+      );
+    }
   }
   let warningTimeout;
   function warnUnclosedStream() {
@@ -1302,6 +1341,13 @@ function createStreamableValue(initialValue) {
     currentValue = value;
   }
   return {
+    /**
+     * @internal This is an internal lock to prevent the value from being
+     * updated by the user.
+     */
+    set [STREAMABLE_VALUE_INTERNAL_LOCK](state) {
+      locked = state;
+    },
     /**
      * 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
@@ -1322,6 +1368,48 @@ function createStreamableValue(initialValue) {
       resolvePrevious(createWrapped());
       warnUnclosedStream();
     },
+    /**
+     * 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'
+     * ```
+     */
+    append(value) {
+      assertStream(".append()");
+      if (typeof currentValue !== "string" && typeof currentValue !== "undefined") {
+        throw new Error(
+          `.append(): The current value is not a string. Received: ${typeof currentValue}`
+        );
+      }
+      if (typeof value !== "string") {
+        throw new Error(
+          `.append(): The value is not a string. Received: ${typeof value}`
+        );
+      }
+      const resolvePrevious = resolvable.resolve;
+      resolvable = createResolvablePromise();
+      if (typeof currentValue === "string") {
+        currentPatchValue = [0, value];
+        currentValue = currentValue + value;
+      } else {
+        currentPatchValue = void 0;
+        currentValue = value;
+      }
+      currentPromise = resolvable.promise;
+      resolvePrevious(createWrapped());
+      warnUnclosedStream();
+    },
+    /**
+     * 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) {
       assertStream(".error()");
       if (warningTimeout) {
@@ -1332,6 +1420,14 @@ function createStreamableValue(initialValue) {
       currentPromise = void 0;
       resolvable.resolve({ error });
     },
+    /**
+     * 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) {
       assertStream(".done()");
       if (warningTimeout) {