@mastra/server 1.79.0-alpha.10 → 1.79.0-alpha.12

package/dist/workflows-bb-otd2o.js

@@ -0,0 +1,1273 @@
+import { r as __exportAll } from "./rolldown-runtime-D3Hj5m0v.js";
+import { t as HTTPException } from "./http-exception-CyfxZB6W.js";
+import { o as optionalRunIdSchema, u as runIdSchema } from "./common-Y30XtCyr.js";
+import { _ as workflowRunCountsResponseSchema, a as observeWorkflowQuerySchema, b as workflowRunResultSchema, d as streamWorkflowBodySchema, f as timeTravelBodySchema, g as workflowInfoSchema, h as workflowIdPathParams, i as listWorkflowsResponseSchema, l as startAsyncWorkflowBodySchema, m as workflowExecutionResultSchema, n as createWorkflowRunResponseSchema, o as restartBodySchema, p as workflowControlResponseSchema, r as listWorkflowRunsQuerySchema, s as resumeBodySchema, t as createWorkflowRunBodySchema, v as workflowRunPathParams, x as workflowRunsResponseSchema, y as workflowRunResultQuerySchema } from "./workflows-Dcx4Ib0t.js";
+import { Y as streamResponseSchema } from "./agents-BHLTMBff.js";
+import { n as createRoute } from "./route-builder-CjkWxv4E.js";
+import { a as getWorkflowInfo, t as WorkflowRegistry } from "./utils-aoLN3Wfi.js";
+import { handleError } from "./server/handlers/error.js";
+import { g as MastraFGAPermissions, i as getEffectiveResourceId, m as validateRunOwnership, o as getPublicWorkflowById } from "./utils-BBJlS81s.js";
+import { z } from "zod/v4";
+import { createReplayStream } from "@mastra/core/stream";
+//#region src/server/handlers/workflows.ts
+var workflows_exports = /* @__PURE__ */ __exportAll({
+	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,
+	EXECUTE_WORKFLOW_STEP_ROUTE: () => EXECUTE_WORKFLOW_STEP_ROUTE,
+	GET_WORKFLOW_BY_ID_ROUTE: () => GET_WORKFLOW_BY_ID_ROUTE,
+	GET_WORKFLOW_RUN_BY_ID_ROUTE: () => GET_WORKFLOW_RUN_BY_ID_ROUTE,
+	LIST_WORKFLOWS_ROUTE: () => LIST_WORKFLOWS_ROUTE,
+	LIST_WORKFLOW_RUNS_ROUTE: () => LIST_WORKFLOW_RUNS_ROUTE,
+	LIST_WORKFLOW_RUN_COUNTS_ROUTE: () => LIST_WORKFLOW_RUN_COUNTS_ROUTE,
+	OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE: () => OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE,
+	OBSERVE_STREAM_WORKFLOW_ROUTE: () => OBSERVE_STREAM_WORKFLOW_ROUTE,
+	RECEIVE_WORKFLOW_EVENT_ROUTE: () => RECEIVE_WORKFLOW_EVENT_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_NO_WAIT_WORKFLOW_ROUTE: () => RESUME_NO_WAIT_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_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,
+	__setWorkflowRunCountsNow: () => __setWorkflowRunCountsNow
+});
+/**
+* Statuses a run cannot come back from. Streaming one of these runIds again would
+* start a fresh execution under the same runId and overwrite its stored snapshot —
+* the in-memory de-dupe that protects concurrent streams only covers runs still held
+* in the workflow's run map, and a finished run has already been dropped from it.
+*/
+const TERMINAL_RUN_STATUSES = [
+	"success",
+	"failed",
+	"canceled",
+	"tripwire"
+];
+/**
+* Runs whose chunks are already being written to the cache in this process,
+* keyed by runId. A run has exactly one writer: without this, two concurrent
+* requests for the same runId each cache every chunk and the replayed history
+* comes back duplicated.
+*/
+const activeRunStreamCachers = /* @__PURE__ */ new Set();
+/**
+* Cache a run's chunks for later replay and return the stream to hand the client.
+*
+* The cached history belongs to the run, not to whoever happens to be watching,
+* so the caching side is driven by its own reader rather than by the client's
+* consumption. If the client disconnects mid-run its branch is cancelled while
+* this reader keeps draining, so `/observe` still replays a complete history —
+* the failure that makes reconnection necessary is exactly the one the cache has
+* to survive. Chunks buffer in the tee while a client lags, bounded by the run's
+* own length.
+*/
+function cacheRunStream({ cache, runId, source }) {
+	if (activeRunStreamCachers.has(runId)) return source;
+	const [toCache, toClient] = source.tee();
+	activeRunStreamCachers.add(runId);
+	(async () => {
+		const reader = toCache.getReader();
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				await cache.listPush(runId, value).catch(() => {});
+			}
+		} catch {} finally {
+			reader.releaseLock();
+			activeRunStreamCachers.delete(runId);
+		}
+	})();
+	return toClient;
+}
+async function listWorkflowsFromSystem({ mastra, workflowId }) {
+	const logger = mastra.getLogger();
+	if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+	let workflow;
+	workflow = WorkflowRegistry.getWorkflow(workflowId);
+	if (!workflow) workflow = getPublicWorkflowById(mastra, workflowId);
+	if (!workflow) {
+		logger.debug("Workflow not found, searching agents for workflow", { workflowId });
+		const agents = mastra.listAgents();
+		if (Object.keys(agents || {}).length) for (const [_, agent] of Object.entries(agents)) try {
+			const workflows = await agent.listWorkflows();
+			if (workflows[workflowId]) {
+				workflow = workflows[workflowId];
+				break;
+			}
+		} catch (error) {
+			logger.debug("Error getting workflow from agent", error);
+		}
+	}
+	if (!workflow) throw new HTTPException(404, { message: "Workflow not found" });
+	return { workflow };
+}
+const LIST_WORKFLOWS_ROUTE = createRoute({
+	method: "GET",
+	path: "/workflows",
+	responseType: "json",
+	queryParamSchema: z.object({ partial: z.string().optional() }),
+	responseSchema: listWorkflowsResponseSchema,
+	summary: "List all workflows",
+	description: "Returns a list of all available workflows in the system",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: (async ({ mastra, partial, requestContext }) => {
+		try {
+			const workflows = mastra.listWorkflows({ serialized: false });
+			const isPartial = partial === "true";
+			const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
+				acc[key] = getWorkflowInfo(workflow, isPartial);
+				return acc;
+			}, {});
+			const fgaProvider = mastra.getServer?.()?.fga;
+			const user = requestContext?.get("user");
+			if (fgaProvider) {
+				if (!user) return {};
+				const workflowList = Object.entries(_workflows).map(([id, w]) => ({
+					id,
+					...w
+				}));
+				const accessible = await fgaProvider.filterAccessible(user, workflowList, "workflow", MastraFGAPermissions.WORKFLOWS_READ);
+				const accessibleSet = new Set(accessible.map((w) => w.id));
+				for (const id of Object.keys(_workflows)) if (!accessibleSet.has(id)) delete _workflows[id];
+			}
+			return _workflows;
+		} catch (error) {
+			return handleError(error, "Error getting workflows");
+		}
+	})
+});
+const RUN_COUNTS_CACHE_TTL_MS = 5e3;
+const runCountsCache = /* @__PURE__ */ new WeakMap();
+let runCountsNow = () => Date.now();
+/** Test seam — lets TTL expiry be tested without wall-clock waits. */
+function __setWorkflowRunCountsNow(now) {
+	runCountsNow = now ?? (() => Date.now());
+}
+const LIST_WORKFLOW_RUN_COUNTS_ROUTE = createRoute({
+	method: "GET",
+	path: "/workflows/run-counts",
+	responseType: "json",
+	responseSchema: workflowRunCountsResponseSchema,
+	summary: "List workflow run counts",
+	description: "Returns per-workflow counts of currently running and suspended (awaiting resume) runs, keyed by the workflow registry key used in the Mastra config",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: (async ({ mastra, requestContext }) => {
+		try {
+			const fgaProvider = mastra.getServer?.()?.fga;
+			const user = requestContext?.get("user");
+			if (fgaProvider && !user) return {};
+			const workflows = mastra.listWorkflows({ serialized: false });
+			const counts = {};
+			const workflowIdToRegistryKey = /* @__PURE__ */ new Map();
+			for (const [registryKey, workflow] of Object.entries(workflows)) {
+				counts[registryKey] = {
+					running: 0,
+					suspended: 0
+				};
+				workflowIdToRegistryKey.set(workflow.id, registryKey);
+			}
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			const cacheable = !fgaProvider && !effectiveResourceId;
+			if (cacheable) {
+				const cached = runCountsCache.get(mastra);
+				if (cached && runCountsNow() - cached.at < RUN_COUNTS_CACHE_TTL_MS) return cached.value;
+			}
+			const storage = mastra.getStorage();
+			const workflowsStore = storage ? await storage.getStore("workflows") : void 0;
+			if (workflowsStore) {
+				const [running, suspended] = await Promise.all([workflowsStore.listWorkflowRuns({
+					status: "running",
+					resourceId: effectiveResourceId
+				}), workflowsStore.listWorkflowRuns({
+					status: "suspended",
+					resourceId: effectiveResourceId
+				})]);
+				for (const run of running.runs) {
+					const registryKey = workflowIdToRegistryKey.get(run.workflowName);
+					const entry = registryKey ? counts[registryKey] : void 0;
+					if (entry) entry.running++;
+				}
+				for (const run of suspended.runs) {
+					const registryKey = workflowIdToRegistryKey.get(run.workflowName);
+					const entry = registryKey ? counts[registryKey] : void 0;
+					if (entry) entry.suspended++;
+				}
+			}
+			if (fgaProvider) {
+				const workflowList = Object.keys(counts).map((id) => ({ id }));
+				const accessible = await fgaProvider.filterAccessible(user, workflowList, "workflow", MastraFGAPermissions.WORKFLOWS_READ);
+				const accessibleSet = new Set(accessible.map((w) => w.id));
+				for (const id of Object.keys(counts)) if (!accessibleSet.has(id)) delete counts[id];
+				return counts;
+			}
+			if (cacheable) runCountsCache.set(mastra, {
+				at: runCountsNow(),
+				value: counts
+			});
+			return counts;
+		} catch (error) {
+			return handleError(error, "Error getting workflow run counts");
+		}
+	})
+});
+const GET_WORKFLOW_BY_ID_ROUTE = createRoute({
+	method: "GET",
+	path: "/workflows/:workflowId",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	responseSchema: workflowInfoSchema,
+	summary: "Get workflow by ID",
+	description: "Returns details for a specific workflow",
+	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
+			});
+			return getWorkflowInfo(workflow, false);
+		} catch (error) {
+			return handleError(error, "Error getting workflow");
+		}
+	})
+});
+const LIST_WORKFLOW_RUNS_ROUTE = createRoute({
+	method: "GET",
+	path: "/workflows/:workflowId/runs",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: listWorkflowRunsQuerySchema,
+	responseSchema: workflowRunsResponseSchema,
+	summary: "List workflow runs",
+	description: "Returns a paginated list of execution runs for the specified workflow",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, fromDate, toDate, page, perPage, limit, offset, resourceId, status, summary, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, resourceId);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			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 (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
+			});
+			if (!workflow) throw new HTTPException(404, { message: "Workflow not found" });
+			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: finalPerPage,
+				page: finalPage,
+				resourceId: effectiveResourceId,
+				status,
+				...summary ? { summary: true } : {}
+			}) || {
+				runs: [],
+				total: 0
+			};
+			if (summary) return {
+				...workflowRuns,
+				runs: workflowRuns.runs.map((run) => ({
+					...run,
+					snapshot: toSummarySnapshot(run.snapshot)
+				}))
+			};
+			return workflowRuns;
+		} catch (error) {
+			return handleError(error, "Error getting workflow runs");
+		}
+	}
+});
+function toSummarySnapshot(snapshot) {
+	let parsed;
+	if (typeof snapshot === "string") try {
+		parsed = JSON.parse(snapshot);
+	} catch {
+		return "";
+	}
+	else parsed = snapshot;
+	if (!parsed || typeof parsed !== "object") return "";
+	const { status, timestamp } = parsed;
+	return {
+		status,
+		timestamp
+	};
+}
+const GET_WORKFLOW_RUN_BY_ID_ROUTE = createRoute({
+	method: "GET",
+	path: "/workflows/:workflowId/runs/:runId",
+	responseType: "json",
+	pathParamSchema: workflowRunPathParams,
+	queryParamSchema: workflowRunResultQuerySchema,
+	responseSchema: workflowRunResultSchema,
+	summary: "Get workflow run by ID",
+	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=result,steps). Available fields: result, error, payload, steps, activeStepsPath, serializedStepGraph. Metadata fields (runId, workflowName, resourceId, createdAt, updatedAt) and status are always included.",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, fields, withNestedWorkflows, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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 fieldList = fields ? fields.split(",").map((f) => f.trim()) : void 0;
+			const run = await workflow.getWorkflowRunById(runId, {
+				withNestedWorkflows: withNestedWorkflows !== "false",
+				fields: fieldList
+			});
+			if (!run) throw new HTTPException(404, { message: "Workflow run not found" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			return run;
+		} catch (error) {
+			return handleError(error, "Error getting workflow run");
+		}
+	}
+});
+const 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, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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 run = await workflow.getWorkflowRunById(runId);
+			if (!run) throw new HTTPException(404, { message: "Workflow run not found" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			await workflow.deleteWorkflowRunById(runId);
+			return { message: "Workflow run deleted" };
+		} catch (error) {
+			return handleError(error, "Error deleting workflow run");
+		}
+	}
+});
+const CREATE_WORKFLOW_RUN_ROUTE = createRoute({
+	method: "POST",
+	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"],
+	requiresAuth: true,
+	requiresPermission: ["workflows:write", "workflows:execute"],
+	handler: async ({ mastra, workflowId, runId, resourceId, disableScorers, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, resourceId);
+			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" });
+			if (runId) {
+				const existingRun = await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false });
+				await validateRunOwnership(existingRun, getEffectiveResourceId(requestContext, void 0), mastra);
+			}
+			return { runId: (await workflow.createRun({
+				runId,
+				resourceId: effectiveResourceId,
+				disableScorers
+			})).runId };
+		} catch (error) {
+			return handleError(error, "Error creating workflow run");
+		}
+	}
+});
+const STREAM_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/stream",
+	responseType: "stream",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: streamWorkflowBodySchema,
+	summary: "Stream workflow execution",
+	description: "Executes a workflow and streams the results in real-time",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, resourceId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, resourceId);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to stream workflow" });
+			const { workflow } = await listWorkflowsFromSystem({
+				mastra,
+				workflowId
+			});
+			if (!workflow) throw new HTTPException(404, { message: "Workflow not found" });
+			const existingRun = await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false });
+			await validateRunOwnership(existingRun, getEffectiveResourceId(requestContext, void 0), mastra);
+			if (existingRun && TERMINAL_RUN_STATUSES.includes(existingRun.status)) throw new HTTPException(409, { message: `Workflow run ${runId} already finished with status "${existingRun.status}". Use /observe to read its stream back, or stream a new runId.` });
+			const serverCache = mastra.getServerCache();
+			const result = (await workflow.createRun({
+				runId,
+				resourceId: effectiveResourceId
+			})).stream({
+				...params,
+				requestContext
+			});
+			if (serverCache) return cacheRunStream({
+				cache: serverCache,
+				runId,
+				source: result.fullStream
+			});
+			return result.fullStream;
+		} catch (error) {
+			return handleError(error, "Error streaming workflow");
+		}
+	}
+});
+const RESUME_STREAM_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/resume-stream",
+	responseType: "stream",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: resumeBodySchema,
+	responseSchema: streamResponseSchema,
+	summary: "Resume workflow stream",
+	description: "Resumes a suspended workflow execution and continues streaming results",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to resume 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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			const _run = await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			});
+			const serverCache = mastra.getServerCache();
+			const resumeResult = _run.resumeStream({
+				...params,
+				requestContext
+			});
+			if (serverCache) return cacheRunStream({
+				cache: serverCache,
+				runId,
+				source: resumeResult.fullStream
+			});
+			return resumeResult.fullStream;
+		} catch (error) {
+			return handleError(error, "Error resuming workflow");
+		}
+	}
+});
+const START_ASYNC_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/start-async",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: optionalRunIdSchema,
+	bodySchema: startAsyncWorkflowBodySchema,
+	responseSchema: workflowExecutionResultSchema,
+	summary: "Start workflow asynchronously",
+	description: "Starts a workflow execution asynchronously without streaming results",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, resourceId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, resourceId);
+			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" });
+			if (runId) {
+				const existingRun = await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false });
+				await validateRunOwnership(existingRun, getEffectiveResourceId(requestContext, void 0), mastra);
+			}
+			return await (await workflow.createRun({
+				runId,
+				resourceId: effectiveResourceId
+			})).start({
+				...params,
+				requestContext
+			});
+		} catch (error) {
+			return handleError(error, "Error starting async workflow");
+		}
+	}
+});
+const START_WORKFLOW_RUN_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/start",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: startAsyncWorkflowBodySchema,
+	responseSchema: workflowControlResponseSchema,
+	summary: "Start specific workflow run",
+	description: "Starts execution of a specific workflow run by ID",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to start run" });
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			(await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).start({
+				...params,
+				requestContext
+			}).catch((error) => {
+				mastra.getLogger().error("Failed to start workflow run", {
+					error,
+					workflowId,
+					runId
+				});
+			});
+			return { message: "Workflow run started" };
+		} catch (e) {
+			return handleError(e, "Error starting workflow run");
+		}
+	}
+});
+const OBSERVE_STREAM_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/observe",
+	responseType: "stream",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: observeWorkflowQuerySchema,
+	responseSchema: streamResponseSchema,
+	summary: "Observe workflow stream",
+	description: "Observes and streams updates from an already running workflow execution. Supports position-based resume with offset for efficient reconnection.",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, offset, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to observe workflow stream" });
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			const _run = await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			});
+			const serverCache = mastra.getServerCache();
+			if (!serverCache) throw new HTTPException(500, { message: "Server cache not found" });
+			const startIndex = offset ?? 0;
+			const cachedRunChunks = await serverCache.listFromTo(runId, startIndex);
+			const liveStream = _run.observeStream();
+			return createReplayStream({
+				history: cachedRunChunks,
+				liveSource: liveStream
+			});
+		} catch (error) {
+			return handleError(error, "Error observing workflow stream");
+		}
+	}
+});
+const RESUME_ASYNC_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/resume-async",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: resumeBodySchema,
+	responseSchema: workflowExecutionResultSchema,
+	summary: "Resume workflow asynchronously",
+	description: "Resumes a suspended workflow execution asynchronously without streaming",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to resume 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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			return await (await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).resume({
+				...params,
+				requestContext
+			});
+		} catch (error) {
+			return handleError(error, "Error resuming workflow step");
+		}
+	}
+});
+/**
+* Fire-and-forget resume: dispatches the resume and returns immediately with the runId,
+* without waiting for the workflow to complete. For Inngest-backed workflows this avoids
+* the `getRunOutput()` polling race that the awaiting `resume-async` route can hit.
+*
+* TODO(v2): in Mastra v2 this fire-and-forget behavior should become the behavior of the
+* `resume-async` route (and `Run.resumeAsync()`), and this route should be removed. It is
+* kept separate in v1 to avoid a breaking change to the existing `resume-async` response
+* contract (which returns the full workflow result).
+*/
+const RESUME_NO_WAIT_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/resume-no-wait",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: resumeBodySchema,
+	responseSchema: createWorkflowRunResponseSchema,
+	summary: "Resume workflow without waiting",
+	description: "Resumes a suspended workflow execution without waiting (fire-and-forget) and returns immediately with the runId. The workflow continues executing in the background.",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to resume 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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			return await (await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).resumeAsync({
+				...params,
+				requestContext
+			});
+		} catch (error) {
+			return handleError(error, "Error resuming workflow step");
+		}
+	}
+});
+const RESUME_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/resume",
+	responseType: "json",
+	pathParamSchema: workflowIdPathParams,
+	queryParamSchema: runIdSchema,
+	bodySchema: resumeBodySchema,
+	responseSchema: workflowControlResponseSchema,
+	summary: "Resume workflow",
+	description: "Resumes a suspended workflow execution from a specific step",
+	tags: ["Workflows"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to resume 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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			(await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).resume({
+				...params,
+				requestContext
+			}).catch((error) => {
+				mastra.getLogger().error("Failed to resume workflow run", {
+					error,
+					workflowId,
+					runId
+				});
+			});
+			return { message: "Workflow run resumed" };
+		} catch (error) {
+			return handleError(error, "Error resuming workflow");
+		}
+	}
+});
+const 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, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			return await (await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).restart({
+				...params,
+				requestContext
+			});
+		} catch (error) {
+			return handleError(error, "Error restarting workflow");
+		}
+	}
+});
+const 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, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			(await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).restart({
+				...params,
+				requestContext
+			}).catch((error) => {
+				mastra.getLogger().error("Failed to restart workflow run in background", {
+					error,
+					workflowId,
+					runId
+				});
+			});
+			return { message: "Workflow run restarted" };
+		} catch (error) {
+			return handleError(error, "Error restarting workflow");
+		}
+	}
+});
+const 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, requestContext }) => {
+		try {
+			await validateRunOwnership({ resourceId: null }, getEffectiveResourceId(requestContext, void 0), mastra);
+			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");
+		}
+	}
+});
+const 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, requestContext }) => {
+		try {
+			await validateRunOwnership({ resourceId: null }, getEffectiveResourceId(requestContext, void 0), mastra);
+			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" });
+			workflow.restartAllActiveWorkflowRuns().catch((error) => {
+				mastra.getLogger().error("Failed to restart active workflow runs", {
+					error,
+					workflowId
+				});
+			});
+			return { message: "All active workflow runs restarted" };
+		} catch (error) {
+			return handleError(error, "Error restarting workflow");
+		}
+	}
+});
+const 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, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			return await (await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).timeTravel({
+				...params,
+				requestContext
+			});
+		} catch (error) {
+			return handleError(error, "Error time traveling workflow");
+		}
+	}
+});
+const 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, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			(await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).timeTravel({
+				...params,
+				requestContext
+			}).catch((error) => {
+				mastra.getLogger().error("Failed to time travel workflow run", {
+					error,
+					workflowId,
+					runId
+				});
+			});
+			return { message: "Workflow run time travel started" };
+		} catch (error) {
+			return handleError(error, "Error time traveling workflow");
+		}
+	}
+});
+const 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, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			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 existingRun = await workflow.getWorkflowRunById(runId);
+			if (!existingRun) throw new HTTPException(404, { message: "Workflow run not found" });
+			await validateRunOwnership(existingRun, effectiveResourceId, mastra);
+			const serverCache = mastra.getServerCache();
+			const result = (await workflow.createRun({
+				runId,
+				resourceId: existingRun.resourceId
+			})).timeTravelStream({
+				...params,
+				requestContext
+			});
+			if (serverCache) return cacheRunStream({
+				cache: serverCache,
+				runId,
+				source: result.fullStream
+			});
+			return result.fullStream;
+		} catch (error) {
+			return handleError(error, "Error time traveling workflow stream");
+		}
+	}
+});
+const CANCEL_WORKFLOW_RUN_ROUTE = createRoute({
+	method: "POST",
+	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, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to cancel workflow run" });
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			await (await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			})).cancel();
+			return { message: "Workflow run cancelled" };
+		} catch (error) {
+			return handleError(error, "Error canceling workflow run");
+		}
+	}
+});
+const STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	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 /workflows/:workflowId/stream instead.",
+	tags: ["Workflows", "Legacy"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, resourceId, requestContext, ...params }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, resourceId);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to resume workflow" });
+			const { workflow } = await listWorkflowsFromSystem({
+				mastra,
+				workflowId
+			});
+			if (!workflow) throw new HTTPException(404, { message: "Workflow not found" });
+			const serverCache = mastra.getServerCache();
+			if (runId) {
+				const existingRun = await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false });
+				await validateRunOwnership(existingRun, getEffectiveResourceId(requestContext, void 0), mastra);
+			}
+			return (await workflow.createRun({
+				runId,
+				resourceId: effectiveResourceId
+			})).streamLegacy({
+				...params,
+				requestContext,
+				onChunk: async (chunk) => {
+					if (serverCache) {
+						const cacheKey = runId;
+						await serverCache.listPush(cacheKey, chunk);
+					}
+				}
+			}).stream;
+		} catch (error) {
+			return handleError(error, "Error executing workflow");
+		}
+	}
+});
+const OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE = createRoute({
+	method: "POST",
+	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 /workflows/:workflowId/observe instead.",
+	tags: ["Workflows", "Legacy"],
+	requiresAuth: true,
+	handler: async ({ mastra, workflowId, runId, requestContext }) => {
+		try {
+			const effectiveResourceId = getEffectiveResourceId(requestContext, void 0);
+			if (!workflowId) throw new HTTPException(400, { message: "Workflow ID is required" });
+			if (!runId) throw new HTTPException(400, { message: "runId required to observe workflow stream" });
+			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" });
+			await validateRunOwnership(run, effectiveResourceId, mastra);
+			const _run = await workflow.createRun({
+				runId,
+				resourceId: run.resourceId
+			});
+			const serverCache = mastra.getServerCache();
+			if (!serverCache) throw new HTTPException(500, { message: "Server cache not found" });
+			const cachedRunChunks = await serverCache.listFromTo(runId, 0);
+			const result = _run.observeStreamLegacy();
+			if (!result.stream) throw new HTTPException(500, { message: "Failed to create observe stream" });
+			return createReplayStream({
+				history: cachedRunChunks,
+				liveSource: result.stream
+			});
+		} catch (error) {
+			return handleError(error, "Error observing workflow stream");
+		}
+	}
+});
+const stepExecutionParentWorkflowSchema = z.lazy(() => z.object({
+	workflowId: z.string(),
+	runId: z.string(),
+	executionPath: z.array(z.number().int().nonnegative()),
+	parentWorkflow: stepExecutionParentWorkflowSchema.optional()
+}));
+const stepExecutionBodySchema = z.object({
+	stepId: z.string(),
+	executionPath: z.array(z.number().int().nonnegative()),
+	parentWorkflow: stepExecutionParentWorkflowSchema.optional(),
+	stepResults: z.record(z.string(), z.unknown()),
+	state: z.record(z.string(), z.unknown()),
+	requestContext: z.record(z.string(), z.unknown()),
+	input: z.unknown().optional(),
+	resumeData: z.unknown().optional(),
+	retryCount: z.number().int().nonnegative().optional(),
+	foreachIdx: z.number().int().nonnegative().optional(),
+	format: z.enum(["legacy", "vnext"]).optional(),
+	perStep: z.boolean().optional(),
+	validateInputs: z.boolean().optional()
+});
+const strategyByMastra = /* @__PURE__ */ new WeakMap();
+async function getStepStrategy(mastra) {
+	let cached = strategyByMastra.get(mastra);
+	if (!cached) {
+		const { InProcessStrategy } = await import("@mastra/core/worker");
+		cached = new InProcessStrategy({ mastra });
+		strategyByMastra.set(mastra, cached);
+	}
+	return cached;
+}
+const stepExecutionResponseSchema = z.unknown();
+const EXECUTE_WORKFLOW_STEP_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/:workflowId/runs/:runId/steps/execute",
+	responseType: "json",
+	pathParamSchema: workflowRunPathParams,
+	bodySchema: stepExecutionBodySchema,
+	responseSchema: stepExecutionResponseSchema,
+	summary: "Execute a workflow step",
+	description: "Internal endpoint used by standalone OrchestrationWorker instances to execute workflow steps remotely via HttpRemoteStrategy.",
+	tags: ["Workflows", "Worker"],
+	requiresAuth: true,
+	handler: (async ({ mastra, workflowId, runId, ...body }) => {
+		try {
+			const candidate = body.requestContext;
+			const serverRequestContext = typeof candidate?.get === "function" ? candidate : void 0;
+			const existingRun = await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
+				runId,
+				workflowName: workflowId
+			});
+			await validateRunOwnership(existingRun, getEffectiveResourceId(serverRequestContext, void 0), mastra);
+			return await (await getStepStrategy(mastra)).executeStep({
+				workflowId,
+				runId,
+				stepId: body.stepId,
+				executionPath: body.executionPath,
+				parentWorkflow: body.parentWorkflow,
+				stepResults: body.stepResults,
+				state: body.state,
+				requestContext: body.requestContext,
+				input: body.input,
+				resumeData: body.resumeData,
+				retryCount: body.retryCount,
+				foreachIdx: body.foreachIdx,
+				format: body.format,
+				perStep: body.perStep,
+				validateInputs: body.validateInputs
+			});
+		} catch (error) {
+			return handleError(error, "Error executing workflow step");
+		}
+	})
+});
+const workflowEventSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	data: z.unknown(),
+	runId: z.string(),
+	createdAt: z.string(),
+	index: z.number().optional(),
+	deliveryAttempt: z.number().optional()
+});
+const receiveWorkflowEventBodySchema = z.object({ event: workflowEventSchema.passthrough() });
+const receiveWorkflowEventResponseSchema = z.object({
+	ok: z.boolean(),
+	retry: z.boolean().optional()
+});
+/**
+* Generic push receive endpoint for workflow events. A push-mode broker
+* (GCP Pub/Sub push subscription, SNS, EventBridge) — or a per-broker adapter
+* that decodes the broker's envelope first — POSTs each event here and the
+* response code tells the broker whether to retry:
+*
+*   - 200/204 → ack
+*   - 5xx     → transient, retry with backoff
+*   - 4xx     → poison, drop / send to DLQ
+*
+* Auth is enforced through the framework's standard `requiresAuth` flow.
+* Operators MUST configure an `authenticateToken` provider that recognizes
+* whatever credential the broker attaches (e.g. a Google-signed OIDC token
+* for GCP Pub/Sub push). Without an auth provider the endpoint is effectively
+* public — same caveat as `EXECUTE_WORKFLOW_STEP_ROUTE`.
+*/
+const RECEIVE_WORKFLOW_EVENT_ROUTE = createRoute({
+	method: "POST",
+	path: "/workflows/events",
+	responseType: "json",
+	bodySchema: receiveWorkflowEventBodySchema,
+	responseSchema: receiveWorkflowEventResponseSchema,
+	summary: "Receive a workflow event from a push-mode broker",
+	description: "Push-mode entry point for workflow events. Brokers (GCP Pub/Sub push, SNS, EventBridge) POST each event here; Mastra processes it through the same pipeline as pull-mode workers.",
+	tags: ["Workflows", "Worker"],
+	requiresAuth: true,
+	requiresPermission: ["workflows:write", "workflows:execute"],
+	handler: (async ({ mastra, event, requestContext }) => {
+		try {
+			const workflowName = event.data?.workflowId;
+			const existingRun = await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
+				runId: event.runId,
+				...typeof workflowName === "string" ? { workflowName } : {}
+			});
+			await validateRunOwnership(existingRun, getEffectiveResourceId(requestContext, void 0), mastra);
+			const rawCreatedAt = event.createdAt;
+			const createdAt = rawCreatedAt instanceof Date ? rawCreatedAt : new Date(rawCreatedAt);
+			if (Number.isNaN(createdAt.getTime())) throw new HTTPException(400, { message: "Invalid createdAt" });
+			return await mastra.handleWorkflowEvent({
+				...event,
+				createdAt
+			});
+		} catch (error) {
+			return handleError(error, "Error receiving workflow event");
+		}
+	})
+});
+//#endregion
+export { STREAM_LEGACY_WORKFLOW_ROUTE as C, TIME_TRAVEL_WORKFLOW_ROUTE as D, TIME_TRAVEL_STREAM_WORKFLOW_ROUTE as E, __setWorkflowRunCountsNow as O, START_WORKFLOW_RUN_ROUTE as S, TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE as T, RESUME_ASYNC_WORKFLOW_ROUTE as _, GET_WORKFLOW_BY_ID_ROUTE as a, RESUME_WORKFLOW_ROUTE as b, LIST_WORKFLOW_RUNS_ROUTE as c, OBSERVE_STREAM_WORKFLOW_ROUTE as d, RECEIVE_WORKFLOW_EVENT_ROUTE as f, RESTART_WORKFLOW_ROUTE as g, RESTART_ASYNC_WORKFLOW_ROUTE as h, EXECUTE_WORKFLOW_STEP_ROUTE as i, workflows_exports as k, LIST_WORKFLOW_RUN_COUNTS_ROUTE as l, RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE as m, CREATE_WORKFLOW_RUN_ROUTE as n, GET_WORKFLOW_RUN_BY_ID_ROUTE as o, RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE as p, DELETE_WORKFLOW_RUN_BY_ID_ROUTE as r, LIST_WORKFLOWS_ROUTE as s, CANCEL_WORKFLOW_RUN_ROUTE as t, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE as u, RESUME_NO_WAIT_WORKFLOW_ROUTE as v, STREAM_WORKFLOW_ROUTE as w, START_ASYNC_WORKFLOW_ROUTE as x, RESUME_STREAM_WORKFLOW_ROUTE as y };
+
+//# sourceMappingURL=workflows-bb-otd2o.js.map