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

package/dist/server/handlers/workflows.js

@@ -1,1257 +1 @@
-import { r as __exportAll } from "../../rolldown-runtime-maW3aOIk.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-X1E7fW3p.js";
-import { n as createRoute } from "../../route-builder-BfQYtclb.js";
-import { a as getWorkflowInfo, t as WorkflowRegistry } from "../../utils-DCAUeb6M.js";
-import { handleError } from "./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) await validateRunOwnership(await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false }), 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) await validateRunOwnership(await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false }), 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;
-			return createReplayStream({
-				history: await serverCache.listFromTo(runId, startIndex),
-				liveSource: _run.observeStream()
-			});
-		} 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) await validateRunOwnership(await workflow.getWorkflowRunById(runId, { withNestedWorkflows: false }), 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 EXECUTE_WORKFLOW_STEP_ROUTE = createRoute({
-	method: "POST",
-	path: "/workflows/:workflowId/runs/:runId/steps/execute",
-	responseType: "json",
-	pathParamSchema: workflowRunPathParams,
-	bodySchema: stepExecutionBodySchema,
-	responseSchema: z.unknown(),
-	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;
-			await validateRunOwnership(await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
-				runId,
-				workflowName: workflowId
-			}), 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()
-});
-/**
-* 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: z.object({ event: workflowEventSchema.passthrough() }),
-	responseSchema: z.object({
-		ok: z.boolean(),
-		retry: z.boolean().optional()
-	}),
-	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;
-			await validateRunOwnership(await (await mastra.getStorage()?.getStore("workflows"))?.getWorkflowRunById({
-				runId: event.runId,
-				...typeof workflowName === "string" ? { workflowName } : {}
-			}), 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 { CANCEL_WORKFLOW_RUN_ROUTE, CREATE_WORKFLOW_RUN_ROUTE, DELETE_WORKFLOW_RUN_BY_ID_ROUTE, EXECUTE_WORKFLOW_STEP_ROUTE, GET_WORKFLOW_BY_ID_ROUTE, GET_WORKFLOW_RUN_BY_ID_ROUTE, LIST_WORKFLOWS_ROUTE, LIST_WORKFLOW_RUNS_ROUTE, LIST_WORKFLOW_RUN_COUNTS_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, RECEIVE_WORKFLOW_EVENT_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_NO_WAIT_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, __setWorkflowRunCountsNow, workflows_exports as t };
-
-//# sourceMappingURL=workflows.js.map
+export { t as CANCEL_WORKFLOW_RUN_ROUTE, n as CREATE_WORKFLOW_RUN_ROUTE, r as DELETE_WORKFLOW_RUN_BY_ID_ROUTE, i as EXECUTE_WORKFLOW_STEP_ROUTE, a as GET_WORKFLOW_BY_ID_ROUTE, o as GET_WORKFLOW_RUN_BY_ID_ROUTE, s as LIST_WORKFLOWS_ROUTE, c as LIST_WORKFLOW_RUNS_ROUTE, l as LIST_WORKFLOW_RUN_COUNTS_ROUTE, u as OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE, d as OBSERVE_STREAM_WORKFLOW_ROUTE, f as RECEIVE_WORKFLOW_EVENT_ROUTE, p as RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ASYNC_ROUTE, m as RESTART_ALL_ACTIVE_WORKFLOW_RUNS_ROUTE, h as RESTART_ASYNC_WORKFLOW_ROUTE, g as RESTART_WORKFLOW_ROUTE, _ as RESUME_ASYNC_WORKFLOW_ROUTE, v as RESUME_NO_WAIT_WORKFLOW_ROUTE, y as RESUME_STREAM_WORKFLOW_ROUTE, b as RESUME_WORKFLOW_ROUTE, x as START_ASYNC_WORKFLOW_ROUTE, S as START_WORKFLOW_RUN_ROUTE, C as STREAM_LEGACY_WORKFLOW_ROUTE, w as STREAM_WORKFLOW_ROUTE, T as TIME_TRAVEL_ASYNC_WORKFLOW_ROUTE, E as TIME_TRAVEL_STREAM_WORKFLOW_ROUTE, D as TIME_TRAVEL_WORKFLOW_ROUTE, O as __setWorkflowRunCountsNow } from "../../workflows-bb-otd2o.js";