@mastra/deployer 0.3.5-alpha.0 → 0.10.0

package/dist/server/index.cjs

@@ -21,6 +21,7 @@ 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 legacyWorkflows = require('@mastra/server/handlers/legacyWorkflows');
 var logs = require('@mastra/server/handlers/logs');
 var util = require('util');
 var buffer = require('buffer');
@@ -31,7 +32,6 @@ var zod = require('zod');
 var telemetry = require('@mastra/server/handlers/telemetry');
 var tools = require('@mastra/server/handlers/tools');
 var vector = require('@mastra/server/handlers/vector');
-var vNextWorkflows = require('@mastra/server/handlers/vNextWorkflows');
 var voice = require('@mastra/server/handlers/voice');
 var workflows = require('@mastra/server/handlers/workflows');
 
@@ -1044,6 +1044,187 @@ async function setAgentInstructionsHandler(c2) {
   }
 }
 
+// src/server/handlers/auth/defaults.ts
+var defaultAuthConfig = {
+  public: [
+    "/",
+    "/refresh-events",
+    "/__refresh",
+    "/assets/*",
+    "/auth/*",
+    "/openapi.json",
+    "/swagger-ui",
+    ["/api/agents", "GET"],
+    ["/a2a/*", ["GET"]]
+  ],
+  // Simple rule system
+  rules: [
+    // Admin users can do anything
+    {
+      condition: (user) => {
+        if (typeof user === "object" && user !== null) {
+          if ("isAdmin" in user) {
+            return !!user.isAdmin;
+          }
+          if ("role" in user) {
+            return user.role === "admin";
+          }
+        }
+        return false;
+      },
+      allow: true
+    }
+  ]
+};
+
+// src/server/handlers/auth/helpers.ts
+var canAccessPublicly = (path, method, authConfig) => {
+  const publicAccess = [...defaultAuthConfig.public || [], ...authConfig.public || []];
+  for (const patternPathOrMethod of publicAccess) {
+    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 (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 (canAccessPublicly(path, method, authConfig)) {
+    return next();
+  }
+  const user = c2.get("runtimeContext").get("user");
+  if (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 (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) {
@@ -1075,6 +1256,184 @@ function handleTriggerClientsRefresh(c2) {
   });
   return c2.json({ success: true, clients: clients.size });
 }
+async function getLegacyWorkflowsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflows = await legacyWorkflows.getLegacyWorkflowsHandler({
+      mastra
+    });
+    return c2.json(workflows);
+  } catch (error) {
+    return handleError(error, "Error getting workflows");
+  }
+}
+async function getLegacyWorkflowByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = await legacyWorkflows.getLegacyWorkflowByIdHandler({
+      mastra,
+      workflowId
+    });
+    return c2.json(workflow);
+  } catch (error) {
+    return handleError(error, "Error getting workflow");
+  }
+}
+async function startAsyncLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const triggerData = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await legacyWorkflows.startAsyncLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      triggerData
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
+  }
+}
+async function createLegacyWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const prevRunId = c2.req.query("runId");
+    const result = await legacyWorkflows.createLegacyWorkflowRunHandler({
+      mastra,
+      workflowId,
+      runId: prevRunId
+    });
+    return c2.json(result);
+  } catch (e2) {
+    return handleError(e2, "Error creating run");
+  }
+}
+async function startLegacyWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const triggerData = await c2.req.json();
+    const runId = c2.req.query("runId");
+    await legacyWorkflows.startLegacyWorkflowRunHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      triggerData
+    });
+    return c2.json({ message: "Workflow run started" });
+  } catch (e2) {
+    return handleError(e2, "Error starting workflow run");
+  }
+}
+function watchLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    return streaming.stream(
+      c2,
+      async (stream4) => {
+        try {
+          const result = await legacyWorkflows.watchLegacyWorkflowHandler({
+            mastra,
+            workflowId,
+            runId
+          });
+          stream4.onAbort(() => {
+            if (!result.locked) {
+              return result.cancel();
+            }
+          });
+          for await (const chunk of result) {
+            await stream4.write(chunk.toString() + "");
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { stepId, context } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const result = await legacyWorkflows.resumeAsyncLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { stepId, context }
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { stepId, context } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    await legacyWorkflows.resumeLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { stepId, context }
+    });
+    return c2.json({ message: "Workflow run resumed" });
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
+  }
+}
+async function getLegacyWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
+    const workflowRuns = await legacyWorkflows.getLegacyWorkflowRunsHandler({
+      mastra,
+      workflowId,
+      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(workflowRuns);
+  } catch (error) {
+    return handleError(error, "Error getting workflow runs");
+  }
+}
 async function getLogsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -3665,217 +4024,37 @@ async function deleteIndex(c2) {
     return handleError(error, "Error deleting index");
   }
 }
