@mastra/deployer 0.2.6-alpha.1 → 0.2.6-alpha.2

package/dist/server/index.js

@@ -1,24 +1,32 @@
+import crypto, { randomUUID } from 'crypto';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
 import { createServer } from 'http';
 import { Http2ServerRequest } from 'http2';
 import { Readable } from 'stream';
-import crypto from 'crypto';
 import { getFilePathWithoutDefaultDocument, getFilePath } from 'hono/utils/filepath';
 import { getMimeType } from 'hono/utils/mime';
 import { createReadStream, lstatSync } from 'fs';
 import { html } from 'hono/html';
+import { Telemetry } from '@mastra/core';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { cors } from 'hono/cors';
 import { logger } from 'hono/logger';
 import { HTTPException } from 'hono/http-exception';
-import { z, ZodFirstPartyTypeKind, ZodOptional } from 'zod';
+import { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateHandler as generateHandler$2, streamGenerateHandler as streamGenerateHandler$2 } from '@mastra/server/handlers/agents';
+import { getLogsHandler as getLogsHandler$1, getLogTransports as getLogTransports$1, getLogsByRunIdHandler as getLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
+import { getMemoryStatusHandler as getMemoryStatusHandler$1, getThreadsHandler as getThreadsHandler$1, getThreadByIdHandler as getThreadByIdHandler$1, getMessagesHandler as getMessagesHandler$1, createThreadHandler as createThreadHandler$1, updateThreadHandler as updateThreadHandler$1, deleteThreadHandler as deleteThreadHandler$1, saveMessagesHandler as saveMessagesHandler$1 } from '@mastra/server/handlers/memory';
+import { getNetworksHandler as getNetworksHandler$1, getNetworkByIdHandler as getNetworkByIdHandler$1, generateHandler as generateHandler$1, streamGenerateHandler as streamGenerateHandler$1 } from '@mastra/server/handlers/network';
 import { Agent } from '@mastra/core/agent';
-import { TABLE_TRACES } from '@mastra/core/storage';
-import { isVercelTool } from '@mastra/core';
-import { streamText } from 'hono/streaming';
+import { z } from 'zod';
+import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
+import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
+import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
+import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
+import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, createRunHandler as createRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1 } from '@mastra/server/handlers/workflows';
+import { stream } from 'hono/streaming';
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -156,14 +164,14 @@ var newRequest = (incoming, defaultHostname) => {
   req[urlKey] = url.href;
   return req;
 };
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
+function writeFromReadableStream(stream2, writable) {
+  if (stream2.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
-    stream.cancel();
+    stream2.cancel();
     return;
   }
-  const reader = stream.getReader();
+  const reader = stream2.getReader();
   writable.on("close", cancel);
   writable.on("error", cancel);
   reader.read().then(flow, cancel);
@@ -171,11 +179,11 @@ function writeFromReadableStream(stream, writable) {
     writable.off("close", cancel);
     writable.off("error", cancel);
   });
