@mastra/deployer 0.15.3 → 0.16.0-alpha.1

package/dist/server/index.cjs

@@ -21,8 +21,9 @@ var timeout = require('hono/timeout');
 var httpException = require('hono/http-exception');
 var a2a = require('@mastra/server/handlers/a2a');
 var streaming = require('hono/streaming');
-var agents = require('@mastra/server/handlers/agents');
 var bodyLimit = require('hono/body-limit');
+var agentBuilder = require('@mastra/server/handlers/agent-builder');
+var agents = require('@mastra/server/handlers/agents');
 var agent = require('@mastra/core/agent');
 var zod = require('zod');
 var tools$1 = require('@mastra/server/handlers/tools');
@@ -287,13 +288,13 @@ var Response2 = class _Response {
 });
 Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-function writeFromReadableStream(stream6, writable) {
-  if (stream6.locked) {
+function writeFromReadableStream(stream7, writable) {
+  if (stream7.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
     return;
   }
-  const reader = stream6.getReader();
+  const reader = stream7.getReader();
   const handleError2 = () => {
   };
   writable.on("error", handleError2);
@@ -560,18 +561,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream6) => {
+var createStreamBody = (stream7) => {
   const body = new ReadableStream({
     start(controller) {
-      stream6.on("data", (chunk) => {
+      stream7.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream6.on("end", () => {
+      stream7.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream6.destroy();
+      stream7.destroy();
     }
   });
   return body;
@@ -660,10 +661,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream6 = fs.createReadStream(path$1, { start, end });
+    const stream7 = fs.createReadStream(path$1, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream6), 206);
+    return c2.body(createStreamBody(stream7), 206);
   };
 };
 var RENDER_TYPE = {
@@ -802,21 +803,21 @@ function c(e2, t2, n2) {
   return e2 && t2 in e2 ? e2[t2] ?? n2 : n2;
 }
 function i(...e2) {
-  return e2.reduce((e3, t2) => {
+  return e2.reduce(((e3, t2) => {
     if (!t2) return e3;
     let n2;
     return ("tags" in e3 && e3.tags || "tags" in t2 && t2.tags) && (n2 = Array.from(/* @__PURE__ */ new Set([...c(e3, "tags", []), ...c(t2, "tags", [])]))), { ...e3, ...t2, tags: n2, responses: { ...c(e3, "responses", {}), ...c(t2, "responses", {}) }, parameters: m(e3.parameters, t2.parameters) };
-  }, {});
+  }), {});
 }
 function p({ path: e2, method: t2, data: n2, schema: s3 }) {
-  e2 = ((e3) => e3.split("/").map((e4) => {
+  e2 = ((e3) => e3.split("/").map(((e4) => {
     let t3 = e4;
     if (t3.startsWith(":")) {
       const e5 = t3.match(/^:([^{?]+)(?:{(.+)})?(\?)?$/);
       e5 ? t3 = `{${e5[1]}}` : (t3 = t3.slice(1, t3.length), t3.endsWith("?") && (t3 = t3.slice(0, -1)), t3 = `{${t3}}`);
     }
     return t3;
-  }).join("/"))(e2);
+  })).join("/"))(e2);
   const o2 = t2.toLowerCase();
   if ("all" === o2) {
     if (!n2) return;
@@ -825,30 +826,30 @@ function p({ path: e2, method: t2, data: n2, schema: s3 }) {
       r.set(e2, { ...t3, ...n2, parameters: m(t3.parameters, n2.parameters) });
     } else r.set(e2, n2);
   } else {
-    const t3 = function(e3) {
+    const t3 = (function(e3) {
       const t4 = Array.from(r.keys());
       let n3 = {};
       for (const s4 of t4) e3.match(s4) && (n3 = i(n3, r.get(s4) ?? {}));
       return n3;
-    }(e2);
+    })(e2);
     s3[e2] = { ...s3[e2] ? s3[e2] : {}, [o2]: { responses: {}, operationId: a(o2, e2), ...i(t3, s3[e2]?.[o2], n2) } };
   }
 }
 var f = (e2) => "$ref" in e2 ? e2.$ref : `${e2.in} ${e2.name}`;
 function m(...e2) {
-  const t2 = e2.flatMap((e3) => e3 ?? []).reduce((e3, t3) => (e3.set(f(t3), t3), e3), /* @__PURE__ */ new Map());
+  const t2 = e2.flatMap(((e3) => e3 ?? [])).reduce(((e3, t3) => (e3.set(f(t3), t3), e3)), /* @__PURE__ */ new Map());
   return Array.from(t2.values());
 }
 function l(e2, { excludeStaticFile: t2 = true, exclude: n2 = [] }) {
   const s3 = {}, o2 = Array.isArray(n2) ? n2 : [n2];
-  for (const [n3, a2] of Object.entries(e2)) if (!o2.some((e3) => "string" == typeof e3 ? n3 === e3 : e3.test(n3)) && (!n3.includes("*") || n3.includes("{")) && (!t2 || (!n3.includes(".") || n3.includes("{")))) {
+  for (const [n3, a2] of Object.entries(e2)) if (!o2.some(((e3) => "string" == typeof e3 ? n3 === e3 : e3.test(n3))) && (!n3.includes("*") || n3.includes("{")) && (!t2 || (!n3.includes(".") || n3.includes("{")))) {
     for (const e3 of Object.keys(a2)) {
       const t3 = a2[e3];
       if (n3.includes("{")) {
         t3.parameters || (t3.parameters = []);
-        const e4 = n3.split("/").filter((e5) => e5.startsWith("{") && !t3.parameters.find((t4) => "path" === t4.in && t4.name === e5.slice(1, e5.length - 1)));
+        const e4 = n3.split("/").filter(((e5) => e5.startsWith("{") && !t3.parameters.find(((t4) => "path" === t4.in && t4.name === e5.slice(1, e5.length - 1)))));
         for (const n4 of e4) {
-          const e5 = n4.slice(1, n4.length - 1), s4 = t3.parameters.findIndex((t4) => "param" === t4.in && t4.name === e5);
+          const e5 = n4.slice(1, n4.length - 1), s4 = t3.parameters.findIndex(((t4) => "param" === t4.in && t4.name === e5));
           -1 !== s4 ? t3.parameters[s4].in = "path" : t3.parameters.push({ schema: { type: "string" }, in: "path", name: e5, required: true });
         }
       }
@@ -866,7 +867,7 @@ function h(e2, t2) {
   return async (o2) => (s3 || (s3 = await y(e2, t2, n2, o2)), o2.json(s3));
 }
 async function y(t2, s3 = u, o2 = d, a2) {
-  const r2 = { ...u, ...s3 }, c2 = { ...d, ...o2 }, i2 = r2.documentation ?? {}, f2 = await async function(t3, s4, o3) {
+  const r2 = { ...u, ...s3 }, c2 = { ...d, ...o2 }, i2 = r2.documentation ?? {}, f2 = await (async function(t3, s4, o3) {
     const a3 = {};
     for (const r3 of t3.routes) {
       if (!(e in r3.handler)) {
@@ -879,7 +880,7 @@ async function y(t2, s3 = u, o2 = d, a2) {
       o3.components = { ...o3.components, ...m2 ?? {} }, p({ method: r3.method, path: r3.path, data: f3, schema: a3 });
     }
     return a3;
-  }(t2, r2, c2);
+  })(t2, r2, c2);
   for (const e2 in f2) for (const t3 in f2[e2]) {
     const n2 = f2[e2][t3]?.hide;
     if (n2) {
@@ -887,11 +888,11 @@ async function y(t2, s3 = u, o2 = d, a2) {
       "boolean" == typeof n2 ? s4 = n2 : "function" == typeof n2 && (a2 ? s4 = n2(a2) : console.warn(`'c' is not defined, cannot evaluate hide function for ${t3} ${e2}`)), s4 && delete f2[e2][t3];
     }
   }
-  return { openapi: c2.version, ...{ ...i2, tags: i2.tags?.filter((e2) => !r2.excludeTags?.includes(e2?.name)), info: { title: "Hono Documentation", description: "Development documentation", version: "0.0.0", ...i2.info }, paths: { ...l(f2, r2), ...i2.paths }, components: { ...i2.components, schemas: { ...c2.components, ...i2.components?.schemas } } } };
+  return { openapi: c2.version, ...{ ...i2, tags: i2.tags?.filter(((e2) => !r2.excludeTags?.includes(e2?.name))), info: { title: "Hono Documentation", description: "Development documentation", version: "0.0.0", ...i2.info }, paths: { ...l(f2, r2), ...i2.paths }, components: { ...i2.components, schemas: { ...c2.components, ...i2.components?.schemas } } } };
 }
 function w(n2) {
   const { validateResponse: s3, ...o2 } = n2;
-  return Object.assign(async (e2, o3) => {
+  return Object.assign((async (e2, o3) => {
     if (await o3(), s3 && n2.responses) {
       const o4 = e2.res.status, a2 = e2.res.headers.get("content-type");
       if (o4 && a2) {
@@ -910,7 +911,7 @@ function w(n2) {
         }
       }
     }
-  }, { [e]: { resolver: (e2, t2) => x(e2, o2, t2) } });
+  }), { [e]: { resolver: (e2, t2) => x(e2, o2, t2) } });
 }
 async function x(e2, t2, n2 = {}) {
   let s3 = {};
@@ -961,15 +962,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "message/stream") {
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream6.write(JSON.stringify(chunk) + "");
+            await stream7.write(JSON.stringify(chunk) + "");
           }
         } catch (err) {
           logger2.error("Error in message/stream stream: " + err?.message);
@@ -999,250 +1000,1128 @@ var defaultAuthConfig = {
             return user.role === "admin";
           }
         }
-        return false;
+        return false;
+      },
+      allow: true
+    }
+  ]
+};
+
+// src/server/handlers/auth/helpers.ts
+var isDevPlaygroundRequest = (req) => {
+  return req.header("x-mastra-dev-playground") === "true" && process.env.MASTRA_DEV === "true";
+};
+var isProtectedPath = (path, method, authConfig) => {
+  const protectedAccess = [...defaultAuthConfig.protected || [], ...authConfig.protected || []];
+  return isAnyMatch(path, method, protectedAccess);
+};
+var canAccessPublicly = (path, method, authConfig) => {
+  const publicAccess = [...defaultAuthConfig.public || [], ...authConfig.public || []];
+  return isAnyMatch(path, method, publicAccess);
+};
+var isAnyMatch = (path, method, patterns) => {
+  if (!patterns) {
+    return false;
+  }
+  for (const patternPathOrMethod of patterns) {
+    if (patternPathOrMethod instanceof RegExp) {
+      if (patternPathOrMethod.test(path)) {
+        return true;
+      }
+    }
+    if (typeof patternPathOrMethod === "string" && pathMatchesPattern(path, patternPathOrMethod)) {
+      return true;
+    }
+    if (Array.isArray(patternPathOrMethod) && patternPathOrMethod.length === 2) {
+      const [pattern, methodOrMethods] = patternPathOrMethod;
+      if (pathMatchesPattern(path, pattern) && matchesOrIncludes(methodOrMethods, method)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var pathMatchesPattern = (path, pattern) => {
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1);
+    return path.startsWith(prefix);
+  }
+  return path === pattern;
+};
+var pathMatchesRule = (path, rulePath) => {
+  if (!rulePath) return true;
+  if (typeof rulePath === "string") {
+    return pathMatchesPattern(path, rulePath);
+  }
+  if (rulePath instanceof RegExp) {
+    console.log("rulePath", rulePath, path, rulePath.test(path));
+    return rulePath.test(path);
+  }
+  if (Array.isArray(rulePath)) {
+    return rulePath.some((p2) => pathMatchesPattern(path, p2));
+  }
+  return false;
+};
+var matchesOrIncludes = (values, value) => {
+  if (typeof values === "string") {
+    return values === value;
+  }
+  if (Array.isArray(values)) {
+    return values.includes(value);
+  }
+  return false;
+};
+var checkRules = async (rules, path, method, user) => {
+  for (const i2 in rules || []) {
+    const rule = rules?.[i2];
+    if (!pathMatchesRule(path, rule.path)) {
+      continue;
+    }
+    if (rule.methods && !matchesOrIncludes(rule.methods, method)) {
+      continue;
+    }
+    const condition = rule.condition;
+    if (typeof condition === "function") {
+      const allowed = await Promise.resolve().then(() => condition(user)).catch(() => false);
+      if (allowed) {
+        return true;
+      }
+    } else if (rule.allow) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/server/handlers/auth/index.ts
+var authenticationMiddleware = async (c2, next) => {
+  const mastra = c2.get("mastra");
+  const authConfig = mastra.getServer()?.experimental_auth;
+  if (!authConfig) {
+    return next();
+  }
+  if (isDevPlaygroundRequest(c2.req)) {
+    return next();
+  }
+  if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
+    return next();
+  }
+  if (canAccessPublicly(c2.req.path, c2.req.method, authConfig)) {
+    return next();
+  }
+  const authHeader = c2.req.header("Authorization");
+  let token = authHeader ? authHeader.replace("Bearer ", "") : null;
+  if (!token && c2.req.query("apiKey")) {
+    token = c2.req.query("apiKey") || null;
+  }
+  if (!token) {
+    return c2.json({ error: "Authentication required" }, 401);
+  }
+  try {
+    let user;
+    if (typeof authConfig.authenticateToken === "function") {
+      user = await authConfig.authenticateToken(token, c2.req);
+    } else {
+      throw new Error("No token verification method configured");
+    }
+    if (!user) {
+      return c2.json({ error: "Invalid or expired token" }, 401);
+    }
+    c2.get("runtimeContext").set("user", user);
+    return next();
+  } catch (err) {
+    console.error(err);
+    return c2.json({ error: "Invalid or expired token" }, 401);
+  }
+};
+var authorizationMiddleware = async (c2, next) => {
+  const mastra = c2.get("mastra");
+  const authConfig = mastra.getServer()?.experimental_auth;
+  if (!authConfig) {
+    return next();
+  }
+  const path = c2.req.path;
+  const method = c2.req.method;
+  if (isDevPlaygroundRequest(c2.req)) {
+    return next();
+  }
+  if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
+    return next();
+  }
+  if (canAccessPublicly(path, method, authConfig)) {
+    return next();
+  }
+  const user = c2.get("runtimeContext").get("user");
+  if ("authorizeUser" in authConfig && typeof authConfig.authorizeUser === "function") {
+    try {
+      const isAuthorized = await authConfig.authorizeUser(user, c2.req);
+      if (isAuthorized) {
+        return next();
+      }
+      return c2.json({ error: "Access denied" }, 403);
+    } catch (err) {
+      console.error(err);
+      return c2.json({ error: "Authorization error" }, 500);
+    }
+  }
+  if ("authorize" in authConfig && typeof authConfig.authorize === "function") {
+    try {
+      const isAuthorized = await authConfig.authorize(path, method, user, c2);
+      if (isAuthorized) {
+        return next();
+      }
+      return c2.json({ error: "Access denied" }, 403);
+    } catch (err) {
+      console.error(err);
+      return c2.json({ error: "Authorization error" }, 500);
+    }
+  }
+  if ("rules" in authConfig && authConfig.rules && authConfig.rules.length > 0) {
+    const isAuthorized = await checkRules(authConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+    return c2.json({ error: "Access denied" }, 403);
+  }
+  if (defaultAuthConfig.rules && defaultAuthConfig.rules.length > 0) {
+    const isAuthorized = await checkRules(defaultAuthConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+  }
+  return c2.json({ error: "Access denied" }, 403);
+};
+
+// src/server/handlers/client.ts
+var clients = /* @__PURE__ */ new Set();
+var hotReloadDisabled = false;
+function handleClientsRefresh(c2) {
+  const stream7 = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue("data: connected\n\n");
+      c2.req.raw.signal.addEventListener("abort", () => {
+        clients.delete(controller);
+      });
+    }
+  });
+  return new Response(stream7, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function handleTriggerClientsRefresh(c2) {
+  clients.forEach((controller) => {
+    try {
+      controller.enqueue("data: refresh\n\n");
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c2.json({ success: true, clients: clients.size });
+}
+function disableHotReload() {
+  hotReloadDisabled = true;
+  console.log("\u{1F512} Hot reload disabled for template installation");
+}
+function enableHotReload() {
+  hotReloadDisabled = false;
+  console.log("\u{1F513} Hot reload re-enabled after template installation");
+}
+function isHotReloadDisabled() {
+  return hotReloadDisabled;
+}
+function handleError(error, defaultMessage) {
+  const apiError = error;
+  throw new httpException.HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage,
+    cause: apiError.cause
+  });
+}
+function errorHandler(err, c2, isDev) {
+  if (err instanceof httpException.HTTPException) {
+    if (isDev) {
+      return c2.json({ error: err.message, cause: err.cause, stack: err.stack }, err.status);
+    }
+    return c2.json({ error: err.message }, err.status);
+  }
+  console.error(err);
+  return c2.json({ error: "Internal Server Error" }, 500);
+}
+
+// src/server/handlers/root.ts
+async function rootHandler(c2) {
+  return c2.text("Hello to the Mastra API!");
+}
+async function getAgentBuilderActionsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actions = await agentBuilder.getAgentBuilderActionsHandler({
+      mastra
+    });
+    return c2.json(actions);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder actions");
+  }
+}
+async function getAgentBuilderActionByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const action = await agentBuilder.getAgentBuilderActionByIdHandler({
+      mastra,
+      actionId
+    });
+    return c2.json(action);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action by ID");
+  }
+}
+async function createAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const result = await agentBuilder.createAgentBuilderActionRunHandler({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error creating agent builder action run");
+  }
+}
+async function startAsyncAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    disableHotReload();
+    const result = await agentBuilder.startAsyncAgentBuilderActionHandler({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      inputData
+    });
+    enableHotReload();
+    return c2.json(result);
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error starting async agent builder action");
+  }
+}
+async function startAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    await agentBuilder.startAgentBuilderActionRunHandler({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      inputData
+    });
+    return c2.json({ message: "Agent builder action run started" });
+  } catch (error) {
+    return handleError(error, "Error starting agent builder action run");
+  }
+}
+async function watchAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const eventType = c2.req.query("eventType");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to watch action" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(c2, async (stream7) => {
+      try {
+        disableHotReload();
+        const result = await agentBuilder.watchAgentBuilderActionHandler({
+          mastra,
+          actionId,
+          runId,
+          eventType
+        });
+        const reader = result.getReader();
+        stream7.onAbort(() => {
+          void reader.cancel("request aborted");
+        });
+        let chunkResult;
+        while ((chunkResult = await reader.read()) && !chunkResult.done) {
+          await stream7.write(JSON.stringify(chunkResult.value) + "");
+        }
+        enableHotReload();
+      } catch (err) {
+        enableHotReload();
+        logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
+      }
+    });
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error watching agent builder action");
+  }
+}
+async function streamAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream7) => {
+        try {
+          disableHotReload();
+          const result = await agentBuilder.streamAgentBuilderActionHandler({
+            mastra,
+            actionId,
+            runId,
+            inputData,
+            runtimeContext
+          });
+          const reader = result.stream.getReader();
+          stream7.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in action stream: " + (err?.message ?? "Unknown error"));
+        }
+        await stream7.close();
+        enableHotReload();
+      },
+      async (err) => {
+        logger2.error("Error in action stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error streaming agent builder action");
+  }
+}
+async function streamVNextAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream7) => {
+        try {
+          disableHotReload();
+          const result = await agentBuilder.streamVNextAgentBuilderActionHandler({
+            mastra,
+            actionId,
+            runId,
+            inputData,
+            runtimeContext
+          });
+          const reader = result.getReader();
+          stream7.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in action VNext stream: " + (err?.message ?? "Unknown error"));
+        }
+        enableHotReload();
+      },
+      async (err) => {
+        logger2.error("Error in action VNext stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error streaming VNext agent builder action");
+  }
+}
+async function resumeAsyncAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume action" });
+    }
+    disableHotReload();
+    const result = await agentBuilder.resumeAsyncAgentBuilderActionHandler({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      body: { step, resumeData }
+    });
+    enableHotReload();
+    return c2.json(result);
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error resuming async agent builder action");
+  }
+}
+async function resumeAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume action" });
+    }
+    disableHotReload();
+    await agentBuilder.resumeAgentBuilderActionHandler({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      body: { step, resumeData }
+    });
+    enableHotReload();
+    return c2.json({ message: "Action run resumed" });
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error resuming agent builder action");
+  }
+}
+async function getAgentBuilderActionRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
+    const runs = await agentBuilder.getAgentBuilderActionRunsHandler({
+      mastra,
+      actionId,
+      fromDate: fromDate ? new Date(fromDate) : void 0,
+      toDate: toDate ? new Date(toDate) : void 0,
+      limit: limit ? Number(limit) : void 0,
+      offset: offset ? Number(offset) : void 0,
+      resourceId
+    });
+    return c2.json(runs);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action runs");
+  }
+}
+async function getAgentBuilderActionRunByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const run = await agentBuilder.getAgentBuilderActionRunByIdHandler({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(run);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action run by ID");
+  }
+}
+async function getAgentBuilderActionRunExecutionResultHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const result = await agentBuilder.getAgentBuilderActionRunExecutionResultHandler({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action run execution result");
+  }
+}
+async function cancelAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const result = await agentBuilder.cancelAgentBuilderActionRunHandler({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error cancelling agent builder action run");
+  }
+}
+async function sendAgentBuilderActionRunEventHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const { event, data } = await c2.req.json();
+    const result = await agentBuilder.sendAgentBuilderActionRunEventHandler({
+      mastra,
+      actionId,
+      runId,
+      event,
+      data
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error sending agent builder action run event");
+  }
+}
+
+// src/server/handlers/routes/agent-builder/router.ts
+function agentBuilderRouter(bodyLimitOptions) {
+  const router = new hono.Hono();
+  router.get(
+    "/",
+    w({
+      description: "Get all agent builder actions",
+      tags: ["agent-builder"],
+      responses: {
+        200: {
+          description: "List of all agent builder actions"
+        }
+      }
+    }),
+    getAgentBuilderActionsHandler
+  );
+  router.get(
+    "/:actionId",
+    w({
+      description: "Get agent builder action by ID",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action details"
+        },
+        404: {
+          description: "Agent builder action not found"
+        }
+      }
+    }),
+    getAgentBuilderActionByIdHandler
+  );
+  router.get(
+    "/:actionId/runs",
+    w({
+      description: "Get all runs for an agent builder action",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        { name: "fromDate", in: "query", required: false, schema: { type: "string", format: "date-time" } },
+        { name: "toDate", in: "query", required: false, schema: { type: "string", format: "date-time" } },
+        { name: "limit", in: "query", required: false, schema: { type: "number" } },
+        { name: "offset", in: "query", required: false, schema: { type: "number" } },
+        { name: "resourceId", in: "query", required: false, schema: { type: "string" } }
+      ],
+      responses: {
+        200: {
+          description: "List of agent builder action runs from storage"
+        }
+      }
+    }),
+    getAgentBuilderActionRunsHandler
+  );
+  router.get(
+    "/:actionId/runs/:runId/execution-result",
+    w({
+      description: "Get execution result for an agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action run execution result"
+        },
+        404: {
+          description: "Agent builder action run execution result not found"
+        }
+      }
+    }),
+    getAgentBuilderActionRunExecutionResultHandler
+  );
+  router.get(
+    "/:actionId/runs/:runId",
+    w({
+      description: "Get agent builder action run by ID",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action run by ID"
+        },
+        404: {
+          description: "Agent builder action run not found"
+        }
+      }
+    }),
+    getAgentBuilderActionRunByIdHandler
+  );
+  router.post(
+    "/:actionId/resume",
+    w({
+      description: "Resume a suspended agent builder action step",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/resume-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Resume a suspended agent builder action step",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeAsyncAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/stream",
+    w({
+      description: "Stream agent builder action in real-time",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    streamAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/streamVNext",
+    w({
+      description: "Stream agent builder action in real-time using the VNext streaming API",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    streamVNextAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/create-run",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Create a new agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "New agent builder action run created"
+        }
+      }
+    }),
+    createAgentBuilderActionRunHandler
+  );
+  router.post(
+    "/:actionId/start-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Execute/Start an agent builder action",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action execution result"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      }
+    }),
+    startAsyncAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/start",
+    w({
+      description: "Create and start a new agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      }
+    }),
+    startAgentBuilderActionRunHandler
+  );
+  router.get(
+    "/:actionId/watch",
+    w({
+      description: "Watch agent builder action transitions in real-time",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        },
+        {
+          name: "eventType",
+          in: "query",
+          required: false,
+          schema: { type: "string", enum: ["watch", "watch-v2"] }
+        }
+      ],
+      tags: ["agent-builder"],
+      responses: {
+        200: {
+          description: "agent builder action transitions in real-time"
+        }
+      }
+    }),
+    watchAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/runs/:runId/cancel",
+    w({
+      description: "Cancel an agent builder action run",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      tags: ["agent-builder"],
+      responses: {
+        200: {
+          description: "agent builder action run cancelled"
+        }
+      }
+    }),
+    cancelAgentBuilderActionRunHandler
+  );
+  router.post(
+    "/:actionId/runs/:runId/send-event",
+    w({
+      description: "Send an event to an agent builder action run",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: { type: "object", properties: { event: { type: "string" }, data: { type: "object" } } }
+          }
+        }
       },
