@mastra/deployer 0.24.6 → 0.24.7-alpha.1

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAsB5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,KAAK,QAAQ,GAAG,EAAE,CAAC;AAEnB,KAAK,SAAS,GAAG;IACf,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,GAAG,CAAC;QAAE,UAAU,EAAE,+BAA+B,CAAA;KAAE,CAAC,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9C,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,wCAmB/D;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAER;cAGgC,QAAQ;eAAa,SAAS;2CAogBhE;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAmC,mDAoDlG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAuB5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,KAAK,QAAQ,GAAG,EAAE,CAAC;AAEnB,KAAK,SAAS,GAAG;IACf,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,GAAG,CAAC;QAAE,UAAU,EAAE,+BAA+B,CAAA;KAAE,CAAC,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5B,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9C,CAAC;AAEF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,wCAmB/D;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAER;cAGgC,QAAQ;eAAa,SAAS;2CA8gBhE;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAmC,mDAoDlG"}

package/dist/server/index.js

@@ -39,7 +39,7 @@ import { getAITracesPaginatedHandler as getAITracesPaginatedHandler$1, getAITrac
 import { getScorersHandler as getScorersHandler$1, getScorerHandler as getScorerHandler$1, getScoresByRunIdHandler as getScoresByRunIdHandler$1, getScoresByScorerIdHandler as getScoresByScorerIdHandler$1, getScoresByEntityIdHandler as getScoresByEntityIdHandler$1, saveScoreHandler as saveScoreHandler$1 } from '@mastra/server/handlers/scores';
 import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
 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 { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeStreamWorkflowHandler as resumeStreamWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamLegacyWorkflowHandler as streamLegacyWorkflowHandler$1, observeStreamLegacyWorkflowHandler as observeStreamLegacyWorkflowHandler$1, streamVNextWorkflowHandler as streamVNextWorkflowHandler$1, observeStreamVNextWorkflowHandler as observeStreamVNextWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1, sendWorkflowRunEventHandler as sendWorkflowRunEventHandler$1 } from '@mastra/server/handlers/workflows';
+import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeStreamWorkflowHandler as resumeStreamWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, timeTravelWorkflowHandler as timeTravelWorkflowHandler$1, timeTravelStreamWorkflowHandler as timeTravelStreamWorkflowHandler$1, timeTravelAsyncWorkflowHandler as timeTravelAsyncWorkflowHandler$1, restartWorkflowHandler as restartWorkflowHandler$1, restartAsyncWorkflowHandler as restartAsyncWorkflowHandler$1, restartAllActiveWorkflowRunsHandler as restartAllActiveWorkflowRunsHandler$1, restartAllActiveWorkflowRunsAsyncHandler as restartAllActiveWorkflowRunsAsyncHandler$1, streamLegacyWorkflowHandler as streamLegacyWorkflowHandler$1, observeStreamLegacyWorkflowHandler as observeStreamLegacyWorkflowHandler$1, streamVNextWorkflowHandler as streamVNextWorkflowHandler$1, observeStreamVNextWorkflowHandler as observeStreamVNextWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1, sendWorkflowRunEventHandler as sendWorkflowRunEventHandler$1 } from '@mastra/server/handlers/workflows';
 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';
 
 // src/server/index.ts
@@ -1052,8 +1052,9 @@ var defaultAuthConfig = {
 };
 
 // src/server/handlers/auth/helpers.ts