-  function cancel(error2) {
-    reader.cancel(error2).catch(() => {
+  function cancel(error) {
+    reader.cancel(error).catch(() => {
     });
-    if (error2) {
-      writable.destroy(error2);
+    if (error) {
+      writable.destroy(error);
     }
   }
   function onDrain() {
@@ -361,7 +369,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   const internalBody = getInternalBody(res);
   if (internalBody) {
-    const { length, source, stream } = internalBody;
+    const { length, source, stream: stream2 } = internalBody;
     if (source instanceof Uint8Array && source.byteLength !== length) ; else {
       if (length) {
         resHeaderRecord["content-length"] = length;
@@ -372,7 +380,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
       } else if (source instanceof Blob) {
         outgoing.end(new Uint8Array(await source.arrayBuffer()));
       } else {
-        await writeFromReadableStream(stream, outgoing);
+        await writeFromReadableStream(stream2, outgoing);
       }
       return;
     }
@@ -476,18 +484,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream) => {
+var createStreamBody = (stream2) => {
   const body = new ReadableStream({
     start(controller) {
-      stream.on("data", (chunk) => {
+      stream2.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream.on("end", () => {
+      stream2.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream.destroy();
+      stream2.destroy();
     }
   });
   return body;
@@ -583,10 +591,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream = createReadStream(path, { start, end });
+    const stream2 = createReadStream(path, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream), 206);
+    return c2.body(createStreamBody(stream2), 206);
   };
 };
 var RENDER_TYPE = {
@@ -833,2007 +841,8 @@ async function x(e2, t2, s3 = {}) {
   }
   return { docs: o2, components: n2 };
 }
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/double-indexed-kv.js
-var DoubleIndexedKV = class {
-  constructor() {
-    this.keyToValue = /* @__PURE__ */ new Map();
-    this.valueToKey = /* @__PURE__ */ new Map();
-  }
-  set(key, value) {
-    this.keyToValue.set(key, value);
-    this.valueToKey.set(value, key);
-  }
-  getByKey(key) {
-    return this.keyToValue.get(key);
-  }
-  getByValue(value) {
-    return this.valueToKey.get(value);
-  }
-  clear() {
-    this.keyToValue.clear();
-    this.valueToKey.clear();
-  }
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/registry.js
-var Registry = class {
-  constructor(generateIdentifier) {
-    this.generateIdentifier = generateIdentifier;
-    this.kv = new DoubleIndexedKV();
-  }
-  register(value, identifier) {
-    if (this.kv.getByValue(value)) {
-      return;
-    }
-    if (!identifier) {
-      identifier = this.generateIdentifier(value);
-    }
-    this.kv.set(identifier, value);
-  }
-  clear() {
-    this.kv.clear();
-  }
-  getIdentifier(value) {
-    return this.kv.getByValue(value);
-  }
-  getValue(identifier) {
-    return this.kv.getByKey(identifier);
-  }
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/class-registry.js
-var ClassRegistry = class extends Registry {
-  constructor() {
-    super((c2) => c2.name);
-    this.classToAllowedProps = /* @__PURE__ */ new Map();
-  }
-  register(value, options) {
-    if (typeof options === "object") {
-      if (options.allowProps) {
-        this.classToAllowedProps.set(value, options.allowProps);
-      }
-      super.register(value, options.identifier);
-    } else {
-      super.register(value, options);
-    }
-  }
-  getAllowedProps(value) {
-    return this.classToAllowedProps.get(value);
-  }
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/util.js
-function valuesOfObj(record) {
-  if ("values" in Object) {
-    return Object.values(record);
-  }
-  const values = [];
-  for (const key in record) {
-    if (record.hasOwnProperty(key)) {
-      values.push(record[key]);
-    }
-  }
-  return values;
-}
-function find(record, predicate) {
-  const values = valuesOfObj(record);
-  if ("find" in values) {
-    return values.find(predicate);
-  }
-  const valuesNotNever = values;
-  for (let i2 = 0; i2 < valuesNotNever.length; i2++) {
-    const value = valuesNotNever[i2];
-    if (predicate(value)) {
-      return value;
-    }
-  }
-  return void 0;
-}
-function forEach(record, run) {
-  Object.entries(record).forEach(([key, value]) => run(value, key));
-}
-function includes(arr, value) {
-  return arr.indexOf(value) !== -1;
-}
-function findArr(record, predicate) {
-  for (let i2 = 0; i2 < record.length; i2++) {
-    const value = record[i2];
-    if (predicate(value)) {
-      return value;
-    }
-  }
-  return void 0;
-}
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/custom-transformer-registry.js
-var CustomTransformerRegistry = class {
-  constructor() {
-    this.transfomers = {};
-  }
-  register(transformer) {
-    this.transfomers[transformer.name] = transformer;
-  }
-  findApplicable(v) {
-    return find(this.transfomers, (transformer) => transformer.isApplicable(v));
-  }
-  findByName(name) {
-    return this.transfomers[name];
-  }
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/is.js
-var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
-var isUndefined = (payload) => typeof payload === "undefined";
-var isNull = (payload) => payload === null;
-var isPlainObject = (payload) => {
-  if (typeof payload !== "object" || payload === null)
-    return false;
-  if (payload === Object.prototype)
-    return false;
-  if (Object.getPrototypeOf(payload) === null)
-    return true;
-  return Object.getPrototypeOf(payload) === Object.prototype;
-};
-var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
-var isArray = (payload) => Array.isArray(payload);
-var isString = (payload) => typeof payload === "string";
-var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
-var isBoolean = (payload) => typeof payload === "boolean";
-var isRegExp = (payload) => payload instanceof RegExp;
-var isMap = (payload) => payload instanceof Map;
-var isSet = (payload) => payload instanceof Set;
-var isSymbol = (payload) => getType(payload) === "Symbol";
-var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
-var isError = (payload) => payload instanceof Error;
-var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
-var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
-var isBigint = (payload) => typeof payload === "bigint";
-var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
-var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
-var isURL = (payload) => payload instanceof URL;
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/pathstringifier.js
-var escapeKey = (key) => key.replace(/\./g, "\\.");
-var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
-var parsePath = (string) => {
-  const result = [];
-  let segment = "";
-  for (let i2 = 0; i2 < string.length; i2++) {
-    let char = string.charAt(i2);
-    const isEscapedDot = char === "\\" && string.charAt(i2 + 1) === ".";
-    if (isEscapedDot) {
-      segment += ".";
-      i2++;
-      continue;
-    }
-    const isEndOfSegment = char === ".";
-    if (isEndOfSegment) {
-      result.push(segment);
-      segment = "";
-      continue;
-    }
-    segment += char;
-  }
-  const lastSegment = segment;
-  result.push(lastSegment);
-  return result;
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/transformer.js
-function simpleTransformation(isApplicable, annotation, transform, untransform) {
-  return {
-    isApplicable,
-    annotation,
-    transform,
-    untransform
-  };
-}
-var simpleRules = [
-  simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
-  simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
-    if (typeof BigInt !== "undefined") {
-      return BigInt(v);
-    }
-    console.error("Please add a BigInt polyfill.");
-    return v;
-  }),
-  simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
-  simpleTransformation(isError, "Error", (v, superJson) => {
-    const baseError = {
-      name: v.name,
-      message: v.message
-    };
-    superJson.allowedErrorProps.forEach((prop) => {
-      baseError[prop] = v[prop];
-    });
-    return baseError;
-  }, (v, superJson) => {
-    const e2 = new Error(v.message);
-    e2.name = v.name;
-    e2.stack = v.stack;
-    superJson.allowedErrorProps.forEach((prop) => {
-      e2[prop] = v[prop];
-    });
-    return e2;
-  }),
-  simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
-    const body = regex.slice(1, regex.lastIndexOf("/"));
-    const flags = regex.slice(regex.lastIndexOf("/") + 1);
-    return new RegExp(body, flags);
-  }),
-  simpleTransformation(
-    isSet,
-    "set",
-    // (sets only exist in es6+)
-    // eslint-disable-next-line es5/no-es6-methods
-    (v) => [...v.values()],
-    (v) => new Set(v)
-  ),
-  simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
-  simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
-    if (isNaNValue(v)) {
-      return "NaN";
-    }
-    if (v > 0) {
-      return "Infinity";
-    } else {
-      return "-Infinity";
-    }
-  }, Number),
-  simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
-    return "-0";
-  }, Number),
-  simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
-];
-function compositeTransformation(isApplicable, annotation, transform, untransform) {
-  return {
-    isApplicable,
-    annotation,
-    transform,
-    untransform
-  };
-}
-var symbolRule = compositeTransformation((s3, superJson) => {
-  if (isSymbol(s3)) {
-    const isRegistered = !!superJson.symbolRegistry.getIdentifier(s3);
-    return isRegistered;
-  }
-  return false;
-}, (s3, superJson) => {
-  const identifier = superJson.symbolRegistry.getIdentifier(s3);
-  return ["symbol", identifier];
-}, (v) => v.description, (_, a2, superJson) => {
-  const value = superJson.symbolRegistry.getValue(a2[1]);
-  if (!value) {
-    throw new Error("Trying to deserialize unknown symbol");
-  }
-  return value;
-});
-var constructorToName = [
-  Int8Array,
-  Uint8Array,
-  Int16Array,
-  Uint16Array,
-  Int32Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array,
-  Uint8ClampedArray
-].reduce((obj, ctor) => {
-  obj[ctor.name] = ctor;
-  return obj;
-}, {});
-var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a2) => {
-  const ctor = constructorToName[a2[1]];
-  if (!ctor) {
-    throw new Error("Trying to deserialize unknown typed array");
-  }
-  return new ctor(v);
-});
-function isInstanceOfRegisteredClass(potentialClass, superJson) {
-  if (potentialClass?.constructor) {
-    const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
-    return isRegistered;
-  }
-  return false;
-}
-var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
-  const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
-  return ["class", identifier];
-}, (clazz, superJson) => {
-  const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
-  if (!allowedProps) {
-    return { ...clazz };
-  }
-  const result = {};
-  allowedProps.forEach((prop) => {
-    result[prop] = clazz[prop];
-  });
-  return result;
-}, (v, a2, superJson) => {
-  const clazz = superJson.classRegistry.getValue(a2[1]);
-  if (!clazz) {
-    throw new Error(`Trying to deserialize unknown class '${a2[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
-  }
-  return Object.assign(Object.create(clazz.prototype), v);
-});
-var customRule = compositeTransformation((value, superJson) => {
-  return !!superJson.customTransformerRegistry.findApplicable(value);
-}, (value, superJson) => {
-  const transformer = superJson.customTransformerRegistry.findApplicable(value);
-  return ["custom", transformer.name];
-}, (value, superJson) => {
-  const transformer = superJson.customTransformerRegistry.findApplicable(value);
-  return transformer.serialize(value);
-}, (v, a2, superJson) => {
-  const transformer = superJson.customTransformerRegistry.findByName(a2[1]);
-  if (!transformer) {
-    throw new Error("Trying to deserialize unknown custom value");
-  }
-  return transformer.deserialize(v);
-});
-var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
-var transformValue = (value, superJson) => {
-  const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
-  if (applicableCompositeRule) {
-    return {
-      value: applicableCompositeRule.transform(value, superJson),
-      type: applicableCompositeRule.annotation(value, superJson)
-    };
-  }
-  const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
-  if (applicableSimpleRule) {
-    return {
-      value: applicableSimpleRule.transform(value, superJson),
-      type: applicableSimpleRule.annotation
-    };
-  }
-  return void 0;
-};
-var simpleRulesByAnnotation = {};
-simpleRules.forEach((rule) => {
-  simpleRulesByAnnotation[rule.annotation] = rule;
-});
-var untransformValue = (json, type, superJson) => {
-  if (isArray(type)) {
-    switch (type[0]) {
-      case "symbol":
-        return symbolRule.untransform(json, type, superJson);
-      case "class":
-        return classRule.untransform(json, type, superJson);
-      case "custom":
-        return customRule.untransform(json, type, superJson);
-      case "typed-array":
-        return typedArrayRule.untransform(json, type, superJson);
-      default:
-        throw new Error("Unknown transformation: " + type);
-    }
-  } else {
-    const transformation = simpleRulesByAnnotation[type];
-    if (!transformation) {
-      throw new Error("Unknown transformation: " + type);
-    }
-    return transformation.untransform(json, superJson);
-  }
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/accessDeep.js
-var getNthKey = (value, n2) => {
-  if (n2 > value.size)
-    throw new Error("index out of bounds");
-  const keys = value.keys();
-  while (n2 > 0) {
-    keys.next();
-    n2--;
-  }
-  return keys.next().value;
-};
-function validatePath(path) {
-  if (includes(path, "__proto__")) {
-    throw new Error("__proto__ is not allowed as a property");
-  }
-  if (includes(path, "prototype")) {
-    throw new Error("prototype is not allowed as a property");
-  }
-  if (includes(path, "constructor")) {
-    throw new Error("constructor is not allowed as a property");
-  }
-}
-var getDeep = (object, path) => {
-  validatePath(path);
-  for (let i2 = 0; i2 < path.length; i2++) {
-    const key = path[i2];
-    if (isSet(object)) {
-      object = getNthKey(object, +key);
-    } else if (isMap(object)) {
-      const row = +key;
-      const type = +path[++i2] === 0 ? "key" : "value";
-      const keyOfRow = getNthKey(object, row);
-      switch (type) {
-        case "key":
-          object = keyOfRow;
-          break;
-        case "value":
-          object = object.get(keyOfRow);
-          break;
-      }
-    } else {
-      object = object[key];
-    }
-  }
-  return object;
-};
-var setDeep = (object, path, mapper) => {
-  validatePath(path);
-  if (path.length === 0) {
-    return mapper(object);
-  }
-  let parent = object;
-  for (let i2 = 0; i2 < path.length - 1; i2++) {
-    const key = path[i2];
-    if (isArray(parent)) {
-      const index = +key;
-      parent = parent[index];
-    } else if (isPlainObject(parent)) {
-      parent = parent[key];
-    } else if (isSet(parent)) {
-      const row = +key;
-      parent = getNthKey(parent, row);
-    } else if (isMap(parent)) {
-      const isEnd = i2 === path.length - 2;
-      if (isEnd) {
-        break;
-      }
-      const row = +key;
-      const type = +path[++i2] === 0 ? "key" : "value";
-      const keyOfRow = getNthKey(parent, row);
-      switch (type) {
-        case "key":
-          parent = keyOfRow;
-          break;
-        case "value":
-          parent = parent.get(keyOfRow);
-          break;
-      }
-    }
-  }
-  const lastKey = path[path.length - 1];
-  if (isArray(parent)) {
-    parent[+lastKey] = mapper(parent[+lastKey]);
-  } else if (isPlainObject(parent)) {
-    parent[lastKey] = mapper(parent[lastKey]);
-  }
-  if (isSet(parent)) {
-    const oldValue = getNthKey(parent, +lastKey);
-    const newValue = mapper(oldValue);
-    if (oldValue !== newValue) {
-      parent.delete(oldValue);
-      parent.add(newValue);
-    }
-  }
-  if (isMap(parent)) {
-    const row = +path[path.length - 2];
-    const keyToRow = getNthKey(parent, row);
-    const type = +lastKey === 0 ? "key" : "value";
-    switch (type) {
-      case "key": {
-        const newKey = mapper(keyToRow);
-        parent.set(newKey, parent.get(keyToRow));
-        if (newKey !== keyToRow) {
-          parent.delete(keyToRow);
-        }
-        break;
-      }
-      case "value": {
-        parent.set(keyToRow, mapper(parent.get(keyToRow)));
-        break;
-      }
-    }
-  }
-  return object;
-};
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/plainer.js
-function traverse(tree, walker2, origin = []) {
-  if (!tree) {
-    return;
-  }
-  if (!isArray(tree)) {
-    forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
-    return;
-  }
-  const [nodeValue, children] = tree;
-  if (children) {
-    forEach(children, (child, key) => {
-      traverse(child, walker2, [...origin, ...parsePath(key)]);
-    });
-  }
-  walker2(nodeValue, origin);
-}
-function applyValueAnnotations(plain, annotations, superJson) {
-  traverse(annotations, (type, path) => {
-    plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
-  });
-  return plain;
-}
-function applyReferentialEqualityAnnotations(plain, annotations) {
-  function apply(identicalPaths, path) {
-    const object = getDeep(plain, parsePath(path));
-    identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
-      plain = setDeep(plain, identicalObjectPath, () => object);
-    });
-  }
-  if (isArray(annotations)) {
-    const [root, other] = annotations;
-    root.forEach((identicalPath) => {
-      plain = setDeep(plain, parsePath(identicalPath), () => plain);
-    });
-    if (other) {
-      forEach(other, apply);
-    }
-  } else {
-    forEach(annotations, apply);
-  }
-  return plain;
-}
-var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
-function addIdentity(object, path, identities) {
-  const existingSet = identities.get(object);
-  if (existingSet) {
-    existingSet.push(path);
-  } else {
-    identities.set(object, [path]);
-  }
-}
-function generateReferentialEqualityAnnotations(identitites, dedupe) {
-  const result = {};
-  let rootEqualityPaths = void 0;
-  identitites.forEach((paths) => {
-    if (paths.length <= 1) {
-      return;
-    }
-    if (!dedupe) {
-      paths = paths.map((path) => path.map(String)).sort((a2, b) => a2.length - b.length);
-    }
-    const [representativePath, ...identicalPaths] = paths;
-    if (representativePath.length === 0) {
-      rootEqualityPaths = identicalPaths.map(stringifyPath);
-    } else {
-      result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
-    }
-  });
-  if (rootEqualityPaths) {
-    if (isEmptyObject(result)) {
-      return [rootEqualityPaths];
-    } else {
-      return [rootEqualityPaths, result];
-    }
-  } else {
-    return isEmptyObject(result) ? void 0 : result;
-  }
-}
-var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
-  const primitive = isPrimitive(object);
-  if (!primitive) {
-    addIdentity(object, path, identities);
-    const seen = seenObjects.get(object);
-    if (seen) {
-      return dedupe ? {
-        transformedValue: null
-      } : seen;
-    }
-  }
-  if (!isDeep(object, superJson)) {
-    const transformed2 = transformValue(object, superJson);
-    const result2 = transformed2 ? {
-      transformedValue: transformed2.value,
-      annotations: [transformed2.type]
-    } : {
-      transformedValue: object
-    };
-    if (!primitive) {
-      seenObjects.set(object, result2);
-    }
-    return result2;
-  }
-  if (includes(objectsInThisPath, object)) {
-    return {
-      transformedValue: null
-    };
-  }
-  const transformationResult = transformValue(object, superJson);
-  const transformed = transformationResult?.value ?? object;
-  const transformedValue = isArray(transformed) ? [] : {};
-  const innerAnnotations = {};
-  forEach(transformed, (value, index) => {
-    if (index === "__proto__" || index === "constructor" || index === "prototype") {
-      throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
-    }
-    const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
-    transformedValue[index] = recursiveResult.transformedValue;
-    if (isArray(recursiveResult.annotations)) {
-      innerAnnotations[index] = recursiveResult.annotations;
-    } else if (isPlainObject(recursiveResult.annotations)) {
-      forEach(recursiveResult.annotations, (tree, key) => {
-        innerAnnotations[escapeKey(index) + "." + key] = tree;
-      });
-    }
-  });
-  const result = isEmptyObject(innerAnnotations) ? {
-    transformedValue,
-    annotations: !!transformationResult ? [transformationResult.type] : void 0
-  } : {
-    transformedValue,
-    annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
-  };
-  if (!primitive) {
-    seenObjects.set(object, result);
-  }
-  return result;
-};
-
-// ../../node_modules/.pnpm/is-what@4.1.16/node_modules/is-what/dist/index.js
-function getType2(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
-function isArray2(payload) {
-  return getType2(payload) === "Array";
-}
-function isPlainObject2(payload) {
-  if (getType2(payload) !== "Object")
-    return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
-
-// ../../node_modules/.pnpm/copy-anything@3.0.5/node_modules/copy-anything/dist/index.js
-function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
-  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
-  if (propType === "enumerable")
-    carry[key] = newVal;
-  if (includeNonenumerable && propType === "nonenumerable") {
-    Object.defineProperty(carry, key, {
-      value: newVal,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    });
-  }
-}
-function copy(target, options = {}) {
-  if (isArray2(target)) {
-    return target.map((item) => copy(item, options));
-  }
-  if (!isPlainObject2(target)) {
-    return target;
-  }
-  const props = Object.getOwnPropertyNames(target);
-  const symbols = Object.getOwnPropertySymbols(target);
-  return [...props, ...symbols].reduce((carry, key) => {
-    if (isArray2(options.props) && !options.props.includes(key)) {
-      return carry;
-    }
-    const val = target[key];
-    const newVal = copy(val, options);
-    assignProp(carry, key, newVal, target, options.nonenumerable);
-    return carry;
-  }, {});
-}
-
-// ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/index.js
-var SuperJSON = class {
-  /**
-   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
-   */
-  constructor({ dedupe = false } = {}) {
-    this.classRegistry = new ClassRegistry();
-    this.symbolRegistry = new Registry((s3) => s3.description ?? "");
-    this.customTransformerRegistry = new CustomTransformerRegistry();
-    this.allowedErrorProps = [];
-    this.dedupe = dedupe;
-  }
-  serialize(object) {
-    const identities = /* @__PURE__ */ new Map();
-    const output = walker(object, identities, this, this.dedupe);
-    const res = {
-      json: output.transformedValue
-    };
-    if (output.annotations) {
-      res.meta = {
-        ...res.meta,
-        values: output.annotations
-      };
-    }
-    const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
-    if (equalityAnnotations) {
-      res.meta = {
-        ...res.meta,
-        referentialEqualities: equalityAnnotations
-      };
-    }
-    return res;
-  }
-  deserialize(payload) {
-    const { json, meta } = payload;
-    let result = copy(json);
-    if (meta?.values) {
-      result = applyValueAnnotations(result, meta.values, this);
-    }
-    if (meta?.referentialEqualities) {
-      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
-    }
-    return result;
-  }
-  stringify(object) {
-    return JSON.stringify(this.serialize(object));
-  }
-  parse(string) {
-    return this.deserialize(JSON.parse(string));
-  }
-  registerClass(v, options) {
-    this.classRegistry.register(v, options);
-  }
-  registerSymbol(v, identifier) {
-    this.symbolRegistry.register(v, identifier);
-  }
-  registerCustom(transformer, name) {
-    this.customTransformerRegistry.register({
-      name,
-      ...transformer
-    });
-  }
-  allowErrorProps(...props) {
-    this.allowedErrorProps.push(...props);
-  }
-};
-SuperJSON.defaultInstance = new SuperJSON();
-SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
-SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
-SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
-SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
-SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
-SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
-SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
-SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
-var stringify = SuperJSON.stringify;
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
-function parseAnyDef() {
-  return {};
-}
-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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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, i2) => 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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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((x2) => !!x2);
-  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.4_zod@3.24.2/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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var emojiRegex = void 0;
-var zodPatterns = {
-  /**
-   * `c` was changed to `[cC]` to replicate /i flag
-   */
-  cuid: /^[cC][^\s-]{8,}$/,
-  cuid2: /^[0-9a-z]+$/,
-  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-  /**
-   * `a-z` was added to replicate /i flag
-   */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
-  /**
-   * Constructed a valid Unicode RegExp
-   *
-   * Lazily instantiate since this type of regex isn't supported
-   * in all envs (e.g. React Native).
-   *
-   * See:
-   * https://github.com/colinhacks/zod/issues/2433
-   * Fix in Zod:
-   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-   */
-  emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-    }
-    return emojiRegex;
-  },
-  /**
-   * Unused
-   */
-  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-  /**
-   * Unused
-   */
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
-  /**
-   * Unused
-   */
-  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-  nanoid: /^[a-zA-Z0-9_-]{21}$/,
-  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
-  };
-  if (def.checks) {
-    for (const check of def.checks) {
-      switch (check.kind) {
-        case "min":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          break;
-        case "max":
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "email":
-          switch (refs.emailStrategy) {
-            case "format:email":
-              addFormat(res, "email", check.message, refs);
-              break;
-            case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
-              break;
-            case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
-              break;
-          }
-          break;
-        case "url":
-          addFormat(res, "uri", check.message, refs);
-          break;
-        case "uuid":
-          addFormat(res, "uuid", check.message, refs);
-          break;
-        case "regex":
-          addPattern(res, check.regex, check.message, refs);
-          break;
-        case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
-          break;
-        case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
-          break;
-        case "startsWith":
-          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
-          break;
-        case "endsWith":
-          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "date":
-          addFormat(res, "date", check.message, refs);
-          break;
-        case "time":
-          addFormat(res, "time", check.message, refs);
-          break;
-        case "duration":
-          addFormat(res, "duration", check.message, refs);
-          break;
-        case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "includes": {
-          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
-          break;
-        case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
-          break;
-        case "cidr": {
-          if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "base64": {
-          switch (refs.base64Strategy) {
-            case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
-              break;
-            }
-            case "contentEncoding:base64": {
-              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
-              break;
-            }
-            case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
-              break;
-            }
-          }
-          break;
-        }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
-        }
-      }
-    }
-  }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
-}
-var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function escapeNonAlphaNumeric(source) {
-  let result = "";
-  for (let i2 = 0; i2 < source.length; i2++) {
-    if (!ALPHA_NUMERIC.has(source[i2])) {
-      result += "\\";
-    }
-    result += source[i2];
-  }
-  return result;
-}
-function addFormat(schema, value, message, refs) {
-  if (schema.format || schema.anyOf?.some((x2) => x2.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((x2) => x2.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 i2 = 0; i2 < source.length; i2++) {
-    if (isEscaped) {
-      pattern += source[i2];
-      isEscaped = false;
-      continue;
-    }
-    if (flags.i) {
-      if (inCharGroup) {
-        if (source[i2].match(/[a-z]/)) {
-          if (inCharRange) {
-            pattern += source[i2];
-            pattern += `${source[i2 - 2]}-${source[i2]}`.toUpperCase();
-            inCharRange = false;
-          } else if (source[i2 + 1] === "-" && source[i2 + 2]?.match(/[a-z]/)) {
-            pattern += source[i2];
-            inCharRange = true;
-          } else {
-            pattern += `${source[i2]}${source[i2].toUpperCase()}`;
-          }
-          continue;
-        }
-      } else if (source[i2].match(/[a-z]/)) {
-        pattern += `[${source[i2]}${source[i2].toUpperCase()}]`;
-        continue;
-      }
-    }
-    if (flags.m) {
-      if (source[i2] === "^") {
-        pattern += `(^|(?<=[\r
-]))`;
-        continue;
-      } else if (source[i2] === "$") {
-        pattern += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i2] === ".") {
-      pattern += inCharGroup ? `${source[i2]}\r
-` : `[${source[i2]}\r
-]`;
-      continue;
-    }
-    pattern += source[i2];
-    if (source[i2] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i2] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i2] === "[") {
-      inCharGroup = true;
-    }
-  }
-  return pattern;
-}
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
-function parseNeverDef() {
-  return {
-    not: {}
-  };
-}
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/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((x2) => x2._def.typeName in primitiveMappings && (!x2._def.checks || !x2._def.checks.length))) {
-    const types = options.reduce((types2, x2) => {
-      const type = primitiveMappings[x2._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x2) => x2._def.typeName === "ZodLiteral" && !x2.description)) {
-    const types = options.reduce((acc, x2) => {
-      const type = typeof x2._def.value;
-      switch (type) {
-        case "string":
-        case "number":
-        case "boolean":
-          return [...acc, type];
-        case "bigint":
-          return [...acc, "integer"];
-        case "object":
-          if (x2._def.value === null)
-            return [...acc, "null"];
-        case "symbol":
-        case "undefined":
-        case "function":
-        default:
-          return acc;
-      }
-    }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x2, i2, a2) => a2.indexOf(x2) === i2);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce((acc, x2) => {
-          return acc.includes(x2._def.value) ? acc : [...acc, x2._def.value];
-        }, [])
-      };
-    }
-  } else if (options.every((x2) => x2._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce((acc, x2) => [
-        ...acc,
-        ...x2._def.values.filter((x3) => !acc.includes(x3))
-      ], [])
-    };
-  }
-  return asAnyOf(def, refs);
-}
-var asAnyOf = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x2, i2) => parseDef(x2._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", `${i2}`]
-  })).filter((x2) => !!x2 && (!refs.strictUnions || typeof x2 === "object" && Object.keys(x2).length > 0));
-  return anyOf.length ? { anyOf } : void 0;
-};
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/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;
-}
-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.4_zod@3.24.2/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.4_zod@3.24.2/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 a2 = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a2 ? "1" : "0"]
-  });
-  return {
-    allOf: [a2, b].filter((x2) => x2 !== void 0)
-  };
-};
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/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.4_zod@3.24.2/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((x2, i2) => parseDef(x2._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i2}`]
-      })).reduce((acc, x2) => x2 === void 0 ? acc : [...acc, x2], []),
-      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((x2, i2) => parseDef(x2._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i2}`]
-      })).reduce((acc, x2) => x2 === void 0 ? acc : [...acc, x2], [])
-    };
-  }
-}
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
-function parseUndefinedDef() {
-  return {
-    not: {}
-  };
-}
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
-function parseUnknownDef() {
-  return {};
-}
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/selectParser.js
-var selectParser = (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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/parseDef.js
-function parseDef(def, refs, forceResolution = false) {
-  const seenItem = refs.seen.get(def);
-  if (refs.override) {
-    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const 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 i2 = 0;
-  for (; i2 < pathA.length && i2 < pathB.length; i2++) {
-    if (pathA[i2] !== pathB[i2])
-      break;
-  }
-  return [(pathA.length - i2).toString(), ...pathB.slice(i2)].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.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
-var zodToJsonSchema = (schema, options) => {
-  const refs = getRefs(options);
-  const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
-    ...acc,
-    [name2]: parseDef(schema2._def, {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name2]
-    }, true) ?? {}
-  }), {}) : void 0;
-  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
-    ...refs,
-    currentPath: [...refs.basePath, refs.definitionPath, name]
-  }, false) ?? {};
-  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title !== void 0) {
-    main.title = title;
-  }
-  const combined = 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;
-};
-
-// ../../node_modules/.pnpm/zod-to-json-schema@3.24.4_zod@3.24.2/node_modules/zod-to-json-schema/dist/esm/index.js
-var esm_default = zodToJsonSchema;
-function handleError(error2, defaultMessage) {
-  console.error(defaultMessage, error2);
-  const apiError = error2;
+function handleError(error, defaultMessage) {
+  const apiError = error;
   throw new HTTPException(apiError.status || 500, {
     message: apiError.message || defaultMessage
   });
@@ -2845,153 +854,71 @@ function errorHandler(err, c2) {
   console.error(err);
   return c2.json({ error: "Internal Server Error" }, 500);
 }
-function validateBody(body) {
-  const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
-    if (!value) {
-      acc[key] = `${key} is required`;
-    }
-    return acc;
-  }, {});
-  if (Object.keys(errorResponse).length > 0) {
-    throw new HTTPException(400, { message: JSON.stringify(errorResponse) });
-  }
-}
 
 // src/server/handlers/agents.ts
 async function getAgentsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agents = mastra.getAgents();
-    const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
-      const agent = _agent;
-      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc2, [key, tool]) => {
-        const _tool = tool;
-        acc2[key] = {
-          ..._tool,
-          inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
-          outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
-        };
-        return acc2;
-      }, {});
-      acc[_id] = {
-        name: agent.name,
-        instructions: agent.instructions,
-        tools: serializedAgentTools,
-        provider: agent.llm?.getProvider(),
-        modelId: agent.llm?.getModelId()
-      };
-      return acc;
-    }, {});
-    return c2.json(serializedAgents);
-  } catch (error2) {
-    return handleError(error2, "Error getting agents");
-  }
+  const serializedAgents = await getAgentsHandler$1({ mastra: c2.get("mastra") });
+  return c2.json(serializedAgents);
 }
 async function getAgentByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
-      const _tool = tool;
-      acc[key] = {
-        ..._tool,
-        inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
-        outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
-      };
-      return acc;
-    }, {});
-    return c2.json({
-      name: agent.name,
-      instructions: agent.instructions,
-      tools: serializedAgentTools,
-      provider: agent.llm?.getProvider(),
-      modelId: agent.llm?.getModelId()
-    });
-  } catch (error2) {
-    return handleError(error2, "Error getting agent");
-  }
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const result = await getAgentByIdHandler$1({
+    mastra,
+    agentId
+  });
+  return c2.json(result);
 }
 async function getEvalsByAgentIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    const evals = await mastra.storage?.getEvalsByAgentName?.(agent.name, "test") || [];
-    return c2.json({
-      id: agentId,
-      name: agent.name,
-      instructions: agent.instructions,
-      evals
-    });
-  } catch (error2) {
-    return handleError(error2, "Error getting test evals");
-  }
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const result = await getEvalsByAgentIdHandler$1({
+    mastra,
+    agentId
+  });
+  return c2.json(result);
 }
 async function getLiveEvalsByAgentIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    const evals = await mastra.storage?.getEvalsByAgentName?.(agent.name, "live") || [];
-    return c2.json({
-      id: agentId,
-      name: agent.name,
-      instructions: agent.instructions,
-      evals
-    });
-  } catch (error2) {
-    return handleError(error2, "Error getting live evals");
-  }
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const result = await getLiveEvalsByAgentIdHandler$1({
+    mastra,
+    agentId
+  });
+  return c2.json(result);
 }
 async function generateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    const { messages, threadId, resourceid, resourceId, output, runId, ...rest } = await c2.req.json();
-    validateBody({ messages });
+    const { resourceId, resourceid, ...body } = await c2.req.json();
     const finalResourceId = resourceId ?? resourceid;
-    const result = await agent.generate(messages, { threadId, resourceId: finalResourceId, output, runId, ...rest });
+    const result = await generateHandler$2({
+      mastra,
+      agentId,
+      resourceId: finalResourceId,
+      ...body
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error generating from agent");
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
   }
 }
 async function streamGenerateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    const { messages, threadId, resourceid, resourceId, output, runId, ...rest } = await c2.req.json();
-    validateBody({ messages });
+    const { resourceId, resourceid, ...body } = await c2.req.json();
     const finalResourceId = resourceId ?? resourceid;
-    const streamResult = await agent.stream(messages, {
-      threadId,
+    const streamResponse = await streamGenerateHandler$2({
+      mastra,
+      agentId,
       resourceId: finalResourceId,
-      output,
-      runId,
-      ...rest
-    });
-    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
-      sendUsage: true,
-      sendReasoning: true,
-      getErrorMessage: (error2) => {
-        return `An error occurred while processing your request. ${error2 instanceof Error ? error2.message : JSON.stringify(error2)}`;
-      }
+      ...body
     });
     return streamResponse;
-  } catch (error2) {
-    return handleError(error2, "Error streaming from agent");
+  } catch (error) {
+    return handleError(error, "Error streaming from agent");
   }
 }
 async function setAgentInstructionsHandler(c2) {
@@ -3017,15 +944,15 @@ async function setAgentInstructionsHandler(c2) {
       },
       200
     );
-  } catch (error2) {
-    return handleError(error2, "Error setting agent instructions");
+  } catch (error) {
+    return handleError(error, "Error setting agent instructions");
   }
 }
 
 // src/server/handlers/client.ts
 var clients = /* @__PURE__ */ new Set();
 function handleClientsRefresh(c2) {
-  const stream = new ReadableStream({
+  const stream2 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -3034,7 +961,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream, {
+  return new Response(stream2, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -3057,13 +984,13 @@ async function getLogsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const transportId = c2.req.query("transportId");
-    if (!transportId) {
-      throw new HTTPException(400, { message: "transportId is required" });
-    }
-    const logs = await mastra.getLogs(transportId);
+    const logs = await getLogsHandler$1({
+      mastra,
+      transportId
+    });
     return c2.json(logs);
-  } catch (error2) {
-    return handleError(error2, "Error getting logs");
+  } catch (error) {
+    return handleError(error, "Error getting logs");
   }
 }
 async function getLogsByRunIdHandler(c2) {
@@ -3071,282 +998,199 @@ async function getLogsByRunIdHandler(c2) {
     const mastra = c2.get("mastra");
     const runId = c2.req.param("runId");
     const transportId = c2.req.query("transportId");
-    if (!transportId) {
-      throw new HTTPException(400, { message: "transportId is required" });
-    }
-    const logs = await mastra.getLogsByRunId({ runId, transportId });
+    const logs = await getLogsByRunIdHandler$1({
+      mastra,
+      runId,
+      transportId
+    });
     return c2.json(logs);
-  } catch (error2) {
-    return handleError(error2, "Error getting logs by run ID");
+  } catch (error) {
+    return handleError(error, "Error getting logs by run ID");
   }
 }
 async function getLogTransports(c2) {
   try {
     const mastra = c2.get("mastra");
-    const logger2 = mastra.getLogger();
-    const transports = logger2.transports;
-    return c2.json({
-      transports: Object.keys(transports)
+    const result = await getLogTransports$1({
+      mastra
     });
-  } catch (e2) {
-    return handleError(e2, "Error getting log Transports ");
-  }
-}
-function getMemoryFromContext(c2) {
-  const mastra = c2.get("mastra");
-  const agentId = c2.req.query("agentId");
-  const agent = agentId ? mastra.getAgent(agentId) : null;
-  if (agentId && !agent) {
-    throw new HTTPException(404, { message: "Agent not found" });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting log Transports");
   }
-  const memory = agent?.getMemory?.() || mastra.memory;
-  return memory;
 }
 async function getMemoryStatusHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
-    if (!memory) {
-      return c2.json({ result: false });
-    }
-    return c2.json({ result: true });
-  } catch (error2) {
-    return handleError(error2, "Error getting memory status");
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const result = await getMemoryStatusHandler$1({
+      mastra,
+      agentId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting memory status");
   }
 }
 async function getThreadsHandler(c2) {
   try {
-    const { resourceid } = c2.req.query();
-    const memory = getMemoryFromContext(c2);
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    if (!resourceid) {
-      throw new HTTPException(400, { message: "Resource ID is required" });
-    }
-    const threads = await memory.getThreadsByResourceId({ resourceId: resourceid });
-    return c2.json(threads);
-  } catch (error2) {
-    return handleError(error2, "Error getting threads");
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const resourceId = c2.req.query("resourceid");
+    const result = await getThreadsHandler$1({
+      mastra,
+      agentId,
+      resourceId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting threads");
   }
 }
 async function getThreadByIdHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    const thread = await memory.getThreadById({ threadId });
-    if (!thread) {
-      throw new HTTPException(404, { message: "Thread not found" });
-    }
-    return c2.json(thread);
-  } catch (error2) {
-    return handleError(error2, "Error getting thread");
+    const result = await getThreadByIdHandler$1({
+      mastra,
+      agentId,
+      threadId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting thread");
   }
 }
 async function saveMessagesHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
-    const { messages } = await c2.req.json();
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    validateBody({ messages });
-    if (!Array.isArray(messages)) {
-      throw new HTTPException(400, { message: "Messages should be an array" });
-    }
-    const processedMessages = messages.map((message) => ({
-      ...message,
-      id: memory.generateId(),
-      createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
-    }));
-    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const body = await c2.req.json();
+    const result = await saveMessagesHandler$1({
+      mastra,
+      agentId,
+      body
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error saving messages");
+  } catch (error) {
+    return handleError(error, "Error saving messages");
   }
 }
 async function createThreadHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
-    const { title, metadata, resourceid, threadId } = await c2.req.json();
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    validateBody({ resourceid });
-    const result = await memory.createThread({ resourceId: resourceid, title, metadata, threadId });
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const body = await c2.req.json();
+    const result = await createThreadHandler$1({
+      mastra,
+      agentId,
+      body
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error saving thread to memory");
+  } catch (error) {
+    return handleError(error, "Error saving thread to memory");
   }
 }
 async function updateThreadHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    const { title, metadata, resourceid } = await c2.req.json();
-    const updatedAt = /* @__PURE__ */ new Date();
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    const thread = await memory.getThreadById({ threadId });
-    if (!thread) {
-      throw new HTTPException(404, { message: "Thread not found" });
-    }
-    const updatedThread = {
-      ...thread,
-      title: title || thread.title,
-      metadata: metadata || thread.metadata,
-      resourceId: resourceid || thread.resourceId,
-      createdAt: thread.createdAt,
-      updatedAt
-    };
-    const result = await memory.saveThread({ thread: updatedThread });
+    const body = await c2.req.json();
+    const result = await updateThreadHandler$1({
+      mastra,
+      agentId,
+      threadId,
+      body
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error updating thread");
+  } catch (error) {
+    return handleError(error, "Error updating thread");
   }
 }
 async function deleteThreadHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    if (!memory) {
-      throw new HTTPException(400, { message: "Memory is not initialized" });
-    }
-    const thread = await memory.getThreadById({ threadId });
-    if (!thread) {
-      throw new HTTPException(404, { message: "Thread not found" });
-    }
-    await memory.deleteThread(threadId);
-    return c2.json({ result: "Thread deleted" });
-  } catch (error2) {
-    return handleError(error2, "Error deleting thread");
+    const result = await deleteThreadHandler$1({
+      mastra,
+      agentId,
+      threadId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error deleting thread");
   }
 }
 async function getMessagesHandler(c2) {
   try {
-    const memory = getMemoryFromContext(c2);
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    if (!memory) {
-      return c2.json({ error: "Memory is not initialized" }, 400);
-    }
-    const thread = await memory.getThreadById({ threadId });
-    if (!thread) {
-      return c2.json({ error: "Thread not found" }, 404);
-    }
-    const result = await memory.query({ threadId });
+    const result = await getMessagesHandler$1({
+      mastra,
+      agentId,
+      threadId
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error getting messages");
+  } catch (error) {
+    return handleError(error, "Error getting messages");
   }
 }
 async function getNetworksHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const networks = mastra.getNetworks();
-    const serializedNetworks = networks.map((network) => {
-      const routingAgent = network.getRoutingAgent();
-      const agents = network.getAgents();
-      return {
-        id: network.formatAgentId(routingAgent.name),
-        name: routingAgent.name,
-        instructions: routingAgent.instructions,
-        agents: agents.map((agent) => ({
-          name: agent.name,
-          provider: agent.llm?.getProvider(),
-          modelId: agent.llm?.getModelId()
-        })),
-        routingModel: {
-          provider: routingAgent.llm?.getProvider(),
-          modelId: routingAgent.llm?.getModelId()
-        }
-      };
+    const networks = await getNetworksHandler$1({
+      mastra
     });
-    return c2.json(serializedNetworks);
-  } catch (error2) {
-    return handleError(error2, "Error getting networks");
+    return c2.json(networks);
+  } catch (error) {
+    return handleError(error, "Error getting networks");
   }
 }
 async function getNetworkByIdHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const networkId = c2.req.param("networkId");
-    const networks = mastra.getNetworks();
-    const network = networks.find((network2) => {
-      const routingAgent2 = network2.getRoutingAgent();
-      return network2.formatAgentId(routingAgent2.name) === networkId;
+    const network = await getNetworkByIdHandler$1({
+      mastra,
+      networkId
     });
-    if (!network) {
-      return c2.json({ error: "Network not found" }, 404);
-    }
-    const routingAgent = network.getRoutingAgent();
-    const agents = network.getAgents();
-    const serializedNetwork = {
-      id: network.formatAgentId(routingAgent.name),
-      name: routingAgent.name,
-      instructions: routingAgent.instructions,
-      agents: agents.map((agent) => ({
-        name: agent.name,
-        provider: agent.llm?.getProvider(),
-        modelId: agent.llm?.getModelId()
-      })),
-      routingModel: {
-        provider: routingAgent.llm?.getProvider(),
-        modelId: routingAgent.llm?.getModelId()
-      }
-    };
-    return c2.json(serializedNetwork);
-  } catch (error2) {
-    return handleError(error2, "Error getting network by ID");
+    return c2.json(network);
+  } catch (error) {
+    return handleError(error, "Error getting network by ID");
   }
 }
 async function generateHandler2(c2) {
   try {
     const mastra = c2.get("mastra");
     const networkId = c2.req.param("networkId");
-    const network = mastra.getNetwork(networkId);
-    if (!network) {
-      throw new HTTPException(404, { message: "Network not found" });
-    }
-    const { messages, threadId, resourceid, resourceId, output, runId, ...rest } = await c2.req.json();
-    validateBody({ messages });
-    const finalResourceId = resourceId ?? resourceid;
-    const result = await network.generate(messages, { threadId, resourceId: finalResourceId, output, runId, ...rest });
+    const body = await c2.req.json();
+    const result = await generateHandler$1({
+      mastra,
+      networkId,
+      body
+    });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error generating from network");
+  } catch (error) {
+    return handleError(error, "Error generating from network");
   }
 }
 async function streamGenerateHandler2(c2) {
   try {
     const mastra = c2.get("mastra");
     const networkId = c2.req.param("networkId");
-    const network = mastra.getNetwork(networkId);
-    if (!network) {
-      throw new HTTPException(404, { message: "Network not found" });
-    }
-    const { messages, threadId, resourceid, resourceId, output, runId, ...rest } = await c2.req.json();
-    validateBody({ messages });
-    const finalResourceId = resourceId ?? resourceid;
-    const streamResult = await network.stream(messages, {
-      threadId,
-      resourceId: finalResourceId,
-      output,
-      runId,
-      ...rest
-    });
-    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
-      sendUsage: true,
-      sendReasoning: true,
-      getErrorMessage: (error2) => {
-        return `An error occurred while processing your request. ${error2 instanceof Error ? error2.message : JSON.stringify(error2)}`;
-      }
+    const body = await c2.req.json();
+    const streamResponse = await streamGenerateHandler$1({
+      mastra,
+      networkId,
+      body
     });
     return streamResponse;
-  } catch (error2) {
-    return handleError(error2, "Error streaming from network");
+  } catch (error) {
+    return handleError(error, "Error streaming from network");
   }
 }
 async function generateSystemPromptHandler(c2) {
@@ -3382,8 +1226,8 @@ async function generateSystemPromptHandler(c2) {
 
         `
       ).join("");
-    } catch (error2) {
-      mastra.getLogger().error(`Error fetching evals`, { error: error2 });
+    } catch (error) {
+      mastra.getLogger().error(`Error fetching evals`, { error });
     }
     const ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS = `
             You are an expert system prompt engineer, specialized in analyzing and enhancing instructions to create clear, effective, and comprehensive system prompts. Your goal is to help users transform their basic instructions into well-structured system prompts that will guide AI behavior effectively.
@@ -3454,8 +1298,8 @@ ${evalSummary}` : ""}
       }
     );
     return c2.json(result?.object || {});
