ai 3.3.5 → 3.3.7

package/rsc/dist/rsc-server.mjs

@@ -139,512 +139,704 @@ function getMutableAIState(...args) {
   return mutableState;
 }
 
-// rsc/constants.ts
-var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
-var DEV_DEFAULT_STREAMABLE_WARNING_TIME = 15 * 1e3;
-
-// rsc/create-suspended-chunk.tsx
-import { Suspense } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-var R = [
-  async ({
-    c: current,
-    n: next
-  }) => {
-    const chunk = await next;
-    if (chunk.done) {
-      return chunk.value;
-    }
-    if (chunk.append) {
-      return /* @__PURE__ */ jsxs(Fragment, { children: [
-        current,
-        /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(R, { c: chunk.value, n: chunk.next }) })
-      ] });
+// rsc/provider.tsx
+import * as React from "react";
+import { InternalAIProvider } from "./rsc-shared.mjs";
+import { jsx } from "react/jsx-runtime";
+async function innerAction({
+  action,
+  options
+}, state, ...args) {
+  "use server";
+  return await withAIState(
+    {
+      state,
+      options
+    },
+    async () => {
+      const result = await action(...args);
+      sealMutableAIState();
+      return [getAIStateDeltaPromise(), result];
     }
-    return /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(R, { c: chunk.value, n: chunk.next }) });
-  }
-][0];
-function createSuspendedChunk(initialValue) {
-  const { promise, resolve, reject } = createResolvablePromise();
-  return {
-    row: /* @__PURE__ */ jsx(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx(R, { c: initialValue, n: promise }) }),
-    resolve,
-    reject
-  };
+  );
 }
