@mastra/server 1.57.0 → 1.58.0-alpha.1

package/dist/{a2a-DKnwIgiw.cjs → a2a-D3ZYeXIx.cjs}

@@ -2,6 +2,7 @@ const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
 const require_route_builder = require("./route-builder-CgLVYL1c.cjs");
 const require_utils = require("./utils-wESuBh27.cjs");
 const require_server_handlers_agents = require("./server/handlers/agents.cjs");
+const require_server_a2a_store = require("./server/a2a/store.cjs");
 const require_a2a = require("./a2a-oM7aqLz4.cjs");
 const require_server_handlers_auth = require("./server/handlers/auth.cjs");
 let zod_v4 = require("zod/v4");
@@ -118,7 +119,7 @@ function createErrorResponse(id, error) {
 	};
 }
 function createSuccessResponse(id, result) {
-	if (!id) throw _mastra_core_a2a.MastraA2AError.internalError("Cannot create success response for null ID.");
+	if (id === null) throw _mastra_core_a2a.MastraA2AError.internalError("Cannot create success response for null ID.");
 	return {
 		jsonrpc: "2.0",
 		id,
@@ -306,6 +307,14 @@ var InMemoryPushNotificationStore = class {
 	}
 };
 //#endregion
+//#region src/server/a2a/task-state.ts
+function isTerminalTaskState(state) {
+	return state === "completed" || state === "failed" || state === "canceled" || state === "rejected";
+}
+function isInterruptedTaskState(state) {
+	return state === "input-required" || state === "auth-required";
+}
+//#endregion
 //#region src/server/a2a/tasks.ts
 function isTaskStatusUpdate(update) {
 	return "state" in update && !("parts" in update);
@@ -341,54 +350,63 @@ function applyUpdateToTask(current, update) {
 	return newTask;
 }
 async function loadOrCreateTask({ agentId, taskId, taskStore, message, contextId, metadata, logger }) {
-	const data = await taskStore.load({
-		agentId,
-		taskId
-	});
-	if (!data) {
-		const initialTask = {
-			id: taskId,
-			contextId: contextId || crypto.randomUUID(),
-			status: {
-				state: "submitted",
-				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-				message: void 0
-			},
-			artifacts: [],
-			history: [message],
-			metadata,
-			kind: "task"
-		};
-		logger?.info(`[Task ${taskId}] Created new task.`);
-		await taskStore.save({
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const snapshot = taskStore.loadWithVersion({
 			agentId,
-			data: initialTask
+			taskId
 		});
-		return initialTask;
+		const data = snapshot?.task;
+		if (!data) {
+			const initialTask = {
+				id: taskId,
+				contextId: contextId || crypto.randomUUID(),
+				status: {
+					state: "submitted",
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					message: void 0
+				},
+				artifacts: [],
+				history: [message],
+				metadata,
+				kind: "task"
+			};
+			logger?.info(`[Task ${taskId}] Created new task.`);
+			try {
+				await taskStore.save({
+					agentId,
+					data: initialTask,
+					expectedVersion: 0
+				});
+				return initialTask;
+			} catch (error) {
+				if (error instanceof require_server_a2a_store.TaskStoreVersionConflictError) continue;
+				throw error;
+			}
+		}
+		logger?.info(`[Task ${taskId}] Loaded existing task.`);
+		const { status } = data;
+		if (isTerminalTaskState(status.state)) throw _mastra_core_a2a.MastraA2AError.invalidRequest(`Task ${taskId} is in terminal state ${status.state} and cannot be restarted.`);
+		let updatedData = {
+			...data,
+			history: [...data.history || [], message]
+		};
+		if (status.state === "input-required" || status.state === "auth-required") {
+			logger?.info(`[Task ${taskId}] Changing state from '${status.state}' to 'working'.`);
+			updatedData = applyUpdateToTask(updatedData, { state: "working" });
+		} else if (status.state === "working") logger?.warn(`[Task ${taskId}] Received message while already 'working'. Proceeding.`);
+		try {
+			await taskStore.save({
+				agentId,
+				data: updatedData,
+				expectedVersion: snapshot.version
+			});
+			return updatedData;
+		} catch (error) {
+			if (error instanceof require_server_a2a_store.TaskStoreVersionConflictError) continue;
+			throw error;
+		}
 	}
-	logger?.info(`[Task ${taskId}] Loaded existing task.`);
-	let updatedData = data;
-	updatedData.history = [...data.history || [], message];
-	const { status } = data;
-	if ([
-		"completed",
-		"failed",
-		"canceled"
-	].includes(status.state)) {
-		logger?.warn(`[Task ${taskId}] Received message for task in final state ${status.state}. Restarting.`);
-		updatedData = applyUpdateToTask(updatedData, {
-			state: "submitted",
-			message: void 0
-		});
-	} else if (status.state === "input-required") {
-		logger?.info(`[Task ${taskId}] Changing state from 'input-required' to 'working'.`);
-		updatedData = applyUpdateToTask(updatedData, { state: "working" });
-	} else if (status.state === "working") logger?.warn(`[Task ${taskId}] Received message while already 'working'. Proceeding.`);
-	await taskStore.save({
-		agentId,
-		data: updatedData
-	});
-	return updatedData;
+	throw _mastra_core_a2a.MastraA2AError.invalidRequest(`Task ${taskId} was updated concurrently. Retry the request.`);
 }
 //#endregion
 //#region src/server/handlers/a2a.ts
@@ -575,6 +593,176 @@ function createDataArtifactUpdate({ taskId, contextId, data, lastChunk }) {
 		}
 	};
 }
+/**
+* Task metadata keys that store the resume bookkeeping for a suspended agent
+* run so a follow-up message for an `input-required` task can resume it.
+*/
+const SUSPENDED_RUN_ID_METADATA_KEY = "suspendedRunId";
+const SUSPENDED_TOOL_CALL_ID_METADATA_KEY = "suspendedToolCallId";
+const SUSPENDED_REQUIRES_APPROVAL_METADATA_KEY = "suspendedRequiresApproval";
+function toJsonSafe(value) {
+	if (value === void 0) return;
+	try {
+		return JSON.parse(JSON.stringify(value));
+	} catch {
+		return;
+	}
+}
+/**
+* Builds the `input-required` status update for a suspended agent run.
+* The status message carries a human-readable prompt plus a data part with
+* the structured suspend payload and resume schema so A2A clients can
+* render/collect the required input (HITL per the A2A spec).
+*/
+function createInputRequiredStatusUpdate({ taskId, contextId, suspendPayload, resumeSchema, logger }) {
+	const extractMessage = (value) => {
+		if (!value || typeof value !== "object") return;
+		const messageValue = value.message;
+		return typeof messageValue === "string" && messageValue.length > 0 ? messageValue : void 0;
+	};
+	const promptText = extractMessage(suspendPayload) ?? extractMessage(suspendPayload?.suspendPayload) ?? "Additional input is required to continue this task.";
+	const safeSuspendPayload = toJsonSafe(suspendPayload);
+	const safeResumeSchema = toJsonSafe(resumeSchema);
+	if (suspendPayload !== void 0 && safeSuspendPayload === void 0) logger?.warn(`[Task ${taskId}] Suspend payload is not JSON-serializable and was omitted from the status message.`);
+	if (resumeSchema !== void 0 && safeResumeSchema === void 0) logger?.warn(`[Task ${taskId}] Resume schema is not JSON-serializable and was omitted from the status message.`);
+	const data = {
+		...safeSuspendPayload !== void 0 ? { suspendPayload: safeSuspendPayload } : {},
+		...safeResumeSchema !== void 0 ? { resumeSchema: safeResumeSchema } : {}
+	};
+	return {
+		state: "input-required",
+		message: {
+			messageId: crypto.randomUUID(),
+			kind: "message",
+			role: "agent",
+			taskId,
+			contextId,
+			parts: [{
+				kind: "text",
+				text: promptText
+			}, ...Object.keys(data).length > 0 ? [{
+				kind: "data",
+				data
+			}] : []]
+		}
+	};
+}
+/**
+* Extracts resume data from a follow-up message for an `input-required` task.
+* Prefers a structured data part; falls back to parsing the text as JSON
+* (the Mastra A2A client serializes structured resume data as JSON text),
+* and finally to the raw text.
+*/
+function extractResumeData(message) {
+	const dataPart = message.parts.find((part) => part.kind === "data");
+	if (dataPart && "data" in dataPart) return dataPart.data;
+	const text = message.parts.filter((part) => part.kind === "text").map((part) => part.text).join("\n").trim();
+	if (!text) return;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function getSuspendedRunId(task) {
+	const value = task?.metadata?.[SUSPENDED_RUN_ID_METADATA_KEY];
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Approval suspensions (`requireApproval`) carry `{ toolCallId, toolName, args, resumeSchema }`
+* without a nested `suspendPayload`, while `suspend()` suspensions include one
+* (see `ToolCallApprovalPayload` / `ToolCallSuspendedPayload` in @mastra/core).
+*/
+function isApprovalSuspension(suspendPayload) {
+	if (!suspendPayload || typeof suspendPayload !== "object") return false;
+	const payload = suspendPayload;
+	return typeof payload.toolCallId === "string" && payload.suspendPayload === void 0;
+}
+const APPROVAL_AFFIRMATIVE_PATTERN = /^(y|yes|approve|approved|ok|okay|confirm|confirmed|true)[.!]?$/i;
+const APPROVAL_NEGATIVE_PATTERN = /^(n|no|decline|declined|deny|denied|reject|rejected|false)[.!]?$/i;
+/**
+* Approval resumes are driven by `resumeData.approved` in the agentic loop, so
+* plain-text replies from A2A clients ("yes", "no") are coerced to the
+* `{ approved }` shape. Unrecognized values pass through unchanged.
+*/
+function normalizeResumeData(resumeData, requiresApproval) {
+	if (!requiresApproval || typeof resumeData !== "string") return resumeData;
+	const text = resumeData.trim();
+	if (APPROVAL_AFFIRMATIVE_PATTERN.test(text)) return { approved: true };
+	if (APPROVAL_NEGATIVE_PATTERN.test(text)) return { approved: false };
+	return resumeData;
+}
+/**
+* Marks a task `input-required` for a suspended agent run and records the
+* resume bookkeeping (runId, toolCallId, approval flag) in task metadata.
+* Shared by the send and stream paths so both report identical suspensions.
+*/
+function applySuspensionToTask({ task, suspendPayload, resumeSchema, runId, logger }) {
+	const nextTask = applyUpdateToTask(task, createInputRequiredStatusUpdate({
+		taskId: task.id,
+		contextId: task.contextId,
+		suspendPayload,
+		resumeSchema,
+		logger
+	}));
+	const payload = suspendPayload;
+	nextTask.metadata = {
+		...clearSuspensionMetadata(nextTask.metadata),
+		[SUSPENDED_RUN_ID_METADATA_KEY]: runId,
+		...typeof payload?.toolCallId === "string" ? { [SUSPENDED_TOOL_CALL_ID_METADATA_KEY]: payload.toolCallId } : {},
+		...isApprovalSuspension(suspendPayload) ? { [SUSPENDED_REQUIRES_APPROVAL_METADATA_KEY]: true } : {}
+	};
+	return nextTask;
+}
+/** Removes the suspension bookkeeping from task metadata once the run completes. */
+function clearSuspensionMetadata(metadata) {
+	const { [SUSPENDED_RUN_ID_METADATA_KEY]: _runId, [SUSPENDED_TOOL_CALL_ID_METADATA_KEY]: _toolCallId, [SUSPENDED_REQUIRES_APPROVAL_METADATA_KEY]: _requiresApproval, ...rest } = metadata ?? {};
+	return rest;
+}
+/**
+* Claims an interrupted task for resume by transitioning it to `working`.
+* `loadWithVersion` and the body of `InMemoryTaskStore.save` both execute
+* synchronously, so two concurrent follow-up messages cannot both claim (and
+* double-resume) the same suspended run.
+*/
+async function claimInterruptedTaskResume({ taskStore, agentId, taskId }) {
+	const snapshot = taskStore.loadWithVersion({
+		agentId,
+		taskId
+	});
+	if (snapshot?.task.status.state !== "input-required" && snapshot?.task.status.state !== "auth-required") return;
+	const task = snapshot.task;
+	const toolCallId = task.metadata?.[SUSPENDED_TOOL_CALL_ID_METADATA_KEY];
+	const claim = {
+		runId: getSuspendedRunId(task) ?? taskId,
+		...typeof toolCallId === "string" ? { toolCallId } : {},
+		requiresApproval: task.metadata?.[SUSPENDED_REQUIRES_APPROVAL_METADATA_KEY] === true
+	};
+	try {
+		await taskStore.save({
+			agentId,
+			data: applyUpdateToTask(task, { state: "working" }),
+			expectedVersion: snapshot.version
+		});
+	} catch (error) {
+		if (error instanceof require_server_a2a_store.TaskStoreVersionConflictError) return;
+		throw error;
+	}
+	return claim;
+}
+async function waitForClaimedResume({ taskStore, agentId, taskId }) {
+	let snapshot = taskStore.loadWithVersion({
+		agentId,
+		taskId
+	});
+	if (!snapshot) throw _mastra_core_a2a.MastraA2AError.taskNotFound(taskId);
+	while (snapshot.task.status.state === "working") snapshot = await taskStore.waitForNextUpdate({
+		agentId,
+		taskId,
+		afterVersion: snapshot.version
+	});
+	return snapshot.task;
+}
 function resolvePushNotificationPair({ pushNotificationStore, pushNotificationSender }) {
 	if (pushNotificationSender) return {
 		pushNotificationStore: pushNotificationSender.getStore(),
@@ -603,23 +791,45 @@ function shouldSendPushNotification(previousTask, nextTask) {
 		"completed",
 		"failed",
 		"canceled",
-		"input-required"
+		"rejected",
+		"input-required",
+		"auth-required"
 	].includes(nextTask.status.state)) return false;
 	return previousTask?.status.state !== nextTask.status.state;
 }
-async function saveTaskAndMaybeSendPushNotification({ taskStore, pushNotificationSender, previousTask, nextTask, agentId, logger }) {
-	await taskStore.save({
+function createLinkedAbortController(abortSignal) {
+	const controller = new AbortController();
+	if (!abortSignal) return {
+		controller,
+		cleanup: () => {}
+	};
+	const abortFromSignal = () => {
+		if (!controller.signal.aborted) controller.abort(abortSignal.reason);
+	};
+	if (abortSignal.aborted) abortFromSignal();
+	else abortSignal.addEventListener("abort", abortFromSignal, { once: true });
+	return {
+		controller,
+		cleanup: () => abortSignal.removeEventListener("abort", abortFromSignal)
+	};
+}
+async function saveTaskAndMaybeSendPushNotification({ taskStore, pushNotificationSender, previousTask, nextTask, agentId, expectedVersion, logger }) {
+	const storedTask = await taskStore.save({
 		agentId,
-		data: nextTask
+		data: nextTask,
+		expectedVersion,
+		skipIfCanceled: true
 	});
-	if (!shouldSendPushNotification(previousTask, nextTask)) return;
+	if (storedTask.status.state === "canceled" && nextTask.status.state !== "canceled") return storedTask;
+	if (!shouldSendPushNotification(previousTask, storedTask)) return storedTask;
 	pushNotificationSender.sendNotifications({
 		agentId,
-		task: nextTask,
+		task: storedTask,
 		logger
 	}).catch((error) => {
 		logger?.error("Failed to schedule A2A push notification", error);
 	});
+	return storedTask;
 }
 function extractFullStreamTextDelta(value) {
 	if (typeof value !== "object" || value === null || !("type" in value)) return null;
@@ -642,12 +852,10 @@ function extractFinalStructuredObject(value) {
 	const objectValue = chunk.payload?.object ?? chunk.object;
 	return objectValue && typeof objectValue === "object" ? objectValue : void 0;
 }
-function isTerminalTaskState(state) {
-	return [
-		"completed",
-		"failed",
-		"canceled"
-	].includes(state);
+function isSuspensionChunk(value) {
+	if (typeof value !== "object" || value === null || !("type" in value)) return false;
+	const type = value.type;
+	return type === "tool-call-suspended" || type === "tool-call-approval";
 }
 function artifactIdentity(artifact) {
 	return artifact.artifactId || artifact.name;
@@ -692,11 +900,15 @@ function getTaskArtifactUpdates({ previous, next }) {
 		artifact: structuredClone(artifact)
 	}));
 }
-async function executeMessageSend({ requestId, message, metadata, currentData, taskStore, pushNotificationSender, agent, agentId, logger, requestContext }) {
+async function executeMessageSend({ requestId, message, metadata, currentData, taskStore, pushNotificationSender, agent, agentId, logger, requestContext, resume }) {
 	const { contextId } = message;
 	try {
 		const resourceId = metadata?.resourceId ?? message.metadata?.resourceId ?? agentId;
-		const result = await agent.generate([convertToCoreMessage(message)], {
+		const result = resume ? await agent.resumeGenerate(normalizeResumeData(extractResumeData(message), resume.requiresApproval), {
+			runId: resume.runId,
+			...resume.toolCallId ? { toolCallId: resume.toolCallId } : {},
+			requestContext
+		}) : await agent.generate([convertToCoreMessage(message)], {
 			runId: currentData.id,
 			requestContext,
 			...contextId ? {
@@ -717,13 +929,32 @@ async function executeMessageSend({ requestId, message, metadata, currentData, t
 			data: result.object
 		});
 		if (artifactUpdate) currentData = applyUpdateToTask(currentData, artifactUpdate);
+		if (result.finishReason === "suspended") {
+			const previousTask = currentData;
+			currentData = applySuspensionToTask({
+				task: currentData,
+				suspendPayload: result.suspendPayload,
+				resumeSchema: result.resumeSchema,
+				runId: result.runId ?? currentData.id,
+				logger
+			});
+			await saveTaskAndMaybeSendPushNotification({
+				taskStore,
+				pushNotificationSender,
+				previousTask,
+				nextTask: currentData,
+				agentId,
+				logger
+			});
+			return createSuccessResponse(requestId, currentData);
+		}
 		const previousTask = currentData;
 		currentData = applyUpdateToTask(currentData, {
 			state: "completed",
 			message: void 0
 		});
 		currentData.metadata = {
-			...currentData.metadata,
+			...clearSuspensionMetadata(currentData.metadata),
 			execution: {
 				toolCalls: result.toolCalls,
 				toolResults: result.toolResults,
@@ -781,11 +1012,28 @@ async function handleMessageSend({ requestId, params, taskStore, pushNotificatio
 	const { message, metadata } = params;
 	const { contextId } = message;
 	const taskId = message.taskId || crypto.randomUUID();
-	const existingTask = await taskStore.load({
+	const existingTask = taskStore.loadWithVersion({
 		agentId,
 		taskId
-	});
+	})?.task;
+	if (message.taskId && !existingTask) throw _mastra_core_a2a.MastraA2AError.taskNotFound(message.taskId);
 	if (params.configuration?.blocking === false && existingTask?.status.state === "working") return createSuccessResponse(requestId, existingTask);
+	if (existingTask?.status.state === "working" && getSuspendedRunId(existingTask)) return createSuccessResponse(requestId, await waitForClaimedResume({
+		taskStore,
+		agentId,
+		taskId
+	}));
+	const wasInterrupted = isInterruptedTaskState(existingTask?.status.state);
+	const resume = await claimInterruptedTaskResume({
+		taskStore,
+		agentId,
+		taskId
+	});
+	if (wasInterrupted && !resume) return createSuccessResponse(requestId, await waitForClaimedResume({
+		taskStore,
+		agentId,
+		taskId
+	}));
 	const { pushNotificationStore: resolvedPushNotificationStore, pushNotificationSender: resolvedPushNotificationSender } = resolvePushNotificationPair({
 		pushNotificationStore,
 		pushNotificationSender
@@ -831,7 +1079,8 @@ async function handleMessageSend({ requestId, params, taskStore, pushNotificatio
 		agent,
 		agentId,
 		logger,
-		requestContext
+		requestContext,
+		resume
 	});
 	if (params.configuration?.blocking === false) {
 		execution.catch((error) => {
@@ -908,11 +1157,20 @@ async function handleDeleteTaskPushNotificationConfig({ requestId, taskStore, pu
 	})) throw _mastra_core_a2a.MastraA2AError.invalidParams(`Push notification config not found: ${params.pushNotificationConfigId}`);
 	return createSuccessResponse(requestId, null);
 }
-async function* handleMessageStream({ requestId, params, taskStore, pushNotificationStore, pushNotificationSender, agent, agentId, logger, requestContext }) {
+async function* handleMessageStream({ requestId, params, taskStore, pushNotificationStore, pushNotificationSender, agent, agentId, logger, requestContext, abortSignal }) {
 	validateMessageSendParams(params);
 	const { message, metadata } = params;
 	const { contextId } = message;
 	const taskId = message.taskId || crypto.randomUUID();
+	if (message.taskId && !taskStore.loadWithVersion({
+		agentId,
+		taskId
+	})) throw _mastra_core_a2a.MastraA2AError.taskNotFound(message.taskId);
+	const resume = await claimInterruptedTaskResume({
+		taskStore,
+		agentId,
+		taskId
+	});
 	const { pushNotificationStore: resolvedPushNotificationStore, pushNotificationSender: resolvedPushNotificationSender } = resolvePushNotificationPair({
 		pushNotificationStore,
 		pushNotificationSender
@@ -948,12 +1206,24 @@ async function* handleMessageStream({ requestId, params, taskStore, pushNotifica
 		agentId,
 		logger
 	});
-	yield createSuccessResponse(requestId, currentData);
+	const { controller: taskAbortController, cleanup: cleanupLinkedAbortController } = createLinkedAbortController(abortSignal);
+	const unregisterTaskAbortController = taskStore.registerAbortController({
+		agentId,
+		taskId,
+		controller: taskAbortController
+	});
 	try {
+		yield createSuccessResponse(requestId, currentData);
 		const resourceId = metadata?.resourceId ?? message.metadata?.resourceId ?? agentId;
-		const result = await agent.stream([convertToCoreMessage(message)], {
+		const result = resume ? await agent.resumeStream(normalizeResumeData(extractResumeData(message), resume.requiresApproval), {
+			runId: resume.runId,
+			...resume.toolCallId ? { toolCallId: resume.toolCallId } : {},
+			requestContext,
+			abortSignal: taskAbortController.signal
+		}) : await agent.stream([convertToCoreMessage(message)], {
 			runId: taskId,
 			requestContext,
+			abortSignal: taskAbortController.signal,
 			...contextId ? {
 				threadId: contextId,
 				resourceId
@@ -962,7 +1232,22 @@ async function* handleMessageStream({ requestId, params, taskStore, pushNotifica
 		let sawTextArtifact = false;
 		let pendingTextChunk;
 		let structuredData;
+		let suspended = false;
+		let streamCanceled = false;
 		for await (const chunk of result.fullStream) {
+			if (taskAbortController.signal.aborted) {
+				const latestTask = await taskStore.load({
+					agentId,
+					taskId: currentData.id
+				});
+				if (latestTask) currentData = latestTask;
+				streamCanceled = true;
+				break;
+			}
+			if (isSuspensionChunk(chunk)) {
+				suspended = true;
+				continue;
+			}
 			const textDelta = extractFullStreamTextDelta(chunk);
 			if (textDelta !== null) {
 				if (!pendingTextChunk) {
@@ -977,13 +1262,17 @@ async function* handleMessageStream({ requestId, params, taskStore, pushNotifica
 					lastChunk: false
 				});
 				currentData = applyUpdateToTask(currentData, textUpdate);
-				await saveTaskAndMaybeSendPushNotification({
+				currentData = await saveTaskAndMaybeSendPushNotification({
 					taskStore,
 					pushNotificationSender: resolvedPushNotificationSender,
 					nextTask: currentData,
 					agentId,
 					logger
 				});
+				if (currentData.status.state === "canceled") {
+					streamCanceled = true;
+					break;
+				}
 				yield createSuccessResponse(requestId, textUpdate);
 				sawTextArtifact = true;
 				pendingTextChunk = textDelta;
@@ -992,98 +1281,217 @@ async function* handleMessageStream({ requestId, params, taskStore, pushNotifica
 			const finalStructuredObject = extractFinalStructuredObject(chunk);
 			if (finalStructuredObject) structuredData = finalStructuredObject;
 		}
-		structuredData ??= await result.object;
-		if (!pendingTextChunk && !sawTextArtifact) {
-			const finalText = await result.text;
-			if (finalText) pendingTextChunk = finalText;
+		if (!streamCanceled && taskAbortController.signal.aborted) {
+			const latestTask = await taskStore.load({
+				agentId,
+				taskId: currentData.id
+			});
+			if (latestTask) currentData = latestTask;
+			streamCanceled = true;
 		}
-		if (pendingTextChunk) {
-			const textUpdate = createTextChunkArtifactUpdate({
-				taskId: currentData.id,
-				contextId: currentData.contextId,
-				text: pendingTextChunk,
-				append: sawTextArtifact,
-				lastChunk: !structuredData
+		if (streamCanceled && abortSignal?.aborted && currentData.status.state !== "canceled") {
+			const previousTask = currentData;
+			currentData = applyUpdateToTask(currentData, {
+				state: "canceled",
+				message: {
+					messageId: crypto.randomUUID(),
+					role: "agent",
+					parts: [{
+						kind: "text",
+						text: "Task canceled because the request was aborted."
+					}],
+					kind: "message"
+				}
 			});
-			currentData = applyUpdateToTask(currentData, textUpdate);
-			await saveTaskAndMaybeSendPushNotification({
+			currentData = await saveTaskAndMaybeSendPushNotification({
 				taskStore,
 				pushNotificationSender: resolvedPushNotificationSender,
+				previousTask,
 				nextTask: currentData,
 				agentId,
 				logger
 			});
-			yield createSuccessResponse(requestId, textUpdate);
-			sawTextArtifact = true;
-			pendingTextChunk = void 0;
 		}
-		if (structuredData) {
-			const dataUpdate = createDataArtifactUpdate({
-				taskId: currentData.id,
-				contextId: currentData.contextId,
-				data: structuredData,
-				lastChunk: true
+		if (!streamCanceled && suspended) {
+			if (pendingTextChunk) {
+				const textUpdate = createTextChunkArtifactUpdate({
+					taskId: currentData.id,
+					contextId: currentData.contextId,
+					text: pendingTextChunk,
+					append: sawTextArtifact,
+					lastChunk: true
+				});
+				currentData = applyUpdateToTask(currentData, textUpdate);
+				currentData = await saveTaskAndMaybeSendPushNotification({
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					nextTask: currentData,
+					agentId,
+					logger
+				});
+				if (currentData.status.state === "canceled") streamCanceled = true;
+				else yield createSuccessResponse(requestId, textUpdate);
+			}
+			const suspensionTask = currentData;
+			currentData = applySuspensionToTask({
+				task: currentData,
+				suspendPayload: await result.suspendPayload,
+				resumeSchema: await result.resumeSchema,
+				runId: result.runId ?? currentData.id,
+				logger
 			});
-			currentData = applyUpdateToTask(currentData, dataUpdate);
-			await saveTaskAndMaybeSendPushNotification({
+			currentData = await saveTaskAndMaybeSendPushNotification({
 				taskStore,
 				pushNotificationSender: resolvedPushNotificationSender,
+				previousTask: suspensionTask,
 				nextTask: currentData,
 				agentId,
 				logger
 			});
-			yield createSuccessResponse(requestId, dataUpdate);
+			if (currentData.status.state === "canceled") streamCanceled = true;
 		}
-		const previousTask = currentData;
-		const completedTask = applyUpdateToTask(currentData, {
-			state: "completed",
-			message: void 0
-		});
-		completedTask.metadata = {
-			...completedTask.metadata,
-			execution: {
-				toolCalls: await result.toolCalls,
-				toolResults: await result.toolResults,
-				usage: await result.usage,
-				finishReason: await result.finishReason
+		if (!streamCanceled && !suspended) {
+			structuredData ??= await result.object;
+			if (!pendingTextChunk && !sawTextArtifact) {
+				const finalText = await result.text;
+				if (finalText) pendingTextChunk = finalText;
 			}
-		};
-		currentData = completedTask;
-		await saveTaskAndMaybeSendPushNotification({
-			taskStore,
-			pushNotificationSender: resolvedPushNotificationSender,
-			previousTask,
-			nextTask: currentData,
+			if (pendingTextChunk) {
+				const textUpdate = createTextChunkArtifactUpdate({
+					taskId: currentData.id,
+					contextId: currentData.contextId,
+					text: pendingTextChunk,
+					append: sawTextArtifact,
+					lastChunk: !structuredData
+				});
+				currentData = applyUpdateToTask(currentData, textUpdate);
+				currentData = await saveTaskAndMaybeSendPushNotification({
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					nextTask: currentData,
+					agentId,
+					logger
+				});
+				if (currentData.status.state === "canceled") streamCanceled = true;
+				else yield createSuccessResponse(requestId, textUpdate);
+				sawTextArtifact = true;
+				pendingTextChunk = void 0;
+			}
+			if (!streamCanceled && structuredData) {
+				const dataUpdate = createDataArtifactUpdate({
+					taskId: currentData.id,
+					contextId: currentData.contextId,
+					data: structuredData,
+					lastChunk: true
+				});
+				currentData = applyUpdateToTask(currentData, dataUpdate);
+				currentData = await saveTaskAndMaybeSendPushNotification({
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					nextTask: currentData,
+					agentId,
+					logger
+				});
+				if (currentData.status.state === "canceled") streamCanceled = true;
+				else yield createSuccessResponse(requestId, dataUpdate);
+			}
+			if (!streamCanceled) {
+				const previousTask = currentData;
+				const completedTask = applyUpdateToTask(currentData, {
+					state: "completed",
+					message: void 0
+				});
+				completedTask.metadata = {
+					...clearSuspensionMetadata(completedTask.metadata),
+					execution: {
+						toolCalls: await result.toolCalls,
+						toolResults: await result.toolResults,
+						usage: await result.usage,
+						finishReason: await result.finishReason
+					}
+				};
+				currentData = await saveTaskAndMaybeSendPushNotification({
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					previousTask,
+					nextTask: completedTask,
+					agentId,
+					logger
+				});
+			}
+		}
+	} catch (handlerError) {
+		const latestTask = await taskStore.load({
 			agentId,
-			logger
+			taskId: currentData.id
 		});
-	} catch (handlerError) {
-		const previousTask = currentData;
-		currentData = applyUpdateToTask(currentData, {
-			state: "failed",
-			message: {
-				messageId: crypto.randomUUID(),
-				role: "agent",
-				parts: [{
-					kind: "text",
-					text: `Handler failed: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`
-				}],
-				kind: "message"
+		if (latestTask?.status.state === "canceled") currentData = latestTask;
+		else if (taskAbortController.signal.aborted) {
+			currentData = latestTask ?? currentData;
+			if (abortSignal?.aborted) {
+				const previousTask = currentData;
+				currentData = applyUpdateToTask(currentData, {
+					state: "canceled",
+					message: {
+						messageId: crypto.randomUUID(),
+						role: "agent",
+						parts: [{
+							kind: "text",
+							text: "Task canceled because the request was aborted."
+						}],
+						kind: "message"
+					}
+				});
+				try {
+					currentData = await saveTaskAndMaybeSendPushNotification({
+						taskStore,
+						pushNotificationSender: resolvedPushNotificationSender,
+						previousTask,
+						nextTask: currentData,
+						agentId,
+						logger
+					});
+				} catch (saveError) {
+					logger?.error(`Failed to save task ${currentData.id} after request abort:`, saveError?.message);
+				}
 			}
-		});
-		try {
-			await saveTaskAndMaybeSendPushNotification({
-				taskStore,
-				pushNotificationSender: resolvedPushNotificationSender,
-				previousTask,
-				nextTask: currentData,
-				agentId,
-				logger
+		} else {
+			currentData = latestTask ?? currentData;
+			const previousTask = currentData;
+			currentData = applyUpdateToTask(currentData, {
+				state: "failed",
+				message: {
+					messageId: crypto.randomUUID(),
+					role: "agent",
+					parts: [{
+						kind: "text",
+						text: `Handler failed: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`
+					}],
+					kind: "message"
+				}
 			});
-		} catch (saveError) {
-			logger?.error(`Failed to save task ${currentData.id} after handler error:`, saveError?.message);
+			try {
+				currentData = await saveTaskAndMaybeSendPushNotification({
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					previousTask,
+					nextTask: currentData,
+					agentId,
+					logger
+				});
+			} catch (saveError) {
+				logger?.error(`Failed to save task ${currentData.id} after handler error:`, saveError?.message);
+			}
 		}
+	} finally {
+		unregisterTaskAbortController();
+		cleanupLinkedAbortController();
 	}
+	const latestTask = await taskStore.load({
+		agentId,
+		taskId: currentData.id
+	});
+	if (latestTask?.status.state === "canceled") currentData = latestTask;
 	yield createSuccessResponse(requestId, {
 		kind: "status-update",
 		taskId: currentData.id,
@@ -1099,7 +1507,7 @@ async function* handleTaskResubscribe({ requestId, taskStore, agentId, taskId, a
 	});
 	if (!snapshot) throw _mastra_core_a2a.MastraA2AError.taskNotFound(taskId);
 	yield createSuccessResponse(requestId, snapshot.task);
-	if (isTerminalTaskState(snapshot.task.status.state)) return;
+	if (isTerminalTaskState(snapshot.task.status.state) || isInterruptedTaskState(snapshot.task.status.state)) return;
 	while (true) {
 		const { task, version } = snapshot;
 		const nextUpdate = await taskStore.waitForNextUpdate({
@@ -1112,14 +1520,16 @@ async function* handleTaskResubscribe({ requestId, taskStore, agentId, taskId, a
 			previous: task,
 			next: nextUpdate.task
 		})) yield createSuccessResponse(requestId, artifactUpdate);
+		const nextState = nextUpdate.task.status.state;
+		const streamEnded = isTerminalTaskState(nextState) || isInterruptedTaskState(nextState);
 		if (didTaskStatusChange(task, nextUpdate.task)) yield createSuccessResponse(requestId, {
 			kind: "status-update",
 			taskId: nextUpdate.task.id,
 			contextId: nextUpdate.task.contextId,
 			status: nextUpdate.task.status,
-			final: isTerminalTaskState(nextUpdate.task.status.state)
+			final: streamEnded
 		});
-		if (isTerminalTaskState(nextUpdate.task.status.state)) return;
+		if (streamEnded) return;
 		snapshot = nextUpdate;
 	}
 }
@@ -1157,44 +1567,53 @@ function createA2ASSEResponse(payload) {
 	} });
 }
 async function handleTaskCancel({ requestId, taskStore, pushNotificationSender, agentId, taskId, logger }) {
-	let data = await taskStore.load({
-		agentId,
-		taskId
-	});
-	if (!data) throw _mastra_core_a2a.MastraA2AError.taskNotFound(taskId);
-	if ([
-		"completed",
-		"failed",
-		"canceled"
-	].includes(data.status.state)) {
-		logger?.info(`Task ${taskId} already in final state ${data.status.state}, cannot cancel.`);
-		return createSuccessResponse(requestId, data);
-	}
-	taskStore.activeCancellations.add(taskId);
-	const cancelUpdate = {
-		state: "canceled",
-		message: {
-			role: "agent",
-			parts: [{
-				kind: "text",
-				text: "Task cancelled by request."
-			}],
-			kind: "message",
-			messageId: crypto.randomUUID()
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const snapshot = taskStore.loadWithVersion({
+			agentId,
+			taskId
+		});
+		const data = snapshot?.task;
+		if (!data) throw _mastra_core_a2a.MastraA2AError.taskNotFound(taskId);
+		if (isTerminalTaskState(data.status.state)) {
+			logger?.info(`Task ${taskId} already in final state ${data.status.state}, cannot cancel.`);
+			throw _mastra_core_a2a.MastraA2AError.taskNotCancelable(taskId);
 		}
-	};
-	const previousTask = data;
-	data = applyUpdateToTask(data, cancelUpdate);
-	await saveTaskAndMaybeSendPushNotification({
-		taskStore,
-		pushNotificationSender: resolvePushNotificationPair({ pushNotificationSender }).pushNotificationSender,
-		previousTask,
-		nextTask: data,
-		agentId,
-		logger
-	});
-	taskStore.activeCancellations.delete(taskId);
-	return createSuccessResponse(requestId, data);
+		taskStore.activeCancellations.add(taskId);
+		taskStore.abortTask({
+			agentId,
+			taskId,
+			reason: new DOMException("Task cancelled by request.", "AbortError")
+		});
+		const canceledTask = applyUpdateToTask(data, {
+			state: "canceled",
+			message: {
+				role: "agent",
+				parts: [{
+					kind: "text",
+					text: "Task cancelled by request."
+				}],
+				kind: "message",
+				messageId: crypto.randomUUID()
+			}
+		});
+		try {
+			await saveTaskAndMaybeSendPushNotification({
+				taskStore,
+				pushNotificationSender: resolvePushNotificationPair({ pushNotificationSender }).pushNotificationSender,
+				previousTask: data,
+				nextTask: canceledTask,
+				agentId,
+				expectedVersion: snapshot.version,
+				logger
+			});
+			return createSuccessResponse(requestId, canceledTask);
+		} catch (error) {
+			if (!(error instanceof require_server_a2a_store.TaskStoreVersionConflictError)) throw error;
+		} finally {
+			taskStore.activeCancellations.delete(taskId);
+		}
+	}
+	throw _mastra_core_a2a.MastraA2AError.invalidRequest(`Task ${taskId} was updated concurrently. Retry the request.`);
 }
 async function getAgentExecutionHandler({ requestId, mastra, agentId, requestContext, method, params, taskStore, pushNotificationStore, pushNotificationSender, logger, abortSignal }) {
 	const agent = await require_server_handlers_agents.getAgentFromSystem({
@@ -1229,7 +1648,8 @@ async function getAgentExecutionHandler({ requestId, mastra, agentId, requestCon
 				agent,
 				agentId,
 				logger,
-				requestContext
+				requestContext,
+				abortSignal
 			});
 			case "tasks/get": return await handleTaskGet({
 				requestId,
@@ -1426,4 +1846,4 @@ Object.defineProperty(exports, "handleTaskResubscribe", {
 	}
 });
 
-//# sourceMappingURL=a2a-DKnwIgiw.cjs.map
+//# sourceMappingURL=a2a-D3ZYeXIx.cjs.map