ai 5.0.0-canary.2 → 5.0.0-canary.20

package/rsc/dist/rsc-server.mjs

@@ -1,2142 +0,0 @@
-// rsc/ai-state.tsx
-import * as jsondiffpatch from "jsondiffpatch";
-import { AsyncLocalStorage } from "async_hooks";
-
-// util/create-resolvable-promise.ts
-function createResolvablePromise() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return {
-    promise,
-    resolve,
-    reject
-  };
-}
-
-// util/is-function.ts
-var isFunction = (value) => typeof value === "function";
-
-// rsc/ai-state.tsx
-var asyncAIStateStorage = new AsyncLocalStorage();
-function getAIStateStoreOrThrow(message) {
-  const store = asyncAIStateStorage.getStore();
-  if (!store) {
-    throw new Error(message);
-  }
-  return store;
-}
-function withAIState({ state, options }, fn) {
-  return asyncAIStateStorage.run(
-    {
-      currentState: JSON.parse(JSON.stringify(state)),
-      // deep clone object
-      originalState: state,
-      sealed: false,
-      options
-    },
-    fn
-  );
-}
-function getAIStateDeltaPromise() {
-  const store = getAIStateStoreOrThrow("Internal error occurred.");
-  return store.mutationDeltaPromise;
-}
-function sealMutableAIState() {
-  const store = getAIStateStoreOrThrow("Internal error occurred.");
-  store.sealed = true;
-}
-function getAIState(...args) {
-  const store = getAIStateStoreOrThrow(
-    "`getAIState` must be called within an AI Action."
-  );
-  if (args.length > 0) {
-    const key = args[0];
-    if (typeof store.currentState !== "object") {
-      throw new Error(
-        `You can't get the "${String(
-          key
-        )}" field from the AI state because it's not an object.`
-      );
-    }
-    return store.currentState[key];
-  }
-  return store.currentState;
-}
-function getMutableAIState(...args) {
-  const store = getAIStateStoreOrThrow(
-    "`getMutableAIState` must be called within an AI Action."
-  );
-  if (store.sealed) {
-    throw new Error(
-      "`getMutableAIState` must be called before returning from an AI Action. Please move it to the top level of the Action's function body."
-    );
-  }
-  if (!store.mutationDeltaPromise) {
-    const { promise, resolve } = createResolvablePromise();
-    store.mutationDeltaPromise = promise;
-    store.mutationDeltaResolve = resolve;
-  }
-  function doUpdate(newState, done) {
-    var _a9, _b;
-    if (args.length > 0) {
-      if (typeof store.currentState !== "object") {
-        const key = args[0];
-        throw new Error(
-          `You can't modify the "${String(
-            key
-          )}" field of the AI state because it's not an object.`
-        );
-      }
-    }
-    if (isFunction(newState)) {
-      if (args.length > 0) {
-        store.currentState[args[0]] = newState(store.currentState[args[0]]);
-      } else {
-        store.currentState = newState(store.currentState);
-      }
-    } else {
-      if (args.length > 0) {
-        store.currentState[args[0]] = newState;
-      } else {
-        store.currentState = newState;
-      }
-    }
-    (_b = (_a9 = store.options).onSetAIState) == null ? void 0 : _b.call(_a9, {
-      key: args.length > 0 ? args[0] : void 0,
-      state: store.currentState,
-      done
-    });
-  }
-  const mutableState = {
-    get: () => {
-      if (args.length > 0) {
-        const key = args[0];
-        if (typeof store.currentState !== "object") {
-          throw new Error(
-            `You can't get the "${String(
-              key
-            )}" field from the AI state because it's not an object.`
-          );
-        }
-        return store.currentState[key];
-      }
-      return store.currentState;
-    },
-    update: function update(newAIState) {
-      doUpdate(newAIState, false);
-    },
-    done: function done(...doneArgs) {
-      if (doneArgs.length > 0) {
-        doUpdate(doneArgs[0], true);
-      }
-      const delta = jsondiffpatch.diff(store.originalState, store.currentState);
-      store.mutationDeltaResolve(delta);
-    }
-  };
-  return mutableState;
-}
-
-// 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];
-    }
-  );
-}
-function wrapAction(action, options) {
-  return innerAction.bind(null, { action, options });
-}
-function createAI({
-  actions,
-  initialAIState,
-  initialUIState,
-  onSetAIState,
-  onGetUIState
-}) {
-  const wrappedActions = {};
-  for (const name9 in actions) {
-    wrappedActions[name9] = wrapAction(actions[name9], {
-      onSetAIState
-    });
-  }
-  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
-  const AI = async (props) => {
-    var _a9, _b;
-    if ("useState" in React) {
-      throw new Error(
-        "This component can only be used inside Server Components."
-      );
-    }
-    let uiState = (_a9 = props.initialUIState) != null ? _a9 : 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;
-      }
-    }
-    return /* @__PURE__ */ jsx(
-      InternalAIProvider,
-      {
-        wrappedActions,
-        wrappedSyncUIState,
-        initialUIState: uiState,
-        initialAIState: aiState,
-        initialAIStatePatch: aiStateDelta,
-        children: props.children
-      }
-    );
-  };
-  return AI;
-}
-
-// rsc/stream-ui/stream-ui.tsx
-import { safeParseJSON } 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;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker);
-  }
-};
-_a = symbol;
-
-// util/download.ts
-async function download({ url }) {
-  var _a9;
-  const urlText = url.toString();
-  try {
-    const response = await fetch(urlText);
-    if (!response.ok) {
-      throw new DownloadError({
-        url: urlText,
-        statusCode: response.status,
-        statusText: response.statusText
-      });
-    }
-    return {
-      data: new Uint8Array(await response.arrayBuffer()),
-      mimeType: (_a9 = response.headers.get("content-type")) != null ? _a9 : 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",
-    bytesPrefix: [71, 73, 70],
-    base64Prefix: "R0lG"
-  },
-  {
-    mimeType: "image/png",
-    bytesPrefix: [137, 80, 78, 71],
-    base64Prefix: "iVBORw"
-  },
-  {
-    mimeType: "image/jpeg",
-    bytesPrefix: [255, 216],
-    base64Prefix: "/9j/"
-  },
-  {
-    mimeType: "image/webp",
-    bytesPrefix: [82, 73, 70, 70],
-    base64Prefix: "UklGRg"
-  },
-  {
-    mimeType: "image/bmp",
-    bytesPrefix: [66, 77],
-    base64Prefix: "Qk"
-  },
-  {
-    mimeType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0],
-    base64Prefix: "SUkqAA"
-  },
-  {
-    mimeType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42],
-    base64Prefix: "TU0AKg"
-  },
-  {
-    mimeType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      97,
-      118,
-      105,
-      102
-    ],
-    base64Prefix: "AAAAIGZ0eXBhdmlm"
-  },
-  {
-    mimeType: "image/heic",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      104,
-      101,
-      105,
-      99
-    ],
-    base64Prefix: "AAAAIGZ0eXBoZWlj"
-  }
-];
-function detectImageMimeType(image) {
-  for (const signature of mimeTypeSignatures) {
-    if (typeof image === "string" ? image.startsWith(signature.base64Prefix) : image.length >= signature.bytesPrefix.length && signature.bytesPrefix.every((byte, index) => image[index] === byte)) {
-      return signature.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);
-  }
-};
-_a2 = symbol2;
-
-// core/prompt/data-content.ts
-import { z } from "zod";
-var dataContentSchema = z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a9, _b;
-      return (_b = (_a9 = globalThis.Buffer) == null ? void 0 : _a9.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64(new Uint8Array(content));
-  }
-  return convertUint8ArrayToBase64(content);
-}
-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 });
-}
-function convertUint8ArrayToText(uint8Array) {
-  try {
-    return new TextDecoder().decode(uint8Array);
-  } catch (error) {
-    throw new Error("Error decoding Uint8Array to text");
-  }
-}
-
-// 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);
-  }
-};
-_a3 = symbol3;
-
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
-  try {
-    const [header, base64Content] = dataUrl.split(",");
-    return {
-      mimeType: header.split(";")[0].split(":")[1],
-      base64Content
-    };
-  } catch (error) {
-    return {
-      mimeType: void 0,
-      base64Content: void 0
-    };
-  }
-}
-
-// core/prompt/convert-to-language-model-prompt.ts
-async function convertToLanguageModelPrompt({
-  prompt,
-  modelSupportsImageUrls = true,
-  modelSupportsUrl = () => false,
-  downloadImplementation = download
-}) {
-  const downloadedAssets = await downloadAssets(
-    prompt.messages,
-    downloadImplementation,
-    modelSupportsImageUrls,
-    modelSupportsUrl
-  );
-  return [
-    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
-    ...prompt.messages.map(
-      (message) => convertToLanguageModelMessage(message, downloadedAssets)
-    )
-  ];
-}
-function convertToLanguageModelMessage(message, downloadedAssets) {
-  var _a9, _b, _c, _d, _e, _f;
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return {
-        role: "system",
-        content: message.content,
-        providerMetadata: (_a9 = message.providerOptions) != null ? _a9 : message.experimental_providerMetadata
-      };
-    }
-    case "user": {
-      if (typeof message.content === "string") {
-        return {
-          role: "user",
-          content: [{ type: "text", text: message.content }],
-          providerMetadata: (_b = message.providerOptions) != null ? _b : message.experimental_providerMetadata
-        };
-      }
-      return {
-        role: "user",
-        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
-        providerMetadata: (_c = message.providerOptions) != null ? _c : message.experimental_providerMetadata
-      };
-    }
-    case "assistant": {
-      if (typeof message.content === "string") {
-        return {
-          role: "assistant",
-          content: [{ type: "text", text: message.content }],
-          providerMetadata: (_d = message.providerOptions) != null ? _d : message.experimental_providerMetadata
-        };
-      }
-      return {
-        role: "assistant",
-        content: message.content.filter(
-          // remove empty text parts:
-          (part) => part.type !== "text" || part.text !== ""
-        ).map((part) => {
-          var _a10;
-          const providerOptions = (_a10 = part.providerOptions) != null ? _a10 : part.experimental_providerMetadata;
-          switch (part.type) {
-            case "file": {
-              return {
-                type: "file",
-                data: part.data instanceof URL ? part.data : convertDataContentToBase64String(part.data),
-                filename: part.filename,
-                mimeType: part.mimeType,
-                providerMetadata: providerOptions
-              };
-            }
-            case "reasoning": {
-              return {
-                type: "reasoning",
-                text: part.text,
-                signature: part.signature,
-                providerMetadata: providerOptions
-              };
-            }
-            case "redacted-reasoning": {
-              return {
-                type: "redacted-reasoning",
-                data: part.data,
-                providerMetadata: providerOptions
-              };
-            }
-            case "text": {
-              return {
-                type: "text",
-                text: part.text,
-                providerMetadata: providerOptions
-              };
-            }
-            case "tool-call": {
-              return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                args: part.args,
-                providerMetadata: providerOptions
-              };
-            }
-          }
-        }),
-        providerMetadata: (_e = message.providerOptions) != null ? _e : message.experimental_providerMetadata
-      };
-    }
-    case "tool": {
-      return {
-        role: "tool",
-        content: message.content.map((part) => {
-          var _a10;
-          return {
-            type: "tool-result",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            result: part.result,
-            content: part.experimental_content,
-            isError: part.isError,
-            providerMetadata: (_a10 = part.providerOptions) != null ? _a10 : part.experimental_providerMetadata
-          };
-        }),
-        providerMetadata: (_f = message.providerOptions) != null ? _f : message.experimental_providerMetadata
-      };
-    }
-    default: {
-      const _exhaustiveCheck = role;
-      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
-    }
-  }
-}
-async function downloadAssets(messages, downloadImplementation, modelSupportsImageUrls, modelSupportsUrl) {
-  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
-    (content) => Array.isArray(content)
-  ).flat().filter(
-    (part) => part.type === "image" || part.type === "file"
-  ).filter(
-    (part) => !(part.type === "image" && modelSupportsImageUrls === true)
-  ).map((part) => part.type === "image" ? part.image : part.data).map(
-    (part) => (
-      // support string urls:
-      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
-    )
-  ).filter((image) => image instanceof URL).filter((url) => !modelSupportsUrl(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])
-  );
-}
-function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a9, _b, _c, _d;
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text,
-      providerMetadata: (_a9 = part.providerOptions) != null ? _a9 : part.experimental_providerMetadata
-    };
-  }
-  let mimeType = part.mimeType;
-  let data;
-  let content;
-  let normalizedData;
-  const type = part.type;
-  switch (type) {
-    case "image":
-      data = part.image;
-      break;
-    case "file":
-      data = part.data;
-      break;
-    default:
-      throw new Error(`Unsupported part type: ${type}`);
-  }
-  try {
-    content = typeof data === "string" ? new URL(data) : data;
-  } catch (error) {
-    content = data;
-  }
-  if (content instanceof URL) {
-    if (content.protocol === "data:") {
-      const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl(
-        content.toString()
-      );
-      if (dataUrlMimeType == null || base64Content == null) {
-        throw new Error(`Invalid data URL format in part ${type}`);
-      }
-      mimeType = dataUrlMimeType;
-      normalizedData = convertDataContentToUint8Array(base64Content);
-    } else {
-      const downloadedFile = downloadedAssets[content.toString()];
-      if (downloadedFile) {
-        normalizedData = downloadedFile.data;
-        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType;
-      } else {
-        normalizedData = content;
-      }
-    }
-  } else {
-    normalizedData = convertDataContentToUint8Array(content);
-  }
-  switch (type) {
-    case "image": {
-      if (normalizedData instanceof Uint8Array) {
-        mimeType = (_b = detectImageMimeType(normalizedData)) != null ? _b : mimeType;
-      }
-      return {
-        type: "image",
-        image: normalizedData,
-        mimeType,
-        providerMetadata: (_c = part.providerOptions) != null ? _c : part.experimental_providerMetadata
-      };
-    }
-    case "file": {
-      if (mimeType == null) {
-        throw new Error(`Mime type is missing for file part`);
-      }
-      return {
-        type: "file",
-        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
-        filename: part.filename,
-        mimeType,
-        providerMetadata: (_d = part.providerOptions) != null ? _d : part.experimental_providerMetadata
-      };
-    }
-  }
-}
-
-// 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({
-    parameter,
-    value,
-    message
-  }) {
-    super({
-      name: name4,
-      message: `Invalid argument for parameter ${parameter}: ${message}`
-    });
-    this[_a4] = true;
-    this.parameter = parameter;
-    this.value = value;
-  }
-  static isInstance(error) {
-    return AISDKError4.hasMarker(error, marker4);
-  }
-};
-_a4 = symbol4;
-
-// core/prompt/prepare-call-settings.ts
-function prepareCallSettings({
-  maxTokens,
-  temperature,
-  topP,
-  topK,
-  presencePenalty,
-  frequencyPenalty,
-  stopSequences,
-  seed
-}) {
-  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 (topK != null) {
-    if (typeof topK !== "number") {
-      throw new InvalidArgumentError({
-        parameter: "topK",
-        value: topK,
-        message: "topK 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"
-      });
-    }
-  }
-  return {
-    maxTokens,
-    // TODO v5 remove default 0 for temperature
-    temperature: temperature != null ? temperature : 0,
-    topP,
-    topK,
-    presencePenalty,
-    frequencyPenalty,
-    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
-    seed
-  };
-}
-
-// util/retry-with-exponential-backoff.ts
-import { APICallError } from "@ai-sdk/provider";
-import { delay, getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
-
-// util/retry-error.ts
-import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
-var name5 = "AI_RetryError";
-var marker5 = `vercel.ai.error.${name5}`;
-var symbol5 = Symbol.for(marker5);
-var _a5;
-var RetryError = class extends AISDKError5 {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super({ name: name5, message });
-    this[_a5] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isInstance(error) {
-    return AISDKError5.hasMarker(error, marker5);
-  }
-};
-_a5 = symbol5;
-
-// 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.isInstance(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
-    });
-  }
-}
-
-// core/prompt/prepare-retries.ts
-function prepareRetries({
-  maxRetries
-}) {
-  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"
-      });
-    }
-  }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
-  return {
-    maxRetries: maxRetriesResult,
-    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
-  };
-}
-
-// 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,
-  activeTools
-}) {
-  if (!isNonEmptyObject(tools)) {
-    return {
-      tools: void 0,
-      toolChoice: void 0
-    };
-  }
-  const filteredTools = activeTools != null ? Object.entries(tools).filter(
-    ([name9]) => activeTools.includes(name9)
-  ) : Object.entries(tools);
-  return {
-    tools: filteredTools.map(([name9, tool]) => {
-      const toolType = tool.type;
-      switch (toolType) {
-        case void 0:
-        case "function":
-          return {
-            type: "function",
-            name: name9,
-            description: tool.description,
-            parameters: asSchema(tool.parameters).jsonSchema
-          };
-        case "provider-defined":
-          return {
-            type: "provider-defined",
-            name: name9,
-            id: tool.id,
-            args: tool.args
-          };
-        default: {
-          const exhaustiveCheck = toolType;
-          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
-        }
-      }
-    }),
-    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
-  };
-}
-
-// core/prompt/standardize-prompt.ts
-import { InvalidPromptError } from "@ai-sdk/provider";
-import { safeValidateTypes } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod";
-
-// core/prompt/attachments-to-parts.ts
-function attachmentsToParts(attachments) {
-  var _a9, _b, _c;
-  const parts = [];
-  for (const attachment of attachments) {
-    let url;
-    try {
-      url = new URL(attachment.url);
-    } catch (error) {
-      throw new Error(`Invalid URL: ${attachment.url}`);
-    }
-    switch (url.protocol) {
-      case "http:":
-      case "https:": {
-        if ((_a9 = attachment.contentType) == null ? void 0 : _a9.startsWith("image/")) {
-          parts.push({ type: "image", image: url });
-        } else {
-          if (!attachment.contentType) {
-            throw new Error(
-              "If the attachment is not an image, it must specify a content type"
-            );
-          }
-          parts.push({
-            type: "file",
-            data: url,
-            mimeType: attachment.contentType
-          });
-        }
-        break;
-      }
-      case "data:": {
-        let header;
-        let base64Content;
-        let mimeType;
-        try {
-          [header, base64Content] = attachment.url.split(",");
-          mimeType = header.split(";")[0].split(":")[1];
-        } catch (error) {
-          throw new Error(`Error processing data URL: ${attachment.url}`);
-        }
-        if (mimeType == null || base64Content == null) {
-          throw new Error(`Invalid data URL format: ${attachment.url}`);
-        }
-        if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) {
-          parts.push({
-            type: "image",
-            image: convertDataContentToUint8Array(base64Content)
-          });
-        } else if ((_c = attachment.contentType) == null ? void 0 : _c.startsWith("text/")) {
-          parts.push({
-            type: "text",
-            text: convertUint8ArrayToText(
-              convertDataContentToUint8Array(base64Content)
-            )
-          });
-        } else {
-          if (!attachment.contentType) {
-            throw new Error(
-              "If the attachment is not an image or text, it must specify a content type"
-            );
-          }
-          parts.push({
-            type: "file",
-            data: base64Content,
-            mimeType: attachment.contentType
-          });
-        }
-        break;
-      }
-      default: {
-        throw new Error(`Unsupported URL protocol: ${url.protocol}`);
-      }
-    }
-  }
-  return parts;
-}
-
-// core/prompt/message-conversion-error.ts
-import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
-var name6 = "AI_MessageConversionError";
-var marker6 = `vercel.ai.error.${name6}`;
-var symbol6 = Symbol.for(marker6);
-var _a6;
-var MessageConversionError = class extends AISDKError6 {
-  constructor({
-    originalMessage,
-    message
-  }) {
-    super({ name: name6, message });
-    this[_a6] = true;
-    this.originalMessage = originalMessage;
-  }
-  static isInstance(error) {
-    return AISDKError6.hasMarker(error, marker6);
-  }
-};
-_a6 = symbol6;
-
-// core/prompt/convert-to-core-messages.ts
-function convertToCoreMessages(messages, options) {
-  var _a9, _b;
-  const tools = (_a9 = options == null ? void 0 : options.tools) != null ? _a9 : {};
-  const coreMessages = [];
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    const isLastMessage = i === messages.length - 1;
-    const { role, content, experimental_attachments } = message;
-    switch (role) {
-      case "system": {
-        coreMessages.push({
-          role: "system",
-          content
-        });
-        break;
-      }
-      case "user": {
-        if (message.parts == null) {
-          coreMessages.push({
-            role: "user",
-            content: experimental_attachments ? [
-              { type: "text", text: content },
-              ...attachmentsToParts(experimental_attachments)
-            ] : content
-          });
-        } else {
-          const textParts = message.parts.filter((part) => part.type === "text").map((part) => ({
-            type: "text",
-            text: part.text
-          }));
-          coreMessages.push({
-            role: "user",
-            content: experimental_attachments ? [...textParts, ...attachmentsToParts(experimental_attachments)] : textParts
-          });
-        }
-        break;
-      }
-      case "assistant": {
-        if (message.parts != null) {
-          let processBlock2 = function() {
-            const content2 = [];
-            for (const part of block) {
-              switch (part.type) {
-                case "file":
-                case "text": {
-                  content2.push(part);
-                  break;
-                }
-                case "reasoning": {
-                  for (const detail of part.details) {
-                    switch (detail.type) {
-                      case "text":
-                        content2.push({
-                          type: "reasoning",
-                          text: detail.text,
-                          signature: detail.signature
-                        });
-                        break;
-                      case "redacted":
-                        content2.push({
-                          type: "redacted-reasoning",
-                          data: detail.data
-                        });
-                        break;
-                    }
-                  }
-                  break;
-                }
-                case "tool-invocation":
-                  content2.push({
-                    type: "tool-call",
-                    toolCallId: part.toolInvocation.toolCallId,
-                    toolName: part.toolInvocation.toolName,
-                    args: part.toolInvocation.args
-                  });
-                  break;
-                default: {
-                  const _exhaustiveCheck = part;
-                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
-                }
-              }
-            }
-            coreMessages.push({
-              role: "assistant",
-              content: content2
-            });
-            const stepInvocations = block.filter(
-              (part) => part.type === "tool-invocation"
-            ).map((part) => part.toolInvocation);
-            if (stepInvocations.length > 0) {
-              coreMessages.push({
-                role: "tool",
-                content: stepInvocations.map(
-                  (toolInvocation) => {
-                    if (!("result" in toolInvocation)) {
-                      throw new MessageConversionError({
-                        originalMessage: message,
-                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                      });
-                    }
-                    const { toolCallId, toolName, result } = toolInvocation;
-                    const tool = tools[toolName];
-                    return (tool == null ? void 0 : tool.experimental_toToolResultContent) != null ? {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result: tool.experimental_toToolResultContent(result),
-                      experimental_content: tool.experimental_toToolResultContent(result)
-                    } : {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result
-                    };
-                  }
-                )
-              });
-            }
-            block = [];
-            blockHasToolInvocations = false;
-            currentStep++;
-          };
-          var processBlock = processBlock2;
-          let currentStep = 0;
-          let blockHasToolInvocations = false;
-          let block = [];
-          for (const part of message.parts) {
-            switch (part.type) {
-              case "text": {
-                if (blockHasToolInvocations) {
-                  processBlock2();
-                }
-                block.push(part);
-                break;
-              }
-              case "file":
-              case "reasoning": {
-                block.push(part);
-                break;
-              }
-              case "tool-invocation": {
-                if (((_b = part.toolInvocation.step) != null ? _b : 0) !== currentStep) {
-                  processBlock2();
-                }
-                block.push(part);
-                blockHasToolInvocations = true;
-                break;
-              }
-            }
-          }
-          processBlock2();
-          break;
-        }
-        const toolInvocations = message.toolInvocations;
-        if (toolInvocations == null || toolInvocations.length === 0) {
-          coreMessages.push({ role: "assistant", content });
-          break;
-        }
-        const maxStep = toolInvocations.reduce((max, toolInvocation) => {
-          var _a10;
-          return Math.max(max, (_a10 = toolInvocation.step) != null ? _a10 : 0);
-        }, 0);
-        for (let i2 = 0; i2 <= maxStep; i2++) {
-          const stepInvocations = toolInvocations.filter(
-            (toolInvocation) => {
-              var _a10;
-              return ((_a10 = toolInvocation.step) != null ? _a10 : 0) === i2;
-            }
-          );
-          if (stepInvocations.length === 0) {
-            continue;
-          }
-          coreMessages.push({
-            role: "assistant",
-            content: [
-              ...isLastMessage && content && i2 === 0 ? [{ type: "text", text: content }] : [],
-              ...stepInvocations.map(
-                ({ toolCallId, toolName, args }) => ({
-                  type: "tool-call",
-                  toolCallId,
-                  toolName,
-                  args
-                })
-              )
-            ]
-          });
-          coreMessages.push({
-            role: "tool",
-            content: stepInvocations.map((toolInvocation) => {
-              if (!("result" in toolInvocation)) {
-                throw new MessageConversionError({
-                  originalMessage: message,
-                  message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                });
-              }
-              const { toolCallId, toolName, result } = toolInvocation;
-              const tool = tools[toolName];
-              return (tool == null ? void 0 : tool.experimental_toToolResultContent) != null ? {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result: tool.experimental_toToolResultContent(result),
-                experimental_content: tool.experimental_toToolResultContent(result)
-              } : {
-                type: "tool-result",
-                toolCallId,
-                toolName,
-                result
-              };
-            })
-          });
-        }
-        if (content && !isLastMessage) {
-          coreMessages.push({ role: "assistant", content });
-        }
-        break;
-      }
-      case "data": {
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new MessageConversionError({
-          originalMessage: message,
-          message: `Unsupported role: ${_exhaustiveCheck}`
-        });
-      }
-    }
-  }
-  return coreMessages;
-}
-
-// core/prompt/detect-prompt-type.ts
-function detectPromptType(prompt) {
-  if (!Array.isArray(prompt)) {
-    return "other";
-  }
-  if (prompt.length === 0) {
-    return "messages";
-  }
-  const characteristics = prompt.map(detectSingleMessageCharacteristics);
-  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
-    return "ui-messages";
-  } else if (characteristics.every(
-    (c) => c === "has-core-specific-parts" || c === "message"
-  )) {
-    return "messages";
-  } else {
-    return "other";
-  }
-}
-function detectSingleMessageCharacteristics(message) {
-  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
-  message.role === "data" || // UI-only role
-  "toolInvocations" in message || // UI-specific field
-  "parts" in message || // UI-specific field
-  "experimental_attachments" in message)) {
-    return "has-ui-specific-parts";
-  } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
-  "experimental_providerMetadata" in message || "providerOptions" in message)) {
-    return "has-core-specific-parts";
-  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
-    return "message";
-  } else {
-    return "other";
-  }
-}
-
-// core/prompt/message.ts
-import { z as z6 } from "zod";
-
-// core/types/provider-metadata.ts
-import { z as z3 } from "zod";
-
-// core/types/json-value.ts
-import { z as z2 } from "zod";
-var jsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.null(),
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.record(z2.string(), jsonValueSchema),
-    z2.array(jsonValueSchema)
-  ])
-);
-
-// core/types/provider-metadata.ts
-var providerMetadataSchema = z3.record(
-  z3.string(),
-  z3.record(z3.string(), jsonValueSchema)
-);
-
-// core/prompt/content-part.ts
-import { z as z5 } from "zod";
-
-// core/prompt/tool-result-content.ts
-import { z as z4 } from "zod";
-var toolResultContentSchema = z4.array(
-  z4.union([
-    z4.object({ type: z4.literal("text"), text: z4.string() }),
-    z4.object({
-      type: z4.literal("image"),
-      data: z4.string(),
-      mimeType: z4.string().optional()
-    })
-  ])
-);
-
-// core/prompt/content-part.ts
-var textPartSchema = z5.object({
-  type: z5.literal("text"),
-  text: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var imagePartSchema = z5.object({
-  type: z5.literal("image"),
-  image: z5.union([dataContentSchema, z5.instanceof(URL)]),
-  mimeType: z5.string().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var filePartSchema = z5.object({
-  type: z5.literal("file"),
-  data: z5.union([dataContentSchema, z5.instanceof(URL)]),
-  filename: z5.string().optional(),
-  mimeType: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = z5.object({
-  type: z5.literal("reasoning"),
-  text: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var redactedReasoningPartSchema = z5.object({
-  type: z5.literal("redacted-reasoning"),
-  data: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = z5.object({
-  type: z5.literal("tool-call"),
-  toolCallId: z5.string(),
-  toolName: z5.string(),
-  args: z5.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var toolResultPartSchema = z5.object({
-  type: z5.literal("tool-result"),
-  toolCallId: z5.string(),
-  toolName: z5.string(),
-  result: z5.unknown(),
-  content: toolResultContentSchema.optional(),
-  isError: z5.boolean().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-
-// core/prompt/message.ts
-var coreSystemMessageSchema = z6.object({
-  role: z6.literal("system"),
-  content: z6.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreUserMessageSchema = z6.object({
-  role: z6.literal("user"),
-  content: z6.union([
-    z6.string(),
-    z6.array(z6.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreAssistantMessageSchema = z6.object({
-  role: z6.literal("assistant"),
-  content: z6.union([
-    z6.string(),
-    z6.array(
-      z6.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        redactedReasoningPartSchema,
-        toolCallPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreToolMessageSchema = z6.object({
-  role: z6.literal("tool"),
-  content: z6.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
-});
-var coreMessageSchema = z6.union([
-  coreSystemMessageSchema,
-  coreUserMessageSchema,
-  coreAssistantMessageSchema,
-  coreToolMessageSchema
-]);
-
-// core/prompt/standardize-prompt.ts
-function standardizePrompt({
-  prompt,
-  tools
-}) {
-  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.system != null && typeof prompt.system !== "string") {
-    throw new InvalidPromptError({
-      prompt,
-      message: "system must be a string"
-    });
-  }
-  if (prompt.prompt != null) {
-    if (typeof prompt.prompt !== "string") {
-      throw new InvalidPromptError({
-        prompt,
-        message: "prompt must be a string"
-      });
-    }
-    return {
-      type: "prompt",
-      system: prompt.system,
-      messages: [
-        {
-          role: "user",
-          content: prompt.prompt
-        }
-      ]
-    };
-  }
-  if (prompt.messages != null) {
-    const promptType = detectPromptType(prompt.messages);
-    if (promptType === "other") {
-      throw new InvalidPromptError({
-        prompt,
-        message: "messages must be an array of CoreMessage or UIMessage"
-      });
-    }
-    const messages = promptType === "ui-messages" ? convertToCoreMessages(prompt.messages, {
-      tools
-    }) : prompt.messages;
-    if (messages.length === 0) {
-      throw new InvalidPromptError({
-        prompt,
-        message: "messages must not be empty"
-      });
-    }
-    const validationResult = safeValidateTypes({
-      value: messages,
-      schema: z7.array(coreMessageSchema)
-    });
-    if (!validationResult.success) {
-      throw new InvalidPromptError({
-        prompt,
-        message: "messages must be an array of CoreMessage or UIMessage",
-        cause: validationResult.error
-      });
-    }
-    return {
-      type: "messages",
-      messages,
-      system: prompt.system
-    };
-  }
-  throw new Error("unreachable");
-}
-
-// core/types/usage.ts
-function calculateLanguageModelUsage({
-  promptTokens,
-  completionTokens
-}) {
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens
-  };
-}
-
-// errors/invalid-tool-arguments-error.ts
-import { AISDKError as AISDKError7, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
-var name7 = "AI_InvalidToolArgumentsError";
-var marker7 = `vercel.ai.error.${name7}`;
-var symbol7 = Symbol.for(marker7);
-var _a7;
-var InvalidToolArgumentsError = class extends AISDKError7 {
-  constructor({
-    toolArgs,
-    toolName,
-    cause,
-    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage2(
-      cause
-    )}`
-  }) {
-    super({ name: name7, message, cause });
-    this[_a7] = true;
-    this.toolArgs = toolArgs;
-    this.toolName = toolName;
-  }
-  static isInstance(error) {
-    return AISDKError7.hasMarker(error, marker7);
-  }
-};
-_a7 = symbol7;
-
-// errors/no-such-tool-error.ts
-import { AISDKError as AISDKError8 } from "@ai-sdk/provider";
-var name8 = "AI_NoSuchToolError";
-var marker8 = `vercel.ai.error.${name8}`;
-var symbol8 = Symbol.for(marker8);
-var _a8;
-var NoSuchToolError = class extends AISDKError8 {
-  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: name8, message });
-    this[_a8] = true;
-    this.toolName = toolName;
-    this.availableTools = availableTools;
-  }
-  static isInstance(error) {
-    return AISDKError8.hasMarker(error, marker8);
-  }
-};
-_a8 = symbol8;
-
-// 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;
-}
-
-// 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 (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 {
-    row: /* @__PURE__ */ jsx2(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx2(R, { c: initialValue, n: promise }) }),
-    resolve,
-    reject
-  };
-}
-
-// 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 streamable = {
-    value: row,
-    update(value) {
-      assertStream(".update()");
-      if (value === currentValue) {
-        warnUnclosedStream();
-        return streamable;
-      }
-      const resolvable = createResolvablePromise();
-      currentValue = value;
-      resolve({ value: currentValue, done: false, next: resolvable.promise });
-      resolve = resolvable.resolve;
-      reject = resolvable.reject;
-      warnUnclosedStream();
-      return streamable;
-    },
-    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 streamable;
-    },
-    error(error) {
-      assertStream(".error()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      reject(error);
-      return streamable;
-    },
-    done(...args) {
-      assertStream(".done()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      if (args.length) {
-        resolve({ value: args[0], done: true });
-        return streamable;
-      }
-      resolve({ value: currentValue, done: true });
-      return streamable;
-    }
-  };
-  return streamable;
-}
-
-// rsc/stream-ui/stream-ui.tsx
-var defaultTextRenderer = ({ content }) => content;
-async function streamUI({
-  model,
-  tools,
-  toolChoice,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  headers,
-  initial,
-  text,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
-  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 [name9, 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: " + name9
-        );
-      }
-    }
-  }
-  const ui = createStreamableUI(initial);
-  const textRender = text || defaultTextRenderer;
-  let finished;
-  let finishEvent = null;
-  async function render({
-    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 } = prepareRetries({ maxRetries });
-  const validatedPrompt = standardizePrompt({
-    prompt: { system, prompt, messages },
-    tools: void 0
-    // streamUI tools don't support multi-modal tool result conversion
-  });
-  const result = await retry(
-    async () => {
-      var _a9;
-      return model.doStream({
-        mode: {
-          type: "regular",
-          ...prepareToolsAndToolChoice({
-            tools,
-            toolChoice,
-            activeTools: void 0
-          })
-        },
-        ...prepareCallSettings(settings),
-        inputFormat: validatedPrompt.type,
-        prompt: await convertToLanguageModelPrompt({
-          prompt: validatedPrompt,
-          modelSupportsImageUrls: model.supportsImageUrls,
-          modelSupportsUrl: (_a9 = model.supportsUrl) == null ? void 0 : _a9.bind(model)
-          // support 'this' context
-        }),
-        providerMetadata: providerOptions,
-        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;
-            render({
-              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
-              });
-            }
-            render({
-              renderer: tool.generate,
-              args: [
-                parseResult.value,
-                {
-                  toolName,
-                  toolCallId: value.toolCallId
-                }
-              ],
-              streamableUI: ui,
-              isLastCall: true
-            });
-            break;
-          }
-          case "error": {
-            throw value.error;
-          }
-          case "finish": {
-            finishEvent = {
-              finishReason: value.finishReason,
-              usage: calculateLanguageModelUsage(value.usage),
-              warnings: result.warnings,
-              rawResponse: result.rawResponse
-            };
-            break;
-          }
-        }
-      }
-      if (!hasToolCall) {
-        render({
-          renderer: textRender,
-          args: [{ content, done: true }],
-          streamableUI: ui,
-          isLastCall: true
-        });
-      }
-      await finished;
-      if (finishEvent && onFinish) {
-        await onFinish({
-          ...finishEvent,
-          value: ui.value
-        });
-      }
-    } catch (error) {
-      ui.error(error);
-    }
-  })();
-  return {
-    ...result,
-    stream,
-    value: ui.value
-  };
-}
-
-// 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);
-    }
-  })();
-  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() {
-    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);
-    }
-  }
-  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 streamable = {
-    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 streamable;
-    },
-    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 streamable;
-    },
-    error(error) {
-      assertStream(".error()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      currentError = error;
-      currentPromise = void 0;
-      resolvable.resolve({ error });
-      return streamable;
-    },
-    done(...args) {
-      assertStream(".done()");
-      if (warningTimeout) {
-        clearTimeout(warningTimeout);
-      }
-      closed = true;
-      currentPromise = void 0;
-      if (args.length) {
-        updateValueStates(args[0]);
-        resolvable.resolve(createWrapped());
-        return streamable;
-      }
-      resolvable.resolve({});
-      return streamable;
-    }
-  };
-  return streamable;
-}
-export {
-  createAI,
-  createStreamableUI,
-  createStreamableValue,
-  getAIState,
-  getMutableAIState,
-  streamUI
-};
-//# sourceMappingURL=rsc-server.mjs.map