-async function getVNextWorkflowsHandler(c2) {
+async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflows = await vNextWorkflows.getVNextWorkflowsHandler({
-      mastra
+    const agentId = c2.req.param("agentId");
+    const speakers = await voice.getSpeakersHandler({
+      mastra,
+      agentId
     });
-    return c2.json(workflows);
+    return c2.json(speakers);
   } catch (error) {
-    return handleError(error, "Error getting workflows");
+    return handleError(error, "Error getting speakers");
   }
 }
-async function getVNextWorkflowByIdHandler(c2) {
+async function speakHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const workflow = await vNextWorkflows.getVNextWorkflowByIdHandler({
+    const agentId = c2.req.param("agentId");
+    const { input, options } = await c2.req.json();
+    const audioStream = await voice.generateSpeechHandler({
       mastra,
-      workflowId
+      agentId,
+      body: { text: input, speakerId: options?.speakerId }
     });
-    return c2.json(workflow);
+    c2.header("Content-Type", `audio/${options?.filetype ?? "mp3"}`);
+    c2.header("Transfer-Encoding", "chunked");
+    return c2.body(audioStream);
   } catch (error) {
-    return handleError(error, "Error getting workflow");
+    return handleError(error, "Error generating speech");
   }
 }
-async function createVNextWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const prevRunId = c2.req.query("runId");
-    const result = await vNextWorkflows.createVNextWorkflowRunHandler({
-      mastra,
-      workflowId,
-      runId: prevRunId
-    });
-    return c2.json(result);
-  } catch (e2) {
-    return handleError(e2, "Error creating run");
-  }
-}
-async function startAsyncVNextWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runtimeContext = c2.get("runtimeContext");
-    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
-    const runId = c2.req.query("runId");
-    const result = await vNextWorkflows.startAsyncVNextWorkflowHandler({
-      mastra,
-      runtimeContext,
-      runtimeContextFromRequest,
-      workflowId,
-      runId,
-      inputData
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error executing workflow");
-  }
-}
-async function startVNextWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runtimeContext = c2.get("runtimeContext");
-    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
-    const runId = c2.req.query("runId");
-    await vNextWorkflows.startVNextWorkflowRunHandler({
-      mastra,
-      runtimeContext,
-      runtimeContextFromRequest,
-      workflowId,
-      runId,
-      inputData
-    });
-    return c2.json({ message: "Workflow run started" });
-  } catch (e2) {
-    return handleError(e2, "Error starting workflow run");
-  }
-}
-function watchVNextWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const logger2 = mastra.getLogger();
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    return streaming.stream(
-      c2,
-      async (stream4) => {
-        try {
-          const result = await vNextWorkflows.watchVNextWorkflowHandler({
-            mastra,
-            workflowId,
-            runId
-          });
-          stream4.onAbort(() => {
-            if (!result.locked) {
-              return result.cancel();
-            }
-          });
-          for await (const chunk of result) {
-            await stream4.write(chunk.toString() + "");
-          }
-        } catch (err) {
-          console.log(err);
-        }
-      },
-      async (err) => {
-        logger2.error("Error in watch stream: " + err?.message);
-      }
-    );
-  } catch (error) {
-    return handleError(error, "Error watching workflow");
-  }
-}
-async function resumeAsyncVNextWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const runtimeContext = c2.get("runtimeContext");
-    const { step, resumeData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    const result = await vNextWorkflows.resumeAsyncVNextWorkflowHandler({
-      mastra,
-      runtimeContext,
-      runtimeContextFromRequest,
-      workflowId,
-      runId,
-      body: { step, resumeData }
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error resuming workflow step");
-  }
-}
-async function resumeVNextWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const { step, resumeData, runtimeContext } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    await vNextWorkflows.resumeVNextWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { step, resumeData }
-    });
-    return c2.json({ message: "Workflow run resumed" });
-  } catch (error) {
-    return handleError(error, "Error resuming workflow");
-  }
-}
-async function getVNextWorkflowRunsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
-    const workflowRuns = await vNextWorkflows.getVNextWorkflowRunsHandler({
-      mastra,
-      workflowId,
-      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(workflowRuns);
-  } catch (error) {
-    return handleError(error, "Error getting workflow runs");
-  }
-}
-async function getSpeakersHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const speakers = await voice.getSpeakersHandler({
-      mastra,
-      agentId
-    });
-    return c2.json(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 { input, options } = await c2.req.json();
-    const audioStream = await voice.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 (error) {
-    return handleError(error, "Error generating speech");
-  }
-}
-async function listenHandler(c2) {
+async function listenHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
@@ -3928,53 +4107,55 @@ async function getWorkflowByIdHandler(c2) {
     return handleError(error, "Error getting workflow");
   }
 }
