@mastra/mcp 0.4.2-alpha.1 → 0.4.2-alpha.3

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MastraBase } from '@mastra/core/base';
 import { createTool } from '@mastra/core/tools';
-import { jsonSchemaToModel } from '@mastra/core/utils';
+import { resolveSerializedZodOutput as resolveSerializedZodOutput$1, isZodType as isZodType$1 } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
@@ -20,924 +20,1561 @@ import * as path from 'path';
 
 // src/client.ts
 
-// ../../node_modules/.pnpm/zod@3.24.3/node_modules/zod/lib/index.mjs
-var util;
-(function(util2) {
-  util2.assertEqual = (val) => val;
-  function assertIs(_arg) {
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseAnyOf.js
+var parseAnyOf = (schema, refs) => {
+  return schema.anyOf.length ? schema.anyOf.length === 1 ? parseSchema(schema.anyOf[0], {
+    ...refs,
+    path: [...refs.path, "anyOf", 0]
+  }) : `z.union([${schema.anyOf.map((schema2, i) => parseSchema(schema2, { ...refs, path: [...refs.path, "anyOf", i] })).join(", ")}])` : `z.any()`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseBoolean.js
+var parseBoolean = (_schema) => {
+  return "z.boolean()";
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseDefault.js
+var parseDefault = (_schema) => {
+  return "z.any()";
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseMultipleType.js
+var parseMultipleType = (schema, refs) => {
+  return `z.union([${schema.type.map((type) => parseSchema({ ...schema, type }, refs)).join(", ")}])`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNot.js
+var parseNot = (schema, refs) => {
+  return `z.any().refine((value) => !${parseSchema(schema.not, {
+    ...refs,
+    path: [...refs.path, "not"]
+  })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNull.js
+var parseNull = (_schema) => {
+  return "z.null()";
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/half.js
+var half = (arr) => {
+  return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseAllOf.js
+var originalIndex = Symbol("Original index");
+var ensureOriginalIndex = (arr) => {
+  let newArr = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (typeof item === "boolean") {
+      newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+    } else if (originalIndex in item) {
+      return arr;
+    } else {
+      newArr.push({ ...item, [originalIndex]: i });
+    }
   }
-  util2.assertIs = assertIs;
-  function assertNever(_x) {
-    throw new Error();
+  return newArr;
+};
+function parseAllOf(schema, refs) {
+  if (schema.allOf.length === 0) {
+    return "z.never()";
+  } else if (schema.allOf.length === 1) {
+    const item = schema.allOf[0];
+    return parseSchema(item, {
+      ...refs,
+      path: [...refs.path, "allOf", item[originalIndex]]
+    });
+  } else {
+    const [left, right] = half(ensureOriginalIndex(schema.allOf));
+    return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
+      allOf: right
+    }, refs)})`;
   }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
+}
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/withMessage.js
+function withMessage(schema, key, get) {
+  const value = schema[key];
+  let r = "";
+  if (value !== void 0) {
+    const got = get({ value, json: JSON.stringify(value) });
+    if (got) {
+      const opener = got[0];
+      const prefix = got.length === 3 ? got[1] : "";
+      const closer = got.length === 3 ? got[2] : got[1];
+      r += opener;
+      if (schema.errorMessage?.[key] !== void 0) {
+        r += prefix + JSON.stringify(schema.errorMessage[key]);
+      }
+      r += closer;
     }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
+  }
+  return r;
+}
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseArray.js
+var parseArray = (schema, refs) => {
+  if (Array.isArray(schema.items)) {
+    return `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+  }
+  let r = !schema.items ? "z.array(z.any())" : `z.array(${parseSchema(schema.items, {
+    ...refs,
+    path: [...refs.path, "items"]
+  })})`;
+  r += withMessage(schema, "minItems", ({ json }) => [
+    `.min(${json}`,
+    ", ",
+    ")"
+  ]);
+  r += withMessage(schema, "maxItems", ({ json }) => [
+    `.max(${json}`,
+    ", ",
+    ")"
+  ]);
+  return r;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseConst.js
+var parseConst = (schema) => {
+  return `z.literal(${JSON.stringify(schema.const)})`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseEnum.js
+var parseEnum = (schema) => {
+  if (schema.enum.length === 0) {
+    return "z.never()";
+  } else if (schema.enum.length === 1) {
+    return `z.literal(${JSON.stringify(schema.enum[0])})`;
+  } else if (schema.enum.every((x) => typeof x === "string")) {
+    return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
+  } else {
+    return `z.union([${schema.enum.map((x) => `z.literal(${JSON.stringify(x)})`).join(", ")}])`;
+  }
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseIfThenElse.js
+var parseIfThenElse = (schema, refs) => {
+  const $if = parseSchema(schema.if, { ...refs, path: [...refs.path, "if"] });
+  const $then = parseSchema(schema.then, {
+    ...refs,
+    path: [...refs.path, "then"]
+  });
+  const $else = parseSchema(schema.else, {
+    ...refs,
+    path: [...refs.path, "else"]
+  });
+  return `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
+  const result = ${$if}.safeParse(value).success
+    ? ${$then}.safeParse(value)
+    : ${$else}.safeParse(value);
+  if (!result.success) {
+    result.error.errors.forEach((error) => ctx.addIssue(error))
+  }
+})`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNumber.js
+var parseNumber = (schema) => {
+  let r = "z.number()";
+  if (schema.type === "integer") {
+    r += withMessage(schema, "type", () => [".int(", ")"]);
+  } else {
+    r += withMessage(schema, "format", ({ value }) => {
+      if (value === "int64") {
+        return [".int(", ")"];
+      }
     });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys.push(key);
+  }
+  r += withMessage(schema, "multipleOf", ({ value, json }) => {
+    if (value === 1) {
+      if (r.startsWith("z.number().int(")) {
+        return;
       }
+      return [".int(", ")"];
     }
-    return keys;
-  };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item))
-        return item;
+    return [`.multipleOf(${json}`, ", ", ")"];
+  });
+  if (typeof schema.minimum === "number") {
+    if (schema.exclusiveMinimum === true) {
+      r += withMessage(schema, "minimum", ({ json }) => [
+        `.gt(${json}`,
+        ", ",
+        ")"
+      ]);
+    } else {
+      r += withMessage(schema, "minimum", ({ json }) => [
+        `.gte(${json}`,
+        ", ",
+        ")"
+      ]);
     }
-    return void 0;
-  };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
-  function joinValues(array, separator = " | ") {
-    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  } else if (typeof schema.exclusiveMinimum === "number") {
+    r += withMessage(schema, "exclusiveMinimum", ({ json }) => [
+      `.gt(${json}`,
+      ", ",
+      ")"
+    ]);
   }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
+  if (typeof schema.maximum === "number") {
+    if (schema.exclusiveMaximum === true) {
+      r += withMessage(schema, "maximum", ({ json }) => [
+        `.lt(${json}`,
+        ", ",
+        ")"
+      ]);
+    } else {
+      r += withMessage(schema, "maximum", ({ json }) => [
+        `.lte(${json}`,
+        ", ",
+        ")"
+      ]);
     }
-    return value;
-  };
-})(util || (util = {}));
-var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
-    return {
-      ...first,
-      ...second
-      // second overwrites first
-    };
-  };
-})(objectUtil || (objectUtil = {}));
-var ZodParsedType = util.arrayToEnum([
-  "string",
-  "nan",
-  "number",
-  "integer",
-  "float",
-  "boolean",
-  "date",
-  "bigint",
-  "symbol",
-  "function",
-  "undefined",
-  "null",
-  "array",
-  "object",
-  "unknown",
-  "promise",
-  "void",
-  "never",
-  "map",
-  "set"
-]);
-var getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
-    case "undefined":
-      return ZodParsedType.undefined;
-    case "string":
-      return ZodParsedType.string;
-    case "number":
-      return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-    case "boolean":
-      return ZodParsedType.boolean;
-    case "function":
-      return ZodParsedType.function;
-    case "bigint":
-      return ZodParsedType.bigint;
-    case "symbol":
-      return ZodParsedType.symbol;
-    case "object":
-      if (Array.isArray(data)) {
-        return ZodParsedType.array;
-      }
-      if (data === null) {
-        return ZodParsedType.null;
-      }
-      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
-        return ZodParsedType.promise;
-      }
-      if (typeof Map !== "undefined" && data instanceof Map) {
-        return ZodParsedType.map;
-      }
-      if (typeof Set !== "undefined" && data instanceof Set) {
-        return ZodParsedType.set;
-      }
-      if (typeof Date !== "undefined" && data instanceof Date) {
-        return ZodParsedType.date;
-      }
-      return ZodParsedType.object;
-    default:
-      return ZodParsedType.unknown;
+  } else if (typeof schema.exclusiveMaximum === "number") {
+    r += withMessage(schema, "exclusiveMaximum", ({ json }) => [
+      `.lt(${json}`,
+      ", ",
+      ")"
+    ]);
   }
+  return r;
 };
-var ZodIssueCode = util.arrayToEnum([
-  "invalid_type",
-  "invalid_literal",
-  "custom",
-  "invalid_union",
-  "invalid_union_discriminator",
-  "invalid_enum_value",
-  "unrecognized_keys",
-  "invalid_arguments",
-  "invalid_return_type",
-  "invalid_date",
-  "invalid_string",
-  "too_small",
-  "too_big",
-  "invalid_intersection_types",
-  "not_multiple_of",
-  "not_finite"
-]);
-var quotelessJson = (obj) => {
-  const json = JSON.stringify(obj, null, 2);
-  return json.replace(/"([^"]+)":/g, "$1:");
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseOneOf.js
+var parseOneOf = (schema, refs) => {
+  return schema.oneOf.length ? schema.oneOf.length === 1 ? parseSchema(schema.oneOf[0], {
+    ...refs,
+    path: [...refs.path, "oneOf", 0]
+  }) : `z.any().superRefine((x, ctx) => {
+    const schemas = [${schema.oneOf.map((schema2, i) => parseSchema(schema2, {
+    ...refs,
+    path: [...refs.path, "oneOf", i]
+  })).join(", ")}];
+    const errors = schemas.reduce<z.ZodError[]>(
+      (errors, schema) =>
+        ((result) =>
+          result.error ? [...errors, result.error] : errors)(
+          schema.safeParse(x),
+        ),
+      [],
+    );
+    if (schemas.length - errors.length !== 1) {
+      ctx.addIssue({
+        path: ctx.path,
+        code: "invalid_union",
+        unionErrors: errors,
+        message: "Invalid input: Should pass single schema",
+      });
+    }
+  })` : "z.any()";
 };
-var ZodError = class _ZodError extends Error {
-  get errors() {
-    return this.issues;
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/jsdocs.js
+var expandJsdocs = (jsdocs) => {
+  const lines = jsdocs.split("\n");
+  const result = lines.length === 1 ? lines[0] : `
+${lines.map((x) => `* ${x}`).join("\n")}
+`;
+  return `/**${result}*/
+`;
+};
+var addJsdocs = (schema, parsed) => {
+  const description = schema.description;
+  if (!description) {
+    return parsed;
   }
-  constructor(issues) {
-    super();
-    this.issues = [];
-    this.addIssue = (sub) => {
-      this.issues = [...this.issues, sub];
-    };
-    this.addIssues = (subs = []) => {
-      this.issues = [...this.issues, ...subs];
-    };
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(this, actualProto);
+  return `
+${expandJsdocs(description)}${parsed}`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseObject.js
+function parseObject(objectSchema, refs) {
+  let properties = void 0;
+  if (objectSchema.properties) {
+    if (!Object.keys(objectSchema.properties).length) {
+      properties = "z.object({})";
     } else {
-      this.__proto__ = actualProto;
+      properties = "z.object({ ";
+      properties += Object.keys(objectSchema.properties).map((key) => {
+        const propSchema = objectSchema.properties[key];
+        let result = `${JSON.stringify(key)}: ${parseSchema(propSchema, {
+          ...refs,
+          path: [...refs.path, "properties", key]
+        })}`;
+        if (refs.withJsdocs && typeof propSchema === "object") {
+          result = addJsdocs(propSchema, result);
+        }
+        const hasDefault = typeof propSchema === "object" && propSchema.default !== void 0;
+        const required = Array.isArray(objectSchema.required) ? objectSchema.required.includes(key) : typeof propSchema === "object" && propSchema.required === true;
+        const optional = !hasDefault && !required;
+        return optional ? `${result}.optional()` : result;
+      }).join(", ");
+      properties += " })";
     }
-    this.name = "ZodError";
-    this.issues = issues;
   }
-  format(_mapper) {
-    const mapper = _mapper || function(issue) {
-      return issue.message;
-    };
-    const fieldErrors = { _errors: [] };
-    const processError = (error) => {
-      for (const issue of error.issues) {
-        if (issue.code === "invalid_union") {
-          issue.unionErrors.map(processError);
-        } else if (issue.code === "invalid_return_type") {
-          processError(issue.returnTypeError);
-        } else if (issue.code === "invalid_arguments") {
-          processError(issue.argumentsError);
-        } else if (issue.path.length === 0) {
-          fieldErrors._errors.push(mapper(issue));
-        } else {
-          let curr = fieldErrors;
-          let i = 0;
-          while (i < issue.path.length) {
-            const el = issue.path[i];
-            const terminal = i === issue.path.length - 1;
-            if (!terminal) {
-              curr[el] = curr[el] || { _errors: [] };
-            } else {
-              curr[el] = curr[el] || { _errors: [] };
-              curr[el]._errors.push(mapper(issue));
-            }
-            curr = curr[el];
-            i++;
-          }
-        }
+  const additionalProperties = objectSchema.additionalProperties !== void 0 ? parseSchema(objectSchema.additionalProperties, {
+    ...refs,
+    path: [...refs.path, "additionalProperties"]
+  }) : void 0;
+  let patternProperties = void 0;
+  if (objectSchema.patternProperties) {
+    const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
+      return [
+        key,
+        parseSchema(value, {
+          ...refs,
+          path: [...refs.path, "patternProperties", key]
+        })
+      ];
+    }, {}));
+    patternProperties = "";
+    if (properties) {
+      if (additionalProperties) {
+        patternProperties += `.catchall(z.union([${[
+          ...Object.values(parsedPatternProperties),
+          additionalProperties
+        ].join(", ")}]))`;
+      } else if (Object.keys(parsedPatternProperties).length > 1) {
+        patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+      } else {
+        patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
+      }
+    } else {
+      if (additionalProperties) {
+        patternProperties += `z.record(z.union([${[
+          ...Object.values(parsedPatternProperties),
+          additionalProperties
+        ].join(", ")}]))`;
+      } else if (Object.keys(parsedPatternProperties).length > 1) {
+        patternProperties += `z.record(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
+      } else {
+        patternProperties += `z.record(${Object.values(parsedPatternProperties)})`;
       }
-    };
-    processError(this);
-    return fieldErrors;
-  }
-  static assert(value) {
-    if (!(value instanceof _ZodError)) {
-      throw new Error(`Not a ZodError: ${value}`);
     }
+    patternProperties += ".superRefine((value, ctx) => {\n";
+    patternProperties += "for (const key in value) {\n";
+    if (additionalProperties) {
+      if (objectSchema.properties) {
+        patternProperties += `let evaluated = [${Object.keys(objectSchema.properties).map((key) => JSON.stringify(key)).join(", ")}].includes(key)
+`;
+      } else {
+        patternProperties += `let evaluated = false
+`;
+      }
+    }
+    for (const key in objectSchema.patternProperties) {
+      patternProperties += "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
+      if (additionalProperties) {
+        patternProperties += "evaluated = true\n";
+      }
+      patternProperties += "const result = " + parsedPatternProperties[key] + ".safeParse(value[key])\n";
+      patternProperties += "if (!result.success) {\n";
+      patternProperties += `ctx.addIssue({
+          path: [...ctx.path, key],
+          code: 'custom',
+          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
+          params: {
+            issues: result.error.issues
+          }
+        })
+`;
+      patternProperties += "}\n";
+      patternProperties += "}\n";
+    }
+    if (additionalProperties) {
+      patternProperties += "if (!evaluated) {\n";
+      patternProperties += "const result = " + additionalProperties + ".safeParse(value[key])\n";
+      patternProperties += "if (!result.success) {\n";
+      patternProperties += `ctx.addIssue({
+          path: [...ctx.path, key],
+          code: 'custom',
+          message: \`Invalid input: must match catchall schema\`,
+          params: {
+            issues: result.error.issues
+          }
+        })
+`;
+      patternProperties += "}\n";
+      patternProperties += "}\n";
+    }
+    patternProperties += "}\n";
+    patternProperties += "})";
   }
-  toString() {
-    return this.message;
+  let output = properties ? patternProperties ? properties + patternProperties : additionalProperties ? additionalProperties === "z.never()" ? properties + ".strict()" : properties + `.catchall(${additionalProperties})` : properties : patternProperties ? patternProperties : additionalProperties ? `z.record(${additionalProperties})` : "z.record(z.any())";
+  if (its.an.anyOf(objectSchema)) {
+    output += `.and(${parseAnyOf({
+      anyOf: objectSchema.anyOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
+    }, refs)})`;
   }
-  get message() {
-    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+  if (its.a.oneOf(objectSchema)) {
+    output += `.and(${parseOneOf({
+      oneOf: objectSchema.oneOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
+    }, refs)})`;
   }
-  get isEmpty() {
-    return this.issues.length === 0;
+  if (its.an.allOf(objectSchema)) {
+    output += `.and(${parseAllOf({
+      allOf: objectSchema.allOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
+    }, refs)})`;
   }
-  flatten(mapper = (issue) => issue.message) {
-    const fieldErrors = {};
-    const formErrors = [];
-    for (const sub of this.issues) {
-      if (sub.path.length > 0) {
-        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-        fieldErrors[sub.path[0]].push(mapper(sub));
-      } else {
-        formErrors.push(mapper(sub));
+  return output;
+}
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseString.js
+var parseString = (schema) => {
+  let r = "z.string()";
+  r += withMessage(schema, "format", ({ value }) => {
+    switch (value) {
+      case "email":
+        return [".email(", ")"];
+      case "ip":
+        return [".ip(", ")"];
+      case "ipv4":
+        return ['.ip({ version: "v4"', ", message: ", " })"];
+      case "ipv6":
+        return ['.ip({ version: "v6"', ", message: ", " })"];
+      case "uri":
+        return [".url(", ")"];
+      case "uuid":
+        return [".uuid(", ")"];
+      case "date-time":
+        return [".datetime({ offset: true", ", message: ", " })"];
+      case "time":
+        return [".time(", ")"];
+      case "date":
+        return [".date(", ")"];
+      case "binary":
+        return [".base64(", ")"];
+      case "duration":
+        return [".duration(", ")"];
+    }
+  });
+  r += withMessage(schema, "pattern", ({ json }) => [
+    `.regex(new RegExp(${json})`,
+    ", ",
+    ")"
+  ]);
+  r += withMessage(schema, "minLength", ({ json }) => [
+    `.min(${json}`,
+    ", ",
+    ")"
+  ]);
+  r += withMessage(schema, "maxLength", ({ json }) => [
+    `.max(${json}`,
+    ", ",
+    ")"
+  ]);
+  r += withMessage(schema, "contentEncoding", ({ value }) => {
+    if (value === "base64") {
+      return [".base64(", ")"];
+    }
+  });
+  const contentMediaType = withMessage(schema, "contentMediaType", ({ value }) => {
+    if (value === "application/json") {
+      return [
+        '.transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: "custom", message: "Invalid JSON" }); }}',
+        ", ",
+        ")"
+      ];
+    }
+  });
+  if (contentMediaType != "") {
+    r += contentMediaType;
+    r += withMessage(schema, "contentSchema", ({ value }) => {
+      if (value && value instanceof Object) {
+        return [
+          `.pipe(${parseSchema(value)}`,
+          ", ",
+          ")"
+        ];
       }
+    });
+  }
+  return r;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/omit.js
+var omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
+  if (!keys.includes(key)) {
+    acc[key] = obj[key];
+  }
+  return acc;
+}, {});
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNullable.js
+var parseNullable = (schema, refs) => {
+  return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseSchema.js
+var parseSchema = (schema, refs = { seen: /* @__PURE__ */ new Map(), path: [] }, blockMeta) => {
+  if (typeof schema !== "object")
+    return schema ? "z.any()" : "z.never()";
+  if (refs.parserOverride) {
+    const custom2 = refs.parserOverride(schema, refs);
+    if (typeof custom2 === "string") {
+      return custom2;
     }
-    return { formErrors, fieldErrors };
   }
-  get formErrors() {
-    return this.flatten();
+  let seen = refs.seen.get(schema);
+  if (seen) {
+    if (seen.r !== void 0) {
+      return seen.r;
+    }
+    if (refs.depth === void 0 || seen.n >= refs.depth) {
+      return "z.any()";
+    }
+    seen.n += 1;
+  } else {
+    seen = { r: void 0, n: 0 };
+    refs.seen.set(schema, seen);
+  }
+  let parsed = selectParser(schema, refs);
+  if (!blockMeta) {
+    if (!refs.withoutDescribes) {
+      parsed = addDescribes(schema, parsed);
+    }
+    if (!refs.withoutDefaults) {
+      parsed = addDefaults(schema, parsed);
+    }
+    parsed = addAnnotations(schema, parsed);
   }
+  seen.r = parsed;
+  return parsed;
 };
-ZodError.create = (issues) => {
-  const error = new ZodError(issues);
-  return error;
+var addDescribes = (schema, parsed) => {
+  if (schema.description) {
+    parsed += `.describe(${JSON.stringify(schema.description)})`;
+  }
+  return parsed;
 };
-var errorMap = (issue, _ctx) => {
-  let message;
-  switch (issue.code) {
-    case ZodIssueCode.invalid_type:
-      if (issue.received === ZodParsedType.undefined) {
-        message = "Required";
-      } else {
-        message = `Expected ${issue.expected}, received ${issue.received}`;
-      }
-      break;
-    case ZodIssueCode.invalid_literal:
-      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
-      break;
-    case ZodIssueCode.unrecognized_keys:
-      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
-      break;
-    case ZodIssueCode.invalid_union:
-      message = `Invalid input`;
-      break;
-    case ZodIssueCode.invalid_union_discriminator:
-      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
-      break;
-    case ZodIssueCode.invalid_enum_value:
-      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
-      break;
-    case ZodIssueCode.invalid_arguments:
-      message = `Invalid function arguments`;
-      break;
-    case ZodIssueCode.invalid_return_type:
-      message = `Invalid function return type`;
-      break;
-    case ZodIssueCode.invalid_date:
-      message = `Invalid date`;
-      break;
-    case ZodIssueCode.invalid_string:
-      if (typeof issue.validation === "object") {
-        if ("includes" in issue.validation) {
-          message = `Invalid input: must include "${issue.validation.includes}"`;
-          if (typeof issue.validation.position === "number") {
-            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
-          }
-        } else if ("startsWith" in issue.validation) {
-          message = `Invalid input: must start with "${issue.validation.startsWith}"`;
-        } else if ("endsWith" in issue.validation) {
-          message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-        } else {
-          util.assertNever(issue.validation);
-        }
-      } else if (issue.validation !== "regex") {
-        message = `Invalid ${issue.validation}`;
-      } else {
-        message = "Invalid";
-      }
-      break;
-    case ZodIssueCode.too_small:
-      if (issue.type === "array")
-        message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
-      else if (issue.type === "string")
-        message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
-      else if (issue.type === "number")
-        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
-      else if (issue.type === "date")
-        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
-      else
-        message = "Invalid input";
-      break;
-    case ZodIssueCode.too_big:
-      if (issue.type === "array")
-        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
-      else if (issue.type === "string")
-        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
-      else if (issue.type === "number")
-        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
-      else if (issue.type === "bigint")
-        message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
-      else if (issue.type === "date")
-        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
-      else
-        message = "Invalid input";
-      break;
-    case ZodIssueCode.custom:
-      message = `Invalid input`;
-      break;
-    case ZodIssueCode.invalid_intersection_types:
-      message = `Intersection results could not be merged`;
-      break;
-    case ZodIssueCode.not_multiple_of:
-      message = `Number must be a multiple of ${issue.multipleOf}`;
-      break;
-    case ZodIssueCode.not_finite:
-      message = "Number must be finite";
-      break;
-    default:
-      message = _ctx.defaultError;
-      util.assertNever(issue);
+var addDefaults = (schema, parsed) => {
+  if (schema.default !== void 0) {
+    parsed += `.default(${JSON.stringify(schema.default)})`;
   }
-  return { message };
+  return parsed;
 };
-var overrideErrorMap = errorMap;
-function setErrorMap(map) {
-  overrideErrorMap = map;
-}
-function getErrorMap() {
-  return overrideErrorMap;
-}
-var makeIssue = (params) => {
-  const { data, path: path2, errorMaps, issueData } = params;
-  const fullPath = [...path2, ...issueData.path || []];
-  const fullIssue = {
-    ...issueData,
-    path: fullPath
-  };
-  if (issueData.message !== void 0) {
-    return {
-      ...issueData,
-      path: fullPath,
-      message: issueData.message
-    };
-  }
-  let errorMessage = "";
-  const maps = errorMaps.filter((m) => !!m).slice().reverse();
-  for (const map of maps) {
-    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
+var addAnnotations = (schema, parsed) => {
+  if (schema.readOnly) {
+    parsed += ".readonly()";
   }
-  return {
-    ...issueData,
-    path: fullPath,
-    message: errorMessage
-  };
+  return parsed;
 };
-var EMPTY_PATH = [];
-function addIssueToContext(ctx, issueData) {
-  const overrideMap = getErrorMap();
-  const issue = makeIssue({
-    issueData,
-    data: ctx.data,
-    path: ctx.path,
-    errorMaps: [
-      ctx.common.contextualErrorMap,
-      // contextual error map is first priority
-      ctx.schemaErrorMap,
-      // then schema-bound map if available
-      overrideMap,
-      // then global override map
-      overrideMap === errorMap ? void 0 : errorMap
-      // then global default map
-    ].filter((x) => !!x)
-  });
-  ctx.common.issues.push(issue);
-}
-var ParseStatus = class _ParseStatus {
-  constructor() {
-    this.value = "valid";
+var selectParser = (schema, refs) => {
+  if (its.a.nullable(schema)) {
+    return parseNullable(schema, refs);
+  } else if (its.an.object(schema)) {
+    return parseObject(schema, refs);
+  } else if (its.an.array(schema)) {
+    return parseArray(schema, refs);
+  } else if (its.an.anyOf(schema)) {
+    return parseAnyOf(schema, refs);
+  } else if (its.an.allOf(schema)) {
+    return parseAllOf(schema, refs);
+  } else if (its.a.oneOf(schema)) {
+    return parseOneOf(schema, refs);
+  } else if (its.a.not(schema)) {
+    return parseNot(schema, refs);
+  } else if (its.an.enum(schema)) {
+    return parseEnum(schema);
+  } else if (its.a.const(schema)) {
+    return parseConst(schema);
+  } else if (its.a.multipleType(schema)) {
+    return parseMultipleType(schema, refs);
+  } else if (its.a.primitive(schema, "string")) {
+    return parseString(schema);
+  } else if (its.a.primitive(schema, "number") || its.a.primitive(schema, "integer")) {
+    return parseNumber(schema);
+  } else if (its.a.primitive(schema, "boolean")) {
+    return parseBoolean();
+  } else if (its.a.primitive(schema, "null")) {
+    return parseNull();
+  } else if (its.a.conditional(schema)) {
+    return parseIfThenElse(schema, refs);
+  } else {
+    return parseDefault();
   }
-  dirty() {
-    if (this.value === "valid")
-      this.value = "dirty";
+};
+var its = {
+  an: {
+    object: (x) => x.type === "object",
+    array: (x) => x.type === "array",
+    anyOf: (x) => x.anyOf !== void 0,
+    allOf: (x) => x.allOf !== void 0,
+    enum: (x) => x.enum !== void 0
+  },
+  a: {
+    nullable: (x) => x.nullable === true,
+    multipleType: (x) => Array.isArray(x.type),
+    not: (x) => x.not !== void 0,
+    const: (x) => x.const !== void 0,
+    primitive: (x, p) => x.type === p,
+    conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),
+    oneOf: (x) => x.oneOf !== void 0
   }
-  abort() {
-    if (this.value !== "aborted")
-      this.value = "aborted";
+};
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/jsonSchemaToZod.js
+var jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
+  if (type && (!name || module !== "esm")) {
+    throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
   }
-  static mergeArray(status, results) {
-    const arrayValue = [];
-    for (const s of results) {
-      if (s.status === "aborted")
-        return INVALID;
-      if (s.status === "dirty")
-        status.dirty();
-      arrayValue.push(s.value);
+  let result = parseSchema(schema, {
+    module,
+    name,
+    path: [],
+    seen: /* @__PURE__ */ new Map(),
+    ...rest
+  });
+  const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description ? expandJsdocs(schema.description) : "";
+  if (module === "cjs") {
+    result = `${jsdocs}module.exports = ${name ? `{ ${JSON.stringify(name)}: ${result} }` : result}
+`;
+    if (!noImport) {
+      result = `${jsdocs}const { z } = require("zod")
+
+${result}`;
     }
-    return { status: status.value, value: arrayValue };
-  }
-  static async mergeObjectAsync(status, pairs) {
-    const syncPairs = [];
-    for (const pair of pairs) {
-      const key = await pair.key;
-      const value = await pair.value;
-      syncPairs.push({
-        key,
-        value
-      });
+  } else if (module === "esm") {
+    result = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${result}
+`;
+    if (!noImport) {
+      result = `import { z } from "zod"
+
+${result}`;
     }
-    return _ParseStatus.mergeObjectSync(status, syncPairs);
+  } else if (name) {
+    result = `${jsdocs}const ${name} = ${result}`;
   }
-  static mergeObjectSync(status, pairs) {
-    const finalObject = {};
-    for (const pair of pairs) {
-      const { key, value } = pair;
-      if (key.status === "aborted")
-        return INVALID;
-      if (value.status === "aborted")
-        return INVALID;
-      if (key.status === "dirty")
-        status.dirty();
-      if (value.status === "dirty")
-        status.dirty();
-      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
-        finalObject[key.value] = value.value;
-      }
-    }
-    return { status: status.value, value: finalObject };
+  if (type && name) {
+    let typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
+    result += `export type ${typeName} = z.infer<typeof ${name}>
+`;
   }
+  return result;
 };
-var INVALID = Object.freeze({
-  status: "aborted"
-});
-var DIRTY = (value) => ({ status: "dirty", value });
-var OK = (value) => ({ status: "valid", value });
-var isAborted = (x) => x.status === "aborted";
-var isDirty = (x) => x.status === "dirty";
-var isValid = (x) => x.status === "valid";
-var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-function __classPrivateFieldGet(receiver, state, kind, f) {
-  if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return state.get(receiver);
-}
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-  if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return state.set(receiver, value), value;
-}
-var errorUtil;
-(function(errorUtil2) {
-  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-  errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
-})(errorUtil || (errorUtil = {}));
-var _ZodEnum_cache;
-var _ZodNativeEnum_cache;
-var ParseInputLazyPath = class {
-  constructor(parent, value, path2, key) {
-    this._cachedPath = [];
-    this.parent = parent;
-    this.data = value;
-    this._path = path2;
-    this._key = key;
+
+// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/index.js
+var esm_default = jsonSchemaToZod;
+
+// ../../node_modules/.pnpm/zod@3.24.3/node_modules/zod/lib/index.mjs
+var util;
+(function(util2) {
+  util2.assertEqual = (val) => val;
+  function assertIs(_arg) {
   }
-  get path() {
-    if (!this._cachedPath.length) {
-      if (this._key instanceof Array) {
-        this._cachedPath.push(...this._path, ...this._key);
-      } else {
-        this._cachedPath.push(...this._path, this._key);
+  util2.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error();
+  }
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util2.objectValues(filtered);
+  };
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
       }
     }
-    return this._cachedPath;
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-};
-var handleResult = (ctx, result) => {
-  if (isValid(result)) {
-    return { success: true, data: result.value };
-  } else {
-    if (!ctx.common.issues.length) {
-      throw new Error("Validation failed but no issues detected.");
+  util2.joinValues = joinValues;
+  util2.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
     }
+    return value;
+  };
+})(util || (util = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
     return {
-      success: false,
-      get error() {
-        if (this._error)
-          return this._error;
-        const error = new ZodError(ctx.common.issues);
-        this._error = error;
-        return this._error;
-      }
+      ...first,
+      ...second
+      // second overwrites first
     };
-  }
-};
-function processCreateParams(params) {
-  if (!params)
-    return {};
-  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
-  if (errorMap2 && (invalid_type_error || required_error)) {
-    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
-  }
-  if (errorMap2)
-    return { errorMap: errorMap2, description };
-  const customMap = (iss, ctx) => {
-    var _a, _b;
-    const { message } = params;
-    if (iss.code === "invalid_enum_value") {
-      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
-    }
-    if (typeof ctx.data === "undefined") {
-      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
-    }
-    if (iss.code !== "invalid_type")
-      return { message: ctx.defaultError };
-    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
   };
-  return { errorMap: customMap, description };
-}
-var ZodType = class {
-  get description() {
-    return this._def.description;
+})(objectUtil || (objectUtil = {}));
+var ZodParsedType = util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+var getParsedType = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return ZodParsedType.undefined;
+    case "string":
+      return ZodParsedType.string;
+    case "number":
+      return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+    case "boolean":
+      return ZodParsedType.boolean;
+    case "function":
+      return ZodParsedType.function;
+    case "bigint":
+      return ZodParsedType.bigint;
+    case "symbol":
+      return ZodParsedType.symbol;
+    case "object":
+      if (Array.isArray(data)) {
+        return ZodParsedType.array;
+      }
+      if (data === null) {
+        return ZodParsedType.null;
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return ZodParsedType.promise;
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return ZodParsedType.map;
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return ZodParsedType.set;
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return ZodParsedType.date;
+      }
+      return ZodParsedType.object;
+    default:
+      return ZodParsedType.unknown;
   }
-  _getType(input) {
-    return getParsedType(input.data);
+};
+var ZodIssueCode = util.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite"
+]);
+var quotelessJson = (obj) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+};
+var ZodError = class _ZodError extends Error {
+  get errors() {
+    return this.issues;
   }
-  _getOrReturnCtx(input, ctx) {
-    return ctx || {
-      common: input.parent.common,
-      data: input.data,
-      parsedType: getParsedType(input.data),
-      schemaErrorMap: this._def.errorMap,
-      path: input.path,
-      parent: input.parent
+  constructor(issues) {
+    super();
+    this.issues = [];
+    this.addIssue = (sub) => {
+      this.issues = [...this.issues, sub];
     };
-  }
-  _processInputParams(input) {
-    return {
-      status: new ParseStatus(),
-      ctx: {
-        common: input.parent.common,
-        data: input.data,
-        parsedType: getParsedType(input.data),
-        schemaErrorMap: this._def.errorMap,
-        path: input.path,
-        parent: input.parent
-      }
+    this.addIssues = (subs = []) => {
+      this.issues = [...this.issues, ...subs];
     };
-  }
-  _parseSync(input) {
-    const result = this._parse(input);
-    if (isAsync(result)) {
-      throw new Error("Synchronous parse encountered promise.");
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
     }
-    return result;
+    this.name = "ZodError";
+    this.issues = issues;
   }
-  _parseAsync(input) {
-    const result = this._parse(input);
-    return Promise.resolve(result);
-  }
-  parse(data, params) {
-    const result = this.safeParse(data, params);
-    if (result.success)
-      return result.data;
-    throw result.error;
-  }
-  safeParse(data, params) {
-    var _a;
-    const ctx = {
-      common: {
-        issues: [],
-        async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
-      },
-      path: (params === null || params === void 0 ? void 0 : params.path) || [],
-      schemaErrorMap: this._def.errorMap,
-      parent: null,
-      data,
-      parsedType: getParsedType(data)
-    };
-    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
-    return handleResult(ctx, result);
-  }
-  "~validate"(data) {
-    var _a, _b;
-    const ctx = {
-      common: {
-        issues: [],
-        async: !!this["~standard"].async
-      },
-      path: [],
-      schemaErrorMap: this._def.errorMap,
-      parent: null,
-      data,
-      parsedType: getParsedType(data)
+  format(_mapper) {
+    const mapper = _mapper || function(issue) {
+      return issue.message;
     };
-    if (!this["~standard"].async) {
-      try {
-        const result = this._parseSync({ data, path: [], parent: ctx });
-        return isValid(result) ? {
-          value: result.value
-        } : {
-          issues: ctx.common.issues
-        };
-      } catch (err) {
-        if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) {
-          this["~standard"].async = true;
+    const fieldErrors = { _errors: [] };
+    const processError = (error) => {
+      for (const issue of error.issues) {
+        if (issue.code === "invalid_union") {
+          issue.unionErrors.map(processError);
+        } else if (issue.code === "invalid_return_type") {
+          processError(issue.returnTypeError);
+        } else if (issue.code === "invalid_arguments") {
+          processError(issue.argumentsError);
+        } else if (issue.path.length === 0) {
+          fieldErrors._errors.push(mapper(issue));
+        } else {
+          let curr = fieldErrors;
+          let i = 0;
+          while (i < issue.path.length) {
+            const el = issue.path[i];
+            const terminal = i === issue.path.length - 1;
+            if (!terminal) {
+              curr[el] = curr[el] || { _errors: [] };
+            } else {
+              curr[el] = curr[el] || { _errors: [] };
+              curr[el]._errors.push(mapper(issue));
+            }
+            curr = curr[el];
+            i++;
+          }
         }
-        ctx.common = {
-          issues: [],
-          async: true
-        };
       }
+    };
+    processError(this);
+    return fieldErrors;
+  }
+  static assert(value) {
+    if (!(value instanceof _ZodError)) {
+      throw new Error(`Not a ZodError: ${value}`);
     }
-    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
-      value: result.value
-    } : {
-      issues: ctx.common.issues
-    });
   }
-  async parseAsync(data, params) {
-    const result = await this.safeParseAsync(data, params);
-    if (result.success)
-      return result.data;
-    throw result.error;
+  toString() {
+    return this.message;
   }
-  async safeParseAsync(data, params) {
-    const ctx = {
-      common: {
-        issues: [],
-        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
-        async: true
-      },
-      path: (params === null || params === void 0 ? void 0 : params.path) || [],
-      schemaErrorMap: this._def.errorMap,
-      parent: null,
-      data,
-      parsedType: getParsedType(data)
-    };
-    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
-    const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
-    return handleResult(ctx, result);
+  get message() {
+    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
   }
-  refine(check, message) {
-    const getIssueProperties = (val) => {
-      if (typeof message === "string" || typeof message === "undefined") {
-        return { message };
-      } else if (typeof message === "function") {
-        return message(val);
+  get isEmpty() {
+    return this.issues.length === 0;
+  }
+  flatten(mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of this.issues) {
+      if (sub.path.length > 0) {
+        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+        fieldErrors[sub.path[0]].push(mapper(sub));
       } else {
-        return message;
-      }
-    };
-    return this._refinement((val, ctx) => {
-      const result = check(val);
-      const setError = () => ctx.addIssue({
-        code: ZodIssueCode.custom,
-        ...getIssueProperties(val)
-      });
-      if (typeof Promise !== "undefined" && result instanceof Promise) {
-        return result.then((data) => {
-          if (!data) {
-            setError();
-            return false;
-          } else {
-            return true;
-          }
-        });
+        formErrors.push(mapper(sub));
       }
-      if (!result) {
-        setError();
-        return false;
+    }
+    return { formErrors, fieldErrors };
+  }
+  get formErrors() {
+    return this.flatten();
+  }
+};
+ZodError.create = (issues) => {
+  const error = new ZodError(issues);
+  return error;
+};
+var errorMap = (issue, _ctx) => {
+  let message;
+  switch (issue.code) {
+    case ZodIssueCode.invalid_type:
+      if (issue.received === ZodParsedType.undefined) {
+        message = "Required";
       } else {
-        return true;
+        message = `Expected ${issue.expected}, received ${issue.received}`;
       }
-    });
-  }
-  refinement(check, refinementData) {
-    return this._refinement((val, ctx) => {
-      if (!check(val)) {
-        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
-        return false;
+      break;
+    case ZodIssueCode.invalid_literal:
+      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+      break;
+    case ZodIssueCode.unrecognized_keys:
+      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+      break;
+    case ZodIssueCode.invalid_union:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_union_discriminator:
+      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+      break;
+    case ZodIssueCode.invalid_enum_value:
+      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+      break;
+    case ZodIssueCode.invalid_arguments:
+      message = `Invalid function arguments`;
+      break;
+    case ZodIssueCode.invalid_return_type:
+      message = `Invalid function return type`;
+      break;
+    case ZodIssueCode.invalid_date:
+      message = `Invalid date`;
+      break;
+    case ZodIssueCode.invalid_string:
+      if (typeof issue.validation === "object") {
+        if ("includes" in issue.validation) {
+          message = `Invalid input: must include "${issue.validation.includes}"`;
+          if (typeof issue.validation.position === "number") {
+            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+          }
+        } else if ("startsWith" in issue.validation) {
+          message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+        } else if ("endsWith" in issue.validation) {
+          message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+        } else {
+          util.assertNever(issue.validation);
+        }
+      } else if (issue.validation !== "regex") {
+        message = `Invalid ${issue.validation}`;
       } else {
-        return true;
+        message = "Invalid";
       }
-    });
-  }
-  _refinement(refinement) {
-    return new ZodEffects({
-      schema: this,
-      typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "refinement", refinement }
-    });
-  }
-  superRefine(refinement) {
-    return this._refinement(refinement);
-  }
-  constructor(def) {
-    this.spa = this.safeParseAsync;
-    this._def = def;
-    this.parse = this.parse.bind(this);
-    this.safeParse = this.safeParse.bind(this);
-    this.parseAsync = this.parseAsync.bind(this);
-    this.safeParseAsync = this.safeParseAsync.bind(this);
-    this.spa = this.spa.bind(this);
-    this.refine = this.refine.bind(this);
-    this.refinement = this.refinement.bind(this);
-    this.superRefine = this.superRefine.bind(this);
-    this.optional = this.optional.bind(this);
-    this.nullable = this.nullable.bind(this);
-    this.nullish = this.nullish.bind(this);
-    this.array = this.array.bind(this);
-    this.promise = this.promise.bind(this);
-    this.or = this.or.bind(this);
-    this.and = this.and.bind(this);
-    this.transform = this.transform.bind(this);
-    this.brand = this.brand.bind(this);
-    this.default = this.default.bind(this);
-    this.catch = this.catch.bind(this);
-    this.describe = this.describe.bind(this);
-    this.pipe = this.pipe.bind(this);
-    this.readonly = this.readonly.bind(this);
-    this.isNullable = this.isNullable.bind(this);
-    this.isOptional = this.isOptional.bind(this);
-    this["~standard"] = {
-      version: 1,
-      vendor: "zod",
-      validate: (data) => this["~validate"](data)
+      break;
+    case ZodIssueCode.too_small:
+      if (issue.type === "array")
+        message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
+      else if (issue.type === "date")
+        message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
+      else
+        message = "Invalid input";
+      break;
+    case ZodIssueCode.too_big:
+      if (issue.type === "array")
+        message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+      else if (issue.type === "bigint")
+        message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
+      else if (issue.type === "date")
+        message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
+      else
+        message = "Invalid input";
+      break;
+    case ZodIssueCode.custom:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_intersection_types:
+      message = `Intersection results could not be merged`;
+      break;
+    case ZodIssueCode.not_multiple_of:
+      message = `Number must be a multiple of ${issue.multipleOf}`;
+      break;
+    case ZodIssueCode.not_finite:
+      message = "Number must be finite";
+      break;
+    default:
+      message = _ctx.defaultError;
+      util.assertNever(issue);
+  }
+  return { message };
+};
+var overrideErrorMap = errorMap;
+function setErrorMap(map) {
+  overrideErrorMap = map;
+}
+function getErrorMap() {
+  return overrideErrorMap;
+}
+var makeIssue = (params) => {
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
+  const fullIssue = {
+    ...issueData,
+    path: fullPath
+  };
+  if (issueData.message !== void 0) {
+    return {
+      ...issueData,
+      path: fullPath,
+      message: issueData.message
     };
   }
-  optional() {
-    return ZodOptional.create(this, this._def);
+  let errorMessage = "";
+  const maps = errorMaps.filter((m) => !!m).slice().reverse();
+  for (const map of maps) {
+    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
   }
-  nullable() {
-    return ZodNullable.create(this, this._def);
+  return {
+    ...issueData,
+    path: fullPath,
+    message: errorMessage
+  };
+};
+var EMPTY_PATH = [];
+function addIssueToContext(ctx, issueData) {
+  const overrideMap = getErrorMap();
+  const issue = makeIssue({
+    issueData,
+    data: ctx.data,
+    path: ctx.path,
+    errorMaps: [
+      ctx.common.contextualErrorMap,
+      // contextual error map is first priority
+      ctx.schemaErrorMap,
+      // then schema-bound map if available
+      overrideMap,
+      // then global override map
+      overrideMap === errorMap ? void 0 : errorMap
+      // then global default map
+    ].filter((x) => !!x)
+  });
+  ctx.common.issues.push(issue);
+}
+var ParseStatus = class _ParseStatus {
+  constructor() {
+    this.value = "valid";
   }
-  nullish() {
-    return this.nullable().optional();
+  dirty() {
+    if (this.value === "valid")
+      this.value = "dirty";
   }
-  array() {
-    return ZodArray.create(this);
+  abort() {
+    if (this.value !== "aborted")
+      this.value = "aborted";
   }
-  promise() {
-    return ZodPromise.create(this, this._def);
+  static mergeArray(status, results) {
+    const arrayValue = [];
+    for (const s of results) {
+      if (s.status === "aborted")
+        return INVALID;
+      if (s.status === "dirty")
+        status.dirty();
+      arrayValue.push(s.value);
+    }
+    return { status: status.value, value: arrayValue };
   }
-  or(option) {
-    return ZodUnion.create([this, option], this._def);
+  static async mergeObjectAsync(status, pairs) {
+    const syncPairs = [];
+    for (const pair of pairs) {
+      const key = await pair.key;
+      const value = await pair.value;
+      syncPairs.push({
+        key,
+        value
+      });
+    }
+    return _ParseStatus.mergeObjectSync(status, syncPairs);
   }
-  and(incoming) {
-    return ZodIntersection.create(this, incoming, this._def);
+  static mergeObjectSync(status, pairs) {
+    const finalObject = {};
+    for (const pair of pairs) {
+      const { key, value } = pair;
+      if (key.status === "aborted")
+        return INVALID;
+      if (value.status === "aborted")
+        return INVALID;
+      if (key.status === "dirty")
+        status.dirty();
+      if (value.status === "dirty")
+        status.dirty();
+      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
+        finalObject[key.value] = value.value;
+      }
+    }
+    return { status: status.value, value: finalObject };
   }
-  transform(transform) {
-    return new ZodEffects({
-      ...processCreateParams(this._def),
-      schema: this,
-      typeName: ZodFirstPartyTypeKind.ZodEffects,
-      effect: { type: "transform", transform }
-    });
+};
+var INVALID = Object.freeze({
+  status: "aborted"
+});
+var DIRTY = (value) => ({ status: "dirty", value });
+var OK = (value) => ({ status: "valid", value });
+var isAborted = (x) => x.status === "aborted";
+var isDirty = (x) => x.status === "dirty";
+var isValid = (x) => x.status === "valid";
+var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return state.set(receiver, value), value;
+}
+var errorUtil;
+(function(errorUtil2) {
+  errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
+  errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+})(errorUtil || (errorUtil = {}));
+var _ZodEnum_cache;
+var _ZodNativeEnum_cache;
+var ParseInputLazyPath = class {
+  constructor(parent, value, path2, key) {
+    this._cachedPath = [];
+    this.parent = parent;
+    this.data = value;
+    this._path = path2;
+    this._key = key;
   }
-  default(def) {
-    const defaultValueFunc = typeof def === "function" ? def : () => def;
-    return new ZodDefault({
-      ...processCreateParams(this._def),
-      innerType: this,
-      defaultValue: defaultValueFunc,
-      typeName: ZodFirstPartyTypeKind.ZodDefault
-    });
+  get path() {
+    if (!this._cachedPath.length) {
+      if (this._key instanceof Array) {
+        this._cachedPath.push(...this._path, ...this._key);
+      } else {
+        this._cachedPath.push(...this._path, this._key);
+      }
+    }
+    return this._cachedPath;
   }
-  brand() {
-    return new ZodBranded({
-      typeName: ZodFirstPartyTypeKind.ZodBranded,
-      type: this,
-      ...processCreateParams(this._def)
-    });
+};
+var handleResult = (ctx, result) => {
+  if (isValid(result)) {
+    return { success: true, data: result.value };
+  } else {
+    if (!ctx.common.issues.length) {
+      throw new Error("Validation failed but no issues detected.");
+    }
+    return {
+      success: false,
+      get error() {
+        if (this._error)
+          return this._error;
+        const error = new ZodError(ctx.common.issues);
+        this._error = error;
+        return this._error;
+      }
+    };
   }
-  catch(def) {
-    const catchValueFunc = typeof def === "function" ? def : () => def;
-    return new ZodCatch({
-      ...processCreateParams(this._def),
-      innerType: this,
-      catchValue: catchValueFunc,
-      typeName: ZodFirstPartyTypeKind.ZodCatch
-    });
+};
+function processCreateParams(params) {
+  if (!params)
+    return {};
+  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
+  if (errorMap2 && (invalid_type_error || required_error)) {
+    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
   }
-  describe(description) {
-    const This = this.constructor;
-    return new This({
-      ...this._def,
-      description
-    });
+  if (errorMap2)
+    return { errorMap: errorMap2, description };
+  const customMap = (iss, ctx) => {
+    var _a, _b;
+    const { message } = params;
+    if (iss.code === "invalid_enum_value") {
+      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
+    }
+    if (typeof ctx.data === "undefined") {
+      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
+    }
+    if (iss.code !== "invalid_type")
+      return { message: ctx.defaultError };
+    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
+  };
+  return { errorMap: customMap, description };
+}
+var ZodType = class {
+  get description() {
+    return this._def.description;
   }
-  pipe(target) {
-    return ZodPipeline.create(this, target);
+  _getType(input) {
+    return getParsedType(input.data);
   }
-  readonly() {
-    return ZodReadonly.create(this);
+  _getOrReturnCtx(input, ctx) {
+    return ctx || {
+      common: input.parent.common,
+      data: input.data,
+      parsedType: getParsedType(input.data),
+      schemaErrorMap: this._def.errorMap,
+      path: input.path,
+      parent: input.parent
+    };
   }
-  isOptional() {
-    return this.safeParse(void 0).success;
+  _processInputParams(input) {
+    return {
+      status: new ParseStatus(),
+      ctx: {
+        common: input.parent.common,
+        data: input.data,
+        parsedType: getParsedType(input.data),
+        schemaErrorMap: this._def.errorMap,
+        path: input.path,
+        parent: input.parent
+      }
+    };
   }
-  isNullable() {
-    return this.safeParse(null).success;
+  _parseSync(input) {
+    const result = this._parse(input);
+    if (isAsync(result)) {
+      throw new Error("Synchronous parse encountered promise.");
+    }
+    return result;
   }
-};
-var cuidRegex = /^c[^\s-]{8,}$/i;
-var cuid2Regex = /^[0-9a-z]+$/;
-var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
-var uuidRegex = /^[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}$/i;
-var nanoidRegex = /^[a-z0-9_-]{21}$/i;
-var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
-var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
-var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
-var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
-var emojiRegex;
-var ipv4Regex = /^(?:(?: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])$/;
-var ipv4CidrRegex = /^(?:(?: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])$/;
-var ipv6Regex = /^(([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]))$/;
-var ipv6CidrRegex = /^(([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])$/;
-var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
-var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
-var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
-var dateRegex = new RegExp(`^${dateRegexSource}$`);
-function timeRegexSource(args) {
-  let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
-  if (args.precision) {
-    regex = `${regex}\\.\\d{${args.precision}}`;
-  } else if (args.precision == null) {
-    regex = `${regex}(\\.\\d+)?`;
+  _parseAsync(input) {
+    const result = this._parse(input);
+    return Promise.resolve(result);
   }
-  return regex;
-}
-function timeRegex(args) {
-  return new RegExp(`^${timeRegexSource(args)}$`);
-}
-function datetimeRegex(args) {
-  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
-  const opts = [];
-  opts.push(args.local ? `Z?` : `Z`);
-  if (args.offset)
-    opts.push(`([+-]\\d{2}:?\\d{2})`);
-  regex = `${regex}(${opts.join("|")})`;
-  return new RegExp(`^${regex}$`);
-}
-function isValidIP(ip, version) {
-  if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
-    return true;
+  parse(data, params) {
+    const result = this.safeParse(data, params);
+    if (result.success)
+      return result.data;
+    throw result.error;
   }
-  if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
-    return true;
+  safeParse(data, params) {
+    var _a;
+    const ctx = {
+      common: {
+        issues: [],
+        async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
+        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap
+      },
+      path: (params === null || params === void 0 ? void 0 : params.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data,
+      parsedType: getParsedType(data)
+    };
+    const result = this._parseSync({ data, path: ctx.path, parent: ctx });
+    return handleResult(ctx, result);
   }
-  return false;
-}
-function isValidJWT(jwt, alg) {
-  if (!jwtRegex.test(jwt))
-    return false;
-  try {
-    const [header] = jwt.split(".");
-    const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
-    const decoded = JSON.parse(atob(base64));
-    if (typeof decoded !== "object" || decoded === null)
-      return false;
-    if (!decoded.typ || !decoded.alg)
-      return false;
-    if (alg && decoded.alg !== alg)
-      return false;
-    return true;
-  } catch (_a) {
-    return false;
+  "~validate"(data) {
+    var _a, _b;
+    const ctx = {
+      common: {
+        issues: [],
+        async: !!this["~standard"].async
+      },
+      path: [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data,
+      parsedType: getParsedType(data)
+    };
+    if (!this["~standard"].async) {
+      try {
+        const result = this._parseSync({ data, path: [], parent: ctx });
+        return isValid(result) ? {
+          value: result.value
+        } : {
+          issues: ctx.common.issues
+        };
+      } catch (err) {
+        if ((_b = (_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === null || _b === void 0 ? void 0 : _b.includes("encountered")) {
+          this["~standard"].async = true;
+        }
+        ctx.common = {
+          issues: [],
+          async: true
+        };
+      }
+    }
+    return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
+      value: result.value
+    } : {
+      issues: ctx.common.issues
+    });
   }
-}
-function isValidCidr(ip, version) {
-  if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
-    return true;
+  async parseAsync(data, params) {
+    const result = await this.safeParseAsync(data, params);
+    if (result.success)
+      return result.data;
+    throw result.error;
   }
-  if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
-    return true;
+  async safeParseAsync(data, params) {
+    const ctx = {
+      common: {
+        issues: [],
+        contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
+        async: true
+      },
+      path: (params === null || params === void 0 ? void 0 : params.path) || [],
+      schemaErrorMap: this._def.errorMap,
+      parent: null,
+      data,
+      parsedType: getParsedType(data)
+    };
+    const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
+    const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
+    return handleResult(ctx, result);
   }
-  return false;
-}
-var ZodString = class _ZodString extends ZodType {
-  _parse(input) {
-    if (this._def.coerce) {
-      input.data = String(input.data);
-    }
-    const parsedType = this._getType(input);
-    if (parsedType !== ZodParsedType.string) {
-      const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(ctx2, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.string,
-        received: ctx2.parsedType
+  refine(check, message) {
+    const getIssueProperties = (val) => {
+      if (typeof message === "string" || typeof message === "undefined") {
+        return { message };
+      } else if (typeof message === "function") {
+        return message(val);
+      } else {
+        return message;
+      }
+    };
+    return this._refinement((val, ctx) => {
+      const result = check(val);
+      const setError = () => ctx.addIssue({
+        code: ZodIssueCode.custom,
+        ...getIssueProperties(val)
       });
-      return INVALID;
-    }
-    const status = new ParseStatus();
-    let ctx = void 0;
-    for (const check of this._def.checks) {
-      if (check.kind === "min") {
-        if (input.data.length < check.value) {
-          ctx = this._getOrReturnCtx(input, ctx);
+      if (typeof Promise !== "undefined" && result instanceof Promise) {
+        return result.then((data) => {
+          if (!data) {
+            setError();
+            return false;
+          } else {
+            return true;
+          }
+        });
+      }
+      if (!result) {
+        setError();
+        return false;
+      } else {
+        return true;
+      }
+    });
+  }
+  refinement(check, refinementData) {
+    return this._refinement((val, ctx) => {
+      if (!check(val)) {
+        ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
+        return false;
+      } else {
+        return true;
+      }
+    });
+  }
+  _refinement(refinement) {
+    return new ZodEffects({
+      schema: this,
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      effect: { type: "refinement", refinement }
+    });
+  }
+  superRefine(refinement) {
+    return this._refinement(refinement);
+  }
+  constructor(def) {
+    this.spa = this.safeParseAsync;
+    this._def = def;
+    this.parse = this.parse.bind(this);
+    this.safeParse = this.safeParse.bind(this);
+    this.parseAsync = this.parseAsync.bind(this);
+    this.safeParseAsync = this.safeParseAsync.bind(this);
+    this.spa = this.spa.bind(this);
+    this.refine = this.refine.bind(this);
+    this.refinement = this.refinement.bind(this);
+    this.superRefine = this.superRefine.bind(this);
+    this.optional = this.optional.bind(this);
+    this.nullable = this.nullable.bind(this);
+    this.nullish = this.nullish.bind(this);
+    this.array = this.array.bind(this);
+    this.promise = this.promise.bind(this);
+    this.or = this.or.bind(this);
+    this.and = this.and.bind(this);
+    this.transform = this.transform.bind(this);
+    this.brand = this.brand.bind(this);
+    this.default = this.default.bind(this);
+    this.catch = this.catch.bind(this);
+    this.describe = this.describe.bind(this);
+    this.pipe = this.pipe.bind(this);
+    this.readonly = this.readonly.bind(this);
+    this.isNullable = this.isNullable.bind(this);
+    this.isOptional = this.isOptional.bind(this);
+    this["~standard"] = {
+      version: 1,
+      vendor: "zod",
+      validate: (data) => this["~validate"](data)
+    };
+  }
+  optional() {
+    return ZodOptional.create(this, this._def);
+  }
+  nullable() {
+    return ZodNullable.create(this, this._def);
+  }
+  nullish() {
+    return this.nullable().optional();
+  }
+  array() {
+    return ZodArray.create(this);
+  }
+  promise() {
+    return ZodPromise.create(this, this._def);
+  }
+  or(option) {
+    return ZodUnion.create([this, option], this._def);
+  }
+  and(incoming) {
+    return ZodIntersection.create(this, incoming, this._def);
+  }
+  transform(transform) {
+    return new ZodEffects({
+      ...processCreateParams(this._def),
+      schema: this,
+      typeName: ZodFirstPartyTypeKind.ZodEffects,
+      effect: { type: "transform", transform }
+    });
+  }
+  default(def) {
+    const defaultValueFunc = typeof def === "function" ? def : () => def;
+    return new ZodDefault({
+      ...processCreateParams(this._def),
+      innerType: this,
+      defaultValue: defaultValueFunc,
+      typeName: ZodFirstPartyTypeKind.ZodDefault
+    });
+  }
+  brand() {
+    return new ZodBranded({
+      typeName: ZodFirstPartyTypeKind.ZodBranded,
+      type: this,
+      ...processCreateParams(this._def)
+    });
+  }
+  catch(def) {
+    const catchValueFunc = typeof def === "function" ? def : () => def;
+    return new ZodCatch({
+      ...processCreateParams(this._def),
+      innerType: this,
+      catchValue: catchValueFunc,
+      typeName: ZodFirstPartyTypeKind.ZodCatch
+    });
+  }
+  describe(description) {
+    const This = this.constructor;
+    return new This({
+      ...this._def,
+      description
+    });
+  }
+  pipe(target) {
+    return ZodPipeline.create(this, target);
+  }
+  readonly() {
+    return ZodReadonly.create(this);
+  }
+  isOptional() {
+    return this.safeParse(void 0).success;
+  }
+  isNullable() {
+    return this.safeParse(null).success;
+  }
+};
+var cuidRegex = /^c[^\s-]{8,}$/i;
+var cuid2Regex = /^[0-9a-z]+$/;
+var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+var uuidRegex = /^[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}$/i;
+var nanoidRegex = /^[a-z0-9_-]{21}$/i;
+var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
+var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
+var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
+var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+var emojiRegex;
+var ipv4Regex = /^(?:(?: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])$/;
+var ipv4CidrRegex = /^(?:(?: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])$/;
+var ipv6Regex = /^(([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]))$/;
+var ipv6CidrRegex = /^(([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])$/;
+var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
+var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
+var dateRegex = new RegExp(`^${dateRegexSource}$`);
+function timeRegexSource(args) {
+  let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
+  if (args.precision) {
+    regex = `${regex}\\.\\d{${args.precision}}`;
+  } else if (args.precision == null) {
+    regex = `${regex}(\\.\\d+)?`;
+  }
+  return regex;
+}
+function timeRegex(args) {
+  return new RegExp(`^${timeRegexSource(args)}$`);
+}
+function datetimeRegex(args) {
+  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+  const opts = [];
+  opts.push(args.local ? `Z?` : `Z`);
+  if (args.offset)
+    opts.push(`([+-]\\d{2}:?\\d{2})`);
+  regex = `${regex}(${opts.join("|")})`;
+  return new RegExp(`^${regex}$`);
+}
+function isValidIP(ip, version) {
+  if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
+    return true;
+  }
+  if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
+    return true;
+  }
+  return false;
+}
+function isValidJWT(jwt, alg) {
+  if (!jwtRegex.test(jwt))
+    return false;
+  try {
+    const [header] = jwt.split(".");
+    const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
+    const decoded = JSON.parse(atob(base64));
+    if (typeof decoded !== "object" || decoded === null)
+      return false;
+    if (!decoded.typ || !decoded.alg)
+      return false;
+    if (alg && decoded.alg !== alg)
+      return false;
+    return true;
+  } catch (_a) {
+    return false;
+  }
+}
+function isValidCidr(ip, version) {
+  if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
+    return true;
+  }
+  if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
+    return true;
+  }
+  return false;
+}
+var ZodString = class _ZodString extends ZodType {
+  _parse(input) {
+    if (this._def.coerce) {
+      input.data = String(input.data);
+    }
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.string) {
+      const ctx2 = this._getOrReturnCtx(input);
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx2.parsedType
+      });
+      return INVALID;
+    }
+    const status = new ParseStatus();
+    let ctx = void 0;
+    for (const check of this._def.checks) {
+      if (check.kind === "min") {
+        if (input.data.length < check.value) {
+          ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.too_small,
             minimum: check.value,
@@ -4111,1020 +4748,385 @@ var InternalMastraMCPClient = class extends MastraBase {
     timeout = DEFAULT_REQUEST_TIMEOUT_MSEC
   }) {
     super({ name: "MastraMCPClient" });
-    this.name = name;
-    this.timeout = timeout;
-    this.logHandler = server.logger;
-    this.enableServerLogs = server.enableServerLogs ?? true;
-    this.serverConfig = server;
-    this.client = new Client(
-      {
-        name,
-        version
-      },
-      {
-        capabilities
-      }
-    );
-    this.setupLogging();
-  }
-  /**
-   * Log a message at the specified level
-   * @param level Log level
-   * @param message Log message
-   * @param details Optional additional details
-   */
-  log(level, message, details) {
-    const loggerMethod = convertLogLevelToLoggerMethod(level);
-    const msg = `[${this.name}] ${message}`;
-    this.logger[loggerMethod](msg, details);
-    if (this.logHandler) {
-      this.logHandler({
-        level,
-        message: msg,
-        timestamp: /* @__PURE__ */ new Date(),
-        serverName: this.name,
-        details
-      });
-    }
-  }
-  setupLogging() {
-    if (this.enableServerLogs) {
-      this.client.setNotificationHandler(
-        z.object({
-          method: z.literal("notifications/message"),
-          params: z.object({
-            level: z.string()
-          }).passthrough()
-        }),
-        (notification) => {
-          const { level, ...params } = notification.params;
-          this.log(level, "[MCP SERVER LOG]", params);
-        }
-      );
-    }
-  }
-  async connectStdio(command) {
-    this.log("debug", `Using Stdio transport for command: ${command}`);
-    try {
-      this.transport = new StdioClientTransport({
-        command,
-        args: this.serverConfig.args,
-        env: { ...getDefaultEnvironment(), ...this.serverConfig.env || {} }
-      });
-      await this.client.connect(this.transport, { timeout: this.serverConfig.timeout ?? this.timeout });
-      this.log("debug", `Successfully connected to MCP server via Stdio`);
-    } catch (e) {
-      this.log("error", e instanceof Error ? e.stack || e.message : JSON.stringify(e));
-      throw e;
-    }
-  }
-  async connectHttp(url) {
-    const { requestInit, eventSourceInit } = this.serverConfig;
-    this.log("debug", `Attempting to connect to URL: ${url}`);
-    let shouldTrySSE = url.pathname.endsWith(`/sse`);
-    if (!shouldTrySSE) {
-      try {
-        this.log("debug", "Trying Streamable HTTP transport...");
-        const streamableTransport = new StreamableHTTPClientTransport(url, {
-          requestInit,
-          reconnectionOptions: this.serverConfig.reconnectionOptions,
-          sessionId: this.serverConfig.sessionId
-        });
-        await this.client.connect(streamableTransport, {
-          timeout: (
-            // this is hardcoded to 3s because the long default timeout would be extremely slow for sse backwards compat (60s)
-            3e3
-          )
-        });
-        this.transport = streamableTransport;
-        this.log("debug", "Successfully connected using Streamable HTTP transport.");
-      } catch (error) {
-        this.log("debug", `Streamable HTTP transport failed: ${error}`);
-        shouldTrySSE = true;
-      }
-    }
-    if (shouldTrySSE) {
-      this.log("debug", "Falling back to deprecated HTTP+SSE transport...");
-      try {
-        const sseTransport = new SSEClientTransport(url, { requestInit, eventSourceInit });
-        await this.client.connect(sseTransport, { timeout: this.serverConfig.timeout ?? this.timeout });
-        this.transport = sseTransport;
-        this.log("debug", "Successfully connected using deprecated HTTP+SSE transport.");
-      } catch (sseError) {
-        this.log(
-          "error",
-          `Failed to connect with SSE transport after failing to connect to Streamable HTTP transport first. SSE error: ${sseError}`
-        );
-        throw new Error("Could not connect to server with any available HTTP transport");
-      }
-    }
-  }
-  isConnected = false;
-  async connect() {
-    if (this.isConnected) return;
-    const { command, url } = this.serverConfig;
-    if (command) {
-      await this.connectStdio(command);
-    } else if (url) {
-      await this.connectHttp(url);
-    } else {
-      throw new Error("Server configuration must include either a command or a url.");
-    }
-    this.isConnected = true;
-    const originalOnClose = this.client.onclose;
-    this.client.onclose = () => {
-      this.log("debug", `MCP server connection closed`);
-      this.isConnected = false;
-      if (typeof originalOnClose === `function`) {
-        originalOnClose();
-      }
-    };
-    asyncExitHook(
-      async () => {
-        this.log("debug", `Disconnecting MCP server during exit`);
-        await this.disconnect();
-      },
-      { wait: 5e3 }
-    );
-    process.on("SIGTERM", () => gracefulExit());
-    this.log("debug", `Successfully connected to MCP server`);
-  }
-  /**
-   * Get the current session ID if using the Streamable HTTP transport.
-   * Returns undefined if not connected or not using Streamable HTTP.
-   */
-  get sessionId() {
-    if (this.transport instanceof StreamableHTTPClientTransport) {
-      return this.transport.sessionId;
-    }
-    return void 0;
-  }
-  async disconnect() {
-    if (!this.transport) {
-      this.log("debug", "Disconnect called but no transport was connected.");
-      return;
-    }
-    this.log("debug", `Disconnecting from MCP server`);
-    try {
-      await this.transport.close();
-      this.log("debug", "Successfully disconnected from MCP server");
-    } catch (e) {
-      this.log("error", "Error during MCP server disconnect", {
-        error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2)
-      });
-      throw e;
-    } finally {
-      this.transport = void 0;
-      this.isConnected = false;
-    }
-  }
-  // TODO: do the type magic to return the right method type. Right now we get infinitely deep infered type errors from Zod without using "any"
-  async resources() {
-    this.log("debug", `Requesting resources from MCP server`);
-    return await this.client.request({ method: "resources/list" }, ListResourcesResultSchema, {
-      timeout: this.timeout
-    });
-  }
-  async tools() {
-    this.log("debug", `Requesting tools from MCP server`);
-    const { tools } = await this.client.listTools({ timeout: this.timeout });
-    const toolsRes = {};
-    tools.forEach((tool) => {
-      this.log("debug", `Processing tool: ${tool.name}`);
-      const s = jsonSchemaToModel(tool.inputSchema);
-      const mastraTool = createTool({
-        id: `${this.name}_${tool.name}`,
-        description: tool.description || "",
-        inputSchema: s,
-        execute: async ({ context }) => {
-          try {
-            this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
-            const res = await this.client.callTool(
-              {
-                name: tool.name,
-                arguments: context
-              },
-              CallToolResultSchema,
-              {
-                timeout: this.timeout
-              }
-            );
-            this.log("debug", `Tool executed successfully: ${tool.name}`);
-            return res;
-          } catch (e) {
-            this.log("error", `Error calling tool: ${tool.name}`, {
-              error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
-              toolArgs: context
-            });
-            throw e;
-          }
-        }
-      });
-      if (tool.name) {
-        toolsRes[tool.name] = mastraTool;
-      }
-    });
-    return toolsRes;
-  }
-};
-var MastraMCPClient = class extends InternalMastraMCPClient {
-  constructor(args) {
-    super(args);
-    this.logger.warn(
-      "[DEPRECATION] MastraMCPClient is deprecated and will be removed in a future release. Please use MCPClient instead."
-    );
-  }
-};
-var mcpClientInstances = /* @__PURE__ */ new Map();
-var MCPClient = class extends MastraBase {
-  serverConfigs = {};
-  id;
-  defaultTimeout;
-  mcpClientsById = /* @__PURE__ */ new Map();
-  disconnectPromise = null;
-  constructor(args) {
-    super({ name: "MCPClient" });
-    this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
-    this.serverConfigs = args.servers;
-    this.id = args.id ?? this.makeId();
-    if (args.id) {
-      this.id = args.id;
-      const cached = mcpClientInstances.get(this.id);
-      if (cached && !equal(cached.serverConfigs, args.servers)) {
-        const existingInstance2 = mcpClientInstances.get(this.id);
-        if (existingInstance2) {
-          void existingInstance2.disconnect();
-        }
-      }
-    } else {
-      this.id = this.makeId();
-    }
-    const existingInstance = mcpClientInstances.get(this.id);
-    if (existingInstance) {
-      if (!args.id) {
-        throw new Error(`MCPClient was initialized multiple times with the same configuration options.
-
-This error is intended to prevent memory leaks.
-
-To fix this you have three different options:
-1. If you need multiple MCPClient class instances with identical server configurations, set an id when configuring: new MCPClient({ id: "my-unique-id" })
-2. Call "await client.disconnect()" after you're done using the client and before you recreate another instance with the same options. If the identical MCPClient instance is already closed at the time of re-creating it, you will not see this error.
-3. If you only need one instance of MCPClient in your app, refactor your code so it's only created one time (ex. move it out of a loop into a higher scope code block)
-`);
-      }
-      return existingInstance;
-    }
-    mcpClientInstances.set(this.id, this);
-    this.addToInstanceCache();
-    return this;
-  }
-  addToInstanceCache() {
-    if (!mcpClientInstances.has(this.id)) {
-      mcpClientInstances.set(this.id, this);
-    }
-  }
-  makeId() {
-    const text = JSON.stringify(this.serverConfigs).normalize("NFKC");
-    const idNamespace = v5(`MCPClient`, v5.DNS);
-    return v5(text, idNamespace);
-  }
-  async disconnect() {
-    if (this.disconnectPromise) {
-      return this.disconnectPromise;
-    }
-    this.disconnectPromise = (async () => {
-      try {
-        mcpClientInstances.delete(this.id);
-        await Promise.all(Array.from(this.mcpClientsById.values()).map((client) => client.disconnect()));
-        this.mcpClientsById.clear();
-      } finally {
-        this.disconnectPromise = null;
-      }
-    })();
-    return this.disconnectPromise;
-  }
-  async getTools() {
-    this.addToInstanceCache();
-    const connectedTools = {};
-    await this.eachClientTools(async ({ serverName, tools }) => {
-      for (const [toolName, toolConfig] of Object.entries(tools)) {
-        connectedTools[`${serverName}_${toolName}`] = toolConfig;
-      }
-    });
-    return connectedTools;
-  }
-  async getToolsets() {
-    this.addToInstanceCache();
-    const connectedToolsets = {};
-    await this.eachClientTools(async ({ serverName, tools }) => {
-      if (tools) {
-        connectedToolsets[serverName] = tools;
-      }
-    });
-    return connectedToolsets;
-  }
-  /**
-   * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
-   * Returns an object mapping server names to their session IDs.
-   */
-  get sessionIds() {
-    const sessionIds = {};
-    for (const [serverName, client] of this.mcpClientsById.entries()) {
-      if (client.sessionId) {
-        sessionIds[serverName] = client.sessionId;
-      }
-    }
-    return sessionIds;
-  }
-  async getConnectedClient(name, config) {
-    if (this.disconnectPromise) {
-      await this.disconnectPromise;
-    }
-    const exists = this.mcpClientsById.has(name);
-    const existingClient = this.mcpClientsById.get(name);
-    if (exists) {
-      if (!existingClient) {
-        throw new Error(`Client ${name} exists but is undefined`);
-      }
-      await existingClient.connect();
-      return existingClient;
-    }
-    this.logger.debug(`Connecting to ${name} MCP server`);
-    const mcpClient = new InternalMastraMCPClient({
-      name,
-      server: config,
-      timeout: config.timeout ?? this.defaultTimeout
-    });
-    this.mcpClientsById.set(name, mcpClient);
-    try {
-      await mcpClient.connect();
-    } catch (e) {
-      this.mcpClientsById.delete(name);
-      this.logger.error(`MCPClient errored connecting to MCP server ${name}`, {
-        error: e instanceof Error ? e.message : String(e)
-      });
-      throw new Error(
-        `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
-      );
-    }
-    this.logger.debug(`Connected to ${name} MCP server`);
-    return mcpClient;
-  }
-  async eachClientTools(cb) {
-    await Promise.all(
-      Object.entries(this.serverConfigs).map(async ([serverName, serverConfig]) => {
-        const client = await this.getConnectedClient(serverName, serverConfig);
-        const tools = await client.tools();
-        await cb({ serverName, tools, client });
-      })
-    );
-  }
-};
-var MCPConfiguration = class extends MCPClient {
-  constructor(args) {
-    super(args);
-    this.logger.warn(
-      `MCPConfiguration has been renamed to MCPClient and MCPConfiguration is deprecated. The API is identical but the MCPConfiguration export will be removed in the future. Update your imports now to prevent future errors.`
-    );
-  }
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseAnyOf.js
-var parseAnyOf = (schema, refs) => {
-  return schema.anyOf.length ? schema.anyOf.length === 1 ? parseSchema(schema.anyOf[0], {
-    ...refs,
-    path: [...refs.path, "anyOf", 0]
-  }) : `z.union([${schema.anyOf.map((schema2, i) => parseSchema(schema2, { ...refs, path: [...refs.path, "anyOf", i] })).join(", ")}])` : `z.any()`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseBoolean.js
-var parseBoolean = (_schema) => {
-  return "z.boolean()";
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseDefault.js
-var parseDefault = (_schema) => {
-  return "z.any()";
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseMultipleType.js
-var parseMultipleType = (schema, refs) => {
-  return `z.union([${schema.type.map((type) => parseSchema({ ...schema, type }, refs)).join(", ")}])`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNot.js
-var parseNot = (schema, refs) => {
-  return `z.any().refine((value) => !${parseSchema(schema.not, {
-    ...refs,
-    path: [...refs.path, "not"]
-  })}.safeParse(value).success, "Invalid input: Should NOT be valid against schema")`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNull.js
-var parseNull = (_schema) => {
-  return "z.null()";
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/half.js
-var half = (arr) => {
-  return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseAllOf.js
-var originalIndex = Symbol("Original index");
-var ensureOriginalIndex = (arr) => {
-  let newArr = [];
-  for (let i = 0; i < arr.length; i++) {
-    const item = arr[i];
-    if (typeof item === "boolean") {
-      newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
-    } else if (originalIndex in item) {
-      return arr;
-    } else {
-      newArr.push({ ...item, [originalIndex]: i });
-    }
-  }
-  return newArr;
-};
-function parseAllOf(schema, refs) {
-  if (schema.allOf.length === 0) {
-    return "z.never()";
-  } else if (schema.allOf.length === 1) {
-    const item = schema.allOf[0];
-    return parseSchema(item, {
-      ...refs,
-      path: [...refs.path, "allOf", item[originalIndex]]
-    });
-  } else {
-    const [left, right] = half(ensureOriginalIndex(schema.allOf));
-    return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
-      allOf: right
-    }, refs)})`;
-  }
-}
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/withMessage.js
-function withMessage(schema, key, get) {
-  const value = schema[key];
-  let r = "";
-  if (value !== void 0) {
-    const got = get({ value, json: JSON.stringify(value) });
-    if (got) {
-      const opener = got[0];
-      const prefix = got.length === 3 ? got[1] : "";
-      const closer = got.length === 3 ? got[2] : got[1];
-      r += opener;
-      if (schema.errorMessage?.[key] !== void 0) {
-        r += prefix + JSON.stringify(schema.errorMessage[key]);
-      }
-      r += closer;
-    }
-  }
-  return r;
-}
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseArray.js
-var parseArray = (schema, refs) => {
-  if (Array.isArray(schema.items)) {
-    return `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
-  }
-  let r = !schema.items ? "z.array(z.any())" : `z.array(${parseSchema(schema.items, {
-    ...refs,
-    path: [...refs.path, "items"]
-  })})`;
-  r += withMessage(schema, "minItems", ({ json }) => [
-    `.min(${json}`,
-    ", ",
-    ")"
-  ]);
-  r += withMessage(schema, "maxItems", ({ json }) => [
-    `.max(${json}`,
-    ", ",
-    ")"
-  ]);
-  return r;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseConst.js
-var parseConst = (schema) => {
-  return `z.literal(${JSON.stringify(schema.const)})`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseEnum.js
-var parseEnum = (schema) => {
-  if (schema.enum.length === 0) {
-    return "z.never()";
-  } else if (schema.enum.length === 1) {
-    return `z.literal(${JSON.stringify(schema.enum[0])})`;
-  } else if (schema.enum.every((x) => typeof x === "string")) {
-    return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
-  } else {
-    return `z.union([${schema.enum.map((x) => `z.literal(${JSON.stringify(x)})`).join(", ")}])`;
-  }
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseIfThenElse.js
-var parseIfThenElse = (schema, refs) => {
-  const $if = parseSchema(schema.if, { ...refs, path: [...refs.path, "if"] });
-  const $then = parseSchema(schema.then, {
-    ...refs,
-    path: [...refs.path, "then"]
-  });
-  const $else = parseSchema(schema.else, {
-    ...refs,
-    path: [...refs.path, "else"]
-  });
-  return `z.union([${$then}, ${$else}]).superRefine((value,ctx) => {
-  const result = ${$if}.safeParse(value).success
-    ? ${$then}.safeParse(value)
-    : ${$else}.safeParse(value);
-  if (!result.success) {
-    result.error.errors.forEach((error) => ctx.addIssue(error))
-  }
-})`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNumber.js
-var parseNumber = (schema) => {
-  let r = "z.number()";
-  if (schema.type === "integer") {
-    r += withMessage(schema, "type", () => [".int(", ")"]);
-  } else {
-    r += withMessage(schema, "format", ({ value }) => {
-      if (value === "int64") {
-        return [".int(", ")"];
+    this.name = name;
+    this.timeout = timeout;
+    this.logHandler = server.logger;
+    this.enableServerLogs = server.enableServerLogs ?? true;
+    this.serverConfig = server;
+    this.client = new Client(
+      {
+        name,
+        version
+      },
+      {
+        capabilities
       }
-    });
+    );
+    this.setupLogging();
   }
-  r += withMessage(schema, "multipleOf", ({ value, json }) => {
-    if (value === 1) {
-      if (r.startsWith("z.number().int(")) {
-        return;
-      }
-      return [".int(", ")"];
-    }
-    return [`.multipleOf(${json}`, ", ", ")"];
-  });
-  if (typeof schema.minimum === "number") {
-    if (schema.exclusiveMinimum === true) {
-      r += withMessage(schema, "minimum", ({ json }) => [
-        `.gt(${json}`,
-        ", ",
-        ")"
-      ]);
-    } else {
-      r += withMessage(schema, "minimum", ({ json }) => [
-        `.gte(${json}`,
-        ", ",
-        ")"
-      ]);
+  /**
+   * Log a message at the specified level
+   * @param level Log level
+   * @param message Log message
+   * @param details Optional additional details
+   */
+  log(level, message, details) {
+    const loggerMethod = convertLogLevelToLoggerMethod(level);
+    const msg = `[${this.name}] ${message}`;
+    this.logger[loggerMethod](msg, details);
+    if (this.logHandler) {
+      this.logHandler({
+        level,
+        message: msg,
+        timestamp: /* @__PURE__ */ new Date(),
+        serverName: this.name,
+        details
+      });
     }
-  } else if (typeof schema.exclusiveMinimum === "number") {
-    r += withMessage(schema, "exclusiveMinimum", ({ json }) => [
-      `.gt(${json}`,
-      ", ",
-      ")"
-    ]);
   }
-  if (typeof schema.maximum === "number") {
-    if (schema.exclusiveMaximum === true) {
-      r += withMessage(schema, "maximum", ({ json }) => [
-        `.lt(${json}`,
-        ", ",
-        ")"
-      ]);
-    } else {
-      r += withMessage(schema, "maximum", ({ json }) => [
-        `.lte(${json}`,
-        ", ",
-        ")"
-      ]);
+  setupLogging() {
+    if (this.enableServerLogs) {
+      this.client.setNotificationHandler(
+        z.object({
+          method: z.literal("notifications/message"),
+          params: z.object({
+            level: z.string()
+          }).passthrough()
+        }),
+        (notification) => {
+          const { level, ...params } = notification.params;
+          this.log(level, "[MCP SERVER LOG]", params);
+        }
+      );
     }
-  } else if (typeof schema.exclusiveMaximum === "number") {
-    r += withMessage(schema, "exclusiveMaximum", ({ json }) => [
-      `.lt(${json}`,
-      ", ",
-      ")"
-    ]);
   }
-  return r;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseOneOf.js
-var parseOneOf = (schema, refs) => {
-  return schema.oneOf.length ? schema.oneOf.length === 1 ? parseSchema(schema.oneOf[0], {
-    ...refs,
-    path: [...refs.path, "oneOf", 0]
-  }) : `z.any().superRefine((x, ctx) => {
-    const schemas = [${schema.oneOf.map((schema2, i) => parseSchema(schema2, {
-    ...refs,
-    path: [...refs.path, "oneOf", i]
-  })).join(", ")}];
-    const errors = schemas.reduce<z.ZodError[]>(
-      (errors, schema) =>
-        ((result) =>
-          result.error ? [...errors, result.error] : errors)(
-          schema.safeParse(x),
-        ),
-      [],
-    );
-    if (schemas.length - errors.length !== 1) {
-      ctx.addIssue({
-        path: ctx.path,
-        code: "invalid_union",
-        unionErrors: errors,
-        message: "Invalid input: Should pass single schema",
+  async connectStdio(command) {
+    this.log("debug", `Using Stdio transport for command: ${command}`);
+    try {
+      this.transport = new StdioClientTransport({
+        command,
+        args: this.serverConfig.args,
+        env: { ...getDefaultEnvironment(), ...this.serverConfig.env || {} }
       });
-    }
-  })` : "z.any()";
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/jsdocs.js
-var expandJsdocs = (jsdocs) => {
-  const lines = jsdocs.split("\n");
-  const result = lines.length === 1 ? lines[0] : `
-${lines.map((x) => `* ${x}`).join("\n")}
-`;
-  return `/**${result}*/
-`;
-};
-var addJsdocs = (schema, parsed) => {
-  const description = schema.description;
-  if (!description) {
-    return parsed;
-  }
-  return `
-${expandJsdocs(description)}${parsed}`;
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseObject.js
-function parseObject(objectSchema, refs) {
-  let properties = void 0;
-  if (objectSchema.properties) {
-    if (!Object.keys(objectSchema.properties).length) {
-      properties = "z.object({})";
-    } else {
-      properties = "z.object({ ";
-      properties += Object.keys(objectSchema.properties).map((key) => {
-        const propSchema = objectSchema.properties[key];
-        let result = `${JSON.stringify(key)}: ${parseSchema(propSchema, {
-          ...refs,
-          path: [...refs.path, "properties", key]
-        })}`;
-        if (refs.withJsdocs && typeof propSchema === "object") {
-          result = addJsdocs(propSchema, result);
-        }
-        const hasDefault = typeof propSchema === "object" && propSchema.default !== void 0;
-        const required = Array.isArray(objectSchema.required) ? objectSchema.required.includes(key) : typeof propSchema === "object" && propSchema.required === true;
-        const optional = !hasDefault && !required;
-        return optional ? `${result}.optional()` : result;
-      }).join(", ");
-      properties += " })";
+      await this.client.connect(this.transport, { timeout: this.serverConfig.timeout ?? this.timeout });
+      this.log("debug", `Successfully connected to MCP server via Stdio`);
+    } catch (e) {
+      this.log("error", e instanceof Error ? e.stack || e.message : JSON.stringify(e));
+      throw e;
     }
   }
-  const additionalProperties = objectSchema.additionalProperties !== void 0 ? parseSchema(objectSchema.additionalProperties, {
-    ...refs,
-    path: [...refs.path, "additionalProperties"]
-  }) : void 0;
-  let patternProperties = void 0;
-  if (objectSchema.patternProperties) {
-    const parsedPatternProperties = Object.fromEntries(Object.entries(objectSchema.patternProperties).map(([key, value]) => {
-      return [
-        key,
-        parseSchema(value, {
-          ...refs,
-          path: [...refs.path, "patternProperties", key]
-        })
-      ];
-    }, {}));
-    patternProperties = "";
-    if (properties) {
-      if (additionalProperties) {
-        patternProperties += `.catchall(z.union([${[
-          ...Object.values(parsedPatternProperties),
-          additionalProperties
-        ].join(", ")}]))`;
-      } else if (Object.keys(parsedPatternProperties).length > 1) {
-        patternProperties += `.catchall(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-      } else {
-        patternProperties += `.catchall(${Object.values(parsedPatternProperties)})`;
-      }
-    } else {
-      if (additionalProperties) {
-        patternProperties += `z.record(z.union([${[
-          ...Object.values(parsedPatternProperties),
-          additionalProperties
-        ].join(", ")}]))`;
-      } else if (Object.keys(parsedPatternProperties).length > 1) {
-        patternProperties += `z.record(z.union([${Object.values(parsedPatternProperties).join(", ")}]))`;
-      } else {
-        patternProperties += `z.record(${Object.values(parsedPatternProperties)})`;
+  async connectHttp(url) {
+    const { requestInit, eventSourceInit } = this.serverConfig;
+    this.log("debug", `Attempting to connect to URL: ${url}`);
+    let shouldTrySSE = url.pathname.endsWith(`/sse`);
+    if (!shouldTrySSE) {
+      try {
+        this.log("debug", "Trying Streamable HTTP transport...");
+        const streamableTransport = new StreamableHTTPClientTransport(url, {
+          requestInit,
+          reconnectionOptions: this.serverConfig.reconnectionOptions,
+          sessionId: this.serverConfig.sessionId
+        });
+        await this.client.connect(streamableTransport, {
+          timeout: (
+            // this is hardcoded to 3s because the long default timeout would be extremely slow for sse backwards compat (60s)
+            3e3
+          )
+        });
+        this.transport = streamableTransport;
+        this.log("debug", "Successfully connected using Streamable HTTP transport.");
+      } catch (error) {
+        this.log("debug", `Streamable HTTP transport failed: ${error}`);
+        shouldTrySSE = true;
       }
     }
-    patternProperties += ".superRefine((value, ctx) => {\n";
-    patternProperties += "for (const key in value) {\n";
-    if (additionalProperties) {
-      if (objectSchema.properties) {
-        patternProperties += `let evaluated = [${Object.keys(objectSchema.properties).map((key) => JSON.stringify(key)).join(", ")}].includes(key)
-`;
-      } else {
-        patternProperties += `let evaluated = false
-`;
+    if (shouldTrySSE) {
+      this.log("debug", "Falling back to deprecated HTTP+SSE transport...");
+      try {
+        const sseTransport = new SSEClientTransport(url, { requestInit, eventSourceInit });
+        await this.client.connect(sseTransport, { timeout: this.serverConfig.timeout ?? this.timeout });
+        this.transport = sseTransport;
+        this.log("debug", "Successfully connected using deprecated HTTP+SSE transport.");
+      } catch (sseError) {
+        this.log(
+          "error",
+          `Failed to connect with SSE transport after failing to connect to Streamable HTTP transport first. SSE error: ${sseError}`
+        );
+        throw new Error("Could not connect to server with any available HTTP transport");
       }
     }
-    for (const key in objectSchema.patternProperties) {
-      patternProperties += "if (key.match(new RegExp(" + JSON.stringify(key) + "))) {\n";
-      if (additionalProperties) {
-        patternProperties += "evaluated = true\n";
-      }
-      patternProperties += "const result = " + parsedPatternProperties[key] + ".safeParse(value[key])\n";
-      patternProperties += "if (!result.success) {\n";
-      patternProperties += `ctx.addIssue({
-          path: [...ctx.path, key],
-          code: 'custom',
-          message: \`Invalid input: Key matching regex /\${key}/ must match schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })
-`;
-      patternProperties += "}\n";
-      patternProperties += "}\n";
+  }
+  isConnected = false;
+  async connect() {
+    if (this.isConnected) return;
+    const { command, url } = this.serverConfig;
+    if (command) {
+      await this.connectStdio(command);
+    } else if (url) {
+      await this.connectHttp(url);
+    } else {
+      throw new Error("Server configuration must include either a command or a url.");
     }
-    if (additionalProperties) {
-      patternProperties += "if (!evaluated) {\n";
-      patternProperties += "const result = " + additionalProperties + ".safeParse(value[key])\n";
-      patternProperties += "if (!result.success) {\n";
-      patternProperties += `ctx.addIssue({
-          path: [...ctx.path, key],
-          code: 'custom',
-          message: \`Invalid input: must match catchall schema\`,
-          params: {
-            issues: result.error.issues
-          }
-        })
-`;
-      patternProperties += "}\n";
-      patternProperties += "}\n";
+    this.isConnected = true;
+    const originalOnClose = this.client.onclose;
+    this.client.onclose = () => {
+      this.log("debug", `MCP server connection closed`);
+      this.isConnected = false;
+      if (typeof originalOnClose === `function`) {
+        originalOnClose();
+      }
+    };
+    asyncExitHook(
+      async () => {
+        this.log("debug", `Disconnecting MCP server during exit`);
+        await this.disconnect();
+      },
+      { wait: 5e3 }
+    );
+    process.on("SIGTERM", () => gracefulExit());
+    this.log("debug", `Successfully connected to MCP server`);
+  }
+  /**
+   * Get the current session ID if using the Streamable HTTP transport.
+   * Returns undefined if not connected or not using Streamable HTTP.
+   */
+  get sessionId() {
+    if (this.transport instanceof StreamableHTTPClientTransport) {
+      return this.transport.sessionId;
     }
-    patternProperties += "}\n";
-    patternProperties += "})";
+    return void 0;
   }
-  let output = properties ? patternProperties ? properties + patternProperties : additionalProperties ? additionalProperties === "z.never()" ? properties + ".strict()" : properties + `.catchall(${additionalProperties})` : properties : patternProperties ? patternProperties : additionalProperties ? `z.record(${additionalProperties})` : "z.record(z.any())";
-  if (its.an.anyOf(objectSchema)) {
-    output += `.and(${parseAnyOf({
-      anyOf: objectSchema.anyOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-    }, refs)})`;
+  async disconnect() {
+    if (!this.transport) {
+      this.log("debug", "Disconnect called but no transport was connected.");
+      return;
+    }
+    this.log("debug", `Disconnecting from MCP server`);
+    try {
+      await this.transport.close();
+      this.log("debug", "Successfully disconnected from MCP server");
+    } catch (e) {
+      this.log("error", "Error during MCP server disconnect", {
+        error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2)
+      });
+      throw e;
+    } finally {
+      this.transport = void 0;
+      this.isConnected = false;
+    }
   }
-  if (its.a.oneOf(objectSchema)) {
-    output += `.and(${parseOneOf({
-      oneOf: objectSchema.oneOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-    }, refs)})`;
+  // TODO: do the type magic to return the right method type. Right now we get infinitely deep infered type errors from Zod without using "any"
+  async resources() {
+    this.log("debug", `Requesting resources from MCP server`);
+    return await this.client.request({ method: "resources/list" }, ListResourcesResultSchema, {
+      timeout: this.timeout
+    });
   }
-  if (its.an.allOf(objectSchema)) {
-    output += `.and(${parseAllOf({
-      allOf: objectSchema.allOf.map((x) => typeof x === "object" && !x.type && (x.properties || x.additionalProperties || x.patternProperties) ? { ...x, type: "object" } : x)
-    }, refs)})`;
+  convertInputSchema(inputSchema) {
+    return isZodType$1(inputSchema) ? inputSchema : resolveSerializedZodOutput$1(esm_default(inputSchema));
   }
-  return output;
-}
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseString.js
-var parseString = (schema) => {
-  let r = "z.string()";
-  r += withMessage(schema, "format", ({ value }) => {
-    switch (value) {
-      case "email":
-        return [".email(", ")"];
-      case "ip":
-        return [".ip(", ")"];
-      case "ipv4":
-        return ['.ip({ version: "v4"', ", message: ", " })"];
-      case "ipv6":
-        return ['.ip({ version: "v6"', ", message: ", " })"];
-      case "uri":
-        return [".url(", ")"];
-      case "uuid":
-        return [".uuid(", ")"];
-      case "date-time":
-        return [".datetime({ offset: true", ", message: ", " })"];
-      case "time":
-        return [".time(", ")"];
-      case "date":
-        return [".date(", ")"];
-      case "binary":
-        return [".base64(", ")"];
-      case "duration":
-        return [".duration(", ")"];
-    }
-  });
-  r += withMessage(schema, "pattern", ({ json }) => [
-    `.regex(new RegExp(${json})`,
-    ", ",
-    ")"
-  ]);
-  r += withMessage(schema, "minLength", ({ json }) => [
-    `.min(${json}`,
-    ", ",
-    ")"
-  ]);
-  r += withMessage(schema, "maxLength", ({ json }) => [
-    `.max(${json}`,
-    ", ",
-    ")"
-  ]);
-  r += withMessage(schema, "contentEncoding", ({ value }) => {
-    if (value === "base64") {
-      return [".base64(", ")"];
-    }
-  });
-  const contentMediaType = withMessage(schema, "contentMediaType", ({ value }) => {
-    if (value === "application/json") {
-      return [
-        '.transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: "custom", message: "Invalid JSON" }); }}',
-        ", ",
-        ")"
-      ];
-    }
-  });
-  if (contentMediaType != "") {
-    r += contentMediaType;
-    r += withMessage(schema, "contentSchema", ({ value }) => {
-      if (value && value instanceof Object) {
-        return [
-          `.pipe(${parseSchema(value)}`,
-          ", ",
-          ")"
-        ];
+  async tools() {
+    this.log("debug", `Requesting tools from MCP server`);
+    const { tools } = await this.client.listTools({ timeout: this.timeout });
+    const toolsRes = {};
+    tools.forEach((tool) => {
+      this.log("debug", `Processing tool: ${tool.name}`);
+      const mastraTool = createTool({
+        id: `${this.name}_${tool.name}`,
+        description: tool.description || "",
+        inputSchema: this.convertInputSchema(tool.inputSchema),
+        execute: async ({ context }) => {
+          try {
+            this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
+            const res = await this.client.callTool(
+              {
+                name: tool.name,
+                arguments: context
+              },
+              CallToolResultSchema,
+              {
+                timeout: this.timeout
+              }
+            );
+            this.log("debug", `Tool executed successfully: ${tool.name}`);
+            return res;
+          } catch (e) {
+            this.log("error", `Error calling tool: ${tool.name}`, {
+              error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
+              toolArgs: context
+            });
+            throw e;
+          }
+        }
+      });
+      if (tool.name) {
+        toolsRes[tool.name] = mastraTool;
       }
     });
+    return toolsRes;
   }
-  return r;
 };
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/utils/omit.js
-var omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
-  if (!keys.includes(key)) {
-    acc[key] = obj[key];
+var MastraMCPClient = class extends InternalMastraMCPClient {
+  constructor(args) {
+    super(args);
+    this.logger.warn(
+      "[DEPRECATION] MastraMCPClient is deprecated and will be removed in a future release. Please use MCPClient instead."
+    );
   }
-  return acc;
-}, {});
+};
+var mcpClientInstances = /* @__PURE__ */ new Map();
+var MCPClient = class extends MastraBase {
+  serverConfigs = {};
+  id;
+  defaultTimeout;
+  mcpClientsById = /* @__PURE__ */ new Map();
+  disconnectPromise = null;
+  constructor(args) {
+    super({ name: "MCPClient" });
+    this.defaultTimeout = args.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+    this.serverConfigs = args.servers;
+    this.id = args.id ?? this.makeId();
+    if (args.id) {
+      this.id = args.id;
+      const cached = mcpClientInstances.get(this.id);
+      if (cached && !equal(cached.serverConfigs, args.servers)) {
+        const existingInstance2 = mcpClientInstances.get(this.id);
+        if (existingInstance2) {
+          void existingInstance2.disconnect();
+        }
+      }
+    } else {
+      this.id = this.makeId();
+    }
+    const existingInstance = mcpClientInstances.get(this.id);
+    if (existingInstance) {
+      if (!args.id) {
+        throw new Error(`MCPClient was initialized multiple times with the same configuration options.
 
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseNullable.js
-var parseNullable = (schema, refs) => {
-  return `${parseSchema(omit(schema, "nullable"), refs, true)}.nullable()`;
-};
+This error is intended to prevent memory leaks.
 
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/parsers/parseSchema.js
-var parseSchema = (schema, refs = { seen: /* @__PURE__ */ new Map(), path: [] }, blockMeta) => {
-  if (typeof schema !== "object")
-    return schema ? "z.any()" : "z.never()";
-  if (refs.parserOverride) {
-    const custom2 = refs.parserOverride(schema, refs);
-    if (typeof custom2 === "string") {
-      return custom2;
-    }
-  }
-  let seen = refs.seen.get(schema);
-  if (seen) {
-    if (seen.r !== void 0) {
-      return seen.r;
-    }
-    if (refs.depth === void 0 || seen.n >= refs.depth) {
-      return "z.any()";
+To fix this you have three different options:
+1. If you need multiple MCPClient class instances with identical server configurations, set an id when configuring: new MCPClient({ id: "my-unique-id" })
+2. Call "await client.disconnect()" after you're done using the client and before you recreate another instance with the same options. If the identical MCPClient instance is already closed at the time of re-creating it, you will not see this error.
+3. If you only need one instance of MCPClient in your app, refactor your code so it's only created one time (ex. move it out of a loop into a higher scope code block)
+`);
+      }
+      return existingInstance;
     }
-    seen.n += 1;
-  } else {
-    seen = { r: void 0, n: 0 };
-    refs.seen.set(schema, seen);
+    mcpClientInstances.set(this.id, this);
+    this.addToInstanceCache();
+    return this;
   }
-  let parsed = selectParser(schema, refs);
-  if (!blockMeta) {
-    if (!refs.withoutDescribes) {
-      parsed = addDescribes(schema, parsed);
-    }
-    if (!refs.withoutDefaults) {
-      parsed = addDefaults(schema, parsed);
+  addToInstanceCache() {
+    if (!mcpClientInstances.has(this.id)) {
+      mcpClientInstances.set(this.id, this);
     }
-    parsed = addAnnotations(schema, parsed);
-  }
-  seen.r = parsed;
-  return parsed;
-};
-var addDescribes = (schema, parsed) => {
-  if (schema.description) {
-    parsed += `.describe(${JSON.stringify(schema.description)})`;
   }
-  return parsed;
-};
-var addDefaults = (schema, parsed) => {
-  if (schema.default !== void 0) {
-    parsed += `.default(${JSON.stringify(schema.default)})`;
+  makeId() {
+    const text = JSON.stringify(this.serverConfigs).normalize("NFKC");
+    const idNamespace = v5(`MCPClient`, v5.DNS);
+    return v5(text, idNamespace);
   }
-  return parsed;
-};
-var addAnnotations = (schema, parsed) => {
-  if (schema.readOnly) {
-    parsed += ".readonly()";
+  async disconnect() {
+    if (this.disconnectPromise) {
+      return this.disconnectPromise;
+    }
+    this.disconnectPromise = (async () => {
+      try {
+        mcpClientInstances.delete(this.id);
+        await Promise.all(Array.from(this.mcpClientsById.values()).map((client) => client.disconnect()));
+        this.mcpClientsById.clear();
+      } finally {
+        this.disconnectPromise = null;
+      }
+    })();
+    return this.disconnectPromise;
   }
-  return parsed;
-};
-var selectParser = (schema, refs) => {
-  if (its.a.nullable(schema)) {
-    return parseNullable(schema, refs);
-  } else if (its.an.object(schema)) {
-    return parseObject(schema, refs);
-  } else if (its.an.array(schema)) {
-    return parseArray(schema, refs);
-  } else if (its.an.anyOf(schema)) {
-    return parseAnyOf(schema, refs);
-  } else if (its.an.allOf(schema)) {
-    return parseAllOf(schema, refs);
-  } else if (its.a.oneOf(schema)) {
-    return parseOneOf(schema, refs);
-  } else if (its.a.not(schema)) {
-    return parseNot(schema, refs);
-  } else if (its.an.enum(schema)) {
-    return parseEnum(schema);
-  } else if (its.a.const(schema)) {
-    return parseConst(schema);
-  } else if (its.a.multipleType(schema)) {
-    return parseMultipleType(schema, refs);
-  } else if (its.a.primitive(schema, "string")) {
-    return parseString(schema);
-  } else if (its.a.primitive(schema, "number") || its.a.primitive(schema, "integer")) {
-    return parseNumber(schema);
-  } else if (its.a.primitive(schema, "boolean")) {
-    return parseBoolean();
-  } else if (its.a.primitive(schema, "null")) {
-    return parseNull();
-  } else if (its.a.conditional(schema)) {
-    return parseIfThenElse(schema, refs);
-  } else {
-    return parseDefault();
+  async getTools() {
+    this.addToInstanceCache();
+    const connectedTools = {};
+    await this.eachClientTools(async ({ serverName, tools }) => {
+      for (const [toolName, toolConfig] of Object.entries(tools)) {
+        connectedTools[`${serverName}_${toolName}`] = toolConfig;
+      }
+    });
+    return connectedTools;
   }
-};
-var its = {
-  an: {
-    object: (x) => x.type === "object",
-    array: (x) => x.type === "array",
-    anyOf: (x) => x.anyOf !== void 0,
-    allOf: (x) => x.allOf !== void 0,
-    enum: (x) => x.enum !== void 0
-  },
-  a: {
-    nullable: (x) => x.nullable === true,
-    multipleType: (x) => Array.isArray(x.type),
-    not: (x) => x.not !== void 0,
-    const: (x) => x.const !== void 0,
-    primitive: (x, p) => x.type === p,
-    conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),
-    oneOf: (x) => x.oneOf !== void 0
+  async getToolsets() {
+    this.addToInstanceCache();
+    const connectedToolsets = {};
+    await this.eachClientTools(async ({ serverName, tools }) => {
+      if (tools) {
+        connectedToolsets[serverName] = tools;
+      }
+    });
+    return connectedToolsets;
   }
-};
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/jsonSchemaToZod.js
-var jsonSchemaToZod = (schema, { module, name, type, noImport, ...rest } = {}) => {
-  if (type && (!name || module !== "esm")) {
-    throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
+  /**
+   * Get the current session IDs for all connected MCP clients using the Streamable HTTP transport.
+   * Returns an object mapping server names to their session IDs.
+   */
+  get sessionIds() {
+    const sessionIds = {};
+    for (const [serverName, client] of this.mcpClientsById.entries()) {
+      if (client.sessionId) {
+        sessionIds[serverName] = client.sessionId;
+      }
+    }
+    return sessionIds;
   }
-  let result = parseSchema(schema, {
-    module,
-    name,
-    path: [],
-    seen: /* @__PURE__ */ new Map(),
-    ...rest
-  });
-  const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description ? expandJsdocs(schema.description) : "";
-  if (module === "cjs") {
-    result = `${jsdocs}module.exports = ${name ? `{ ${JSON.stringify(name)}: ${result} }` : result}
-`;
-    if (!noImport) {
-      result = `${jsdocs}const { z } = require("zod")
-
-${result}`;
+  async getConnectedClient(name, config) {
+    if (this.disconnectPromise) {
+      await this.disconnectPromise;
     }
-  } else if (module === "esm") {
-    result = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${result}
-`;
-    if (!noImport) {
-      result = `import { z } from "zod"
-
-${result}`;
+    const exists = this.mcpClientsById.has(name);
+    const existingClient = this.mcpClientsById.get(name);
+    if (exists) {
+      if (!existingClient) {
+        throw new Error(`Client ${name} exists but is undefined`);
+      }
+      await existingClient.connect();
+      return existingClient;
     }
-  } else if (name) {
-    result = `${jsdocs}const ${name} = ${result}`;
+    this.logger.debug(`Connecting to ${name} MCP server`);
+    const mcpClient = new InternalMastraMCPClient({
+      name,
+      server: config,
+      timeout: config.timeout ?? this.defaultTimeout
+    });
+    this.mcpClientsById.set(name, mcpClient);
+    try {
+      await mcpClient.connect();
+    } catch (e) {
+      this.mcpClientsById.delete(name);
+      this.logger.error(`MCPClient errored connecting to MCP server ${name}`, {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      throw new Error(
+        `Failed to connect to MCP server ${name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
+      );
+    }
+    this.logger.debug(`Connected to ${name} MCP server`);
+    return mcpClient;
   }
-  if (type && name) {
-    let typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
-    result += `export type ${typeName} = z.infer<typeof ${name}>
-`;
+  async eachClientTools(cb) {
+    await Promise.all(
+      Object.entries(this.serverConfigs).map(async ([serverName, serverConfig]) => {
+        const client = await this.getConnectedClient(serverName, serverConfig);
+        const tools = await client.tools();
+        await cb({ serverName, tools, client });
+      })
+    );
+  }
+};
+var MCPConfiguration = class extends MCPClient {
+  constructor(args) {
+    super(args);
+    this.logger.warn(
+      `MCPConfiguration has been renamed to MCPClient and MCPConfiguration is deprecated. The API is identical but the MCPConfiguration export will be removed in the future. Update your imports now to prevent future errors.`
+    );
   }
-  return result;
 };
-
-// ../../node_modules/.pnpm/json-schema-to-zod@2.6.0/node_modules/json-schema-to-zod/dist/esm/index.js
-var esm_default = jsonSchemaToZod;
 
 // ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/Options.js
 var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");