@mastra/server 1.58.0-alpha.0 → 1.58.0-alpha.12

package/dist/{a2a-uPi5sPwb.js → a2a-B9X-RdWt.js}

@@ -1,8 +1,9 @@
 import { i as __toESM, n as __exportAll, t as __commonJSMin } from "./rolldown-runtime-DuvcJU0W.js";
-import { n as createRoute } from "./route-builder-CIk5k35M.js";
-import { r as convertInstructionsToString } from "./utils-BUK03Frl.js";
+import { n as createRoute } from "./route-builder-CQkb7tQY.js";
+import { r as convertInstructionsToString } from "./utils-QXKhjIm6.js";
 import { getAgentFromSystem } from "./server/handlers/agents.js";
-import { a as agentExecutionResponseSchema, i as agentExecutionBodySchema, r as agentCardResponseSchema, t as a2aAgentIdPathParams } from "./a2a-CnU9zaGR.js";
+import { TaskStoreVersionConflictError } from "./server/a2a/store.js";
+import { a as agentExecutionResponseSchema, i as agentExecutionBodySchema, r as agentCardResponseSchema, t as a2aAgentIdPathParams } from "./a2a-8C4O2dVJ.js";
 import { getPublicOrigin } from "./server/handlers/auth.js";
 import { z } from "zod/v4";
 import { isDeepStrictEqual } from "util";
@@ -115,7 +116,7 @@ function createErrorResponse(id, error) {
 	};
 }
 function createSuccessResponse(id, result) {
-	if (!id) throw MastraA2AError.internalError("Cannot create success response for null ID.");
+	if (id === null) throw MastraA2AError.internalError("Cannot create success response for null ID.");
 	return {
 		jsonrpc: "2.0",
 		id,
@@ -303,6 +304,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);
@@ -338,54 +347,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 TaskStoreVersionConflictError) continue;
+				throw error;
+			}
+		}
+		logger?.info(`[Task ${taskId}] Loaded existing task.`);
+		const { status } = data;
+		if (isTerminalTaskState(status.state)) throw 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 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 MastraA2AError.invalidRequest(`Task ${taskId} was updated concurrently. Retry the request.`);
 }
 //#endregion
 //#region src/server/handlers/a2a.ts