-async function startAsyncWorkflowHandler(c2) {
+async function createWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
-    const runId = c2.req.query("runId");
-    const result = await workflows.startAsyncWorkflowHandler({
+    const prevRunId = c2.req.query("runId");
+    const result = await workflows.createWorkflowRunHandler({
       mastra,
-      runtimeContext,
       workflowId,
-      runId,
-      triggerData
+      runId: prevRunId
     });
     return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error executing workflow");
+  } catch (e2) {
+    return handleError(e2, "Error creating run");
   }
 }
-async function createRunHandler(c2) {
+async function startAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const prevRunId = c2.req.query("runId");
-    const result = await workflows.createRunHandler({
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await workflows.startAsyncWorkflowHandler({
       mastra,
+      runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
-      runId: prevRunId
+      runId,
+      inputData
     });
     return c2.json(result);
-  } catch (e2) {
-    return handleError(e2, "Error creating run");
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
   }
 }
 async function startWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     const runId = c2.req.query("runId");
     await workflows.startWorkflowRunHandler({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
-      triggerData
+      inputData
     });
     return c2.json({ message: "Workflow run started" });
   } catch (e2) {
@@ -4022,19 +4203,20 @@ function watchWorkflowHandler(c2) {
 async function resumeAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
     const runId = c2.req.query("runId");
-    const { stepId, context } = await c2.req.json();
+    const runtimeContext = c2.get("runtimeContext");
+    const { step, resumeData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
     }
     const result = await workflows.resumeAsyncWorkflowHandler({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
-      body: { stepId, context }
+      body: { step, resumeData }
     });
     return c2.json(result);
   } catch (error) {
@@ -4044,10 +4226,9 @@ async function resumeAsyncWorkflowHandler(c2) {
 async function resumeWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
     const runId = c2.req.query("runId");
-    const { stepId, context } = await c2.req.json();
+    const { step, resumeData, runtimeContext } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
     }
@@ -4056,7 +4237,7 @@ async function resumeWorkflowHandler(c2) {
       runtimeContext,
       workflowId,
       runId,
-      body: { stepId, context }
+      body: { step, resumeData }
     });
     return c2.json({ message: "Workflow run resumed" });
   } catch (error) {
@@ -4273,6 +4454,8 @@ async function createHonoServer(mastra, options = {}) {
     };
     app.use("*", timeout.timeout(server?.timeout ?? 3 * 60 * 1e3), cors.cors(corsConfig));
   }
+  app.use("*", authenticationMiddleware);
+  app.use("*", authorizationMiddleware);
   const bodyLimitOptions = {
     maxSize: server?.bodySizeLimit ?? 4.5 * 1024 * 1024,
     // 4.5 MB,
@@ -5840,23 +6023,23 @@ async function createHonoServer(mastra, options = {}) {
     storeTelemetryHandler
   );
   app.get(
-    "/api/workflows/v-next",
+    "/api/workflows/legacy",
     h({
-      description: "Get all vNext workflows",
-      tags: ["vNextWorkflows"],
+      description: "Get all legacy workflows",
+      tags: ["legacyWorkflows"],
       responses: {
         200: {
-          description: "List of all vNext workflows"
+          description: "List of all legacy workflows"
         }
       }
     }),
-    getVNextWorkflowsHandler
+    getLegacyWorkflowsHandler
   );
   app.get(
-    "/api/workflows/v-next/:workflowId",
+    "/api/workflows/legacy/:workflowId",
     h({
-      description: "Get vNext workflow by ID",
-      tags: ["vNextWorkflows"],
+      description: "Get legacy workflow by ID",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -5867,20 +6050,20 @@ async function createHonoServer(mastra, options = {}) {
       ],
       responses: {
         200: {
-          description: "vNext workflow details"
+          description: "Legacy Workflow details"
         },
         404: {
-          description: "vNext workflow not found"
+          description: "Legacy Workflow not found"
         }
       }
     }),
-    getVNextWorkflowByIdHandler
+    getLegacyWorkflowByIdHandler
   );
   app.get(
-    "/api/workflows/v-next/:workflowId/runs",
+    "/api/workflows/legacy/:workflowId/runs",
     h({
-      description: "Get all runs for a vNext workflow",
-      tags: ["vNextWorkflows"],
+      description: "Get all runs for a legacy workflow",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -5896,17 +6079,17 @@ async function createHonoServer(mastra, options = {}) {
       ],
       responses: {
         200: {
-          description: "List of vNext workflow runs from storage"
+          description: "List of legacy workflow runs from storage"
         }
       }
     }),
-    getVNextWorkflowRunsHandler
+    getLegacyWorkflowRunsHandler
   );
   app.post(
-    "/api/workflows/v-next/:workflowId/resume",
+    "/api/workflows/legacy/:workflowId/resume",
     h({
-      description: "Resume a suspended vNext workflow step",
-      tags: ["vNextWorkflows"],
+      description: "Resume a suspended legacy workflow step",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -5928,29 +6111,22 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                step: {
-                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
-                },
-                resumeData: { type: "object" },
-                runtimeContext: {
-                  type: "object",
-                  description: "Runtime context for the workflow execution"
-                }
-              },
-              required: ["step"]
+                stepId: { type: "string" },
+                context: { type: "object" }
+              }
             }
           }
         }
       }
     }),
