@mastra/deployer 0.3.4 → 0.4.0-alpha.1

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");
@@ -2984,7 +3343,7 @@ var getMcpServerMessageHandler = async (c2) => {
   try {
     await server.startHTTP({
       url: new URL(c2.req.url),
-      httpPath: `/api/servers/${serverId}/mcp`,
+      httpPath: `/api/mcp/${serverId}/mcp`,
       req,
       res,
       options: {
@@ -3005,8 +3364,8 @@ var getMcpServerSseHandler = async (c2) => {
     return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
   }
   const requestUrl = new URL(c2.req.url);
-  const sseConnectionPath = `/api/servers/${serverId}/sse`;
-  const sseMessagePath = `/api/servers/${serverId}/messages`;
+  const sseConnectionPath = `/api/mcp/${serverId}/sse`;
+  const sseMessagePath = `/api/mcp/${serverId}/messages`;
   try {
     return await server.startHonoSSE({
       url: requestUrl,
@@ -3019,17 +3378,159 @@ var getMcpServerSseHandler = async (c2) => {
     return handleError(error, "Error handling MCP SSE request");
   }
 };
-async function getMemoryStatusHandler(c2) {
+var listMcpRegistryServersHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  if (!mastra || typeof mastra.getMCPServers !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServers method not available in listMcpRegistryServersHandler");
+    return c2.json({ error: "Mastra instance or getMCPServers method not available" }, 500);
+  }
+  const mcpServersMap = mastra.getMCPServers();
+  if (!mcpServersMap) {
+    c2.get("logger")?.warn("getMCPServers returned undefined or null in listMcpRegistryServersHandler");
+    return c2.json({ servers: [], next: null, total_count: 0 });
+  }
+  const allServersArray = Array.from(
+    mcpServersMap instanceof Map ? mcpServersMap.values() : Object.values(mcpServersMap)
+  );
+  const limit = parseInt(c2.req.query("limit") || "50", 10);
+  const offset = parseInt(c2.req.query("offset") || "0", 10);
+  const paginatedServers = allServersArray.slice(offset, offset + limit);
+  const serverInfos = paginatedServers.map((server) => server.getServerInfo());
+  const total_count = allServersArray.length;
+  let next = null;
+  if (offset + limit < total_count) {
+    const nextOffset = offset + limit;
+    const currentUrl = new URL(c2.req.url);
+    currentUrl.searchParams.set("offset", nextOffset.toString());
+    currentUrl.searchParams.set("limit", limit.toString());
+    next = currentUrl.toString();
+  }
+  return c2.json({
+    servers: serverInfos,
+    next,
+    total_count
+  });
+};
+var getMcpRegistryServerDetailHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("id");
+  const requestedVersion = c2.req.query("version");
+  if (!mastra || typeof mastra.getMCPServer !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in getMcpRegistryServerDetailHandler");
+    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  }
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
+  }
+  const serverDetailInfo = server.getServerDetail();
+  if (requestedVersion && serverDetailInfo.version_detail.version !== requestedVersion) {
+    c2.get("logger")?.info(
+      `MCP server with ID '${serverId}' found, but version '${serverDetailInfo.version_detail.version}' does not match requested version '${requestedVersion}'.`
+    );
+    return c2.json(
+      {
+        error: `MCP server with ID '${serverId}' found, but not version '${requestedVersion}'. Available version is '${serverDetailInfo.version_detail.version}'.`
+      },
+      404
+      // Return 404 as the specific version is not found
+    );
+  }
+  return c2.json(serverDetailInfo);
+};
+var listMcpServerToolsHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  if (!mastra || typeof mastra.getMCPServer !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in listMcpServerToolsHandler");
+    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  }
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
+  }
+  if (typeof server.getToolListInfo !== "function") {
+    c2.get("logger")?.error(`MCPServer with ID '${serverId}' does not support getToolListInfo.`);
+    return c2.json({ error: `Server '${serverId}' cannot list tools in this way.` }, 501);
+  }
   try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.query("agentId");
-    const result = await memory.getMemoryStatusHandler({
-      mastra,
-      agentId
-    });
-    return c2.json(result);
+    const toolListInfo = server.getToolListInfo();
+    return c2.json(toolListInfo);
   } catch (error) {
-    return handleError(error, "Error getting memory status");
+    c2.get("logger")?.error(`Error in listMcpServerToolsHandler for serverId '${serverId}':`, { error: error.message });
+    return handleError(error, `Error listing tools for MCP server '${serverId}'`);
+  }
+};
+var getMcpServerToolDetailHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const toolId = c2.req.param("toolId");
+  if (!mastra || typeof mastra.getMCPServer !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in getMcpServerToolDetailHandler");
+    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  }
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
+  }
+  if (typeof server.getToolInfo !== "function") {
+    c2.get("logger")?.error(`MCPServer with ID '${serverId}' does not support getToolInfo.`);
+    return c2.json({ error: `Server '${serverId}' cannot provide tool details in this way.` }, 501);
+  }
+  try {
+    const toolInfo = server.getToolInfo(toolId);
+    if (!toolInfo) {
+      return c2.json({ error: `Tool with ID '${toolId}' not found on MCP server '${serverId}'` }, 404);
+    }
+    return c2.json(toolInfo);
+  } catch (error) {
+    c2.get("logger")?.error(`Error in getMcpServerToolDetailHandler for serverId '${serverId}', toolId '${toolId}':`, {
+      error: error.message
+    });
+    return handleError(error, `Error getting tool '${toolId}' details for MCP server '${serverId}'`);
+  }
+};
+var executeMcpServerToolHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const toolId = c2.req.param("toolId");
+  if (!mastra || typeof mastra.getMCPServer !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in executeMcpServerToolHandler");
+    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  }
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
+  }
+  if (typeof server.executeTool !== "function") {
+    c2.get("logger")?.error(`MCPServer with ID '${serverId}' does not support executeTool.`);
+    return c2.json({ error: `Server '${serverId}' cannot execute tools in this way.` }, 501);
+  }
+  try {
+    const body = await c2.req.json();
+    const args = body?.data;
+    const runtimeContext = body?.runtimeContext;
+    const result = await server.executeTool(toolId, args, runtimeContext);
+    return c2.json({ result });
+  } catch (error) {
+    c2.get("logger")?.error(`Error executing tool '${toolId}' on server '${serverId}':`, { error: error.message });
+    if (error.name === "ZodError") {
+      return c2.json({ error: "Invalid tool arguments", details: error.errors }, 400);
+    }
+    return handleError(error, `Error executing tool '${toolId}' on MCP server '${serverId}'`);
+  }
+};
+async function getMemoryStatusHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const result = await memory.getMemoryStatusHandler({
+      mastra,
+      agentId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting memory status");
   }
 }
 async function getThreadsHandler(c2) {
@@ -3523,186 +4024,6 @@ async function deleteIndex(c2) {
     return handleError(error, "Error deleting index");
   }
 }