-  } catch (error2) {
-    return handleError(error2, "Error generating system prompt");
+  } catch (error) {
+    return handleError(error, "Error generating system prompt");
   }
 }
 
@@ -3466,189 +1310,68 @@ async function rootHandler(c2) {
 async function getTelemetryHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const telemetry = mastra.getTelemetry();
-    const storage = mastra.getStorage();
     const { name, scope, page, perPage } = c2.req.query();
     const attribute = c2.req.queries("attribute");
-    if (!telemetry) {
-      throw new HTTPException(400, { message: "Telemetry is not initialized" });
-    }
-    if (!storage) {
-      throw new HTTPException(400, { message: "Storage is not initialized" });
-    }
-    const attributes = attribute ? Object.fromEntries(
-      (Array.isArray(attribute) ? attribute : [attribute]).map((attr) => {
-        const [key, value] = attr.split(":");
-        return [key, value];
-      })
-    ) : void 0;
-    const traces = await storage.getTraces({
-      name,
-      scope,
-      page: Number(page ?? 0),
-      perPage: Number(perPage ?? 100),
-      attributes
+    const traces = await getTelemetryHandler$1({
+      mastra,
+      body: { name, scope, page: Number(page ?? 0), perPage: Number(perPage ?? 100), attribute }
     });
     return c2.json({ traces });
-  } catch (error2) {
-    return handleError(error2, "Error saving messages");
+  } catch (error) {
+    return handleError(error, "Error getting telemetry traces");
   }
 }
 async function storeTelemetryHandler(c2) {
   try {
     const body = await c2.req.json();
     const mastra = c2.get("mastra");
-    const storage = mastra.getStorage();
-    const now = /* @__PURE__ */ new Date();
-    const items = body?.resourceSpans?.[0]?.scopeSpans;
-    const allSpans = items.reduce((acc, scopedSpans) => {
-      const { scope, spans } = scopedSpans;
-      for (const span of spans) {
-        const {
-          spanId,
-          parentSpanId,
-          traceId,
-          name,
-          kind,
-          attributes,
-          status,
-          events,
-          links,
-          startTimeUnixNano,
-          endTimeUnixNano,
-          ...rest
-        } = span;
-        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
-        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
-        acc.push({
-          id: spanId,
-          parentSpanId,
-          traceId,
-          name,
-          scope: scope.name,
-          kind,
-          status: JSON.stringify(status),
-          events: JSON.stringify(events),
-          links: JSON.stringify(links),
-          attributes: JSON.stringify(
-            attributes.reduce((acc2, attr) => {
-              const valueKey = Object.keys(attr.value)[0];
-              if (valueKey) {
-                acc2[attr.key] = attr.value[valueKey];
-              }
-              return acc2;
-            }, {})
-          ),
-          startTime,
-          endTime,
-          other: JSON.stringify(rest),
-          createdAt: now
-        });
-      }
-      return acc;
-    }, []);
-    return storage.__batchInsert({
-      tableName: TABLE_TRACES,
-      records: allSpans
-    }).then(() => {
-      return c2.json(
-        {
-          status: "success",
-          message: "Traces received and processed successfully",
-          traceCount: body.resourceSpans?.length || 0
-        },
-        200
-      );
-    }).catch((e2) => {
-      return c2.json(
-        {
-          status: "error",
-          message: "Failed to process traces",
-          // @ts-ignore
-          error: error.message
-        },
-        500
-      );
-    });
-  } catch (error2) {
-    console.error("Error processing traces:", error2);
-    return c2.json(
-      {
-        status: "error",
-        message: "Failed to process traces",
-        // @ts-ignore
-        error: error2.message
-      },
-      500
-    );
+    const result = await storeTelemetryHandler$1({ mastra, body });
+    if (result.status === "error") {
+      return c2.json(result, 500);
+    }
+    return c2.json(result, 200);
+  } catch (error) {
+    return handleError(error, "Error storing telemetry traces");
   }
 }
 async function getToolsHandler(c2) {
   try {
     const tools = c2.get("tools");
-    if (!tools) {
-      return c2.json({});
-    }
-    const serializedTools = Object.entries(tools).reduce(
-      (acc, [id, _tool]) => {
-        const tool = _tool;
-        acc[id] = {
-          ...tool,
-          inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
-          outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
-        };
-        return acc;
-      },
-      {}
-    );
-    return c2.json(serializedTools);
-  } catch (error2) {
-    return handleError(error2, "Error getting tools");
+    const result = await getToolsHandler$1({
+      tools
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting tools");
   }
 }
 async function getToolByIdHandler(c2) {
   try {
     const tools = c2.get("tools");
     const toolId = c2.req.param("toolId");
-    const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
-    if (!tool) {
-      throw new HTTPException(404, { message: "Tool not found" });
-    }
-    const serializedTool = {
-      ...tool,
-      inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
-      outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
-    };
-    return c2.json(serializedTool);
-  } catch (error2) {
-    return handleError(error2, "Error getting tool");
+    const result = await getToolByIdHandler$1({
+      tools,
+      toolId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting tool");
   }
 }
 function executeToolHandler(tools) {
   return async (c2) => {
     try {
+      const mastra = c2.get("mastra");
       const toolId = decodeURIComponent(c2.req.param("toolId"));
-      const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
-      if (!tool) {
-        return c2.json({ error: "Tool not found" }, 404);
-      }
-      if (!tool?.execute) {
-        return c2.json({ error: "Tool is not executable" }, 400);
-      }
       const { data } = await c2.req.json();
-      const mastra = c2.get("mastra");
-      if (isVercelTool(tool)) {
-        const result2 = await tool.execute(data);
-        return c2.json(result2);
-      }
-      const result = await tool.execute({
-        context: data,
+      const result = await executeToolHandler$1(tools)({
         mastra,
-        runId: mastra.runId
+        toolId,
+        data
       });
       return c2.json(result);
-    } catch (error2) {
-      return handleError(error2, "Error executing tool");
+    } catch (error) {
+      return handleError(error, "Error executing tool");
     }
   };
 }
@@ -3657,175 +1380,150 @@ async function executeAgentToolHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
     const toolId = c2.req.param("toolId");
-    const agent = mastra.getAgent(agentId);
-    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
-    if (!tool) {
-      throw new HTTPException(404, { message: "Tool not found" });
-    }
-    if (!tool?.execute) {
-      return c2.json({ error: "Tool is not executable" }, 400);
-    }
     const { data } = await c2.req.json();
-    if (isVercelTool(tool)) {
-      const result2 = await tool.execute(data);
-      return c2.json(result2);
-    }
-    const result = await tool.execute({
-      context: data,
+    const result = await executeAgentToolHandler$1({
       mastra,
-      runId: agentId
+      agentId,
+      toolId,
+      data
     });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error executing tool");
+  } catch (error) {
+    return handleError(error, "Error executing tool");
   }
 }
-var getVector = (c2, vectorName) => {
-  const vector = c2.get("mastra").getVector(vectorName);
-  if (!vector) {
-    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
-  }
-  return vector;
-};
 async function upsertVectors(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
-    const { indexName, vectors, metadata, ids } = await c2.req.json();
-    if (!indexName || !vectors || !Array.isArray(vectors)) {
-      throw new HTTPException(400, { message: "Invalid request body. indexName and vectors array are required." });
-    }
-    const vector = getVector(c2, vectorName);
-    const result = await vector.upsert({ indexName, vectors, metadata, ids });
+    const body = await c2.req.json();
+    const result = await upsertVectors$1({
+      mastra,
+      vectorName,
+      index: body
+    });
     return c2.json({ ids: result });
-  } catch (error2) {
-    return handleError(error2, "Error upserting vectors");
+  } catch (error) {
+    return handleError(error, "Error upserting vectors");
   }
 }
 async function createIndex(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
-    const { indexName, dimension, metric } = await c2.req.json();
-    if (!indexName || typeof dimension !== "number" || dimension <= 0) {
-      throw new HTTPException(400, {
-        message: "Invalid request body. indexName and positive dimension number are required."
-      });
-    }
-    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
-      throw new HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
-    }
-    const vector = getVector(c2, vectorName);
-    await vector.createIndex({ indexName, dimension, metric });
+    const body = await c2.req.json();
+    await createIndex$1({
+      mastra,
+      vectorName,
+      index: body
+    });
     return c2.json({ success: true });
-  } catch (error2) {
-    return handleError(error2, "Error creating index");
+  } catch (error) {
+    return handleError(error, "Error creating index");
   }
 }
 async function queryVectors(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
     const { indexName, queryVector, topK = 10, filter, includeVector = false } = await c2.req.json();
-    if (!indexName || !queryVector || !Array.isArray(queryVector)) {
-      throw new HTTPException(400, { message: "Invalid request body. indexName and queryVector array are required." });
-    }
-    const vector = getVector(c2, vectorName);
-    const results = await vector.query({ indexName, queryVector, topK, filter, includeVector });
+    const results = await queryVectors$1({
+      mastra,
+      vectorName,
+      query: { indexName, queryVector, topK, filter, includeVector }
+    });
     return c2.json({ results });
-  } catch (error2) {
-    return handleError(error2, "Error querying vectors");
+  } catch (error) {
+    return handleError(error, "Error querying vectors");
   }
 }
 async function listIndexes(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
-    const vector = getVector(c2, vectorName);
-    const indexes = await vector.listIndexes();
-    return c2.json({ indexes: indexes.filter(Boolean) });
-  } catch (error2) {
-    return handleError(error2, "Error listing indexes");
+    const indexes = await listIndexes$1({
+      mastra,
+      vectorName
+    });
+    return c2.json({ indexes });
+  } catch (error) {
+    return handleError(error, "Error listing indexes");
   }
 }
 async function describeIndex(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
     const indexName = c2.req.param("indexName");
     if (!indexName) {
       throw new HTTPException(400, { message: "Index name is required" });
     }
-    const vector = getVector(c2, vectorName);
-    const stats = await vector.describeIndex(indexName);
+    const stats = await describeIndex$1({
+      mastra,
+      vectorName,
+      indexName
+    });
     return c2.json({
       dimension: stats.dimension,
       count: stats.count,
       metric: stats.metric?.toLowerCase()
     });
-  } catch (error2) {
-    return handleError(error2, "Error describing index");
+  } catch (error) {
+    return handleError(error, "Error describing index");
   }
 }
 async function deleteIndex(c2) {
   try {
+    const mastra = c2.get("mastra");
     const vectorName = c2.req.param("vectorName");
     const indexName = c2.req.param("indexName");
     if (!indexName) {
       throw new HTTPException(400, { message: "Index name is required" });
     }
-    const vector = getVector(c2, vectorName);
-    await vector.deleteIndex(indexName);
+    await deleteIndex$1({
+      mastra,
+      vectorName,
+      indexName
+    });
     return c2.json({ success: true });
-  } catch (error2) {
-    return handleError(error2, "Error deleting index");
+  } catch (error) {
+    return handleError(error, "Error deleting index");
   }
 }
 async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    if (!agent.voice) {
-      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
-    }
-    const speakers = await agent.getSpeakers();
+    const speakers = await getSpeakersHandler$1({
+      mastra,
+      agentId
+    });
     return c2.json(speakers);
-  } catch (error2) {
-    return handleError(error2, "Error getting speakers");
+  } catch (error) {
+    return handleError(error, "Error getting speakers");
   }
 }
 async function speakHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    if (!agent.voice) {
-      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
-    }
     const { input, options } = await c2.req.json();