-      allow: true
-    }
-  ]
-};
-
-// src/server/handlers/auth/helpers.ts
-var isDevPlaygroundRequest = (req) => {
-  return req.header("x-mastra-dev-playground") === "true" && process.env.MASTRA_DEV === "true";
-};
-var isProtectedPath = (path, method, authConfig) => {
-  const protectedAccess = [...defaultAuthConfig.protected || [], ...authConfig.protected || []];
-  return isAnyMatch(path, method, protectedAccess);
-};
-var canAccessPublicly = (path, method, authConfig) => {
-  const publicAccess = [...defaultAuthConfig.public || [], ...authConfig.public || []];
-  return isAnyMatch(path, method, publicAccess);
-};
-var isAnyMatch = (path, method, patterns) => {
-  if (!patterns) {
-    return false;
-  }
-  for (const patternPathOrMethod of patterns) {
-    if (patternPathOrMethod instanceof RegExp) {
-      if (patternPathOrMethod.test(path)) {
-        return true;
-      }
-    }
-    if (typeof patternPathOrMethod === "string" && pathMatchesPattern(path, patternPathOrMethod)) {
-      return true;
-    }
-    if (Array.isArray(patternPathOrMethod) && patternPathOrMethod.length === 2) {
-      const [pattern, methodOrMethods] = patternPathOrMethod;
-      if (pathMatchesPattern(path, pattern) && matchesOrIncludes(methodOrMethods, method)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-var pathMatchesPattern = (path, pattern) => {
-  if (pattern.endsWith("*")) {
-    const prefix = pattern.slice(0, -1);
-    return path.startsWith(prefix);
-  }
-  return path === pattern;
-};
-var pathMatchesRule = (path, rulePath) => {
-  if (!rulePath) return true;
-  if (typeof rulePath === "string") {
-    return pathMatchesPattern(path, rulePath);
-  }
-  if (rulePath instanceof RegExp) {
-    console.log("rulePath", rulePath, path, rulePath.test(path));
-    return rulePath.test(path);
-  }
-  if (Array.isArray(rulePath)) {
-    return rulePath.some((p2) => pathMatchesPattern(path, p2));
-  }
-  return false;
-};
-var matchesOrIncludes = (values, value) => {
-  if (typeof values === "string") {
-    return values === value;
-  }
-  if (Array.isArray(values)) {
-    return values.includes(value);
-  }
-  return false;
-};
-var checkRules = async (rules, path, method, user) => {
-  for (const i2 in rules || []) {
-    const rule = rules?.[i2];
-    if (!pathMatchesRule(path, rule.path)) {
-      continue;
-    }
-    if (rule.methods && !matchesOrIncludes(rule.methods, method)) {
-      continue;
-    }
-    const condition = rule.condition;
-    if (typeof condition === "function") {
-      const allowed = await Promise.resolve().then(() => condition(user)).catch(() => false);
-      if (allowed) {
-        return true;
-      }
-    } else if (rule.allow) {
-      return true;
-    }
-  }
-  return false;
-};
-
-// src/server/handlers/auth/index.ts
-var authenticationMiddleware = async (c2, next) => {
-  const mastra = c2.get("mastra");
-  const authConfig = mastra.getServer()?.experimental_auth;
-  if (!authConfig) {
-    return next();
-  }
-  if (isDevPlaygroundRequest(c2.req)) {
-    return next();
-  }
-  if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
-    return next();
-  }
-  if (canAccessPublicly(c2.req.path, c2.req.method, authConfig)) {
-    return next();
-  }
-  const authHeader = c2.req.header("Authorization");
-  let token = authHeader ? authHeader.replace("Bearer ", "") : null;
-  if (!token && c2.req.query("apiKey")) {
-    token = c2.req.query("apiKey") || null;
-  }
-  if (!token) {
-    return c2.json({ error: "Authentication required" }, 401);
-  }
-  try {
-    let user;
-    if (typeof authConfig.authenticateToken === "function") {
-      user = await authConfig.authenticateToken(token, c2.req);
-    } else {
-      throw new Error("No token verification method configured");
-    }
-    if (!user) {
-      return c2.json({ error: "Invalid or expired token" }, 401);
-    }
-    c2.get("runtimeContext").set("user", user);
-    return next();
-  } catch (err) {
-    console.error(err);
-    return c2.json({ error: "Invalid or expired token" }, 401);
-  }
-};
-var authorizationMiddleware = async (c2, next) => {
-  const mastra = c2.get("mastra");
-  const authConfig = mastra.getServer()?.experimental_auth;
-  if (!authConfig) {
-    return next();
-  }
-  const path = c2.req.path;
-  const method = c2.req.method;
-  if (isDevPlaygroundRequest(c2.req)) {
-    return next();
-  }
-  if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
-    return next();
-  }
-  if (canAccessPublicly(path, method, authConfig)) {
-    return next();
-  }
-  const user = c2.get("runtimeContext").get("user");
-  if ("authorizeUser" in authConfig && typeof authConfig.authorizeUser === "function") {
-    try {
-      const isAuthorized = await authConfig.authorizeUser(user, c2.req);
-      if (isAuthorized) {
-        return next();
-      }
-      return c2.json({ error: "Access denied" }, 403);
-    } catch (err) {
-      console.error(err);
-      return c2.json({ error: "Authorization error" }, 500);
-    }
-  }
-  if ("authorize" in authConfig && typeof authConfig.authorize === "function") {
-    try {
-      const isAuthorized = await authConfig.authorize(path, method, user, c2);
-      if (isAuthorized) {
-        return next();
+      tags: ["agent-builder"],
+      responses: {
+        200: {
+          description: "agent builder action run event sent"
+        }
       }
-      return c2.json({ error: "Access denied" }, 403);
-    } catch (err) {
-      console.error(err);
-      return c2.json({ error: "Authorization error" }, 500);
-    }
-  }
-  if ("rules" in authConfig && authConfig.rules && authConfig.rules.length > 0) {
-    const isAuthorized = await checkRules(authConfig.rules, path, method, user);
-    if (isAuthorized) {
-      return next();
-    }
-    return c2.json({ error: "Access denied" }, 403);
-  }
-  if (defaultAuthConfig.rules && defaultAuthConfig.rules.length > 0) {
-    const isAuthorized = await checkRules(defaultAuthConfig.rules, path, method, user);
-    if (isAuthorized) {
-      return next();
-    }
-  }
-  return c2.json({ error: "Access denied" }, 403);
-};
-
-// src/server/handlers/client.ts
-var clients = /* @__PURE__ */ new Set();
-function handleClientsRefresh(c2) {
-  const stream6 = new ReadableStream({
-    start(controller) {
-      clients.add(controller);
-      controller.enqueue("data: connected\n\n");
-      c2.req.raw.signal.addEventListener("abort", () => {
-        clients.delete(controller);
-      });
-    }
-  });
-  return new Response(stream6, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*"
-    }
-  });
-}
-function handleTriggerClientsRefresh(c2) {
-  clients.forEach((controller) => {
-    try {
-      controller.enqueue("data: refresh\n\n");
-    } catch {
-      clients.delete(controller);
-    }
-  });
-  return c2.json({ success: true, clients: clients.size });
-}
-function handleError(error, defaultMessage) {
-  const apiError = error;
-  throw new httpException.HTTPException(apiError.status || 500, {
-    message: apiError.message || defaultMessage,
-    cause: apiError.cause
-  });
-}
-function errorHandler(err, c2, isDev) {
-  if (err instanceof httpException.HTTPException) {
-    if (isDev) {
-      return c2.json({ error: err.message, cause: err.cause, stack: err.stack }, err.status);
-    }
-    return c2.json({ error: err.message }, err.status);
-  }
-  console.error(err);
-  return c2.json({ error: "Internal Server Error" }, 500);
-}
-
-// src/server/handlers/root.ts
-async function rootHandler(c2) {
-  return c2.text("Hello to the Mastra API!");
+    }),
+    sendAgentBuilderActionRunEventHandler
+  );
+  return router;
 }
 var AllowedProviderKeys = {
   openai: "OPENAI_API_KEY",
@@ -1445,7 +2324,7 @@ async function streamVNextGenerateHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const streamResponse = await agents.streamVNextGenerateHandler({
             mastra,
@@ -1455,20 +2334,20 @@ async function streamVNextGenerateHandler(c2) {
             abortSignal: c2.req.raw.signal
           });
           const reader = streamResponse.fullStream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+            await stream7.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
           }
-          await stream6.write("data: [DONE]\n\n");
+          await stream7.write("data: [DONE]\n\n");
         } catch (err) {
           logger2.error("Error in streamVNext generate: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream7.close();
       },
       async (err) => {
         logger2.error("Error in watch stream: " + err?.message);
@@ -7215,7 +8094,7 @@ async function streamGenerateVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await vNextNetwork.streamGenerateVNextNetworkHandler({
             mastra,
@@ -7224,12 +8103,12 @@ async function streamGenerateVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network stream: " + (err?.message ?? "Unknown error"));
@@ -7270,7 +8149,7 @@ async function loopStreamVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await vNextNetwork.loopStreamVNextNetworkHandler({
             mastra,
@@ -7279,12 +8158,12 @@ async function loopStreamVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network loop stream: " + (err?.message ?? "Unknown error"));
@@ -8670,7 +9549,7 @@ function watchWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             mastra,
@@ -8678,12 +9557,12 @@ function watchWorkflowHandler(c2) {
             runId
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
@@ -8708,7 +9587,7 @@ async function streamWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.streamWorkflowHandler({
             mastra,
@@ -8718,17 +9597,17 @@ async function streamWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow stream: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream7.close();
       },
       async (err) => {
         logger2.error("Error in workflow stream: " + err?.message);
@@ -8749,7 +9628,7 @@ async function streamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.streamVNextWorkflowHandler({
             mastra,
@@ -8759,12 +9638,12 @@ async function streamVNextWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow VNext stream: " + (err?.message ?? "Unknown error"));
@@ -8992,20 +9871,20 @@ function watchLegacyWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await legacyWorkflows.watchLegacyWorkflowHandler({
             mastra,
             workflowId,
             runId
           });
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream6.write(chunk.toString() + "");
+            await stream7.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -10305,6 +11184,7 @@ async function createHonoServer(mastra, options = {
   app.route("/api/workflows", workflowsRouter(bodyLimitOptions));
   app.route("/api/logs", logsRouter());
   app.route("/api/scores", scoresRouter(bodyLimitOptions));
+  app.route("/api/agent-builder", agentBuilderRouter(bodyLimitOptions));
   app.route("/api/tools", toolsRouter(bodyLimitOptions, options.tools));
   app.route("/api/vector", vectorRouter(bodyLimitOptions));
   if (options?.isDev || server?.build?.openAPIDocs || server?.build?.swaggerUI) {
@@ -10342,6 +11222,18 @@ async function createHonoServer(mastra, options = {
       }),
       handleTriggerClientsRefresh
     );
+    app.get(
+      "/__hot-reload-status",
+      w({
+        hide: true
+      }),
+      (c2) => {
+        return c2.json({
+          disabled: isHotReloadDisabled(),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    );
     app.use("/assets/*", async (c2, next) => {
       const path = c2.req.path;
       if (path.endsWith(".js")) {