@mastra/deployer 0.3.5-alpha.0 → 0.10.0

package/dist/server/index.js

@@ -19,6 +19,7 @@ import { HTTPException } from 'hono/http-exception';
 import { getAgentCardByIdHandler as getAgentCardByIdHandler$1, getAgentExecutionHandler as getAgentExecutionHandler$1 } from '@mastra/server/handlers/a2a';
 import { stream } from 'hono/streaming';
 import { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateHandler as generateHandler$2, streamGenerateHandler as streamGenerateHandler$2 } from '@mastra/server/handlers/agents';
+import { getLegacyWorkflowsHandler as getLegacyWorkflowsHandler$1, getLegacyWorkflowByIdHandler as getLegacyWorkflowByIdHandler$1, getLegacyWorkflowRunsHandler as getLegacyWorkflowRunsHandler$1, resumeLegacyWorkflowHandler as resumeLegacyWorkflowHandler$1, resumeAsyncLegacyWorkflowHandler as resumeAsyncLegacyWorkflowHandler$1, createLegacyWorkflowRunHandler as createLegacyWorkflowRunHandler$1, startAsyncLegacyWorkflowHandler as startAsyncLegacyWorkflowHandler$1, startLegacyWorkflowRunHandler as startLegacyWorkflowRunHandler$1, watchLegacyWorkflowHandler as watchLegacyWorkflowHandler$1 } from '@mastra/server/handlers/legacyWorkflows';
 import { getLogsHandler as getLogsHandler$1, getLogTransports as getLogTransports$1, getLogsByRunIdHandler as getLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
 import { Writable, Readable as Readable$1 } from 'node:stream';
 import util from 'node:util';
@@ -30,9 +31,8 @@ import { z } from 'zod';
 import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
 import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
 import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
-import { getVNextWorkflowsHandler as getVNextWorkflowsHandler$1, getVNextWorkflowByIdHandler as getVNextWorkflowByIdHandler$1, getVNextWorkflowRunsHandler as getVNextWorkflowRunsHandler$1, resumeVNextWorkflowHandler as resumeVNextWorkflowHandler$1, resumeAsyncVNextWorkflowHandler as resumeAsyncVNextWorkflowHandler$1, createVNextWorkflowRunHandler as createVNextWorkflowRunHandler$1, startAsyncVNextWorkflowHandler as startAsyncVNextWorkflowHandler$1, startVNextWorkflowRunHandler as startVNextWorkflowRunHandler$1, watchVNextWorkflowHandler as watchVNextWorkflowHandler$1 } from '@mastra/server/handlers/vNextWorkflows';
 import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
-import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, createRunHandler as createRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1 } from '@mastra/server/handlers/workflows';
+import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1 } from '@mastra/server/handlers/workflows';
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -1038,6 +1038,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) {
@@ -1069,6 +1250,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 getLegacyWorkflowsHandler$1({
+      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 getLegacyWorkflowByIdHandler$1({
+      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 startAsyncLegacyWorkflowHandler$1({
+      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 createLegacyWorkflowRunHandler$1({
+      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 startLegacyWorkflowRunHandler$1({
+      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(400, { message: "runId required to watch workflow" });
+    }
+    return stream(
+      c2,
+      async (stream4) => {
+        try {
+          const result = await watchLegacyWorkflowHandler$1({
+            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(400, { message: "runId required to resume workflow" });
+    }
+    const result = await resumeAsyncLegacyWorkflowHandler$1({
+      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(400, { message: "runId required to resume workflow" });
+    }
+    await resumeLegacyWorkflowHandler$1({
+      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 getLegacyWorkflowRunsHandler$1({
+      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");
@@ -3659,217 +4018,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 getVNextWorkflowsHandler$1({
-      mastra
+    const agentId = c2.req.param("agentId");
+    const speakers = await getSpeakersHandler$1({
+      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 getVNextWorkflowByIdHandler$1({
+    const agentId = c2.req.param("agentId");
+    const { input, options } = await c2.req.json();
+    const audioStream = await 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 createVNextWorkflowRunHandler$1({
-      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 startAsyncVNextWorkflowHandler$1({
-      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 startVNextWorkflowRunHandler$1({
-      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(400, { message: "runId required to watch workflow" });
-    }
-    return stream(
-      c2,
-      async (stream4) => {
-        try {
-          const result = await watchVNextWorkflowHandler$1({
-            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(400, { message: "runId required to resume workflow" });
-    }
-    const result = await resumeAsyncVNextWorkflowHandler$1({
-      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(400, { message: "runId required to resume workflow" });
-    }
-    await resumeVNextWorkflowHandler$1({
-      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 getVNextWorkflowRunsHandler$1({
-      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 getSpeakersHandler$1({
-      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 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");
@@ -3922,53 +4101,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 startAsyncWorkflowHandler$1({
+    const prevRunId = c2.req.query("runId");
+    const result = await createWorkflowRunHandler$1({
       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 createRunHandler$1({
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await startAsyncWorkflowHandler$1({
       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 startWorkflowRunHandler$1({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
-      triggerData
+      inputData
     });
     return c2.json({ message: "Workflow run started" });
   } catch (e2) {
@@ -4016,19 +4197,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(400, { message: "runId required to resume workflow" });
     }
     const result = await resumeAsyncWorkflowHandler$1({
       mastra,
       runtimeContext,
+      runtimeContextFromRequest,
       workflowId,
       runId,
-      body: { stepId, context }
+      body: { step, resumeData }
     });
     return c2.json(result);
   } catch (error) {
@@ -4038,10 +4220,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(400, { message: "runId required to resume workflow" });
     }
@@ -4050,7 +4231,7 @@ async function resumeWorkflowHandler(c2) {
       runtimeContext,
       workflowId,
       runId,
-      body: { stepId, context }
+      body: { step, resumeData }
     });
     return c2.json({ message: "Workflow run resumed" });
   } catch (error) {
@@ -4267,6 +4448,8 @@ async function createHonoServer(mastra, options = {}) {
     };
     app.use("*", timeout(server?.timeout ?? 3 * 60 * 1e3), cors(corsConfig));
   }
+  app.use("*", authenticationMiddleware);
+  app.use("*", authorizationMiddleware);
   const bodyLimitOptions = {
     maxSize: server?.bodySizeLimit ?? 4.5 * 1024 * 1024,
     // 4.5 MB,
@@ -5834,23 +6017,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",
@@ -5861,20 +6044,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",
@@ -5890,17 +6073,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",
@@ -5922,29 +6105,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(bodyLimitOptions),
     h({
-      description: "Resume a suspended vNext workflow step",
-      tags: ["vNextWorkflows"],
+      description: "Resume a suspended legacy workflow step",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -5966,29 +6142,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(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",
@@ -6005,18 +6173,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(bodyLimitOptions),
     h({
-      description: "Execute/Start a vNext workflow",
-      tags: ["vNextWorkflows"],
+      description: "Execute/Start a legacy workflow",
+      tags: ["legacyWorkflows"],
       parameters: [
         {
           name: "workflowId",
@@ -6038,11 +6206,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" }
               }
             }
           }
@@ -6050,20 +6214,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",
@@ -6085,11 +6249,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" }
               }
             }
           }
@@ -6097,19 +6257,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",
@@ -6124,14 +6284,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",
@@ -6222,9 +6382,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"]
             }
           }
         }
@@ -6232,43 +6399,6 @@ async function createHonoServer(mastra, options = {}) {
     }),
     resumeWorkflowHandler
   );
-  app.post(
-    "/api/workflows/:workflowId/resumeAsync",
-    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(bodyLimitOptions),
@@ -6296,9 +6426,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"]
             }
           }
         }
@@ -6307,7 +6444,8 @@ async function createHonoServer(mastra, options = {}) {
     resumeAsyncWorkflowHandler
   );
   app.post(
-    "/api/workflows/:workflowId/createRun",
+    "/api/workflows/:workflowId/create-run",
+    bodyLimit(bodyLimitOptions),
     h({
       description: "Create a new workflow run",
       tags: ["workflows"],
@@ -6331,51 +6469,7 @@ async function createHonoServer(mastra, options = {}) {
         }
       }
     }),
-    createRunHandler
-  );
-  app.post(
-    "/api/workflows/:workflowId/startAsync",
-    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",
@@ -6404,7 +6498,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"
+                }
               }
             }
           }
@@ -6412,10 +6510,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"
         }
       }
     }),
@@ -6447,7 +6545,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"
+                }
               }
             }
           }
@@ -6455,10 +6557,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"
         }
       }
     }),
@@ -6485,7 +6587,7 @@ async function createHonoServer(mastra, options = {}) {
       tags: ["workflows"],
       responses: {
         200: {
-          description: "Workflow transitions in real-time"
+          description: "workflow transitions in real-time"
         }
       }
     }),