ai 3.1.0-canary.4 → 3.1.1

package/rsc/dist/rsc-server.mjs

@@ -175,10 +175,319 @@ function getMutableAIState(...args) {
 }
 
 // rsc/streamable.tsx
+import zodToJsonSchema2 from "zod-to-json-schema";
+
+// core/util/detect-image-mimetype.ts
+var mimeTypeSignatures = [
+  { mimeType: "image/gif", bytes: [71, 73, 70] },
+  { mimeType: "image/png", bytes: [137, 80, 78, 71] },
+  { mimeType: "image/jpeg", bytes: [255, 216] },
+  { mimeType: "image/webp", bytes: [82, 73, 70, 70] }
+];
+function detectImageMimeType(image) {
+  for (const { bytes, mimeType } of mimeTypeSignatures) {
+    if (image.length >= bytes.length && bytes.every((byte, index) => image[index] === byte)) {
+      return mimeType;
+    }
+  }
+  return void 0;
+}
+
+// core/prompt/data-content.ts
+import { InvalidDataContentError } from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    return convertBase64ToUint8Array(content);
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new InvalidDataContentError({ content });
+}
+
+// core/prompt/convert-to-language-model-prompt.ts
+function convertToLanguageModelPrompt(prompt) {
+  const languageModelMessages = [];
+  if (prompt.system != null) {
+    languageModelMessages.push({ role: "system", content: prompt.system });
+  }
+  switch (prompt.type) {
+    case "prompt": {
+      languageModelMessages.push({
+        role: "user",
+        content: [{ type: "text", text: prompt.prompt }]
+      });
+      break;
+    }
+    case "messages": {
+      languageModelMessages.push(
+        ...prompt.messages.map((message) => {
+          switch (message.role) {
+            case "user": {
+              if (typeof message.content === "string") {
+                return {
+                  role: "user",
+                  content: [{ type: "text", text: message.content }]
+                };
+              }
+              return {
+                role: "user",
+                content: message.content.map(
+                  (part) => {
+                    var _a;
+                    switch (part.type) {
+                      case "text": {
+                        return part;
+                      }
+                      case "image": {
+                        if (part.image instanceof URL) {
+                          return {
+                            type: "image",
+                            image: part.image,
+                            mimeType: part.mimeType
+                          };
+                        }
+                        const imageUint8 = convertDataContentToUint8Array(
+                          part.image
+                        );
+                        return {
+                          type: "image",
+                          image: imageUint8,
+                          mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
+                        };
+                      }
+                    }
+                  }
+                )
+              };
+            }
+            case "assistant": {
+              if (typeof message.content === "string") {
+                return {
+                  role: "assistant",
+                  content: [{ type: "text", text: message.content }]
+                };
+              }
+              return { role: "assistant", content: message.content };
+            }
+            case "tool": {
+              return message;
+            }
+          }
+        })
+      );
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = prompt;
+      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+    }
+  }
+  return languageModelMessages;
+}
+
+// core/prompt/get-validated-prompt.ts
+import { InvalidPromptError } from "@ai-sdk/provider";
+function getValidatedPrompt(prompt) {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  return prompt.prompt != null ? {
+    type: "prompt",
+    prompt: prompt.prompt,
+    messages: void 0,
+    system: prompt.system
+  } : {
+    type: "messages",
+    prompt: void 0,
+    messages: prompt.messages,
+    // only possible case bc of checks above
+    system: prompt.system
+  };
+}
+
+// core/prompt/prepare-call-settings.ts
+import { InvalidArgumentError } from "@ai-sdk/provider";
+function prepareCallSettings({
+  maxTokens,
+  temperature,
+  topP,
+  presencePenalty,
+  frequencyPenalty,
+  seed,
+  maxRetries
+}) {
+  if (maxTokens != null) {
+    if (!Number.isInteger(maxTokens)) {
+      throw new InvalidArgumentError({
+        parameter: "maxTokens",
+        value: maxTokens,
+        message: "maxTokens must be an integer"
+      });
+    }
+    if (maxTokens < 1) {
+      throw new InvalidArgumentError({
+        parameter: "maxTokens",
+        value: maxTokens,
+        message: "maxTokens must be >= 1"
+      });
+    }
+  }
+  if (temperature != null) {
+    if (typeof temperature !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "temperature",
+        value: temperature,
+        message: "temperature must be a number"
+      });
+    }
+  }
+  if (topP != null) {
+    if (typeof topP !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topP",
+        value: topP,
+        message: "topP must be a number"
+      });
+    }
+  }
+  if (presencePenalty != null) {
+    if (typeof presencePenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "presencePenalty",
+        value: presencePenalty,
+        message: "presencePenalty must be a number"
+      });
+    }
+  }
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
+  }
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new InvalidArgumentError({
+        parameter: "seed",
+        value: seed,
+        message: "seed must be an integer"
+      });
+    }
+  }
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  return {
+    maxTokens,
+    temperature: temperature != null ? temperature : 0,
+    topP,
+    presencePenalty,
+    frequencyPenalty,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
+}
+
+// core/util/convert-zod-to-json-schema.ts
 import zodToJsonSchema from "zod-to-json-schema";