-    await validateBody({ input });
-    const audioStream = await agent.voice.speak(input, options);
+    const audioStream = await generateSpeechHandler({
+      mastra,
+      agentId,
+      body: { text: input, speakerId: options?.speakerId }
+    });
     c2.header("Content-Type", `audio/${options?.filetype ?? "mp3"}`);
     c2.header("Transfer-Encoding", "chunked");
     return c2.body(audioStream);
-  } catch (error2) {
-    return handleError(error2, "Error generating speech");
+  } catch (error) {
+    return handleError(error, "Error generating speech");
   }
 }
 async function listenHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const agent = mastra.getAgent(agentId);
-    const logger2 = mastra.getLogger();
-    if (!agent) {
-      throw new HTTPException(404, { message: "Agent not found" });
-    }
-    if (!agent.voice) {
-      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
-    }
     const formData = await c2.req.formData();
     const audioFile = formData.get("audio");
     const options = formData.get("options");
@@ -3833,115 +1531,76 @@ async function listenHandler(c2) {
       throw new HTTPException(400, { message: "Audio file is required" });
     }
     const audioData = await audioFile.arrayBuffer();
-    const audioStream = new Readable();
-    audioStream.push(Buffer.from(audioData));
-    audioStream.push(null);
-    let parsedOptions;
+    let parsedOptions = {};
     try {
       parsedOptions = options ? JSON.parse(options) : {};
-    } catch (error2) {
-      if (error2 instanceof SyntaxError) {
-        logger2.error("Invalid JSON in options:", error2);
-      }
-      parsedOptions = {};
+    } catch {
     }
