expxagents 0.28.0 → 0.28.2

package/node_modules/ai/rsc/dist/rsc-server.mjs

@@ -0,0 +1,2174 @@
+// 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-mimetype.ts
+import { convertBase64ToUint8Array } from "@ai-sdk/provider-utils";
+var imageMimeTypeSignatures = [
+  {
+    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"
+  }
+];
+var stripID3 = (data) => {
+  const bytes = typeof data === "string" ? convertBase64ToUint8Array(data) : data;
+  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
+  return bytes.slice(id3Size + 10);
+};
+function stripID3TagsIfPresent(data) {
+  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
+  data[1] === 68 && // 'D'
+  data[2] === 51;
+  return hasId3 ? stripID3(data) : data;
+}
+function detectMimeType({
+  data,
+  signatures
+}) {
+  const processedData = stripID3TagsIfPresent(data);
+  for (const signature of signatures) {
+    if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
+      (byte, index) => processedData[index] === byte
+    )) {
+      return signature.mimeType;
+    }
+  }
+  return void 0;
+}
+
+// core/prompt/data-content.ts
+import {
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  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 convertBase64ToUint8Array2(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 = detectMimeType({
+          data: normalizedData,
+          signatures: imageMimeTypeSignatures
+        })) != 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/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);
+    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: [
+          "message must be a CoreMessage or a UI message",
+          `Validation error: ${validationResult.error.message}`
+        ].join("\n"),
+        cause: validationResult.error
+      });
+    }
+    return {
+      type: "messages",
+      messages,
+      system: prompt.system
+    };
+  }
+  throw new Error("unreachable");
+}
+function detectPromptType(prompt) {
+  if (!Array.isArray(prompt)) {
+    throw new InvalidPromptError({
+      prompt,
+      message: [
+        "messages must be an array of CoreMessage or UIMessage",
+        `Received non-array value: ${JSON.stringify(prompt)}`
+      ].join("\n"),
+      cause: prompt
+    });
+  }
+  if (prompt.length === 0) {
+    return "messages";
+  }
+  const characteristics = prompt.map(detectSingleMessageCharacteristics);
+  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
+    return "ui-messages";
+  }
+  const nonMessageIndex = characteristics.findIndex(
+    (c) => c !== "has-core-specific-parts" && c !== "message"
+  );
+  if (nonMessageIndex === -1) {
+    return "messages";
+  }
+  throw new InvalidPromptError({
+    prompt,
+    message: [
+      "messages must be an array of CoreMessage or UIMessage",
+      `Received message of type: "${characteristics[nonMessageIndex]}" at index ${nonMessageIndex}`,
+      `messages[${nonMessageIndex}]: ${JSON.stringify(prompt[nonMessageIndex])}`
+    ].join("\n"),
+    cause: prompt
+  });
+}
+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/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