-    resumeVNextWorkflowHandler
+    resumeLegacyWorkflowHandler
   );
   app.post(
-    "/api/workflows/v-next/:workflowId/resume-async",
+    "/api/workflows/legacy/:workflowId/resume-async",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
-      description: "Resume a suspended vNext workflow step",
-      tags: ["vNextWorkflows"],
+      description: "Resume a suspended legacy workflow step",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -5972,29 +6148,21 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                step: {
-                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
-                },
-                resumeData: { type: "object" },
-                runtimeContext: {
-                  type: "object",
-                  description: "Runtime context for the workflow execution"
-                }
-              },
-              required: ["step"]
+                stepId: { type: "string" },
+                context: { type: "object" }
+              }
             }
           }
         }
       }
     }),
-    resumeAsyncVNextWorkflowHandler
+    resumeAsyncLegacyWorkflowHandler
   );
   app.post(
-    "/api/workflows/v-next/:workflowId/create-run",
-    bodyLimit.bodyLimit(bodyLimitOptions),
+    "/api/workflows/legacy/:workflowId/create-run",
     h({
-      description: "Create a new vNext workflow run",
-      tags: ["vNextWorkflows"],
+      description: "Create a new legacy workflow run",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -6011,18 +6179,18 @@ async function createHonoServer(mastra, options = {}) {
       ],
       responses: {
         200: {
-          description: "New vNext workflow run created"
+          description: "New legacy workflow run created"
         }
       }
     }),
-    createVNextWorkflowRunHandler
+    createLegacyWorkflowRunHandler
   );
   app.post(
-    "/api/workflows/v-next/:workflowId/start-async",
+    "/api/workflows/legacy/:workflowId/start-async",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
-      description: "Execute/Start a vNext workflow",
-      tags: ["vNextWorkflows"],
+      description: "Execute/Start a legacy workflow",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -6044,11 +6212,7 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                inputData: { type: "object" },
-                runtimeContext: {
-                  type: "object",
-                  description: "Runtime context for the workflow execution"
-                }
+                input: { type: "object" }
               }
             }
           }
@@ -6056,20 +6220,20 @@ async function createHonoServer(mastra, options = {}) {
       },
       responses: {
         200: {
-          description: "vNext workflow execution result"
+          description: "Legacy Workflow execution result"
         },
         404: {
-          description: "vNext workflow not found"
+          description: "Legacy Workflow not found"
         }
       }
     }),
-    startAsyncVNextWorkflowHandler
+    startAsyncLegacyWorkflowHandler
   );
   app.post(
-    "/api/workflows/v-next/:workflowId/start",
+    "/api/workflows/legacy/:workflowId/start",
     h({
-      description: "Create and start a new vNext workflow run",
-      tags: ["vNextWorkflows"],
+      description: "Create and start a new legacy workflow run",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -6091,11 +6255,7 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                inputData: { type: "object" },
-                runtimeContext: {
-                  type: "object",
-                  description: "Runtime context for the workflow execution"
-                }
+                input: { type: "object" }
               }
             }
           }