-async function getVNextWorkflowsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflows = await vNextWorkflows.getVNextWorkflowsHandler({
-      mastra
-    });
-    return c2.json(workflows);
-  } catch (error) {
-    return handleError(error, "Error getting workflows");
-  }
-}
-async function getVNextWorkflowByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const workflow = await vNextWorkflows.getVNextWorkflowByIdHandler({
-      mastra,
-      workflowId
-    });
-    return c2.json(workflow);
-  } catch (error) {
-    return handleError(error, "Error getting workflow");
-  }
-}
-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");
@@ -3786,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) {
@@ -3880,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) {
@@ -3902,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" });
     }
@@ -3914,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) {
@@ -4131,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,
@@ -5176,7 +5501,7 @@ async function createHonoServer(mastra, options = {}) {
     executeAgentToolHandler
   );
   app.post(
-    "/api/servers/:serverId/mcp",
+    "/api/mcp/:serverId/mcp",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
       description: "Send a message to an MCP server using Streamable HTTP",
@@ -5203,8 +5528,8 @@ async function createHonoServer(mastra, options = {}) {
     }),
     getMcpServerMessageHandler
   );
-  const mcpSseBasePath = "/api/servers/:serverId/sse";
-  const mcpSseMessagePath = "/api/servers/:serverId/messages";
+  const mcpSseBasePath = "/api/mcp/:serverId/sse";
+  const mcpSseMessagePath = "/api/mcp/:serverId/messages";
   app.get(
     mcpSseBasePath,
     h({
@@ -5262,6 +5587,158 @@ async function createHonoServer(mastra, options = {}) {
     }),
     getMcpServerSseHandler
   );
+  app.get(
+    "/api/mcp/v0/servers",
+    h({
+      description: "List all available MCP server instances with basic information.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "limit",
+          in: "query",
+          description: "Number of results per page.",
+          required: false,
+          schema: { type: "integer", default: 50, minimum: 1, maximum: 5e3 }
+        },
+        {
+          name: "offset",
+          in: "query",
+          description: "Number of results to skip for pagination.",
+          required: false,
+          schema: { type: "integer", default: 0, minimum: 0 }
+        }
+      ],
+      responses: {
+        200: {
+          description: "A list of MCP server instances.",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  servers: { type: "array", items: { $ref: "#/components/schemas/ServerInfo" } },
+                  next: { type: "string", format: "uri", nullable: true },
+                  total_count: { type: "integer" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    listMcpRegistryServersHandler
+  );
+  app.get(
+    "/api/mcp/v0/servers/:id",
+    h({
+      description: "Get detailed information about a specific MCP server instance.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: "Unique ID of the MCP server instance.",
+          schema: { type: "string" }
+        },
+        {
+          name: "version",
+          in: "query",
+          required: false,
+          description: "Desired MCP server version (currently informational, server returns its actual version).",
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Detailed information about the MCP server instance.",
+          content: {
+            "application/json": { schema: { $ref: "#/components/schemas/ServerDetailInfo" } }
+          }
+        },
+        404: {
+          description: "MCP server instance not found.",
+          content: { "application/json": { schema: { type: "object", properties: { error: { type: "string" } } } } }
+        }
+      }
+    }),
+    getMcpRegistryServerDetailHandler
+  );
+  app.get(
+    "/api/mcp/:serverId/tools",
+    h({
+      description: "List all tools available on a specific MCP server instance.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          description: "Unique ID of the MCP server instance.",
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: { description: "A list of tools for the MCP server." },
+        // Define schema if you have one for McpServerToolListResponse
+        404: { description: "MCP server instance not found." },
+        501: { description: "Server does not support listing tools." }
+      }
+    }),
+    listMcpServerToolsHandler
+  );
+  app.get(
+    "/api/mcp/:serverId/tools/:toolId",
+    h({
+      description: "Get details for a specific tool on an MCP server.",
+      tags: ["mcp"],
+      parameters: [
+        { name: "serverId", in: "path", required: true, schema: { type: "string" } },
+        { name: "toolId", in: "path", required: true, schema: { type: "string" } }
+      ],
+      responses: {
+        200: { description: "Details of the specified tool." },
+        // Define schema for McpToolInfo
+        404: { description: "MCP server or tool not found." },
+        501: { description: "Server does not support getting tool details." }
+      }
+    }),
+    getMcpServerToolDetailHandler
+  );
+  app.post(
+    "/api/mcp/:serverId/tools/:toolId/execute",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    h({
+      description: "Execute a specific tool on an MCP server.",
+      tags: ["mcp"],
+      parameters: [
+        { name: "serverId", in: "path", required: true, schema: { type: "string" } },
+        { name: "toolId", in: "path", required: true, schema: { type: "string" } }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                data: { type: "object" },
+                runtimeContext: { type: "object" }
+              }
+            }
+          }
+        }
+        // Simplified schema
+      },
+      responses: {
+        200: { description: "Result of the tool execution." },
+        400: { description: "Invalid tool arguments." },
+        404: { description: "MCP server or tool not found." },
+        501: { description: "Server does not support tool execution." }
+      }
+    }),
+    executeMcpServerToolHandler
+  );
   app.get(
     "/api/memory/status",
     h({
@@ -5546,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",
@@ -5573,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",
@@ -5602,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",
@@ -5634,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",
@@ -5678,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",
@@ -5717,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",
@@ -5750,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" }
               }
             }
           }
@@ -5762,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",
@@ -5797,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" }
               }
             }
           }
@@ -5809,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",
@@ -5836,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",
@@ -5934,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"]
             }
           }
         }
@@ -5944,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),
@@ -6008,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"]
             }
           }
         }
@@ -6019,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"],
@@ -6043,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",
@@ -6116,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"
+                }
               }
             }
           }
@@ -6124,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"
         }
       }
     }),
@@ -6159,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"
+                }
               }
             }
           }
@@ -6167,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"
         }
       }
     }),
@@ -6197,7 +6593,7 @@ async function createHonoServer(mastra, options = {}) {
       tags: ["workflows"],
       responses: {
         200: {
-          description: "Workflow transitions in real-time"
+          description: "workflow transitions in real-time"
         }
       }
     }),
@@ -6615,7 +7011,7 @@ async function createNodeServer(mastra, options = {}) {
     {
       fetch: app.fetch,
       port,
-      hostname: serverOptions?.host ?? "localhost"
+      hostname: serverOptions?.host
     },
     () => {
       const logger2 = mastra.getLogger();