@mastra/server 0.0.0-configure-project-root-for-private-packages-20250919100548 → 0.0.0-cor235-20251008175106

package/dist/{chunk-HJ4EQIE6.cjs → chunk-7HDOBOGG.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 
-var chunkNZMDHQVP_cjs = require('./chunk-NZMDHQVP.cjs');
-var chunkFALVL2VV_cjs = require('./chunk-FALVL2VV.cjs');
-var chunkHVBBFCDH_cjs = require('./chunk-HVBBFCDH.cjs');
-var chunkPPYGWINI_cjs = require('./chunk-PPYGWINI.cjs');
-var chunkSIGXR3JT_cjs = require('./chunk-SIGXR3JT.cjs');
+var chunkMQDBNHBT_cjs = require('./chunk-MQDBNHBT.cjs');
+var chunkOYL5TBJW_cjs = require('./chunk-OYL5TBJW.cjs');
+var chunk2PLXW4ZX_cjs = require('./chunk-2PLXW4ZX.cjs');
+var chunkLPM6BBAX_cjs = require('./chunk-LPM6BBAX.cjs');
+var chunkVY4ENABS_cjs = require('./chunk-VY4ENABS.cjs');
 var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
 var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.cjs');
-var chunkEMMSS5I5_cjs = require('./chunk-EMMSS5I5.cjs');
+var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
 var agent = require('@mastra/core/agent');
 var memory = require('@mastra/core/memory');
 var utils = require('@mastra/core/utils');
@@ -21,6 +21,7 @@ var path = require('path');
 var fs = require('fs');
 var module$1 = require('module');
 var util = require('util');
+var llm = require('@mastra/core/llm');
 var os = require('os');
 var workflows = require('@mastra/core/workflows');
 
@@ -44,8 +45,140 @@ function _interopNamespace(e) {
 
 var z42__namespace = /*#__PURE__*/_interopNamespace(z42);
 
+// ../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/get-context.js
+var require_get_context = chunkO7I5CWRX_cjs.__commonJS({
+  "../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/get-context.js"(exports, module) {
+    var __defProp4 = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export4 = (target, all) => {
+      for (var name20 in all)
+        __defProp4(target, name20, { get: all[name20], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp4({}, "__esModule", { value: true }), mod);
+    var get_context_exports = {};
+    __export4(get_context_exports, {
+      SYMBOL_FOR_REQ_CONTEXT: () => SYMBOL_FOR_REQ_CONTEXT,
+      getContext: () => getContext3
+    });
+    module.exports = __toCommonJS(get_context_exports);
+    var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
+    function getContext3() {
+      const fromSymbol = globalThis;
+      return fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.() ?? {};
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js
+var require_get_vercel_oidc_token = chunkO7I5CWRX_cjs.__commonJS({
+  "../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/get-vercel-oidc-token.js"(exports, module) {
+    var __defProp4 = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export4 = (target, all) => {
+      for (var name20 in all)
+        __defProp4(target, name20, { get: all[name20], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp4({}, "__esModule", { value: true }), mod);
+    var get_vercel_oidc_token_exports = {};
+    __export4(get_vercel_oidc_token_exports, {
+      getVercelOidcToken: () => getVercelOidcToken3,
+      getVercelOidcTokenSync: () => getVercelOidcTokenSync2
+    });
+    module.exports = __toCommonJS(get_vercel_oidc_token_exports);
+    var import_get_context = require_get_context();
+    var import_token_error = chunkOYL5TBJW_cjs.require_token_error();
+    async function getVercelOidcToken3() {
+      let token = "";
+      let err;
+      try {
+        token = getVercelOidcTokenSync2();
+      } catch (error) {
+        err = error;
+      }
+      try {
+        const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
+          await import('./token-util-S4A355II.cjs'),
+          await import('./token-53CFGXUO.cjs')
+        ]);
+        if (!token || isExpired(getTokenPayload(token))) {
+          await refreshToken();
+          token = getVercelOidcTokenSync2();
+        }
+      } catch (error) {
+        if (err?.message && error instanceof Error) {
+          error.message = `${err.message}
+${error.message}`;
+        }
+        throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token`, error);
+      }
+      return token;
+    }
+    function getVercelOidcTokenSync2() {
+      const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
+      if (!token) {
+        throw new Error(
+          `The 'x-vercel-oidc-token' header is missing from the request. Do you have the OIDC option enabled in the Vercel project settings?`
+        );
+      }
+      return token;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/index.js
+var require_dist = chunkO7I5CWRX_cjs.__commonJS({
+  "../../node_modules/.pnpm/@vercel+oidc@3.0.1/node_modules/@vercel/oidc/dist/index.js"(exports, module) {
+    var __defProp4 = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export4 = (target, all) => {
+      for (var name20 in all)
+        __defProp4(target, name20, { get: all[name20], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp4(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp4({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export4(src_exports, {
+      getContext: () => import_get_context.getContext,
+      getVercelOidcToken: () => import_get_vercel_oidc_token.getVercelOidcToken,
+      getVercelOidcTokenSync: () => import_get_vercel_oidc_token.getVercelOidcTokenSync
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_get_vercel_oidc_token = require_get_vercel_oidc_token();
+    var import_get_context = require_get_context();
+  }
+});
+
 // ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
-var require_base64_js = chunkEMMSS5I5_cjs.__commonJS({
+var require_base64_js = chunkO7I5CWRX_cjs.__commonJS({
   "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
     exports.byteLength = byteLength;
     exports.toByteArray = toByteArray;
@@ -145,7 +278,7 @@ var require_base64_js = chunkEMMSS5I5_cjs.__commonJS({
 });
 
 // ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
-var require_ignore = chunkEMMSS5I5_cjs.__commonJS({
+var require_ignore = chunkO7I5CWRX_cjs.__commonJS({
   "../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
     function makeArray(subject) {
       return Array.isArray(subject) ? subject : [subject];
@@ -547,80 +680,1354 @@ var require_ignore = chunkEMMSS5I5_cjs.__commonJS({
         }
         return this._rules.test(path, false, MODE_CHECK_IGNORE);
       }
-      _t(path, cache, checkUnignored, slices) {
-        if (path in cache) {
-          return cache[path];
-        }
-        if (!slices) {
-          slices = path.split(SLASH).filter(Boolean);
-        }
-        slices.pop();
-        if (!slices.length) {
-          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// src/server/handlers/agent-builder.ts
+var agent_builder_exports = {};
+chunkO7I5CWRX_cjs.__export(agent_builder_exports, {
+  cancelAgentBuilderActionRunHandler: () => cancelAgentBuilderActionRunHandler,
+  createAgentBuilderActionRunHandler: () => createAgentBuilderActionRunHandler,
+  getAgentBuilderActionByIdHandler: () => getAgentBuilderActionByIdHandler,
+  getAgentBuilderActionRunByIdHandler: () => getAgentBuilderActionRunByIdHandler,
+  getAgentBuilderActionRunExecutionResultHandler: () => getAgentBuilderActionRunExecutionResultHandler,
+  getAgentBuilderActionRunsHandler: () => getAgentBuilderActionRunsHandler,
+  getAgentBuilderActionsHandler: () => getAgentBuilderActionsHandler,
+  resumeAgentBuilderActionHandler: () => resumeAgentBuilderActionHandler,
+  resumeAsyncAgentBuilderActionHandler: () => resumeAsyncAgentBuilderActionHandler,
+  sendAgentBuilderActionRunEventHandler: () => sendAgentBuilderActionRunEventHandler,
+  startAgentBuilderActionRunHandler: () => startAgentBuilderActionRunHandler,
+  startAsyncAgentBuilderActionHandler: () => startAsyncAgentBuilderActionHandler,
+  streamAgentBuilderActionHandler: () => streamAgentBuilderActionHandler,
+  streamVNextAgentBuilderActionHandler: () => streamVNextAgentBuilderActionHandler,
+  watchAgentBuilderActionHandler: () => watchAgentBuilderActionHandler
+});
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = 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",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name20, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name20],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+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("/");
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== zod.ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = 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, refs);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+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);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+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":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          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":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          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": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+      }
+    }
+  }
+  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) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    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] === "-" && source[i + 2]?.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;
+    }
+  }
+  return pattern;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+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(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object3 = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object3[object3[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object3[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
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(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;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  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;
+    }
+    let propOptional = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    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 {
+    return true;
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef(refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+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)
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+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) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+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], [])
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case zod.ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case zod.ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodUnion:
+    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case zod.ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case zod.ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodNaN:
+    case zod.ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef(refs);
+    case zod.ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case zod.ZodFirstPartyTypeKind.ZodFunction:
+    case zod.ZodFirstPartyTypeKind.ZodVoid:
+    case zod.ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)();
+  }
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(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 jsonSchema3 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema3) {
+    addMeta(def, refs, jsonSchema3);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema3, def, refs);
+    newItem.jsonSchema = jsonSchema3;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema3;
+  return jsonSchema3;
+}
+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(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema3) => {
+  if (def.description) {
+    jsonSchema3.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema3.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema3;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name21, schema2]) => ({
+    ...acc,
+    [name21]: parseDef(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name21]
+    }, true) ?? parseAnyDef(refs)
+  }), {}) : void 0;
+  const name20 = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef(schema._def, name20 === void 0 ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name20]
+  }, false) ?? parseAnyDef(refs);
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
         }
-        const parent = this._t(
-          slices.join(SLASH) + SLASH,
-          cache,
-          checkUnignored,
-          slices
-        );
-        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
-      }
-      ignores(path) {
-        return this._test(path, this._ignoreCache, false).ignored;
-      }
-      createFilter() {
-        return (path) => !this.ignores(path);
-      }
-      filter(paths) {
-        return makeArray(paths).filter(this.createFilter());
-      }
-      // @returns {TestResult}
-      test(path) {
-        return this._test(path, this._testCache, true);
-      }
-    };
-    var factory = (options) => new Ignore(options);
-    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
-    var setupWindows = () => {
-      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
-      checkPath.convert = makePosix;
-      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
-    };
-    if (
-      // Detect `process` so that it can run in browsers.
-      typeof process !== "undefined" && process.platform === "win32"
-    ) {
-      setupWindows();
+      };
     }
-    module.exports = factory;
-    factory.default = factory;
-    module.exports.isPathValid = isPathValid;
-    define(module.exports, Symbol.for("setupWindows"), setupWindows);
   }
-});
+  const combined = name20 === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name20
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name20]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
 
-// src/server/handlers/agent-builder.ts
-var agent_builder_exports = {};
-chunkEMMSS5I5_cjs.__export(agent_builder_exports, {
-  cancelAgentBuilderActionRunHandler: () => cancelAgentBuilderActionRunHandler,
-  createAgentBuilderActionRunHandler: () => createAgentBuilderActionRunHandler,
-  getAgentBuilderActionByIdHandler: () => getAgentBuilderActionByIdHandler,
-  getAgentBuilderActionRunByIdHandler: () => getAgentBuilderActionRunByIdHandler,
-  getAgentBuilderActionRunExecutionResultHandler: () => getAgentBuilderActionRunExecutionResultHandler,
-  getAgentBuilderActionRunsHandler: () => getAgentBuilderActionRunsHandler,
-  getAgentBuilderActionsHandler: () => getAgentBuilderActionsHandler,
-  resumeAgentBuilderActionHandler: () => resumeAgentBuilderActionHandler,
-  resumeAsyncAgentBuilderActionHandler: () => resumeAsyncAgentBuilderActionHandler,
-  sendAgentBuilderActionRunEventHandler: () => sendAgentBuilderActionRunEventHandler,
-  startAgentBuilderActionRunHandler: () => startAgentBuilderActionRunHandler,
-  startAsyncAgentBuilderActionHandler: () => startAsyncAgentBuilderActionHandler,
-  streamAgentBuilderActionHandler: () => streamAgentBuilderActionHandler,
-  streamVNextAgentBuilderActionHandler: () => streamVNextAgentBuilderActionHandler,
-  watchAgentBuilderActionHandler: () => watchAgentBuilderActionHandler
-});
-function zodToJsonSchema(zodSchema3, target = "jsonSchema7", strategy = "relative") {
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js
+var esm_default = zodToJsonSchema;
+
+// ../schema-compat/dist/chunk-GWTUXMDD.js
+function zodToJsonSchema2(zodSchema3, target = "jsonSchema7", strategy = "relative") {
   const fn = "toJSONSchema";
   if (fn in zod.z) {
     return zod.z[fn](zodSchema3, {
@@ -634,7 +2041,7 @@ function zodToJsonSchema(zodSchema3, target = "jsonSchema7", strategy = "relativ
       }
     });
   } else {
-    return chunkHVBBFCDH_cjs.esm_default(zodSchema3, {
+    return esm_default(zodSchema3, {
       $refStrategy: strategy,
       target
     });
@@ -960,11 +2367,11 @@ function parsePartialJson(jsonText) {
   if (jsonText === void 0) {
     return { value: void 0, state: "undefined-input" };
   }
-  let result = chunkSIGXR3JT_cjs.safeParseJSON({ text: jsonText });
+  let result = chunkLPM6BBAX_cjs.safeParseJSON({ text: jsonText });
   if (result.success) {
     return { value: result.value, state: "successful-parse" };
   }
-  result = chunkSIGXR3JT_cjs.safeParseJSON({ text: fixJson(jsonText) });
+  result = chunkLPM6BBAX_cjs.safeParseJSON({ text: fixJson(jsonText) });
   if (result.success) {
     return { value: result.value, state: "repaired-parse" };
   }
@@ -1234,10 +2641,10 @@ function formatDataStreamPart(type, value) {
 `;
 }
 function zodSchema(zodSchema22, options) {
-  var _a19;
-  const useReferences = (_a19 = void 0 ) != null ? _a19 : false;
+  var _a20;
+  const useReferences = (_a20 = void 0 ) != null ? _a20 : false;
   return jsonSchema(
-    chunkHVBBFCDH_cjs.esm_default(zodSchema22, {
+    esm_default(zodSchema22, {
       $refStrategy: useReferences ? "root" : "none",
       target: "jsonSchema7"
       // note: openai mode breaks various gemini conversions
@@ -1258,7 +2665,7 @@ function jsonSchema(jsonSchema22, {
     [schemaSymbol]: true,
     _type: void 0,
     // should never be used directly
-    [chunkSIGXR3JT_cjs.validatorSymbol]: true,
+    [chunkLPM6BBAX_cjs.validatorSymbol]: true,
     jsonSchema: jsonSchema22,
     validate
   };
@@ -1348,11 +2755,11 @@ var major = VERSION.split(".")[0];
 var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
 var _global = _globalThis;
 function registerGlobal(type, instance, diag, allowOverride) {
-  var _a19;
+  var _a20;
   if (allowOverride === void 0) {
     allowOverride = false;
   }
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a19 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a19 !== void 0 ? _a19 : {
+  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a20 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a20 !== void 0 ? _a20 : {
     version: VERSION
   };
   if (!allowOverride && api[type]) {
@@ -1370,8 +2777,8 @@ function registerGlobal(type, instance, diag, allowOverride) {
   return true;
 }
 function getGlobal(type) {
-  var _a19, _b8;
-  var globalVersion = (_a19 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a19 === void 0 ? void 0 : _a19.version;
+  var _a20, _b8;
+  var globalVersion = (_a20 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a20 === void 0 ? void 0 : _a20.version;
   if (!globalVersion || !isCompatible(globalVersion)) {
     return;
   }
@@ -1548,13 +2955,13 @@ var DiagAPI = (
       }
       var self = this;
       var setLogger = function(logger, optionsOrLogLevel) {
-        var _a19, _b8, _c;
+        var _a20, _b8, _c;
         if (optionsOrLogLevel === void 0) {
           optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
         }
         if (logger === self) {
           var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-          self.error((_a19 = err.stack) !== null && _a19 !== void 0 ? _a19 : err.message);
+          self.error((_a20 = err.stack) !== null && _a20 !== void 0 ? _a20 : err.message);
           return false;
         }
         if (typeof optionsOrLogLevel === "number") {
@@ -1725,12 +3132,12 @@ var ContextAPI = (
       return this._getContextManager().active();
     };
     ContextAPI2.prototype.with = function(context, fn, thisArg) {
-      var _a19;
+      var _a20;
       var args = [];
       for (var _i = 3; _i < arguments.length; _i++) {
         args[_i - 3] = arguments[_i];
       }
-      return (_a19 = this._getContextManager()).with.apply(_a19, __spreadArray4([context, fn, thisArg], __read4(args), false));
+      return (_a20 = this._getContextManager()).with.apply(_a20, __spreadArray4([context, fn, thisArg], __read4(args), false));
     };
     ContextAPI2.prototype.bind = function(context, target) {
       return this._getContextManager().bind(context, target);
@@ -1825,8 +3232,8 @@ function setSpanContext(context, spanContext) {
   return setSpan(context, new NonRecordingSpan(spanContext));
 }
 function getSpanContext(context) {
-  var _a19;
-  return (_a19 = getSpan(context)) === null || _a19 === void 0 ? void 0 : _a19.spanContext();
+  var _a20;
+  return (_a20 = getSpan(context)) === null || _a20 === void 0 ? void 0 : _a20.spanContext();
 }
 
 // ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
@@ -1852,7 +3259,7 @@ var NoopTracer = (
   (function() {
     function NoopTracer2() {
     }
-    NoopTracer2.prototype.startSpan = function(name19, options, context) {
+    NoopTracer2.prototype.startSpan = function(name20, options, context) {
       if (context === void 0) {
         context = contextApi.active();
       }
@@ -1867,7 +3274,7 @@ var NoopTracer = (
         return new NonRecordingSpan();
       }
     };
-    NoopTracer2.prototype.startActiveSpan = function(name19, arg2, arg3, arg4) {
+    NoopTracer2.prototype.startActiveSpan = function(name20, arg2, arg3, arg4) {
       var opts;
       var ctx;
       var fn;
@@ -1884,7 +3291,7 @@ var NoopTracer = (
         fn = arg4;
       }
       var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-      var span = this.startSpan(name19, opts, parentContext);
+      var span = this.startSpan(name20, opts, parentContext);
       var contextWithSpanSet = setSpan(parentContext, span);
       return contextApi.with(contextWithSpanSet, fn, void 0, span);
     };
@@ -1900,14 +3307,14 @@ var NOOP_TRACER = new NoopTracer();
 var ProxyTracer = (
   /** @class */
   (function() {
-    function ProxyTracer2(_provider, name19, version, options) {
+    function ProxyTracer2(_provider, name20, version, options) {
       this._provider = _provider;
-      this.name = name19;
+      this.name = name20;
       this.version = version;
       this.options = options;
     }
-    ProxyTracer2.prototype.startSpan = function(name19, options, context) {
-      return this._getTracer().startSpan(name19, options, context);
+    ProxyTracer2.prototype.startSpan = function(name20, options, context) {
+      return this._getTracer().startSpan(name20, options, context);
     };
     ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
       var tracer = this._getTracer();
@@ -1948,20 +3355,20 @@ var ProxyTracerProvider = (
   (function() {
     function ProxyTracerProvider2() {
     }
-    ProxyTracerProvider2.prototype.getTracer = function(name19, version, options) {
-      var _a19;
-      return (_a19 = this.getDelegateTracer(name19, version, options)) !== null && _a19 !== void 0 ? _a19 : new ProxyTracer(this, name19, version, options);
+    ProxyTracerProvider2.prototype.getTracer = function(name20, version, options) {
+      var _a20;
+      return (_a20 = this.getDelegateTracer(name20, version, options)) !== null && _a20 !== void 0 ? _a20 : new ProxyTracer(this, name20, version, options);
     };
     ProxyTracerProvider2.prototype.getDelegate = function() {
-      var _a19;
-      return (_a19 = this._delegate) !== null && _a19 !== void 0 ? _a19 : NOOP_TRACER_PROVIDER;
+      var _a20;
+      return (_a20 = this._delegate) !== null && _a20 !== void 0 ? _a20 : NOOP_TRACER_PROVIDER;
     };
     ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
       this._delegate = delegate;
     };
-    ProxyTracerProvider2.prototype.getDelegateTracer = function(name19, version, options) {
-      var _a19;
-      return (_a19 = this._delegate) === null || _a19 === void 0 ? void 0 : _a19.getTracer(name19, version, options);
+    ProxyTracerProvider2.prototype.getDelegateTracer = function(name20, version, options) {
+      var _a20;
+      return (_a20 = this._delegate) === null || _a20 === void 0 ? void 0 : _a20.getTracer(name20, version, options);
     };
     return ProxyTracerProvider2;
   })()
@@ -2007,8 +3414,8 @@ var TraceAPI = (
     TraceAPI2.prototype.getTracerProvider = function() {
       return getGlobal(API_NAME3) || this._proxyTracerProvider;
     };
-    TraceAPI2.prototype.getTracer = function(name19, version) {
-      return this.getTracerProvider().getTracer(name19, version);
+    TraceAPI2.prototype.getTracer = function(name20, version) {
+      return this.getTracerProvider().getTracer(name20, version);
     };
     TraceAPI2.prototype.disable = function() {
       unregisterGlobal(API_NAME3, DiagAPI.instance());
@@ -2038,7 +3445,7 @@ function prepareResponseHeaders(headers, {
   }
   return responseHeaders;
 }
-var UnsupportedModelVersionError = class extends chunkSIGXR3JT_cjs.AISDKError {
+var UnsupportedModelVersionError = class extends chunkLPM6BBAX_cjs.AISDKError {
   constructor() {
     super({
       name: "AI_UnsupportedModelVersionError",
@@ -2050,7 +3457,7 @@ var name = "AI_InvalidArgumentError";
 var marker = `vercel.ai.error.${name}`;
 var symbol = Symbol.for(marker);
 var _a;
-var InvalidArgumentError2 = class extends chunkSIGXR3JT_cjs.AISDKError {
+var InvalidArgumentError = class extends chunkLPM6BBAX_cjs.AISDKError {
   constructor({
     parameter,
     value,
@@ -2065,7 +3472,7 @@ var InvalidArgumentError2 = class extends chunkSIGXR3JT_cjs.AISDKError {
     this.value = value;
   }
   static isInstance(error) {
-    return chunkSIGXR3JT_cjs.AISDKError.hasMarker(error, marker);
+    return chunkLPM6BBAX_cjs.AISDKError.hasMarker(error, marker);
   }
 };
 _a = symbol;
@@ -2073,7 +3480,7 @@ var name2 = "AI_RetryError";
 var marker2 = `vercel.ai.error.${name2}`;
 var symbol2 = Symbol.for(marker2);
 var _a2;
-var RetryError = class extends chunkSIGXR3JT_cjs.AISDKError {
+var RetryError = class extends chunkLPM6BBAX_cjs.AISDKError {
   constructor({
     message,
     reason,
@@ -2086,7 +3493,7 @@ var RetryError = class extends chunkSIGXR3JT_cjs.AISDKError {
     this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return chunkSIGXR3JT_cjs.AISDKError.hasMarker(error, marker2);
+    return chunkLPM6BBAX_cjs.AISDKError.hasMarker(error, marker2);
   }
 };
 _a2 = symbol2;
@@ -2107,13 +3514,13 @@ async function _retryWithExponentialBackoff(f, {
   try {
     return await f();
   } catch (error) {
-    if (chunkSIGXR3JT_cjs.isAbortError(error)) {
+    if (chunkLPM6BBAX_cjs.isAbortError(error)) {
       throw error;
     }
     if (maxRetries === 0) {
       throw error;
     }
-    const errorMessage = chunkSIGXR3JT_cjs.getErrorMessage(error);
+    const errorMessage = chunkLPM6BBAX_cjs.getErrorMessage(error);
     const newErrors = [...errors, error];
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
@@ -2123,8 +3530,8 @@ async function _retryWithExponentialBackoff(f, {
         errors: newErrors
       });
     }
-    if (error instanceof Error && chunkSIGXR3JT_cjs.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await chunkSIGXR3JT_cjs.delay(delayInMs);
+    if (error instanceof Error && chunkLPM6BBAX_cjs.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await chunkLPM6BBAX_cjs.delay(delayInMs);
       return _retryWithExponentialBackoff(
         f,
         { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
@@ -2146,14 +3553,14 @@ function prepareRetries({
 }) {
   if (maxRetries != null) {
     if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError({
         parameter: "maxRetries",
         value: maxRetries,
         message: "maxRetries must be an integer"
       });
     }
     if (maxRetries < 0) {
-      throw new InvalidArgumentError2({
+      throw new InvalidArgumentError({
         parameter: "maxRetries",
         value: maxRetries,
         message: "maxRetries must be >= 0"
@@ -2526,7 +3933,7 @@ var name4 = "AI_NoObjectGeneratedError";
 var marker4 = `vercel.ai.error.${name4}`;
 var symbol4 = Symbol.for(marker4);
 var _a4;
-var NoObjectGeneratedError = class extends chunkSIGXR3JT_cjs.AISDKError {
+var NoObjectGeneratedError = class extends chunkLPM6BBAX_cjs.AISDKError {
   constructor({
     message = "No object generated.",
     cause,
@@ -2543,7 +3950,7 @@ var NoObjectGeneratedError = class extends chunkSIGXR3JT_cjs.AISDKError {
     this.finishReason = finishReason;
   }
   static isInstance(error) {
-    return chunkSIGXR3JT_cjs.AISDKError.hasMarker(error, marker4);
+    return chunkLPM6BBAX_cjs.AISDKError.hasMarker(error, marker4);
   }
 };
 _a4 = symbol4;
@@ -2697,13 +4104,13 @@ function injectJsonInstruction({
     schemaSuffix
   ].filter((line) => line != null).join("\n");
 }
-chunkSIGXR3JT_cjs.createIdGenerator({ prefix: "aiobj", size: 24 });
-chunkSIGXR3JT_cjs.createIdGenerator({ prefix: "aiobj", size: 24 });
-chunkSIGXR3JT_cjs.createIdGenerator({
+chunkLPM6BBAX_cjs.createIdGenerator({ prefix: "aiobj", size: 24 });
+chunkLPM6BBAX_cjs.createIdGenerator({ prefix: "aiobj", size: 24 });
+chunkLPM6BBAX_cjs.createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
-chunkSIGXR3JT_cjs.createIdGenerator({
+chunkLPM6BBAX_cjs.createIdGenerator({
   prefix: "msg",
   size: 24
 });
@@ -2760,7 +4167,7 @@ var object = ({
       }
     },
     parseOutput({ text: text22 }, context) {
-      const parseResult = chunkSIGXR3JT_cjs.safeParseJSON({ text: text22 });
+      const parseResult = chunkLPM6BBAX_cjs.safeParseJSON({ text: text22 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -2771,7 +4178,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = chunkSIGXR3JT_cjs.safeValidateTypes({
+      const validationResult = chunkLPM6BBAX_cjs.safeValidateTypes({
         value: parseResult.value,
         schema
       });
@@ -2875,11 +4282,11 @@ function mergeStreams(stream1, stream2) {
     }
   });
 }
-chunkSIGXR3JT_cjs.createIdGenerator({
+chunkLPM6BBAX_cjs.createIdGenerator({
   prefix: "aitxt",
   size: 24
 });
-chunkSIGXR3JT_cjs.createIdGenerator({
+chunkLPM6BBAX_cjs.createIdGenerator({
   prefix: "msg",
   size: 24
 });
@@ -3115,7 +4522,7 @@ __export2(llamaindex_adapter_exports, {
 });
 function toDataStreamInternal2(stream, callbacks) {
   const trimStart = trimStartOfStream();
-  return chunkSIGXR3JT_cjs.convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
+  return chunkLPM6BBAX_cjs.convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
     new TransformStream({
       async transform(message, controller) {
         controller.enqueue(trimStart(message.delta));
@@ -3161,9 +4568,334 @@ function trimStartOfStream() {
       if (text22)
         isStreamStart = false;
     }
-    return text22;
-  };
+    return text22;
+  };
+}
+
+// ../../node_modules/.pnpm/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker17 = "vercel.ai.error";
+var symbol17 = Symbol.for(marker17);
+var _a17;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * 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[_a17] = 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 _AISDKError2.hasMarker(error, marker17);
+  }
+  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;
+  }
+};
+_a17 = symbol17;
+var AISDKError2 = _AISDKError;
+var name17 = "AI_APICallError";
+var marker22 = `vercel.ai.error.${name17}`;
+var symbol22 = Symbol.for(marker22);
+var _a22;
+var APICallError2 = class extends AISDKError2 {
+  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: name17, message, cause });
+    this[_a22] = 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 AISDKError2.hasMarker(error, marker22);
+  }
+};
+_a22 = symbol22;
+var name22 = "AI_EmptyResponseBodyError";
+var marker32 = `vercel.ai.error.${name22}`;
+var symbol32 = Symbol.for(marker32);
+var _a32;
+var EmptyResponseBodyError = class extends AISDKError2 {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name22, message });
+    this[_a32] = true;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker32);
+  }
+};
+_a32 = symbol32;
+function getErrorMessage2(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 name32 = "AI_InvalidArgumentError";
+var marker42 = `vercel.ai.error.${name32}`;
+var symbol42 = Symbol.for(marker42);
+var _a42;
+var InvalidArgumentError2 = class extends AISDKError2 {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name32, message, cause });
+    this[_a42] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker42);
+  }
+};
+_a42 = symbol42;
+var name62 = "AI_JSONParseError";
+var marker72 = `vercel.ai.error.${name62}`;
+var symbol72 = Symbol.for(marker72);
+var _a72;
+var JSONParseError = class extends AISDKError2 {
+  constructor({ text: text3, cause }) {
+    super({
+      name: name62,
+      message: `JSON parsing failed: Text: ${text3}.
+Error message: ${getErrorMessage2(cause)}`,
+      cause
+    });
+    this[_a72] = true;
+    this.text = text3;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker72);
+  }
+};
+_a72 = symbol72;
+var name102 = "AI_NoSuchModelError";
+var marker112 = `vercel.ai.error.${name102}`;
+var symbol112 = Symbol.for(marker112);
+var _a112;
+var NoSuchModelError = class extends AISDKError2 {
+  constructor({
+    errorName = name102,
+    modelId,
+    modelType,
+    message = `No such ${modelType}: ${modelId}`
+  }) {
+    super({ name: errorName, message });
+    this[_a112] = true;
+    this.modelId = modelId;
+    this.modelType = modelType;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker112);
+  }
+};
+_a112 = symbol112;
+var name122 = "AI_TypeValidationError";
+var marker132 = `vercel.ai.error.${name122}`;
+var symbol132 = Symbol.for(marker132);
+var _a132;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError2 {
+  constructor({ value, cause }) {
+    super({
+      name: name122,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage2(cause)}`,
+      cause
+    });
+    this[_a132] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker132);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, 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.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a132 = symbol132;
+var TypeValidationError = _TypeValidationError;
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.6/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;
+  }
+};
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        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() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
 }
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => ({
@@ -3205,11 +4937,11 @@ function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
 function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
-  var _a19, _b8, _c;
+  var _a20, _b8, _c;
   if (globalThisAny.window) {
     return `runtime/browser`;
   }
-  if ((_a19 = globalThisAny.navigator) == null ? void 0 : _a19.userAgent) {
+  if ((_a20 = globalThisAny.navigator) == null ? void 0 : _a20.userAgent) {
     return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
   }
   if ((_c = (_b8 = globalThisAny.process) == null ? void 0 : _b8.versions) == null ? void 0 : _c.node) {
@@ -3255,7 +4987,7 @@ var createIdGenerator2 = ({
     return generator;
   }
   if (alphabet.includes(separator)) {
-    throw new chunkHVBBFCDH_cjs.InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "separator",
       message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
     });
@@ -3263,7 +4995,7 @@ var createIdGenerator2 = ({
   return () => `${prefix}${separator}${generator()}`;
 };
 createIdGenerator2();
-function getErrorMessage2(error) {
+function getErrorMessage3(error) {
   if (error == null) {
     return "unknown error";
   }
@@ -3291,7 +5023,7 @@ function handleFetchError({
   if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
     const cause = error.cause;
     if (cause != null) {
-      return new chunkHVBBFCDH_cjs.APICallError({
+      return new APICallError2({
         message: `Cannot connect to API: ${cause.message}`,
         cause,
         url,
@@ -3303,7 +5035,7 @@ function handleFetchError({
   }
   return error;
 }
-var VERSION2 = "3.0.9" ;
+var VERSION2 = "3.0.10" ;
 var getOriginalFetch = () => globalThis.fetch;
 var getFromApi = async ({
   url,
@@ -3333,10 +5065,10 @@ var getFromApi = async ({
           requestBodyValues: {}
         });
       } catch (error) {
-        if (isAbortError2(error) || chunkHVBBFCDH_cjs.APICallError.isInstance(error)) {
+        if (isAbortError2(error) || APICallError2.isInstance(error)) {
           throw error;
         }
-        throw new chunkHVBBFCDH_cjs.APICallError({
+        throw new APICallError2({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -3355,11 +5087,11 @@ var getFromApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError2(error) || chunkHVBBFCDH_cjs.APICallError.isInstance(error)) {
+        if (isAbortError2(error) || APICallError2.isInstance(error)) {
           throw error;
         }
       }
-      throw new chunkHVBBFCDH_cjs.APICallError({
+      throw new APICallError2({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -3446,7 +5178,7 @@ function standardSchemaValidator(standardSchema) {
     const result = await standardSchema["~standard"].validate(value);
     return result.issues == null ? { success: true, value: result.value } : {
       success: false,
-      error: new chunkHVBBFCDH_cjs.TypeValidationError({
+      error: new TypeValidationError({
         value,
         cause: result.issues
       })
@@ -3459,7 +5191,7 @@ async function validateTypes({
 }) {
   const result = await safeValidateTypes2({ value, schema });
   if (!result.success) {
-    throw chunkHVBBFCDH_cjs.TypeValidationError.wrap({ value, cause: result.error });
+    throw TypeValidationError.wrap({ value, cause: result.error });
   }
   return result.value;
 }
@@ -3478,13 +5210,13 @@ async function safeValidateTypes2({
     }
     return {
       success: false,
-      error: chunkHVBBFCDH_cjs.TypeValidationError.wrap({ value, cause: result.error }),
+      error: TypeValidationError.wrap({ value, cause: result.error }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: chunkHVBBFCDH_cjs.TypeValidationError.wrap({ value, cause: error }),
+      error: TypeValidationError.wrap({ value, cause: error }),
       rawValue: value
     };
   }
@@ -3500,10 +5232,10 @@ async function parseJSON({
     }
     return validateTypes({ value, schema });
   } catch (error) {
-    if (chunkHVBBFCDH_cjs.JSONParseError.isInstance(error) || chunkHVBBFCDH_cjs.TypeValidationError.isInstance(error)) {
+    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
       throw error;
     }
-    throw new chunkHVBBFCDH_cjs.JSONParseError({ text: text3, cause: error });
+    throw new JSONParseError({ text: text3, cause: error });
   }
 }
 async function safeParseJSON2({
@@ -3519,7 +5251,7 @@ async function safeParseJSON2({
   } catch (error) {
     return {
       success: false,
-      error: chunkHVBBFCDH_cjs.JSONParseError.isInstance(error) ? error : new chunkHVBBFCDH_cjs.JSONParseError({ text: text3, cause: error }),
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text: text3, cause: error }),
       rawValue: void 0
     };
   }
@@ -3528,7 +5260,7 @@ function parseJsonEventStream({
   stream,
   schema
 }) {
-  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new chunkHVBBFCDH_cjs.EventSourceParserStream()).pipeThrough(
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
     new TransformStream({
       async transform({ data }, controller) {
         if (data === "[DONE]") {
@@ -3593,10 +5325,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError2(error) || chunkHVBBFCDH_cjs.APICallError.isInstance(error)) {
+        if (isAbortError2(error) || APICallError2.isInstance(error)) {
           throw error;
         }
-        throw new chunkHVBBFCDH_cjs.APICallError({
+        throw new APICallError2({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -3615,11 +5347,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError2(error) || chunkHVBBFCDH_cjs.APICallError.isInstance(error)) {
+        if (isAbortError2(error) || APICallError2.isInstance(error)) {
           throw error;
         }
       }
-      throw new chunkHVBBFCDH_cjs.APICallError({
+      throw new APICallError2({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -3648,7 +5380,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new chunkHVBBFCDH_cjs.APICallError({
+      value: new APICallError2({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -3666,7 +5398,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new chunkHVBBFCDH_cjs.APICallError({
+      value: new APICallError2({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -3680,7 +5412,7 @@ var createJsonErrorResponseHandler = ({
   } catch (parseError) {
     return {
       responseHeaders,
-      value: new chunkHVBBFCDH_cjs.APICallError({
+      value: new APICallError2({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -3695,7 +5427,7 @@ var createJsonErrorResponseHandler = ({
 var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new chunkHVBBFCDH_cjs.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
@@ -3713,7 +5445,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new chunkHVBBFCDH_cjs.APICallError({
+    throw new APICallError2({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -3729,7 +5461,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
-var getRelativePath = (pathA, pathB) => {
+var getRelativePath2 = (pathA, pathB) => {
   let i = 0;
   for (; i < pathA.length && i < pathB.length; i++) {
     if (pathA[i] !== pathB[i])
@@ -3737,10 +5469,10 @@ var getRelativePath = (pathA, pathB) => {
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
-var ignoreOverride = Symbol(
+var ignoreOverride2 = Symbol(
   "Let zodToJsonSchema decide on which parser to use"
 );
-var defaultOptions = {
+var defaultOptions2 = {
   name: void 0,
   $refStrategy: "root",
   basePath: ["#"],
@@ -3761,23 +5493,23 @@ var defaultOptions = {
   base64Strategy: "contentEncoding:base64",
   nameStrategy: "ref"
 };
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
+var getDefaultOptions2 = (options) => typeof options === "string" ? {
+  ...defaultOptions2,
   name: options
 } : {
-  ...defaultOptions,
+  ...defaultOptions2,
   ...options
 };
-function parseAnyDef() {
+function parseAnyDef2() {
   return {};
 }
-function parseArrayDef(def, refs) {
-  var _a19, _b8, _c;
+function parseArrayDef2(def, refs) {
+  var _a20, _b8, _c;
   const res = {
     type: "array"
   };
-  if (((_a19 = def.type) == null ? void 0 : _a19._def) && ((_c = (_b8 = def.type) == null ? void 0 : _b8._def) == null ? void 0 : _c.typeName) !== v3.ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
+  if (((_a20 = def.type) == null ? void 0 : _a20._def) && ((_c = (_b8 = def.type) == null ? void 0 : _b8._def) == null ? void 0 : _c.typeName) !== v3.ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef2(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
     });
@@ -3794,7 +5526,7 @@ function parseArrayDef(def, refs) {
   }
   return res;
 }
-function parseBigintDef(def) {
+function parseBigintDef2(def) {
   const res = {
     type: "integer",
     format: "int64"
@@ -3824,20 +5556,20 @@ function parseBigintDef(def) {
   }
   return res;
 }
-function parseBooleanDef() {
+function parseBooleanDef2() {
   return { type: "boolean" };
 }
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
+function parseBrandedDef2(_def, refs) {
+  return parseDef2(_def.type._def, refs);
 }
-var parseCatchDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
+var parseCatchDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
 };
-function parseDateDef(def, refs, overrideDateStrategy) {
+function parseDateDef2(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+      anyOf: strategy.map((item, i) => parseDateDef2(def, refs, item))
     };
   }
   switch (strategy) {
@@ -3853,10 +5585,10 @@ function parseDateDef(def, refs, overrideDateStrategy) {
         format: "date"
       };
     case "integer":
-      return integerDateParser(def);
+      return integerDateParser2(def);
   }
 }
-var integerDateParser = (def) => {
+var integerDateParser2 = (def) => {
   const res = {
     type: "integer",
     format: "unix-time"
@@ -3873,40 +5605,40 @@ var integerDateParser = (def) => {
   }
   return res;
 };
-function parseDefaultDef(_def, refs) {
+function parseDefaultDef2(_def, refs) {
   return {
-    ...parseDef(_def.innerType._def, refs),
+    ...parseDef2(_def.innerType._def, refs),
     default: _def.defaultValue()
   };
 }
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
+function parseEffectsDef2(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef2(_def.schema._def, refs) : parseAnyDef2();
 }
-function parseEnumDef(def) {
+function parseEnumDef2(def) {
   return {
     type: "string",
     enum: Array.from(def.values)
   };
 }
-var isJsonSchema7AllOfType = (type) => {
+var isJsonSchema7AllOfType2 = (type) => {
   if ("type" in type && type.type === "string")
     return false;
   return "allOf" in type;
 };
-function parseIntersectionDef(def, refs) {
+function parseIntersectionDef2(def, refs) {
   const allOf = [
-    parseDef(def.left._def, {
+    parseDef2(def.left._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "0"]
     }),
-    parseDef(def.right._def, {
+    parseDef2(def.right._def, {
       ...refs,
       currentPath: [...refs.currentPath, "allOf", "1"]
     })
   ].filter((x) => !!x);
   const mergedAllOf = [];
   allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
+    if (isJsonSchema7AllOfType2(schema)) {
       mergedAllOf.push(...schema.allOf);
     } else {
       let nestedSchema = schema;
@@ -3919,7 +5651,7 @@ function parseIntersectionDef(def, refs) {
   });
   return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
 }
-function parseLiteralDef(def) {
+function parseLiteralDef2(def) {
   const parsedType = typeof def.value;
   if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
     return {
@@ -3931,8 +5663,8 @@ function parseLiteralDef(def) {
     const: def.value
   };
 }
-var emojiRegex = void 0;
-var zodPatterns = {
+var emojiRegex2 = void 0;
+var zodPatterns2 = {
   /**
    * `c` was changed to `[cC]` to replicate /i flag
    */
@@ -3955,13 +5687,13 @@ var zodPatterns = {
    * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
    */
   emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp(
+    if (emojiRegex2 === void 0) {
+      emojiRegex2 = RegExp(
         "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
         "u"
       );
     }
-    return emojiRegex;
+    return emojiRegex2;
   },
   /**
    * Unused
@@ -3982,7 +5714,7 @@ var zodPatterns = {
   nanoid: /^[a-zA-Z0-9_-]{21}$/,
   jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
 };
-function parseStringDef(def, refs) {
+function parseStringDef2(def, refs) {
   const res = {
     type: "string"
   };
@@ -3998,67 +5730,67 @@ function parseStringDef(def, refs) {
         case "email":
           switch (refs.emailStrategy) {
             case "format:email":
-              addFormat(res, "email", check.message, refs);
+              addFormat2(res, "email", check.message, refs);
               break;
             case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
+              addFormat2(res, "idn-email", check.message, refs);
               break;
             case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
+              addPattern2(res, zodPatterns2.email, check.message, refs);
               break;
           }
           break;
         case "url":
-          addFormat(res, "uri", check.message, refs);
+          addFormat2(res, "uri", check.message, refs);
           break;
         case "uuid":
-          addFormat(res, "uuid", check.message, refs);
+          addFormat2(res, "uuid", check.message, refs);
           break;
         case "regex":
-          addPattern(res, check.regex, check.message, refs);
+          addPattern2(res, check.regex, check.message, refs);
           break;
         case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
+          addPattern2(res, zodPatterns2.cuid, check.message, refs);
           break;
         case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          addPattern2(res, zodPatterns2.cuid2, check.message, refs);
           break;
         case "startsWith":
-          addPattern(
+          addPattern2(
             res,
-            RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
+            RegExp(`^${escapeLiteralCheckValue2(check.value, refs)}`),
             check.message,
             refs
           );
           break;
         case "endsWith":
-          addPattern(
+          addPattern2(
             res,
-            RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
+            RegExp(`${escapeLiteralCheckValue2(check.value, refs)}$`),
             check.message,
             refs
           );
           break;
         case "datetime":
-          addFormat(res, "date-time", check.message, refs);
+          addFormat2(res, "date-time", check.message, refs);
           break;
         case "date":
-          addFormat(res, "date", check.message, refs);
+          addFormat2(res, "date", check.message, refs);
           break;
         case "time":
-          addFormat(res, "time", check.message, refs);
+          addFormat2(res, "time", check.message, refs);
           break;
         case "duration":
-          addFormat(res, "duration", check.message, refs);
+          addFormat2(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(
+          addPattern2(
             res,
-            RegExp(escapeLiteralCheckValue(check.value, refs)),
+            RegExp(escapeLiteralCheckValue2(check.value, refs)),
             check.message,
             refs
           );
@@ -4066,39 +5798,39 @@ function parseStringDef(def, refs) {
         }
         case "ip": {
           if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
+            addFormat2(res, "ipv4", check.message, refs);
           }
           if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
+            addFormat2(res, "ipv6", check.message, refs);
           }
           break;
         }
         case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
+          addPattern2(res, zodPatterns2.base64url, check.message, refs);
           break;
         case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
+          addPattern2(res, zodPatterns2.jwt, check.message, refs);
           break;
         case "cidr": {
           if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+            addPattern2(res, zodPatterns2.ipv4Cidr, check.message, refs);
           }
           if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+            addPattern2(res, zodPatterns2.ipv6Cidr, check.message, refs);
           }
           break;
         }
         case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          addPattern2(res, zodPatterns2.emoji(), check.message, refs);
           break;
         case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
+          addPattern2(res, zodPatterns2.ulid, check.message, refs);
           break;
         }
         case "base64": {
           switch (refs.base64Strategy) {
             case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
+              addFormat2(res, "binary", check.message, refs);
               break;
             }
             case "contentEncoding:base64": {
@@ -4106,39 +5838,39 @@ function parseStringDef(def, refs) {
               break;
             }
             case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
+              addPattern2(res, zodPatterns2.base64, check.message, refs);
               break;
             }
           }
           break;
         }
         case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
+          addPattern2(res, zodPatterns2.nanoid, check.message, refs);
         }
       }
     }
   }
   return res;
 }
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+function escapeLiteralCheckValue2(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric2(literal) : literal;
 }
-var ALPHA_NUMERIC = new Set(
+var ALPHA_NUMERIC2 = new Set(
   "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
 );
-function escapeNonAlphaNumeric(source) {
+function escapeNonAlphaNumeric2(source) {
   let result = "";
   for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC.has(source[i])) {
+    if (!ALPHA_NUMERIC2.has(source[i])) {
       result += "\\";
     }
     result += source[i];
   }
   return result;
 }
-function addFormat(schema, value, message, refs) {
-  var _a19;
-  if (schema.format || ((_a19 = schema.anyOf) == null ? void 0 : _a19.some((x) => x.format))) {
+function addFormat2(schema, value, message, refs) {
+  var _a20;
+  if (schema.format || ((_a20 = schema.anyOf) == null ? void 0 : _a20.some((x) => x.format))) {
     if (!schema.anyOf) {
       schema.anyOf = [];
     }
@@ -4156,9 +5888,9 @@ function addFormat(schema, value, message, refs) {
     schema.format = value;
   }
 }
-function addPattern(schema, regex, message, refs) {
-  var _a19;
-  if (schema.pattern || ((_a19 = schema.allOf) == null ? void 0 : _a19.some((x) => x.pattern))) {
+function addPattern2(schema, regex, message, refs) {
+  var _a20;
+  if (schema.pattern || ((_a20 = schema.allOf) == null ? void 0 : _a20.some((x) => x.pattern))) {
     if (!schema.allOf) {
       schema.allOf = [];
     }
@@ -4169,15 +5901,15 @@ function addPattern(schema, regex, message, refs) {
       delete schema.pattern;
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
+      pattern: stringifyRegExpWithFlags2(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+    schema.pattern = stringifyRegExpWithFlags2(regex, refs);
   }
 }
-function stringifyRegExpWithFlags(regex, refs) {
-  var _a19;
+function stringifyRegExpWithFlags2(regex, refs) {
+  var _a20;
   if (!refs.applyRegexFlags || !regex.flags) {
     return regex.source;
   }
@@ -4207,7 +5939,7 @@ function stringifyRegExpWithFlags(regex, refs) {
             pattern += source[i];
             pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
             inCharRange = false;
-          } else if (source[i + 1] === "-" && ((_a19 = source[i + 2]) == null ? void 0 : _a19.match(/[a-z]/))) {
+          } else if (source[i + 1] === "-" && ((_a20 = source[i + 2]) == null ? void 0 : _a20.match(/[a-z]/))) {
             pattern += source[i];
             inCharRange = true;
           } else {
@@ -4248,17 +5980,17 @@ function stringifyRegExpWithFlags(regex, refs) {
   }
   return pattern;
 }
-function parseRecordDef(def, refs) {
-  var _a19, _b8, _c, _d, _e, _f;
+function parseRecordDef2(def, refs) {
+  var _a20, _b8, _c, _d, _e, _f;
   const schema = {
     type: "object",
-    additionalProperties: (_a19 = parseDef(def.valueType._def, {
+    additionalProperties: (_a20 = parseDef2(def.valueType._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
-    })) != null ? _a19 : refs.allowedAdditionalProperties
+    })) != null ? _a20 : refs.allowedAdditionalProperties
   };
   if (((_b8 = def.keyType) == null ? void 0 : _b8._def.typeName) === v3.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    const { type, ...keyType } = parseStringDef2(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
@@ -4271,7 +6003,7 @@ function parseRecordDef(def, refs) {
       }
     };
   } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === v3.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === v3.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef(
+    const { type, ...keyType } = parseBrandedDef2(
       def.keyType._def,
       refs
     );
@@ -4282,18 +6014,18 @@ function parseRecordDef(def, refs) {
   }
   return schema;
 }
-function parseMapDef(def, refs) {
+function parseMapDef2(def, refs) {
   if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
+    return parseRecordDef2(def, refs);
   }
-  const keys = parseDef(def.keyType._def, {
+  const keys = parseDef2(def.keyType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef();
-  const values = parseDef(def.valueType._def, {
+  }) || parseAnyDef2();
+  const values = parseDef2(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef();
+  }) || parseAnyDef2();
   return {
     type: "array",
     maxItems: 125,
@@ -4305,7 +6037,7 @@ function parseMapDef(def, refs) {
     }
   };
 }
-function parseNativeEnumDef(def) {
+function parseNativeEnumDef2(def) {
   const object3 = def.values;
   const actualKeys = Object.keys(def.values).filter((key) => {
     return typeof object3[object3[key]] !== "number";
@@ -4319,28 +6051,28 @@ function parseNativeEnumDef(def) {
     enum: actualValues
   };
 }
-function parseNeverDef() {
-  return { not: parseAnyDef() };
+function parseNeverDef2() {
+  return { not: parseAnyDef2() };
 }
-function parseNullDef() {
+function parseNullDef2() {
   return {
     type: "null"
   };
 }
-var primitiveMappings = {
+var primitiveMappings2 = {
   ZodString: "string",
   ZodNumber: "number",
   ZodBigInt: "integer",
   ZodBoolean: "boolean",
   ZodNull: "null"
 };
-function parseUnionDef(def, refs) {
+function parseUnionDef2(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)
+    (x) => x._def.typeName in primitiveMappings2 && (!x._def.checks || !x._def.checks.length)
   )) {
     const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
+      const type = primitiveMappings2[x._def.typeName];
       return type && !types2.includes(type) ? [...types2, type] : types2;
     }, []);
     return {
@@ -4393,11 +6125,11 @@ function parseUnionDef(def, refs) {
       )
     };
   }
-  return asAnyOf(def, refs);
+  return asAnyOf2(def, refs);
 }
-var asAnyOf = (def, refs) => {
+var asAnyOf2 = (def, refs) => {
   const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
-    (x, i) => parseDef(x._def, {
+    (x, i) => parseDef2(x._def, {
       ...refs,
       currentPath: [...refs.currentPath, "anyOf", `${i}`]
     })
@@ -4406,24 +6138,24 @@ var asAnyOf = (def, refs) => {
   );
   return anyOf.length ? { anyOf } : void 0;
 };
-function parseNullableDef(def, refs) {
+function parseNullableDef2(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],
+        primitiveMappings2[def.innerType._def.typeName],
         "null"
       ]
     };
   }
-  const base = parseDef(def.innerType._def, {
+  const base = parseDef2(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "0"]
   });
   return base && { anyOf: [base, { type: "null" }] };
 }
-function parseNumberDef(def) {
+function parseNumberDef2(def) {
   const res = {
     type: "number"
   };
@@ -4455,7 +6187,7 @@ function parseNumberDef(def) {
   }
   return res;
 }
-function parseObjectDef(def, refs) {
+function parseObjectDef2(def, refs) {
   const result = {
     type: "object",
     properties: {}
@@ -4467,8 +6199,8 @@ function parseObjectDef(def, refs) {
     if (propDef === void 0 || propDef._def === void 0) {
       continue;
     }
-    const propOptional = safeIsOptional(propDef);
-    const parsedDef = parseDef(propDef._def, {
+    const propOptional = safeIsOptional2(propDef);
+    const parsedDef = parseDef2(propDef._def, {
       ...refs,
       currentPath: [...refs.currentPath, "properties", propName],
       propertyPath: [...refs.currentPath, "properties", propName]
@@ -4484,15 +6216,15 @@ function parseObjectDef(def, refs) {
   if (required.length) {
     result.required = required;
   }
-  const additionalProperties = decideAdditionalProperties(def, refs);
+  const additionalProperties = decideAdditionalProperties2(def, refs);
   if (additionalProperties !== void 0) {
     result.additionalProperties = additionalProperties;
   }
   return result;
 }
-function decideAdditionalProperties(def, refs) {
+function decideAdditionalProperties2(def, refs) {
   if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
+    return parseDef2(def.catchall._def, {
       ...refs,
       currentPath: [...refs.currentPath, "additionalProperties"]
     });
@@ -4506,35 +6238,35 @@ function decideAdditionalProperties(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional(schema) {
+function safeIsOptional2(schema) {
   try {
     return schema.isOptional();
   } catch (e2) {
     return true;
   }
 }
-var parseOptionalDef = (def, refs) => {
-  var _a19;
-  if (refs.currentPath.toString() === ((_a19 = refs.propertyPath) == null ? void 0 : _a19.toString())) {
-    return parseDef(def.innerType._def, refs);
+var parseOptionalDef2 = (def, refs) => {
+  var _a20;
+  if (refs.currentPath.toString() === ((_a20 = refs.propertyPath) == null ? void 0 : _a20.toString())) {
+    return parseDef2(def.innerType._def, refs);
   }
-  const innerSchema = parseDef(def.innerType._def, {
+  const innerSchema = parseDef2(def.innerType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "anyOf", "1"]
   });
-  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
+  return innerSchema ? { anyOf: [{ not: parseAnyDef2() }, innerSchema] } : parseAnyDef2();
 };
-var parsePipelineDef = (def, refs) => {
+var parsePipelineDef2 = (def, refs) => {
   if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
+    return parseDef2(def.in._def, refs);
   } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
+    return parseDef2(def.out._def, refs);
   }
-  const a = parseDef(def.in._def, {
+  const a = parseDef2(def.in._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", "0"]
   });
-  const b = parseDef(def.out._def, {
+  const b = parseDef2(def.out._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
   });
@@ -4542,11 +6274,11 @@ var parsePipelineDef = (def, refs) => {
     allOf: [a, b].filter((x) => x !== void 0)
   };
 };
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
+function parsePromiseDef2(def, refs) {
+  return parseDef2(def.type._def, refs);
 }
-function parseSetDef(def, refs) {
-  const items = parseDef(def.valueType._def, {
+function parseSetDef2(def, refs) {
+  const items = parseDef2(def.valueType._def, {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
@@ -4563,13 +6295,13 @@ function parseSetDef(def, refs) {
   }
   return schema;
 }
-function parseTupleDef(def, refs) {
+function parseTupleDef2(def, refs) {
   if (def.rest) {
     return {
       type: "array",
       minItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef(x._def, {
+        (x, i) => parseDef2(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -4577,7 +6309,7 @@ function parseTupleDef(def, refs) {
         (acc, x) => x === void 0 ? acc : [...acc, x],
         []
       ),
-      additionalItems: parseDef(def.rest._def, {
+      additionalItems: parseDef2(def.rest._def, {
         ...refs,
         currentPath: [...refs.currentPath, "additionalItems"]
       })
@@ -4588,7 +6320,7 @@ function parseTupleDef(def, refs) {
       minItems: def.items.length,
       maxItems: def.items.length,
       items: def.items.map(
-        (x, i) => parseDef(x._def, {
+        (x, i) => parseDef2(x._def, {
           ...refs,
           currentPath: [...refs.currentPath, "items", `${i}`]
         })
@@ -4599,83 +6331,83 @@ function parseTupleDef(def, refs) {
     };
   }
 }
-function parseUndefinedDef() {
+function parseUndefinedDef2() {
   return {
-    not: parseAnyDef()
+    not: parseAnyDef2()
   };
 }
-function parseUnknownDef() {
-  return parseAnyDef();
+function parseUnknownDef2() {
+  return parseAnyDef2();
 }
-var parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
+var parseReadonlyDef2 = (def, refs) => {
+  return parseDef2(def.innerType._def, refs);
 };
-var selectParser = (def, typeName, refs) => {
+var selectParser2 = (def, typeName, refs) => {
   switch (typeName) {
     case v3.ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
+      return parseStringDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def);
+      return parseNumberDef2(def);
     case v3.ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
+      return parseObjectDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def);
+      return parseBigintDef2(def);
     case v3.ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
+      return parseBooleanDef2();
     case v3.ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
+      return parseDateDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
+      return parseUndefinedDef2();
     case v3.ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef();
+      return parseNullDef2();
     case v3.ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
+      return parseArrayDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodUnion:
     case v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
+      return parseUnionDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
+      return parseIntersectionDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
+      return parseTupleDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
+      return parseRecordDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def);
+      return parseLiteralDef2(def);
     case v3.ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
+      return parseEnumDef2(def);
     case v3.ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
+      return parseNativeEnumDef2(def);
     case v3.ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
+      return parseNullableDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
+      return parseOptionalDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
+      return parseMapDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
+      return parseSetDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
     case v3.ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
+      return parsePromiseDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodNaN:
     case v3.ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
+      return parseNeverDef2();
     case v3.ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
+      return parseEffectsDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
+      return parseAnyDef2();
     case v3.ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
+      return parseUnknownDef2();
     case v3.ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
+      return parseDefaultDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
+      return parseBrandedDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
+      return parseReadonlyDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
+      return parseCatchDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
+      return parsePipelineDef2(def, refs);
     case v3.ZodFirstPartyTypeKind.ZodFunction:
     case v3.ZodFirstPartyTypeKind.ZodVoid:
     case v3.ZodFirstPartyTypeKind.ZodSymbol:
@@ -4684,33 +6416,33 @@ var selectParser = (def, typeName, refs) => {
       return /* @__PURE__ */ ((_) => void 0)();
   }
 };
-function parseDef(def, refs, forceResolution = false) {
-  var _a19;
+function parseDef2(def, refs, forceResolution = false) {
+  var _a20;
   const seenItem = refs.seen.get(def);
   if (refs.override) {
-    const overrideResult = (_a19 = refs.override) == null ? void 0 : _a19.call(
+    const overrideResult = (_a20 = refs.override) == null ? void 0 : _a20.call(
       refs,
       def,
       refs,
       seenItem,
       forceResolution
     );
-    if (overrideResult !== ignoreOverride) {
+    if (overrideResult !== ignoreOverride2) {
       return overrideResult;
     }
   }
   if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
+    const seenSchema = get$ref2(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 jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
+  const jsonSchema22 = typeof jsonSchemaOrGetter === "function" ? parseDef2(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
   if (jsonSchema22) {
-    addMeta(def, refs, jsonSchema22);
+    addMeta2(def, refs, jsonSchema22);
   }
   if (refs.postProcess) {
     const postProcessResult = refs.postProcess(jsonSchema22, def, refs);
@@ -4720,12 +6452,12 @@ function parseDef(def, refs, forceResolution = false) {
   newItem.jsonSchema = jsonSchema22;
   return jsonSchema22;
 }
-var get$ref = (item, refs) => {
+var get$ref2 = (item, refs) => {
   switch (refs.$refStrategy) {
     case "root":
       return { $ref: item.path.join("/") };
     case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
+      return { $ref: getRelativePath2(refs.currentPath, item.path) };
     case "none":
     case "seen": {
       if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
@@ -4734,31 +6466,31 @@ var get$ref = (item, refs) => {
             "/"
           )}! Defaulting to any`
         );
-        return parseAnyDef();
+        return parseAnyDef2();
       }
-      return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
+      return refs.$refStrategy === "seen" ? parseAnyDef2() : void 0;
     }
   }
 };
-var addMeta = (def, refs, jsonSchema22) => {
+var addMeta2 = (def, refs, jsonSchema22) => {
   if (def.description) {
     jsonSchema22.description = def.description;
   }
   return jsonSchema22;
 };
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
+var getRefs2 = (options) => {
+  const _options = getDefaultOptions2(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(([name19, def]) => [
+      Object.entries(_options.definitions).map(([name20, def]) => [
         def._def,
         {
           def: def._def,
-          path: [..._options.basePath, _options.definitionPath, name19],
+          path: [..._options.basePath, _options.definitionPath, name20],
           // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
           jsonSchema: void 0
         }
@@ -4766,60 +6498,60 @@ var getRefs = (options) => {
     )
   };
 };
-var zodToJsonSchema2 = (schema, options) => {
-  var _a19;
-  const refs = getRefs(options);
+var zodToJsonSchema3 = (schema, options) => {
+  var _a20;
+  const refs = getRefs2(options);
   let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
-    (acc, [name24, schema2]) => {
-      var _a24;
+    (acc, [name25, schema2]) => {
+      var _a25;
       return {
         ...acc,
-        [name24]: (_a24 = parseDef(
+        [name25]: (_a25 = parseDef2(
           schema2._def,
           {
             ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name24]
+            currentPath: [...refs.basePath, refs.definitionPath, name25]
           },
           true
-        )) != null ? _a24 : parseAnyDef()
+        )) != null ? _a25 : parseAnyDef2()
       };
     },
     {}
   ) : void 0;
-  const name19 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a19 = parseDef(
+  const name20 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
+  const main = (_a20 = parseDef2(
     schema._def,
-    name19 === void 0 ? refs : {
+    name20 === void 0 ? refs : {
       ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name19]
+      currentPath: [...refs.basePath, refs.definitionPath, name20]
     },
     false
-  )) != null ? _a19 : parseAnyDef();
+  )) != null ? _a20 : parseAnyDef2();
   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 = name19 === void 0 ? definitions ? {
+  const combined = name20 === void 0 ? definitions ? {
     ...main,
     [refs.definitionPath]: definitions
   } : main : {
     $ref: [
       ...refs.$refStrategy === "relative" ? [] : refs.basePath,
       refs.definitionPath,
-      name19
+      name20
     ].join("/"),
     [refs.definitionPath]: {
       ...definitions,
-      [name19]: main
+      [name20]: main
     }
   };
   combined.$schema = "http://json-schema.org/draft-07/schema#";
   return combined;
 };
-var zod_to_json_schema_default = zodToJsonSchema2;
+var zod_to_json_schema_default = zodToJsonSchema3;
 function zod3Schema(zodSchema22, options) {
-  var _a19;
-  const useReferences = (_a19 = void 0 ) != null ? _a19 : false;
+  var _a20;
+  const useReferences = (_a20 = void 0 ) != null ? _a20 : false;
   return jsonSchema2(
     zod_to_json_schema_default(zodSchema22, {
       $refStrategy: useReferences ? "root" : "none"
@@ -4833,8 +6565,8 @@ function zod3Schema(zodSchema22, options) {
   );
 }
 function zod4Schema(zodSchema22, options) {
-  var _a19;
-  const useReferences = (_a19 = void 0 ) != null ? _a19 : false;
+  var _a20;
+  const useReferences = (_a20 = void 0 ) != null ? _a20 : false;
   const z4JSONSchema = z42__namespace.toJSONSchema(zodSchema22, {
     target: "draft-7",
     io: "output",
@@ -4882,18 +6614,20 @@ function asSchema2(schema) {
 function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
-var marker17 = "vercel.ai.gateway.error";
-var symbol17 = Symbol.for(marker17);
-var _a17;
+var import_oidc = chunkO7I5CWRX_cjs.__toESM(require_dist(), 1);
+var import_oidc2 = chunkO7I5CWRX_cjs.__toESM(require_dist(), 1);
+var marker18 = "vercel.ai.gateway.error";
+var symbol18 = Symbol.for(marker18);
+var _a18;
 var _b;
-var GatewayError = class _GatewayError extends (_b = Error, _a17 = symbol17, _b) {
+var GatewayError = class _GatewayError extends (_b = Error, _a18 = symbol18, _b) {
   constructor({
     message,
     statusCode = 500,
     cause
   }) {
     super(message);
-    this[_a17] = true;
+    this[_a18] = true;
     this.statusCode = statusCode;
     this.cause = cause;
   }
@@ -4906,27 +6640,27 @@ var GatewayError = class _GatewayError extends (_b = Error, _a17 = symbol17, _b)
     return _GatewayError.hasMarker(error);
   }
   static hasMarker(error) {
-    return typeof error === "object" && error !== null && symbol17 in error && error[symbol17] === true;
+    return typeof error === "object" && error !== null && symbol18 in error && error[symbol18] === true;
   }
 };
-var name17 = "GatewayAuthenticationError";
-var marker22 = `vercel.ai.gateway.error.${name17}`;
-var symbol22 = Symbol.for(marker22);
-var _a22;
+var name18 = "GatewayAuthenticationError";
+var marker23 = `vercel.ai.gateway.error.${name18}`;
+var symbol23 = Symbol.for(marker23);
+var _a23;
 var _b2;
-var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2 = GatewayError, _a22 = symbol22, _b2) {
+var GatewayAuthenticationError = class _GatewayAuthenticationError extends (_b2 = GatewayError, _a23 = symbol23, _b2) {
   constructor({
     message = "Authentication failed",
     statusCode = 401,
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a22] = true;
-    this.name = name17;
+    this[_a23] = true;
+    this.name = name18;
     this.type = "authentication_error";
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol22 in error;
+    return GatewayError.hasMarker(error) && symbol23 in error;
   }
   /**
    * Creates a contextual error message when authentication fails
@@ -4977,55 +6711,55 @@ The token is expected to be provided via the 'VERCEL_OIDC_TOKEN' environment var
     });
   }
 };
-var name22 = "GatewayInvalidRequestError";
-var marker32 = `vercel.ai.gateway.error.${name22}`;
-var symbol32 = Symbol.for(marker32);
-var _a32;
+var name23 = "GatewayInvalidRequestError";
+var marker33 = `vercel.ai.gateway.error.${name23}`;
+var symbol33 = Symbol.for(marker33);
+var _a33;
 var _b3;
-var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a32 = symbol32, _b3) {
+var GatewayInvalidRequestError = class extends (_b3 = GatewayError, _a33 = symbol33, _b3) {
   constructor({
     message = "Invalid request",
     statusCode = 400,
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a32] = true;
-    this.name = name22;
+    this[_a33] = true;
+    this.name = name23;
     this.type = "invalid_request_error";
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol32 in error;
+    return GatewayError.hasMarker(error) && symbol33 in error;
   }
 };
-var name32 = "GatewayRateLimitError";
-var marker42 = `vercel.ai.gateway.error.${name32}`;
-var symbol42 = Symbol.for(marker42);
-var _a42;
+var name33 = "GatewayRateLimitError";
+var marker43 = `vercel.ai.gateway.error.${name33}`;
+var symbol43 = Symbol.for(marker43);
+var _a43;
 var _b4;
-var GatewayRateLimitError = class extends (_b4 = GatewayError, _a42 = symbol42, _b4) {
+var GatewayRateLimitError = class extends (_b4 = GatewayError, _a43 = symbol43, _b4) {
   constructor({
     message = "Rate limit exceeded",
     statusCode = 429,
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a42] = true;
-    this.name = name32;
+    this[_a43] = true;
+    this.name = name33;
     this.type = "rate_limit_exceeded";
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol42 in error;
+    return GatewayError.hasMarker(error) && symbol43 in error;
   }
 };
-var name42 = "GatewayModelNotFoundError";
-var marker52 = `vercel.ai.gateway.error.${name42}`;
-var symbol52 = Symbol.for(marker52);
+var name43 = "GatewayModelNotFoundError";
+var marker53 = `vercel.ai.gateway.error.${name43}`;
+var symbol53 = Symbol.for(marker53);
 var modelNotFoundParamSchema = z42.z.object({
   modelId: z42.z.string()
 });
-var _a52;
+var _a53;
 var _b5;
-var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a52 = symbol52, _b5) {
+var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a53 = symbol53, _b5) {
   constructor({
     message = "Model not found",
     statusCode = 404,
@@ -5033,41 +6767,41 @@ var GatewayModelNotFoundError = class extends (_b5 = GatewayError, _a52 = symbol
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a52] = true;
-    this.name = name42;
+    this[_a53] = true;
+    this.name = name43;
     this.type = "model_not_found";
     this.modelId = modelId;
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol52 in error;
+    return GatewayError.hasMarker(error) && symbol53 in error;
   }
 };
-var name52 = "GatewayInternalServerError";
-var marker62 = `vercel.ai.gateway.error.${name52}`;
-var symbol62 = Symbol.for(marker62);
-var _a62;
+var name53 = "GatewayInternalServerError";
+var marker63 = `vercel.ai.gateway.error.${name53}`;
+var symbol63 = Symbol.for(marker63);
+var _a63;
 var _b6;
-var GatewayInternalServerError = class extends (_b6 = GatewayError, _a62 = symbol62, _b6) {
+var GatewayInternalServerError = class extends (_b6 = GatewayError, _a63 = symbol63, _b6) {
   constructor({
     message = "Internal server error",
     statusCode = 500,
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a62] = true;
-    this.name = name52;
+    this[_a63] = true;
+    this.name = name53;
     this.type = "internal_server_error";
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol62 in error;
+    return GatewayError.hasMarker(error) && symbol63 in error;
   }
 };
-var name62 = "GatewayResponseError";
-var marker72 = `vercel.ai.gateway.error.${name62}`;
-var symbol72 = Symbol.for(marker72);
-var _a72;
+var name63 = "GatewayResponseError";
+var marker73 = `vercel.ai.gateway.error.${name63}`;
+var symbol73 = Symbol.for(marker73);
+var _a73;
 var _b7;
-var GatewayResponseError = class extends (_b7 = GatewayError, _a72 = symbol72, _b7) {
+var GatewayResponseError = class extends (_b7 = GatewayError, _a73 = symbol73, _b7) {
   constructor({
     message = "Invalid response from Gateway",
     statusCode = 502,
@@ -5076,14 +6810,14 @@ var GatewayResponseError = class extends (_b7 = GatewayError, _a72 = symbol72, _
     cause
   } = {}) {
     super({ message, statusCode, cause });
-    this[_a72] = true;
-    this.name = name62;
+    this[_a73] = true;
+    this.name = name63;
     this.type = "response_error";
     this.response = response;
     this.validationError = validationError;
   }
   static isInstance(error) {
-    return GatewayError.hasMarker(error) && symbol72 in error;
+    return GatewayError.hasMarker(error) && symbol73 in error;
   }
 };
 function createGatewayErrorFromResponse({
@@ -5144,14 +6878,14 @@ var gatewayErrorResponseSchema = z42.z.object({
   })
 });
 function asGatewayError(error, authMethod) {
-  var _a83;
+  var _a84;
   if (GatewayError.isInstance(error)) {
     return error;
   }
-  if (chunkHVBBFCDH_cjs.APICallError.isInstance(error)) {
+  if (APICallError2.isInstance(error)) {
     return createGatewayErrorFromResponse({
       response: extractApiCallResponse(error),
-      statusCode: (_a83 = error.statusCode) != null ? _a83 : 500,
+      statusCode: (_a84 = error.statusCode) != null ? _a84 : 500,
       defaultMessage: "Gateway request failed",
       cause: error,
       authMethod
@@ -5212,6 +6946,24 @@ var GatewayFetchMetadata = class {
       throw asGatewayError(error);
     }
   }
+  async getCredits() {
+    try {
+      const baseUrl = new URL(this.config.baseURL);
+      const { value } = await getFromApi({
+        url: `${baseUrl.origin}/v1/credits`,
+        headers: await resolve(this.config.headers()),
+        successfulResponseHandler: createJsonResponseHandler(gatewayCreditsSchema),
+        failedResponseHandler: createJsonErrorResponseHandler({
+          errorSchema: z42.z.any(),
+          errorToMessage: (data) => data
+        }),
+        fetch: this.config.fetch
+      });
+      return value;
+    } catch (error) {
+      throw asGatewayError(error);
+    }
+  }
 };
 var gatewayLanguageModelSpecificationSchema = z42.z.object({
   specificationVersion: z42.z.literal("v2"),
@@ -5240,6 +6992,13 @@ var gatewayLanguageModelEntrySchema = z42.z.object({
 var gatewayFetchMetadataSchema = z42.z.object({
   models: z42.z.array(gatewayLanguageModelEntrySchema)
 });
+var gatewayCreditsSchema = z42.z.object({
+  balance: z42.z.string(),
+  total_used: z42.z.string()
+}).transform(({ balance, total_used }) => ({
+  balance,
+  totalUsed: total_used
+}));
 var GatewayLanguageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -5402,7 +7161,7 @@ var GatewayEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a83;
+    var _a84;
     const resolvedHeaders = await resolve(this.config.headers());
     try {
       const {
@@ -5433,7 +7192,7 @@ var GatewayEmbeddingModel = class {
       });
       return {
         embeddings: responseBody.embeddings,
-        usage: (_a83 = responseBody.usage) != null ? _a83 : void 0,
+        usage: (_a84 = responseBody.usage) != null ? _a84 : void 0,
         providerMetadata: responseBody.providerMetadata,
         response: { headers: responseHeaders, body: rawValue }
       };
@@ -5456,44 +7215,31 @@ var gatewayEmbeddingResponseSchema = z42.z.object({
   usage: z42.z.object({ tokens: z42.z.number() }).nullish(),
   providerMetadata: z42.z.record(z42.z.string(), z42.z.record(z42.z.string(), z42.z.unknown())).optional()
 });
-async function getVercelOidcToken() {
-  var _a83, _b8;
-  const token = (_b8 = (_a83 = getContext().headers) == null ? void 0 : _a83["x-vercel-oidc-token"]) != null ? _b8 : process.env.VERCEL_OIDC_TOKEN;
-  if (!token) {
-    throw new GatewayAuthenticationError({
-      message: "OIDC token not available",
-      statusCode: 401
-    });
-  }
-  return token;
-}
 async function getVercelRequestId() {
-  var _a83;
-  return (_a83 = getContext().headers) == null ? void 0 : _a83["x-vercel-id"];
-}
-var SYMBOL_FOR_REQ_CONTEXT = Symbol.for("@vercel/request-context");
-function getContext() {
-  var _a83, _b8, _c;
-  const fromSymbol = globalThis;
-  return (_c = (_b8 = (_a83 = fromSymbol[SYMBOL_FOR_REQ_CONTEXT]) == null ? void 0 : _a83.get) == null ? void 0 : _b8.call(_a83)) != null ? _c : {};
+  var _a84;
+  return (_a84 = (0, import_oidc.getContext)().headers) == null ? void 0 : _a84["x-vercel-id"];
 }
+var VERSION3 = "1.0.33" ;
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
 function createGatewayProvider(options = {}) {
-  var _a83, _b8;
+  var _a84, _b8;
   let pendingMetadata = null;
   let metadataCache = null;
-  const cacheRefreshMillis = (_a83 = options.metadataCacheRefreshMillis) != null ? _a83 : 1e3 * 60 * 5;
+  const cacheRefreshMillis = (_a84 = options.metadataCacheRefreshMillis) != null ? _a84 : 1e3 * 60 * 5;
   let lastFetchTime = 0;
   const baseURL = (_b8 = withoutTrailingSlash(options.baseURL)) != null ? _b8 : "https://ai-gateway.vercel.sh/v1/ai";
   const getHeaders = async () => {
     const auth = await getGatewayAuthToken(options);
     if (auth) {
-      return {
-        Authorization: `Bearer ${auth.token}`,
-        "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
-        [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
-        ...options.headers
-      };
+      return withUserAgentSuffix(
+        {
+          Authorization: `Bearer ${auth.token}`,
+          "ai-gateway-protocol-version": AI_GATEWAY_PROTOCOL_VERSION,
+          [GATEWAY_AUTH_METHOD_HEADER]: auth.authMethod,
+          ...options.headers
+        },
+        `ai-sdk/gateway/${VERSION3}`
+      );
     }
     throw GatewayAuthenticationError.createContextualError({
       apiKeyProvided: false,
@@ -5534,8 +7280,8 @@ function createGatewayProvider(options = {}) {
     });
   };
   const getAvailableModels = async () => {
-    var _a93, _b9, _c;
-    const now = (_c = (_b9 = (_a93 = options._internal) == null ? void 0 : _a93.currentDate) == null ? void 0 : _b9.call(_a93).getTime()) != null ? _c : Date.now();
+    var _a94, _b9, _c;
+    const now = (_c = (_b9 = (_a94 = options._internal) == null ? void 0 : _a94.currentDate) == null ? void 0 : _b9.call(_a94).getTime()) != null ? _c : Date.now();
     if (!pendingMetadata || now - lastFetchTime > cacheRefreshMillis) {
       lastFetchTime = now;
       pendingMetadata = new GatewayFetchMetadata({
@@ -5551,6 +7297,15 @@ function createGatewayProvider(options = {}) {
     }
     return metadataCache ? Promise.resolve(metadataCache) : pendingMetadata;
   };
+  const getCredits = async () => {
+    return new GatewayFetchMetadata({
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch
+    }).getCredits().catch(async (error) => {
+      throw asGatewayError(error, parseAuthMethod(await getHeaders()));
+    });
+  };
   const provider = function(modelId) {
     if (new.target) {
       throw new Error(
@@ -5560,8 +7315,9 @@ function createGatewayProvider(options = {}) {
     return createLanguageModel(modelId);
   };
   provider.getAvailableModels = getAvailableModels;
+  provider.getCredits = getCredits;
   provider.imageModel = (modelId) => {
-    throw new chunkHVBBFCDH_cjs.NoSuchModelError({ modelId, modelType: "imageModel" });
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
   };
   provider.languageModel = createLanguageModel;
   provider.textEmbeddingModel = (modelId) => {
@@ -5588,7 +7344,7 @@ async function getGatewayAuthToken(options) {
     };
   }
   try {
-    const oidcToken = await getVercelOidcToken();
+    const oidcToken = await (0, import_oidc2.getVercelOidcToken)();
     return {
       token: oidcToken,
       authMethod: "oidc"
@@ -5602,34 +7358,34 @@ var __export3 = (target, all) => {
   for (var name172 in all)
     __defProp2(target, name172, { get: all[name172], enumerable: true });
 };
-var name23 = "AI_InvalidArgumentError";
-var marker23 = `vercel.ai.error.${name23}`;
-var symbol23 = Symbol.for(marker23);
-var _a23;
-var InvalidArgumentError3 = class extends chunkHVBBFCDH_cjs.AISDKError {
+var name24 = "AI_InvalidArgumentError";
+var marker24 = `vercel.ai.error.${name24}`;
+var symbol24 = Symbol.for(marker24);
+var _a24;
+var InvalidArgumentError3 = class extends AISDKError2 {
   constructor({
     parameter,
     value,
     message
   }) {
     super({
-      name: name23,
+      name: name24,
       message: `Invalid argument for parameter ${parameter}: ${message}`
     });
-    this[_a23] = true;
+    this[_a24] = true;
     this.parameter = parameter;
     this.value = value;
   }
   static isInstance(error) {
-    return chunkHVBBFCDH_cjs.AISDKError.hasMarker(error, marker23);
+    return AISDKError2.hasMarker(error, marker24);
   }
 };
-_a23 = symbol23;
-var name72 = "AI_NoObjectGeneratedError";
-var marker73 = `vercel.ai.error.${name72}`;
-var symbol73 = Symbol.for(marker73);
-var _a73;
-var NoObjectGeneratedError2 = class extends chunkHVBBFCDH_cjs.AISDKError {
+_a24 = symbol24;
+var name73 = "AI_NoObjectGeneratedError";
+var marker74 = `vercel.ai.error.${name73}`;
+var symbol74 = Symbol.for(marker74);
+var _a74;
+var NoObjectGeneratedError2 = class extends AISDKError2 {
   constructor({
     message = "No object generated.",
     cause,
@@ -5638,19 +7394,19 @@ var NoObjectGeneratedError2 = class extends chunkHVBBFCDH_cjs.AISDKError {
     usage,
     finishReason
   }) {
-    super({ name: name72, message, cause });
-    this[_a73] = true;
+    super({ name: name73, message, cause });
+    this[_a74] = true;
     this.text = text22;
     this.response = response;
     this.usage = usage;
     this.finishReason = finishReason;
   }
   static isInstance(error) {
-    return chunkHVBBFCDH_cjs.AISDKError.hasMarker(error, marker73);
+    return AISDKError2.hasMarker(error, marker74);
   }
 };
-_a73 = symbol73;
-var UnsupportedModelVersionError2 = class extends chunkHVBBFCDH_cjs.AISDKError {
+_a74 = symbol74;
+var UnsupportedModelVersionError2 = class extends AISDKError2 {
   constructor(options) {
     super({
       name: "AI_UnsupportedModelVersionError",
@@ -5665,7 +7421,7 @@ var name152 = "AI_RetryError";
 var marker152 = `vercel.ai.error.${name152}`;
 var symbol152 = Symbol.for(marker152);
 var _a152;
-var RetryError2 = class extends chunkHVBBFCDH_cjs.AISDKError {
+var RetryError2 = class extends AISDKError2 {
   constructor({
     message,
     reason,
@@ -5678,7 +7434,7 @@ var RetryError2 = class extends chunkHVBBFCDH_cjs.AISDKError {
     this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return chunkHVBBFCDH_cjs.AISDKError.hasMarker(error, marker152);
+    return AISDKError2.hasMarker(error, marker152);
   }
 };
 _a152 = symbol152;
@@ -5701,6 +7457,7 @@ function getGlobalProvider() {
   var _a172;
   return (_a172 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a172 : gateway;
 }
+var VERSION4 = "5.0.60" ;
 var dataContentSchema2 = z42.z.union([
   z42.z.string(),
   z42.z.instanceof(Uint8Array),
@@ -6077,7 +7834,7 @@ async function _retryWithExponentialBackoff2(f, {
     if (maxRetries === 0) {
       throw error;
     }
-    const errorMessage = getErrorMessage2(error);
+    const errorMessage = getErrorMessage3(error);
     const newErrors = [...errors, error];
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
@@ -6087,7 +7844,7 @@ async function _retryWithExponentialBackoff2(f, {
         errors: newErrors
       });
     }
-    if (error instanceof Error && chunkHVBBFCDH_cjs.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+    if (error instanceof Error && APICallError2.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
       await delay2(
         getRetryDelayInMs({
           error,
@@ -6148,7 +7905,6 @@ function prepareRetries2({
 function stepCountIs(stepCount) {
   return ({ steps }) => steps.length === stepCount;
 }
-var VERSION3 = "5.0.44" ;
 createIdGenerator2({
   prefix: "aitxt",
   size: 24
@@ -6220,11 +7976,6 @@ z42.z.union([
     providerExecuted: z42.z.boolean().optional(),
     dynamic: z42.z.boolean().optional()
   }),
-  z42.z.strictObject({
-    type: z42.z.literal("reasoning"),
-    text: z42.z.string(),
-    providerMetadata: providerMetadataSchema2.optional()
-  }),
   z42.z.strictObject({
     type: z42.z.literal("reasoning-start"),
     id: z42.z.string(),
@@ -6241,9 +7992,6 @@ z42.z.union([
     id: z42.z.string(),
     providerMetadata: providerMetadataSchema2.optional()
   }),
-  z42.z.strictObject({
-    type: z42.z.literal("reasoning-part-finish")
-  }),
   z42.z.strictObject({
     type: z42.z.literal("source-url"),
     sourceId: z42.z.string(),
@@ -6266,7 +8014,10 @@ z42.z.union([
     providerMetadata: providerMetadataSchema2.optional()
   }),
   z42.z.strictObject({
-    type: z42.z.string().startsWith("data-"),
+    type: z42.z.custom(
+      (value) => typeof value === "string" && value.startsWith("data-"),
+      { message: 'Type must start with "data-"' }
+    ),
     id: z42.z.string().optional(),
     data: z42.z.unknown(),
     transient: z42.z.boolean().optional()
@@ -6655,7 +8406,7 @@ async function embedMany2({
   });
   const headersWithUserAgent = withUserAgentSuffix(
     headers != null ? headers : {},
-    `ai/${VERSION3}`
+    `ai/${VERSION4}`
   );
   const baseTelemetryAttributes = getBaseTelemetryAttributes2({
     model,
@@ -8073,9 +9824,9 @@ var MetadataHandler = class {
 };
 var ProtoRequiredHandler = class {
   apply(zodSchema3, schema) {
-    var _a19;
+    var _a20;
     const objectSchema = schema;
-    if (!((_a19 = objectSchema.required) == null ? void 0 : _a19.includes("__proto__")) || schema.type !== void 0) {
+    if (!((_a20 = objectSchema.required) == null ? void 0 : _a20.includes("__proto__")) || schema.type !== void 0) {
       return zodSchema3;
     }
     return z42.z.any().refine(
@@ -8094,11 +9845,11 @@ var ProtoRequiredHandler = class {
 };
 var ContainsHandler = class {
   apply(zodSchema3, schema) {
-    var _a19;
+    var _a20;
     const arraySchema = schema;
     if (arraySchema.contains === void 0) return zodSchema3;
     const containsSchema = convertJsonSchemaToZod(arraySchema.contains);
-    const minContains = (_a19 = arraySchema.minContains) != null ? _a19 : 1;
+    const minContains = (_a20 = arraySchema.minContains) != null ? _a20 : 1;
     const maxContains = arraySchema.maxContains;
     return zodSchema3.refine(
       (value) => {
@@ -8623,7 +10374,7 @@ var Memory = class extends memory.MastraMemory {
     const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === `resource`;
     if (config?.semanticRecall && selectBy?.vectorSearchString && this.vector) {
       const { embeddings, dimension } = await this.embedMessageContent(selectBy.vectorSearchString);
-      const { indexName } = await this.createEmbeddingIndex(dimension);
+      const { indexName } = await this.createEmbeddingIndex(dimension, config);
       await Promise.all(
         embeddings.map(async (embedding) => {
           if (typeof this.vector === `undefined`) {
@@ -8755,19 +10506,56 @@ var Memory = class extends memory.MastraMemory {
       sortDirection
     });
   }
-  async saveThread({ thread }) {
-    return this.storage.saveThread({ thread });
+  async handleWorkingMemoryFromMetadata({
+    workingMemory,
+    resourceId,
+    memoryConfig
+  }) {
+    const config = this.getMergedThreadConfig(memoryConfig || {});
+    if (config.workingMemory?.enabled) {
+      this.checkStorageFeatureSupport(config);
+      const scope = config.workingMemory.scope || "thread";
+      if (scope === "resource" && resourceId) {
+        await this.storage.updateResource({
+          resourceId,
+          workingMemory
+        });
+      }
+    }
+  }
+  async saveThread({
+    thread,
+    memoryConfig
+  }) {
+    const savedThread = await this.storage.saveThread({ thread });
+    if (thread.metadata?.workingMemory && typeof thread.metadata.workingMemory === "string" && thread.resourceId) {
+      await this.handleWorkingMemoryFromMetadata({
+        workingMemory: thread.metadata.workingMemory,
+        resourceId: thread.resourceId,
+        memoryConfig
+      });
+    }
+    return savedThread;
   }
   async updateThread({
     id,
     title,
-    metadata
+    metadata,
+    memoryConfig
   }) {
-    return this.storage.updateThread({
+    const updatedThread = await this.storage.updateThread({
       id,
       title,
       metadata
     });
+    if (metadata?.workingMemory && typeof metadata.workingMemory === "string" && updatedThread.resourceId) {
+      await this.handleWorkingMemoryFromMetadata({
+        workingMemory: metadata.workingMemory,
+        resourceId: updatedThread.resourceId,
+        memoryConfig
+      });
+    }
+    return updatedThread;
   }
   async deleteThread(threadId) {
     await this.storage.deleteThread({ threadId });
@@ -8977,7 +10765,7 @@ ${workingMemory}`;
           if (!textForEmbedding) return;
           const { embeddings, chunks, dimension } = await this.embedMessageContent(textForEmbedding);
           if (typeof indexName === `undefined`) {
-            indexName = this.createEmbeddingIndex(dimension).then((result2) => result2.indexName);
+            indexName = this.createEmbeddingIndex(dimension, config).then((result2) => result2.indexName);
           }
           if (typeof this.vector === `undefined`) {
             throw new Error(
@@ -9105,7 +10893,7 @@ ${workingMemory}`;
         const schema = config.workingMemory.schema;
         let convertedSchema;
         if (isZodObject(schema)) {
-          convertedSchema = zodToJsonSchema(schema);
+          convertedSchema = zodToJsonSchema2(schema);
         } else {
           convertedSchema = schema;
         }
@@ -9285,7 +11073,7 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
 };
 
 // ../../node_modules/.pnpm/js-tiktoken@1.0.21/node_modules/js-tiktoken/dist/chunk-VL2OQCWN.js
-var import_base64_js = chunkEMMSS5I5_cjs.__toESM(require_base64_js(), 1);
+var import_base64_js = chunkO7I5CWRX_cjs.__toESM(require_base64_js(), 1);
 var __defProp3 = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
@@ -9544,7 +11332,7 @@ var TokenLimiter = class extends memory.MemoryProcessor {
 };
 
 // ../agent-builder/dist/index.js
-var import_ignore = chunkEMMSS5I5_cjs.__toESM(require_ignore(), 1);
+var import_ignore = chunkO7I5CWRX_cjs.__toESM(require_ignore(), 1);
 var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
 var TemplateUnitSchema = zod.z.object({
   kind: zod.z.enum(UNIT_KINDS),
@@ -10147,50 +11935,28 @@ var createModelInstance = async (provider, modelId, version = "v2") => {
     const providerMap = {
       v1: {
         openai: async () => {
-          const { openai: openai22 } = await import('./dist-WKYB3LTJ.cjs');
-          return openai22(modelId);
-        },
-        anthropic: async () => {
-          const { anthropic } = await import('./dist-7IHNNYMF.cjs');
-          return anthropic(modelId);
-        },
-        groq: async () => {
-          const { groq } = await import('./dist-WCQDRTIV.cjs');
-          return groq(modelId);
-        },
-        xai: async () => {
-          const { xai } = await import('./dist-6U6EFC5C.cjs');
-          return xai(modelId);
-        },
-        google: async () => {
-          const { google } = await import('./dist-F2ET4MNO.cjs');
-          return google(modelId);
-        }
-      },
-      v2: {
-        openai: async () => {
-          const { openai: openai22 } = await import('./dist-EZZMMMNT.cjs');
-          return openai22(modelId);
+          const { openai: openai2 } = await import('./dist-P4MXBQ3U.cjs');
+          return openai2(modelId);
         },
         anthropic: async () => {
-          const { anthropic } = await import('./dist-3SJKQJGY.cjs');
+          const { anthropic } = await import('./dist-4MVGNSRL.cjs');
           return anthropic(modelId);
         },
         groq: async () => {
-          const { groq } = await import('./dist-3A5DXB37.cjs');
+          const { groq } = await import('./dist-RFMYFILX.cjs');
           return groq(modelId);
         },
         xai: async () => {
-          const { xai } = await import('./dist-EOMYFT4Y.cjs');
+          const { xai } = await import('./dist-G2BYZJOC.cjs');
           return xai(modelId);
         },
         google: async () => {
-          const { google } = await import('./dist-HY7RMLJQ.cjs');
+          const { google } = await import('./dist-FZYCV3VB.cjs');
           return google(modelId);
         }
       }
     };
-    const providerFn = providerMap[version][provider];
+    const providerFn = version === `v1` ? providerMap[version][provider] : () => new llm.ModelRouterLanguageModel(`${provider}/${modelId}`);
     if (!providerFn) {
       console.error(`Unsupported provider: ${provider}`);
       return null;
@@ -10205,7 +11971,7 @@ var createModelInstance = async (provider, modelId, version = "v2") => {
 };
 var resolveModel = async ({
   runtimeContext,
-  defaultModel = chunkFALVL2VV_cjs.openai("gpt-4.1"),
+  defaultModel = "openai/gpt-4.1",
   projectPath
 }) => {
   const modelFromContext = runtimeContext.get("model");
@@ -10229,7 +11995,7 @@ var resolveModel = async ({
     }
   }
   console.info("Using default model");
-  return defaultModel;
+  return typeof defaultModel === `string` ? new llm.ModelRouterLanguageModel(defaultModel) : defaultModel;
 };
 var AgentBuilderDefaults = class _AgentBuilderDefaults {
   static DEFAULT_INSTRUCTIONS = (projectPath) => `You are a Mastra Expert Agent, specialized in building production-ready AI applications using the Mastra framework. You excel at creating agents, tools, workflows, and complete applications with real, working implementations.
@@ -11739,14 +13505,14 @@ export const mastra = new Mastra({
         noEmit: true
       };
       const host = {
-        getSourceFile: (name19) => name19 === fileName ? sourceFile : void 0,
+        getSourceFile: (name20) => name20 === fileName ? sourceFile : void 0,
         writeFile: () => {
         },
         getCurrentDirectory: () => "",
         getDirectories: () => [],
-        fileExists: (name19) => name19 === fileName,
-        readFile: (name19) => name19 === fileName ? fileContent : void 0,
-        getCanonicalFileName: (name19) => name19,
+        fileExists: (name20) => name20 === fileName,
+        readFile: (name20) => name20 === fileName ? fileContent : void 0,
+        getCanonicalFileName: (name20) => name20,
         useCaseSensitiveFileNames: () => true,
         getNewLine: () => "\n",
         getDefaultLibFileName: () => "lib.d.ts"
@@ -12738,7 +14504,7 @@ ${config.instructions}` : "";
    * Enhanced generate method with AgentBuilder-specific configuration
    * Overrides the base Agent generate method to provide additional project context
    */
-  generate = async (messages, generateOptions = {}) => {
+  generateLegacy = async (messages, generateOptions = {}) => {
     const { maxSteps, ...baseOptions } = generateOptions;
     const originalInstructions = await this.getInstructions({ runtimeContext: generateOptions?.runtimeContext });
     const additionalInstructions = baseOptions.instructions;
@@ -12761,13 +14527,13 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting generation with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.generate(messages, enhancedOptions);
+    return super.generateLegacy(messages, enhancedOptions);
   };
   /**
    * Enhanced stream method with AgentBuilder-specific configuration
    * Overrides the base Agent stream method to provide additional project context
    */
-  stream = async (messages, streamOptions = {}) => {
+  streamLegacy = async (messages, streamOptions = {}) => {
     const { maxSteps, ...baseOptions } = streamOptions;
     const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
     const additionalInstructions = baseOptions.instructions;
@@ -12790,13 +14556,13 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.stream(messages, enhancedOptions);
+    return super.streamLegacy(messages, enhancedOptions);
   };
   /**
    * Enhanced stream method with AgentBuilder-specific configuration
    * Overrides the base Agent stream method to provide additional project context
    */
-  async streamVNext(messages, streamOptions) {
+  async stream(messages, streamOptions) {
     const { ...baseOptions } = streamOptions || {};
     const originalInstructions = await this.getInstructions({ runtimeContext: streamOptions?.runtimeContext });
     const additionalInstructions = baseOptions.instructions;
@@ -12818,9 +14584,9 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.streamVNext(messages, enhancedOptions);
+    return super.stream(messages, enhancedOptions);
   }
-  async generateVNext(messages, options) {
+  async generate(messages, options) {
     const { ...baseOptions } = options || {};
     const originalInstructions = await this.getInstructions({ runtimeContext: options?.runtimeContext });
     const additionalInstructions = baseOptions.instructions;
@@ -12842,7 +14608,7 @@ ${additionalInstructions}`;
     this.logger.debug(`[AgentBuilder:${this.name}] Starting streaming with enhanced context`, {
       projectPath: this.builderConfig.projectPath
     });
-    return super.generateVNext(messages, enhancedOptions);
+    return super.generate(messages, enhancedOptions);
   }
 };
 var cloneTemplateStep = workflows.createStep({
@@ -12935,7 +14701,7 @@ var discoverUnitsStep = workflows.createStep({
     const targetPath = resolveTargetPath(inputData, runtimeContext);
     const tools = await AgentBuilderDefaults.DEFAULT_TOOLS(templateDir);
     console.info("targetPath", targetPath);
-    const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunkPPYGWINI_cjs.openai("gpt-4.1") });
+    const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
     try {
       const agent$1 = new agent.Agent({
         model,
@@ -12995,10 +14761,12 @@ Return the actual exported names of the units, as well as the file names.`,
         networks: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
         other: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional()
       });
-      const result = isV2 ? await agent$1.generateVNext(prompt, {
-        output,
+      const result = isV2 ? await agent.tryGenerateWithJsonFallback(agent$1, prompt, {
+        structuredOutput: {
+          schema: output
+        },
         maxSteps: 100
-      }) : await agent$1.generate(prompt, {
+      }) : await agent$1.generateLegacy(prompt, {
         experimental_output: output,
         maxSteps: 100
       });
@@ -13126,25 +14894,25 @@ var packageMergeStep = workflows.createStep({
       const tplDevDeps = ensureObj(packageInfo.devDependencies);
       const tplPeerDeps = ensureObj(packageInfo.peerDependencies);
       const tplScripts = ensureObj(packageInfo.scripts);
-      const existsAnywhere = (name19) => name19 in targetPkg.dependencies || name19 in targetPkg.devDependencies || name19 in targetPkg.peerDependencies;
-      for (const [name19, ver] of Object.entries(tplDeps)) {
-        if (!existsAnywhere(name19)) {
-          targetPkg.dependencies[name19] = String(ver);
+      const existsAnywhere = (name20) => name20 in targetPkg.dependencies || name20 in targetPkg.devDependencies || name20 in targetPkg.peerDependencies;
+      for (const [name20, ver] of Object.entries(tplDeps)) {
+        if (!existsAnywhere(name20)) {
+          targetPkg.dependencies[name20] = String(ver);
         }
       }
-      for (const [name19, ver] of Object.entries(tplDevDeps)) {
-        if (!existsAnywhere(name19)) {
-          targetPkg.devDependencies[name19] = String(ver);
+      for (const [name20, ver] of Object.entries(tplDevDeps)) {
+        if (!existsAnywhere(name20)) {
+          targetPkg.devDependencies[name20] = String(ver);
         }
       }
-      for (const [name19, ver] of Object.entries(tplPeerDeps)) {
-        if (!(name19 in targetPkg.peerDependencies)) {
-          targetPkg.peerDependencies[name19] = String(ver);
+      for (const [name20, ver] of Object.entries(tplPeerDeps)) {
+        if (!(name20 in targetPkg.peerDependencies)) {
+          targetPkg.peerDependencies[name20] = String(ver);
         }
       }
       const prefix = `template:${slug}:`;
-      for (const [name19, cmd] of Object.entries(tplScripts)) {
-        const newKey = `${prefix}${name19}`;
+      for (const [name20, cmd] of Object.entries(tplScripts)) {
+        const newKey = `${prefix}${name20}`;
         if (!(newKey in targetPkg.scripts)) {
           targetPkg.scripts[newKey] = String(cmd);
         }
@@ -13229,9 +14997,9 @@ var programmaticFileCopyStep = workflows.createStep({
           return "unknown";
         }
       };
-      const convertNaming = (name19, convention) => {
-        const baseName = path.basename(name19, path.extname(name19));
-        const ext = path.extname(name19);
+      const convertNaming = (name20, convention) => {
+        const baseName = path.basename(name20, path.extname(name20));
+        const ext = path.extname(name20);
         switch (convention) {
           case "camelCase":
             return baseName.replace(/[-_]/g, "").replace(/([A-Z])/g, (match, p1, offset) => offset === 0 ? p1.toLowerCase() : p1) + ext;
@@ -13242,7 +15010,7 @@ var programmaticFileCopyStep = workflows.createStep({
           case "PascalCase":
             return baseName.replace(/[-_]/g, "").replace(/^[a-z]/, (match) => match.toUpperCase()) + ext;
           default:
-            return name19;
+            return name20;
         }
       };
       for (const unit of orderedUnits) {
@@ -13559,7 +15327,7 @@ var intelligentMergeStep = workflows.createStep({
     const { conflicts, copiedFiles, commitSha, slug, templateDir, branchName } = inputData;
     const targetPath = resolveTargetPath(inputData, runtimeContext);
     try {
-      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunkPPYGWINI_cjs.openai("gpt-4.1") });
+      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
       const copyFileTool = tools.createTool({
         id: "copy-file",
         description: "Copy a file from template to target project (use only for edge cases - most files are already copied programmatically).",
@@ -13744,7 +15512,7 @@ For each task:
 Start by listing your tasks and work through them systematically!
 `;
       const isV2 = model.specificationVersion === "v2";
-      const result = isV2 ? await agentBuilder.streamVNext(prompt) : await agentBuilder.stream(prompt);
+      const result = isV2 ? await agentBuilder.stream(prompt) : await agentBuilder.streamLegacy(prompt);
       const actualResolutions = [];
       for await (const chunk of result.fullStream) {
         if (chunk.type === "step-finish" || chunk.type === "step-start") {
@@ -13845,7 +15613,7 @@ var validationAndFixStep = workflows.createStep({
     );
     let currentIteration = 1;
     try {
-      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunkPPYGWINI_cjs.openai("gpt-4.1") });
+      const model = await resolveModel({ runtimeContext, projectPath: targetPath, defaultModel: chunk2PLXW4ZX_cjs.openai("gpt-4.1") });
       const allTools = await AgentBuilderDefaults.getToolsForMode(targetPath, "template");
       const validationAgent = new agent.Agent({
         name: "code-validator-fixer",
@@ -13986,9 +15754,11 @@ Start by running validateCode with all validation types to get a complete pictur
 Previous iterations may have fixed some issues, so start by re-running validateCode to see the current state, then fix any remaining issues.`;
         const isV2 = model.specificationVersion === "v2";
         const output = zod.z.object({ success: zod.z.boolean() });
-        const result = isV2 ? await validationAgent.streamVNext(iterationPrompt, {
-          output
-        }) : await validationAgent.stream(iterationPrompt, {
+        const result = isV2 ? await agent.tryStreamWithJsonFallback(validationAgent, iterationPrompt, {
+          structuredOutput: {
+            schema: output
+          }
+        }) : await validationAgent.streamLegacy(iterationPrompt, {
           experimental_output: output
         });
         let iterationErrors = 0;
@@ -14598,7 +16368,7 @@ var planningIterationStep = workflows.createStep({
         projectStructure,
         research
       });
-      const result = await planningAgent.generateVNext(planningPrompt, {
+      const result = await planningAgent.generate(planningPrompt, {
         output: PlanningAgentOutputSchema
         // maxSteps: 15,
       });
@@ -15304,7 +17074,7 @@ var workflowResearchStep = workflows.createStep({
         dependencies: inputData.dependencies,
         hasWorkflowsDir: inputData.structure.hasWorkflowsDir
       });
-      const result = await researchAgent.generateVNext(researchPrompt, {
+      const result = await researchAgent.generate(researchPrompt, {
         output: WorkflowResearchResultSchema
         // stopWhen: stepCountIs(10),
       });
@@ -15454,7 +17224,7 @@ ${additionalInstructions}`;
         })}
 
 ${workflowBuilderPrompts.validation.instructions}`;
-        const stream = await executionAgent.streamVNext(iterationPrompt, {
+        const stream = await executionAgent.stream(iterationPrompt, {
           structuredOutput: {
             schema: TaskExecutionIterationInputSchema(tasks.length),
             model
@@ -15627,8 +17397,8 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
     const mastra = actionArgs.mastra;
     const logger = mastra.getLogger();
     try {
-      chunkNZMDHQVP_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
-      if (actionId && !chunkNZMDHQVP_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+      chunkVY4ENABS_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkVY4ENABS_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
         throw new chunk7NADHFD2_cjs.HTTPException(400, {
           message: `Invalid agent-builder action: ${actionId}. Valid actions are: ${Object.keys(agentBuilderWorkflows).join(", ")}`
         });
@@ -15643,7 +17413,7 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
         const result = await workflowHandlerFn(handlerArgs);
         return result;
       } finally {
-        chunkNZMDHQVP_cjs.WorkflowRegistry.cleanup();
+        chunkVY4ENABS_cjs.WorkflowRegistry.cleanup();
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -15657,10 +17427,10 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
 }
 var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () => {
   try {
-    const registryWorkflows = chunkNZMDHQVP_cjs.WorkflowRegistry.getAllWorkflows();
+    const registryWorkflows = chunkVY4ENABS_cjs.WorkflowRegistry.getAllWorkflows();
     const _workflows = Object.entries(registryWorkflows).reduce(
       (acc, [key, workflow]) => {
-        acc[key] = chunkNZMDHQVP_cjs.getWorkflowInfo(workflow);
+        acc[key] = chunkVY4ENABS_cjs.getWorkflowInfo(workflow);
         return acc;
       },
       {}
@@ -15671,59 +17441,59 @@ var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () =
   }
 }, "Getting agent builder actions");
 var getAgentBuilderActionByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.getWorkflowByIdHandler,
+  chunkMQDBNHBT_cjs.getWorkflowByIdHandler,
   "Getting agent builder action by ID"
 );
 var getAgentBuilderActionRunByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.getWorkflowRunByIdHandler,
+  chunkMQDBNHBT_cjs.getWorkflowRunByIdHandler,
   "Getting agent builder action run by ID"
 );
 var getAgentBuilderActionRunExecutionResultHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.getWorkflowRunExecutionResultHandler,
+  chunkMQDBNHBT_cjs.getWorkflowRunExecutionResultHandler,
   "Getting agent builder action run execution result"
 );
 var createAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.createWorkflowRunHandler,
+  chunkMQDBNHBT_cjs.createWorkflowRunHandler,
   "Creating agent builder action run"
 );
 var startAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.startAsyncWorkflowHandler,
+  chunkMQDBNHBT_cjs.startAsyncWorkflowHandler,
   "Starting async agent builder action"
 );
 var startAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.startWorkflowRunHandler,
+  chunkMQDBNHBT_cjs.startWorkflowRunHandler,
   "Starting agent builder action run"
 );
 var watchAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.watchWorkflowHandler,
+  chunkMQDBNHBT_cjs.watchWorkflowHandler,
   "Watching agent builder action"
 );
 var streamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.streamWorkflowHandler,
+  chunkMQDBNHBT_cjs.streamWorkflowHandler,
   "Streaming agent builder action"
 );
 var streamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.streamVNextWorkflowHandler,
+  chunkMQDBNHBT_cjs.streamVNextWorkflowHandler,
   "Streaming VNext agent builder action"
 );
 var resumeAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.resumeAsyncWorkflowHandler,
+  chunkMQDBNHBT_cjs.resumeAsyncWorkflowHandler,
   "Resuming async agent builder action"
 );
 var resumeAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.resumeWorkflowHandler,
+  chunkMQDBNHBT_cjs.resumeWorkflowHandler,
   "Resuming agent builder action"
 );
 var getAgentBuilderActionRunsHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.getWorkflowRunsHandler,
+  chunkMQDBNHBT_cjs.getWorkflowRunsHandler,
   "Getting agent builder action runs"
 );
 var cancelAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.cancelWorkflowRunHandler,
+  chunkMQDBNHBT_cjs.cancelWorkflowRunHandler,
   "Cancelling agent builder action run"
 );
 var sendAgentBuilderActionRunEventHandler = createAgentBuilderWorkflowHandler(
-  chunkNZMDHQVP_cjs.sendWorkflowRunEventHandler,
+  chunkMQDBNHBT_cjs.sendWorkflowRunEventHandler,
   "Sending agent builder action run event"
 );
 
@@ -15743,5 +17513,5 @@ exports.startAsyncAgentBuilderActionHandler = startAsyncAgentBuilderActionHandle
 exports.streamAgentBuilderActionHandler = streamAgentBuilderActionHandler;
 exports.streamVNextAgentBuilderActionHandler = streamVNextAgentBuilderActionHandler;
 exports.watchAgentBuilderActionHandler = watchAgentBuilderActionHandler;
-//# sourceMappingURL=chunk-HJ4EQIE6.cjs.map
-//# sourceMappingURL=chunk-HJ4EQIE6.cjs.map
+//# sourceMappingURL=chunk-7HDOBOGG.cjs.map
+//# sourceMappingURL=chunk-7HDOBOGG.cjs.map