@@ -402,7 +420,9 @@ var a2a_exports = /* @__PURE__ */ __exportAll({
 	handleSetTaskPushNotificationConfig: () => handleSetTaskPushNotificationConfig,
 	handleTaskCancel: () => handleTaskCancel,
 	handleTaskGet: () => handleTaskGet,
-	handleTaskResubscribe: () => handleTaskResubscribe
+	handleTaskList: () => handleTaskList,
+	handleTaskResubscribe: () => handleTaskResubscribe,
+	resolveA2AProtocolVersion: () => resolveA2AProtocolVersion
 });
 const messagePartSchema = z.discriminatedUnion("kind", [
 	z.object({
@@ -444,6 +464,7 @@ const messageSendParamsSchema = z.object({
 	configuration: z.object({
 		acceptedOutputModes: z.array(z.string()).optional(),
 		blocking: z.boolean().optional(),
+		returnImmediately: z.boolean().optional(),
 		historyLength: z.number().optional(),
 		pushNotificationConfig: z.object({
 			url: z.string(),
@@ -458,6 +479,159 @@ const messageSendParamsSchema = z.object({
 });
 const defaultPushNotificationStore = new InMemoryPushNotificationStore();
 const defaultPushNotificationSender = new DefaultPushNotificationSender(defaultPushNotificationStore);
+const V1_TASK_STATES = {
+	submitted: "TASK_STATE_SUBMITTED",
+	working: "TASK_STATE_WORKING",
+	completed: "TASK_STATE_COMPLETED",
+	failed: "TASK_STATE_FAILED",
+	canceled: "TASK_STATE_CANCELED",
+	"input-required": "TASK_STATE_INPUT_REQUIRED",
+	rejected: "TASK_STATE_REJECTED",
+	"auth-required": "TASK_STATE_AUTH_REQUIRED"
+};
+function normalizeV1Part(part) {
+	if ("text" in part) return {
+		kind: "text",
+		text: part.text,
+		metadata: part.metadata
+	};
+	if ("raw" in part) return {
+		kind: "file",
+		file: {
+			bytes: part.raw,
+			mimeType: part.mediaType,
+			name: part.filename
+		},
+		metadata: part.metadata
+	};
+	if ("url" in part) return {
+		kind: "file",
+		file: {
+			uri: part.url,
+			mimeType: part.mediaType,
+			name: part.filename
+		},
+		metadata: part.metadata
+	};
+	return {
+		kind: "data",
+		data: part.data,
+		metadata: part.metadata
+	};
+}
+function normalizeV1Params(params) {
+	if (!params?.message) return params;
+	const configuration = params.configuration;
+	return {
+		...params,
+		message: {
+			...params.message,
+			kind: "message",
+			role: params.message.role === "ROLE_AGENT" ? "agent" : "user",
+			parts: params.message.parts.map((part) => normalizeV1Part(part))
+		},
+		configuration: configuration ? {
+			...configuration,
+			blocking: configuration.returnImmediately === void 0 ? void 0 : !configuration.returnImmediately,
+			pushNotificationConfig: configuration.taskPushNotificationConfig
+		} : void 0
+	};
+}
+function toV1Part(part) {
+	if (part.kind === "text") return {
+		text: part.text,
+		metadata: part.metadata
+	};
+	if (part.kind === "file") return "uri" in part.file ? {
+		url: part.file.uri,
+		filename: part.file.name,
+		mediaType: part.file.mimeType,
+		metadata: part.metadata
+	} : {
+		raw: part.file.bytes,
+		filename: part.file.name,
+		mediaType: part.file.mimeType,
+		metadata: part.metadata
+	};
+	return {
+		data: part.data,
+		metadata: part.metadata
+	};
+}
+function toV1Message(message) {
+	if (!message) return void 0;
+	return {
+		messageId: message.messageId,
+		contextId: message.contextId,
+		taskId: message.taskId,
+		role: message.role === "agent" ? "ROLE_AGENT" : "ROLE_USER",
+		parts: message.parts?.map(toV1Part),
+		metadata: message.metadata,
+		extensions: message.extensions,
+		referenceTaskIds: message.referenceTaskIds
+	};
+}
+function toV1Task(task, { includeArtifacts = true, historyLength } = {}) {
+	return {
+		id: task.id,
+		contextId: task.contextId,
+		status: {
+			state: V1_TASK_STATES[task.status.state] ?? "TASK_STATE_UNSPECIFIED",
+			message: toV1Message(task.status.message),
+			timestamp: task.status.timestamp
+		},
+		artifacts: includeArtifacts ? task.artifacts?.map((artifact) => ({
+			artifactId: artifact.artifactId,
+			name: artifact.name,
+			description: artifact.description,
+			parts: artifact.parts?.map(toV1Part),
+			metadata: artifact.metadata,
+			extensions: artifact.extensions
+		})) : void 0,
+		history: task.history?.slice(historyLength === void 0 ? 0 : -historyLength).map(toV1Message),
+		metadata: task.metadata
+	};
+}
+function toV1Result(result, method) {
+	if (method === "message/send") return result?.kind === "message" ? { message: toV1Message(result) } : { task: toV1Task(result) };
+	if (method === "message/stream" || method === "tasks/resubscribe") {
+		if (result?.kind === "status-update") return { statusUpdate: {
+			taskId: result.taskId,
+			contextId: result.contextId,
+			status: {
+				state: V1_TASK_STATES[result.status.state] ?? "TASK_STATE_UNSPECIFIED",
+				message: toV1Message(result.status.message),
+				timestamp: result.status.timestamp
+			},
+			final: result.final,
+			metadata: result.metadata
+		} };
+		if (result?.kind === "artifact-update") return { artifactUpdate: {
+			taskId: result.taskId,
+			contextId: result.contextId,
+			artifact: {
+				...result.artifact,
+				parts: result.artifact.parts?.map(toV1Part)
+			},
+			append: result.append,
+			lastChunk: result.lastChunk,
+			metadata: result.metadata
+		} };
+		return result?.kind === "message" ? { message: toV1Message(result) } : { task: toV1Task(result) };
+	}
+	if (method === "tasks/get" || method === "tasks/cancel") return toV1Task(result);
+	return result;
+}
+function convertV1Response(response, method) {
+	if (!response || !("result" in response)) return response;
+	return {
+		...response,
+		result: toV1Result(response.result, method)
+	};
+}
+async function* convertV1Stream(stream, method) {
+	for await (const response of stream) yield convertV1Response(response, method);
+}
 function createAgentCardDefaults({ pushNotifications = false } = {}) {
 	return {
 		protocolVersion: "0.3.0",
@@ -572,6 +746,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 TaskStoreVersionConflictError) return;
+		throw error;
+	}
+	return claim;
+}
+async function waitForClaimedResume({ taskStore, agentId, taskId }) {
+	let snapshot = taskStore.loadWithVersion({
+		agentId,
+		taskId
+	});
+	if (!snapshot) throw 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(),
@@ -600,23 +944,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;
@@ -639,12 +1005,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;
@@ -689,11 +1053,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 ? {
@@ -714,13 +1082,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,
@@ -778,11 +1165,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 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
@@ -828,7 +1232,8 @@ async function handleMessageSend({ requestId, params, taskStore, pushNotificatio
 		agent,
 		agentId,
 		logger,
-		requestContext
+		requestContext,
+		resume
 	});
 	if (params.configuration?.blocking === false) {
 		execution.catch((error) => {
@@ -846,6 +1251,25 @@ async function handleTaskGet({ requestId, taskStore, agentId, taskId }) {
 	if (!task) throw MastraA2AError.taskNotFound(taskId);
 	return createSuccessResponse(requestId, task);
 }
+function handleTaskList({ requestId, taskStore, agentId, params }) {
+	const requestedPageSize = params.pageSize ?? 50;
+	const offset = params.pageToken ? Number.parseInt(params.pageToken, 10) : 0;
+	const start = Number.isFinite(offset) && offset >= 0 ? offset : 0;
+	const status = typeof params.status === "string" ? params.status.replace(/^TASK_STATE_/, "").toLowerCase().replaceAll("_", "-") : void 0;
+	const timestampAfter = params.statusTimestampAfter ? Date.parse(params.statusTimestampAfter) : void 0;
+	const matchingTasks = taskStore.list({ agentId }).filter((task) => !params.contextId || task.contextId === params.contextId).filter((task) => !status || task.status.state === status).filter((task) => !timestampAfter || task.status.timestamp !== void 0 && Date.parse(task.status.timestamp) >= timestampAfter);
+	const tasks = matchingTasks.slice(start, start + requestedPageSize).map((task) => toV1Task(task, {
+		includeArtifacts: params.includeArtifacts ?? false,
+		historyLength: params.historyLength
+	}));
+	const nextOffset = start + tasks.length;
+	return createSuccessResponse(requestId, {
+		tasks,
+		nextPageToken: nextOffset < matchingTasks.length ? String(nextOffset) : "",
+		pageSize: requestedPageSize,
+		totalSize: matchingTasks.length
+	});
+}
 async function loadTaskOrThrow({ taskStore, agentId, taskId }) {
 	const task = await taskStore.load({
 		agentId,
@@ -905,11 +1329,20 @@ async function handleDeleteTaskPushNotificationConfig({ requestId, taskStore, pu
 	})) throw 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 MastraA2AError.taskNotFound(message.taskId);
+	const resume = await claimInterruptedTaskResume({
+		taskStore,
+		agentId,
+		taskId
+	});
 	const { pushNotificationStore: resolvedPushNotificationStore, pushNotificationSender: resolvedPushNotificationSender } = resolvePushNotificationPair({
 		pushNotificationStore,
 		pushNotificationSender
@@ -945,12 +1378,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
@@ -959,7 +1404,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) {
@@ -974,13 +1434,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;
@@ -989,98 +1453,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,
@@ -1096,7 +1679,7 @@ async function* handleTaskResubscribe({ requestId, taskStore, agentId, taskId, a
 	});
 	if (!snapshot) throw 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({
@@ -1109,14 +1692,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;
 	}
 }
@@ -1154,101 +1739,135 @@ function createA2ASSEResponse(payload) {
 	} });
 }
 async function handleTaskCancel({ requestId, taskStore, pushNotificationSender, agentId, taskId, logger }) {
-	let data = await taskStore.load({
-		agentId,
-		taskId
-	});
-	if (!data) throw 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 MastraA2AError.taskNotFound(taskId);
+		if (isTerminalTaskState(data.status.state)) {
+			logger?.info(`Task ${taskId} already in final state ${data.status.state}, cannot cancel.`);
+			throw 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 TaskStoreVersionConflictError)) throw error;
+		} finally {
+			taskStore.activeCancellations.delete(taskId);
+		}
+	}
+	throw MastraA2AError.invalidRequest(`Task ${taskId} was updated concurrently. Retry the request.`);
 }
-async function getAgentExecutionHandler({ requestId, mastra, agentId, requestContext, method, params, taskStore, pushNotificationStore, pushNotificationSender, logger, abortSignal }) {
+async function getAgentExecutionHandler({ requestId, mastra, agentId, requestContext, method, params, taskStore, pushNotificationStore, pushNotificationSender, logger, abortSignal, protocolVersion = "0.3" }) {
 	const agent = await getAgentFromSystem({
 		mastra,
 		agentId
 	});
+	const protocolParams = protocolVersion === "1.0" ? normalizeV1Params(params) : params;
 	const { pushNotificationStore: resolvedPushNotificationStore, pushNotificationSender: resolvedPushNotificationSender } = resolvePushNotificationPair({
 		pushNotificationStore,
 		pushNotificationSender
 	});
 	let taskId;
 	try {
-		taskId = getTaskIdFromParams(params);
+		taskId = getTaskIdFromParams(protocolParams);
 		switch (method) {
-			case "message/send": return await handleMessageSend({
-				requestId,
-				params,
-				taskStore,
-				pushNotificationStore: resolvedPushNotificationStore,
-				pushNotificationSender: resolvedPushNotificationSender,
-				agent,
-				agentId,
-				logger,
-				requestContext
-			});
-			case "message/stream": return await handleMessageStream({
-				requestId,
-				taskStore,
-				params,
-				pushNotificationStore: resolvedPushNotificationStore,
-				pushNotificationSender: resolvedPushNotificationSender,
-				agent,
-				agentId,
-				logger,
-				requestContext
-			});
-			case "tasks/get": return await handleTaskGet({
-				requestId,
-				taskStore,
-				agentId,
-				taskId: taskId || "No task ID provided"
-			});
-			case "tasks/cancel": return await handleTaskCancel({
-				requestId,
-				taskStore,
-				pushNotificationSender: resolvedPushNotificationSender,
-				agentId,
-				taskId: taskId || "No task ID provided",
-				logger
-			});
-			case "tasks/resubscribe": return await handleTaskResubscribe({
-				requestId,
-				taskStore,
-				agentId,
-				taskId: taskId || "No task ID provided",
-				abortSignal
-			});
+			case "message/send": {
+				const result = await handleMessageSend({
+					requestId,
+					params: protocolParams,
+					taskStore,
+					pushNotificationStore: resolvedPushNotificationStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					agent,
+					agentId,
+					logger,
+					requestContext
+				});
+				return protocolVersion === "1.0" ? convertV1Response(result, method) : result;
+			}
+			case "message/stream": {
+				const result = await handleMessageStream({
+					requestId,
+					taskStore,
+					params: protocolParams,
+					pushNotificationStore: resolvedPushNotificationStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					agent,
+					agentId,
+					logger,
+					requestContext,
+					abortSignal
+				});
+				return protocolVersion === "1.0" ? convertV1Stream(result, method) : result;
+			}
+			case "tasks/get": {
+				const result = await handleTaskGet({
+					requestId,
+					taskStore,
+					agentId,
+					taskId: taskId || "No task ID provided"
+				});
+				return protocolVersion === "1.0" ? convertV1Response(result, method) : result;
+			}
+			case "tasks/list":
+				if (protocolVersion !== "1.0") throw MastraA2AError.methodNotFound(method);
+				return handleTaskList({
+					requestId,
+					taskStore,
+					agentId,
+					params: protocolParams ?? {}
+				});
+			case "tasks/cancel": {
+				const result = await handleTaskCancel({
+					requestId,
+					taskStore,
+					pushNotificationSender: resolvedPushNotificationSender,
+					agentId,
+					taskId: taskId || "No task ID provided",
+					logger
+				});
+				return protocolVersion === "1.0" ? convertV1Response(result, method) : result;
+			}
+			case "tasks/resubscribe": {
+				const result = handleTaskResubscribe({
+					requestId,
+					taskStore,
+					agentId,
+					taskId: taskId || "No task ID provided",
+					abortSignal
+				});
+				return protocolVersion === "1.0" ? convertV1Stream(result, method) : result;
+			}
 			case "tasks/pushNotificationConfig/set": return await handleSetTaskPushNotificationConfig({
 				requestId,
 				taskStore,
@@ -1285,6 +1904,12 @@ async function getAgentExecutionHandler({ requestId, mastra, agentId, requestCon
 		return normalizeError(error, requestId, taskId, logger);
 	}
 }
+function resolveA2AProtocolVersion(request) {
+	const version = request?.headers.get("A2A-Version")?.trim();
+	if (!version || version === "0.3") return "0.3";
+	if (version === "1.0") return "1.0";
+	throw MastraA2AError.versionNotSupported(version);
+}
 const GET_AGENT_CARD_ROUTE = createRoute({
 	method: "GET",
 	path: "/.well-known/:agentId/agent-card.json",
@@ -1321,23 +1946,31 @@ const AGENT_EXECUTION_ROUTE = createRoute({
 	description: "Executes an agent action via JSON-RPC 2.0 over A2A protocol",
 	tags: ["Agent-to-Agent"],
 	requiresAuth: true,
-	handler: async ({ mastra, agentId, requestContext, taskStore, abortSignal, ...bodyParams }) => {
+	handler: async ({ mastra, agentId, requestContext, taskStore, abortSignal, request, ...bodyParams }) => {
 		const { id: requestId, method } = bodyParams;
+		const params = "params" in bodyParams ? bodyParams.params : void 0;
+		let protocolVersion;
+		try {
+			protocolVersion = resolveA2AProtocolVersion(request);
+		} catch (error) {
+			return createA2AJsonResponse(normalizeError(error, requestId));
+		}
 		const result = await getAgentExecutionHandler({
 			requestId,
 			mastra,
 			agentId,
 			requestContext,
 			method,
-			params: "params" in bodyParams ? bodyParams.params : void 0,
+			params,
 			taskStore,
-			abortSignal
+			abortSignal,
+			protocolVersion
 		});
 		if (method === "message/stream" || method === "tasks/resubscribe") return createA2ASSEResponse(result);
 		return createA2AJsonResponse(result);
 	}
 });
 //#endregion
-export { getAgentExecutionHandler as a, handleListTaskPushNotificationConfig as c, handleSetTaskPushNotificationConfig as d, handleTaskCancel as f, getAgentCardByIdHandler as i, handleMessageSend as l, handleTaskResubscribe as m, GET_AGENT_CARD_ROUTE as n, handleDeleteTaskPushNotificationConfig as o, handleTaskGet as p, a2a_exports as r, handleGetTaskPushNotificationConfig as s, AGENT_EXECUTION_ROUTE as t, handleMessageStream as u };
+export { getAgentExecutionHandler as a, handleListTaskPushNotificationConfig as c, handleSetTaskPushNotificationConfig as d, handleTaskCancel as f, resolveA2AProtocolVersion as g, handleTaskResubscribe as h, getAgentCardByIdHandler as i, handleMessageSend as l, handleTaskList as m, GET_AGENT_CARD_ROUTE as n, handleDeleteTaskPushNotificationConfig as o, handleTaskGet as p, a2a_exports as r, handleGetTaskPushNotificationConfig as s, AGENT_EXECUTION_ROUTE as t, handleMessageStream as u };
 
-//# sourceMappingURL=a2a-uPi5sPwb.js.map
+//# sourceMappingURL=a2a-B9X-RdWt.js.map