@mastra/server 0.0.0-span-scorring-test-20251124132129 → 0.0.0-standard-schema-20260126101119

package/dist/{chunk-VQAT5HX6.js → chunk-FDSHHJRG.js}

@@ -1,35 +1,52 @@
-import { getWorkflowInfo, WorkflowRegistry } from './chunk-G7BPNX2V.js';
-import { streamResponseSchema } from './chunk-R4M3BSUG.js';
-import { createOffsetPaginationSchema, tracingOptionsSchema, optionalRunIdSchema, runIdSchema, messageResponseSchema } from './chunk-PKRHEXX7.js';
-import { createRoute } from './chunk-FAQICBMH.js';
-import { handleError } from './chunk-UXGQZUYZ.js';
+import { getWorkflowInfo, WorkflowRegistry } from './chunk-OEF6DYI4.js';
+import { streamResponseSchema } from './chunk-DOU5IGJB.js';
+import { createCombinedPaginationSchema, tracingOptionsSchema, messageResponseSchema, optionalRunIdSchema, runIdSchema } from './chunk-HT4LP3BO.js';
+import { handleError } from './chunk-7AINN3FK.js';
 import { HTTPException } from './chunk-6QWQZI4Q.js';
+import { createRoute } from './chunk-N5RGHD5P.js';
 import { __export } from './chunk-PR4QN5HX.js';
 import { TransformStream, ReadableStream } from 'stream/web';
-import z from 'zod';
+import z, { z as z$1 } from 'zod';
 
 // src/server/handlers/workflows.ts
 var workflows_exports = {};
 __export(workflows_exports, {
   CANCEL_WORKFLOW_RUN_ROUTE: () => CANCEL_WORKFLOW_RUN_ROUTE,
   CREATE_WORKFLOW_RUN_ROUTE: () => CREATE_WORKFLOW_RUN_ROUTE,
+  DELETE_WORKFLOW_RUN_BY_ID_ROUTE: () => DELETE_WORKFLOW_RUN_BY_ID_ROUTE,
   GET_WORKFLOW_BY_ID_ROUTE: () => GET_WORKFLOW_BY_ID_ROUTE,
   GET_WORKFLOW_RUN_BY_ID_ROUTE: () => GET_WORKFLOW_RUN_BY_ID_ROUTE,
-  GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE: () => GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE,
   LIST_WORKFLOWS_ROUTE: () => LIST_WORKFLOWS_ROUTE,
   LIST_WORKFLOW_RUNS_ROUTE: () => LIST_WORKFLOW_RUNS_ROUTE,
   OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE: () => OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE,
-  OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE: () => OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE,
   OBSERVE_STREAM_WORKFLOW_ROUTE: () => OBSERVE_STREAM_WORKFLOW_ROUTE,
+  RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE: () => RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE,
+  RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE: () => RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE,
+  RESTART_ASYNC_WORKFLOW_ROUTE: () => RESTART_ASYNC_WORKFLOW_ROUTE,
+  RESTART_WORKFLOW_ROUTE: () => RESTART_WORKFLOW_ROUTE,
   RESUME_ASYNC_WORKFLOW_ROUTE: () => RESUME_ASYNC_WORKFLOW_ROUTE,
   RESUME_STREAM_WORKFLOW_ROUTE: () => RESUME_STREAM_WORKFLOW_ROUTE,
   RESUME_WORKFLOW_ROUTE: () => RESUME_WORKFLOW_ROUTE,
   START_ASYNC_WORKFLOW_ROUTE: () => START_ASYNC_WORKFLOW_ROUTE,
   START_WORKFLOW_RUN_ROUTE: () => START_WORKFLOW_RUN_ROUTE,
   STREAM_LEGACY_WORKFLOW_ROUTE: () => STREAM_LEGACY_WORKFLOW_ROUTE,
-  STREAM_VNEXT_WORKFLOW_ROUTE: () => STREAM_VNEXT_WORKFLOW_ROUTE,
-  STREAM_WORKFLOW_ROUTE: () => STREAM_WORKFLOW_ROUTE
+  STREAM_WORKFLOW_ROUTE: () => STREAM_WORKFLOW_ROUTE,
+  TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE: () => TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE,
+  TIME_TRAVEL_STREAM_WORKFLOW_ROUTE: () => TIME_TRAVEL_STREAM_WORKFLOW_ROUTE,
+  TIME_TRAVEL_WORKFLOW_ROUTE: () => TIME_TRAVEL_WORKFLOW_ROUTE
 });
