@scalar/agent-chat 0.2.0 → 0.2.2

package/dist/node_modules/.pnpm/@ai-sdk_provider-utils@4.0.5_zod@4.3.5/node_modules/@ai-sdk/provider-utils/dist/index.js

@@ -0,0 +1,1177 @@
+import { InvalidArgumentError as L, JSONParseError as w, TypeValidationError as h } from "../../../../../@ai-sdk_provider@3.0.2/node_modules/@ai-sdk/provider/dist/index.js";
+import { EventSourceParserStream as F } from "../../../../../eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/stream.js";
+import { ZodFirstPartyTypeKind as o } from "../../../../../zod@4.3.5/node_modules/zod/v3/types.js";
+import { safeParseAsync as I } from "../../../../../zod@4.3.5/node_modules/zod/v4/classic/parse.js";
+import { toJSONSchema as R } from "../../../../../zod@4.3.5/node_modules/zod/v4/core/json-schema-processors.js";
+var M = ({
+  prefix: e,
+  size: t = 16,
+  alphabet: r = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator: n = "-"
+} = {}) => {
+  const a = () => {
+    const i = r.length, s = new Array(t);
+    for (let u = 0; u < t; u++)
+      s[u] = r[Math.random() * i | 0];
+    return s.join("");
+  };
+  if (e == null)
+    return a;
+  if (r.includes(n))
+    throw new L({
+      argument: "separator",
+      message: `The separator "${n}" must not be part of the alphabet "${r}".`
+    });
+  return () => `${e}${n}${a()}`;
+}, Be = M();
+function He(e = globalThis) {
+  var t, r, n;
+  return e.window ? "runtime/browser" : (t = e.navigator) != null && t.userAgent ? `runtime/${e.navigator.userAgent.toLowerCase()}` : (n = (r = e.process) == null ? void 0 : r.versions) != null && n.node ? `runtime/node.js/${e.process.version.substring(0)}` : e.EdgeRuntime ? "runtime/vercel-edge" : "runtime/unknown";
+}
+function C(e) {
+  if (e == null)
+    return {};
+  const t = {};
+  if (e instanceof Headers)
+    e.forEach((r, n) => {
+      t[n.toLowerCase()] = r;
+    });
+  else {
+    Array.isArray(e) || (e = Object.entries(e));
+    for (const [r, n] of e)
+      n != null && (t[r.toLowerCase()] = n);
+  }
+  return t;
+}
+function qe(e, ...t) {
+  const r = new Headers(C(e)), n = r.get("user-agent") || "";
+  return r.set(
+    "user-agent",
+    [n, ...t].filter(Boolean).join(" ")
+  ), Object.fromEntries(r.entries());
+}
+var U = /"__proto__"\s*:/, V = /"constructor"\s*:/;
+function S(e) {
+  const t = JSON.parse(e);
+  return t === null || typeof t != "object" || U.test(e) === !1 && V.test(e) === !1 ? t : J(t);
+}
+function J(e) {
+  let t = [e];
+  for (; t.length; ) {
+    const r = t;
+    t = [];
+    for (const n of r) {
+      if (Object.prototype.hasOwnProperty.call(n, "__proto__"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      if (Object.prototype.hasOwnProperty.call(n, "constructor") && Object.prototype.hasOwnProperty.call(n.constructor, "prototype"))
+        throw new SyntaxError("Object contains forbidden prototype property");
+      for (const a in n) {
+        const i = n[a];
+        i && typeof i == "object" && t.push(i);
+      }
+    }
+  }
+  return e;
+}
+function B(e) {
+  const { stackTraceLimit: t } = Error;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch {
+    return S(e);
+  }
+  try {
+    return S(e);
+  } finally {
+    Error.stackTraceLimit = t;
+  }
+}
+function O(e) {
+  if (e.type === "object" || Array.isArray(e.type) && e.type.includes("object")) {
+    e.additionalProperties = !1;
+    const { properties: r } = e;
+    if (r != null)
+      for (const n of Object.keys(r))
+        r[n] = g(r[n]);
+  }
+  e.items != null && (e.items = Array.isArray(e.items) ? e.items.map(g) : g(e.items)), e.anyOf != null && (e.anyOf = e.anyOf.map(g)), e.allOf != null && (e.allOf = e.allOf.map(g)), e.oneOf != null && (e.oneOf = e.oneOf.map(g));
+  const { definitions: t } = e;
+  if (t != null)
+    for (const r of Object.keys(t))
+      t[r] = g(t[r]);
+  return e;
+}
+function g(e) {
+  return typeof e == "boolean" ? e : O(e);
+}
+var H = Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+), $ = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: !0,
+  rejectedAdditionalProperties: !1,
+  definitionPath: "definitions",
+  strictUnions: !1,
+  definitions: {},
+  errorMessages: !1,
+  patternStrategy: "escape",
+  applyRegexFlags: !1,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+}, q = (e) => typeof e == "string" ? {
+  ...$,
+  name: e
+} : {
+  ...$,
+  ...e
+};
+function d() {
+  return {};
+}
+function K(e, t) {
+  var r, n, a;
+  const i = {
+    type: "array"
+  };
+  return (r = e.type) != null && r._def && ((a = (n = e.type) == null ? void 0 : n._def) == null ? void 0 : a.typeName) !== o.ZodAny && (i.items = l(e.type._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items"]
+  })), e.minLength && (i.minItems = e.minLength.value), e.maxLength && (i.maxItems = e.maxLength.value), e.exactLength && (i.minItems = e.exactLength.value, i.maxItems = e.exactLength.value), i;
+}
+function G(e) {
+  const t = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!e.checks) return t;
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "min":
+        r.inclusive ? t.minimum = r.value : t.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? t.maximum = r.value : t.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        t.multipleOf = r.value;
+        break;
+    }
+  return t;
+}
+function W() {
+  return { type: "boolean" };
+}
+function N(e, t) {
+  return l(e.type._def, t);
+}
+var Q = (e, t) => l(e.innerType._def, t);
+function D(e, t, r) {
+  const n = r ?? t.dateStrategy;
+  if (Array.isArray(n))
+    return {
+      anyOf: n.map((a, i) => D(e, t, a))
+    };
+  switch (n) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return X(e);
+  }
+}
+var X = (e) => {
+  const t = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "min":
+        t.minimum = r.value;
+        break;
+      case "max":
+        t.maximum = r.value;
+        break;
+    }
+  return t;
+};
+function Y(e, t) {
+  return {
+    ...l(e.innerType._def, t),
+    default: e.defaultValue()
+  };
+}
+function ee(e, t) {
+  return t.effectStrategy === "input" ? l(e.schema._def, t) : d();
+}
+function te(e) {
+  return {
+    type: "string",
+    enum: Array.from(e.values)
+  };
+}
+var re = (e) => "type" in e && e.type === "string" ? !1 : "allOf" in e;
+function ne(e, t) {
+  const r = [
+    l(e.left._def, {
+      ...t,
+      currentPath: [...t.currentPath, "allOf", "0"]
+    }),
+    l(e.right._def, {
+      ...t,
+      currentPath: [...t.currentPath, "allOf", "1"]
+    })
+  ].filter((a) => !!a), n = [];
+  return r.forEach((a) => {
+    if (re(a))
+      n.push(...a.allOf);
+    else {
+      let i = a;
+      if ("additionalProperties" in a && a.additionalProperties === !1) {
+        const { additionalProperties: s, ...u } = a;
+        i = u;
+      }
+      n.push(i);
+    }
+  }), n.length ? { allOf: n } : void 0;
+}
+function ae(e) {
+  const t = typeof e.value;
+  return t !== "bigint" && t !== "number" && t !== "boolean" && t !== "string" ? {
+    type: Array.isArray(e.value) ? "array" : "object"
+  } : {
+    type: t === "bigint" ? "integer" : t,
+    const: e.value
+  };
+}
+var P = void 0, m = {
+  /**
+   * `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: () => (P === void 0 && (P = RegExp(
+    "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+    "u"
+  )), P),
+  /**
+   * 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 E(e, t) {
+  const r = {
+    type: "string"
+  };
+  if (e.checks)
+    for (const n of e.checks)
+      switch (n.kind) {
+        case "min":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, n.value) : n.value;
+          break;
+        case "max":
+          r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, n.value) : n.value;
+          break;
+        case "email":
+          switch (t.emailStrategy) {
+            case "format:email":
+              y(r, "email", n.message, t);
+              break;
+            case "format:idn-email":
+              y(r, "idn-email", n.message, t);
+              break;
+            case "pattern:zod":
+              f(r, m.email, n.message, t);
+              break;
+          }
+          break;
+        case "url":
+          y(r, "uri", n.message, t);
+          break;
+        case "uuid":
+          y(r, "uuid", n.message, t);
+          break;
+        case "regex":
+          f(r, n.regex, n.message, t);
+          break;
+        case "cuid":
+          f(r, m.cuid, n.message, t);
+          break;
+        case "cuid2":
+          f(r, m.cuid2, n.message, t);
+          break;
+        case "startsWith":
+          f(
+            r,
+            RegExp(`^${_(n.value, t)}`),
+            n.message,
+            t
+          );
+          break;
+        case "endsWith":
+          f(
+            r,
+            RegExp(`${_(n.value, t)}$`),
+            n.message,
+            t
+          );
+          break;
+        case "datetime":
+          y(r, "date-time", n.message, t);
+          break;
+        case "date":
+          y(r, "date", n.message, t);
+          break;
+        case "time":
+          y(r, "time", n.message, t);
+          break;
+        case "duration":
+          y(r, "duration", n.message, t);
+          break;
+        case "length":
+          r.minLength = typeof r.minLength == "number" ? Math.max(r.minLength, n.value) : n.value, r.maxLength = typeof r.maxLength == "number" ? Math.min(r.maxLength, n.value) : n.value;
+          break;
+        case "includes": {
+          f(
+            r,
+            RegExp(_(n.value, t)),
+            n.message,
+            t
+          );
+          break;
+        }
+        case "ip": {
+          n.version !== "v6" && y(r, "ipv4", n.message, t), n.version !== "v4" && y(r, "ipv6", n.message, t);
+          break;
+        }
+        case "base64url":
+          f(r, m.base64url, n.message, t);
+          break;
+        case "jwt":
+          f(r, m.jwt, n.message, t);
+          break;
+        case "cidr": {
+          n.version !== "v6" && f(r, m.ipv4Cidr, n.message, t), n.version !== "v4" && f(r, m.ipv6Cidr, n.message, t);
+          break;
+        }
+        case "emoji":
+          f(r, m.emoji(), n.message, t);
+          break;
+        case "ulid": {
+          f(r, m.ulid, n.message, t);
+          break;
+        }
+        case "base64": {
+          switch (t.base64Strategy) {
+            case "format:binary": {
+              y(r, "binary", n.message, t);
+              break;
+            }
+            case "contentEncoding:base64": {
+              r.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              f(r, m.base64, n.message, t);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid":
+          f(r, m.nanoid, n.message, t);
+      }
+  return r;
+}
+function _(e, t) {
+  return t.patternStrategy === "escape" ? oe(e) : e;
+}
+var ie = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function oe(e) {
+  let t = "";
+  for (let r = 0; r < e.length; r++)
+    ie.has(e[r]) || (t += "\\"), t += e[r];
+  return t;
+}
+function y(e, t, r, n) {
+  var a;
+  e.format || (a = e.anyOf) != null && a.some((i) => i.format) ? (e.anyOf || (e.anyOf = []), e.format && (e.anyOf.push({
+    format: e.format
+  }), delete e.format), e.anyOf.push({
+    format: t,
+    ...r && n.errorMessages && { errorMessage: { format: r } }
+  })) : e.format = t;
+}
+function f(e, t, r, n) {
+  var a;
+  e.pattern || (a = e.allOf) != null && a.some((i) => i.pattern) ? (e.allOf || (e.allOf = []), e.pattern && (e.allOf.push({
+    pattern: e.pattern
+  }), delete e.pattern), e.allOf.push({
+    pattern: T(t, n),
+    ...r && n.errorMessages && { errorMessage: { pattern: r } }
+  })) : e.pattern = T(t, n);
+}
+function T(e, t) {
+  var r;
+  if (!t.applyRegexFlags || !e.flags)
+    return e.source;
+  const n = {
+    i: e.flags.includes("i"),
+    // Case-insensitive
+    m: e.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: e.flags.includes("s")
+    // `.` matches newlines
+  }, a = n.i ? e.source.toLowerCase() : e.source;
+  let i = "", s = !1, u = !1, p = !1;
+  for (let c = 0; c < a.length; c++) {
+    if (s) {
+      i += a[c], s = !1;
+      continue;
+    }
+    if (n.i) {
+      if (u) {
+        if (a[c].match(/[a-z]/)) {
+          p ? (i += a[c], i += `${a[c - 2]}-${a[c]}`.toUpperCase(), p = !1) : a[c + 1] === "-" && ((r = a[c + 2]) != null && r.match(/[a-z]/)) ? (i += a[c], p = !0) : i += `${a[c]}${a[c].toUpperCase()}`;
+          continue;
+        }
+      } else if (a[c].match(/[a-z]/)) {
+        i += `[${a[c]}${a[c].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (n.m) {
+      if (a[c] === "^") {
+        i += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (a[c] === "$") {
+        i += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (n.s && a[c] === ".") {
+      i += u ? `${a[c]}\r
+` : `[${a[c]}\r
+]`;
+      continue;
+    }
+    i += a[c], a[c] === "\\" ? s = !0 : u && a[c] === "]" ? u = !1 : !u && a[c] === "[" && (u = !0);
+  }
+  try {
+    new RegExp(i);
+  } catch {
+    return console.warn(
+      `Could not convert regex pattern at ${t.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    ), e.source;
+  }
+  return i;
+}
+function x(e, t) {
+  var r, n, a, i, s, u;
+  const p = {
+    type: "object",
+    additionalProperties: (r = l(e.valueType._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalProperties"]
+    })) != null ? r : t.allowedAdditionalProperties
+  };
+  if (((n = e.keyType) == null ? void 0 : n._def.typeName) === o.ZodString && ((a = e.keyType._def.checks) != null && a.length)) {
+    const { type: c, ...v } = E(e.keyType._def, t);
+    return {
+      ...p,
+      propertyNames: v
+    };
+  } else {
+    if (((i = e.keyType) == null ? void 0 : i._def.typeName) === o.ZodEnum)
+      return {
+        ...p,
+        propertyNames: {
+          enum: e.keyType._def.values
+        }
+      };
+    if (((s = e.keyType) == null ? void 0 : s._def.typeName) === o.ZodBranded && e.keyType._def.type._def.typeName === o.ZodString && ((u = e.keyType._def.type._def.checks) != null && u.length)) {
+      const { type: c, ...v } = N(
+        e.keyType._def,
+        t
+      );
+      return {
+        ...p,
+        propertyNames: v
+      };
+    }
+  }
+  return p;
+}
+function se(e, t) {
+  if (t.mapStrategy === "record")
+    return x(e, t);
+  const r = l(e.keyType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items", "items", "0"]
+  }) || d(), n = l(e.valueType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "items", "items", "1"]
+  }) || d();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [r, n],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function ue(e) {
+  const t = e.values, n = Object.keys(e.values).filter((i) => typeof t[t[i]] != "number").map((i) => t[i]), a = Array.from(
+    new Set(n.map((i) => typeof i))
+  );
+  return {
+    type: a.length === 1 ? a[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: n
+  };
+}
+function ce() {
+  return { not: d() };
+}
+function le() {
+  return {
+    type: "null"
+  };
+}
+var k = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function pe(e, t) {
+  const r = e.options instanceof Map ? Array.from(e.options.values()) : e.options;
+  if (r.every(
+    (n) => n._def.typeName in k && (!n._def.checks || !n._def.checks.length)
+  )) {
+    const n = r.reduce((a, i) => {
+      const s = k[i._def.typeName];
+      return s && !a.includes(s) ? [...a, s] : a;
+    }, []);
+    return {
+      type: n.length > 1 ? n : n[0]
+    };
+  } else if (r.every((n) => n._def.typeName === "ZodLiteral" && !n.description)) {
+    const n = r.reduce(
+      (a, i) => {
+        const s = typeof i._def.value;
+        switch (s) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...a, s];
+          case "bigint":
+            return [...a, "integer"];
+          case "object":
+            if (i._def.value === null) return [...a, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return a;
+        }
+      },
+      []
+    );
+    if (n.length === r.length) {
+      const a = n.filter((i, s, u) => u.indexOf(i) === s);
+      return {
+        type: a.length > 1 ? a : a[0],
+        enum: r.reduce(
+          (i, s) => i.includes(s._def.value) ? i : [...i, s._def.value],
+          []
+        )
+      };
+    }
+  } else if (r.every((n) => n._def.typeName === "ZodEnum"))
+    return {
+      type: "string",
+      enum: r.reduce(
+        (n, a) => [
+          ...n,
+          ...a._def.values.filter((i) => !n.includes(i))
+        ],
+        []
+      )
+    };
+  return fe(e, t);
+}
+var fe = (e, t) => {
+  const r = (e.options instanceof Map ? Array.from(e.options.values()) : e.options).map(
+    (n, a) => l(n._def, {
+      ...t,
+      currentPath: [...t.currentPath, "anyOf", `${a}`]
+    })
+  ).filter(
+    (n) => !!n && (!t.strictUnions || typeof n == "object" && Object.keys(n).length > 0)
+  );
+  return r.length ? { anyOf: r } : void 0;
+};
+function de(e, t) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    e.innerType._def.typeName
+  ) && (!e.innerType._def.checks || !e.innerType._def.checks.length))
+    return {
+      type: [
+        k[e.innerType._def.typeName],
+        "null"
+      ]
+    };
+  const r = l(e.innerType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "anyOf", "0"]
+  });
+  return r && { anyOf: [r, { type: "null" }] };
+}
+function me(e) {
+  const t = {
+    type: "number"
+  };
+  if (!e.checks) return t;
+  for (const r of e.checks)
+    switch (r.kind) {
+      case "int":
+        t.type = "integer";
+        break;
+      case "min":
+        r.inclusive ? t.minimum = r.value : t.exclusiveMinimum = r.value;
+        break;
+      case "max":
+        r.inclusive ? t.maximum = r.value : t.exclusiveMaximum = r.value;
+        break;
+      case "multipleOf":
+        t.multipleOf = r.value;
+        break;
+    }
+  return t;
+}
+function ye(e, t) {
+  const r = {
+    type: "object",
+    properties: {}
+  }, n = [], a = e.shape();
+  for (const s in a) {
+    let u = a[s];
+    if (u === void 0 || u._def === void 0)
+      continue;
+    const p = ve(u), c = l(u._def, {
+      ...t,
+      currentPath: [...t.currentPath, "properties", s],
+      propertyPath: [...t.currentPath, "properties", s]
+    });
+    c !== void 0 && (r.properties[s] = c, p || n.push(s));
+  }
+  n.length && (r.required = n);
+  const i = ge(e, t);
+  return i !== void 0 && (r.additionalProperties = i), r;
+}
+function ge(e, t) {
+  if (e.catchall._def.typeName !== "ZodNever")
+    return l(e.catchall._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalProperties"]
+    });
+  switch (e.unknownKeys) {
+    case "passthrough":
+      return t.allowedAdditionalProperties;
+    case "strict":
+      return t.rejectedAdditionalProperties;
+    case "strip":
+      return t.removeAdditionalStrategy === "strict" ? t.allowedAdditionalProperties : t.rejectedAdditionalProperties;
+  }
+}
+function ve(e) {
+  try {
+    return e.isOptional();
+  } catch {
+    return !0;
+  }
+}
+var he = (e, t) => {
+  var r;
+  if (t.currentPath.toString() === ((r = t.propertyPath) == null ? void 0 : r.toString()))
+    return l(e.innerType._def, t);
+  const n = l(e.innerType._def, {
+    ...t,
+    currentPath: [...t.currentPath, "anyOf", "1"]
+  });
+  return n ? { anyOf: [{ not: d() }, n] } : d();
+}, be = (e, t) => {
+  if (t.pipeStrategy === "input")
+    return l(e.in._def, t);
+  if (t.pipeStrategy === "output")
+    return l(e.out._def, t);
+  const r = l(e.in._def, {
+    ...t,
+    currentPath: [...t.currentPath, "allOf", "0"]
+  }), n = l(e.out._def, {
+    ...t,
+    currentPath: [...t.currentPath, "allOf", r ? "1" : "0"]
+  });
+  return {
+    allOf: [r, n].filter((a) => a !== void 0)
+  };
+};
+function Pe(e, t) {
+  return l(e.type._def, t);
+}
+function _e(e, t) {
+  const n = {
+    type: "array",
+    uniqueItems: !0,
+    items: l(e.valueType._def, {
+      ...t,
+      currentPath: [...t.currentPath, "items"]
+    })
+  };
+  return e.minSize && (n.minItems = e.minSize.value), e.maxSize && (n.maxItems = e.maxSize.value), n;
+}
+function ke(e, t) {
+  return e.rest ? {
+    type: "array",
+    minItems: e.items.length,
+    items: e.items.map(
+      (r, n) => l(r._def, {
+        ...t,
+        currentPath: [...t.currentPath, "items", `${n}`]
+      })
+    ).reduce(
+      (r, n) => n === void 0 ? r : [...r, n],
+      []
+    ),
+    additionalItems: l(e.rest._def, {
+      ...t,
+      currentPath: [...t.currentPath, "additionalItems"]
+    })
+  } : {
+    type: "array",
+    minItems: e.items.length,
+    maxItems: e.items.length,
+    items: e.items.map(
+      (r, n) => l(r._def, {
+        ...t,
+        currentPath: [...t.currentPath, "items", `${n}`]
+      })
+    ).reduce(
+      (r, n) => n === void 0 ? r : [...r, n],
+      []
+    )
+  };
+}
+function Ae() {
+  return {
+    not: d()
+  };
+}
+function Oe() {
+  return d();
+}
+var Ze = (e, t) => l(e.innerType._def, t), we = (e, t, r) => {
+  switch (t) {
+    case o.ZodString:
+      return E(e, r);
+    case o.ZodNumber:
+      return me(e);
+    case o.ZodObject:
+      return ye(e, r);
+    case o.ZodBigInt:
+      return G(e);
+    case o.ZodBoolean:
+      return W();
+    case o.ZodDate:
+      return D(e, r);
+    case o.ZodUndefined:
+      return Ae();
+    case o.ZodNull:
+      return le();
+    case o.ZodArray:
+      return K(e, r);
+    case o.ZodUnion:
+    case o.ZodDiscriminatedUnion:
+      return pe(e, r);
+    case o.ZodIntersection:
+      return ne(e, r);
+    case o.ZodTuple:
+      return ke(e, r);
+    case o.ZodRecord:
+      return x(e, r);
+    case o.ZodLiteral:
+      return ae(e);
+    case o.ZodEnum:
+      return te(e);
+    case o.ZodNativeEnum:
+      return ue(e);
+    case o.ZodNullable:
+      return de(e, r);
+    case o.ZodOptional:
+      return he(e, r);
+    case o.ZodMap:
+      return se(e, r);
+    case o.ZodSet:
+      return _e(e, r);
+    case o.ZodLazy:
+      return () => e.getter()._def;
+    case o.ZodPromise:
+      return Pe(e, r);
+    case o.ZodNaN:
+    case o.ZodNever:
+      return ce();
+    case o.ZodEffects:
+      return ee(e, r);
+    case o.ZodAny:
+      return d();
+    case o.ZodUnknown:
+      return Oe();
+    case o.ZodDefault:
+      return Y(e, r);
+    case o.ZodBranded:
+      return N(e, r);
+    case o.ZodReadonly:
+      return Ze(e, r);
+    case o.ZodCatch:
+      return Q(e, r);
+    case o.ZodPipeline:
+      return be(e, r);
+    case o.ZodFunction:
+    case o.ZodVoid:
+    case o.ZodSymbol:
+      return;
+    default:
+      return /* @__PURE__ */ ((n) => {
+      })();
+  }
+}, Se = (e, t) => {
+  let r = 0;
+  for (; r < e.length && r < t.length && e[r] === t[r]; r++)
+    ;
+  return [(e.length - r).toString(), ...t.slice(r)].join("/");
+};
+function l(e, t, r = !1) {
+  var n;
+  const a = t.seen.get(e);
+  if (t.override) {
+    const p = (n = t.override) == null ? void 0 : n.call(
+      t,
+      e,
+      t,
+      a,
+      r
+    );
+    if (p !== H)
+      return p;
+  }
+  if (a && !r) {
+    const p = $e(a, t);
+    if (p !== void 0)
+      return p;
+  }
+  const i = { def: e, path: t.currentPath, jsonSchema: void 0 };
+  t.seen.set(e, i);
+  const s = we(e, e.typeName, t), u = typeof s == "function" ? l(s(), t) : s;
+  if (u && Te(e, t, u), t.postProcess) {
+    const p = t.postProcess(u, e, t);
+    return i.jsonSchema = u, p;
+  }
+  return i.jsonSchema = u, u;
+}
+var $e = (e, t) => {
+  switch (t.$refStrategy) {
+    case "root":
+      return { $ref: e.path.join("/") };
+    case "relative":
+      return { $ref: Se(t.currentPath, e.path) };
+    case "none":
+    case "seen":
+      return e.path.length < t.currentPath.length && e.path.every((r, n) => t.currentPath[n] === r) ? (console.warn(
+        `Recursive reference detected at ${t.currentPath.join(
+          "/"
+        )}! Defaulting to any`
+      ), d()) : t.$refStrategy === "seen" ? d() : void 0;
+  }
+}, Te = (e, t, r) => (e.description && (r.description = e.description), r), Ne = (e) => {
+  const t = q(e), r = t.name !== void 0 ? [...t.basePath, t.definitionPath, t.name] : t.basePath;
+  return {
+    ...t,
+    currentPath: r,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(t.definitions).map(([n, a]) => [
+        a._def,
+        {
+          def: a._def,
+          path: [...t.basePath, t.definitionPath, n],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+}, De = (e, t) => {
+  var r;
+  const n = Ne(t);
+  let a = typeof t == "object" && t.definitions ? Object.entries(t.definitions).reduce(
+    (c, [v, z]) => {
+      var Z;
+      return {
+        ...c,
+        [v]: (Z = l(
+          z._def,
+          {
+            ...n,
+            currentPath: [...n.basePath, n.definitionPath, v]
+          },
+          !0
+        )) != null ? Z : d()
+      };
+    },
+    {}
+  ) : void 0;
+  const i = typeof t == "string" ? t : t?.nameStrategy === "title" ? void 0 : t?.name, s = (r = l(
+    e._def,
+    i === void 0 ? n : {
+      ...n,
+      currentPath: [...n.basePath, n.definitionPath, i]
+    },
+    !1
+  )) != null ? r : d(), u = typeof t == "object" && t.name !== void 0 && t.nameStrategy === "title" ? t.name : void 0;
+  u !== void 0 && (s.title = u);
+  const p = i === void 0 ? a ? {
+    ...s,
+    [n.definitionPath]: a
+  } : s : {
+    $ref: [
+      ...n.$refStrategy === "relative" ? [] : n.basePath,
+      n.definitionPath,
+      i
+    ].join("/"),
+    [n.definitionPath]: {
+      ...a,
+      [i]: s
+    }
+  };
+  return p.$schema = "http://json-schema.org/draft-07/schema#", p;
+}, A = Symbol.for("vercel.ai.schema");
+function Ke(e) {
+  let t;
+  return () => (t == null && (t = e()), t);
+}
+function b(e, {
+  validate: t
+} = {}) {
+  return {
+    [A]: !0,
+    _type: void 0,
+    // should never be used directly
+    get jsonSchema() {
+      return typeof e == "function" && (e = e()), e;
+    },
+    validate: t
+  };
+}
+function Ee(e) {
+  return typeof e == "object" && e !== null && A in e && e[A] === !0 && "jsonSchema" in e && "validate" in e;
+}
+function xe(e) {
+  return e == null ? b({ properties: {}, additionalProperties: !1 }) : Ee(e) ? e : "~standard" in e ? e["~standard"].vendor === "zod" ? Ie(e) : je(e) : e();
+}
+function je(e) {
+  return b(
+    () => O(
+      e["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
+    {
+      validate: async (t) => {
+        const r = await e["~standard"].validate(t);
+        return "value" in r ? { success: !0, value: r.value } : {
+          success: !1,
+          error: new h({
+            value: t,
+            cause: r.issues
+          })
+        };
+      }
+    }
+  );
+}
+function ze(e, t) {
+  var r;
+  const n = (r = void 0) != null ? r : !1;
+  return b(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => De(e, {
+      $refStrategy: n ? "root" : "none"
+    }),
+    {
+      validate: async (a) => {
+        const i = await e.safeParseAsync(a);
+        return i.success ? { success: !0, value: i.data } : { success: !1, error: i.error };
+      }
+    }
+  );
+}
+function Le(e, t) {
+  var r;
+  const n = (r = void 0) != null ? r : !1;
+  return b(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => O(
+      R(e, {
+        target: "draft-7",
+        io: "input",
+        reused: n ? "ref" : "inline"
+      })
+    ),
+    {
+      validate: async (a) => {
+        const i = await I(e, a);
+        return i.success ? { success: !0, value: i.data } : { success: !1, error: i.error };
+      }
+    }
+  );
+}
+function Fe(e) {
+  return "_zod" in e;
+}
+function Ie(e, t) {
+  return Fe(e) ? Le(e) : ze(e);
+}
+async function Ge({
+  value: e,
+  schema: t
+}) {
+  const r = await j({ value: e, schema: t });
+  if (!r.success)
+    throw h.wrap({ value: e, cause: r.error });
+  return r.value;
+}
+async function j({
+  value: e,
+  schema: t
+}) {
+  const r = xe(t);
+  try {
+    if (r.validate == null)
+      return { success: !0, value: e, rawValue: e };
+    const n = await r.validate(e);
+    return n.success ? { success: !0, value: n.value, rawValue: e } : {
+      success: !1,
+      error: h.wrap({ value: e, cause: n.error }),
+      rawValue: e
+    };
+  } catch (n) {
+    return {
+      success: !1,
+      error: h.wrap({ value: e, cause: n }),
+      rawValue: e
+    };
+  }
+}
+async function Re({
+  text: e,
+  schema: t
+}) {
+  try {
+    const r = B(e);
+    return t == null ? { success: !0, value: r, rawValue: r } : await j({ value: r, schema: t });
+  } catch (r) {
+    return {
+      success: !1,
+      error: w.isInstance(r) ? r : new w({ text: e, cause: r }),
+      rawValue: void 0
+    };
+  }
+}
+function We({
+  stream: e,
+  schema: t
+}) {
+  return e.pipeThrough(new TextDecoderStream()).pipeThrough(new F()).pipeThrough(
+    new TransformStream({
+      async transform({ data: r }, n) {
+        r !== "[DONE]" && n.enqueue(await Re({ text: r, schema: t }));
+      }
+    })
+  );
+}
+async function Qe(e) {
+  return typeof e == "function" && (e = e()), Promise.resolve(e);
+}
+export {
+  F as EventSourceParserStream,
+  xe as asSchema,
+  M as createIdGenerator,
+  Be as generateId,
+  He as getRuntimeEnvironmentUserAgent,
+  b as jsonSchema,
+  Ke as lazySchema,
+  C as normalizeHeaders,
+  We as parseJsonEventStream,
+  Qe as resolve,
+  Re as safeParseJSON,
+  j as safeValidateTypes,
+  Ge as validateTypes,
+  qe as withUserAgentSuffix,
+  Ie as zodSchema
+};