-    const transcription = await agent.voice.listen(audioStream, parsedOptions);
+    const transcription = await transcribeSpeechHandler({
+      mastra,
+      agentId,
+      body: {
+        audioData: Buffer.from(audioData),
+        options: parsedOptions
+      }
+    });
     return c2.json({ text: transcription });
-  } catch (error2) {
-    return handleError(error2, "Error transcribing speech");
+  } catch (error) {
+    return handleError(error, "Error transcribing speech");
   }
 }
 async function getWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflows = mastra.getWorkflows({ serialized: false });
-    const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
-      acc[key] = {
-        stepGraph: workflow.stepGraph,
-        stepSubscriberGraph: workflow.stepSubscriberGraph,
-        serializedStepGraph: workflow.serializedStepGraph,
-        serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
-        name: workflow.name,
-        triggerSchema: workflow.triggerSchema ? stringify(esm_default(workflow.triggerSchema)) : void 0,
-        steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
-          const _step = step;
-          acc2[key2] = {
-            ..._step,
-            inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
-            outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
-          };
-          return acc2;
-        }, {})
-      };
-      return acc;
-    }, {});
-    return c2.json(_workflows);
-  } catch (error2) {
-    return handleError(error2, "Error getting workflows");
+    const workflows = await getWorkflowsHandler$1({
+      mastra
+    });
+    return c2.json(workflows);
+  } catch (error) {
+    return handleError(error, "Error getting workflows");
   }
 }
 async function getWorkflowByIdHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