@@ -6103,19 +6263,19 @@ async function createHonoServer(mastra, options = {}) {
       },
       responses: {
         200: {
-          description: "vNext workflow run started"
+          description: "Legacy Workflow run started"
         },
         404: {
-          description: "vNext workflow not found"
+          description: "Legacy Workflow not found"
         }
       }
     }),
-    startVNextWorkflowRunHandler
+    startLegacyWorkflowRunHandler
   );
   app.get(
-    "/api/workflows/v-next/:workflowId/watch",
+    "/api/workflows/legacy/:workflowId/watch",
     h({
-      description: "Watch vNext workflow transitions in real-time",
+      description: "Watch legacy workflow transitions in real-time",
       parameters: [
         {
           name: "workflowId",
@@ -6130,14 +6290,14 @@ async function createHonoServer(mastra, options = {}) {
           schema: { type: "string" }
         }
       ],
-      tags: ["vNextWorkflows"],
+      tags: ["legacyWorkflows"],
       responses: {
         200: {
-          description: "vNext workflow transitions in real-time"
+          description: "Legacy Workflow transitions in real-time"
         }
       }
     }),
-    watchVNextWorkflowHandler
+    watchLegacyWorkflowHandler
   );
   app.get(
     "/api/workflows",
@@ -6228,9 +6388,16 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                stepId: { type: "string" },
-                context: { type: "object" }
-              }
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
+              },
+              required: ["step"]
             }
           }
         }
@@ -6238,43 +6405,6 @@ async function createHonoServer(mastra, options = {}) {
     }),
     resumeWorkflowHandler
   );
-  app.post(
-    "/api/workflows/:workflowId/resumeAsync",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    h({
-      description: "@deprecated Use /api/workflows/:workflowId/resume-async instead",
-      tags: ["workflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          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: {
-                stepId: { type: "string" },
-                context: { type: "object" }
-              }
-            }
-          }
-        }
-      }
-    }),
-    resumeAsyncWorkflowHandler
-  );
   app.post(
     "/api/workflows/:workflowId/resume-async",
     bodyLimit.bodyLimit(bodyLimitOptions),
@@ -6302,9 +6432,16 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                stepId: { type: "string" },
-                context: { type: "object" }
-              }
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
+              },
+              required: ["step"]
             }
           }
         }
@@ -6313,7 +6450,8 @@ async function createHonoServer(mastra, options = {}) {
     resumeAsyncWorkflowHandler
   );
   app.post(
-    "/api/workflows/:workflowId/createRun",
+    "/api/workflows/:workflowId/create-run",
+    bodyLimit.bodyLimit(bodyLimitOptions),
     h({
       description: "Create a new workflow run",
       tags: ["workflows"],
@@ -6337,51 +6475,7 @@ async function createHonoServer(mastra, options = {}) {
         }
       }
     }),
-    createRunHandler
-  );
-  app.post(
-    "/api/workflows/:workflowId/startAsync",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    h({
-      description: "@deprecated Use /api/workflows/:workflowId/start-async instead",
-      tags: ["workflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          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: {
-                input: { type: "object" }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: "Workflow execution result"
-        },
-        404: {
-          description: "Workflow not found"
-        }
-      }
-    }),
-    startAsyncWorkflowHandler
+    createWorkflowRunHandler
   );
   app.post(
     "/api/workflows/:workflowId/start-async",
@@ -6410,7 +6504,11 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                input: { type: "object" }
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               }
             }
           }
@@ -6418,10 +6516,10 @@ async function createHonoServer(mastra, options = {}) {
       },
       responses: {
         200: {
-          description: "Workflow execution result"
+          description: "workflow execution result"
         },
         404: {
-          description: "Workflow not found"
+          description: "workflow not found"
         }
       }
     }),
@@ -6453,7 +6551,11 @@ async function createHonoServer(mastra, options = {}) {
             schema: {
               type: "object",
               properties: {
-                input: { type: "object" }
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
               }
             }
           }
@@ -6461,10 +6563,10 @@ async function createHonoServer(mastra, options = {}) {
       },
       responses: {
         200: {
-          description: "Workflow run started"
+          description: "workflow run started"
         },
         404: {
-          description: "Workflow not found"
+          description: "workflow not found"
         }
       }
     }),
@@ -6491,7 +6593,7 @@ async function createHonoServer(mastra, options = {}) {
       tags: ["workflows"],
       responses: {
         200: {
-          description: "Workflow transitions in real-time"
+          description: "workflow transitions in real-time"
         }
       }
     }),