@mastra/mcp 0.4.0-alpha.8 → 0.4.0

package/dist/index.js

@@ -5,9 +5,16 @@ 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';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import { ListResourcesResultSchema, CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListResourcesResultSchema, CallToolResultSchema, ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { asyncExitHook, gracefulExit } from 'exit-hook';
 import { v5 } from 'uuid';
+import { isVercelTool, isZodType, resolveSerializedZodOutput } from '@mastra/core';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 
 // src/client.ts
 
@@ -364,8 +371,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -487,11 +494,11 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -4105,7 +4112,7 @@ var MastraMCPClient = class extends MastraBase {
     this.timeout = timeout;
     this.logHandler = server.logger;
     this.enableServerLogs = server.enableServerLogs ?? true;
-    const { logger, enableServerLogs, ...serverConfig } = server;
+    const { logger: logger3, enableServerLogs, ...serverConfig } = server;
     if (`url` in serverConfig) {
       this.transport = new SSEClientTransport(serverConfig.url, {
         requestInit: serverConfig.requestInit,
@@ -4352,4 +4359,2123 @@ To fix this you have three different options:
   }
 };
 
-export { MCPConfiguration, MastraMCPClient };
+// ../../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(", ")"];
+      }
+    });
+  }
+  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}`,
+        ", ",
+        ")"
+      ]);
+    }
+  } 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}`,
+        ", ",
+        ")"
+      ]);
+    }
+  } 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",
+      });
+    }
+  })` : "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 += " })";
+    }
+  }
+  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)})`;
+      }
+    }
+    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 += "})";
+  }
+  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)})`;
+  }
+  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)})`;
+  }
+  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)})`;
+  }
+  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;
+    }
+  }
+  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;
+};
+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)})`;
+  }
+  return parsed;
+};
+var addAnnotations = (schema, parsed) => {
+  if (schema.readOnly) {
+    parsed += ".readonly()";
+  }
+  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();
+  }
+};
+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
+  }
+};
+
+// ../../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`");
+  }
+  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}`;
+    }
+  } else if (module === "esm") {
+    result = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${result}
+`;
+    if (!noImport) {
+      result = `import { z } from "zod"
+
+${result}`;
+    }
+  } else if (name) {
+    result = `${jsdocs}const ${name} = ${result}`;
+  }
+  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;
+};
+
+// ../../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");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => ({
+  ...defaultOptions,
+  ...options
+});
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/Refs.js
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+function parseAnyDef() {
+  return {};
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+function parseLiteralDef(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var emojiRegex2 = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex2 === void 0) {
+      emojiRegex2 = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex2;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+          break;
+        case "endsWith":
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "includes": {
+          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  return pattern;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? {}
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || {};
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || {};
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+function parseNeverDef() {
+  return {
+    not: {}
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef instanceof ZodOptional) {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
+      }
+      propOptional = false;
+    }
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+var parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: {}
+      },
+      innerSchema
+    ]
+  } : {};
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+function parseUndefinedDef() {
+  return {
+    not: {}
+  };
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+function parseUnknownDef() {
+  return {};
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var selectParser2 = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef();
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef();
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef();
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef();
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)();
+  }
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser2(def, def.typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return {};
+      }
+      return refs.$refStrategy === "seen" ? {} : void 0;
+    }
+  }
+};
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+var addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.24.3/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  const definitions = void 0;
+  const name = options?.name;
+  const main = parseDef(schema._def, refs , false) ?? {};
+  const combined = name === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name]: main
+    }
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
+  }
+  return combined;
+};
+var writeErrorLog = (message, data) => {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString();
+  const hourTimestamp = timestamp.slice(0, 13);
+  const logMessage = {
+    timestamp,
+    message,
+    ...data ? typeof data === "object" ? data : { data } : {}
+  };
+  try {
+    const cacheDir = path.join(os.homedir(), ".cache", "mastra", "mcp-docs-server-logs");
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const logFile = path.join(cacheDir, `${hourTimestamp}.log`);
+    fs.appendFileSync(logFile, JSON.stringify(logMessage) + "\n", "utf8");
+  } catch (err) {
+    console.error("Failed to write to log file:", err);
+  }
+};
+function createLogger(server) {
+  const sendLog = async (level, message, data) => {
+    return;
+  };
+  return {
+    info: async (message, data) => {
+      console.error(message, data ? data : "");
+      await sendLog();
+    },
+    warning: async (message, data) => {
+      console.error(message, data ? data : "");
+      await sendLog();
+    },
+    error: async (message, error) => {
+      const errorData = error instanceof Error ? {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      } : error;
+      writeErrorLog(message, errorData);
+      console.error(message, errorData ? errorData : "");
+      await sendLog();
+    },
+    debug: async (message, data) => {
+      if (process.env.DEBUG || process.env.NODE_ENV === "development") {
+        console.error(message, data ? data : "");
+        await sendLog();
+      }
+    }
+  };
+}
+
+// src/server.ts
+var logger2 = createLogger();
+var MCPServer = class {
+  server;
+  convertedTools;
+  stdioTransport;
+  sseTransport;
+  /**
+   * Get the current stdio transport.
+   */
+  getStdioTransport() {
+    return this.stdioTransport;
+  }
+  /**
+   * Get the current SSE transport.
+   */
+  getSseTransport() {
+    return this.sseTransport;
+  }
+  /**
+   * Get a read-only view of the registered tools (for testing/introspection).
+   */
+  tools() {
+    return this.convertedTools;
+  }
+  /**
+   * Construct a new MCPServer instance.
+   * @param opts.name - Server name
+   * @param opts.version - Server version
+   * @param opts.tools - Tool definitions to register
+   */
+  constructor({ name, version, tools }) {
+    this.server = new Server({ name, version }, { capabilities: { tools: {}, logging: { enabled: true } } });
+    this.convertedTools = this.convertTools(tools);
+    void logger2.info(
+      `Initialized MCPServer '${name}' v${version} with tools: ${Object.keys(this.convertedTools).join(", ")}`
+    );
+    this.registerListToolsHandler();
+    this.registerCallToolHandler();
+  }
+  /**
+   * Convert and validate all provided tools, logging registration status.
+   * @param tools Tool definitions
+   * @returns Converted tools registry
+   */
+  convertTools(tools) {
+    const convertedTools = {};
+    for (const toolName of Object.keys(tools)) {
+      let inputSchema;
+      let zodSchema;
+      const toolInstance = tools[toolName];
+      if (!toolInstance) {
+        void logger2.warning(`Tool instance for '${toolName}' is undefined. Skipping.`);
+        continue;
+      }
+      if (typeof toolInstance.execute !== "function") {
+        void logger2.warning(`Tool '${toolName}' does not have a valid execute function. Skipping.`);
+        continue;
+      }
+      if (isVercelTool(toolInstance)) {
+        if (isZodType(toolInstance.parameters)) {
+          zodSchema = toolInstance.parameters;
+          inputSchema = zodToJsonSchema(zodSchema);
+        } else if (typeof toolInstance.parameters === "object") {
+          zodSchema = resolveSerializedZodOutput(esm_default(toolInstance.parameters));
+          inputSchema = toolInstance.parameters;
+        } else {
+          zodSchema = z.object({});
+          inputSchema = zodToJsonSchema(zodSchema);
+        }
+      } else {
+        zodSchema = toolInstance?.inputSchema ?? z.object({});
+        inputSchema = zodToJsonSchema(zodSchema);
+      }
+      const execute = async (args, execOptions) => {
+        if (isVercelTool(toolInstance)) {
+          return await toolInstance.execute?.(args, execOptions) ?? void 0;
+        }
+        return await toolInstance.execute?.({ context: args }, execOptions) ?? void 0;
+      };
+      convertedTools[toolName] = {
+        name: toolName,
+        description: toolInstance?.description,
+        inputSchema,
+        zodSchema,
+        execute
+      };
+      void logger2.info(`Registered tool: '${toolName}' [${toolInstance?.description || "No description"}]`);
+    }
+    void logger2.info(`Total tools registered: ${Object.keys(convertedTools).length}`);
+    return convertedTools;
+  }
+  /**
+   * Register the ListTools handler for listing all available tools.
+   */
+  registerListToolsHandler() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      await logger2.debug("Handling ListTools request");
+      return {
+        tools: Object.values(this.convertedTools).map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        }))
+      };
+    });
+  }
+  /**
+   * Register the CallTool handler for executing a tool by name.
+   */
+  registerCallToolHandler() {
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const startTime = Date.now();
+      try {
+        const tool = this.convertedTools[request.params.name];
+        if (!tool) {
+          await logger2.warning(`CallTool: Unknown tool '${request.params.name}' requested.`);
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
+            isError: true
+          };
+        }
+        await logger2.debug(`CallTool: Invoking '${request.params.name}' with arguments:`, request.params.arguments);
+        const args = tool.zodSchema.parse(request.params.arguments ?? {});
+        const result = await tool.execute(args, request.params);
+        const duration = Date.now() - startTime;
+        await logger2.info(`Tool '${request.params.name}' executed successfully in ${duration}ms.`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result)
+            }
+          ],
+          isError: false
+        };
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        if (error instanceof z.ZodError) {
+          await logger2.warning("Invalid tool arguments", {
+            tool: request.params.name,
+            errors: error.errors,
+            duration: `${duration}ms`
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Invalid arguments: ${error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ")}`
+              }
+            ],
+            isError: true
+          };
+        }
+        await logger2.error(`Tool execution failed: ${request.params.name}`, error);
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    });
+  }
+  /**
+   * Start the MCP server using stdio transport (for Windsurf integration).
+   */
+  async startStdio() {
+    this.stdioTransport = new StdioServerTransport();
+    await this.server.connect(this.stdioTransport);
+    await logger2.info("Started MCP Server (stdio)");
+  }
+  /**
+   * Handles MCP-over-SSE protocol for user-provided HTTP servers.
+   * Call this from your HTTP server for both the SSE and message endpoints.
+   *
+   * @param url Parsed URL of the incoming request
+   * @param ssePath Path for establishing the SSE connection (e.g. '/sse')
+   * @param messagePath Path for POSTing client messages (e.g. '/message')
+   * @param req Incoming HTTP request
+   * @param res HTTP response (must support .write/.end)
+   */
+  async startSSE({
+    url,
+    ssePath,
+    messagePath,
+    req,
+    res
+  }) {
+    if (url.pathname === ssePath) {
+      await logger2.debug("Received SSE connection");
+      this.sseTransport = new SSEServerTransport(messagePath, res);
+      await this.server.connect(this.sseTransport);
+      this.server.onclose = async () => {
+        await this.server.close();
+        this.sseTransport = void 0;
+      };
+      res.on("close", () => {
+        this.sseTransport = void 0;
+      });
+    } else if (url.pathname === messagePath) {
+      await logger2.debug("Received message");
+      if (!this.sseTransport) {
+        res.writeHead(503);
+        res.end("SSE connection not established");
+        return;
+      }
+      await this.sseTransport.handlePostMessage(req, res);
+    } else {
+      await logger2.debug("Unknown path:", url.pathname);
+      res.writeHead(404);
+      res.end();
+    }
+  }
+};
+
+export { MCPConfiguration, MCPServer, MastraMCPClient };