+function convertZodToJSONSchema(zodSchema) {
+  return zodToJsonSchema(zodSchema);
+}
 
-// shared/utils.ts
-import { customAlphabet } from "nanoid/non-secure";
+// core/util/retry-with-exponential-backoff.ts
+import { APICallError, RetryError } from "@ai-sdk/provider";
+import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
+
+// core/util/delay.ts
+async function delay(delayInMs) {
+  return new Promise((resolve) => setTimeout(resolve, delayInMs));
+}
+
+// core/util/retry-with-exponential-backoff.ts
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+    if (maxRetries === 0) {
+      throw error;
+    }
+    const errorMessage = getErrorMessage(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error && APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await delay(delayInMs);
+      return _retryWithExponentialBackoff(
+        f,
+        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+        newErrors
+      );
+    }
+    if (tryNumber === 1) {
+      throw error;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
+}
 
 // shared/stream-parts.ts
 var textStreamPart = {
@@ -280,9 +589,9 @@ var toolCallStreamPart = {
   code: "7",
   name: "tool_calls",
   parse: (value) => {
-    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some((tc) => {
-      tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string";
-    })) {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some(
+      (tc) => tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string"
+    )) {
       throw new Error(
         '"tool_calls" parts expect an object with a ToolCallPayload.'
       );
@@ -361,10 +670,6 @@ function formatStreamPart(type, value) {
 }
 
 // shared/utils.ts
-var nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
 function createChunkDecoder(complex) {
   const decoder = new TextDecoder();
   if (!complex) {
@@ -505,14 +810,7 @@ function readableFromAsyncIterable(iterable) {
 }
 
 // streams/stream-data.ts
-function createStreamDataTransformer(experimental_streamData) {
-  if (!experimental_streamData) {
-    return new TransformStream({
-      transform: async (chunk, controller) => {
-        controller.enqueue(chunk);
-      }
-    });
-  }
+function createStreamDataTransformer() {
   const encoder = new TextEncoder();
   const decoder = new TextDecoder();
   return new TransformStream({
@@ -664,9 +962,7 @@ function OpenAIStream(res, callbacks) {
     const functionCallTransformer = createFunctionCallTransformer(cb);
     return stream.pipeThrough(functionCallTransformer);
   } else {
-    return stream.pipeThrough(
-      createStreamDataTransformer(cb == null ? void 0 : cb.experimental_streamData)
-    );
+    return stream.pipeThrough(createStreamDataTransformer());
   }
 }
 function createFunctionCallTransformer(callbacks) {
@@ -676,7 +972,6 @@ function createFunctionCallTransformer(callbacks) {
   let aggregatedFinalCompletionResponse = "";
   let isFunctionStreamingIn = false;
   let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const isComplexMode = callbacks == null ? void 0 : callbacks.experimental_streamData;
   const decode = createChunkDecoder();
   return new TransformStream({
     async transform(chunk, controller) {
@@ -691,7 +986,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
+          textEncoder.encode(formatStreamPart("text", message))
         );
         return;
       } else {
@@ -802,17 +1097,17 @@ function createFunctionCallTransformer(callbacks) {
           if (!functionResponse) {
             controller.enqueue(
               textEncoder.encode(
-                isComplexMode ? formatStreamPart(
+                formatStreamPart(
                   payload.function_call ? "function_call" : "tool_calls",
                   // parse to prevent double-encoding:
                   JSON.parse(aggregatedResponse)
-                ) : aggregatedResponse
+                )
               )
             );
             return;
           } else if (typeof functionResponse === "string") {
             controller.enqueue(
-              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(functionResponse)
+              textEncoder.encode(formatStreamPart("text", functionResponse))
             );
             aggregatedFinalCompletionResponse = functionResponse;
             return;
@@ -873,7 +1168,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 +1188,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 +1213,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 +1225,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) {
@@ -918,16 +1245,56 @@ 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;
   let currentPromise = resolvable.promise;
+  let currentPatchValue;
   function assertStream(method) {
     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() {
@@ -943,29 +1310,106 @@ 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 {
+    /**
+     * @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
+     * `readStreamableValue` or `useStreamableValue` APIs.
+     */
     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();
     },
+    /**
+     * 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) {
@@ -976,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) {
@@ -984,8 +1436,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({});
@@ -1000,7 +1452,7 @@ function render(options) {
       return {
         name,
         description,
-        parameters: zodToJsonSchema(parameters)
+        parameters: zodToJsonSchema2(parameters)
       };
     }
   ) : void 0;
@@ -1011,7 +1463,7 @@ function render(options) {
         function: {
           name,
           description,
-          parameters: zodToJsonSchema(parameters)
+          parameters: zodToJsonSchema2(parameters)
         }
       };
     }
@@ -1122,6 +1574,194 @@ function render(options) {
   return ui.value;
 }
 
+// rsc/stream-ui/stream-ui.tsx
+import {
+  InvalidToolArgumentsError,
+  NoSuchToolError
+} from "@ai-sdk/provider";
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+var defaultTextRenderer = ({ content }) => content;
+async function streamUI({
+  model,
+  tools,
+  system,
+  prompt,
+  messages,
+  maxRetries,
+  abortSignal,
+  initial,
+  text,
+  ...settings
+}) {
+  if (typeof model === "string") {
+    throw new Error(
+      "`model` cannot be a string in `streamUI`. Use the actual model instance instead."
+    );
+  }
+  if ("functions" in settings) {
+    throw new Error(
+      "`functions` is not supported in `streamUI`, use `tools` instead."
+    );
+  }
+  if ("provider" in settings) {
+    throw new Error(
+      "`provider` is no longer needed in `streamUI`. Use `model` instead."
+    );
+  }
+  if (tools) {
+    for (const [name, tool] of Object.entries(tools)) {
+      if ("render" in tool) {
+        throw new Error(
+          "Tool definition in `streamUI` should not have `render` property. Use `generate` instead. Found in tool: " + name
+        );
+      }
+    }
+  }
+  const ui = createStreamableUI(initial);
+  const textRender = text || defaultTextRenderer;
+  let finished;
+  async function handleRender(args, renderer, res) {
+    if (!renderer)
+      return;
+    const resolvable = createResolvablePromise();
+    if (finished) {
+      finished = finished.then(() => resolvable.promise);
+    } else {
+      finished = resolvable.promise;
+    }
+    const value = renderer(...args);
+    if (value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function") {
+      const node = await value;
+      res.update(node);
+      resolvable.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.asyncIterator in value) {
+      const it = value;
+      while (true) {
+        const { done, value: value2 } = await it.next();
+        res.update(value2);
+        if (done)
+          break;
+      }
+      resolvable.resolve(void 0);
+    } else if (value && typeof value === "object" && Symbol.iterator in value) {
+      const it = value;
+      while (true) {
+        const { done, value: value2 } = it.next();
+        res.update(value2);
+        if (done)
+          break;
+      }
+      resolvable.resolve(void 0);
+    } else {
+      res.update(value);
+      resolvable.resolve(void 0);
+    }
+  }
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const result = await retry(
+    () => model.doStream({
+      mode: {
+        type: "regular",
+        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool]) => ({
+          type: "function",
+          name,
+          description: tool.description,
+          parameters: convertZodToJSONSchema(tool.parameters)
+        }))
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      abortSignal
+    })
+  );
+  const [stream, forkedStream] = result.stream.tee();
+  (async () => {
+    try {
+      let content = "";
+      let hasToolCall = false;
+      const reader = forkedStream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        switch (value.type) {
+          case "text-delta": {
+            content += value.textDelta;
+            handleRender(
+              [{ content, done: false, delta: value.textDelta }],
+              textRender,
+              ui
+            );
+            break;
+          }
+          case "tool-call-delta": {
+            hasToolCall = true;
+            break;
+          }
+          case "tool-call": {
+            const toolName = value.toolName;
+            if (!tools) {
+              throw new NoSuchToolError({ toolName });
+            }
+            const tool = tools[toolName];
+            if (!tool) {
+              throw new NoSuchToolError({
+                toolName,
+                availableTools: Object.keys(tools)
+              });
+            }
+            const parseResult = safeParseJSON({
+              text: value.args,
+              schema: tool.parameters
+            });
+            if (parseResult.success === false) {
+              throw new InvalidToolArgumentsError({
+                toolName,
+                toolArgs: value.args,
+                cause: parseResult.error
+              });
+            }
+            handleRender(
+              [
+                parseResult.value,
+                {
+                  toolName,
+                  toolCallId: value.toolCallId
+                }
+              ],
+              tool.generate,
+              ui
+            );
+            break;
+          }
+          case "error": {
+            throw value.error;
+          }
+          case "finish": {
+          }
+        }
+      }
+      if (hasToolCall) {
+        await finished;
+        ui.done();
+      } else {
+        handleRender([{ content, done: true }], textRender, ui);
+        await finished;
+        ui.done();
+      }
+    } catch (error) {
+      ui.error(error);
+    }
+  })();
+  return {
+    ...result,
+    stream,
+    value: ui.value
+  };
+}
+
 // rsc/provider.tsx
 import * as React2 from "react";
 import { InternalAIProvider } from "./rsc-shared.mjs";
@@ -1150,8 +1790,8 @@ function createAI({
   actions,
   initialAIState,
   initialUIState,
-  unstable_onSetAIState: onSetAIState,
-  unstable_onGetUIState: onGetUIState
+  onSetAIState,
+  onGetUIState
 }) {
   const wrappedActions = {};
   for (const name in actions) {
@@ -1197,6 +1837,7 @@ export {
   createStreamableValue,
   getAIState,
   getMutableAIState,
-  render
+  render,
+  streamUI
 };
 //# sourceMappingURL=rsc-server.mjs.map