-
-// rsc/streamable.tsx
-function createStreamableUI(initialValue) {
-  let currentValue = initialValue;
-  let closed = false;
-  let { row, resolve, reject } = createSuspendedChunk(initialValue);
-  function assertStream(method) {
-    if (closed) {
-      throw new Error(method + ": UI stream is already closed.");
-    }
+function wrapAction(action, options) {
+  return innerAction.bind(null, { action, options });
+}
+function createAI({
+  actions,
+  initialAIState,
+  initialUIState,
+  onSetAIState,
+  onGetUIState
+}) {
+  const wrappedActions = {};
+  for (const name8 in actions) {
+    wrappedActions[name8] = wrapAction(actions[name8], {
+      onSetAIState
+    });
   }
-  let warningTimeout;
-  function warnUnclosedStream() {
-    if (process.env.NODE_ENV === "development") {
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      warningTimeout = setTimeout(() => {
-        console.warn(
-          "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
-        );
-      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
+  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
+  const AI = async (props) => {
+    var _a8, _b;
+    if ("useState" in React) {
+      throw new Error(
+        "This component can only be used inside Server Components."
+      );
     }
-  }
-  warnUnclosedStream();
-  const streamable2 = {
-    value: row,
-    update(value) {
-      assertStream(".update()");
-      if (value === currentValue) {
-        warnUnclosedStream();
-        return streamable2;
-      }
-      const resolvable = createResolvablePromise();
-      currentValue = value;
-      resolve({ value: currentValue, done: false, next: resolvable.promise });
-      resolve = resolvable.resolve;
-      reject = resolvable.reject;
-      warnUnclosedStream();
-      return streamable2;
-    },
-    append(value) {
-      assertStream(".append()");
-      const resolvable = createResolvablePromise();
-      currentValue = value;
-      resolve({ value, done: false, append: true, next: resolvable.promise });
-      resolve = resolvable.resolve;
-      reject = resolvable.reject;
-      warnUnclosedStream();
-      return streamable2;
-    },
-    error(error) {
-      assertStream(".error()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      reject(error);
-      return streamable2;
-    },
-    done(...args) {
-      assertStream(".done()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      if (args.length) {
-        resolve({ value: args[0], done: true });
-        return streamable2;
+    let uiState = (_a8 = props.initialUIState) != null ? _a8 : initialUIState;
+    let aiState = (_b = props.initialAIState) != null ? _b : initialAIState;
+    let aiStateDelta = void 0;
+    if (wrappedSyncUIState) {
+      const [newAIStateDelta, newUIState] = await wrappedSyncUIState(aiState);
+      if (newUIState !== void 0) {
+        aiStateDelta = newAIStateDelta;
+        uiState = newUIState;
       }
-      resolve({ value: currentValue, done: true });
-      return streamable2;
     }
+    return /* @__PURE__ */ jsx(
+      InternalAIProvider,
+      {
+        wrappedActions,
+        wrappedSyncUIState,
+        initialUIState: uiState,
+        initialAIState: aiState,
+        initialAIStatePatch: aiStateDelta,
+        children: props.children
+      }
+    );
   };
-  return streamable2;
+  return AI;
 }
-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);
+
+// rsc/stream-ui/stream-ui.tsx
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+
+// core/prompt/convert-to-language-model-prompt.ts
+import { getErrorMessage } from "@ai-sdk/provider-utils";
+
+// util/download-error.ts
+import { AISDKError } from "@ai-sdk/provider";
+var name = "AI_DownloadError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a;
+var DownloadError = class extends AISDKError {
+  constructor({
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+  }) {
+    super({ name, message, cause });
+    this[_a] = true;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
   }
-  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."
-      );
-    }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker);
   }
-  let warningTimeout;
-  function warnUnclosedStream() {
-    if (process.env.NODE_ENV === "development") {
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      warningTimeout = setTimeout(() => {
-        console.warn(
-          "The streamable value has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
-        );
-      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
-    }
+  /**
+   * @deprecated use `isInstance` instead
+   */
+  static isDownloadError(error) {
+    return error instanceof Error && error.name === name && typeof error.url === "string" && (error.statusCode == null || typeof error.statusCode === "number") && (error.statusText == null || typeof error.statusText === "string");
   }
-  warnUnclosedStream();
-  function createWrapped(initialChunk) {
-    let init;
-    if (currentError !== void 0) {
-      init = { error: currentError };
-    } else {
-      if (currentPatchValue && !initialChunk) {
-        init = { diff: currentPatchValue };
-      } else {
-        init = { curr: currentValue };
+  /**
+   * @deprecated Do not use this method. It will be removed in the next major version.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      url: this.url,
+      statusCode: this.statusCode,
+      statusText: this.statusText,
+      cause: this.cause
+    };
+  }
+};
+_a = symbol;
+
+// util/download.ts
+async function download({
+  url,
+  fetchImplementation = fetch
+}) {
+  var _a8;
+  const urlText = url.toString();
+  try {
+    const response = await fetchImplementation(urlText);
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    return {
+      data: new Uint8Array(await response.arrayBuffer()),
+      mimeType: (_a8 = response.headers.get("content-type")) != null ? _a8 : void 0
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+}
+
+// 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 {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
+
+// core/prompt/invalid-data-content-error.ts
+import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
+var name2 = "AI_InvalidDataContentError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var InvalidDataContentError = class extends AISDKError2 {
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  }) {
+    super({ name: name2, message, cause });
+    this[_a2] = true;
+    this.content = content;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker2);
+  }
+  /**
+   * @deprecated use `isInstance` instead
+   */
+  static isInvalidDataContentError(error) {
+    return error instanceof Error && error.name === name2 && error.content != null;
+  }
+  /**
+   * @deprecated Do not use this method. It will be removed in the next major version.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      cause: this.cause,
+      content: this.content
+    };
+  }
+};
+_a2 = symbol2;
+
+// core/prompt/data-content.ts
+function convertDataContentToUint8Array(content) {
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  if (typeof content === "string") {
+    try {
+      return convertBase64ToUint8Array(content);
+    } catch (error) {
+      throw new InvalidDataContentError({
+        message: "Invalid data content. Content string is not a base64-encoded media.",
+        content,
+        cause: error
+      });
+    }
+  }
+  if (content instanceof ArrayBuffer) {
+    return new Uint8Array(content);
+  }
+  throw new InvalidDataContentError({ content });
+}
+
+// core/prompt/invalid-message-role-error.ts
+import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
+var name3 = "AI_InvalidMessageRoleError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var InvalidMessageRoleError = class extends AISDKError3 {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name3, message });
+    this[_a3] = true;
+    this.role = role;
+  }
+  static isInstance(error) {
+    return AISDKError3.hasMarker(error, marker3);
+  }
+  /**
+   * @deprecated use `isInstance` instead
+   */
+  static isInvalidMessageRoleError(error) {
+    return error instanceof Error && error.name === name3 && typeof error.role === "string";
+  }
+  /**
+   * @deprecated Do not use this method. It will be removed in the next major version.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      role: this.role
+    };
+  }
+};
+_a3 = symbol3;
+
+// core/prompt/convert-to-language-model-prompt.ts
+async function convertToLanguageModelPrompt({
+  prompt,
+  modelSupportsImageUrls = true,
+  downloadImplementation = download
+}) {
+  const languageModelMessages = [];
+  if (prompt.system != null) {
+    languageModelMessages.push({ role: "system", content: prompt.system });
+  }
+  const downloadedImages = modelSupportsImageUrls || prompt.messages == null ? null : await downloadImages(prompt.messages, downloadImplementation);
+  const promptType = prompt.type;
+  switch (promptType) {
+    case "prompt": {
+      languageModelMessages.push({
+        role: "user",
+        content: [{ type: "text", text: prompt.prompt }]
+      });
+      break;
+    }
+    case "messages": {
+      languageModelMessages.push(
+        ...prompt.messages.map(
+          (message) => convertToLanguageModelMessage(message, downloadedImages)
+        )
+      );
+      break;
+    }
+    default: {
+      const _exhaustiveCheck = promptType;
+      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+    }
+  }
+  return languageModelMessages;
+}
+function convertToLanguageModelMessage(message, downloadedImages) {
+  const role = message.role;
+  switch (role) {
+    case "system": {
+      return { role: "system", content: message.content };
+    }
+    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 _a8, _b, _c;
+            switch (part.type) {
+              case "text": {
+                return part;
+              }
+              case "image": {
+                if (part.image instanceof URL) {
+                  if (downloadedImages == null) {
+                    return {
+                      type: "image",
+                      image: part.image,
+                      mimeType: part.mimeType
+                    };
+                  } else {
+                    const downloadedImage = downloadedImages[part.image.toString()];
+                    return {
+                      type: "image",
+                      image: downloadedImage.data,
+                      mimeType: (_a8 = part.mimeType) != null ? _a8 : downloadedImage.mimeType
+                    };
+                  }
+                }
+                if (typeof part.image === "string") {
+                  try {
+                    const url = new URL(part.image);
+                    switch (url.protocol) {
+                      case "http:":
+                      case "https:": {
+                        if (downloadedImages == null) {
+                          return {
+                            type: "image",
+                            image: url,
+                            mimeType: part.mimeType
+                          };
+                        } else {
+                          const downloadedImage = downloadedImages[part.image];
+                          return {
+                            type: "image",
+                            image: downloadedImage.data,
+                            mimeType: (_b = part.mimeType) != null ? _b : downloadedImage.mimeType
+                          };
+                        }
+                      }
+                      case "data:": {
+                        try {
+                          const [header, base64Content] = part.image.split(",");
+                          const mimeType = header.split(";")[0].split(":")[1];
+                          if (mimeType == null || base64Content == null) {
+                            throw new Error("Invalid data URL format");
+                          }
+                          return {
+                            type: "image",
+                            image: convertDataContentToUint8Array(base64Content),
+                            mimeType
+                          };
+                        } catch (error) {
+                          throw new Error(
+                            `Error processing data URL: ${getErrorMessage(
+                              message
+                            )}`
+                          );
+                        }
+                      }
+                      default: {
+                        throw new Error(
+                          `Unsupported URL protocol: ${url.protocol}`
+                        );
+                      }
+                    }
+                  } catch (_ignored) {
+                  }
+                }
+                const imageUint8 = convertDataContentToUint8Array(part.image);
+                return {
+                  type: "image",
+                  image: imageUint8,
+                  mimeType: (_c = part.mimeType) != null ? _c : detectImageMimeType(imageUint8)
+                };
+              }
+            }
+          }
+        )
+      };
+    }
+    case "assistant": {
+      if (typeof message.content === "string") {
+        return {
+          role: "assistant",
+          content: [{ type: "text", text: message.content }]
+        };
       }
+      return {
+        role: "assistant",
+        content: message.content.filter(
+          // remove empty text parts:
+          (part) => part.type !== "text" || part.text !== ""
+        )
+      };
     }
-    if (currentPromise) {
-      init.next = currentPromise;
-    }
-    if (initialChunk) {
-      init.type = STREAMABLE_VALUE_TYPE;
+    case "tool": {
+      return message;
     }
-    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)];
-        }
-      }
+    default: {
+      const _exhaustiveCheck = role;
+      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
     }
-    currentValue = value;
   }
-  const streamable2 = {
-    set [STREAMABLE_VALUE_INTERNAL_LOCK](state) {
-      locked = state;
-    },
-    get value() {
-      return createWrapped(true);
-    },
-    update(value) {
-      assertStream(".update()");
-      const resolvePrevious = resolvable.resolve;
-      resolvable = createResolvablePromise();
-      updateValueStates(value);
-      currentPromise = resolvable.promise;
-      resolvePrevious(createWrapped());
-      warnUnclosedStream();
-      return streamable2;
-    },
-    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();
-      return streamable2;
-    },
-    error(error) {
-      assertStream(".error()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      currentError = error;
-      currentPromise = void 0;
-      resolvable.resolve({ error });
-      return streamable2;
-    },
-    done(...args) {
-      assertStream(".done()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      currentPromise = void 0;
-      if (args.length) {
-        updateValueStates(args[0]);
-        resolvable.resolve(createWrapped());
-        return streamable2;
-      }
-      resolvable.resolve({});
-      return streamable2;
-    }
-  };
-  return streamable2;
 }
-
-// rsc/render.ts
-import zodToJsonSchema2 from "zod-to-json-schema";
-
-// util/retry-with-exponential-backoff.ts
-import { APICallError } from "@ai-sdk/provider";
-import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
-
-// util/delay.ts
-async function delay(delayInMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayInMs));
+async function downloadImages(messages, downloadImplementation) {
+  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
+    (content) => Array.isArray(content)
+  ).flat().filter((part) => part.type === "image").map((part) => part.image).map(
+    (part) => (
+      // support string urls in image parts:
+      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
+    )
+  ).filter((image) => image instanceof URL);
+  const downloadedImages = await Promise.all(
+    urls.map(async (url) => ({
+      url,
+      data: await downloadImplementation({ url })
+    }))
+  );
+  return Object.fromEntries(
+    downloadedImages.map(({ url, data }) => [url.toString(), data])
+  );
 }
 
-// util/retry-error.ts
-import { AISDKError } from "@ai-sdk/provider";
-var name = "AI_RetryError";
-var marker = `vercel.ai.error.${name}`;
-var symbol = Symbol.for(marker);
-var _a;
-var RetryError = class extends AISDKError {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super({ name, message });
-    this[_a] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker);
-  }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isRetryError(error) {
-    return error instanceof Error && error.name === name && typeof error.reason === "string" && Array.isArray(error.errors);
+// 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"
+    });
   }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      reason: this.reason,
-      lastError: this.lastError,
-      errors: this.errors
-    };
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
   }
-};
-_a = symbol;
-
-// 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;
+  if (prompt.messages != null) {
+    for (const message of prompt.messages) {
+      if (message.role === "system" && typeof message.content !== "string") {
+        throw new InvalidPromptError({
+          prompt,
+          message: "system message content must be a string"
+        });
+      }
     }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
   }
+  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/convert-to-language-model-prompt.ts
-import { getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider-utils";
-
-// util/download-error.ts
-import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
-var name2 = "AI_DownloadError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
-var DownloadError = class extends AISDKError2 {
+// errors/invalid-argument-error.ts
+import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
+var name4 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError4 {
   constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+    parameter,
+    value,
+    message
   }) {
-    super({ name: name2, message, cause });
-    this[_a2] = true;
-    this.url = url;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
+    super({
+      name: name4,
+      message: `Invalid argument for parameter ${parameter}: ${message}`
+    });
+    this[_a4] = true;
+    this.parameter = parameter;
+    this.value = value;
   }
   static isInstance(error) {
-    return AISDKError2.hasMarker(error, marker2);
+    return AISDKError4.hasMarker(error, marker4);
   }
   /**
    * @deprecated use `isInstance` instead
    */
-  static isDownloadError(error) {
-    return error instanceof Error && error.name === name2 && typeof error.url === "string" && (error.statusCode == null || typeof error.statusCode === "number") && (error.statusText == null || typeof error.statusText === "string");
+  static isInvalidArgumentError(error) {
+    return error instanceof Error && error.name === name4 && typeof error.parameter === "string" && typeof error.value === "string";
   }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
   toJSON() {
     return {
       name: this.name,
       message: this.message,
-      url: this.url,
-      statusCode: this.statusCode,
-      statusText: this.statusText,
-      cause: this.cause
+      stack: this.stack,
+      parameter: this.parameter,
+      value: this.value
     };
   }
 };
-_a2 = symbol2;
+_a4 = symbol4;
 
-// util/download.ts
-async function download({
-  url,
-  fetchImplementation = fetch
+// core/prompt/prepare-call-settings.ts
+function prepareCallSettings({
+  maxTokens,
+  temperature,
+  topP,
+  presencePenalty,
+  frequencyPenalty,
+  stopSequences,
+  seed,
+  maxRetries
 }) {
-  var _a8;
-  const urlText = url.toString();
-  try {
-    const response = await fetchImplementation(urlText);
-    if (!response.ok) {
-      throw new DownloadError({
-        url: urlText,
-        statusCode: response.status,
-        statusText: response.statusText
+  if (maxTokens != null) {
+    if (!Number.isInteger(maxTokens)) {
+      throw new InvalidArgumentError({
+        parameter: "maxTokens",
+        value: maxTokens,
+        message: "maxTokens must be an integer"
       });
     }
-    return {
-      data: new Uint8Array(await response.arrayBuffer()),
-      mimeType: (_a8 = response.headers.get("content-type")) != null ? _a8 : void 0
-    };
-  } catch (error) {
-    if (DownloadError.isInstance(error)) {
-      throw error;
+    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"
+      });
     }
-    throw new DownloadError({ url: urlText, cause: error });
   }
+  return {
+    maxTokens,
+    temperature: temperature != null ? temperature : 0,
+    topP,
+    presencePenalty,
+    frequencyPenalty,
+    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
 }
 
-// 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;
-    }
+// core/prompt/prepare-tools-and-tool-choice.ts
+import { asSchema } from "@ai-sdk/ui-utils";
+
+// core/util/is-non-empty-object.ts
+function isNonEmptyObject(object) {
+  return object != null && Object.keys(object).length > 0;
+}
+
+// core/prompt/prepare-tools-and-tool-choice.ts
+function prepareToolsAndToolChoice({
+  tools,
+  toolChoice
+}) {
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: void 0,
+      toolChoice: void 0
+    };
   }
-  return void 0;
+  return {
+    tools: Object.entries(tools).map(([name8, tool]) => ({
+      type: "function",
+      name: name8,
+      description: tool.description,
+      parameters: asSchema(tool.parameters).jsonSchema
+    })),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
 }
 
-// core/prompt/data-content.ts
-import {
-  convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
-} from "@ai-sdk/provider-utils";
+// core/types/token-usage.ts
+function calculateCompletionTokenUsage(usage) {
+  return {
+    promptTokens: usage.promptTokens,
+    completionTokens: usage.completionTokens,
+    totalTokens: usage.promptTokens + usage.completionTokens
+  };
+}
 
-// core/prompt/invalid-data-content-error.ts
-import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
-var name3 = "AI_InvalidDataContentError";
-var marker3 = `vercel.ai.error.${name3}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
-var InvalidDataContentError = class extends AISDKError3 {
+// errors/invalid-tool-arguments-error.ts
+import { AISDKError as AISDKError5, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
+var name5 = "AI_InvalidToolArgumentsError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var InvalidToolArgumentsError = class extends AISDKError5 {
   constructor({
-    content,
+    toolArgs,
+    toolName,
     cause,
-    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage2(
+      cause
+    )}`
   }) {
-    super({ name: name3, message, cause });
-    this[_a3] = true;
-    this.content = content;
+    super({ name: name5, message, cause });
+    this[_a5] = true;
+    this.toolArgs = toolArgs;
+    this.toolName = toolName;
   }
   static isInstance(error) {
-    return AISDKError3.hasMarker(error, marker3);
+    return AISDKError5.hasMarker(error, marker5);
   }
   /**
    * @deprecated use `isInstance` instead
    */
-  static isInvalidDataContentError(error) {
-    return error instanceof Error && error.name === name3 && error.content != null;
+  static isInvalidToolArgumentsError(error) {
+    return error instanceof Error && error.name === name5 && typeof error.toolName === "string" && typeof error.toolArgs === "string";
   }
   /**
    * @deprecated Do not use this method. It will be removed in the next major version.
@@ -653,59 +845,40 @@ var InvalidDataContentError = class extends AISDKError3 {
     return {
       name: this.name,
       message: this.message,
-      stack: this.stack,
       cause: this.cause,
-      content: this.content
+      stack: this.stack,
+      toolName: this.toolName,
+      toolArgs: this.toolArgs
     };
-  }
-};
-_a3 = symbol3;
-
-// core/prompt/data-content.ts
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
-  }
-  if (typeof content === "string") {
-    try {
-      return convertBase64ToUint8Array(content);
-    } catch (error) {
-      throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded media.",
-        content,
-        cause: error
-      });
-    }
-  }
-  if (content instanceof ArrayBuffer) {
-    return new Uint8Array(content);
-  }
-  throw new InvalidDataContentError({ content });
-}
+  }
+};
+_a5 = symbol5;
 
-// core/prompt/invalid-message-role-error.ts
-import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
-var name4 = "AI_InvalidMessageRoleError";
-var marker4 = `vercel.ai.error.${name4}`;
-var symbol4 = Symbol.for(marker4);
-var _a4;
-var InvalidMessageRoleError = class extends AISDKError4 {
+// errors/no-such-tool-error.ts
+import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
+var name6 = "AI_NoSuchToolError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var NoSuchToolError = class extends AISDKError6 {
   constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+    toolName,
+    availableTools = void 0,
+    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
   }) {
-    super({ name: name4, message });
-    this[_a4] = true;
-    this.role = role;
+    super({ name: name6, message });
+    this[_a6] = true;
+    this.toolName = toolName;
+    this.availableTools = availableTools;
   }
   static isInstance(error) {
-    return AISDKError4.hasMarker(error, marker4);
+    return AISDKError6.hasMarker(error, marker6);
   }
   /**
    * @deprecated use `isInstance` instead
    */
-  static isInvalidMessageRoleError(error) {
-    return error instanceof Error && error.name === name4 && typeof error.role === "string";
+  static isNoSuchToolError(error) {
+    return error instanceof Error && error.name === name6 && "toolName" in error && error.toolName != void 0 && typeof error.name === "string";
   }
   /**
    * @deprecated Do not use this method. It will be removed in the next major version.
@@ -715,528 +888,429 @@ var InvalidMessageRoleError = class extends AISDKError4 {
       name: this.name,
       message: this.message,
       stack: this.stack,
-      role: this.role
+      toolName: this.toolName,
+      availableTools: this.availableTools
     };
   }
 };
-_a4 = symbol4;
+_a6 = symbol6;
 
-// core/prompt/convert-to-language-model-prompt.ts
-async function convertToLanguageModelPrompt({
-  prompt,
-  modelSupportsImageUrls = true,
-  downloadImplementation = download
-}) {
-  const languageModelMessages = [];
-  if (prompt.system != null) {
-    languageModelMessages.push({ role: "system", content: prompt.system });
-  }
-  const downloadedImages = modelSupportsImageUrls || prompt.messages == null ? null : await downloadImages(prompt.messages, downloadImplementation);
-  const promptType = prompt.type;
-  switch (promptType) {
-    case "prompt": {
-      languageModelMessages.push({
-        role: "user",
-        content: [{ type: "text", text: prompt.prompt }]
-      });
-      break;
-    }
-    case "messages": {
-      languageModelMessages.push(
-        ...prompt.messages.map(
-          (message) => convertToLanguageModelMessage(message, downloadedImages)
-        )
-      );
-      break;
-    }
-    default: {
-      const _exhaustiveCheck = promptType;
-      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
-    }
-  }
-  return languageModelMessages;
-}
-function convertToLanguageModelMessage(message, downloadedImages) {
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return { role: "system", content: message.content };
-    }
-    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 _a8, _b, _c;
-            switch (part.type) {
-              case "text": {
-                return part;
-              }
-              case "image": {
-                if (part.image instanceof URL) {
-                  if (downloadedImages == null) {
-                    return {
-                      type: "image",
-                      image: part.image,
-                      mimeType: part.mimeType
-                    };
-                  } else {
-                    const downloadedImage = downloadedImages[part.image.toString()];
-                    return {
-                      type: "image",
-                      image: downloadedImage.data,
-                      mimeType: (_a8 = part.mimeType) != null ? _a8 : downloadedImage.mimeType
-                    };
-                  }
-                }
-                if (typeof part.image === "string") {
-                  try {
-                    const url = new URL(part.image);
-                    switch (url.protocol) {
-                      case "http:":
-                      case "https:": {
-                        if (downloadedImages == null) {
-                          return {
-                            type: "image",
-                            image: url,
-                            mimeType: part.mimeType
-                          };
-                        } else {
-                          const downloadedImage = downloadedImages[part.image];
-                          return {
-                            type: "image",
-                            image: downloadedImage.data,
-                            mimeType: (_b = part.mimeType) != null ? _b : downloadedImage.mimeType
-                          };
-                        }
-                      }
-                      case "data:": {
-                        try {
-                          const [header, base64Content] = part.image.split(",");
-                          const mimeType = header.split(";")[0].split(":")[1];
-                          if (mimeType == null || base64Content == null) {
-                            throw new Error("Invalid data URL format");
-                          }
-                          return {
-                            type: "image",
-                            image: convertDataContentToUint8Array(base64Content),
-                            mimeType
-                          };
-                        } catch (error) {
-                          throw new Error(
-                            `Error processing data URL: ${getErrorMessage2(
-                              message
-                            )}`
-                          );
-                        }
-                      }
-                      default: {
-                        throw new Error(
-                          `Unsupported URL protocol: ${url.protocol}`
-                        );
-                      }
-                    }
-                  } catch (_ignored) {
-                  }
-                }
-                const imageUint8 = convertDataContentToUint8Array(part.image);
-                return {
-                  type: "image",
-                  image: imageUint8,
-                  mimeType: (_c = part.mimeType) != null ? _c : detectImageMimeType(imageUint8)
-                };
-              }
-            }
-          }
-        )
-      };
-    }
-    case "assistant": {
-      if (typeof message.content === "string") {
-        return {
-          role: "assistant",
-          content: [{ type: "text", text: message.content }]
-        };
-      }
-      return {
-        role: "assistant",
-        content: message.content.filter(
-          // remove empty text parts:
-          (part) => part.type !== "text" || part.text !== ""
-        )
-      };
-    }
-    case "tool": {
-      return message;
-    }
-    default: {
-      const _exhaustiveCheck = role;
-      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
-    }
-  }
+// util/is-async-generator.ts
+function isAsyncGenerator(value) {
+  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-async function downloadImages(messages, downloadImplementation) {
-  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
-    (content) => Array.isArray(content)
-  ).flat().filter((part) => part.type === "image").map((part) => part.image).map(
-    (part) => (
-      // support string urls in image parts:
-      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
-    )
-  ).filter((image) => image instanceof URL);
-  const downloadedImages = await Promise.all(
-    urls.map(async (url) => ({
-      url,
-      data: await downloadImplementation({ url })
-    }))
-  );
-  return Object.fromEntries(
-    downloadedImages.map(({ url, data }) => [url.toString(), data])
-  );
+
+// util/is-generator.ts
+function isGenerator(value) {
+  return value != null && typeof value === "object" && Symbol.iterator in value;
 }
 
-// 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"
-    });
-  }
-  if (prompt.messages != null) {
-    for (const message of prompt.messages) {
-      if (message.role === "system" && typeof message.content !== "string") {
-        throw new InvalidPromptError({
-          prompt,
-          message: "system message content must be a string"
-        });
-      }
-    }
-  }
-  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
-  };
+// util/retry-with-exponential-backoff.ts
+import { APICallError } from "@ai-sdk/provider";
+import { getErrorMessage as getErrorMessage3, isAbortError } from "@ai-sdk/provider-utils";
+
+// util/delay.ts
+async function delay(delayInMs) {
+  return delayInMs === void 0 ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs));
 }
 
-// errors/invalid-argument-error.ts
-import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
-var name5 = "AI_InvalidArgumentError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var InvalidArgumentError = class extends AISDKError5 {
+// util/retry-error.ts
+import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
+var name7 = "AI_RetryError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var RetryError = class extends AISDKError7 {
   constructor({
-    parameter,
-    value,
-    message
+    message,
+    reason,
+    errors
   }) {
-    super({
-      name: name5,
-      message: `Invalid argument for parameter ${parameter}: ${message}`
-    });
-    this[_a5] = true;
-    this.parameter = parameter;
-    this.value = value;
+    super({ name: name7, message });
+    this[_a7] = true;
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return AISDKError5.hasMarker(error, marker5);
+    return AISDKError7.hasMarker(error, marker7);
   }
   /**
    * @deprecated use `isInstance` instead
    */
-  static isInvalidArgumentError(error) {
-    return error instanceof Error && error.name === name5 && typeof error.parameter === "string" && typeof error.value === "string";
+  static isRetryError(error) {
+    return error instanceof Error && error.name === name7 && typeof error.reason === "string" && Array.isArray(error.errors);
   }
+  /**
+   * @deprecated Do not use this method. It will be removed in the next major version.
+   */
   toJSON() {
     return {
       name: this.name,
       message: this.message,
-      stack: this.stack,
-      parameter: this.parameter,
-      value: this.value
+      reason: this.reason,
+      lastError: this.lastError,
+      errors: this.errors
     };
   }
 };
-_a5 = symbol5;
+_a7 = symbol7;
 
-// core/prompt/prepare-call-settings.ts
-function prepareCallSettings({
-  maxTokens,
-  temperature,
-  topP,
-  presencePenalty,
-  frequencyPenalty,
-  stopSequences,
-  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"
-      });
+// 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 (topP != null) {
-    if (typeof topP !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "topP",
-        value: topP,
-        message: "topP must be a number"
-      });
+    if (maxRetries === 0) {
+      throw error;
     }
-  }
-  if (presencePenalty != null) {
-    if (typeof presencePenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "presencePenalty",
-        value: presencePenalty,
-        message: "presencePenalty must be a number"
+    const errorMessage = getErrorMessage3(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 (frequencyPenalty != null) {
-    if (typeof frequencyPenalty !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "frequencyPenalty",
-        value: frequencyPenalty,
-        message: "frequencyPenalty must be a number"
-      });
+    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 (seed != null) {
-    if (!Number.isInteger(seed)) {
-      throw new InvalidArgumentError({
-        parameter: "seed",
-        value: seed,
-        message: "seed must be an integer"
-      });
+    if (tryNumber === 1) {
+      throw error;
     }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
   }
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
+}
+
+// util/constants.ts
+var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
+
+// rsc/streamable-ui/create-suspended-chunk.tsx
+import { Suspense } from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var R = [
+  async ({
+    c: current,
+    n: next
+  }) => {
+    const chunk = await next;
+    if (chunk.done) {
+      return chunk.value;
     }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
+    if (chunk.append) {
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        current,
+        /* @__PURE__ */ jsx2(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx2(R, { c: chunk.value, n: chunk.next }) })
+      ] });
     }
+    return /* @__PURE__ */ jsx2(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx2(R, { c: chunk.value, n: chunk.next }) });
   }
+][0];
+function createSuspendedChunk(initialValue) {
+  const { promise, resolve, reject } = createResolvablePromise();
   return {
-    maxTokens,
-    temperature: temperature != null ? temperature : 0,
-    topP,
-    presencePenalty,
-    frequencyPenalty,
-    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
-    seed,
-    maxRetries: maxRetries != null ? maxRetries : 2
-  };
-}
-
-// core/types/token-usage.ts
-function calculateCompletionTokenUsage(usage) {
-  return {
-    promptTokens: usage.promptTokens,
-    completionTokens: usage.completionTokens,
-    totalTokens: usage.promptTokens + usage.completionTokens
+    row: /* @__PURE__ */ jsx2(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx2(R, { c: initialValue, n: promise }) }),
+    resolve,
+    reject
   };
 }
 
-// core/util/schema.ts
-import { validatorSymbol } from "@ai-sdk/provider-utils";
-import zodToJsonSchema from "zod-to-json-schema";
-var schemaSymbol = Symbol.for("vercel.ai.schema");
-function jsonSchema(jsonSchema2, {
-  validate
-} = {}) {
-  return {
-    [schemaSymbol]: true,
-    _type: void 0,
-    // should never be used directly
-    [validatorSymbol]: true,
-    jsonSchema: jsonSchema2,
-    validate
-  };
-}
-function isSchema(value) {
-  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
-}
-function asSchema(schema) {
-  return isSchema(schema) ? schema : zodSchema(schema);
-}
-function zodSchema(zodSchema2) {
-  return jsonSchema(
-    // we assume that zodToJsonSchema will return a valid JSONSchema7:
-    zodToJsonSchema(zodSchema2),
-    {
-      validate: (value) => {
-        const result = zodSchema2.safeParse(value);
-        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+// rsc/streamable-ui/create-streamable-ui.tsx
+function createStreamableUI(initialValue) {
+  let currentValue = initialValue;
+  let closed = false;
+  let { row, resolve, reject } = createSuspendedChunk(initialValue);
+  function assertStream(method) {
+    if (closed) {
+      throw new Error(method + ": UI stream is already closed.");
+    }
+  }
+  let warningTimeout;
+  function warnUnclosedStream() {
+    if (process.env.NODE_ENV === "development") {
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      warningTimeout = setTimeout(() => {
+        console.warn(
+          "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
+        );
+      }, HANGING_STREAM_WARNING_TIME_MS);
+    }
+  }
+  warnUnclosedStream();
+  const streamable2 = {
+    value: row,
+    update(value) {
+      assertStream(".update()");
+      if (value === currentValue) {
+        warnUnclosedStream();
+        return streamable2;
+      }
+      const resolvable = createResolvablePromise();
+      currentValue = value;
+      resolve({ value: currentValue, done: false, next: resolvable.promise });
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      warnUnclosedStream();
+      return streamable2;
+    },
+    append(value) {
+      assertStream(".append()");
+      const resolvable = createResolvablePromise();
+      currentValue = value;
+      resolve({ value, done: false, append: true, next: resolvable.promise });
+      resolve = resolvable.resolve;
+      reject = resolvable.reject;
+      warnUnclosedStream();
+      return streamable2;
+    },
+    error(error) {
+      assertStream(".error()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      closed = true;
+      reject(error);
+      return streamable2;
+    },
+    done(...args) {
+      assertStream(".done()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      closed = true;
+      if (args.length) {
+        resolve({ value: args[0], done: true });
+        return streamable2;
       }
+      resolve({ value: currentValue, done: true });
+      return streamable2;
     }
-  );
-}
-
-// core/util/is-non-empty-object.ts
-function isNonEmptyObject(object) {
-  return object != null && Object.keys(object).length > 0;
+  };
+  return streamable2;
 }
 
-// core/prompt/prepare-tools-and-tool-choice.ts
-function prepareToolsAndToolChoice({
+// rsc/stream-ui/stream-ui.tsx
+var defaultTextRenderer = ({ content }) => content;
+async function streamUI({
+  model,
   tools,
-  toolChoice
+  toolChoice,
+  system,
+  prompt,
+  messages,
+  maxRetries,
+  abortSignal,
+  headers,
+  initial,
+  text,
+  onFinish,
+  ...settings
 }) {
-  if (!isNonEmptyObject(tools)) {
-    return {
-      tools: void 0,
-      toolChoice: void 0
-    };
+  if (typeof model === "string") {
+    throw new Error(
+      "`model` cannot be a string in `streamUI`. Use the actual model instance instead."
+    );
   }
-  return {
-    tools: Object.entries(tools).map(([name8, tool]) => ({
-      type: "function",
-      name: name8,
-      description: tool.description,
-      parameters: asSchema(tool.parameters).jsonSchema
-    })),
-    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
-  };
-}
-
-// errors/invalid-tool-arguments-error.ts
-import { AISDKError as AISDKError6, getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
-var name6 = "AI_InvalidToolArgumentsError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var InvalidToolArgumentsError = class extends AISDKError6 {
-  constructor({
-    toolArgs,
-    toolName,
-    cause,
-    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage3(
-      cause
-    )}`
-  }) {
-    super({ name: name6, message, cause });
-    this[_a6] = true;
-    this.toolArgs = toolArgs;
-    this.toolName = toolName;
+  if ("functions" in settings) {
+    throw new Error(
+      "`functions` is not supported in `streamUI`, use `tools` instead."
+    );
   }
-  static isInstance(error) {
-    return AISDKError6.hasMarker(error, marker6);
+  if ("provider" in settings) {
+    throw new Error(
+      "`provider` is no longer needed in `streamUI`. Use `model` instead."
+    );
   }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isInvalidToolArgumentsError(error) {
-    return error instanceof Error && error.name === name6 && typeof error.toolName === "string" && typeof error.toolArgs === "string";
+  if (tools) {
+    for (const [name8, 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: " + name8
+        );
+      }
+    }
   }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      cause: this.cause,
-      stack: this.stack,
-      toolName: this.toolName,
-      toolArgs: this.toolArgs
-    };
+  const ui = createStreamableUI(initial);
+  const textRender = text || defaultTextRenderer;
+  let finished;
+  async function render2({
+    args,
+    renderer,
+    streamableUI,
+    isLastCall = false
+  }) {
+    if (!renderer)
+      return;
+    const renderFinished = createResolvablePromise();
+    finished = finished ? finished.then(() => renderFinished.promise) : renderFinished.promise;
+    const rendererResult = renderer(...args);
+    if (isAsyncGenerator(rendererResult) || isGenerator(rendererResult)) {
+      while (true) {
+        const { done, value } = await rendererResult.next();
+        const node = await value;
+        if (isLastCall && done) {
+          streamableUI.done(node);
+        } else {
+          streamableUI.update(node);
+        }
+        if (done)
+          break;
+      }
+    } else {
+      const node = await rendererResult;
+      if (isLastCall) {
+        streamableUI.done(node);
+      } else {
+        streamableUI.update(node);
+      }
+    }
+    renderFinished.resolve(void 0);
   }
-};
-_a6 = symbol6;
+  const retry = retryWithExponentialBackoff({ maxRetries });
+  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
+  const result = await retry(
+    async () => model.doStream({
+      mode: {
+        type: "regular",
+        ...prepareToolsAndToolChoice({ tools, toolChoice })
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: await convertToLanguageModelPrompt({
+        prompt: validatedPrompt,
+        modelSupportsImageUrls: model.supportsImageUrls
+      }),
+      abortSignal,
+      headers
+    })
+  );
+  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;
+            render2({
+              renderer: textRender,
+              args: [{ content, done: false, delta: value.textDelta }],
+              streamableUI: 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)
+              });
+            }
+            hasToolCall = true;
+            const parseResult = safeParseJSON({
+              text: value.args,
+              schema: tool.parameters
+            });
+            if (parseResult.success === false) {
+              throw new InvalidToolArgumentsError({
+                toolName,
+                toolArgs: value.args,
+                cause: parseResult.error
+              });
+            }
+            render2({
+              renderer: tool.generate,
+              args: [
+                parseResult.value,
+                {
+                  toolName,
+                  toolCallId: value.toolCallId
+                }
+              ],
+              streamableUI: ui,
+              isLastCall: true
+            });
+            break;
+          }
+          case "error": {
+            throw value.error;
+          }
+          case "finish": {
+            onFinish == null ? void 0 : onFinish({
+              finishReason: value.finishReason,
+              usage: calculateCompletionTokenUsage(value.usage),
+              value: ui.value,
+              warnings: result.warnings,
+              rawResponse: result.rawResponse
+            });
+          }
+        }
+      }
+      if (!hasToolCall) {
+        render2({
+          renderer: textRender,
+          args: [{ content, done: true }],
+          streamableUI: ui,
+          isLastCall: true
+        });
+      }
+      await finished;
+    } catch (error) {
+      ui.error(error);
+    }
+  })();
+  return {
+    ...result,
+    stream,
+    value: ui.value
+  };
+}
 
-// errors/no-such-tool-error.ts
-import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
-var name7 = "AI_NoSuchToolError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var NoSuchToolError = class extends AISDKError7 {
-  constructor({
-    toolName,
-    availableTools = void 0,
-    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
-  }) {
-    super({ name: name7, message });
-    this[_a7] = true;
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-  static isInstance(error) {
-    return AISDKError7.hasMarker(error, marker7);
-  }
-  /**
-   * @deprecated use `isInstance` instead
-   */
-  static isNoSuchToolError(error) {
-    return error instanceof Error && error.name === name7 && "toolName" in error && error.toolName != void 0 && typeof error.name === "string";
-  }
-  /**
-   * @deprecated Do not use this method. It will be removed in the next major version.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      stack: this.stack,
-      toolName: this.toolName,
-      availableTools: this.availableTools
-    };
-  }
-};
-_a7 = symbol7;
+// rsc/stream-ui/render.ts
+import zodToJsonSchema from "zod-to-json-schema";
 
 // streams/ai-stream.ts
 import {
@@ -1364,7 +1438,6 @@ function readableFromAsyncIterable(iterable) {
 
 // streams/stream-data.ts
 import { formatStreamPart } from "@ai-sdk/ui-utils";
-var STREAM_DATA_WARNING_TIME_MS = 15 * 1e3;
 function createStreamDataTransformer() {
   const encoder = new TextEncoder();
   const decoder = new TextDecoder();
@@ -1708,7 +1781,7 @@ async function consumeStream(stream) {
   }
 }
 
-// rsc/render.ts
+// rsc/stream-ui/render.ts
 function render(options) {
   const ui = createStreamableUI(options.initial);
   const text = options.text ? options.text : ({ content }) => content;
@@ -1717,7 +1790,7 @@ function render(options) {
       return {
         name: name8,
         description,
-        parameters: zodToJsonSchema2(parameters)
+        parameters: zodToJsonSchema(parameters)
       };
     }
   ) : void 0;
@@ -1728,7 +1801,7 @@ function render(options) {
         function: {
           name: name8,
           description,
-          parameters: zodToJsonSchema2(parameters)
+          parameters: zodToJsonSchema(parameters)
         }
       };
     }
@@ -1809,308 +1882,206 @@ function render(options) {
             async experimental_onToolCall(toolCallPayload) {
               var _a8, _b;
               hasFunction = true;
-              for (const tool of toolCallPayload.tools) {
-                handleRender(
-                  tool.func.arguments,
-                  (_b = (_a8 = options.tools) == null ? void 0 : _a8[tool.func.name]) == null ? void 0 : _b.render,
-                  ui
-                );
-              }
-            }
-          } : {},
-          onText(chunk) {
-            content += chunk;
-            handleRender({ content, done: false, delta: chunk }, text, ui);
-          },
-          async onFinal() {
-            if (hasFunction) {
-              await finished;
-              ui.done();
-              return;
-            }
-            handleRender({ content, done: true }, text, ui);
-            await finished;
-            ui.done();
-          }
-        }
-      )
-    );
-  })();
-  return ui.value;
-}
-
-// rsc/stream-ui/stream-ui.tsx
-import { safeParseJSON } from "@ai-sdk/provider-utils";
-
-// util/is-async-generator.ts
-function isAsyncGenerator(value) {
-  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
-}
-
-// util/is-generator.ts
-function isGenerator(value) {
-  return value != null && typeof value === "object" && Symbol.iterator in value;
-}
-
-// rsc/stream-ui/stream-ui.tsx
-var defaultTextRenderer = ({ content }) => content;
-async function streamUI({
-  model,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  headers,
-  initial,
-  text,
-  onFinish,
-  ...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 [name8, 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: " + name8
-        );
-      }
-    }
-  }
-  const ui = createStreamableUI(initial);
-  const textRender = text || defaultTextRenderer;
-  let finished;
-  async function render2({
-    args,
-    renderer,
-    streamableUI,
-    isLastCall = false
-  }) {
-    if (!renderer)
-      return;
-    const renderFinished = createResolvablePromise();
-    finished = finished ? finished.then(() => renderFinished.promise) : renderFinished.promise;
-    const rendererResult = renderer(...args);
-    if (isAsyncGenerator(rendererResult) || isGenerator(rendererResult)) {
-      while (true) {
-        const { done, value } = await rendererResult.next();
-        const node = await value;
-        if (isLastCall && done) {
-          streamableUI.done(node);
-        } else {
-          streamableUI.update(node);
-        }
-        if (done)
-          break;
-      }
-    } else {
-      const node = await rendererResult;
-      if (isLastCall) {
-        streamableUI.done(node);
-      } else {
-        streamableUI.update(node);
-      }
-    }
-    renderFinished.resolve(void 0);
-  }
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-  const result = await retry(
-    async () => model.doStream({
-      mode: {
-        type: "regular",
-        ...prepareToolsAndToolChoice({ tools, toolChoice })
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: validatedPrompt.type,
-      prompt: await convertToLanguageModelPrompt({
-        prompt: validatedPrompt,
-        modelSupportsImageUrls: model.supportsImageUrls
-      }),
-      abortSignal,
-      headers
-    })
-  );
-  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;
-            render2({
-              renderer: textRender,
-              args: [{ content, done: false, delta: value.textDelta }],
-              streamableUI: 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)
-              });
-            }
-            hasToolCall = true;
-            const parseResult = safeParseJSON({
-              text: value.args,
-              schema: tool.parameters
-            });
-            if (parseResult.success === false) {
-              throw new InvalidToolArgumentsError({
-                toolName,
-                toolArgs: value.args,
-                cause: parseResult.error
-              });
-            }
-            render2({
-              renderer: tool.generate,
-              args: [
-                parseResult.value,
-                {
-                  toolName,
-                  toolCallId: value.toolCallId
-                }
-              ],
-              streamableUI: ui,
-              isLastCall: true
-            });
-            break;
-          }
-          case "error": {
-            throw value.error;
-          }
-          case "finish": {
-            onFinish == null ? void 0 : onFinish({
-              finishReason: value.finishReason,
-              usage: calculateCompletionTokenUsage(value.usage),
-              value: ui.value,
-              warnings: result.warnings,
-              rawResponse: result.rawResponse
-            });
+              for (const tool of toolCallPayload.tools) {
+                handleRender(
+                  tool.func.arguments,
+                  (_b = (_a8 = options.tools) == null ? void 0 : _a8[tool.func.name]) == null ? void 0 : _b.render,
+                  ui
+                );
+              }
+            }
+          } : {},
+          onText(chunk) {
+            content += chunk;
+            handleRender({ content, done: false, delta: chunk }, text, ui);
+          },
+          async onFinal() {
+            if (hasFunction) {
+              await finished;
+              ui.done();
+              return;
+            }
+            handleRender({ content, done: true }, text, ui);
+            await finished;
+            ui.done();
           }
         }
-      }
-      if (!hasToolCall) {
-        render2({
-          renderer: textRender,
-          args: [{ content, done: true }],
-          streamableUI: ui,
-          isLastCall: true
-        });
-      }
-      await finished;
-    } catch (error) {
-      ui.error(error);
-    }
+      )
+    );
   })();
-  return {
-    ...result,
-    stream,
-    value: ui.value
-  };
+  return ui.value;
 }
 
-// rsc/provider.tsx
-import * as React2 from "react";
-import { InternalAIProvider } from "./rsc-shared.mjs";
-import { jsx as jsx2 } from "react/jsx-runtime";
-async function innerAction({
-  action,
-  options
-}, state, ...args) {
-  "use server";
-  return await withAIState(
-    {
-      state,
-      options
-    },
-    async () => {
-      const result = await action(...args);
-      sealMutableAIState();
-      return [getAIStateDeltaPromise(), result];
+// rsc/streamable-value/streamable-value.ts
+var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
+
+// rsc/streamable-value/create-streamable-value.ts
+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);
     }
-  );
-}
-function wrapAction(action, options) {
-  return innerAction.bind(null, { action, options });
+  })();
+  return streamableValue;
 }
-function createAI({
-  actions,
-  initialAIState,
-  initialUIState,
-  onSetAIState,
-  onGetUIState
-}) {
-  const wrappedActions = {};
-  for (const name8 in actions) {
-    wrappedActions[name8] = wrapAction(actions[name8], {
-      onSetAIState
-    });
-  }
-  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
-  const AI = async (props) => {
-    var _a8, _b;
-    if ("useState" in React2) {
+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(
-        "This component can only be used inside Server Components."
+        method + ": Value stream is locked and cannot be updated."
       );
     }
-    let uiState = (_a8 = props.initialUIState) != null ? _a8 : initialUIState;
-    let aiState = (_b = props.initialAIState) != null ? _b : initialAIState;
-    let aiStateDelta = void 0;
-    if (wrappedSyncUIState) {
-      const [newAIStateDelta, newUIState] = await wrappedSyncUIState(aiState);
-      if (newUIState !== void 0) {
-        aiStateDelta = newAIStateDelta;
-        uiState = newUIState;
+  }
+  let warningTimeout;
+  function warnUnclosedStream() {
+    if (process.env.NODE_ENV === "development") {
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
       }
+      warningTimeout = setTimeout(() => {
+        console.warn(
+          "The streamable value has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
+        );
+      }, HANGING_STREAM_WARNING_TIME_MS);
     }
-    return /* @__PURE__ */ jsx2(
-      InternalAIProvider,
-      {
-        wrappedActions,
-        wrappedSyncUIState,
-        initialUIState: uiState,
-        initialAIState: aiState,
-        initialAIStatePatch: aiStateDelta,
-        children: props.children
+  }
+  warnUnclosedStream();
+  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 (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;
+  }
+  const streamable2 = {
+    set [STREAMABLE_VALUE_INTERNAL_LOCK](state) {
+      locked = state;
+    },
+    get value() {
+      return createWrapped(true);
+    },
+    update(value) {
+      assertStream(".update()");
+      const resolvePrevious = resolvable.resolve;
+      resolvable = createResolvablePromise();
+      updateValueStates(value);
+      currentPromise = resolvable.promise;
+      resolvePrevious(createWrapped());
+      warnUnclosedStream();
+      return streamable2;
+    },
+    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();
+      return streamable2;
+    },
+    error(error) {
+      assertStream(".error()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      closed = true;
+      currentError = error;
+      currentPromise = void 0;
+      resolvable.resolve({ error });
+      return streamable2;
+    },
+    done(...args) {
+      assertStream(".done()");
+      if (warningTimeout) {
+        clearTimeout(warningTimeout);
+      }
+      closed = true;
+      currentPromise = void 0;
+      if (args.length) {
+        updateValueStates(args[0]);
+        resolvable.resolve(createWrapped());
+        return streamable2;
+      }
+      resolvable.resolve({});
+      return streamable2;
+    }
   };
-  return AI;
+  return streamable2;
 }
 export {
   createAI,