-var isDevPlaygroundRequest = (req) => {
-  return req.header("x-mastra-dev-playground") === "true" && process.env.MASTRA_DEV === "true";
+var isDevPlaygroundRequest = (req, authConfig) => {
+  const protectedAccess = [...defaultAuthConfig.protected || [], ...authConfig.protected || []];
+  return process.env.MASTRA_DEV === "true" && (!isAnyMatch(req.path, req.method, protectedAccess) || req.header("x-mastra-dev-playground") === "true");
 };
 var isCustomRoutePublic = (path, method, customRouteAuthConfig) => {
   if (!customRouteAuthConfig) {
@@ -1158,7 +1159,7 @@ var authenticationMiddleware = async (c2, next) => {
   if (!authConfig) {
     return next();
   }
-  if (isDevPlaygroundRequest(c2.req)) {
+  if (isDevPlaygroundRequest(c2.req, authConfig)) {
     return next();
   }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig, customRouteAuthConfig)) {
@@ -1201,7 +1202,7 @@ var authorizationMiddleware = async (c2, next) => {
   }
   const path = c2.req.path;
   const method = c2.req.method;
-  if (isDevPlaygroundRequest(c2.req)) {
+  if (isDevPlaygroundRequest(c2.req, authConfig)) {
     return next();
   }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig, customRouteAuthConfig)) {
@@ -1317,6 +1318,17 @@ async function healthHandler(c2) {
   return c2.json({ success: true }, 200);
 }
 
+// src/server/handlers/restart-active-runs.ts
+async function restartAllActiveWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    void mastra.restartAllActiveWorkflowRuns();
+    return c2.json({ message: "Restarting all active workflow runs..." });
+  } catch (error) {
+    return handleError(error, "Error restarting active workflow runs");
+  }
+}
+
 // src/server/handlers/root.ts
 async function rootHandler(c2) {
   const baseUrl = new URL(c2.req.url).origin;
@@ -2555,9 +2567,11 @@ var vNextBodyOptions = {
   ...sharedBodyOptions
 };
 async function getAgentsHandler(c2) {
+  const partial = c2.req.query("partial") === "true";
   const serializedAgents = await getAgentsHandler$1({
     mastra: c2.get("mastra"),
-    runtimeContext: c2.get("runtimeContext")
+    runtimeContext: c2.get("runtimeContext"),
+    partial
   });
   return c2.json(serializedAgents);
 }
@@ -9888,8 +9902,10 @@ function vectorRouter(bodyLimitOptions) {
 async function getWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const partial = c2.req.query("partial") === "true";
     const workflows = await getWorkflowsHandler$1({
-      mastra
+      mastra,
+      partial
     });
     return c2.json(workflows);
   } catch (error) {
@@ -10332,6 +10348,163 @@ async function sendWorkflowRunEventHandler(c2) {
     return handleError(error, "Error sending workflow run event");
   }
 }
+async function restartAsyncWorkflowHandler(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 { tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to restart workflow" });
+    }
+    const result = await restartAsyncWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error restarting workflow run");
+  }
+}
+async function restartWorkflowHandler(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 { tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to restart workflow" });
+    }
+    await restartWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions
+    });
+    return c2.json({ message: "Workflow run restarted" });
+  } catch (error) {
+    return handleError(error, "Error restarting workflow");
+  }
+}
+async function restartAllActiveWorkflowRunsAsyncHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const result = await restartAllActiveWorkflowRunsAsyncHandler$1({
+      mastra,
+      workflowId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error restarting all active workflow runs");
+  }
+}
+async function restartAllActiveWorkflowRunsHandler2(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    await restartAllActiveWorkflowRunsHandler$1({
+      mastra,
+      workflowId
+    });
+    return c2.json({ message: "All active workflow runs restarted" });
+  } catch (error) {
+    return handleError(error, "Error restarting all active workflow runs");
+  }
+}
+async function timeTravelAsyncWorkflowHandler(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 { tracingOptions, ...body } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to time travel workflow" });
+    }
+    const result = await timeTravelAsyncWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions,
+      body
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error time traveling workflow run");
+  }
+}
+async function timeTravelWorkflowHandler(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 { tracingOptions, ...body } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to time travel workflow" });
+    }
+    await timeTravelWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      tracingOptions,
+      body
+    });
+    return c2.json({ message: "Workflow run time traveled" });
+  } catch (error) {
+    return handleError(error, "Error time traveling workflow");
+  }
+}
+async function timeTravelStreamWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const { tracingOptions, ...body } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await timeTravelStreamWorkflowHandler$1({
+            mastra,
+            workflowId,
+            runId,
+            body,
+            runtimeContext,
+            tracingOptions
+          });
+          const reader = result.getReader();
+          stream6.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in workflow time travel stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in workflow time travel stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming time traveled workflow");
+  }
+}
 async function getLegacyWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -11074,6 +11247,315 @@ function workflowsRouter(bodyLimitOptions) {
     }),
     resumeAsyncWorkflowHandler
   );
+  router.post(
+    "/:workflowId/time-travel",
+    w({
+      description: "Time travel a workflow run",
+      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: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/time-travel-stream",
+    w({
+      description: "Time travel a workflow run using streamVNext",
+      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: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelStreamWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/time-travel-async",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Time travel a workflow run asynchronously",
+      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: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                inputData: { type: "object" },
+                resumeData: { type: "object" },
+                initialState: { type: "object" },
+                context: { type: "object", description: "Context for the workflow execution" },
+                nestedStepsContext: { type: "object", description: "Nested steps context for the workflow execution" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    timeTravelAsyncWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart a workflow run",
+      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: {
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    restartWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart-async",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart a workflow run asynchronously",
+      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: {
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the workflow execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    restartAsyncWorkflowHandler
+  );
+  router.post(
+    "/:workflowId/restart-all-active-workflow-runs",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart all active workflow runs",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ]
+    }),
+    restartAllActiveWorkflowRunsHandler2
+  );
+  router.post(
+    "/:workflowId/restart-all-active-workflow-runs-async",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Restart all active workflow runs asynchronously",
+      tags: ["workflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ]
+    }),
+    restartAllActiveWorkflowRunsAsyncHandler
+  );
   router.post(
     "/:workflowId/stream-legacy",
     w({
@@ -12057,6 +12539,15 @@ async function createHonoServer(mastra, options = {
       middleware({ url: "/openapi.json" })
     );
   }
+  if (options?.isDev) {
+    app.post(
+      "/__restart-active-workflow-runs",
+      w({
+        hide: true
+      }),
+      restartAllActiveWorkflowRunsHandler
+    );
+  }
   if (options?.playground) {
     app.get(
       "/refresh-events",