-    const triggerSchema = workflow?.triggerSchema;
-    const stepGraph = workflow.stepGraph;
-    const stepSubscriberGraph = workflow.stepSubscriberGraph;
-    const serializedStepGraph = workflow.serializedStepGraph;
-    const serializedStepSubscriberGraph = workflow.serializedStepSubscriberGraph;
-    const serializedSteps = Object.entries(workflow.steps).reduce((acc, [key, step]) => {
-      const _step = step;
-      acc[key] = {
-        ..._step,
-        inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
-        outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
-      };
-      return acc;
-    }, {});
-    return c2.json({
-      name: workflow.name,
-      triggerSchema: triggerSchema ? stringify(esm_default(triggerSchema)) : void 0,
-      steps: serializedSteps,
-      stepGraph,
-      stepSubscriberGraph,
-      serializedStepGraph,
-      serializedStepSubscriberGraph
+    const workflow = await getWorkflowByIdHandler$1({
+      mastra,
+      workflowId
     });
-  } catch (error2) {
-    return handleError(error2, "Error getting workflow");
+    return c2.json(workflow);
+  } catch (error) {
+    return handleError(error, "Error getting workflow");
   }
 }
 async function startAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
-    const body = await c2.req.json();
+    const triggerData = await c2.req.json();
     const runId = c2.req.query("runId");
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to start run" });
-    }
-    const run = workflow.getRun(runId);
-    if (!run) {
-      throw new HTTPException(404, { message: "Workflow run not found" });
-    }
-    const result = await run.start({
-      triggerData: body
+    const result = await startAsyncWorkflowHandler$1({
+      mastra,
+      workflowId,
+      runId,
+      triggerData
     });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error executing workflow");
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
   }
 }
 async function createRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
     const prevRunId = c2.req.query("runId");
