@ensembleapp/client-sdk 0.0.55 → 0.0.57

package/dist/chunk-LQHHZ2OJ.js

@@ -0,0 +1,4177 @@
+// ../../node_modules/.pnpm/@ai-sdk+provider@3.0.13/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _b;
+var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name143,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name143;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker153) {
+    const markerSymbol = Symbol.for(marker153);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseHeaders,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super({ name, message, cause });
+    this[_a2] = true;
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseHeaders = responseHeaders;
+    this.responseBody = responseBody;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker2);
+  }
+};
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var _b3;
+var EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name2, message });
+    this[_a3] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker3);
+  }
+};
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var _b5;
+var InvalidPromptError = class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
+  constructor({
+    prompt,
+    message,
+    cause
+  }) {
+    super({ name: name4, message: `Invalid prompt: ${message}`, cause });
+    this[_a5] = true;
+    this.prompt = prompt;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker5);
+  }
+};
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var _b6;
+var InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
+  constructor({
+    data,
+    message = `Invalid response data: ${JSON.stringify(data)}.`
+  }) {
+    super({ name: name5, message });
+    this[_a6] = true;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker6);
+  }
+};
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var _b7;
+var JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
+  constructor({ text: text2, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text2}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text2;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+var _b9;
+var LoadSettingError = class extends (_b9 = AISDKError, _a9 = symbol9, _b9) {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name8, message });
+    this[_a9] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker9);
+  }
+};
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+var _b10;
+var NoContentGeneratedError = class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
+  // used in isInstance
+  constructor({
+    message = "No content generated."
+  } = {}) {
+    super({ name: name9, message });
+    this[_a10] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker10);
+  }
+};
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+var _b11;
+var NoSuchModelError = class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
+  constructor({
+    errorName = name10,
+    modelId,
+    modelType,
+    message = `No such ${modelType}: ${modelId}`
+  }) {
+    super({ name: errorName, message });
+    this[_a11] = true;
+    this.modelId = modelId;
+    this.modelType = modelType;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker11);
+  }
+};
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+var _b12;
+var TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+  constructor(options) {
+    super({
+      name: name11,
+      message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+    });
+    this[_a12] = true;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+    this.values = options.values;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker12);
+  }
+};
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _b13;
+var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
+  constructor({
+    value,
+    cause,
+    context
+  }) {
+    let contextPrefix = "Type validation failed";
+    if (context == null ? void 0 : context.field) {
+      contextPrefix += ` for ${context.field}`;
+    }
+    if ((context == null ? void 0 : context.entityName) || (context == null ? void 0 : context.entityId)) {
+      contextPrefix += " (";
+      const parts = [];
+      if (context.entityName) {
+        parts.push(context.entityName);
+      }
+      if (context.entityId) {
+        parts.push(`id: "${context.entityId}"`);
+      }
+      contextPrefix += parts.join(", ");
+      contextPrefix += ")";
+    }
+    super({
+      name: name12,
+      message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+    this.context = context;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @param {TypeValidationContext} params.context - Optional context about what is being validated.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause,
+    context
+  }) {
+    var _a153, _b152, _c;
+    if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a153 = cause.context) == null ? void 0 : _a153.field) === (context == null ? void 0 : context.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context == null ? void 0 : context.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context == null ? void 0 : context.entityId)) {
+      return cause;
+    }
+    return new _TypeValidationError({ value, cause, context });
+  }
+};
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@4.0.34_zod@4.4.3/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+import * as z4 from "zod/v4";
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod/v3";
+
+// ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// ../../node_modules/.pnpm/eventsource-parser@3.1.0/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            typeof onError == "function" && onError(error), (onError === "terminate" || error.type === "max-buffer-size-exceeded") && controller.error(error);
+          },
+          onRetry,
+          onComment,
+          maxBufferSize
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@4.0.34_zod@4.4.3/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var { btoa, atob } = globalThis;
+async function cancelResponseBody(response) {
+  var _a23;
+  try {
+    await ((_a23 = response.body) == null ? void 0 : _a23.cancel());
+  } catch (e) {
+  }
+}
+var name14 = "AI_DownloadError";
+var marker15 = `vercel.ai.error.${name14}`;
+var symbol15 = Symbol.for(marker15);
+var _a15;
+var _b15;
+var DownloadError = class extends (_b15 = AISDKError, _a15 = symbol15, _b15) {
+  constructor({
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+  }) {
+    super({ name: name14, message, cause });
+    this[_a15] = true;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker15);
+  }
+};
+function isBrowserRuntime(globalThisAny = globalThis) {
+  return globalThisAny.window != null;
+}
+function validateDownloadUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    throw new DownloadError({
+      url,
+      message: `Invalid URL: ${url}`
+    });
+  }
+  if (parsed.protocol === "data:") {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new DownloadError({
+      url,
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
+    });
+  }
+  const hostname = parsed.hostname.toLowerCase().replace(/\.+$/, "");
+  if (!hostname) {
+    throw new DownloadError({
+      url,
+      message: `URL must have a hostname`
+    });
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) {
+    throw new DownloadError({
+      url,
+      message: `URL with hostname ${hostname} is not allowed`
+    });
+  }
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    const ipv6 = hostname.slice(1, -1);
+    if (isPrivateIPv6(ipv6)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IPv6 address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+  if (isIPv4(hostname)) {
+    if (isPrivateIPv4(hostname)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IP address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+}
+function isIPv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    const num = Number(part);
+    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+  });
+}
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map(Number);
+  const [a, b, c] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 240) return true;
+  return false;
+}
+function parseIPv6(ip) {
+  let address = ip.toLowerCase();
+  const zoneIndex = address.indexOf("%");
+  if (zoneIndex !== -1) {
+    address = address.slice(0, zoneIndex);
+  }
+  const halves = address.split("::");
+  if (halves.length > 2) return null;
+  const toGroups = (segment) => {
+    if (segment === "") return [];
+    const groups = [];
+    const parts = segment.split(":");
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part.includes(".")) {
+        if (i !== parts.length - 1 || !isIPv4(part)) return null;
+        const [a, b, c, d] = part.split(".").map(Number);
+        groups.push(a << 8 | b, c << 8 | d);
+        continue;
+      }
+      if (!/^[0-9a-f]{1,4}$/.test(part)) return null;
+      groups.push(parseInt(part, 16));
+    }
+    return groups;
+  };
+  const head = toGroups(halves[0]);
+  if (head === null) return null;
+  if (halves.length === 2) {
+    const tail = toGroups(halves[1]);
+    if (tail === null) return null;
+    const fill = 8 - head.length - tail.length;
+    if (fill < 0) return null;
+    return [...head, ...new Array(fill).fill(0), ...tail];
+  }
+  return head.length === 8 ? head : null;
+}
+function isPrivateIPv6(ip) {
+  const groups = parseIPv6(ip);
+  if (groups === null) return true;
+  const topZero = (count) => groups.slice(0, count).every((group) => group === 0);
+  if (topZero(7) && (groups[7] === 0 || groups[7] === 1)) return true;
+  if ((groups[0] & 65024) === 64512) return true;
+  if ((groups[0] & 65472) === 65152) return true;
+  if ((groups[0] & 65472) === 65216) return true;
+  if ((groups[0] & 65280) === 65280) return true;
+  const embedsIPv4 = (
+    // ::/96 — IPv4-compatible (deprecated)
+    topZero(6) || // ::ffff:0:0/96 — IPv4-mapped (ffff in group 5)
+    topZero(5) && groups[5] === 65535 || // ::ffff:0:0/96 — IPv4-translated form (ffff in group 4, group 5 zero)
+    topZero(4) && groups[4] === 65535 && groups[5] === 0 || // 64:ff9b::/96 — NAT64 well-known prefix
+    groups[0] === 100 && groups[1] === 65435 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 0 || // 64:ff9b:1::/48 — NAT64 local-use prefix
+    groups[0] === 100 && groups[1] === 65435 && groups[2] === 1
+  );
+  if (embedsIPv4) {
+    const a = groups[6] >> 8 & 255;
+    const b = groups[6] & 255;
+    const c = groups[7] >> 8 & 255;
+    const d = groups[7] & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  return false;
+}
+var MAX_DOWNLOAD_REDIRECTS = 10;
+async function fetchWithValidatedRedirects({
+  url,
+  headers,
+  abortSignal,
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS
+}) {
+  const baseInit = { signal: abortSignal };
+  if (headers !== void 0) {
+    baseInit.headers = headers;
+  }
+  let currentUrl = url;
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+    validateDownloadUrl(currentUrl);
+    const response = await fetch(currentUrl, {
+      ...baseInit,
+      redirect: "manual"
+    });
+    if (response.type === "opaqueredirect") {
+      if (!isBrowserRuntime()) {
+        throw new DownloadError({
+          url,
+          message: `Redirect from ${currentUrl} could not be validated and was blocked`
+        });
+      }
+      return await fetch(currentUrl, { ...baseInit, redirect: "follow" });
+    }
+    const location = response.headers.get("location");
+    if (response.status >= 300 && response.status < 400 && location) {
+      await cancelResponseBody(response);
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+    return response;
+  }
+  throw new DownloadError({
+    url,
+    message: `Too many redirects (max ${maxRedirects})`
+  });
+}
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    const length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url,
+        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+    }
+  }
+  const body = response.body;
+  if (body == null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.length;
+      if (totalBytes > maxBytes) {
+        throw new DownloadError({
+          url,
+          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+var createIdGenerator = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
+  var _a23, _b22, _c;
+  if (globalThisAny.window) {
+    return `runtime/browser`;
+  }
+  if ((_a23 = globalThisAny.navigator) == null ? void 0 : _a23.userAgent) {
+    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
+  }
+  if ((_c = (_b22 = globalThisAny.process) == null ? void 0 : _b22.versions) == null ? void 0 : _c.node) {
+    return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
+  }
+  if (globalThisAny.EdgeRuntime) {
+    return `runtime/vercel-edge`;
+  }
+  return "runtime/unknown";
+}
+function normalizeHeaders(headers) {
+  if (headers == null) {
+    return {};
+  }
+  const normalized = {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      normalized[key.toLowerCase()] = value;
+    });
+  } else {
+    if (!Array.isArray(headers)) {
+      headers = Object.entries(headers);
+    }
+    for (const [key, value] of headers) {
+      if (value != null) {
+        normalized[key.toLowerCase()] = value;
+      }
+    }
+  }
+  return normalized;
+}
+function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
+  const normalizedHeaders = new Headers(normalizeHeaders(headers));
+  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+  normalizedHeaders.set(
+    "user-agent",
+    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
+  );
+  return Object.fromEntries(normalizedHeaders.entries());
+}
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+function _parse(text2) {
+  const obj = JSON.parse(text2);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text2) === false && suspectConstructorRx.test(text2) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse(text2) {
+  const { stackTraceLimit } = Error;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch (e) {
+    return _parse(text2);
+  }
+  try {
+    return _parse(text2);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
+  if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
+    jsonSchema2.additionalProperties = false;
+    const { properties } = jsonSchema2;
+    if (properties != null) {
+      for (const key of Object.keys(properties)) {
+        properties[key] = visit(properties[key]);
+      }
+    }
+  }
+  if (jsonSchema2.items != null) {
+    jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
+  }
+  if (jsonSchema2.anyOf != null) {
+    jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
+  }
+  if (jsonSchema2.allOf != null) {
+    jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
+  }
+  if (jsonSchema2.oneOf != null) {
+    jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
+  }
+  const { definitions } = jsonSchema2;
+  if (definitions != null) {
+    for (const key of Object.keys(definitions)) {
+      definitions[key] = visit(definitions[key]);
+    }
+  }
+  return jsonSchema2;
+}
+function visit(def) {
+  if (typeof def === "boolean") return def;
+  return addAdditionalPropertiesToJsonSchema(def);
+}
+var ignoreOverride = /* @__PURE__ */ Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+);
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+function parseAnyDef() {
+  return {};
+}
+function parseArrayDef(def, refs) {
+  var _a23, _b22, _c;
+  const res = {
+    type: "array"
+  };
+  if (((_a23 = def.type) == null ? void 0 : _a23._def) && ((_c = (_b22 = def.type) == null ? void 0 : _b22._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    res.minItems = def.minLength.value;
+  }
+  if (def.maxLength) {
+    res.maxItems = def.maxLength.value;
+  }
+  if (def.exactLength) {
+    res.minItems = def.exactLength.value;
+    res.maxItems = def.exactLength.value;
+  }
+  return res;
+}
+function parseBigintDef(def) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks) return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseBooleanDef() {
+  return { type: "boolean" };
+}
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def);
+  }
+}
+var integerDateParser = (def) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        res.minimum = check.value;
+        break;
+      case "max":
+        res.maximum = check.value;
+        break;
+    }
+  }
+  return res;
+};
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
+}
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string") return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
+}
+function parseLiteralDef(def) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp(
+        "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+        "u"
+      );
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          break;
+        case "max":
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(
+            res,
+            RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
+            check.message,
+            refs
+          );
+          break;
+        case "endsWith":
+          addPattern(
+            res,
+            RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
+            check.message,
+            refs
+          );
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "includes": {
+          addPattern(
+            res,
+            RegExp(escapeLiteralCheckValue(check.value, refs)),
+            check.message,
+            refs
+          );
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              res.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_) => {
+          })(check);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  var _a23;
+  if (schema.format || ((_a23 = schema.anyOf) == null ? void 0 : _a23.some((x) => x.format))) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format
+      });
+      delete schema.format;
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    schema.format = value;
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  var _a23;
+  if (schema.pattern || ((_a23 = schema.allOf) == null ? void 0 : _a23.some((x) => x.pattern))) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern
+      });
+      delete schema.pattern;
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  var _a23;
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    // Case-insensitive
+    m: regex.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && ((_a23 = source[i + 2]) == null ? void 0 : _a23.match(/[a-z]/))) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch (e) {
+    console.warn(
+      `Could not convert regex pattern at ${refs.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    );
+    return regex.source;
+  }
+  return pattern;
+}
+function parseRecordDef(def, refs) {
+  var _a23, _b22, _c, _d, _e, _f;
+  const schema = {
+    type: "object",
+    additionalProperties: (_a23 = parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    })) != null ? _a23 : refs.allowedAdditionalProperties
+  };
+  if (((_b22 = def.keyType) == null ? void 0 : _b22._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+    const { type, ...keyType } = parseBrandedDef(
+      def.keyType._def,
+      refs
+    );
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef();
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function parseNativeEnumDef(def) {
+  const object2 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object2[object2[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object2[key]);
+  const parsedTypes = Array.from(
+    new Set(actualValues.map((values) => typeof values))
+  );
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+function parseNeverDef() {
+  return { not: parseAnyDef() };
+}
+function parseNullDef() {
+  return {
+    type: "null"
+  };
+}
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every(
+    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
+  )) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce(
+      (acc, x) => {
+        const type = typeof x._def.value;
+        switch (type) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...acc, type];
+          case "bigint":
+            return [...acc, "integer"];
+          case "object":
+            if (x._def.value === null) return [...acc, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return acc;
+        }
+      },
+      []
+    );
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce(
+          (acc, x) => {
+            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+          },
+          []
+        )
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce(
+        (acc, x) => [
+          ...acc,
+          ...x._def.values.filter((x2) => !acc.includes(x2))
+        ],
+        []
+      )
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
+    (x, i) => parseDef(x._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "anyOf", `${i}`]
+    })
+  ).filter(
+    (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
+  );
+  return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    def.innerType._def.typeName
+  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks) return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        break;
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseObjectDef(def, refs) {
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    const propOptional = safeIsOptional(propDef);
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch (e) {
+    return true;
+  }
+}
+var parseOptionalDef = (def, refs) => {
+  var _a23;
+  if (refs.currentPath.toString() === ((_a23 = refs.propertyPath) == null ? void 0 : _a23.toString())) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
+};
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    schema.minItems = def.minSize.value;
+  }
+  if (def.maxSize) {
+    schema.maxItems = def.maxSize.value;
+  }
+  return schema;
+}
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      ),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      )
+    };
+  }
+}
+function parseUndefinedDef() {
+  return {
+    not: parseAnyDef()
+  };
+}
+function parseUnknownDef() {
+  return parseAnyDef();
+}
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind3.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNumber:
+      return parseNumberDef(def);
+    case ZodFirstPartyTypeKind3.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBigInt:
+      return parseBigintDef(def);
+    case ZodFirstPartyTypeKind3.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind3.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUndefined:
+      return parseUndefinedDef();
+    case ZodFirstPartyTypeKind3.ZodNull:
+      return parseNullDef();
+    case ZodFirstPartyTypeKind3.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUnion:
+    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLiteral:
+      return parseLiteralDef(def);
+    case ZodFirstPartyTypeKind3.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind3.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNaN:
+    case ZodFirstPartyTypeKind3.ZodNever:
+      return parseNeverDef();
+    case ZodFirstPartyTypeKind3.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodAny:
+      return parseAnyDef();
+    case ZodFirstPartyTypeKind3.ZodUnknown:
+      return parseUnknownDef();
+    case ZodFirstPartyTypeKind3.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodFunction:
+    case ZodFirstPartyTypeKind3.ZodVoid:
+    case ZodFirstPartyTypeKind3.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)(typeName);
+  }
+};
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i]) break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+function parseDef(def, refs, forceResolution = false) {
+  var _a23;
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = (_a23 = refs.override) == null ? void 0 : _a23.call(
+      refs,
+      def,
+      refs,
+      seenItem,
+      forceResolution
+    );
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema2) {
+    addMeta(def, refs, jsonSchema2);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
+    newItem.jsonSchema = jsonSchema2;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema2;
+  return jsonSchema2;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(
+          `Recursive reference detected at ${refs.currentPath.join(
+            "/"
+          )}! Defaulting to any`
+        );
+        return parseAnyDef();
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema2) => {
+  if (def.description) {
+    jsonSchema2.description = def.description;
+  }
+  return jsonSchema2;
+};
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(_options.definitions).map(([name23, def]) => [
+        def._def,
+        {
+          def: def._def,
+          path: [..._options.basePath, _options.definitionPath, name23],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+};
+var zod3ToJsonSchema = (schema, options) => {
+  var _a23;
+  const refs = getRefs(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
+    (acc, [name33, schema2]) => {
+      var _a33;
+      return {
+        ...acc,
+        [name33]: (_a33 = parseDef(
+          schema2._def,
+          {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name33]
+          },
+          true
+        )) != null ? _a33 : parseAnyDef()
+      };
+    },
+    {}
+  ) : void 0;
+  const name23 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
+  const main = (_a23 = parseDef(
+    schema._def,
+    name23 === void 0 ? refs : {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name23]
+    },
+    false
+  )) != null ? _a23 : parseAnyDef();
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  const combined = name23 === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name23
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name23]: main
+    }
+  };
+  combined.$schema = "http://json-schema.org/draft-07/schema#";
+  return combined;
+};
+var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+function lazySchema(createSchema) {
+  let schema;
+  return () => {
+    if (schema == null) {
+      schema = createSchema();
+    }
+    return schema;
+  };
+}
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    get jsonSchema() {
+      if (typeof jsonSchema2 === "function") {
+        jsonSchema2 = jsonSchema2();
+      }
+      return jsonSchema2;
+    },
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+}
+function standardSchema(standardSchema2) {
+  return jsonSchema(
+    () => addAdditionalPropertiesToJsonSchema(
+      standardSchema2["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
+    {
+      validate: async (value) => {
+        const result = await standardSchema2["~standard"].validate(value);
+        return "value" in result ? { success: true, value: result.value } : {
+          success: false,
+          error: new TypeValidationError({
+            value,
+            cause: result.issues
+          })
+        };
+      }
+    }
+  );
+}
+function zod3Schema(zodSchema2, options) {
+  var _a23;
+  const useReferences = (_a23 = options == null ? void 0 : options.useReferences) != null ? _a23 : false;
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => zod3ToJsonSchema(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none"
+    }),
+    {
+      validate: async (value) => {
+        const result = await zodSchema2.safeParseAsync(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function zod4Schema(zodSchema2, options) {
+  var _a23;
+  const useReferences = (_a23 = options == null ? void 0 : options.useReferences) != null ? _a23 : false;
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => addAdditionalPropertiesToJsonSchema(
+      z4.toJSONSchema(zodSchema2, {
+        target: "draft-7",
+        io: "input",
+        reused: useReferences ? "ref" : "inline"
+      })
+    ),
+    {
+      validate: async (value) => {
+        const result = await z4.safeParseAsync(zodSchema2, value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function isZod4Schema(zodSchema2) {
+  return "_zod" in zodSchema2;
+}
+function zodSchema(zodSchema2, options) {
+  if (isZod4Schema(zodSchema2)) {
+    return zod4Schema(zodSchema2, options);
+  } else {
+    return zod3Schema(zodSchema2, options);
+  }
+}
+async function safeValidateTypes({
+  value,
+  schema,
+  context
+}) {
+  const actualSchema = asSchema(schema);
+  try {
+    if (actualSchema.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await actualSchema.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error, context }),
+      rawValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error, context }),
+      rawValue: value
+    };
+  }
+}
+async function safeParseJSON({
+  text: text2,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text2);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    return await safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text: text2, cause: error }),
+      rawValue: void 0
+    };
+  }
+}
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
+}
+async function resolve(value) {
+  if (typeof value === "function") {
+    value = value();
+  }
+  return Promise.resolve(value);
+}
+var textDecoder = new TextDecoder();
+
+// ../../node_modules/.pnpm/ai@6.0.217_zod@4.4.3/node_modules/ai/dist/index.mjs
+import { z } from "zod/v4";
+import { z as z6 } from "zod/v4";
+import { z as z5 } from "zod/v4";
+import { z as z3 } from "zod/v4";
+import { z as z2 } from "zod/v4";
+import { z as z42 } from "zod/v4";
+import { z as z7 } from "zod/v4";
+import { z as z8 } from "zod/v4";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name222 in all)
+    __defProp(target, name222, { get: all[name222], enumerable: true });
+};
+var name15 = "AI_InvalidArgumentError";
+var marker16 = `vercel.ai.error.${name15}`;
+var symbol16 = Symbol.for(marker16);
+var _a16;
+_a16 = symbol16;
+var name22 = "AI_InvalidStreamPartError";
+var marker22 = `vercel.ai.error.${name22}`;
+var symbol22 = Symbol.for(marker22);
+var _a22;
+_a22 = symbol22;
+var name32 = "AI_InvalidToolApprovalError";
+var marker32 = `vercel.ai.error.${name32}`;
+var symbol32 = Symbol.for(marker32);
+var _a32;
+_a32 = symbol32;
+var name42 = "AI_InvalidToolApprovalSignatureError";
+var marker42 = `vercel.ai.error.${name42}`;
+var symbol42 = Symbol.for(marker42);
+var _a42;
+_a42 = symbol42;
+var name52 = "AI_InvalidToolInputError";
+var marker52 = `vercel.ai.error.${name52}`;
+var symbol52 = Symbol.for(marker52);
+var _a52;
+_a52 = symbol52;
+var name62 = "AI_ToolCallNotFoundForApprovalError";
+var marker62 = `vercel.ai.error.${name62}`;
+var symbol62 = Symbol.for(marker62);
+var _a62;
+_a62 = symbol62;
+var name72 = "AI_MissingToolResultsError";
+var marker72 = `vercel.ai.error.${name72}`;
+var symbol72 = Symbol.for(marker72);
+var _a72;
+_a72 = symbol72;
+var name82 = "AI_NoImageGeneratedError";
+var marker82 = `vercel.ai.error.${name82}`;
+var symbol82 = Symbol.for(marker82);
+var _a82;
+_a82 = symbol82;
+var name92 = "AI_NoObjectGeneratedError";
+var marker92 = `vercel.ai.error.${name92}`;
+var symbol92 = Symbol.for(marker92);
+var _a92;
+var NoObjectGeneratedError = class extends AISDKError {
+  constructor({
+    message = "No object generated.",
+    cause,
+    text: text2,
+    response,
+    usage,
+    finishReason
+  }) {
+    super({ name: name92, message, cause });
+    this[_a92] = true;
+    this.text = text2;
+    this.response = response;
+    this.usage = usage;
+    this.finishReason = finishReason;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker92);
+  }
+};
+_a92 = symbol92;
+var name102 = "AI_NoOutputGeneratedError";
+var marker102 = `vercel.ai.error.${name102}`;
+var symbol102 = Symbol.for(marker102);
+var _a102;
+_a102 = symbol102;
+var name112 = "AI_NoSpeechGeneratedError";
+var marker112 = `vercel.ai.error.${name112}`;
+var symbol112 = Symbol.for(marker112);
+var _a112;
+_a112 = symbol112;
+var name122 = "AI_NoTranscriptGeneratedError";
+var marker122 = `vercel.ai.error.${name122}`;
+var symbol122 = Symbol.for(marker122);
+var _a122;
+_a122 = symbol122;
+var name132 = "AI_NoVideoGeneratedError";
+var marker132 = `vercel.ai.error.${name132}`;
+var symbol132 = Symbol.for(marker132);
+var _a132;
+_a132 = symbol132;
+var name142 = "AI_NoSuchToolError";
+var marker142 = `vercel.ai.error.${name142}`;
+var symbol142 = Symbol.for(marker142);
+var _a142;
+_a142 = symbol142;
+var name152 = "AI_ToolCallRepairError";
+var marker152 = `vercel.ai.error.${name152}`;
+var symbol152 = Symbol.for(marker152);
+var _a152;
+_a152 = symbol152;
+var name16 = "AI_UIMessageStreamError";
+var marker162 = `vercel.ai.error.${name16}`;
+var symbol162 = Symbol.for(marker162);
+var _a162;
+_a162 = symbol162;
+var name17 = "AI_InvalidDataContentError";
+var marker17 = `vercel.ai.error.${name17}`;
+var symbol17 = Symbol.for(marker17);
+var _a17;
+_a17 = symbol17;
+var name18 = "AI_InvalidMessageRoleError";
+var marker18 = `vercel.ai.error.${name18}`;
+var symbol18 = Symbol.for(marker18);
+var _a18;
+_a18 = symbol18;
+var name19 = "AI_MessageConversionError";
+var marker19 = `vercel.ai.error.${name19}`;
+var symbol19 = Symbol.for(marker19);
+var _a19;
+_a19 = symbol19;
+var name20 = "AI_RetryError";
+var marker20 = `vercel.ai.error.${name20}`;
+var symbol20 = Symbol.for(marker20);
+var _a20;
+_a20 = symbol20;
+var VERSION = true ? "6.0.217" : "0.0.0-test";
+var download = async ({
+  url,
+  maxBytes,
+  abortSignal
+}) => {
+  var _a222;
+  const urlText = url.toString();
+  try {
+    const headers = withUserAgentSuffix(
+      {},
+      `ai-sdk/${VERSION}`,
+      getRuntimeEnvironmentUserAgent()
+    );
+    const response = await fetchWithValidatedRedirects({
+      url: urlText,
+      headers,
+      abortSignal
+    });
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data = await readResponseWithSizeLimit({
+      response,
+      url: urlText,
+      maxBytes: maxBytes != null ? maxBytes : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    return {
+      data,
+      mediaType: (_a222 = response.headers.get("content-type")) != null ? _a222 : void 0
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+};
+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 _a222, _b16;
+      return (_b16 = (_a222 = globalThis.Buffer) == null ? void 0 : _a222.isBuffer(value)) != null ? _b16 : false;
+    },
+    { message: "Must be a Buffer" }
+  )
+]);
+var jsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.null(),
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.record(z2.string(), jsonValueSchema.optional()),
+    z2.array(jsonValueSchema)
+  ])
+);
+var providerMetadataSchema = z3.record(
+  z3.string(),
+  z3.record(z3.string(), jsonValueSchema.optional())
+);
+var textPartSchema = z42.object({
+  type: z42.literal("text"),
+  text: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var imagePartSchema = z42.object({
+  type: z42.literal("image"),
+  image: z42.union([dataContentSchema, z42.instanceof(URL)]),
+  mediaType: z42.string().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var filePartSchema = z42.object({
+  type: z42.literal("file"),
+  data: z42.union([dataContentSchema, z42.instanceof(URL)]),
+  filename: z42.string().optional(),
+  mediaType: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningPartSchema = z42.object({
+  type: z42.literal("reasoning"),
+  text: z42.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = z42.object({
+  type: z42.literal("tool-call"),
+  toolCallId: z42.string(),
+  toolName: z42.string(),
+  input: z42.unknown(),
+  providerOptions: providerMetadataSchema.optional(),
+  providerExecuted: z42.boolean().optional()
+});
+var outputSchema = z42.discriminatedUnion(
+  "type",
+  [
+    z42.object({
+      type: z42.literal("text"),
+      value: z42.string(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z42.object({
+      type: z42.literal("json"),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z42.object({
+      type: z42.literal("execution-denied"),
+      reason: z42.string().optional(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z42.object({
+      type: z42.literal("error-text"),
+      value: z42.string(),
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z42.object({
+      type: z42.literal("error-json"),
+      value: jsonValueSchema,
+      providerOptions: providerMetadataSchema.optional()
+    }),
+    z42.object({
+      type: z42.literal("content"),
+      value: z42.array(
+        z42.union([
+          z42.object({
+            type: z42.literal("text"),
+            text: z42.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("media"),
+            data: z42.string(),
+            mediaType: z42.string()
+          }),
+          z42.object({
+            type: z42.literal("file-data"),
+            data: z42.string(),
+            mediaType: z42.string(),
+            filename: z42.string().optional(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("file-url"),
+            url: z42.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("file-id"),
+            fileId: z42.union([z42.string(), z42.record(z42.string(), z42.string())]),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("image-data"),
+            data: z42.string(),
+            mediaType: z42.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("image-url"),
+            url: z42.string(),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("image-file-id"),
+            fileId: z42.union([z42.string(), z42.record(z42.string(), z42.string())]),
+            providerOptions: providerMetadataSchema.optional()
+          }),
+          z42.object({
+            type: z42.literal("custom"),
+            providerOptions: providerMetadataSchema.optional()
+          })
+        ])
+      )
+    })
+  ]
+);
+var toolResultPartSchema = z42.object({
+  type: z42.literal("tool-result"),
+  toolCallId: z42.string(),
+  toolName: z42.string(),
+  output: outputSchema,
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolApprovalRequestSchema = z42.object({
+  type: z42.literal("tool-approval-request"),
+  approvalId: z42.string(),
+  toolCallId: z42.string()
+});
+var toolApprovalResponseSchema = z42.object({
+  type: z42.literal("tool-approval-response"),
+  approvalId: z42.string(),
+  approved: z42.boolean(),
+  reason: z42.string().optional()
+});
+var systemModelMessageSchema = z5.object(
+  {
+    role: z5.literal("system"),
+    content: z5.string(),
+    providerOptions: providerMetadataSchema.optional()
+  }
+);
+var userModelMessageSchema = z5.object({
+  role: z5.literal("user"),
+  content: z5.union([
+    z5.string(),
+    z5.array(z5.union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var assistantModelMessageSchema = z5.object({
+  role: z5.literal("assistant"),
+  content: z5.union([
+    z5.string(),
+    z5.array(
+      z5.union([
+        textPartSchema,
+        filePartSchema,
+        reasoningPartSchema,
+        toolCallPartSchema,
+        toolResultPartSchema,
+        toolApprovalRequestSchema
+      ])
+    )
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolModelMessageSchema = z5.object({
+  role: z5.literal("tool"),
+  content: z5.array(z5.union([toolResultPartSchema, toolApprovalResponseSchema])),
+  providerOptions: providerMetadataSchema.optional()
+});
+var modelMessageSchema = z5.union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema
+]);
+var encoder = new TextEncoder();
+var output_exports = {};
+__export(output_exports, {
+  array: () => array,
+  choice: () => choice,
+  json: () => json,
+  object: () => object,
+  text: () => text
+});
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  let unicodeEscapeDigits = 0;
+  function isHexDigit(char) {
+    return char >= "0" && char <= "9" || char >= "A" && char <= "F" || char >= "a" && char <= "f";
+  }
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        if (char === "u") {
+          unicodeEscapeDigits = 0;
+          stack.push("INSIDE_STRING_UNICODE_ESCAPE");
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+      case "INSIDE_STRING_UNICODE_ESCAPE": {
+        if (isHexDigit(char)) {
+          unicodeEscapeDigits++;
+          if (unicodeEscapeDigits === 4) {
+            stack.pop();
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+async function parsePartialJson(jsonText) {
+  if (jsonText === void 0) {
+    return { value: void 0, state: "undefined-input" };
+  }
+  let result = await safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = await safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+var text = () => ({
+  name: "text",
+  responseFormat: Promise.resolve({ type: "text" }),
+  async parseCompleteOutput({ text: text2 }) {
+    return text2;
+  },
+  async parsePartialOutput({ text: text2 }) {
+    return { partial: text2 };
+  },
+  createElementStreamTransform() {
+    return void 0;
+  }
+});
+var object = ({
+  schema: inputSchema,
+  name: name222,
+  description
+}) => {
+  const schema = asSchema(inputSchema);
+  return {
+    name: "object",
+    responseFormat: resolve(schema.jsonSchema).then((jsonSchema2) => ({
+      type: "json",
+      schema: jsonSchema2,
+      ...name222 != null && { name: name222 },
+      ...description != null && { description }
+    })),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const validationResult = await safeValidateTypes({
+        value: parseResult.value,
+        schema
+      });
+      if (!validationResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: validationResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return validationResult.value;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          return {
+            // Note: currently no validation of partial results:
+            partial: result.value
+          };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return void 0;
+    }
+  };
+};
+var array = ({
+  element: inputElementSchema,
+  name: name222,
+  description
+}) => {
+  const elementSchema = asSchema(inputElementSchema);
+  return {
+    name: "array",
+    // JSON schema that describes an array of elements:
+    responseFormat: resolve(elementSchema.jsonSchema).then((jsonSchema2) => {
+      const { $schema, ...itemSchema } = jsonSchema2;
+      return {
+        type: "json",
+        schema: {
+          $schema: "http://json-schema.org/draft-07/schema#",
+          type: "object",
+          properties: {
+            elements: { type: "array", items: itemSchema }
+          },
+          required: ["elements"],
+          additionalProperties: false
+        },
+        ...name222 != null && { name: name222 },
+        ...description != null && { description }
+      };
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: new TypeValidationError({
+            value: outerValue,
+            cause: "response must be an object with an elements array"
+          }),
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      for (const element of outerValue.elements) {
+        const validationResult = await safeValidateTypes({
+          value: element,
+          schema: elementSchema
+        });
+        if (!validationResult.success) {
+          throw new NoObjectGeneratedError({
+            message: "No object generated: response did not match schema.",
+            cause: validationResult.error,
+            text: text2,
+            response: context2.response,
+            usage: context2.usage,
+            finishReason: context2.finishReason
+          });
+        }
+      }
+      return outerValue.elements;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("elements" in outerValue) || !Array.isArray(outerValue.elements)) {
+            return void 0;
+          }
+          const rawElements = result.state === "repaired-parse" && outerValue.elements.length > 0 ? outerValue.elements.slice(0, -1) : outerValue.elements;
+          const parsedElements = [];
+          for (const rawElement of rawElements) {
+            const validationResult = await safeValidateTypes({
+              value: rawElement,
+              schema: elementSchema
+            });
+            if (validationResult.success) {
+              parsedElements.push(validationResult.value);
+            }
+          }
+          return { partial: parsedElements };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      let publishedElements = 0;
+      return new TransformStream({
+        transform({ partialOutput }, controller) {
+          if (partialOutput != null) {
+            for (; publishedElements < partialOutput.length; publishedElements++) {
+              controller.enqueue(partialOutput[publishedElements]);
+            }
+          }
+        }
+      });
+    }
+  };
+};
+var choice = ({
+  options: choiceOptions,
+  name: name222,
+  description
+}) => {
+  return {
+    name: "choice",
+    // JSON schema that describes an enumeration:
+    responseFormat: Promise.resolve({
+      type: "json",
+      schema: {
+        $schema: "http://json-schema.org/draft-07/schema#",
+        type: "object",
+        properties: {
+          result: { type: "string", enum: choiceOptions }
+        },
+        required: ["result"],
+        additionalProperties: false
+      },
+      ...name222 != null && { name: name222 },
+      ...description != null && { description }
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      const outerValue = parseResult.value;
+      if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string" || !choiceOptions.includes(outerValue.result)) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: response did not match schema.",
+          cause: new TypeValidationError({
+            value: outerValue,
+            cause: "response must be an object that contains a choice value."
+          }),
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return outerValue.result;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          const outerValue = result.value;
+          if (outerValue == null || typeof outerValue !== "object" || !("result" in outerValue) || typeof outerValue.result !== "string") {
+            return void 0;
+          }
+          const potentialMatches = choiceOptions.filter(
+            (choiceOption) => choiceOption.startsWith(outerValue.result)
+          );
+          if (result.state === "successful-parse") {
+            return potentialMatches.includes(outerValue.result) ? { partial: outerValue.result } : void 0;
+          } else {
+            return potentialMatches.length === 1 ? { partial: potentialMatches[0] } : void 0;
+          }
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return void 0;
+    }
+  };
+};
+var json = ({
+  name: name222,
+  description
+} = {}) => {
+  return {
+    name: "json",
+    responseFormat: Promise.resolve({
+      type: "json",
+      ...name222 != null && { name: name222 },
+      ...description != null && { description }
+    }),
+    async parseCompleteOutput({ text: text2 }, context2) {
+      const parseResult = await safeParseJSON({ text: text2 });
+      if (!parseResult.success) {
+        throw new NoObjectGeneratedError({
+          message: "No object generated: could not parse the response.",
+          cause: parseResult.error,
+          text: text2,
+          response: context2.response,
+          usage: context2.usage,
+          finishReason: context2.finishReason
+        });
+      }
+      return parseResult.value;
+    },
+    async parsePartialOutput({ text: text2 }) {
+      const result = await parsePartialJson(text2);
+      switch (result.state) {
+        case "failed-parse":
+        case "undefined-input": {
+          return void 0;
+        }
+        case "repaired-parse":
+        case "successful-parse": {
+          return result.value === void 0 ? void 0 : { partial: result.value };
+        }
+      }
+    },
+    createElementStreamTransform() {
+      return void 0;
+    }
+  };
+};
+var originalGenerateId = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var JsonToSseTransformStream = class extends TransformStream {
+  constructor() {
+    super({
+      transform(part, controller) {
+        controller.enqueue(`data: ${JSON.stringify(part)}
+
+`);
+      },
+      flush(controller) {
+        controller.enqueue("data: [DONE]\n\n");
+      }
+    });
+  }
+};
+var toolMetadataSchema = z7.record(
+  z7.string(),
+  jsonValueSchema.optional()
+);
+var uiMessageChunkSchema = lazySchema(
+  () => zodSchema(
+    z7.union([
+      z7.strictObject({
+        type: z7.literal("text-start"),
+        id: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("text-delta"),
+        id: z7.string(),
+        delta: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("text-end"),
+        id: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("error"),
+        errorText: z7.string()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-input-start"),
+        toolCallId: z7.string(),
+        toolName: z7.string(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        toolMetadata: toolMetadataSchema.optional(),
+        dynamic: z7.boolean().optional(),
+        title: z7.string().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-input-delta"),
+        toolCallId: z7.string(),
+        inputTextDelta: z7.string()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-input-available"),
+        toolCallId: z7.string(),
+        toolName: z7.string(),
+        input: z7.unknown(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        toolMetadata: toolMetadataSchema.optional(),
+        dynamic: z7.boolean().optional(),
+        title: z7.string().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-input-error"),
+        toolCallId: z7.string(),
+        toolName: z7.string(),
+        input: z7.unknown(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        toolMetadata: toolMetadataSchema.optional(),
+        dynamic: z7.boolean().optional(),
+        errorText: z7.string(),
+        title: z7.string().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-approval-request"),
+        approvalId: z7.string(),
+        toolCallId: z7.string(),
+        signature: z7.string().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-output-available"),
+        toolCallId: z7.string(),
+        output: z7.unknown(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        toolMetadata: toolMetadataSchema.optional(),
+        dynamic: z7.boolean().optional(),
+        preliminary: z7.boolean().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-output-error"),
+        toolCallId: z7.string(),
+        errorText: z7.string(),
+        providerExecuted: z7.boolean().optional(),
+        providerMetadata: providerMetadataSchema.optional(),
+        toolMetadata: toolMetadataSchema.optional(),
+        dynamic: z7.boolean().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("tool-output-denied"),
+        toolCallId: z7.string()
+      }),
+      z7.strictObject({
+        type: z7.literal("reasoning-start"),
+        id: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("reasoning-delta"),
+        id: z7.string(),
+        delta: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("reasoning-end"),
+        id: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("source-url"),
+        sourceId: z7.string(),
+        url: z7.string(),
+        title: z7.string().optional(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("source-document"),
+        sourceId: z7.string(),
+        mediaType: z7.string(),
+        title: z7.string(),
+        filename: z7.string().optional(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("file"),
+        url: z7.string(),
+        mediaType: z7.string(),
+        providerMetadata: providerMetadataSchema.optional()
+      }),
+      z7.strictObject({
+        type: z7.custom(
+          (value) => typeof value === "string" && value.startsWith("data-"),
+          { message: 'Type must start with "data-"' }
+        ),
+        id: z7.string().optional(),
+        data: z7.unknown(),
+        transient: z7.boolean().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("start-step")
+      }),
+      z7.strictObject({
+        type: z7.literal("finish-step")
+      }),
+      z7.strictObject({
+        type: z7.literal("start"),
+        messageId: z7.string().optional(),
+        messageMetadata: z7.unknown().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("finish"),
+        finishReason: z7.enum([
+          "stop",
+          "length",
+          "content-filter",
+          "tool-calls",
+          "error",
+          "other"
+        ]).optional(),
+        messageMetadata: z7.unknown().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("abort"),
+        reason: z7.string().optional()
+      }),
+      z7.strictObject({
+        type: z7.literal("message-metadata"),
+        messageMetadata: z7.unknown()
+      })
+    ])
+  )
+);
+function isStaticToolUIPart(part) {
+  return part.type.startsWith("tool-");
+}
+function isDynamicToolUIPart(part) {
+  return part.type === "dynamic-tool";
+}
+function isToolUIPart(part) {
+  return isStaticToolUIPart(part) || isDynamicToolUIPart(part);
+}
+var originalGenerateId2 = createIdGenerator({
+  prefix: "aitxt",
+  size: 24
+});
+var toolMetadataSchema2 = z8.record(
+  z8.string(),
+  jsonValueSchema.optional()
+);
+var uiMessagesSchema = lazySchema(
+  () => zodSchema(
+    z8.array(
+      z8.object({
+        id: z8.string(),
+        role: z8.enum(["system", "user", "assistant"]),
+        metadata: z8.unknown().optional(),
+        parts: z8.array(
+          z8.union([
+            z8.object({
+              type: z8.literal("text"),
+              text: z8.string(),
+              state: z8.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("reasoning"),
+              text: z8.string(),
+              state: z8.enum(["streaming", "done"]).optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("source-url"),
+              sourceId: z8.string(),
+              url: z8.string(),
+              title: z8.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("source-document"),
+              sourceId: z8.string(),
+              mediaType: z8.string(),
+              title: z8.string(),
+              filename: z8.string().optional(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("file"),
+              mediaType: z8.string(),
+              filename: z8.string().optional(),
+              url: z8.string(),
+              providerMetadata: providerMetadataSchema.optional()
+            }),
+            z8.object({
+              type: z8.literal("step-start")
+            }),
+            z8.object({
+              type: z8.string().startsWith("data-"),
+              id: z8.string().optional(),
+              data: z8.unknown()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("input-streaming"),
+              input: z8.unknown().optional(),
+              providerExecuted: z8.boolean().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("input-available"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("approval-requested"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.never().optional(),
+                reason: z8.never().optional(),
+                signature: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("approval-responded"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.boolean(),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-available"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.unknown(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              resultProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: z8.boolean().optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-error"),
+              input: z8.unknown().optional(),
+              rawInput: z8.unknown().optional(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              resultProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.literal("dynamic-tool"),
+              toolName: z8.string(),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-denied"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(false),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("input-streaming"),
+              providerExecuted: z8.boolean().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              input: z8.unknown().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("input-available"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.never().optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("approval-requested"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.never().optional(),
+                reason: z8.never().optional(),
+                signature: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("approval-responded"),
+              input: z8.unknown(),
+              providerExecuted: z8.boolean().optional(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.boolean(),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              })
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-available"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.unknown(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              resultProviderMetadata: providerMetadataSchema.optional(),
+              preliminary: z8.boolean().optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-error"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown().optional(),
+              rawInput: z8.unknown().optional(),
+              output: z8.never().optional(),
+              errorText: z8.string(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              resultProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(true),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              }).optional()
+            }),
+            z8.object({
+              type: z8.string().startsWith("tool-"),
+              toolCallId: z8.string(),
+              toolMetadata: toolMetadataSchema2.optional(),
+              state: z8.literal("output-denied"),
+              providerExecuted: z8.boolean().optional(),
+              input: z8.unknown(),
+              output: z8.never().optional(),
+              errorText: z8.never().optional(),
+              callProviderMetadata: providerMetadataSchema.optional(),
+              approval: z8.object({
+                id: z8.string(),
+                approved: z8.literal(false),
+                reason: z8.string().optional(),
+                signature: z8.string().optional()
+              })
+            })
+          ])
+        ).nonempty("Message must contain at least one part")
+      })
+    ).nonempty("Messages array must not be empty")
+  )
+);
+var originalGenerateId3 = createIdGenerator({ prefix: "aiobj", size: 24 });
+function createDownload(options) {
+  return ({ url, abortSignal }) => download({ url, maxBytes: options == null ? void 0 : options.maxBytes, abortSignal });
+}
+var originalGenerateId4 = createIdGenerator({ prefix: "aiobj", size: 24 });
+var defaultDownload = createDownload();
+var name21 = "AI_NoSuchProviderError";
+var marker21 = `vercel.ai.error.${name21}`;
+var symbol21 = Symbol.for(marker21);
+var _a21;
+_a21 = symbol21;
+var defaultDownload2 = createDownload();
+var HttpChatTransport = class {
+  constructor({
+    api = "/api/chat",
+    credentials,
+    headers,
+    body,
+    fetch: fetch2,
+    prepareSendMessagesRequest,
+    prepareReconnectToStreamRequest
+  }) {
+    this.api = api;
+    this.credentials = credentials;
+    this.headers = headers;
+    this.body = body;
+    this.fetch = fetch2;
+    this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+    this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
+  }
+  async sendMessages({
+    abortSignal,
+    ...options
+  }) {
+    var _a222, _b16, _c, _d, _e;
+    const resolvedBody = await resolve(this.body);
+    const resolvedHeaders = await resolve(this.headers);
+    const resolvedCredentials = await resolve(this.credentials);
+    const baseHeaders = {
+      ...normalizeHeaders(resolvedHeaders),
+      ...normalizeHeaders(options.headers)
+    };
+    const preparedRequest = await ((_a222 = this.prepareSendMessagesRequest) == null ? void 0 : _a222.call(this, {
+      api: this.api,
+      id: options.chatId,
+      messages: options.messages,
+      body: { ...resolvedBody, ...options.body },
+      headers: baseHeaders,
+      credentials: resolvedCredentials,
+      requestMetadata: options.metadata,
+      trigger: options.trigger,
+      messageId: options.messageId
+    }));
+    const api = (_b16 = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b16 : this.api;
+    const headers = (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? normalizeHeaders(preparedRequest.headers) : baseHeaders;
+    const body = (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : {
+      ...resolvedBody,
+      ...options.body,
+      id: options.chatId,
+      messages: options.messages,
+      trigger: options.trigger,
+      messageId: options.messageId
+    };
+    const credentials = (_c = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _c : resolvedCredentials;
+    const fetch2 = (_d = this.fetch) != null ? _d : globalThis.fetch;
+    const response = await fetch2(api, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body),
+      credentials,
+      signal: abortSignal
+    });
+    if (!response.ok) {
+      throw new Error(
+        (_e = await response.text()) != null ? _e : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    return this.processResponseStream(response.body);
+  }
+  async reconnectToStream(options) {
+    var _a222, _b16, _c, _d, _e;
+    const resolvedBody = await resolve(this.body);
+    const resolvedHeaders = await resolve(this.headers);
+    const resolvedCredentials = await resolve(this.credentials);
+    const baseHeaders = {
+      ...normalizeHeaders(resolvedHeaders),
+      ...normalizeHeaders(options.headers)
+    };
+    const preparedRequest = await ((_a222 = this.prepareReconnectToStreamRequest) == null ? void 0 : _a222.call(this, {
+      api: this.api,
+      id: options.chatId,
+      body: { ...resolvedBody, ...options.body },
+      headers: baseHeaders,
+      credentials: resolvedCredentials,
+      requestMetadata: options.metadata
+    }));
+    const api = (_b16 = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b16 : `${this.api}/${options.chatId}/stream`;
+    const headers = (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? normalizeHeaders(preparedRequest.headers) : baseHeaders;
+    const credentials = (_c = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _c : resolvedCredentials;
+    const fetch2 = (_d = this.fetch) != null ? _d : globalThis.fetch;
+    const response = await fetch2(api, {
+      method: "GET",
+      headers,
+      credentials
+    });
+    if (response.status === 204) {
+      return null;
+    }
+    if (!response.ok) {
+      throw new Error(
+        (_e = await response.text()) != null ? _e : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    return this.processResponseStream(response.body);
+  }
+};
+var DefaultChatTransport = class extends HttpChatTransport {
+  constructor(options = {}) {
+    super(options);
+  }
+  processResponseStream(stream) {
+    return parseJsonEventStream({
+      stream,
+      schema: uiMessageChunkSchema
+    }).pipeThrough(
+      new TransformStream({
+        async transform(chunk, controller) {
+          if (!chunk.success) {
+            throw chunk.error;
+          }
+          controller.enqueue(chunk.value);
+        }
+      })
+    );
+  }
+};
+function lastAssistantMessageIsCompleteWithApprovalResponses({
+  messages
+}) {
+  const message = messages[messages.length - 1];
+  if (!message) {
+    return false;
+  }
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter(isToolUIPart);
+  return (
+    // has at least one tool approval response
+    lastStepToolInvocations.filter((part) => part.state === "approval-responded").length > 0 && // all tool approvals must have a response
+    lastStepToolInvocations.every(
+      (part) => part.state === "output-available" || part.state === "output-error" || part.state === "approval-responded"
+    )
+  );
+}
+function lastAssistantMessageIsCompleteWithToolCalls({
+  messages
+}) {
+  const message = messages[messages.length - 1];
+  if (!message) {
+    return false;
+  }
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter(isToolUIPart).filter((part) => !part.providerExecuted);
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every(
+    (part) => part.state === "output-available" || part.state === "output-error"
+  );
+}
+
+// ../agent-sdk/dist/schemas.js
+import z32 from "zod";
+import z9 from "zod";
+import z22 from "zod";
+import { z as z43 } from "zod";
+var VersionSelectorSchema = z9.union([
+  z9.literal("latest").describe("Latest version (draft if available, otherwise latest published). This is the default if left empty"),
+  z9.literal("published").describe("Last published version (fallback to draft if no published version exists)"),
+  z9.number().min(1).describe("Specific version number (1, 2, 3...)")
+]);
+var FeedbackRatingSchema = z22.enum(["positive", "negative"]);
+var CreateFeedbackRequestSchema = z32.object({
+  agentId: z32.string(),
+  agentVersion: VersionSelectorSchema.optional(),
+  threadId: z32.string().min(1),
+  messageId: z32.string().min(1),
+  // these can be undefined (not provided - use old values) or null (explicitly clear values)
+  rating: FeedbackRatingSchema.nullish(),
+  improvementText: z32.string().nullish(),
+  // Array of notes with optional noteId + free-form key/value pairs
+  notes: z32.array(z32.record(z32.string(), z32.any())).optional()
+});
+var ChoicesFieldSchema = z43.object({
+  type: z43.literal("choices"),
+  name: z43.string(),
+  label: z43.string(),
+  options: z43.array(z43.object({
+    label: z43.string(),
+    value: z43.string(),
+    description: z43.string().optional()
+  })).min(2),
+  multiSelect: z43.boolean().optional(),
+  required: z43.boolean().optional(),
+  defaultValue: z43.union([z43.string(), z43.array(z43.string())]).optional()
+});
+var TextFieldSchema = z43.object({
+  type: z43.literal("text"),
+  name: z43.string(),
+  label: z43.string(),
+  placeholder: z43.string().optional(),
+  multiline: z43.boolean().optional(),
+  required: z43.boolean().optional(),
+  defaultValue: z43.string().optional()
+});
+var NumberFieldSchema = z43.object({
+  type: z43.literal("number"),
+  name: z43.string(),
+  label: z43.string(),
+  min: z43.number().optional(),
+  max: z43.number().optional(),
+  required: z43.boolean().optional(),
+  defaultValue: z43.number().optional()
+});
+var CheckboxFieldSchema = z43.object({
+  type: z43.literal("checkbox"),
+  name: z43.string(),
+  label: z43.string(),
+  defaultValue: z43.boolean().optional()
+});
+var DateFieldSchema = z43.object({
+  type: z43.literal("date"),
+  name: z43.string(),
+  label: z43.string(),
+  required: z43.boolean().optional(),
+  defaultValue: z43.string().optional()
+  // ISO date string
+});
+var InputFieldSchema = z43.discriminatedUnion("type", [
+  ChoicesFieldSchema,
+  TextFieldSchema,
+  NumberFieldSchema,
+  CheckboxFieldSchema,
+  DateFieldSchema
+]);
+var CollectUserInputArgsSchema = z43.object({
+  title: z43.string().optional(),
+  description: z43.string().optional(),
+  fields: z43.array(InputFieldSchema).min(1),
+  submitLabel: z43.string().optional(),
+  cancelLabel: z43.string().optional(),
+  allowFreeformResponse: z43.boolean().optional().default(true)
+});
+var voiceTableWidgetDefinition = {
+  widgetType: "table",
+  schema: {
+    type: "object",
+    description: "Display a comparison or other tabular details beside the spoken answer.",
+    properties: {
+      title: { type: "string", description: "Short descriptive title for the table." },
+      markdown: { type: "string", description: "A Markdown table with a header row, separator row, and data rows. Use accurate retrieved values. Do not include code fences or narrative." }
+    },
+    required: ["markdown"],
+    additionalProperties: false
+  }
+};
+var commonProperties = {
+  title: { type: "string", description: "Short chart title." },
+  description: { type: "string", description: "Optional context, period, or source note." },
+  valueLabel: { type: "string", description: "Metric and unit, e.g. Monthly premium ($), Employees, or Coverage (%). Keep all values in the same unit." }
+};
+var categoryData = (nonnegative = false) => ({
+  type: "array",
+  minItems: 1,
+  maxItems: nonnegative ? 12 : 40,
+  items: {
+    type: "object",
+    properties: { label: { type: "string" }, value: { type: "number", ...nonnegative ? { minimum: 0 } : {} } },
+    required: ["label", "value"],
+    additionalProperties: false
+  }
+});
+var voiceChartWidgetDefinitions = [
+  {
+    widgetType: "bar_chart",
+    schema: {
+      type: "object",
+      description: "Compare numeric values across categories. Prefer one chart for related values in the same unit; do not mix dollars and percentages.",
+      properties: { ...commonProperties, data: categoryData() },
+      required: ["title", "data"],
+      additionalProperties: false
+    }
+  },
+  {
+    widgetType: "line_chart",
+    schema: {
+      type: "object",
+      description: "Show one or more trends over ordered time points. Values keys must match series keys. Omit a missing value instead of inventing zero.",
+      properties: {
+        ...commonProperties,
+        series: {
+          type: "array",
+          minItems: 1,
+          maxItems: 6,
+          items: { type: "object", properties: { key: { type: "string" }, label: { type: "string" } }, required: ["key", "label"], additionalProperties: false }
+        },
+        data: {
+          type: "array",
+          minItems: 2,
+          maxItems: 100,
+          items: {
+            type: "object",
+            properties: { label: { type: "string" }, values: { type: "object", additionalProperties: { type: "number" } } },
+            required: ["label", "values"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["title", "series", "data"],
+      additionalProperties: false
+    }
+  },
+  {
+    widgetType: "pie_chart",
+    schema: {
+      type: "object",
+      description: "Show parts of one whole as a donut. Values must be nonnegative and total above zero. Use bar_chart for unrelated comparisons or negative values.",
+      properties: { ...commonProperties, centerLabel: { type: "string", description: "Short label underneath the total in the donut center." }, data: categoryData(true) },
+      required: ["title", "data"],
+      additionalProperties: false
+    }
+  }
+];
+var INTERRUPTED_TOOL_ERROR = "Interrupted before completion.";
+function markInterruptedTools(message) {
+  return {
+    ...message,
+    parts: message.parts.map((part) => {
+      if ((part.type.startsWith("tool-") || part.type === "dynamic-tool") && "state" in part && (part.state === "input-streaming" || part.state === "input-available")) {
+        return { ...part, state: "output-error", input: part.input ?? {}, errorText: INTERRUPTED_TOOL_ERROR };
+      }
+      return part;
+    })
+  };
+}
+
+// lib/ui-widgets.ts
+var SDK_WIDGET_MARKER = /* @__PURE__ */ Symbol("__isSDKWidget");
+function isSDKWidget(widget) {
+  return SDK_WIDGET_MARKER in widget && widget[SDK_WIDGET_MARKER] === true;
+}
+function createSDKWidget(widget) {
+  return {
+    ...widget,
+    [SDK_WIDGET_MARKER]: true
+  };
+}
+var createWidget = (widget) => widget;
+
+export {
+  jsonSchema,
+  asSchema,
+  DefaultChatTransport,
+  lastAssistantMessageIsCompleteWithApprovalResponses,
+  lastAssistantMessageIsCompleteWithToolCalls,
+  voiceTableWidgetDefinition,
+  voiceChartWidgetDefinitions,
+  INTERRUPTED_TOOL_ERROR,
+  markInterruptedTools,
+  SDK_WIDGET_MARKER,
+  isSDKWidget,
+  createSDKWidget,
+  createWidget
+};
+//# sourceMappingURL=chunk-LQHHZ2OJ.js.map