+var workflowRunStatusSchema = z.enum([
+  "running",
+  "waiting",
+  "suspended",
+  "success",
+  "failed",
+  "canceled",
+  "pending",
+  "bailed",
+  "tripwire",
+  "paused"
+]);
 var workflowIdPathParams = z.object({
   workflowId: z.string().describe("Unique identifier for the workflow")
 });
@@ -38,7 +55,14 @@ var workflowRunPathParams = workflowIdPathParams.extend({
 });
 var serializedStepSchema = z.object({
   id: z.string(),
-  description: z.string().optional()
+  description: z.string().optional(),
+  stateSchema: z.string().optional(),
+  inputSchema: z.string().optional(),
+  outputSchema: z.string().optional(),
+  resumeSchema: z.string().optional(),
+  suspendSchema: z.string().optional(),
+  component: z.string().optional(),
+  isWorkflow: z.boolean().optional()
 });
 var serializedStepFlowEntrySchema = z.object({
   type: z.enum(["step", "sleep", "sleepUntil", "waitForEvent", "parallel", "conditional", "loop", "foreach"])
@@ -51,7 +75,9 @@ var workflowInfoSchema = z.object({
   stepGraph: z.array(serializedStepFlowEntrySchema),
   inputSchema: z.string().optional(),
   outputSchema: z.string().optional(),
-  options: z.object({}).optional()
+  stateSchema: z.string().optional(),
+  options: z.object({}).optional(),
+  isProcessorWorkflow: z.boolean().optional()
 });
 var listWorkflowsResponseSchema = z.record(z.string(), workflowInfoSchema);
 var workflowRunSchema = z.object({
@@ -66,16 +92,19 @@ var workflowRunsResponseSchema = z.object({
   runs: z.array(workflowRunSchema),
   total: z.number()
 });
-var workflowRunResponseSchema = workflowRunSchema;
-var listWorkflowRunsQuerySchema = createOffsetPaginationSchema().extend({
+var listWorkflowRunsQuerySchema = createCombinedPaginationSchema().extend({
   fromDate: z.coerce.date().optional(),
   toDate: z.coerce.date().optional(),
-  resourceId: z.string().optional()
+  resourceId: z.string().optional(),
+  status: workflowRunStatusSchema.optional()
 });
 var workflowExecutionBodySchema = z.object({
+  resourceId: z.string().optional(),
   inputData: z.unknown().optional(),
+  initialState: z.unknown().optional(),
   requestContext: z.record(z.string(), z.unknown()).optional(),
-  tracingOptions: tracingOptionsSchema.optional()
+  tracingOptions: tracingOptionsSchema.optional(),
+  perStep: z.boolean().optional()
 });
 var streamLegacyWorkflowBodySchema = workflowExecutionBodySchema;
 var streamWorkflowBodySchema = workflowExecutionBodySchema.extend({
@@ -85,23 +114,90 @@ var resumeBodySchema = z.object({
   step: z.union([z.string(), z.array(z.string())]).optional(),
   // Optional - workflow can auto-resume all suspended steps
   resumeData: z.unknown().optional(),
+  requestContext: z.record(z.string(), z.unknown()).optional(),
+  tracingOptions: tracingOptionsSchema.optional(),
+  perStep: z.boolean().optional()
+});
+var restartBodySchema = z.object({
   requestContext: z.record(z.string(), z.unknown()).optional(),
   tracingOptions: tracingOptionsSchema.optional()
 });
+var timeTravelBodySchema = z.object({
+  inputData: z.unknown().optional(),
+  resumeData: z.unknown().optional(),
+  initialState: z.unknown().optional(),
+  step: z.union([z.string(), z.array(z.string())]),
+  context: z.record(z.string(), z.any()).optional(),
+  nestedStepsContext: z.record(z.string(), z.record(z.string(), z.any())).optional(),
+  requestContext: z.record(z.string(), z.unknown()).optional(),
+  tracingOptions: tracingOptionsSchema.optional(),
+  perStep: z.boolean().optional()
+});
 var startAsyncWorkflowBodySchema = workflowExecutionBodySchema;
 z.object({
   event: z.string(),
   data: z.unknown()
 });
+var VALID_WORKFLOW_RESULT_FIELDS = /* @__PURE__ */ new Set([
+  "result",
+  "error",
+  "payload",
+  "steps",
+  "activeStepsPath",
+  "serializedStepGraph"
+]);
+var WORKFLOW_RESULT_FIELDS_ERROR = "Invalid field name. Available fields: result, error, payload, steps, activeStepsPath, serializedStepGraph";
+var createFieldsValidator = (description) => z.string().optional().refine(
+  (value) => {
+    if (!value) return true;
+    const requestedFields = value.split(",").map((f) => f.trim());
+    return requestedFields.every((field) => VALID_WORKFLOW_RESULT_FIELDS.has(field));
+  },
+  { message: WORKFLOW_RESULT_FIELDS_ERROR }
+).describe(description);
+var withNestedWorkflowsField = z.enum(["true", "false"]).optional().describe("Whether to include nested workflow data in steps. Defaults to true. Set to false for better performance.");
 var workflowExecutionResultSchema = z.object({
-  status: z.string(),
+  status: workflowRunStatusSchema.optional(),
   result: z.unknown().optional(),
-  error: z.unknown().optional()
+  error: z.unknown().optional(),
+  payload: z.unknown().optional(),
+  initialState: z.unknown().optional(),
+  steps: z.record(z.string(), z.any()).optional(),
+  activeStepsPath: z.record(z.string(), z.array(z.number())).optional(),
+  serializedStepGraph: z.array(serializedStepFlowEntrySchema).optional()
+});
+var workflowRunResultQuerySchema = z.object({
+  fields: createFieldsValidator(
+    "Comma-separated list of fields to return. Available fields: result, error, payload, steps, activeStepsPath, serializedStepGraph. Metadata fields (runId, workflowName, resourceId, createdAt, updatedAt) and status are always included."
+  ),
+  withNestedWorkflows: withNestedWorkflowsField
+});
+var workflowRunResultSchema = z.object({
+  // Metadata - always present
+  runId: z.string(),
+  workflowName: z.string(),
+  resourceId: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  // Execution state
+  status: workflowRunStatusSchema,
+  initialState: z.record(z.string(), z.any()).optional(),
+  result: z.unknown().optional(),
+  error: z.unknown().optional(),
+  payload: z.unknown().optional(),
+  steps: z.record(z.string(), z.any()).optional(),
+  // Optional detailed fields
+  activeStepsPath: z.record(z.string(), z.array(z.number())).optional(),
+  serializedStepGraph: z.array(serializedStepFlowEntrySchema).optional()
 });
 var workflowControlResponseSchema = messageResponseSchema;
 var createWorkflowRunResponseSchema = z.object({
   runId: z.string()
 });
+var createWorkflowRunBodySchema = z.object({
+  resourceId: z.string().optional(),
+  disableScorers: z.boolean().optional()
+});
 
 // src/server/handlers/workflows.ts
 async function listWorkflowsFromSystem({ mastra, workflowId }) {
@@ -143,35 +239,41 @@ async function listWorkflowsFromSystem({ mastra, workflowId }) {
 }
 var LIST_WORKFLOWS_ROUTE = createRoute({
   method: "GET",
-  path: "/api/workflows",
+  path: "/workflows",
   responseType: "json",
+  queryParamSchema: z$1.object({
+    partial: z$1.string().optional()
+  }),
   responseSchema: listWorkflowsResponseSchema,
   summary: "List all workflows",
   description: "Returns a list of all available workflows in the system",
   tags: ["Workflows"],
-  handler: async ({ mastra }) => {
+  requiresAuth: true,
+  handler: (async ({ mastra, partial }) => {
     try {
       const workflows = mastra.listWorkflows({ serialized: false });
+      const isPartial = partial === "true";
       const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
-        acc[key] = getWorkflowInfo(workflow);
+        acc[key] = getWorkflowInfo(workflow, isPartial);
         return acc;
       }, {});
       return _workflows;
     } catch (error) {
       return handleError(error, "Error getting workflows");
     }
-  }
+  })
 });
 var GET_WORKFLOW_BY_ID_ROUTE = createRoute({
   method: "GET",
-  path: "/api/workflows/:workflowId",
+  path: "/workflows/:workflowId",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   responseSchema: workflowInfoSchema,
   summary: "Get workflow by ID",
   description: "Returns details for a specific workflow",
   tags: ["Workflows"],
-  handler: async ({ mastra, workflowId }) => {
+  requiresAuth: true,
+  handler: (async ({ mastra, workflowId }) => {
     try {
       if (!workflowId) {
         throw new HTTPException(400, { message: "Workflow ID is required" });
@@ -181,11 +283,11 @@ var GET_WORKFLOW_BY_ID_ROUTE = createRoute({
     } catch (error) {
       return handleError(error, "Error getting workflow");
     }
-  }
+  })
 });
 var LIST_WORKFLOW_RUNS_ROUTE = createRoute({
   method: "GET",
-  path: "/api/workflows/:workflowId/runs",
+  path: "/workflows/:workflowId/runs",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: listWorkflowRunsQuerySchema,
@@ -193,17 +295,24 @@ var LIST_WORKFLOW_RUNS_ROUTE = createRoute({
   summary: "List workflow runs",
   description: "Returns a paginated list of execution runs for the specified workflow",
   tags: ["Workflows"],
-  handler: async ({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId }) => {
+  requiresAuth: true,
+  handler: (async ({ mastra, workflowId, fromDate, toDate, page, perPage, limit, offset, resourceId, status }) => {
     try {
       if (!workflowId) {
         throw new HTTPException(400, { message: "Workflow ID is required" });
       }
-      const perPage = limit;
-      const page = offset !== void 0 && typeof limit === "number" && limit !== 0 ? Math.floor(offset / limit) : 0;
-      if (perPage !== void 0 && (typeof perPage !== "number" || !Number.isInteger(perPage) || perPage <= 0)) {
-        throw new HTTPException(400, { message: "limit must be a positive integer" });
+      let finalPage = page;
+      let finalPerPage = perPage;
+      if (finalPerPage === void 0 && limit !== void 0) {
+        finalPerPage = limit;
+      }
+      if (finalPage === void 0 && offset !== void 0 && finalPerPage !== void 0 && finalPerPage > 0) {
+        finalPage = Math.floor(offset / finalPerPage);
       }
-      if (page !== void 0 && (!Number.isInteger(page) || page < 0)) {
+      if (finalPerPage !== void 0 && (typeof finalPerPage !== "number" || !Number.isInteger(finalPerPage) || finalPerPage <= 0)) {
+        throw new HTTPException(400, { message: "perPage must be a positive integer" });
+      }
+      if (finalPage !== void 0 && (!Number.isInteger(finalPage) || finalPage < 0)) {
         throw new HTTPException(400, { message: "page must be a non-negative integer" });
       }
       const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
@@ -213,9 +322,10 @@ var LIST_WORKFLOW_RUNS_ROUTE = createRoute({
       const workflowRuns = await workflow.listWorkflowRuns({
         fromDate: fromDate ? typeof fromDate === "string" ? new Date(fromDate) : fromDate : void 0,
         toDate: toDate ? typeof toDate === "string" ? new Date(toDate) : toDate : void 0,
-        perPage,
-        page,
-        resourceId
+        perPage: finalPerPage,
+        page: finalPage,
+        resourceId,
+        status
       }) || {
         runs: [],
         total: 0
@@ -224,18 +334,20 @@ var LIST_WORKFLOW_RUNS_ROUTE = createRoute({
     } catch (error) {
       return handleError(error, "Error getting workflow runs");
     }
-  }
+  })
 });
 var GET_WORKFLOW_RUN_BY_ID_ROUTE = createRoute({
   method: "GET",
-  path: "/api/workflows/:workflowId/runs/:runId",
+  path: "/workflows/:workflowId/runs/:runId",
   responseType: "json",
   pathParamSchema: workflowRunPathParams,
-  responseSchema: workflowRunResponseSchema,
+  queryParamSchema: workflowRunResultQuerySchema,
+  responseSchema: workflowRunResultSchema,
   summary: "Get workflow run by ID",
-  description: "Returns details for a specific workflow run",
+  description: "Returns a workflow run with metadata and processed execution state. Use the fields query parameter to reduce payload size by requesting only specific fields (e.g., ?fields=status,result,metadata)",
   tags: ["Workflows"],
-  handler: async ({ mastra, workflowId, runId }) => {
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, fields, withNestedWorkflows }) => {
     try {
       if (!workflowId) {
         throw new HTTPException(400, { message: "Workflow ID is required" });
@@ -247,7 +359,12 @@ var GET_WORKFLOW_RUN_BY_ID_ROUTE = createRoute({
       if (!workflow) {
         throw new HTTPException(404, { message: "Workflow not found" });
       }
-      const run = await workflow.getWorkflowRunById(runId);
+      const fieldList = fields ? fields.split(",").map((f) => f.trim()) : void 0;
+      const run = await workflow.getWorkflowRunById(runId, {
+        withNestedWorkflows: withNestedWorkflows !== "false",
+        // Default to true unless explicitly 'false'
+        fields: fieldList
+      });
       if (!run) {
         throw new HTTPException(404, { message: "Workflow run not found" });
       }
@@ -257,17 +374,48 @@ var GET_WORKFLOW_RUN_BY_ID_ROUTE = createRoute({
     }
   }
 });
+var DELETE_WORKFLOW_RUN_BY_ID_ROUTE = createRoute({
+  method: "DELETE",
+  path: "/workflows/:workflowId/runs/:runId",
+  responseType: "json",
+  pathParamSchema: workflowRunPathParams,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Delete workflow run by ID",
+  description: "Deletes a specific workflow run by ID",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "Run ID is required" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      await workflow.deleteWorkflowRunById(runId);
+      return { message: "Workflow run deleted" };
+    } catch (error) {
+      return handleError(error, "Error deleting workflow run");
+    }
+  }
+});
 var CREATE_WORKFLOW_RUN_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/create-run",
+  path: "/workflows/:workflowId/create-run",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: optionalRunIdSchema,
+  bodySchema: createWorkflowRunBodySchema,
   responseSchema: createWorkflowRunResponseSchema,
   summary: "Create workflow run",
   description: "Creates a new workflow execution instance with an optional custom run ID",
   tags: ["Workflows"],
-  handler: async ({ mastra, workflowId, runId }) => {
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, resourceId, disableScorers }) => {
     try {
       if (!workflowId) {
         throw new HTTPException(400, { message: "Workflow ID is required" });
@@ -276,7 +424,7 @@ var CREATE_WORKFLOW_RUN_ROUTE = createRoute({
       if (!workflow) {
         throw new HTTPException(404, { message: "Workflow not found" });
       }
-      const run = await workflow.createRun({ runId });
+      const run = await workflow.createRun({ runId, resourceId, disableScorers });
       return { runId: run.runId };
     } catch (error) {
       return handleError(error, "Error creating workflow run");
@@ -285,7 +433,7 @@ var CREATE_WORKFLOW_RUN_ROUTE = createRoute({
 });
 var STREAM_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/stream",
+  path: "/workflows/:workflowId/stream",
   responseType: "stream",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -293,7 +441,8 @@ var STREAM_WORKFLOW_ROUTE = createRoute({
   summary: "Stream workflow execution",
   description: "Executes a workflow and streams the results in real-time",
   tags: ["Workflows"],
-  handler: async ({ mastra, workflowId, runId, ...params }) => {
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, resourceId, ...params }) => {
     try {
       if (!workflowId) {
         throw new HTTPException(400, { message: "Workflow ID is required" });
@@ -306,7 +455,7 @@ var STREAM_WORKFLOW_ROUTE = createRoute({
         throw new HTTPException(404, { message: "Workflow not found" });
       }
       const serverCache = mastra.getServerCache();
-      const run = await workflow.createRun({ runId });
+      const run = await workflow.createRun({ runId, resourceId });
       const result = run.stream(params);
       return result.fullStream.pipeThrough(
         new TransformStream({
@@ -325,21 +474,9 @@ var STREAM_WORKFLOW_ROUTE = createRoute({
     }
   }
 });
-var STREAM_VNEXT_WORKFLOW_ROUTE = createRoute({
-  method: "POST",
-  path: "/api/workflows/:workflowId/streamVNext",
-  responseType: "stream",
-  pathParamSchema: workflowIdPathParams,
-  queryParamSchema: runIdSchema,
-  bodySchema: streamWorkflowBodySchema,
-  summary: "Stream workflow execution (v2)",
-  description: "Executes a workflow using the v2 streaming API and streams the results in real-time",
-  tags: ["Workflows"],
-  handler: STREAM_WORKFLOW_ROUTE.handler
-});
 var RESUME_STREAM_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/resume-stream",
+  path: "/workflows/:workflowId/resume-stream",
   responseType: "stream",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -348,6 +485,7 @@ var RESUME_STREAM_WORKFLOW_ROUTE = createRoute({
   summary: "Resume workflow stream",
   description: "Resumes a suspended workflow execution and continues streaming results",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -384,40 +522,9 @@ var RESUME_STREAM_WORKFLOW_ROUTE = createRoute({
     }
   }
 });
-var GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE = createRoute({
-  method: "GET",
-  path: "/api/workflows/:workflowId/runs/:runId/execution-result",
-  responseType: "json",
-  pathParamSchema: workflowRunPathParams,
-  responseSchema: workflowExecutionResultSchema,
-  summary: "Get workflow execution result",
-  description: "Returns the final execution result of a completed workflow run",
-  tags: ["Workflows"],
-  handler: async ({ mastra, workflowId, runId }) => {
-    try {
-      if (!workflowId) {
-        throw new HTTPException(400, { message: "Workflow ID is required" });
-      }
-      if (!runId) {
-        throw new HTTPException(400, { message: "Run ID is required" });
-      }
-      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
-      if (!workflow) {
-        throw new HTTPException(404, { message: "Workflow not found" });
-      }
-      const executionResult = await workflow.getWorkflowRunExecutionResult(runId);
-      if (!executionResult) {
-        throw new HTTPException(404, { message: "Workflow run execution result not found" });
-      }
-      return executionResult;
-    } catch (error) {
-      return handleError(error, "Error getting workflow run execution result");
-    }
-  }
-});
 var START_ASYNC_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/start-async",
+  path: "/workflows/:workflowId/start-async",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: optionalRunIdSchema,
@@ -426,6 +533,7 @@ var START_ASYNC_WORKFLOW_ROUTE = createRoute({
   summary: "Start workflow asynchronously",
   description: "Starts a workflow execution asynchronously without streaming results",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -445,7 +553,7 @@ var START_ASYNC_WORKFLOW_ROUTE = createRoute({
 });
 var START_WORKFLOW_RUN_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/start",
+  path: "/workflows/:workflowId/start",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -454,6 +562,7 @@ var START_WORKFLOW_RUN_ROUTE = createRoute({
   summary: "Start specific workflow run",
   description: "Starts execution of a specific workflow run by ID",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -482,7 +591,7 @@ var START_WORKFLOW_RUN_ROUTE = createRoute({
 });
 var OBSERVE_STREAM_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/observe",
+  path: "/workflows/:workflowId/observe",
   responseType: "stream",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -490,6 +599,7 @@ var OBSERVE_STREAM_WORKFLOW_ROUTE = createRoute({
   summary: "Observe workflow stream",
   description: "Observes and streams updates from an already running workflow execution",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId }) => {
     try {
       if (!workflowId) {
@@ -550,21 +660,9 @@ var OBSERVE_STREAM_WORKFLOW_ROUTE = createRoute({
     }
   }
 });
-var OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE = createRoute({
-  method: "POST",
-  path: "/api/workflows/:workflowId/observe-streamVNext",
-  responseType: "stream",
-  pathParamSchema: workflowIdPathParams,
-  queryParamSchema: runIdSchema,
-  responseSchema: streamResponseSchema,
-  summary: "Observe workflow stream (v2)",
-  description: "Observes and streams updates from an already running workflow execution using v2 streaming API",
-  tags: ["Workflows"],
-  handler: OBSERVE_STREAM_WORKFLOW_ROUTE.handler
-});
 var RESUME_ASYNC_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/resume-async",
+  path: "/workflows/:workflowId/resume-async",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -573,6 +671,7 @@ var RESUME_ASYNC_WORKFLOW_ROUTE = createRoute({
   summary: "Resume workflow asynchronously",
   description: "Resumes a suspended workflow execution asynchronously without streaming",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -599,7 +698,7 @@ var RESUME_ASYNC_WORKFLOW_ROUTE = createRoute({
 });
 var RESUME_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/resume",
+  path: "/workflows/:workflowId/resume",
   responseType: "json",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
@@ -608,6 +707,7 @@ var RESUME_WORKFLOW_ROUTE = createRoute({
   summary: "Resume workflow",
   description: "Resumes a suspended workflow execution from a specific step",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -632,15 +732,255 @@ var RESUME_WORKFLOW_ROUTE = createRoute({
     }
   }
 });
+var RESTART_ASYNC_WORKFLOW_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/restart-async",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: restartBodySchema,
+  responseSchema: workflowExecutionResultSchema,
+  summary: "Restart workflow asynchronously",
+  description: "Restarts an active workflow execution asynchronously",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, ...params }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "runId required to restart workflow" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      const run = await workflow.getWorkflowRunById(runId);
+      if (!run) {
+        throw new HTTPException(404, { message: "Workflow run not found" });
+      }
+      const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
+      const result = await _run.restart(params);
+      return result;
+    } catch (error) {
+      return handleError(error, "Error restarting workflow");
+    }
+  }
+});
+var RESTART_WORKFLOW_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/restart",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: restartBodySchema,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Restart workflow",
+  description: "Restarts an active workflow execution",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, ...params }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "runId required to restart workflow" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      const run = await workflow.getWorkflowRunById(runId);
+      if (!run) {
+        throw new HTTPException(404, { message: "Workflow run not found" });
+      }
+      const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
+      void _run.restart(params);
+      return { message: "Workflow run restarted" };
+    } catch (error) {
+      return handleError(error, "Error restarting workflow");
+    }
+  }
+});
+var RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/restart-all-active-workflow-runs-async",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Restart all active workflow runs asynchronously",
+  description: "Restarts all active workflow runs asynchronously",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      await workflow.restartAllActiveWorkflowRuns();
+      return { message: "All active workflow runs restarted" };
+    } catch (error) {
+      return handleError(error, "Error restarting workflow");
+    }
+  }
+});
+var RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/restart-all-active-workflow-runs",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Restart all active workflow runs",
+  description: "Restarts all active workflow runs",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      void workflow.restartAllActiveWorkflowRuns();
+      return { message: "All active workflow runs restarted" };
+    } catch (error) {
+      return handleError(error, "Error restarting workflow");
+    }
+  }
+});
+var TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/time-travel-async",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: timeTravelBodySchema,
+  responseSchema: workflowExecutionResultSchema,
+  summary: "Time travel workflow asynchronously",
+  description: "Time travels a workflow run asynchronously without streaming",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, ...params }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "runId required to time travel workflow" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      const run = await workflow.getWorkflowRunById(runId);
+      if (!run) {
+        throw new HTTPException(404, { message: "Workflow run not found" });
+      }
+      const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
+      const result = await _run.timeTravel(params);
+      return result;
+    } catch (error) {
+      return handleError(error, "Error time traveling workflow");
+    }
+  }
+});
+var TIME_TRAVEL_WORKFLOW_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/time-travel",
+  responseType: "json",
+  pathParamSchema: workflowIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: timeTravelBodySchema,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Time travel workflow",
+  description: "Time travels a workflow run, starting from a specific step",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, ...params }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "runId required to time travel workflow" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      const run = await workflow.getWorkflowRunById(runId);
+      if (!run) {
+        throw new HTTPException(404, { message: "Workflow run not found" });
+      }
+      const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
+      void _run.timeTravel(params);
+      return { message: "Workflow run time travel started" };
+    } catch (error) {
+      return handleError(error, "Error time traveling workflow");
+    }
+  }
+});
+var TIME_TRAVEL_STREAM_WORKFLOW_ROUTE = createRoute({
+  method: "POST",
+  path: "/workflows/:workflowId/time-travel-stream",
+  responseType: "stream",
+  pathParamSchema: workflowIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: timeTravelBodySchema,
+  summary: "Time travel workflow stream",
+  description: "Time travels a workflow run, starting from a specific step, and streams the results in real-time",
+  tags: ["Workflows"],
+  requiresAuth: true,
+  handler: async ({ mastra, workflowId, runId, ...params }) => {
+    try {
+      if (!workflowId) {
+        throw new HTTPException(400, { message: "Workflow ID is required" });
+      }
+      if (!runId) {
+        throw new HTTPException(400, { message: "runId required to time travel workflow stream" });
+      }
+      const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
+      if (!workflow) {
+        throw new HTTPException(404, { message: "Workflow not found" });
+      }
+      const serverCache = mastra.getServerCache();
+      const run = await workflow.createRun({ runId });
+      const result = run.timeTravelStream(params);
+      return result.fullStream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            if (serverCache) {
+              const cacheKey = runId;
+              serverCache.listPush(cacheKey, chunk).catch(() => {
+              });
+            }
+            controller.enqueue(chunk);
+          }
+        })
+      );
+    } catch (error) {
+      return handleError(error, "Error time traveling workflow stream");
+    }
+  }
+});
 var CANCEL_WORKFLOW_RUN_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/runs/:runId/cancel",
+  path: "/workflows/:workflowId/runs/:runId/cancel",
   responseType: "json",
   pathParamSchema: workflowRunPathParams,
   responseSchema: workflowControlResponseSchema,
   summary: "Cancel workflow run",
   description: "Cancels an in-progress workflow execution",
   tags: ["Workflows"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId }) => {
     try {
       if (!workflowId) {
@@ -667,15 +1007,16 @@ var CANCEL_WORKFLOW_RUN_ROUTE = createRoute({
 });
 var STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/stream-legacy",
+  path: "/workflows/:workflowId/stream-legacy",
   responseType: "stream",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
   bodySchema: streamWorkflowBodySchema,
   responseSchema: streamResponseSchema,
   summary: "[DEPRECATED] Stream workflow with legacy format",
-  description: "Legacy endpoint for streaming workflow execution. Use /api/workflows/:workflowId/stream instead.",
+  description: "Legacy endpoint for streaming workflow execution. Use /workflows/:workflowId/stream instead.",
   tags: ["Workflows", "Legacy"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId, ...params }) => {
     try {
       if (!workflowId) {
@@ -707,14 +1048,15 @@ var STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
 });
 var OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
   method: "POST",
-  path: "/api/workflows/:workflowId/observe-stream-legacy",
+  path: "/workflows/:workflowId/observe-stream-legacy",
   responseType: "stream",
   pathParamSchema: workflowIdPathParams,
   queryParamSchema: runIdSchema,
   responseSchema: streamResponseSchema,
   summary: "[DEPRECATED] Observe workflow stream with legacy format",
-  description: "Legacy endpoint for observing workflow stream. Use /api/workflows/:workflowId/observe instead.",
+  description: "Legacy endpoint for observing workflow stream. Use /workflows/:workflowId/observe instead.",
   tags: ["Workflows", "Legacy"],
+  requiresAuth: true,
   handler: async ({ mastra, workflowId, runId }) => {
     try {
       if (!workflowId) {
@@ -751,6 +1093,6 @@ var OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
   }
 });
 
-export { CANCEL_WORKFLOW_RUN_ROUTE, CREATE_WORKFLOW_RUN_ROUTE, GET_WORKFLOW_BY_ID_ROUTE, GET_WORKFLOW_RUN_BY_ID_ROUTE, GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE, LIST_WORKFLOWS_ROUTE, LIST_WORKFLOW_RUNS_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, RESUME_ASYNC_WORKFLOW_ROUTE, RESUME_STREAM_WORKFLOW_ROUTE, RESUME_WORKFLOW_ROUTE, START_ASYNC_WORKFLOW_ROUTE, START_WORKFLOW_RUN_ROUTE, STREAM_LEGACY_WORKFLOW_ROUTE, STREAM_VNEXT_WORKFLOW_ROUTE, STREAM_WORKFLOW_ROUTE, createWorkflowRunResponseSchema, listWorkflowRunsQuerySchema, listWorkflowsResponseSchema, resumeBodySchema, startAsyncWorkflowBodySchema, streamLegacyWorkflowBodySchema, streamWorkflowBodySchema, workflowControlResponseSchema, workflowExecutionResultSchema, workflowInfoSchema, workflowRunResponseSchema, workflowRunsResponseSchema, workflows_exports };
-//# sourceMappingURL=chunk-VQAT5HX6.js.map
-//# sourceMappingURL=chunk-VQAT5HX6.js.map
+export { CANCEL_WORKFLOW_RUN_ROUTE, CREATE_WORKFLOW_RUN_ROUTE, DELETE_WORKFLOW_RUN_BY_ID_ROUTE, GET_WORKFLOW_BY_ID_ROUTE, GET_WORKFLOW_RUN_BY_ID_ROUTE, LIST_WORKFLOWS_ROUTE, LIST_WORKFLOW_RUNS_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE, RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE, RESTART_ASYNC_WORKFLOW_ROUTE, RESTART_WORKFLOW_ROUTE, RESUME_ASYNC_WORKFLOW_ROUTE, RESUME_STREAM_WORKFLOW_ROUTE, RESUME_WORKFLOW_ROUTE, START_ASYNC_WORKFLOW_ROUTE, START_WORKFLOW_RUN_ROUTE, STREAM_LEGACY_WORKFLOW_ROUTE, STREAM_WORKFLOW_ROUTE, TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE, TIME_TRAVEL_STREAM_WORKFLOW_ROUTE, TIME_TRAVEL_WORKFLOW_ROUTE, createWorkflowRunResponseSchema, listWorkflowRunsQuerySchema, listWorkflowsResponseSchema, resumeBodySchema, startAsyncWorkflowBodySchema, streamLegacyWorkflowBodySchema, streamWorkflowBodySchema, workflowControlResponseSchema, workflowExecutionResultSchema, workflowInfoSchema, workflowRunResultQuerySchema, workflowRunResultSchema, workflowRunsResponseSchema, workflows_exports };
+//# sourceMappingURL=chunk-FDSHHJRG.js.map
+//# sourceMappingURL=chunk-FDSHHJRG.js.map