-    const { runId } = workflow.createRun({ runId: prevRunId });
-    return c2.json({ runId });
+    const result = await createRunHandler$1({
+      mastra,
+      workflowId,
+      runId: prevRunId
+    });
+    return c2.json(result);
   } catch (e2) {
     return handleError(e2, "Error creating run");
   }
@@ -3950,105 +1609,95 @@ async function startWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
-    const body = await c2.req.json();
+    const triggerData = await c2.req.json();
     const runId = c2.req.query("runId");
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to start run" });
-    }
-    const run = workflow.getRun(runId);
-    if (!run) {
-      throw new HTTPException(404, { message: "Workflow run not found" });
-    }
-    run.start({
-      triggerData: body
+    await startWorkflowRunHandler$1({
+      mastra,
+      workflowId,
+      runId,
+      triggerData
     });
     return c2.json({ message: "Workflow run started" });
   } catch (e2) {
     return handleError(e2, "Error starting workflow run");
   }
 }
-async function watchWorkflowHandler(c2) {
+function watchWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const logger2 = mastra.getLogger();
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
     const runId = c2.req.query("runId");
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to watch workflow" });
     }
-    const run = workflow.getRun(runId);
-    if (!run) {
-      throw new HTTPException(404, { message: "Workflow run not found" });
-    }
-    return streamText(
+    return stream(
       c2,
-      async (stream) => {
-        return new Promise((_resolve, _reject) => {
-          let unwatch = run.watch(({ activePaths, runId: runId2, timestamp, results }) => {
-            const activePathsObj = Object.fromEntries(activePaths);
-            void stream.write(JSON.stringify({ activePaths: activePathsObj, runId: runId2, timestamp, results }) + "");
+      async (stream2) => {
+        try {
+          const result = await watchWorkflowHandler$1({
+            mastra,
+            workflowId,
+            runId
           });
-          stream.onAbort(() => {
-            unwatch?.();
+          stream2.onAbort(() => {
+            if (!result.locked) {
+              return result.cancel();
+            }
           });
-        });
+          for await (const chunk of result) {
+            await stream2.write(chunk.toString() + "");
+          }
+        } catch (err) {
+          console.log(err);
+        }
       },
-      async (err, stream) => {
+      async (err) => {
         logger2.error("Error in watch stream: " + err?.message);
-        stream.abort();
-        await stream.close();
       }
     );
-  } catch (error2) {
-    return handleError(error2, "Error watching workflow");
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
   }
 }
 async function resumeAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
     const runId = c2.req.query("runId");
     const { stepId, context } = await c2.req.json();
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const run = workflow.getRun(runId);
-    if (!run) {
-      throw new HTTPException(404, { message: "Workflow run not found" });
-    }
-    const result = await run.resume({
-      stepId,
-      context
+    const result = await resumeAsyncWorkflowHandler$1({
+      mastra,
+      workflowId,
+      runId,
+      body: { stepId, context }
     });
     return c2.json(result);
-  } catch (error2) {
-    return handleError(error2, "Error resuming workflow step");
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
   }
 }
 async function resumeWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = mastra.getWorkflow(workflowId);
     const runId = c2.req.query("runId");
     const { stepId, context } = await c2.req.json();
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const run = workflow.getRun(runId);
-    if (!run) {
-      throw new HTTPException(404, { message: "Workflow run not found" });
-    }
-    run.resume({
-      stepId,
-      context
+    await resumeWorkflowHandler$1({
+      mastra,
+      workflowId,
+      runId,
+      body: { stepId, context }
     });
     return c2.json({ message: "Workflow run resumed" });
-  } catch (error2) {
-    return handleError(error2, "Error resuming workflow");
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
   }
 }
 
@@ -4199,7 +1848,23 @@ async function createHonoServer(mastra, options = {}) {
     c2.set("mastra", mastra);
     c2.set("tools", tools);
     c2.set("playground", options.playground === true);
-    await next();
+    const requestId = c2.req.header("x-request-id") ?? randomUUID();
+    const span = Telemetry.getActiveSpan();
+    if (span) {
+      span.setAttribute("http.request_id", requestId);
+      span.updateName(`${c2.req.method} ${c2.req.path}`);
+      const newCtx = Telemetry.setBaggage({
+        "http.request_id": requestId
+      });
+      await new Promise((resolve) => {
+        Telemetry.withContext(newCtx, async () => {
+          await next();
+          resolve(true);
+        });
+      });
+    } else {
+      await next();
+    }
   });
   const bodyLimitOptions = {
     maxSize: 4.5 * 1024 * 1024,