@mastra/mcp 2.6.0 → 2.7.0

package/dist/index.js

@@ -2,7 +2,7 @@ import { createRequire } from "module";
 import { AsyncLocalStorage } from "async_hooks";
 import { MastraBase } from "@mastra/core/base";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
-import { createTool, isValidationError, noopObserve, validateToolOutput } from "@mastra/core/tools";
+import { createTool, isValidationError, noopObserve, validateToolInput, validateToolOutput } from "@mastra/core/tools";
 import z3, { ZodFirstPartyTypeKind } from "zod/v3";
 import { toJSONSchema, z } from "zod/v4";
 import { z as z$1 } from "zod";
@@ -18,12 +18,12 @@ import http, { createServer } from "http";
 import { MCPServerBase, MCP_SERVER_EVENT_ERROR_IDS } from "@mastra/core/mcp";
 import { isStandardSchemaWithJSON, standardSchemaToJSONSchema, toStandardSchema } from "@mastra/core/schema";
 import { readFileSync } from "fs";
-import { RequestContext } from "@mastra/core/request-context";
+import { MASTRA_AUTH_TOKEN_KEY, RequestContext } from "@mastra/core/request-context";
 import { makeCoreTool } from "@mastra/core/utils";
 import { PromptSchema } from "@modelcontextprotocol/core";
 import { RESOURCE_MIME_TYPE, RESOURCE_URI_META_KEY } from "@modelcontextprotocol/ext-apps";
 import { hostHeaderValidation, originValidation, toNodeHandler } from "@modelcontextprotocol/node";
-import { CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, ProtocolError as ProtocolError$1, ProtocolErrorCode as ProtocolErrorCode$1, Server, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse, specTypeSchemas } from "@modelcontextprotocol/server";
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, MissingRequiredClientCapabilityError, PROTOCOL_VERSION_META_KEY, ProtocolError as ProtocolError$1, ProtocolErrorCode as ProtocolErrorCode$1, Server, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse, specTypeSchemas } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import https from "https";
 import { SignalProvider } from "@mastra/core/signals";
@@ -12508,8 +12508,8 @@ const WEBHOOK_HEADERS = {
 *
 * @experimental SEP-3415 is a draft Extensions Track proposal. Shapes may change.
 */
-const JsonObjectSchema = z.record(z.string(), z.unknown());
-const MetaSchema = JsonObjectSchema.optional();
+const JsonObjectSchema$1 = z.record(z.string(), z.unknown());
+const MetaSchema$1 = JsonObjectSchema$1.optional();
 const CursorSchema = z.string().nullable();
 const ResultTypeSchema = z.string().optional();
 const RequestIdSchema = z.union([z.string(), z.number()]);
@@ -12520,17 +12520,17 @@ const EventDescriptorSchema = z.looseObject({
 	name: z.string(),
 	description: z.string().optional(),
 	delivery: z.array(z.string()).min(1),
-	inputSchema: JsonObjectSchema.optional(),
-	payloadSchema: JsonObjectSchema.optional(),
-	_meta: MetaSchema
+	inputSchema: JsonObjectSchema$1.optional(),
+	payloadSchema: JsonObjectSchema$1.optional(),
+	_meta: MetaSchema$1
 });
 const EventOccurrenceSchema = z.looseObject({
 	eventId: z.string(),
 	name: z.string(),
 	timestamp: z.string(),
-	data: JsonObjectSchema,
+	data: JsonObjectSchema$1,
 	cursor: CursorSchema.optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 const EventsErrorSchema = z.looseObject({
 	code: z.number().int(),
@@ -12539,7 +12539,7 @@ const EventsErrorSchema = z.looseObject({
 });
 const ListEventsRequestParamsSchema = z.looseObject({
 	cursor: z.string().optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 z.object({
 	method: z.literal(EVENTS_METHODS.list),
@@ -12549,14 +12549,14 @@ const ListEventsResultSchema = z.looseObject({
 	resultType: ResultTypeSchema,
 	events: z.array(EventDescriptorSchema),
 	nextCursor: z.string().optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 const SubscriptionParamsShape = {
 	name: z.string(),
-	arguments: JsonObjectSchema.optional(),
+	arguments: JsonObjectSchema$1.optional(),
 	cursor: CursorSchema.optional(),
 	maxAgeMs: z.number().int().nonnegative().optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 };
 const PollEventsRequestParamsSchema = z.looseObject({
 	...SubscriptionParamsShape,
@@ -12573,7 +12573,7 @@ const PollEventsResultSchema = z.looseObject({
 	truncated: z.boolean().optional(),
 	hasMore: z.boolean().optional(),
 	nextPollMs: z.number().nonnegative().optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 const StreamEventsRequestParamsSchema = z.looseObject(SubscriptionParamsShape);
 z.object({
@@ -12582,7 +12582,7 @@ z.object({
 });
 const StreamEventsResultSchema = z.looseObject({
 	resultType: ResultTypeSchema,
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 /** `_meta` on every `notifications/events/*` message delivered on a push stream. */
 const StreamNotificationMetaSchema = z.looseObject({ [EVENTS_SUBSCRIPTION_ID_META_KEY]: RequestIdSchema });
@@ -12601,7 +12601,7 @@ const EventErrorNotificationParamsSchema = z.looseObject({
 	_meta: StreamNotificationMetaSchema
 });
 const EventTerminatedNotificationParamsSchema = EventErrorNotificationParamsSchema;
-const EventsListChangedNotificationParamsSchema = z.looseObject({ _meta: MetaSchema }).optional();
+const EventsListChangedNotificationParamsSchema = z.looseObject({ _meta: MetaSchema$1 }).optional();
 z.object({
 	method: z.literal(EVENTS_NOTIFICATIONS.active),
 	params: EventActiveNotificationParamsSchema
@@ -12661,13 +12661,13 @@ const SubscribeEventsResultSchema = z.looseObject({
 	cursor: CursorSchema,
 	truncated: z.boolean().optional(),
 	deliveryStatus: WebhookDeliveryStatusSchema.optional(),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 const UnsubscribeEventsRequestParamsSchema = z.looseObject({
 	name: z.string(),
-	arguments: JsonObjectSchema.optional(),
+	arguments: JsonObjectSchema$1.optional(),
 	delivery: z.looseObject({ url: z.string().url() }),
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 z.object({
 	method: z.literal(EVENTS_METHODS.unsubscribe),
@@ -12675,7 +12675,7 @@ z.object({
 });
 const UnsubscribeEventsResultSchema = z.looseObject({
 	resultType: ResultTypeSchema,
-	_meta: MetaSchema
+	_meta: MetaSchema$1
 });
 const WebhookGapBodySchema = z.looseObject({
 	type: z.literal("gap"),
@@ -13224,6 +13224,176 @@ function extractBearerToken(authHeader) {
 	if (authHeader.slice(0, 7).toLowerCase() !== prefix) return void 0;
 	return authHeader.slice(7).trim() || void 0;
 }
+// src/shared/tasks/constants.ts
+/**
+* Wire constants for the MCP Tasks extension (SEP-2663, protocol revision 2026-07-28).
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+/** Extension identifier used as the key under `capabilities.extensions`. */
+const TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
+const TASKS_METHODS = {
+	get: "tasks/get",
+	update: "tasks/update",
+	cancel: "tasks/cancel"
+};
+/** `resultType` of a `tools/call` result that is a task handle instead of a `CallToolResult`. */
+const TASK_RESULT_TYPE = "task";
+const TASK_STATUSES = [
+	"working",
+	"input_required",
+	"completed",
+	"failed",
+	"cancelled"
+];
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"cancelled"
+]);
+/** `completed`, `failed` and `cancelled` are terminal: the task never changes again. */
+function isTerminalTaskStatus(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+const TASKS_ERROR_CODES = {
+	/** Unknown, expired or foreign task id. Also used for a principal mismatch, so existence is not revealed. */
+	InvalidParams: -32602,
+	InternalError: -32603,
+	/** The request needs a task but the client did not declare `io.modelcontextprotocol/tasks`. */
+	MissingRequiredClientCapability: -32021
+};
+/** How long a server keeps a task by default: 24 hours. */
+const DEFAULT_TASK_TTL_MS = 864e5;
+/** Suggested poll interval once a task is older than {@link DEFAULT_TASK_INITIAL_POLL_WINDOW_MS}. */
+const DEFAULT_TASK_POLL_INTERVAL_MS = 5e3;
+// src/shared/tasks/schemas.ts
+/**
+* Zod schemas for the MCP Tasks extension (SEP-2663) wire format.
+*
+* Objects are loose so fields added by later revisions pass through. `resultType` is required on
+* the raw `tools/call` task handle, as the 2026-07-28 revision requires it there.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+const JsonObjectSchema = z.record(z.string(), z.unknown());
+const MetaSchema = JsonObjectSchema.optional();
+const TaskStatusSchema = z.enum(TASK_STATUSES);
+/** An embedded elicitation, sampling or roots request (`{ method, params }`). */
+const TaskInputRequestSchema = z.looseObject({
+	method: z.string(),
+	params: JsonObjectSchema.optional()
+});
+/** Keyed by identifiers that are unique over the task's lifetime. */
+const TaskInputRequestsSchema = z.record(z.string(), TaskInputRequestSchema);
+/** The bare result object answering the input request with the same key. */
+const TaskInputResponsesSchema = z.record(z.string(), JsonObjectSchema);
+const TaskShape = {
+	taskId: z.string().min(1),
+	status: TaskStatusSchema,
+	statusMessage: z.string().optional(),
+	createdAt: z.string(),
+	lastUpdatedAt: z.string(),
+	ttlMs: z.number().int().nonnegative().nullable(),
+	pollIntervalMs: z.number().int().nonnegative().optional()
+};
+z.looseObject(TaskShape);
+const DetailedTaskSchema = z.discriminatedUnion("status", [
+	z.looseObject({
+		...TaskShape,
+		status: z.literal("working")
+	}),
+	z.looseObject({
+		...TaskShape,
+		status: z.literal("input_required"),
+		inputRequests: TaskInputRequestsSchema
+	}),
+	z.looseObject({
+		...TaskShape,
+		status: z.literal("completed"),
+		result: JsonObjectSchema
+	}),
+	z.looseObject({
+		...TaskShape,
+		status: z.literal("failed"),
+		error: JsonObjectSchema
+	}),
+	z.looseObject({
+		...TaskShape,
+		status: z.literal("cancelled")
+	})
+]);
+/** What a server returns from `tools/call` instead of a `CallToolResult` when it creates a task. */
+const CreateTaskResultSchema = z.looseObject({
+	...TaskShape,
+	resultType: z.literal(TASK_RESULT_TYPE),
+	_meta: MetaSchema
+});
+const TaskIdParamsSchema = z.looseObject({
+	taskId: z.string().min(1),
+	_meta: MetaSchema
+});
+const GetTaskRequestParamsSchema = TaskIdParamsSchema;
+const CancelTaskRequestParamsSchema = TaskIdParamsSchema;
+TaskIdParamsSchema.extend({ inputResponses: TaskInputResponsesSchema });
+const UpdateTaskHandlerParamsSchema = TaskIdParamsSchema;
+const CompleteResultShape = {
+	resultType: z.literal("complete").optional(),
+	_meta: MetaSchema
+};
+/** `tasks/get` result: the full task. */
+const GetTaskResultSchema = z.intersection(z.looseObject(CompleteResultShape), DetailedTaskSchema);
+/** `tasks/update` and `tasks/cancel` only acknowledge. */
+const TaskAckResultSchema = z.looseObject(CompleteResultShape);
+// src/shared/tasks/capability.ts
+/**
+* Whether a capabilities object declares the Tasks extension. A non-object entry counts as absent,
+* and the legacy 2025-11-25 top-level `capabilities.tasks` key is ignored: it is not wire-compatible.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function hasTasksCapability(capabilities) {
+	const entry = capabilities?.extensions?.[TASKS_EXTENSION_ID];
+	return typeof entry === "object" && entry !== null && !Array.isArray(entry);
+}
+/**
+* The `extensions` entry a peer advertises to declare the Tasks extension. SEP-2663 defines no
+* settings, so the value is an empty object.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function tasksCapabilityEntry() {
+	return { [TASKS_EXTENSION_ID]: {} };
+}
+// src/shared/tasks/task-id.ts
+/**
+* A new task id: 192 random bits, base64url. Task ids work as bearer tokens, so they must not be
+* guessable or derived from anything else (such as a workflow run id).
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function createTaskId() {
+	return randomBytes(24).toString("base64url");
+}
+/**
+* A stable key for a task that is safe to store and show: the SHA-256 of the task id, base64url.
+* Client and server compute the same key, so traces on both sides can be matched without
+* recording the task id itself.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function taskKeyOf(taskId) {
+	return createHash("sha256").update(taskId).digest("base64url");
+}
+/**
+* The poll interval a server suggests for a task created at `createdAt`: frequent while the task is
+* young, then slower.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function suggestedPollIntervalMs(createdAt, now, options = {}) {
+	const window = options.initialWindowMs ?? 6e4;
+	return now - createdAt < window ? options.initialMs ?? 2e3 : options.steadyMs ?? 5e3;
+}
 // src/shared/trace-context.ts
 /** `_meta` keys defined by the MCP specification for W3C trace propagation. */
 const TRACEPARENT_META_KEY = "traceparent";
@@ -14215,6 +14385,26 @@ function isReconnectableMCPError(error) {
 	const errorMessage = error.message.toLowerCase();
 	return errorMessage.includes("not connected") || errorMessage.includes("http 400") || errorMessage.includes("http 401") || errorMessage.includes("http 403") || errorMessage.includes("http 404") || errorMessage.includes("econnrefused") || errorMessage.includes("fetch failed") || errorMessage.includes("connection refused") || errorMessage.includes("connection closed") || errorMessage.includes("typeerror: terminated");
 }
+const GATEWAY_UNAVAILABLE_STATUSES = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+/**
+* Whether a failed `tasks/get` poll should be retried while waiting out an outage.
+*
+* Adds HTTP 502/503/504 (a proxy or load balancer answering while the server
+* restarts or deploys) to the reconnectable failures. Kept separate from
+* {@link isReconnectableMCPError}: `tasks/get` is idempotent, but a `tools/call`
+* retried after a gateway 5xx could run its work twice.
+*/
+function isRecoverableTaskPollError(error) {
+	if (isReconnectableMCPError(error)) return true;
+	if (!(error instanceof Error)) return false;
+	const { httpStatus } = getMCPDiscoveryErrorDetails(error);
+	if (httpStatus !== void 0) return GATEWAY_UNAVAILABLE_STATUSES.has(httpStatus);
+	return /\bhttp 50[234]\b/i.test(error.message);
+}
 const MAX_DISCOVERY_ERROR_CAUSE_DEPTH = 8;
 function isHttpStatus(value) {
 	return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599;
@@ -15096,6 +15286,270 @@ function getInputSchemaError(schema) {
 	}
 	return result.valid ? void 0 : result.errorMessage.split("; ").at(-1);
 }
+// src/client/tasks/intercept.ts
+/**
+* `_meta` key carrying an intercepted task handle. The `mastra.ai/` prefix keeps it out of the
+* reserved MCP namespace.
+*/
+const TASK_HANDLE_META_KEY = "mastra.ai/mcp-task";
+/**
+* Lets task handles through on a connection that declared the Tasks extension.
+*
+* The SDK rejects `resultType: "task"` before any caller code runs. This rewrites such a response
+* into a complete `CallToolResult` with `isError: true` that carries the task under
+* {@link TASK_HANDLE_META_KEY}: `isError` keeps the SDK from applying the tool's output schema, and
+* if the marker is ever missed the call fails instead of returning a wrong result.
+* Call after `connect()`, which installs the protocol's own message handler.
+*/
+function interceptTaskResults(transport) {
+	const deliver = transport.onmessage;
+	if (!deliver) throw new Error("interceptTaskResults must run after the transport is connected");
+	transport.onmessage = (message, extra) => {
+		const result = "result" in message ? message.result : void 0;
+		if (result?.resultType === "task") {
+			const parsed = CreateTaskResultSchema.safeParse(result);
+			if (parsed.success) {
+				const { resultType: _resultType, _meta, ...task } = parsed.data;
+				message = {
+					...message,
+					result: {
+						resultType: "complete",
+						isError: true,
+						content: [{
+							type: "text",
+							text: `MCP task ${task.taskId} was not awaited`
+						}],
+						_meta: {
+							..._meta ?? {},
+							[TASK_HANDLE_META_KEY]: task
+						}
+					}
+				};
+			}
+		}
+		deliver.call(transport, message, extra);
+	};
+}
+/** The task handle a rewritten result carries, if any. */
+function takeTaskHandle(result) {
+	const handle = result._meta?.[TASK_HANDLE_META_KEY];
+	return handle && typeof handle === "object" ? handle : void 0;
+}
+// src/client/tasks/options.ts
+/** `setTimeout` fires at once for longer delays. */
+const MAX_TIMER_DELAY_MS$1 = 2147483647;
+/** Normalises a server's `tasks` option; `undefined` means tasks are off. */
+function resolveTasksOptions(serverName, option) {
+	if (!option) return void 0;
+	if (option === true) return {};
+	for (const key of ["pollIntervalMs", "maxWaitMs"]) {
+		const value = option[key];
+		if (value !== void 0 && (!Number.isInteger(value) || value <= 0 || value > MAX_TIMER_DELAY_MS$1)) throw new RangeError(`MCP server '${serverName}': tasks.${key} must be a positive integer of at most ${MAX_TIMER_DELAY_MS$1}`);
+	}
+	return option;
+}
+// src/client/tasks/requester.ts
+/**
+* Sends `tasks/get`, `tasks/update` and `tasks/cancel` to one server. Each is sent with an explicit
+* result schema, which the SDK requires for the Tasks extension's methods on the 2026-07-28 revision.
+* The SDK sets the `Mcp-Name: <taskId>` routing header on Streamable HTTP.
+*/
+var TaskRequester = class {
+	client;
+	options;
+	constructor(client, options = {}) {
+		this.client = client;
+		this.options = options;
+	}
+	async get(taskId, options = {}) {
+		const { resultType: _resultType, _meta, ...task } = await this.client.request({
+			method: TASKS_METHODS.get,
+			params: this.params({ taskId })
+		}, GetTaskResultSchema, this.requestOptions(options));
+		return task;
+	}
+	async update(taskId, inputResponses, options = {}) {
+		await this.client.request({
+			method: TASKS_METHODS.update,
+			params: this.params({
+				taskId,
+				inputResponses
+			})
+		}, TaskAckResultSchema, this.requestOptions(options));
+	}
+	async cancel(taskId, options = {}) {
+		await this.client.request({
+			method: TASKS_METHODS.cancel,
+			params: this.params({ taskId })
+		}, TaskAckResultSchema, this.requestOptions(options));
+	}
+	params(params) {
+		const meta = this.options.meta?.();
+		return meta ? {
+			...params,
+			_meta: meta
+		} : params;
+	}
+	requestOptions(options) {
+		return {
+			timeout: this.options.timeout,
+			signal: options.signal
+		};
+	}
+};
+// src/client/tasks/wait.ts
+/** Why a task wait stopped without a terminal task. */
+var TaskWaitError = class extends Error {
+	reason;
+	task;
+	constructor(reason, message, task, cause) {
+		super(message, cause === void 0 ? void 0 : { cause });
+		this.reason = reason;
+		this.task = task;
+		this.name = "TaskWaitError";
+	}
+};
+const DEFAULT_MAX_OUTAGE_MS = 3e5;
+const MAX_OUTAGE_BACKOFF_MS = 3e4;
+/** Polls at least this often, whatever the server suggests. */
+const MAX_TASK_POLL_INTERVAL_MS = 36e5;
+const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) return reject(signal.reason);
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(signal.reason);
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* Polls a remote task until it reaches a terminal status, answering its input requests on the way.
+*
+* Aborting the signal or exceeding `maxWaitMs` sends `tasks/cancel` (fire-and-forget) and rejects.
+* Each input request key is answered at most once, however many polls list it.
+*/
+async function waitForTask(port, created, options = {}) {
+	const sleep = options.sleep ?? defaultSleep;
+	const now = options.now ?? Date.now;
+	const maxOutageMs = options.maxOutageMs ?? DEFAULT_MAX_OUTAGE_MS;
+	const deadline = options.maxWaitMs === void 0 ? void 0 : now() + options.maxWaitMs;
+	const answered = /* @__PURE__ */ new Set();
+	let task = created;
+	const startedAt = now();
+	const ttlEndOf = (current) => {
+		if (current.ttlMs === null) return Infinity;
+		const createdAt = Date.parse(current.createdAt);
+		return (Number.isNaN(createdAt) ? startedAt : createdAt) + current.ttlMs;
+	};
+	let cancelSent = false;
+	const cancel = () => {
+		if (cancelSent) return;
+		cancelSent = true;
+		port.cancel(created.taskId).catch(() => {});
+	};
+	const timedOut = () => new TaskWaitError("timeout", `Gave up on MCP task ${task.taskId} after ${options.maxWaitMs}ms`, task);
+	const stop = new AbortController();
+	const stopped = new Promise((_, reject) => {
+		stop.signal.addEventListener("abort", () => reject(stop.signal.reason), { once: true });
+	});
+	stopped.catch(() => {});
+	const bounded = (operation) => Promise.race([operation, stopped]);
+	const onAbort = () => {
+		cancel();
+		stop.abort(options.signal.reason);
+	};
+	if (options.signal?.aborted) onAbort();
+	else options.signal?.addEventListener("abort", onAbort, { once: true });
+	const deadlineTimer = options.maxWaitMs === void 0 ? void 0 : setTimeout(() => {
+		cancel();
+		stop.abort(timedOut());
+	}, options.maxWaitMs);
+	deadlineTimer?.unref?.();
+	try {
+		let reported;
+		for (;;) {
+			if (task.status !== reported) {
+				reported = task.status;
+				options.onStatus?.(task);
+			}
+			stop.signal.throwIfAborted();
+			if (isTerminalTaskStatus(task.status)) return task;
+			if (task.status === "input_required" && "inputRequests" in task) {
+				const { inputRequests } = task;
+				const pending = Object.entries(inputRequests).filter(([key]) => !answered.has(key));
+				if (pending.length > 0) {
+					const responses = await bounded(answerInputRequests(pending, task, options.inputRequests, stop.signal));
+					for (const key of Object.keys(responses)) answered.add(key);
+					await bounded(port.update(task.taskId, responses, { signal: stop.signal }));
+					task = await poll();
+					continue;
+				}
+			}
+			const ttlLeft = ttlEndOf(task) - now();
+			if (ttlLeft <= 0) throw new TaskWaitError("expired", `MCP task ${task.taskId} outlived its ${task.ttlMs}ms TTL`, task);
+			let interval = Math.min(pollIntervalOf(task), ttlLeft);
+			if (deadline !== void 0) {
+				const remaining = deadline - now();
+				if (remaining <= 0) {
+					cancel();
+					throw timedOut();
+				}
+				interval = Math.min(interval, remaining);
+			}
+			await bounded(sleep(interval, stop.signal));
+			task = await poll();
+		}
+		function pollIntervalOf(current) {
+			const suggested = current.pollIntervalMs ?? options.pollIntervalMs ?? 5e3;
+			return Number.isFinite(suggested) ? Math.min(MAX_TASK_POLL_INTERVAL_MS, Math.max(100, suggested)) : DEFAULT_TASK_POLL_INTERVAL_MS;
+		}
+		async function poll() {
+			let outageStartedAt;
+			let backoff;
+			for (;;) try {
+				return await bounded(port.get(created.taskId, { signal: stop.signal }));
+			} catch (error) {
+				stop.signal.throwIfAborted();
+				if (!port.isRecoverable(error)) throw error;
+				const at = now();
+				outageStartedAt ??= at;
+				if (deadline !== void 0 && at >= deadline) {
+					cancel();
+					throw timedOut();
+				}
+				const giveUpAt = Math.min(outageStartedAt + maxOutageMs, ttlEndOf(task));
+				if (at >= giveUpAt) throw new TaskWaitError("unreachable", `Couldn't reach the MCP server for ${Math.round((at - outageStartedAt) / 1e3)}s while waiting for task ${task.taskId}; the task may still finish on the server`, task, error);
+				try {
+					await bounded(port.recover(error));
+				} catch (recoverError) {
+					stop.signal.throwIfAborted();
+					if (!port.isRecoverable(recoverError)) throw recoverError;
+				}
+				backoff = Math.min(MAX_OUTAGE_BACKOFF_MS, backoff === void 0 ? pollIntervalOf(task) : backoff * 2);
+				await bounded(sleep(Math.max(0, Math.min(backoff, giveUpAt - at, (deadline ?? Infinity) - at)), stop.signal));
+			}
+		}
+	} finally {
+		clearTimeout(deadlineTimer);
+		options.signal?.removeEventListener("abort", onAbort);
+	}
+}
+async function answerInputRequests(pending, task, handler, signal) {
+	if (!handler) throw new TaskWaitError("input_unhandled", `MCP task ${task.taskId} needs input, but no inputRequests handler is configured`, task);
+	const responses = {};
+	for (const [key, request] of pending) {
+		if (request.method !== "elicitation/create") throw new TaskWaitError("input_unsupported", `MCP task ${task.taskId} sent an unsupported input request '${request.method}'`, task);
+		responses[key] = await handler({
+			key,
+			params: request.params,
+			signal
+		});
+	}
+	return responses;
+}
 // src/client/url-policy.ts
 /**
 * Redirect status codes the manual redirect loop follows. Other 3xx statuses
@@ -15302,6 +15756,13 @@ function shouldDetachPersistentTransportRequest(init) {
 		return false;
 	}
 }
+const TASK_WAIT_ERROR_IDS = {
+	timeout: "MCP_CLIENT_TOOL_TASK_TIMEOUT",
+	expired: "MCP_CLIENT_TOOL_TASK_EXPIRED",
+	input_unhandled: "MCP_CLIENT_TOOL_TASK_INPUT_UNHANDLED",
+	input_unsupported: "MCP_CLIENT_TOOL_TASK_INPUT_UNSUPPORTED",
+	unreachable: "MCP_CLIENT_TOOL_TASK_POLL_FAILED"
+};
 /**
 * Reports the JSON-RPC id of each `events/stream` request as it goes out on `transport`. The
 * server identifies a push stream by that id, and the SDK doesn't return it to the caller.
@@ -15488,6 +15949,8 @@ var InternalMastraMCPClient = class extends MastraBase {
 	priorDiscovery;
 	requireToolApproval;
 	onToolError;
+	taskOptions;
+	taskRequester;
 	jsonSchemaValidator;
 	jsonSchemaValidatorPromise;
 	/** Provides access to resource operations (list, read, notifications) */
@@ -15519,13 +15982,15 @@ var InternalMastraMCPClient = class extends MastraBase {
 		this.requireToolApproval = server.requireToolApproval;
 		this.onToolError = server.onToolError ?? "throw";
 		this.jsonSchemaValidator = server.jsonSchemaValidator;
+		this.taskOptions = resolveTasksOptions(name, server.tasks);
 		const configured = server.capabilities ?? {};
 		if (configured.elicitation !== void 0 && !server.inputRequests) throw new Error(`MCP server '${name}' advertises the elicitation capability without an inputRequests handler. Configure inputRequests or remove capabilities.elicitation.`);
 		const clientCapabilities = {
 			...server.inputRequests ? { elicitation: configured.elicitation ?? { form: {} } } : {},
 			extensions: {
 				...configured.extensions ?? {},
-				"io.modelcontextprotocol/ui": {}
+				"io.modelcontextprotocol/ui": {},
+				...this.taskOptions ? tasksCapabilityEntry() : {}
 			}
 		};
 		this.client = new Client({
@@ -15536,6 +16001,10 @@ var InternalMastraMCPClient = class extends MastraBase {
 			...server.jsonSchemaValidator ? { jsonSchemaValidator: server.jsonSchemaValidator } : {},
 			versionNegotiation: { mode: negotiationMode(server.protocolVersion) }
 		});
+		this.taskRequester = new TaskRequester(this.client, {
+			timeout: this.timeout,
+			meta: () => this.requestMeta()
+		});
 		if (server.inputRequests) {
 			const handler = server.inputRequests;
 			this.client.setRequestHandler("elicitation/create", async (request, ctx) => {
@@ -15645,6 +16114,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 				timeout: this.serverConfig.timeout ?? this.timeout,
 				prior: this.priorDiscovery
 			});
+			if (this.taskOptions) interceptTaskResults(transport);
 			this.transport = transport;
 			this.log("debug", `Successfully connected to MCP server via Stdio`);
 		} catch (e) {
@@ -15678,6 +16148,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 				timeout: connectTimeout ?? DEFAULT_SERVER_CONNECT_TIMEOUT_MSEC,
 				prior: this.priorDiscovery
 			});
+			if (this.taskOptions) interceptTaskResults(transport);
 			this.transport = transport;
 			this.log("debug", "Successfully connected using Streamable HTTP transport.");
 			this.closePendingAuthTransport();
@@ -16474,6 +16945,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 				strict: getMastraToolStrictMeta(toolMeta),
 				...mcpToolProps,
 				requireApproval,
+				...this.taskOptions ? { background: this.taskToolBackgroundConfig() } : {},
 				mcpMetadata: {
 					serverName: this.name,
 					serverVersion: serverMeta.version,
@@ -16506,6 +16978,13 @@ var InternalMastraMCPClient = class extends MastraBase {
 							}));
 							const toolCallSpan = context?.tracingContext?.currentSpan;
 							if (toolCallSpan && serverSpan) toolCallSpan.links = [...toolCallSpan.links ?? [], serverSpan];
+							const task = this.taskOptions ? takeTaskHandle(res) : void 0;
+							if (!task) return finishToolCall(res);
+							this.log("debug", `Tool ${tool.name} continues as MCP task ${task.taskId}`);
+							toolCallSpan?.update({ metadata: { mcpTaskKey: taskKeyOf(task.taskId) } });
+							return finishToolCall(await this.awaitToolTask(tool.name, task, context?.abortSignal, context?.writer));
+						};
+						const finishToolCall = async (res) => {
 							if (res.isError && this.onToolError === "throw") {
 								const errorText = extractToolErrorText(res.content);
 								this.log("debug", `Tool reported an error: ${tool.name}`, { error: errorText });
@@ -16540,7 +17019,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 						try {
 							return await executeToolCall();
 						} catch (e) {
-							if (!(e instanceof MastraError && e.id === "MCP_CLIENT_TOOL_EXECUTION_FAILED") && isReconnectableMCPError(e)) {
+							if (!(e instanceof MastraError && (e.id === "MCP_CLIENT_TOOL_EXECUTION_FAILED" || e.id.startsWith("MCP_CLIENT_TOOL_TASK_"))) && isReconnectableMCPError(e)) {
 								this.log("debug", `Transport error detected for tool ${tool.name}, attempting reconnection...`, { error: e instanceof Error ? e.message : String(e) });
 								try {
 									await this.reconnectAfterTransportFailure(failedTransport, lifecycleGeneration);
@@ -16574,6 +17053,78 @@ var InternalMastraMCPClient = class extends MastraBase {
 			return;
 		}
 	}
+	/** Reads, answers and cancels this server's tasks (SEP-2663). */
+	get tasks() {
+		return this.taskRequester;
+	}
+	/**
+	* Background settings for tools of a tasks-enabled server: they may run for as long as the
+	* remote task, and must never be retried, as a retry would start a second task.
+	*/
+	taskToolBackgroundConfig() {
+		return {
+			enabled: true,
+			defaultDisposition: "deferred",
+			timeoutMs: this.taskOptions?.maxWaitMs ?? 864e5,
+			maxRetries: 0
+		};
+	}
+	/** Waits for a remote task created by a tool call and returns its `CallToolResult`. */
+	async awaitToolTask(toolName, task, signal, writer) {
+		const details = {
+			toolName,
+			serverName: this.name,
+			taskId: task.taskId
+		};
+		const onStatus = (current) => {
+			const progress = {
+				type: "mcp-task",
+				taskId: current.taskId,
+				status: current.status,
+				createdAt: current.createdAt,
+				serverName: this.name
+			};
+			writer?.write(progress).catch(() => {});
+		};
+		const fail = (id, text, cause) => new MastraError({
+			id,
+			domain: ErrorDomain.MCP,
+			category: ErrorCategory.THIRD_PARTY,
+			text,
+			details
+		}, cause);
+		const lifecycleGeneration = this.lifecycleGeneration;
+		let polledTransport;
+		let terminal;
+		try {
+			terminal = await waitForTask({
+				get: (taskId, options) => {
+					polledTransport = this.transport;
+					return this.taskRequester.get(taskId, options);
+				},
+				update: (taskId, responses, options) => this.taskRequester.update(taskId, responses, options),
+				cancel: (taskId) => this.taskRequester.cancel(taskId),
+				isRecoverable: isRecoverableTaskPollError,
+				recover: () => this.reconnectAfterTransportFailure(polledTransport, lifecycleGeneration)
+			}, task, {
+				signal,
+				inputRequests: this.serverConfig.inputRequests,
+				pollIntervalMs: this.taskOptions?.pollIntervalMs,
+				maxWaitMs: this.taskOptions?.maxWaitMs,
+				onStatus
+			});
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			if (error instanceof TaskWaitError) throw fail(TASK_WAIT_ERROR_IDS[error.reason], error.message, error.cause);
+			const reason = error instanceof Error ? error.message : String(error);
+			throw fail("MCP_CLIENT_TOOL_TASK_POLL_FAILED", `Polling MCP task ${task.taskId} failed: ${reason}`, error);
+		}
+		switch (terminal.status) {
+			case "completed": return terminal.result;
+			case "cancelled": throw fail("MCP_CLIENT_TOOL_TASK_CANCELLED", terminal.statusMessage ?? `MCP task ${task.taskId} was cancelled`);
+			case "failed": throw fail("MCP_CLIENT_TOOL_TASK_FAILED", (typeof terminal.error.message === "string" ? terminal.error.message : void 0) ?? terminal.statusMessage ?? `MCP task ${task.taskId} failed`);
+		}
+	}
 	stampServerIdInMeta(meta) {
 		const ui = meta.ui;
 		if (!ui?.resourceUri) return meta;
@@ -17592,6 +18143,63 @@ To fix this you have three different options:
 		};
 	}
 	/**
+	* Reads, answers and cancels MCP tasks (SEP-2663) on configured servers. Tool calls to a server
+	* with `tasks` enabled already wait for their tasks; use this to inspect or steer one directly.
+	*
+	* @experimental SEP-2663 extension; this API may change.
+	*
+	* @example
+	* ```typescript
+	* const task = await mcp.tasks.get('reports', taskId);
+	* if (task.status === 'working') await mcp.tasks.cancel('reports', taskId);
+	* ```
+	*/
+	get tasks() {
+		this.addToInstanceCache();
+		const wrap = async (id, details, run) => {
+			try {
+				return await run();
+			} catch (error) {
+				throw new MastraError({
+					id,
+					domain: ErrorDomain.MCP,
+					category: ErrorCategory.THIRD_PARTY,
+					details
+				}, error);
+			}
+		};
+		return {
+			/**
+			* Returns a task's current state, including its result once completed.
+			*
+			* @throws {MastraError} `MCP_CLIENT_GET_TASK_FAILED`; the cause is a `-32602` protocol error
+			* when the server does not know the task.
+			*/
+			get: (serverName, taskId, options) => wrap("MCP_CLIENT_GET_TASK_FAILED", {
+				serverName,
+				taskId
+			}, async () => (await this.getConnectedClientForServer(serverName)).tasks.get(taskId, options)),
+			/**
+			* Answers input requests of an `input_required` task, keyed as in its `inputRequests`.
+			*
+			* @throws {MastraError} `MCP_CLIENT_UPDATE_TASK_FAILED`
+			*/
+			update: (serverName, taskId, inputResponses, options) => wrap("MCP_CLIENT_UPDATE_TASK_FAILED", {
+				serverName,
+				taskId
+			}, async () => (await this.getConnectedClientForServer(serverName)).tasks.update(taskId, inputResponses, options)),
+			/**
+			* Asks the server to stop a task. Cancellation is cooperative: the task may still complete.
+			*
+			* @throws {MastraError} `MCP_CLIENT_CANCEL_TASK_FAILED`
+			*/
+			cancel: (serverName, taskId, options) => wrap("MCP_CLIENT_CANCEL_TASK_FAILED", {
+				serverName,
+				taskId
+			}, async () => (await this.getConnectedClientForServer(serverName)).tasks.cancel(taskId, options))
+		};
+	}
+	/**
 	* Provides access to resource-related operations across all configured servers.
 	*
 	* Resources represent data exposed by MCP servers (files, database records, API responses, etc.).
@@ -18802,14 +19410,45 @@ async function toRequestContext(ctx, mapAuthInfoToUser) {
 * never share a principal. A token refreshed mid-round therefore starts over.
 */
 function principalOf(ctx, requestContext) {
+	return callerOf(ctx, requestContext).principal;
+}
+/**
+* A readable name for the caller, for operators debugging a server: the principal, except that a
+* token principal keeps only a short prefix of the token's hash. Never a credential, so it can be
+* stored and shown; it is not unique enough to authorize anything.
+*/
+function clientLabelOf(ctx, requestContext) {
+	return callerOf(ctx, requestContext).label;
+}
+const TOKEN_LABEL_HASH_LENGTH = 8;
+function callerOf(ctx, requestContext) {
 	const authInfo = ctx.http?.authInfo;
-	if (!authInfo) return "anonymous";
+	if (!authInfo) return {
+		principal: "anonymous",
+		label: "anonymous"
+	};
 	const subject = authInfo.extra?.sub ?? authInfo.extra?.subject;
-	if (typeof subject === "string" && subject) return `${authInfo.clientId}:sub:${subject}`;
+	if (typeof subject === "string" && subject) {
+		const principal = `${authInfo.clientId}:sub:${subject}`;
+		return {
+			principal,
+			label: principal
+		};
+	}
 	const user = requestContext.get("user");
 	const userId = user && typeof user === "object" ? user.id : void 0;
-	if (typeof userId === "string" && userId) return `${authInfo.clientId}:user:${userId}`;
-	return `${authInfo.clientId}:token:${createHash("sha256").update(authInfo.token).digest("base64url")}`;
+	if (typeof userId === "string" && userId) {
+		const principal = `${authInfo.clientId}:user:${userId}`;
+		return {
+			principal,
+			label: principal
+		};
+	}
+	const tokenHash = createHash("sha256").update(authInfo.token).digest("base64url");
+	return {
+		principal: `${authInfo.clientId}:token:${tokenHash}`,
+		label: `${authInfo.clientId}:token:${tokenHash.slice(0, TOKEN_LABEL_HASH_LENGTH)}`
+	};
 }
 function hashArguments(value) {
 	return createHash("sha256").update(canonicalJSON(value)).digest("base64url");
@@ -20198,65 +20837,1742 @@ function echoes(body, challenge) {
 	const b = Buffer.from(challenge);
 	return a.length === b.length && timingSafeEqual(a, b);
 }
-// src/server/server.ts
-const EMPTY_OBJECT_SCHEMA = {
-	type: "object",
-	properties: {}
-};
+// src/server/tasks/store.ts
+/** How a principal is stored and shown. Principals can carry user and subject ids, so only their hash is kept. */
+function principalKeyOf(principal) {
+	return createHash("sha256").update(principal).digest("base64url");
+}
 /**
-* Exposes Mastra tools, agents, workflows, resources and prompts to Model Context
-* Protocol (MCP) clients using protocol revision 2026-07-28: self-contained requests
-* over Streamable HTTP or stdio, native `input_required` continuation and
-* per-request logging.
-*
-* @example
-* `yourTool` is a tool you have already configured.
-* ```typescript
-* import { MCPServer } from '@mastra/mcp';
-*
-* const server = new MCPServer({
-*   id: 'my-server',
-*   name: 'My Server',
-*   version: '1.0.0',
-*   tools: { yourTool },
-* });
-* await server.startStdio();
-* ```
-*
-* @see For documentation bundled with your installed package, locate
-* `@mastra/mcp/package.json` with your project's resolver or package-manager
-* tooling, then read `dist/docs/SKILL.md` from that package root and follow its
-* reference links. Use package-manager tools for virtual or archived packages.
+* Thrown by {@link MCPTaskStore.create} when the task would go over one of its `limits`.
 *
-* @see [MCP server documentation](https://mastra.ai/reference/tools/mcp-server)
-* if packaged docs are unavailable.
+* @experimental SEP-2663 extension; API may change.
 */
-var MCPServer = class extends MCPServerBase {
-	mcpVersion = 2;
-	resources;
-	prompts;
-	toolActions;
-	/**
-	* Publishes occurrences of the configured `events` to poll, push and (when
-	* `eventsOptions.webhook` is set) webhook subscribers.
-	*
-	* @experimental SEP-3415 is a draft; this API may change.
-	*/
-	events;
-	resourceOptions;
-	promptOptions;
-	appResourceList = [];
-	appResourceHtml = /* @__PURE__ */ new Map();
-	jsonSchemaValidator;
-	cacheHints;
-	mapAuthInfoToUser;
-	fga;
-	requestStateCodec;
-	eventRegistry;
+var MCPTaskLimitError = class extends Error {
+	scope;
+	limit;
+	kind;
+	constructor(scope, limit, kind = "open") {
+		super(`Too many ${kind} MCP tasks ${scope === "principal" ? "for this principal" : "in this store"} (limit ${limit})`);
+		this.scope = scope;
+		this.limit = limit;
+		this.kind = kind;
+		this.name = "MCPTaskLimitError";
+	}
+};
+function decodeTaskListCursor(cursor) {
+	if (!cursor) return void 0;
+	try {
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (typeof parsed.before === "string" && !Number.isNaN(Date.parse(parsed.before)) && Array.isArray(parsed.seen)) return {
+			before: parsed.before,
+			seen: parsed.seen.filter((key) => typeof key === "string")
+		};
+	} catch {}
+}
+/** Whether a task comes after the cursor in newest-first order. */
+function isPastTaskListCursor(listing, cursor) {
+	if (!cursor) return true;
+	const created = Date.parse(listing.createdAt);
+	const before = Date.parse(cursor.before);
+	return created < before || created === before && !cursor.seen.includes(listing.taskKey);
+}
+/** The cursor for the page after `listings`, newest first. */
+function nextTaskListCursor(listings, previous) {
+	const last = listings.at(-1);
+	if (!last) return void 0;
+	const before = Date.parse(last.createdAt);
+	const seen = listings.filter((listing) => Date.parse(listing.createdAt) === before).map((listing) => listing.taskKey);
+	if (previous && Date.parse(previous.before) === before) seen.push(...previous.seen);
+	const cursor = {
+		before: new Date(before).toISOString(),
+		seen
+	};
+	return Buffer.from(JSON.stringify(cursor)).toString("base64url");
+}
+/** Whether a listing matches the filters a store could not apply while reading. */
+function matchesTaskListOptions(listing, options) {
+	if (options.status && listing.status !== options.status) return false;
+	if (options.surface && listing.context?.toolName !== options.surface) return false;
+	if (options.principalKey && listing.principalKey !== options.principalKey) return false;
+	if (options.taskKey && listing.taskKey !== options.taskKey) return false;
+	return true;
+}
+/** @experimental SEP-2663 extension; API may change. */
+function isMCPTaskStoreAdmin(store) {
+	const admin = store;
+	return typeof admin.list === "function" && typeof admin.updateByKey === "function" && typeof admin.cancelByKey === "function";
+}
+/** Projects a detailed task onto a listing. */
+function toListing(taskKey, principalKey, context, task, clientLabel) {
+	return {
+		taskKey,
+		principalKey,
+		...clientLabel !== void 0 && { clientLabel },
+		...context && { context },
+		status: task.status,
+		...task.statusMessage !== void 0 && { statusMessage: task.statusMessage },
+		createdAt: task.createdAt,
+		lastUpdatedAt: task.lastUpdatedAt,
+		ttlMs: task.ttlMs,
+		...task.status === "input_required" && { inputRequests: task.inputRequests },
+		...task.status === "completed" && { result: task.result },
+		...task.status === "failed" && { error: task.error }
+	};
+}
+// src/server/tasks/background-store.ts
+const ENVELOPE_VERSION = 1;
+/** For `ttlMs: null`: a deadline cleanup never reaches. */
+const NEVER = /* @__PURE__ */ new Date("9999-12-31T00:00:00.000Z");
+/** The longest delay `setTimeout` honours; larger values fire at once. */
+const MAX_TIMEOUT_MS = 2 ** 31 - 1;
+/** How long an expired task still answers `failed` before it is forgotten. */
+const EXPIRED_RETENTION_MS = 6e4;
+/** What core writes when recovery reclaims a crashed attempt it won't run again. */
+const CORE_LOST_MESSAGE = "Worker process terminated before task completed";
+const TASK_LOST_MESSAGE = "task lost: the server restarted while it was running";
+const TASK_EXPIRED_MESSAGE = "Task expired before it finished";
+const TERMINAL_ROW_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"timed_out"
+]);
+const OPEN_ROW_STATUSES = [
+	"pending",
+	"running",
+	"suspended"
+];
+const UPDATE_ATTEMPTS = 3;
+/**
+* The row statuses {@link projectTask} can turn into each task status: a suspended row whose
+* requests are all answered is working, and an open row past its TTL is failed.
+*/
+const ROW_STATUSES_FOR = {
+	working: [
+		"pending",
+		"running",
+		"suspended"
+	],
+	input_required: ["suspended"],
+	completed: ["completed"],
+	cancelled: ["cancelled"],
+	failed: [
+		"failed",
+		"timed_out",
+		...OPEN_ROW_STATUSES
+	]
+};
+/** How long an aborted attempt's row is watched for core to record why: from 50ms apart, backing off to 1s. */
+const ABORT_SETTLE_FIRST_READ_MS = 50;
+const ABORT_SETTLE_MAX_READ_MS = 1e3;
+/** The most rows one sweep reads, in each of its two listings. */
+const SWEEP_BATCH = 100;
+/** Running, or pending but pinned (`pinToWorker`) to the worker that holds its attempt. */
+function isOwned(row) {
+	return row.status === "running" || row.status === "pending" && Boolean(row.ownerId);
+}
+function isTerminalRow(row) {
+	return TERMINAL_ROW_STATUSES.has(row.status);
+}
+function envelopeOf(row) {
+	const metadata = row.metadata;
+	return metadata?.v === ENVELOPE_VERSION && typeof metadata.principalKey === "string" ? metadata : void 0;
+}
+function openInputRequests(envelope) {
+	const answered = envelope.inputResponses ?? {};
+	return Object.fromEntries(Object.entries(envelope.inputRequests ?? {}).filter(([key]) => !(key in answered)));
+}
+function isFullyAnswered(row, envelope) {
+	return row.status === "suspended" && Object.keys(envelope.inputRequests ?? {}).length > 0 && Object.keys(openInputRequests(envelope)).length === 0;
+}
+/**
+* Stopped by a client, by expiry (the sweep cancels the row, then records it as failed), or by core
+* timing the attempt out at the task's TTL.
+*/
+function wasStopped(row, now) {
+	return row.status === "cancelled" || row.status === "timed_out" || row.status === "failed" && isExpired(row, now);
+}
+function isExpired(row, now) {
+	return row.expiresAt !== void 0 && row.expiresAt.getTime() <= now;
+}
+/** Terminal past its deadline: gone, whether or not cleanup has deleted the row yet. */
+function isForgotten(row, now) {
+	return isTerminalRow(row) && row.expiresAt !== void 0 && row.expiresAt.getTime() + EXPIRED_RETENTION_MS <= now;
+}
+function latest(...dates) {
+	return new Date(Math.max(...dates.filter((date) => date !== void 0).map((date) => date.getTime())));
+}
+/**
+* Projects a background-task row onto the MCP task it backs, as `tasks/get` answers it.
+*
+* A row still running past its TTL reads as `failed` before the sweep gets to it.
+*/
+function projectTask(row, envelope, taskId, now) {
+	const base = {
+		taskId,
+		status: "working",
+		createdAt: row.createdAt.toISOString(),
+		lastUpdatedAt: latest(row.createdAt, row.startedAt, row.suspendedAt, row.completedAt).toISOString(),
+		ttlMs: envelope.ttlMs,
+		pollIntervalMs: envelope.pollIntervalMs ?? suggestedPollIntervalMs(row.createdAt.getTime(), now)
+	};
+	const failed = (message) => ({
+		...base,
+		status: "failed",
+		error: {
+			code: TASKS_ERROR_CODES.InternalError,
+			message
+		}
+	});
+	if (!isTerminalRow(row) && isExpired(row, now)) return failed(TASK_EXPIRED_MESSAGE);
+	switch (row.status) {
+		case "pending":
+		case "running": return base;
+		case "suspended": {
+			const open = openInputRequests(envelope);
+			return Object.keys(open).length === 0 ? base : {
+				...base,
+				status: "input_required",
+				inputRequests: open
+			};
+		}
+		case "completed": return {
+			...base,
+			status: "completed",
+			result: { ...row.result }
+		};
+		case "cancelled": return {
+			...base,
+			status: "cancelled"
+		};
+		case "timed_out": return failed(isExpired(row, now) ? TASK_EXPIRED_MESSAGE : row.error?.message ?? "Task timed out");
+		case "failed": {
+			const message = row.error?.message ?? "Task failed";
+			return failed(message === CORE_LOST_MESSAGE ? TASK_LOST_MESSAGE : message);
+		}
+	}
+}
+/**
+* An {@link MCPTaskStore} on Mastra's background tasks: every MCP task is a background-task row in
+* Mastra's storage, so any instance sharing that storage can read, answer and cancel it, and run it.
+*
+* Rows are owned by `mcp-server:<serverId>` and keyed by a hash of the task id. Each attempt runs
+* the tool's work rebuilt from the row (`workFor`), through a static executor registered for
+* every task tool, so a worker other than the creating one can run it.
+*/
+var BackgroundTaskMCPTaskStore = class {
+	#manager;
+	#owner;
+	#workFor;
+	#recoverFor;
+	#getLogger;
+	#gates = /* @__PURE__ */ new Map();
+	/**
+	* Aborts for first attempts already running under their request, by row id, until the row's
+	* executor takes the attempt over. A row pinned here can wait for a slot while its attempt runs,
+	* and the manager can't abort an attempt it never started.
+	*/
+	#firstAttempts = /* @__PURE__ */ new Map();
+	#executors = /* @__PURE__ */ new Set();
+	#onCancel;
+	#sweepTimer;
+	#closed = false;
+	#sweeping;
+	/** The page of open rows the next sweep checks. */
+	#sweepPage = 0;
+	constructor(options) {
+		this.#manager = options.manager;
+		this.#owner = `mcp-server:${options.serverId}`;
+		this.#workFor = options.workFor;
+		this.#recoverFor = options.recoverFor;
+		this.#onCancel = options.onCancel;
+		this.#getLogger = options.logger;
+	}
+	/** The `agentId` every row of this server carries. */
+	get owner() {
+		return this.#owner;
+	}
+	/**
+	* The row's `toolName`: `mcp-server:<serverId>:<tool>`. Core looks an executor up as
+	* `<agentId>:<toolName>`, then as the bare `toolName`; the bare lookup hits the executor
+	* registered under this name, never a Mastra tool named like the MCP tool. Where no executor is
+	* registered (the server closed, an older instance, a worker without the server), the attempt
+	* fails instead of running a same-named tool with the task's arguments.
+	*/
+	#rowToolName(toolName) {
+		return `${this.#owner}:${toolName}`;
+	}
+	/**
+	* Registers the executor that runs `toolName`'s tasks on any worker. It must be registered on
+	* every instance before the manager recovers rows, or recovered attempts find no executor.
+	*/
+	registerTool(toolName) {
+		const key = this.#rowToolName(toolName);
+		this.#manager.registerStaticExecutor(key, { execute: (args, options) => {
+			const { context } = args;
+			return this.#execute(this.#workFor(context), args, options);
+		} });
+		this.#executors.add(key);
+	}
+	async create(params, { pinToWorker = false, clientLabel } = {}) {
+		const context = params.context;
+		if (!context || typeof context.toolName !== "string") throw new Error("A background-task MCP task needs the tool it runs in its context");
+		if (!this.#executors.has(this.#rowToolName(context.toolName))) this.registerTool(context.toolName);
+		this.#startSweeping();
+		const taskId = createTaskId();
+		const taskKey = taskKeyOf(taskId);
+		const recover = this.#recoverFor(context.toolName);
+		const principalKey = principalKeyOf(params.principal);
+		if (params.limits) await this.#checkLimits(params.limits, principalKey);
+		const envelope = {
+			v: ENVELOPE_VERSION,
+			principalKey,
+			...clientLabel !== void 0 && { clientLabel },
+			...params.trace && { trace: {
+				traceId: params.trace.traceId,
+				spanId: params.trace.spanId
+			} },
+			ttlMs: params.ttlMs,
+			...params.pollIntervalMs !== void 0 && { pollIntervalMs: params.pollIntervalMs },
+			recover,
+			usedInputKeys: []
+		};
+		const createdAt = Date.now();
+		const gate = {};
+		gate.promise = new Promise((resolve) => gate.resolve = resolve);
+		this.#gates.set(taskId, gate);
+		let first = true;
+		const taskContext = { executor: { execute: async (args, options) => {
+			const { work, options: runOptions } = await gate.promise;
+			const initial = first ? runOptions.initialAttempt : void 0;
+			first = false;
+			if (initial && gate.rowId) this.#firstAttempts.delete(gate.rowId);
+			return this.#execute(work, args, options, initial);
+		} } };
+		const args = {
+			taskKey,
+			context
+		};
+		try {
+			const { task, fallbackToSync } = await this.#manager.enqueue({
+				runId: taskKey,
+				toolName: this.#rowToolName(context.toolName),
+				toolCallId: taskKey,
+				args,
+				agentId: this.#owner,
+				resourceId: `${this.#owner}:${principalKey}`,
+				timeoutMs: params.ttlMs === null ? MAX_TIMEOUT_MS : Math.min(Math.max(params.ttlMs, 1), MAX_TIMEOUT_MS),
+				maxRetries: recover ? 1 : 0,
+				expiresAt: params.ttlMs === null ? NEVER : new Date(createdAt + params.ttlMs),
+				metadata: envelope
+			}, taskContext, { pinToWorker });
+			if (fallbackToSync) throw new Error("Background tasks are at capacity and backpressure is 'fallback-sync'; MCP tasks need 'queue'");
+			gate.rowId = task.id;
+		} catch (error) {
+			this.#gates.delete(taskId);
+			throw error;
+		}
+		return {
+			taskId,
+			status: "working",
+			createdAt: new Date(createdAt).toISOString(),
+			lastUpdatedAt: new Date(createdAt).toISOString(),
+			ttlMs: params.ttlMs,
+			pollIntervalMs: params.pollIntervalMs ?? suggestedPollIntervalMs(createdAt, createdAt)
+		};
+	}
+	/**
+	* Counts open rows (not finished and not past their TTL) in storage, so the limits hold across
+	* every instance sharing it. Counting and inserting are separate writes, so creates racing on
+	* different instances can each pass the count and overshoot a limit by up to their number.
+	*/
+	async #checkLimits(limits, principalKey) {
+		const open = {
+			agentId: this.#owner,
+			status: OPEN_ROW_STATUSES,
+			dateFilterBy: "expiresAt",
+			fromDate: new Date(Date.now() + 1),
+			perPage: 1
+		};
+		if ((await this.#manager.listTasks({
+			...open,
+			resourceId: `${this.#owner}:${principalKey}`
+		})).total >= limits.perPrincipal) throw new MCPTaskLimitError("principal", limits.perPrincipal);
+		if ((await this.#manager.listTasks(open)).total >= limits.total) throw new MCPTaskLimitError("total", limits.total);
+	}
+	run(taskId, work, options = {}) {
+		const gate = this.#gates.get(taskId);
+		if (!gate) throw new Error(`MCP task ${taskKeyOf(taskId)} not found`);
+		this.#gates.delete(taskId);
+		const { initialAttempt } = options;
+		if (initialAttempt && gate.rowId) {
+			const rowId = gate.rowId;
+			this.#firstAttempts.set(rowId, initialAttempt.abort);
+			const done = () => {
+				if (this.#firstAttempts.get(rowId) === initialAttempt.abort) this.#firstAttempts.delete(rowId);
+			};
+			initialAttempt.outcome.then(done, done);
+		}
+		gate.resolve({
+			work,
+			options
+		});
+	}
+	async get(taskId, access) {
+		this.#startSweeping();
+		const found = await this.#find(taskKeyOf(taskId), access);
+		if (!found) return void 0;
+		const { row, envelope } = found;
+		if (isTerminalRow(row)) this.#manager.deregisterTaskContext(row.id);
+		if (isFullyAnswered(row, envelope)) await this.#resume(row, envelope);
+		return projectTask(row, envelope, taskId, Date.now());
+	}
+	async update(taskId, inputResponses, access) {
+		const taskKey = taskKeyOf(taskId);
+		return await this.#update(taskKey, inputResponses, `with key "${taskKey}"`, access) !== "not_found";
+	}
+	async cancel(taskId, access) {
+		return await this.#cancel(taskKeyOf(taskId), access) !== "not_found";
+	}
+	/** Lists this server's tasks across principals, most recently created first. */
+	async list(options = {}) {
+		this.#startSweeping();
+		const limit = options.limit ?? 50;
+		const cursor = decodeTaskListCursor(options.cursor);
+		const now = Date.now();
+		const matching = [];
+		for (let page = 0; matching.length <= limit; page++) {
+			const { tasks } = await this.#manager.listTasks({
+				agentId: this.#owner,
+				...options.surface && { toolName: this.#rowToolName(options.surface) },
+				...options.principalKey && { resourceId: `${this.#owner}:${options.principalKey}` },
+				...options.taskKey && { toolCallId: options.taskKey },
+				...options.status && { status: ROW_STATUSES_FOR[options.status] },
+				...cursor && { toDate: new Date(Date.parse(cursor.before) + 1) },
+				orderBy: "createdAt",
+				orderDirection: "desc",
+				page,
+				perPage: limit + 1
+			});
+			for (const row of tasks) {
+				const envelope = envelopeOf(row);
+				if (!envelope || isForgotten(row, now)) continue;
+				const { context } = row.args;
+				const listing = toListing(row.toolCallId, envelope.principalKey, context, projectTask(row, envelope, "", now), envelope.clientLabel);
+				if (!isPastTaskListCursor(listing, cursor) || !matchesTaskListOptions(listing, options)) continue;
+				matching.push(listing);
+				if (matching.length > limit) break;
+			}
+			if (tasks.length <= limit) break;
+		}
+		const listings = matching.slice(0, limit);
+		return {
+			listings,
+			...matching.length > limit && { nextCursor: nextTaskListCursor(listings, cursor) }
+		};
+	}
+	updateByKey(taskKey, inputResponses) {
+		return this.#update(taskKey, inputResponses, `with key "${taskKey}"`);
+	}
+	cancelByKey(taskKey) {
+		return this.#cancel(taskKey);
+	}
+	/** Without `access`, any principal's task (admin). `label` names the task in errors. */
+	async #update(taskKey, inputResponses, label, access) {
+		this.#startSweeping();
+		const found = await this.#find(taskKey, access);
+		if (!found) return "not_found";
+		let { row, envelope } = found;
+		let stored = false;
+		const storage = await this.#manager.getStorage();
+		for (let attempt = 0; attempt < UPDATE_ATTEMPTS && row.status === "suspended"; attempt++) {
+			const open = openInputRequests(envelope);
+			const accepted = Object.entries(inputResponses).filter(([key]) => key in open);
+			if (accepted.length === 0) break;
+			const next = {
+				...envelope,
+				inputResponses: {
+					...envelope.inputResponses,
+					...Object.fromEntries(accepted)
+				}
+			};
+			const written = await storage.updateTask(row.id, { metadata: next }, {
+				expectedStatus: "suspended",
+				expectedSuspendedAt: row.suspendedAt ?? null
+			});
+			const reread = await storage.getTask(row.id);
+			const rereadEnvelope = reread && envelopeOf(reread);
+			if (!reread || !rereadEnvelope) return "not_found";
+			row = reread;
+			envelope = rereadEnvelope;
+			if (written && accepted.every(([key]) => key in (envelope.inputResponses ?? {}))) {
+				stored = true;
+				break;
+			}
+		}
+		if (!stored && row.status === "suspended") {
+			const open = openInputRequests(envelope);
+			if (Object.keys(inputResponses).some((key) => key in open && !(key in (envelope.inputResponses ?? {})))) throw new Error(`Could not store the input responses for MCP task ${label}`);
+		}
+		if (isFullyAnswered(row, envelope)) await this.#resume(row, envelope);
+		return stored ? "done" : "ignored";
+	}
+	async traceOf(taskId, access) {
+		return (await this.#find(taskKeyOf(taskId), access))?.envelope.trace;
+	}
+	async #cancel(taskKey, access) {
+		this.#startSweeping();
+		const found = await this.#find(taskKey, access);
+		if (!found) return "not_found";
+		if (isTerminalRow(found.row)) return "ignored";
+		try {
+			await this.#manager.cancel(found.row.id);
+		} catch (error) {
+			this.#getLogger?.().warn("Could not cancel MCP task", { error });
+		}
+		this.#abortFirstAttempt(found.row.id, /* @__PURE__ */ new Error("Task cancelled"));
+		this.#notifyCancel(found.row);
+		return "done";
+	}
+	/** Fire and forget: a slow hook must hold up neither the `tasks/cancel` ack nor the sweep. */
+	#notifyCancel(row) {
+		const onCancel = this.#onCancel;
+		if (!onCancel) return;
+		const context = row.args.context;
+		Promise.resolve().then(() => onCancel(context)).catch((error) => this.#getLogger?.().warn("Could not stop what a cancelled MCP task stands for", { error }));
+	}
+	/**
+	* An attempt here was aborted. The abort says why only in core's message, so read the row: if
+	* another instance cancelled or expired the task, or core timed the attempt out, run `onCancel`
+	* here as well, where the work may be executing (a workflow run, say). Core records a timeout only
+	* once the aborted attempt settles, so a row still running under this worker is read again, less
+	* often each time and again after a failed read, until core records how the attempt ended. A shutdown releases the lease and a
+	* lost lease changes the owner: either leaves the row running without this worker, and the work
+	* alone.
+	*/
+	#notifyIfCancelled(taskKey) {
+		const check = async () => {
+			for (let wait = ABORT_SETTLE_FIRST_READ_MS; !this.#closed; wait = Math.min(wait * 2, ABORT_SETTLE_MAX_READ_MS)) {
+				let row;
+				try {
+					row = (await this.#manager.listTasks({
+						agentId: this.#owner,
+						toolCallId: taskKey,
+						perPage: 1
+					})).tasks[0];
+				} catch (error) {
+					this.#getLogger?.().warn("Could not read an aborted MCP task attempt; reading it again", { error });
+					await new Promise((resolve) => setTimeout(resolve, wait));
+					continue;
+				}
+				if (!row) return;
+				if (wasStopped(row, Date.now())) return this.#notifyCancel(row);
+				if (row.status !== "running" || row.ownerId !== this.#manager.ownerId) return;
+				await new Promise((resolve) => setTimeout(resolve, wait));
+			}
+		};
+		check().catch((error) => this.#getLogger?.().warn("Could not check why an MCP task attempt was aborted", { error }));
+	}
+	#abortFirstAttempt(rowId, reason) {
+		const abort = this.#firstAttempts.get(rowId);
+		if (!abort) return;
+		this.#firstAttempts.delete(rowId);
+		abort(reason);
+	}
+	/**
+	* Stops sweeping, waits for a sweep already running to stop at its next step, then unregisters
+	* this store's executors. Rows stay in storage.
+	*/
+	async close() {
+		this.#closed = true;
+		clearInterval(this.#sweepTimer);
+		this.#sweepTimer = void 0;
+		await this.#sweeping?.catch(() => {});
+		for (const key of this.#executors) this.#manager.unregisterStaticExecutor(key);
+		this.#executors.clear();
+	}
+	/**
+	* Repairs what no request would: expires rows past their TTL, resumes answered rows whose
+	* process-local resume was lost, and settles rows whose worker died while this manager was
+	* already running (the manager itself only recovers rows when it starts).
+	*/
+	sweep() {
+		if (this.#closed) return Promise.resolve();
+		this.#sweeping ??= this.#sweep().finally(() => this.#sweeping = void 0);
+		return this.#sweeping;
+	}
+	/**
+	* Starts the periodic sweep before any task request, so this instance settles rows a dead worker
+	* left behind even if no client ever asks it about a task. Does nothing once the store is closed.
+	*/
+	startSweeping() {
+		this.#startSweeping();
+	}
+	#startSweeping() {
+		if (this.#sweepTimer || this.#closed) return;
+		this.#sweepTimer = setInterval(() => {
+			this.sweep().catch((error) => this.#getLogger?.().debug("MCP task sweep failed", { error }));
+		}, this.#manager.config.leaseDurationMs);
+		this.#sweepTimer.unref?.();
+	}
+	/**
+	* Bounded per tick, however many rows are open: it expires at most {@link SWEEP_BATCH} rows past
+	* their TTL, and checks one page of {@link SWEEP_BATCH} other open rows, moving to the next page
+	* on the next tick. Rows that need a restart are restarted only while slots are free.
+	*/
+	async #sweep() {
+		const storage = await this.#manager.getStorage();
+		const now = Date.now();
+		const lease = this.#manager.config.leaseDurationMs;
+		for (const rowId of this.#firstAttempts.keys()) {
+			if (this.#closed) return;
+			const current = await storage.getTask(rowId).catch(() => void 0);
+			if (current && isTerminalRow(current) && !this.#closed) this.#abortFirstAttempt(rowId, /* @__PURE__ */ new Error("Task cancelled"));
+		}
+		if (this.#closed) return;
+		if (storage.supportsTaskExpiry) await storage.deleteTasks({
+			agentId: this.#owner,
+			status: [...TERMINAL_ROW_STATUSES],
+			dateFilterBy: "expiresAt",
+			toDate: /* @__PURE__ */ new Date(now - EXPIRED_RETENTION_MS)
+		}).catch((error) => this.#getLogger?.().debug("Could not delete expired MCP tasks", { error }));
+		if (this.#closed) return;
+		const { tasks: expired } = await this.#manager.listTasks({
+			agentId: this.#owner,
+			status: OPEN_ROW_STATUSES,
+			dateFilterBy: "expiresAt",
+			toDate: new Date(now + 1),
+			perPage: SWEEP_BATCH
+		});
+		for (const row of expired) {
+			if (this.#closed) return;
+			if (!envelopeOf(row)) continue;
+			await this.#expire(storage, row).catch((error) => this.#getLogger?.().debug("Could not expire MCP task", { error }));
+		}
+		if (this.#closed) return;
+		const { tasks: rows } = await this.#manager.listTasks({
+			agentId: this.#owner,
+			status: OPEN_ROW_STATUSES,
+			orderBy: "createdAt",
+			orderDirection: "asc",
+			page: this.#sweepPage,
+			perPage: SWEEP_BATCH
+		});
+		this.#sweepPage = rows.length < SWEEP_BATCH ? 0 : this.#sweepPage + 1;
+		const restarts = [];
+		for (const row of rows) {
+			if (this.#closed) return;
+			const envelope = envelopeOf(row);
+			if (!envelope || isExpired(row, now)) continue;
+			try {
+				if (isFullyAnswered(row, envelope)) await this.#resume(row, envelope);
+				else if (isOwned(row) && (!row.leaseExpiresAt || row.leaseExpiresAt.getTime() <= now)) {
+					if (await this.#reclaim(storage, row, envelope) && !this.#closed) restarts.push(row.id);
+				} else if (row.status === "pending" && !row.ownerId && now - row.createdAt.getTime() >= lease) restarts.push(row.id);
+			} catch (error) {
+				this.#getLogger?.().debug("Could not sweep MCP task", { error });
+			}
+		}
+		if (restarts.length === 0 || this.#closed) return;
+		const free = await this.#freeSlots(storage);
+		for (const rowId of restarts.slice(0, free)) {
+			if (this.#closed) return;
+			await this.#restart(rowId);
+		}
+	}
+	/** Slots this server's rows can take now, by the manager's global and per-owner limits. */
+	async #freeSlots(storage) {
+		const { globalConcurrency, perAgentConcurrency, perOwnerConcurrency } = this.#manager.config;
+		const ownerLimit = perOwnerConcurrency && Object.hasOwn(perOwnerConcurrency, this.#owner) ? perOwnerConcurrency[this.#owner] : perAgentConcurrency;
+		const [running, mine] = await Promise.all([storage.getRunningCount(), storage.getRunningCountByAgent(this.#owner)]);
+		return Math.max(0, Math.min(globalConcurrency - running, ownerLimit - mine));
+	}
+	/** Aborts the work, then records the task as failed until its retention ends. */
+	async #expire(storage, row) {
+		await this.#manager.cancel(row.id);
+		this.#abortFirstAttempt(row.id, /* @__PURE__ */ new Error(TASK_EXPIRED_MESSAGE));
+		this.#notifyCancel(row);
+		await storage.updateTask(row.id, {
+			status: "failed",
+			error: { message: TASK_EXPIRED_MESSAGE },
+			completedAt: /* @__PURE__ */ new Date(),
+			expiresAt: new Date(Date.now() + EXPIRED_RETENTION_MS)
+		}, { expectedStatus: "cancelled" });
+	}
+	/**
+	* A running row, or a pending row pinned to the worker running its first attempt, whose lease
+	* lapsed or was released: its worker died, or shut down, with the attempt in flight. Fenced like
+	* the manager's own recovery, so of all instances (and managers) noticing it, exactly one
+	* settles it. Returns whether it won the row back to pending, for the sweep to restart.
+	*/
+	async #reclaim(storage, row, envelope) {
+		const fence = {
+			expectedStatus: row.status,
+			expectedOwnerId: row.ownerId ?? null,
+			expectedLeaseExpiresAt: row.leaseExpiresAt ?? null
+		};
+		if (envelope.recover && row.retryCount < row.maxRetries) return await storage.updateTask(row.id, {
+			status: "pending",
+			retryCount: row.retryCount + 1,
+			ownerId: void 0,
+			leaseExpiresAt: void 0
+		}, fence);
+		await storage.updateTask(row.id, {
+			status: "failed",
+			error: { message: TASK_LOST_MESSAGE },
+			completedAt: /* @__PURE__ */ new Date(),
+			ownerId: void 0,
+			leaseExpiresAt: void 0
+		}, fence);
+		return false;
+	}
+	/** Dispatches a reclaimed row; the dispatch claim is fenced, so it runs once however often this is called. */
+	async #restart(rowId) {
+		try {
+			await this.#manager.restart(rowId);
+		} catch (error) {
+			this.#getLogger?.().debug("Could not restart MCP task", { error });
+		}
+	}
+	/** Without `access`, any principal's task (admin). */
+	async #find(taskKey, access) {
+		const principalKey = access && principalKeyOf(access.principal);
+		const { tasks } = await this.#manager.listTasks({
+			agentId: this.#owner,
+			...principalKey !== void 0 && { resourceId: `${this.#owner}:${principalKey}` },
+			toolCallId: taskKey,
+			perPage: 1
+		});
+		const row = tasks[0];
+		const envelope = row && envelopeOf(row);
+		if (!row || !envelope || principalKey !== void 0 && envelope.principalKey !== principalKey) return void 0;
+		if (isForgotten(row, Date.now())) return void 0;
+		return {
+			row,
+			envelope
+		};
+	}
+	async #resume(row, envelope) {
+		const resumeData = {
+			inputResponses: envelope.inputResponses ?? {},
+			suspendPayload: row.suspendPayload
+		};
+		try {
+			await this.#manager.resume(row.id, resumeData, { onNoSlot: "queue" });
+		} catch (error) {
+			this.#getLogger?.().debug("Could not resume MCP task", { error });
+		}
+	}
+	/**
+	* Counts the attempt this worker just claimed, for a traced task, and describes it for its span.
+	* The write is fenced on the claim; losing it only costs the span its number.
+	*/
+	async #countAttempt(taskKey, resumed) {
+		const { tasks } = await this.#manager.listTasks({
+			agentId: this.#owner,
+			toolCallId: taskKey,
+			perPage: 1
+		});
+		const row = tasks[0];
+		const envelope = row && envelopeOf(row);
+		if (!row || !envelope?.trace) return void 0;
+		const attempt = (envelope.attempts ?? 0) + 1;
+		await (await this.#manager.getStorage()).updateTask(row.id, { metadata: {
+			...envelope,
+			attempts: attempt
+		} }, {
+			expectedStatus: "running",
+			expectedOwnerId: row.ownerId ?? null
+		}).catch(() => void 0);
+		return {
+			...envelope.trace,
+			taskKey,
+			attempt,
+			resumed,
+			recovered: !resumed && attempt > 1
+		};
+	}
+	/** Runs one attempt and turns its outcome into what the background-task workflow records. */
+	async #execute(work, args, options, initial) {
+		const signal = options?.abortSignal ?? new AbortController().signal;
+		const resumeData = options?.resumeData;
+		const trace = await this.#countAttempt(args.taskKey, resumeData !== void 0);
+		let outcome;
+		if (initial) {
+			const abort = () => initial.abort(signal.reason);
+			if (signal.aborted) abort();
+			else signal.addEventListener("abort", abort, { once: true });
+			outcome = initial.outcome.finally(() => signal.removeEventListener("abort", abort));
+		} else {
+			const attempt = {
+				signal,
+				...trace && { trace },
+				...resumeData && { resume: {
+					inputResponses: resumeData.inputResponses,
+					suspendPayload: resumeData.suspendPayload
+				} }
+			};
+			outcome = Promise.resolve().then(() => work(attempt));
+		}
+		const result = await new Promise((resolve, reject) => {
+			const onAbort = () => {
+				reject(signal.reason ?? /* @__PURE__ */ new Error("Task cancelled"));
+				this.#notifyIfCancelled(args.taskKey);
+			};
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+			outcome.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+		});
+		if (result.status === "completed") return result.result;
+		const storage = await this.#manager.getStorage();
+		const { tasks } = await this.#manager.listTasks({
+			agentId: this.#owner,
+			toolCallId: args.taskKey,
+			perPage: 1
+		});
+		const row = tasks[0];
+		const envelope = row && envelopeOf(row);
+		if (!row || !envelope) throw new Error("MCP task row is gone");
+		const keys = Object.keys(result.inputRequests);
+		if (keys.length === 0) throw new Error("Task asked for input without any input request");
+		const reused = keys.find((key) => envelope.usedInputKeys.includes(key));
+		if (reused !== void 0) throw new Error(`Input request key "${reused}" was already used by this task`);
+		const next = {
+			...envelope,
+			inputRequests: result.inputRequests,
+			inputResponses: {},
+			usedInputKeys: [...envelope.usedInputKeys, ...keys]
+		};
+		if (!await storage.updateTask(row.id, { metadata: next }, {
+			expectedStatus: "running",
+			expectedOwnerId: this.#manager.ownerId
+		})) throw new Error("MCP task is no longer running here");
+		if (!options?.suspend) throw new Error("Background task runtime cannot suspend this task");
+		await options.suspend(result.suspendPayload);
+	}
+};
+// src/server/tasks/in-memory-store.ts
+const DEFAULT_EXPIRED_RETENTION_MS = 6e4;
+const MAX_TIMER_DELAY_MS = 2147483647;
+/**
+* Default {@link MCPTaskStore}: tasks live in this process. A task created here can only be read on
+* the same instance and does not survive a restart, so use it for single-instance servers.
+*
+* When a task's TTL elapses its work is aborted and it turns `failed`; it is forgotten after
+* `expiredRetentionMs`. Finished tasks stay in memory until then, so `limits.retainedPerPrincipal`
+* and `limits.retainedTotal` bound how many tasks it holds; a task with a `null` TTL counts until
+* the store closes.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+var InMemoryMCPTaskStore = class {
+	#tasks = /* @__PURE__ */ new Map();
+	/** The same records, by task key. */
+	#byKey = /* @__PURE__ */ new Map();
+	/** Open (non-terminal) tasks per principal, and in total. */
+	#openByPrincipal = /* @__PURE__ */ new Map();
+	#open = 0;
+	/** Every record held (open or finished, until purged) per principal, and in total. */
+	#retainedByPrincipal = /* @__PURE__ */ new Map();
+	#now;
+	#expiredRetentionMs;
+	#onCancel;
+	constructor(options = {}) {
+		this.#now = options.now ?? Date.now;
+		this.#expiredRetentionMs = options.expiredRetentionMs ?? DEFAULT_EXPIRED_RETENTION_MS;
+		this.#onCancel = options.onCancel;
+	}
+	async create(params, { clientLabel } = {}) {
+		assertNonNegativeInteger("ttlMs", params.ttlMs);
+		assertNonNegativeInteger("pollIntervalMs", params.pollIntervalMs);
+		const openForPrincipal = this.#openByPrincipal.get(params.principal) ?? 0;
+		const retainedForPrincipal = this.#retainedByPrincipal.get(params.principal) ?? 0;
+		const { limits } = params;
+		if (limits) {
+			if (openForPrincipal >= limits.perPrincipal) throw new MCPTaskLimitError("principal", limits.perPrincipal);
+			if (this.#open >= limits.total) throw new MCPTaskLimitError("total", limits.total);
+			if (limits.retainedPerPrincipal !== void 0 && retainedForPrincipal >= limits.retainedPerPrincipal) throw new MCPTaskLimitError("principal", limits.retainedPerPrincipal, "retained");
+			if (limits.retainedTotal !== void 0 && this.#tasks.size >= limits.retainedTotal) throw new MCPTaskLimitError("total", limits.retainedTotal, "retained");
+		}
+		const now = this.#now();
+		const taskId = createTaskId();
+		const record = {
+			taskId,
+			taskKey: taskKeyOf(taskId),
+			principal: params.principal,
+			clientLabel,
+			context: params.context,
+			...params.trace && { trace: params.trace },
+			attempts: 0,
+			status: "working",
+			createdAt: now,
+			lastUpdatedAt: now,
+			ttlMs: params.ttlMs,
+			pollIntervalMs: params.pollIntervalMs,
+			usedInputKeys: /* @__PURE__ */ new Set(),
+			abort: new AbortController()
+		};
+		if (record.ttlMs !== null) this.#arm(record, now + record.ttlMs, () => this.#expire(record));
+		this.#tasks.set(record.taskId, record);
+		this.#byKey.set(record.taskKey, record);
+		this.#openByPrincipal.set(record.principal, openForPrincipal + 1);
+		this.#open++;
+		this.#retainedByPrincipal.set(record.principal, retainedForPrincipal + 1);
+		return this.#snapshot(record);
+	}
+	async get(taskId, access) {
+		const record = this.#lookup(taskKeyOf(taskId), access);
+		return record && this.#detailed(record);
+	}
+	async update(taskId, inputResponses, access) {
+		return this.#update(taskKeyOf(taskId), inputResponses, access) !== "not_found";
+	}
+	async cancel(taskId, access) {
+		return this.#cancel(taskKeyOf(taskId), access) !== "not_found";
+	}
+	async list(options = {}) {
+		const limit = options.limit ?? 50;
+		const cursor = decodeTaskListCursor(options.cursor);
+		const matching = [];
+		const now = this.#now();
+		for (const record of [...this.#tasks.values()].reverse()) {
+			if (record.purgeAt !== void 0 && now >= record.purgeAt) {
+				this.#purge(record);
+				continue;
+			}
+			if (options.taskKey && record.taskKey !== options.taskKey) continue;
+			const listing = toListing(record.taskKey, principalKeyOf(record.principal), record.context, this.#detailed(record), record.clientLabel);
+			if (!isPastTaskListCursor(listing, cursor) || !matchesTaskListOptions(listing, options)) continue;
+			matching.push(listing);
+			if (matching.length > limit) break;
+		}
+		const listings = matching.slice(0, limit);
+		return {
+			listings,
+			...matching.length > limit && { nextCursor: nextTaskListCursor(listings, cursor) }
+		};
+	}
+	async updateByKey(taskKey, inputResponses) {
+		return this.#update(taskKey, inputResponses);
+	}
+	async cancelByKey(taskKey) {
+		return this.#cancel(taskKey);
+	}
+	#update(taskKey, inputResponses, access) {
+		const record = this.#lookup(taskKey, access);
+		if (!record) return "not_found";
+		const pending = record.pendingInput;
+		if (!pending) return "ignored";
+		let accepted = false;
+		for (const [key, response] of Object.entries(inputResponses)) if (Object.hasOwn(pending.requests, key) && !pending.responses.has(key)) {
+			pending.responses.set(key, response);
+			accepted = true;
+		}
+		if (Object.keys(pending.requests).every((key) => pending.responses.has(key))) {
+			record.pendingInput = void 0;
+			this.#transition(record, "working");
+			pending.resolve(Object.fromEntries(pending.responses));
+		}
+		return accepted ? "done" : "ignored";
+	}
+	#cancel(taskKey, access) {
+		const record = this.#lookup(taskKey, access);
+		if (!record) return "not_found";
+		if (isTerminalTaskStatus(record.status)) return "ignored";
+		this.#finish(record, "cancelled", /* @__PURE__ */ new Error("Task was cancelled"));
+		this.#notifyCancel(record);
+		return "done";
+	}
+	async traceOf(taskId, access) {
+		return this.#lookup(taskKeyOf(taskId), access)?.trace;
+	}
+	/** Whether this store holds the task, for any caller. */
+	has(taskId) {
+		return this.#tasks.has(taskId);
+	}
+	/** The context recorded at creation. */
+	context(taskId) {
+		return this.#tasks.get(taskId)?.context;
+	}
+	run(taskId, work, options = {}) {
+		const record = this.#tasks.get(taskId);
+		if (!record) throw new Error(`MCP task ${taskKeyOf(taskId)} not found`);
+		const initial = options.initialAttempt;
+		if (!initial) {
+			this.#attempt(record, work);
+			return;
+		}
+		record.attempts++;
+		const signal = record.abort.signal;
+		const abort = () => initial.abort(signal.reason);
+		if (signal.aborted) abort();
+		else signal.addEventListener("abort", abort, { once: true });
+		this.#settle(record, work, initial.outcome.finally(() => signal.removeEventListener("abort", abort)));
+	}
+	#attempt(record, work, resume) {
+		record.attempts++;
+		const attempt = {
+			signal: record.abort.signal,
+			...resume && { resume },
+			...record.trace && { trace: {
+				...record.trace,
+				taskKey: taskKeyOf(record.taskId),
+				attempt: record.attempts,
+				resumed: resume !== void 0,
+				recovered: false
+			} }
+		};
+		this.#settle(record, work, Promise.resolve().then(() => work(attempt)));
+	}
+	#settle(record, work, outcome) {
+		outcome.then((result) => this.#record(record, work, result), (error) => this.#fail(record, {
+			code: TASKS_ERROR_CODES.InternalError,
+			message: error instanceof Error ? error.message : String(error)
+		}));
+	}
+	#record(record, work, outcome) {
+		if (isTerminalTaskStatus(record.status)) return;
+		if (outcome.status === "completed") {
+			record.result = outcome.result;
+			this.#finish(record, "completed");
+			return;
+		}
+		const keys = Object.keys(outcome.inputRequests);
+		const reused = keys.find((key) => record.usedInputKeys.has(key));
+		if (keys.length === 0 || reused !== void 0) {
+			this.#fail(record, {
+				code: TASKS_ERROR_CODES.InternalError,
+				message: reused === void 0 ? "Task asked for input without any input request" : `Input request key "${reused}" was already used by this task`
+			});
+			return;
+		}
+		for (const key of keys) record.usedInputKeys.add(key);
+		const { suspendPayload } = outcome;
+		record.pendingInput = {
+			requests: outcome.inputRequests,
+			responses: /* @__PURE__ */ new Map(),
+			resolve: (inputResponses) => this.#attempt(record, work, {
+				inputResponses,
+				suspendPayload
+			}),
+			reject: () => {}
+		};
+		this.#transition(record, "input_required");
+	}
+	#fail(record, error) {
+		if (isTerminalTaskStatus(record.status)) return;
+		record.error = error;
+		this.#finish(record, "failed", new Error(error.message));
+	}
+	/** The writer for a task this store holds. Writes after the task is terminal are ignored. */
+	handle(taskId) {
+		const record = this.#tasks.get(taskId);
+		if (!record) throw new Error(`MCP task ${taskKeyOf(taskId)} not found`);
+		const live = () => !isTerminalTaskStatus(record.status);
+		return {
+			taskId,
+			signal: record.abort.signal,
+			status: (message) => {
+				if (!live()) return;
+				record.statusMessage = message;
+				record.lastUpdatedAt = this.#now();
+			},
+			requireInput: (requests) => {
+				if (!live()) return Promise.reject(/* @__PURE__ */ new Error(`MCP task ${taskKeyOf(taskId)} is no longer running`));
+				if (record.pendingInput) return Promise.reject(/* @__PURE__ */ new Error(`MCP task ${taskKeyOf(taskId)} is already waiting for input`));
+				const keys = Object.keys(requests);
+				if (keys.length === 0) return Promise.reject(/* @__PURE__ */ new Error("requireInput needs at least one input request"));
+				const reused = keys.find((key) => record.usedInputKeys.has(key));
+				if (reused !== void 0) return Promise.reject(/* @__PURE__ */ new Error(`Input request key "${reused}" was already used by MCP task ${taskKeyOf(taskId)}`));
+				for (const key of keys) record.usedInputKeys.add(key);
+				return new Promise((resolve, reject) => {
+					record.pendingInput = {
+						requests,
+						responses: /* @__PURE__ */ new Map(),
+						resolve,
+						reject
+					};
+					this.#transition(record, "input_required");
+				});
+			},
+			complete: (result) => {
+				if (!live()) return;
+				record.result = result;
+				this.#finish(record, "completed");
+			},
+			fail: (error) => {
+				if (!live()) return;
+				record.error = error;
+				this.#finish(record, "failed");
+			}
+		};
+	}
+	/** Cancels all running work, invalidates every handle and forgets every task. */
+	close() {
+		for (const record of this.#tasks.values()) {
+			clearTimeout(record.expiryTimer);
+			if (!isTerminalTaskStatus(record.status)) this.#finish(record, "cancelled", /* @__PURE__ */ new Error("MCP task store closed"));
+		}
+		this.#tasks.clear();
+		this.#byKey.clear();
+		this.#openByPrincipal.clear();
+		this.#open = 0;
+		this.#retainedByPrincipal.clear();
+	}
+	/** Without `access`, any principal's task (admin). */
+	#lookup(taskKey, access) {
+		const record = this.#byKey.get(taskKey);
+		if (!record || access && record.principal !== access.principal) return void 0;
+		if (record.purgeAt !== void 0 && this.#now() >= record.purgeAt) {
+			this.#purge(record);
+			return;
+		}
+		return record;
+	}
+	/** Forgets an expired task, freeing its retained slot. */
+	#purge(record) {
+		if (this.#tasks.get(record.taskId) !== record) return;
+		clearTimeout(record.expiryTimer);
+		this.#tasks.delete(record.taskId);
+		this.#byKey.delete(record.taskKey);
+		const retained = this.#retainedByPrincipal.get(record.principal) - 1;
+		if (retained === 0) this.#retainedByPrincipal.delete(record.principal);
+		else this.#retainedByPrincipal.set(record.principal, retained);
+	}
+	/** setTimeout fires after 1 ms past 2^31-1 ms (~24.8 days), so a longer wait goes in steps. */
+	#arm(record, at, fire) {
+		const delay = at - this.#now();
+		record.expiryTimer = delay > MAX_TIMER_DELAY_MS ? setTimeout(() => this.#arm(record, at, fire), MAX_TIMER_DELAY_MS) : setTimeout(fire, delay);
+		record.expiryTimer.unref?.();
+	}
+	#expire(record) {
+		if (!isTerminalTaskStatus(record.status)) {
+			record.error = {
+				code: TASKS_ERROR_CODES.InternalError,
+				message: "Task expired before it finished"
+			};
+			this.#finish(record, "failed", /* @__PURE__ */ new Error("Task expired"));
+			this.#notifyCancel(record);
+		}
+		record.purgeAt = this.#now() + this.#expiredRetentionMs;
+		this.#arm(record, record.purgeAt, () => this.#purge(record));
+	}
+	/** Fire and forget: a slow hook must hold up neither the `tasks/cancel` ack nor expiry. */
+	#notifyCancel(record) {
+		const onCancel = this.#onCancel;
+		const context = record.context;
+		if (!onCancel || !context) return;
+		Promise.resolve().then(() => onCancel(context)).catch(() => {});
+	}
+	#transition(record, status) {
+		record.status = status;
+		record.lastUpdatedAt = this.#now();
+	}
+	/** The only way a task turns terminal, so it is also where it stops counting as open. */
+	#finish(record, status, reason) {
+		const open = this.#openByPrincipal.get(record.principal) - 1;
+		if (open === 0) this.#openByPrincipal.delete(record.principal);
+		else this.#openByPrincipal.set(record.principal, open);
+		this.#open--;
+		this.#transition(record, status);
+		const pending = record.pendingInput;
+		record.pendingInput = void 0;
+		pending?.reject(reason ?? /* @__PURE__ */ new Error(`MCP task "${taskKeyOf(record.taskId)}" ${status} while waiting for input`));
+		if (reason) record.abort.abort(reason);
+	}
+	#snapshot(record) {
+		return {
+			taskId: record.taskId,
+			status: record.status,
+			...record.statusMessage !== void 0 && { statusMessage: record.statusMessage },
+			createdAt: new Date(record.createdAt).toISOString(),
+			lastUpdatedAt: new Date(record.lastUpdatedAt).toISOString(),
+			ttlMs: record.ttlMs,
+			pollIntervalMs: record.pollIntervalMs ?? suggestedPollIntervalMs(record.createdAt, this.#now())
+		};
+	}
+	#detailed(record) {
+		const base = this.#snapshot(record);
+		switch (record.status) {
+			case "input_required": {
+				const { requests, responses } = record.pendingInput;
+				const open = Object.fromEntries(Object.entries(requests).filter(([key]) => !responses.has(key)));
+				return {
+					...base,
+					status: "input_required",
+					inputRequests: open
+				};
+			}
+			case "completed": return {
+				...base,
+				status: "completed",
+				result: { ...record.result }
+			};
+			case "failed": return {
+				...base,
+				status: "failed",
+				error: { ...record.error }
+			};
+			case "working":
+			case "cancelled": return {
+				...base,
+				status: record.status
+			};
+		}
+	}
+};
+function assertNonNegativeInteger(name, value) {
+	if (value === null || value === void 0) return;
+	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a non-negative integer, got ${value}`);
+}
+// src/server/tasks/config.ts
+const MODES = [
+	"off",
+	"auto",
+	"always"
+];
+const DEFAULT_SYNC_WINDOW_MS = 2e3;
+const DEFAULT_MAX_OPEN_TASKS_PER_CLIENT = 100;
+const DEFAULT_MAX_OPEN_TASKS = 1e3;
+const DEFAULT_MAX_RETAINED_TASKS_PER_CLIENT = 1e3;
+const DEFAULT_MAX_RETAINED_TASKS = 1e4;
+function invalid(text) {
+	return new MastraError({
+		id: "MCP_SERVER_TASKS_INVALID_CONFIG",
+		domain: ErrorDomain.MCP,
+		category: ErrorCategory.USER,
+		text
+	});
+}
+function assertMode(owner, mode) {
+	if (!MODES.includes(mode)) throw invalid(`${owner} has an unknown task mode "${String(mode)}"; use 'off', 'auto' or 'always'.`);
+}
+function assertDuration(owner, value) {
+	if (value === null || value === void 0) return;
+	if (!Number.isSafeInteger(value) || value < 0) throw invalid(`${owner} must be a non-negative integer number of milliseconds, got ${value}.`);
+}
+function assertBoolean(owner, value) {
+	if (value !== void 0 && typeof value !== "boolean") throw invalid(`${owner} must be a boolean, got ${String(value)}.`);
+}
+function positiveInteger(owner, value) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 1) throw invalid(`${owner} must be a positive integer, got ${value}.`);
+	return value;
+}
+/**
+* Resolves an open cap and the retained cap that contains it. Every open task is also retained, so
+* an unset cap follows the one that was set, and setting both with retained below open is refused.
+*/
+function caps([openName, open, defaultOpen], [retainedName, retained, defaultRetained]) {
+	const openCap = positiveInteger(openName, open);
+	const retainedCap = positiveInteger(retainedName, retained);
+	if (openCap !== void 0 && retainedCap !== void 0 && retainedCap < openCap) throw invalid(`${retainedName} (${retainedCap}) must be at least ${openName} (${openCap}).`);
+	return [openCap ?? Math.min(defaultOpen, retainedCap ?? defaultOpen), retainedCap ?? Math.max(defaultRetained, openCap ?? 0)];
+}
+/** Validates `tasks` against the configured tools, workflows and agents. Throws on anything a server could not serve. */
+function resolveTasksConfig(options, surfaces) {
+	const config = options ?? {};
+	const defaultMode = config.default ?? "off";
+	assertMode("tasks.default", defaultMode);
+	assertDuration("tasks.ttlMs", config.ttlMs);
+	const ttlMs = config.ttlMs === void 0 ? DEFAULT_TASK_TTL_MS : config.ttlMs;
+	assertBoolean("tasks.recover", config.recover);
+	const recover = config.recover ?? false;
+	const [perPrincipal, retainedPerPrincipal] = caps([
+		"tasks.maxOpenTasksPerClient",
+		config.maxOpenTasksPerClient,
+		DEFAULT_MAX_OPEN_TASKS_PER_CLIENT
+	], [
+		"tasks.maxRetainedTasksPerClient",
+		config.maxRetainedTasksPerClient,
+		DEFAULT_MAX_RETAINED_TASKS_PER_CLIENT
+	]);
+	const [total, retainedTotal] = caps([
+		"tasks.maxOpenTasks",
+		config.maxOpenTasks,
+		DEFAULT_MAX_OPEN_TASKS
+	], [
+		"tasks.maxRetainedTasks",
+		config.maxRetainedTasks,
+		DEFAULT_MAX_RETAINED_TASKS
+	]);
+	const limits = {
+		perPrincipal,
+		total,
+		retainedPerPrincipal,
+		retainedTotal
+	};
+	/** Resolves one surface's per-key entries, keyed by the tool name each key is exposed as. */
+	const resolveSurface = (option, keys, exposedAs, surfaceRecover) => {
+		const known = new Set(keys);
+		const tools = new Set(surfaces.tools);
+		const resolved = /* @__PURE__ */ new Map();
+		const entries = config[option] ?? {};
+		const noun = option.slice(0, -1);
+		for (const [key, entry] of Object.entries(entries)) {
+			if (!known.has(key)) throw invalid(`tasks.${option} names "${key}", which is not one of this server's ${option}.`);
+			const owner = `tasks.${option}.${key}`;
+			if (option !== "tools" && tools.has(exposedAs(key))) throw invalid(`${owner} names a ${noun} hidden by the tool "${exposedAs(key)}", so it is never served.`);
+			const surface = typeof entry === "string" ? { mode: entry } : entry;
+			assertMode(owner, surface.mode);
+			assertDuration(`${owner}.syncWindowMs`, surface.syncWindowMs);
+			assertDuration(`${owner}.ttlMs`, surface.ttlMs);
+			if (option === "workflows" && "recover" in surface) throw invalid(`${owner}.recover is not a ${noun} option: a workflow task always re-attaches to its run.`);
+			assertBoolean(`${owner}.recover`, surface.recover);
+			resolved.set(exposedAs(key), {
+				mode: surface.mode,
+				syncWindowMs: surface.syncWindowMs ?? DEFAULT_SYNC_WINDOW_MS,
+				ttlMs: surface.ttlMs === void 0 ? ttlMs : surface.ttlMs,
+				recover: surfaceRecover(surface)
+			});
+		}
+		return resolved;
+	};
+	const perTool = resolveSurface("tools", surfaces.tools, (key) => key, (tool) => tool.recover ?? recover);
+	const perWorkflow = resolveSurface("workflows", surfaces.workflows ?? [], (key) => `run_${key}`, () => true);
+	const perAgent = resolveSurface("agents", surfaces.agents ?? [], (key) => `ask_${key}`, (agent) => agent.recover ?? recover);
+	const fallback = {
+		mode: defaultMode,
+		syncWindowMs: DEFAULT_SYNC_WINDOW_MS,
+		ttlMs,
+		recover
+	};
+	const modeFor = (name, toolType) => {
+		if (toolType === "workflow") return perWorkflow.get(name) ?? {
+			...fallback,
+			recover: true
+		};
+		if (toolType === "agent") return perAgent.get(name) ?? fallback;
+		return perTool.get(name) ?? fallback;
+	};
+	const exposed = new Map([
+		...surfaces.tools.map((name) => [name, void 0]),
+		...(surfaces.workflows ?? []).map((key) => [`run_${key}`, "workflow"]),
+		...(surfaces.agents ?? []).map((key) => [`ask_${key}`, "agent"])
+	]);
+	const required = new Set(config.required ?? []);
+	for (const name of required) {
+		if (!exposed.has(name)) throw invalid(`tasks.required names "${name}", which is not one of this server's tools.`);
+		if (modeFor(name, exposed.get(name)).mode === "off") throw invalid(`tasks.required names "${name}", which is not served as a task.`);
+	}
+	return {
+		enabled: defaultMode !== "off" || [
+			...perTool.values(),
+			...perWorkflow.values(),
+			...perAgent.values()
+		].some((surface) => surface.mode !== "off"),
+		store: config.store,
+		limits,
+		required,
+		authorize: config.authorize,
+		modeFor
+	};
+}
+/**
+* Picks the store on first use, once the server knows whether it runs on a Mastra instance with
+* durable background tasks. `run` follows the `create` it pairs with, so the choice is made by then.
+*/
+var SelectingMCPTaskStore = class {
+	#select;
+	#selecting;
+	#selected;
+	/** In-memory stores chosen before a later registration on Mastra, still serving the tasks created on them. */
+	#earlier = [];
+	constructor(select) {
+		this.#select = select;
+	}
+	/** The chosen store, choosing it if no task request has yet. */
+	resolve() {
+		return this.#store();
+	}
+	/**
+	* Chooses again on next use, for a server registered on Mastra after it served tasks. An
+	* in-memory store chosen before keeps the tasks created on it and goes on serving them.
+	*/
+	reselect() {
+		const chosen = this.#selected;
+		if (chosen) {
+			if (!(chosen instanceof InMemoryMCPTaskStore)) return;
+			this.#earlier.push(chosen);
+			this.#selected = void 0;
+			this.#selecting = void 0;
+			return;
+		}
+		const choosing = this.#selecting;
+		if (!choosing) return;
+		const next = choosing.then(() => {
+			this.reselect();
+			return this.#store();
+		});
+		next.catch(() => {});
+		this.#selecting = next;
+	}
+	/** Cancels the work of the in-memory stores it chose; a background-task store is closed by the server. */
+	close() {
+		for (const store of [...this.#earlier.splice(0), this.#selected]) if (store instanceof InMemoryMCPTaskStore) store.close();
+	}
+	/** The store that holds this task: an earlier in-memory store that created it, else the chosen one. */
+	#storeOf(taskId) {
+		const earlier = this.#earlier.find((store) => store.has(taskId));
+		return earlier ? Promise.resolve(earlier) : this.#store();
+	}
+	#store() {
+		this.#selecting ??= this.#select().then((store) => this.#selected = store, (error) => {
+			this.#selecting = void 0;
+			throw error;
+		});
+		return this.#selecting;
+	}
+	async create(params) {
+		return (await this.#store()).create(params);
+	}
+	async get(taskId, access) {
+		return (await this.#storeOf(taskId)).get(taskId, access);
+	}
+	async update(taskId, inputResponses, access) {
+		return (await this.#storeOf(taskId)).update(taskId, inputResponses, access);
+	}
+	async cancel(taskId, access) {
+		return (await this.#storeOf(taskId)).cancel(taskId, access);
+	}
+	async traceOf(taskId, access) {
+		return (await this.#storeOf(taskId)).traceOf?.(taskId, access);
+	}
+	run(taskId, work, options) {
+		const store = this.#earlier.find((earlier) => earlier.has(taskId)) ?? this.#selected;
+		if (!store) throw new Error(`MCP task ${taskKeyOf(taskId)} not found`);
+		store.run(taskId, work, options);
+	}
+	/** The chosen store's admin view, or `undefined` when it has none. */
+	async admin() {
+		const store = await this.#store();
+		return isMCPTaskStoreAdmin(store) ? store : void 0;
+	}
+};
+// src/server/tasks/emit.ts
+/** `_meta` key a tool handler uses to hand a task to {@link emitTaskResults}. */
+const TASK_RESULT_META_KEY = "mastra.ai/mcp-task-result";
+/**
+* A `tools/call` result standing in for a task handle. The SDK only lets a tool handler return a
+* `CallToolResult`; {@link emitTaskResults} replaces this one with the `CreateTaskResult` on the
+* wire. `isError` keeps the SDK from applying the tool's output schema to the placeholder.
+*/
+function taskHandleResult(task) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: "MCP task created"
+		}],
+		_meta: { [TASK_RESULT_META_KEY]: task }
+	};
+}
+/** The task a result built by {@link taskHandleResult} stands for; `undefined` for any other result. */
+function taskOfHandleResult(result) {
+	return (result?._meta)?.[TASK_RESULT_META_KEY];
+}
+/**
+* Sends results built by {@link taskHandleResult} as `CreateTaskResult`s. Only call handlers that
+* checked the caller declared the Tasks extension may build them.
+*/
+function emitTaskResults(transport) {
+	const send = transport.send.bind(transport);
+	transport.send = (message, options) => {
+		const result = "result" in message ? message.result : void 0;
+		const task = taskOfHandleResult(result);
+		if (task) {
+			const { [TASK_RESULT_META_KEY]: _task, ...rest } = result._meta;
+			message = {
+				...message,
+				result: {
+					...task,
+					resultType: TASK_RESULT_TYPE,
+					...Object.keys(rest).length > 0 ? { _meta: rest } : {}
+				}
+			};
+		}
+		return send(message, options);
+	};
+}
+// src/server/tasks/handlers.ts
+function notFound() {
+	return new ProtocolError$1(TASKS_ERROR_CODES.InvalidParams, "Task not found");
+}
+/**
+* Registers `tasks/get`, `tasks/update` and `tasks/cancel` on one protocol instance. They are
+* registered with explicit schemas, which the SDK requires to serve the Tasks extension's methods on
+* the 2026-07-28 revision.
+*/
+function registerTaskHandlers(server, deps) {
+	const { store, authorize } = deps;
+	const trace = deps.trace ?? ((_server, _method, _params, _ctx, fn) => fn(new RequestContext()));
+	/** `tasks/update` and `tasks/cancel` check `authorize` against the task before acting on it. */
+	const serve = (method, params, ctx, fn, metadata) => {
+		const mcpTaskKey = taskKeyOf(params.taskId);
+		return trace(server, method, { mcpTaskKey }, ctx, async (requestContext) => {
+			const principal = await deps.principal(ctx, requestContext);
+			if (authorize) {
+				const task = await store.get(params.taskId, { principal });
+				if (!task || !await authorize({
+					principal,
+					task,
+					requestContext
+				})) throw notFound();
+			}
+			return fn({ principal });
+		}, {
+			parentOf: store.traceOf ? async (requestContext) => store.traceOf(params.taskId, { principal: await deps.principal(ctx, requestContext) }) : void 0,
+			metadata: {
+				mcpTaskKey,
+				...metadata
+			}
+		});
+	};
+	server.setRequestHandler(TASKS_METHODS.get, {
+		params: GetTaskRequestParamsSchema,
+		result: GetTaskResultSchema
+	}, (params, ctx) => trace(server, TASKS_METHODS.get, {}, ctx, async (requestContext) => {
+		const principal = await deps.principal(ctx, requestContext);
+		const task = await store.get(params.taskId, { principal });
+		if (!task || authorize && !await authorize({
+			principal,
+			task,
+			requestContext
+		})) throw notFound();
+		return task;
+	}, { untraced: true }));
+	server.setRequestHandler(TASKS_METHODS.update, {
+		params: UpdateTaskHandlerParamsSchema,
+		result: TaskAckResultSchema
+	}, (params, ctx) => serve(TASKS_METHODS.update, params, ctx, async (access) => {
+		const inputResponses = ctx.mcpReq.inputResponses ?? {};
+		if (!await store.update(params.taskId, inputResponses, access)) throw notFound();
+		return {};
+	}));
+	server.setRequestHandler(TASKS_METHODS.cancel, {
+		params: CancelTaskRequestParamsSchema,
+		result: TaskAckResultSchema
+	}, (params, ctx) => serve(TASKS_METHODS.cancel, params, ctx, async (access) => {
+		if (!await store.cancel(params.taskId, access)) throw notFound();
+		return {};
+	}, { mcpTaskStatus: "cancelled" }));
+}
+// src/server/tasks/inspector.ts
+/** The tools served as tasks, as Studio shows them. */
+function listTaskSurfaces(tasks, tools) {
+	const surfaces = [];
+	for (const [name, toolType] of tools) {
+		const { mode, recover, ttlMs } = tasks.modeFor(name, toolType);
+		if (mode === "off") continue;
+		surfaces.push({
+			name,
+			type: toolType === "workflow" ? "workflow" : toolType === "agent" ? "agent" : "tool",
+			mode,
+			recover,
+			required: tasks.required.has(name),
+			ttlMs
+		});
+	}
+	return surfaces;
+}
+function tasksInfo(tasks, tools) {
+	return {
+		enabled: tasks.enabled,
+		listable: !tasks.store || isMCPTaskStoreAdmin(tasks.store),
+		surfaces: listTaskSurfaces(tasks, tools)
+	};
+}
+/**
+* Studio's view of the task store. Cancel and answer go through the store's `cancelByKey` and
+* `updateByKey`, the same code as `tasks/cancel` and `tasks/update`.
+*/
+function createTasksInspector(admin) {
+	const required = async () => {
+		const store = await admin();
+		if (!store) throw new Error("This MCP task store cannot be listed");
+		return store;
+	};
+	return {
+		async list(params = {}) {
+			const { listings, nextCursor } = await (await required()).list(params);
+			return {
+				tasks: listings.map(toSummary),
+				...nextCursor && { nextCursor }
+			};
+		},
+		async find(taskId) {
+			const { listings } = await (await required()).list({
+				taskKey: taskKeyOf(taskId),
+				limit: 1
+			});
+			return listings[0] && toSummary(listings[0]);
+		},
+		async cancel(taskKey) {
+			return await (await required()).cancelByKey(taskKey) === "done";
+		},
+		async answer(taskKey, inputResponses) {
+			return await (await required()).updateByKey(taskKey, inputResponses) === "done";
+		}
+	};
+}
+function toSummary(listing) {
+	const toolName = listing.context?.toolName;
+	return {
+		taskKey: listing.taskKey,
+		surface: typeof toolName === "string" ? toolName : "",
+		status: listing.status,
+		...listing.statusMessage !== void 0 && { statusMessage: listing.statusMessage },
+		createdAt: listing.createdAt,
+		lastUpdatedAt: listing.lastUpdatedAt,
+		...listing.ttlMs !== null && { expiresAt: new Date(new Date(listing.createdAt).getTime() + listing.ttlMs).toISOString() },
+		principalKey: listing.principalKey,
+		...listing.clientLabel !== void 0 && { clientLabel: listing.clientLabel },
+		...listing.inputRequests && { inputRequests: listing.inputRequests },
+		...listing.result && { result: listing.result },
+		...listing.error && { error: listing.error }
+	};
+}
+// src/server/tasks/workflow-runs.ts
+/**
+* Whether a task's context is a workflow task's.
+*
+* @experimental SEP-2663 extension; API may change.
+*/
+function isWorkflowTaskContext(context) {
+	return context?.kind === "workflow" && typeof context.runId === "string" && typeof context.workflowKey === "string";
+}
+/** Statuses a run never leaves. */
+const FINAL_STATUSES = /* @__PURE__ */ new Set([
+	"success",
+	"failed",
+	"tripwire",
+	"canceled",
+	"bailed"
+]);
+function isFinalRunStatus(status) {
+	return FINAL_STATUSES.has(status);
+}
+/** The text a finished run answers with: the same fields the synchronous `run_` tool returns. */
+function runSummary(view) {
+	return {
+		status: view.status,
+		input: view.input,
+		steps: view.steps,
+		result: view.result
+	};
+}
+function runErrorMessage(view) {
+	const error = view.error;
+	if (typeof error === "string") return error;
+	if (error && typeof error.message === "string") return error.message;
+	return "unknown error";
+}
+/**
+* The first step the run is suspended on. A run with several (parallel branches) is resumed one at
+* a time: after each resume it suspends again on the next.
+*/
+function firstSuspendedStep(workflow, view) {
+	for (const [stepId, raw] of Object.entries(view.steps ?? {})) {
+		const result = raw;
+		if (result?.status !== "suspended") continue;
+		const { __workflow_meta: meta, ...payload } = result.suspendPayload ?? {};
+		const nested = meta?.path;
+		const path = [stepId, ...Array.isArray(nested) ? nested.filter((part) => typeof part === "string") : []];
+		return {
+			path,
+			step: stepAt(workflow, path),
+			payload,
+			suspendedAt: result.suspendedAt
+		};
+	}
+}
+/**
+* Whether `answered` (recorded when the task asked) is still the run's current suspension. Another
+* resume, from Studio or the API, moves the run on; a step that suspends again gets a new `suspendedAt`.
+*/
+function isStillSuspended(view, answered) {
+	const result = view.steps?.[answered.step[0]];
+	if (view.status !== "suspended" || result?.status !== "suspended") return false;
+	return answered.suspendedAt === void 0 || result.suspendedAt === answered.suspendedAt;
+}
+/** Walks the workflow's step definitions along `path`, descending into nested workflows. */
+function stepAt(workflow, path) {
+	let steps = workflow.steps;
+	let step;
+	for (const id of path) {
+		step = steps?.[id];
+		if (!step) return void 0;
+		steps = step.steps;
+	}
+	return step;
+}
+// src/server/server.ts
+const EMPTY_OBJECT_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+/**
+* Exposes Mastra tools, agents, workflows, resources and prompts to Model Context
+* Protocol (MCP) clients using protocol revision 2026-07-28: self-contained requests
+* over Streamable HTTP or stdio, native `input_required` continuation and
+* per-request logging.
+*
+* @example
+* `yourTool` is a tool you have already configured.
+* ```typescript
+* import { MCPServer } from '@mastra/mcp';
+*
+* const server = new MCPServer({
+*   id: 'my-server',
+*   name: 'My Server',
+*   version: '1.0.0',
+*   tools: { yourTool },
+* });
+* await server.startStdio();
+* ```
+*
+* @see For documentation bundled with your installed package, locate
+* `@mastra/mcp/package.json` with your project's resolver or package-manager
+* tooling, then read `dist/docs/SKILL.md` from that package root and follow its
+* reference links. Use package-manager tools for virtual or archived packages.
+*
+* @see [MCP server documentation](https://mastra.ai/reference/tools/mcp-server)
+* if packaged docs are unavailable.
+*/
+var MCPServer = class extends MCPServerBase {
+	mcpVersion = 2;
+	resources;
+	prompts;
+	toolActions;
+	/**
+	* Publishes occurrences of the configured `events` to poll, push and (when
+	* `eventsOptions.webhook` is set) webhook subscribers.
+	*
+	* @experimental SEP-3415 is a draft; this API may change.
+	*/
+	events;
+	resourceOptions;
+	promptOptions;
+	appResourceList = [];
+	appResourceHtml = /* @__PURE__ */ new Map();
+	jsonSchemaValidator;
+	cacheHints;
+	mapAuthInfoToUser;
+	fga;
+	requestStateCodec;
+	eventRegistry;
 	eventsOptions;
 	eventsInspector;
+	tasksInspector;
 	webhooks;
 	legacy;
+	tasks;
+	/** Where tasks are kept: `tasks.store`, or the store picked on first use. */
+	taskStore;
+	/** Cancels for the workflow runs executing in this process, by run id, while they execute. */
+	executingRuns = /* @__PURE__ */ new Map();
+	/** Prepared on Mastra registration so its executors exist before the manager recovers rows. */
+	backgroundTaskStore;
 	httpHandler;
 	nodeHandler;
 	stdioHandle;
@@ -20273,6 +22589,13 @@ var MCPServer = class extends MCPServerBase {
 		this.requestStateCodec = this.createRequestStateCodec(config.requestState);
 		this.eventsOptions = config.eventsOptions ?? {};
 		this.legacy = config.legacy ?? "reject";
+		this.tasks = resolveTasksConfig(config.tasks, {
+			tools: Object.keys(config.tools ?? {}),
+			workflows: Object.keys(config.workflows ?? {}),
+			agents: Object.keys(config.agents ?? {})
+		});
+		this.hasStableId = Boolean(config.id);
+		this.taskStore = this.tasks.store ?? new SelectingMCPTaskStore(() => this.selectTaskStore());
 		const webhook = this.eventsOptions.webhook;
 		this.eventRegistry = new ServerEventRegistry(config.events, { webhook: webhook !== void 0 });
 		if (webhook && this.eventRegistry.size > 0) this.webhooks = new WebhookDispatcher({
@@ -20401,11 +22724,7 @@ var MCPServer = class extends MCPServerBase {
 	* so a tool cannot suspend into a request no client can answer.
 	*/
 	assertFormRepresentable(owner, resumeSchema) {
-		const requestedSchema = this.formSchema(resumeSchema);
-		const validation = specTypeSchemas.ElicitRequestFormParams["~standard"].validate({
-			message: owner,
-			requestedSchema
-		});
+		const validation = formValidation(owner, this.formSchema(resumeSchema));
 		if (validation instanceof Promise || validation.issues) throw new MastraError({
 			id: "MCP_SERVER_RESUME_SCHEMA_NOT_REPRESENTABLE",
 			domain: ErrorDomain.MCP,
@@ -20417,6 +22736,15 @@ var MCPServer = class extends MCPServerBase {
 			}
 		});
 	}
+	/** The input-request form for `resumeSchema`, or `undefined` when the protocol can't present it. */
+	representableForm(resumeSchema) {
+		const requestedSchema = resumeSchema ? this.formSchema(resumeSchema) : {
+			type: "object",
+			properties: {}
+		};
+		const validation = formValidation("form", requestedSchema);
+		return validation instanceof Promise || validation.issues ? void 0 : requestedSchema;
+	}
 	/**
 	* Input-request forms are a restricted flat-object subset of JSON Schema, so
 	* the dialect declaration is left off the requested schema.
@@ -20546,6 +22874,10 @@ var MCPServer = class extends MCPServerBase {
 			...capabilities.extensions,
 			[EVENTS_EXTENSION_ID]: this.eventsCapability()
 		};
+		if (this.tasks.enabled) capabilities.extensions = {
+			...capabilities.extensions,
+			...tasksCapabilityEntry()
+		};
 		return capabilities;
 	}
 	/**
@@ -20585,6 +22917,19 @@ var MCPServer = class extends MCPServerBase {
 			jsonSchema: (schema, options) => this.jsonSchema(schema, options),
 			trace: (instance, method, params, ctx, fn) => this.traceCustomRequest(instance, method, params, ctx, fn)
 		});
+		if (this.tasks.enabled) {
+			registerTaskHandlers(server, {
+				store: this.taskStore,
+				authorize: this.tasks.authorize,
+				principal: principalOf,
+				trace: (instance, method, params, ctx, fn, tracing) => this.traceCustomRequest(instance, method, params, ctx, fn, tracing)
+			});
+			const connect = server.connect.bind(server);
+			server.connect = async (transport) => {
+				emitTaskResults(transport);
+				return connect(transport);
+			};
+		}
 		return server;
 	}
 	/**
@@ -20592,8 +22937,10 @@ var MCPServer = class extends MCPServerBase {
 	* extension): the request runs under an `MCP_SERVER_REQUEST` span with its resolved
 	* request context. A push stream's span lasts as long as the stream.
 	*/
-	async traceCustomRequest(server, method, params, ctx, fn) {
+	async traceCustomRequest(server, method, params, ctx, fn, tracing = {}) {
+		if (tracing.untraced) return fn(await toRequestContext(ctx, this.mapAuthInfoToUser));
 		const caller = callerTrace(ctx);
+		const { metadata } = tracing;
 		let requestContext;
 		try {
 			requestContext = await toRequestContext(ctx, this.mapAuthInfoToUser);
@@ -20601,15 +22948,19 @@ var MCPServer = class extends MCPServerBase {
 			this.startRequestSpan(method, params, {
 				server,
 				ctx,
-				caller
+				caller,
+				metadata
 			})?.error({ error });
 			throw error;
 		}
+		const task = await tracing.parentOf?.(requestContext).catch(() => void 0);
 		const requestSpan = this.startRequestSpan(method, params, {
 			server,
 			ctx,
 			caller,
-			requestContext
+			requestContext,
+			metadata,
+			task
 		});
 		return this.traceRequest(requestSpan, () => fn(requestContext));
 	}
@@ -20681,6 +23032,11 @@ var MCPServer = class extends MCPServerBase {
 			},
 			tracingContext: {},
 			links: caller && [caller.link],
+			metadata: connection?.metadata,
+			...connection?.task && {
+				tracingOptions: { traceId: connection.task.traceId },
+				resumedFromSpanId: connection.task.spanId
+			},
 			requestContext: connection?.requestContext,
 			mastra: this.mastra
 		});
@@ -20693,6 +23049,22 @@ var MCPServer = class extends MCPServerBase {
 	async traceRequest(requestSpan, fn, getReportedError) {
 		try {
 			const result = await fn();
+			const task = taskOfHandleResult(result);
+			if (task) {
+				const mcpTaskKey = taskKeyOf(task.taskId);
+				requestSpan?.end({
+					output: { task: {
+						status: task.status,
+						mcpTaskKey
+					} },
+					metadata: {
+						mcpTaskKey,
+						mcpTaskStatus: task.status
+					}
+				});
+				if (requestSpan) this.flushTaskRoot(requestSpan);
+				return result;
+			}
 			const errorResult = result;
 			if (errorResult?.isError) requestSpan?.error({ error: getReportedError?.() ?? new MastraError({
 				id: "MCP_SERVER_REQUEST_FAILED",
@@ -20710,19 +23082,19 @@ var MCPServer = class extends MCPServerBase {
 			throw error;
 		}
 	}
+	/**
+	* Writes a task's root span out now rather than with the exporter's next batch: the task's later
+	* spans may be recorded by another process, and if this one dies first, a trace without its root
+	* drops out of trace lists.
+	*/
+	flushTaskRoot(span) {
+		span.observabilityInstance.flush().catch((error) => this.logger.debug("Could not flush a task trace root", { error }));
+	}
 	/** Answers a suspended round: one keyed form derived from the handler's `resumeSchema`. */
 	async inputRequired(ctx, requestContext, suspension) {
-		const payload = suspension.suspendPayload;
-		const message = typeof payload?.message === "string" ? payload.message : typeof suspension.resumeSchema?.description === "string" ? suspension.resumeSchema.description : `"${suspension.name}" needs more input`;
 		const { method, name, argsHash, round, suspendPayload } = suspension;
 		return inputRequired({
-			inputRequests: { [INPUT_KEY]: inputRequired.elicit({
-				message,
-				requestedSchema: suspension.resumeSchema ?? {
-					type: "object",
-					properties: {}
-				}
-			}) },
+			inputRequests: { [INPUT_KEY]: this.inputRequestForm(name, suspendPayload, suspension.resumeSchema) },
 			requestState: await this.requestStateCodec.mint({
 				method,
 				name,
@@ -20734,6 +23106,18 @@ var MCPServer = class extends MCPServerBase {
 			})
 		});
 	}
+	/** The form a suspended handler asks the client to fill in. */
+	inputRequestForm(name, suspendPayload, resumeSchema) {
+		const payload = suspendPayload;
+		const message = typeof payload?.message === "string" ? payload.message : typeof resumeSchema?.description === "string" ? resumeSchema.description : `"${name}" needs more input`;
+		return inputRequired.elicit({
+			message,
+			requestedSchema: resumeSchema ?? {
+				type: "object",
+				properties: {}
+			}
+		});
+	}
 	async serverRequest(ctx, requestContext, method, name, args, resumeSchema) {
 		const argsHash = hashArguments(args);
 		const continuation = readContinuation(ctx, requestContext, {
@@ -20784,13 +23168,35 @@ var MCPServer = class extends MCPServerBase {
 			try {
 				await this.enforceToolExecutionFGA(name, requestContext);
 				if (continuation && continuation.outcome !== "accept") return errorResult$1(`Tool '${name}' was ${continuation.outcome === "decline" ? "declined" : "cancelled"}`);
-				const execution = await this.runTool(name, tool, args, {
+				const resume = continuation && {
+					resumeData: continuation.resumeData,
+					suspendPayload: continuation.suspendPayload
+				};
+				const taskMode = this.tasks.modeFor(name, tool.mcp?.toolType);
+				const asTask = taskMode.mode !== "off" && clientDeclaredTasks(ctx);
+				if (taskMode.mode !== "off" && !asTask && this.tasks.required.has(name)) throw new MissingRequiredClientCapabilityError({ requiredCapabilities: { extensions: tasksCapabilityEntry() } }, `Tool '${name}' only runs as a task; declare the io.modelcontextprotocol/tasks extension`);
+				if (asTask && tool.mcp?.toolType === "workflow") return await this.startWorkflowTask(ctx, requestContext, name, args, taskMode, { currentSpan: trace.requestSpan });
+				if (asTask && taskMode.mode === "always") try {
+					return await this.startToolTask(ctx, requestContext, name, args, taskMode, {
+						resume,
+						rootSpan: trace.requestSpan
+					});
+				} catch (error) {
+					if (error instanceof MCPTaskLimitError) return errorResult$1(taskLimitMessage(error));
+					throw error;
+				}
+				const options = {
 					requestContext,
 					mcp,
 					tracingContext: { currentSpan: trace.requestSpan },
-					resumeData: continuation?.resumeData,
-					suspendPayload: continuation?.suspendPayload
-				});
+					...resume
+				};
+				let execution;
+				if (asTask) {
+					const raced = await this.runWithinSyncWindow(ctx, requestContext, name, tool, args, taskMode, options);
+					if ("task" in raced) return raced.task;
+					execution = raced.execution;
+				} else execution = await this.runTool(name, tool, args, options);
 				if (execution.status === "suspended") {
 					this.logger.debug(`Tool '${name}' requires client input.`);
 					return this.inputRequired(ctx, requestContext, {
@@ -20807,21 +23213,549 @@ var MCPServer = class extends MCPServerBase {
 				return result;
 			} catch (error) {
 				if (error instanceof ProtocolError$1) throw error;
-				this.logger.error("Tool execution failed", {
-					tool: name,
-					error
-				});
-				const mastraError = error instanceof MastraError ? error : new MastraError({
-					id: "TOOL_EXECUTION_FAILED",
-					domain: ErrorDomain.TOOL,
-					category: ErrorCategory.USER,
-					details: { toolName: name }
-				}, error);
+				const mastraError = this.toolError(name, error);
 				trace.reportError(mastraError);
 				return errorResult$1(JSON.stringify(mastraError.toJSON()));
 			}
 		});
 	}
+	/** Logs a tool's failure and wraps it as the error a client receives. */
+	toolError(name, error) {
+		this.logger.error("Tool execution failed", {
+			tool: name,
+			error
+		});
+		return error instanceof MastraError ? error : new MastraError({
+			id: "TOOL_EXECUTION_FAILED",
+			domain: ErrorDomain.TOOL,
+			category: ErrorCategory.USER,
+			details: { toolName: name }
+		}, error);
+	}
+	/**
+	* `'auto'` mode: runs the tool under the request for up to `syncWindowMs`. A tool that settles in
+	* time is answered like any synchronous call; otherwise the same execution carries on as a task,
+	* no longer tied to the request's cancellation.
+	*/
+	async runWithinSyncWindow(ctx, requestContext, name, tool, args, taskMode, options) {
+		const controller = new AbortController();
+		const requestSignal = ctx.mcpReq.signal;
+		const followRequest = () => controller.abort(requestSignal.reason);
+		if (requestSignal.aborted) followRequest();
+		else requestSignal.addEventListener("abort", followRequest, { once: true });
+		const settled = this.runTool(name, tool, args, {
+			...options,
+			abortSignal: controller.signal,
+			mcp: {
+				...options.mcp,
+				extra: {
+					...options.mcp.extra,
+					signal: controller.signal
+				},
+				log: (...params) => options.mcp.log(...params).catch(() => {}),
+				progress: (params) => options.mcp.progress(params).catch(() => {})
+			}
+		}).then((execution) => ({ execution }), (error) => ({ error }));
+		let timer;
+		const deadline = new Promise((resolve) => {
+			timer = setTimeout(() => resolve("timeout"), taskMode.syncWindowMs);
+		});
+		const winner = await Promise.race([settled, deadline]);
+		clearTimeout(timer);
+		requestSignal.removeEventListener("abort", followRequest);
+		if (winner !== "timeout") {
+			if ("error" in winner) throw winner.error;
+			return winner;
+		}
+		try {
+			return { task: await this.startToolTask(ctx, requestContext, name, args, taskMode, {
+				rootSpan: options.tracingContext?.currentSpan,
+				resume: options.resumeData === void 0 ? void 0 : {
+					resumeData: options.resumeData,
+					suspendPayload: options.suspendPayload
+				},
+				initialAttempt: () => ({
+					outcome: settled.then((outcome) => "error" in outcome ? this.toolErrorOutcome(name, outcome.error) : this.toTaskOutcome(name, tool, outcome.execution)),
+					abort: (reason) => controller.abort(reason)
+				})
+			}) };
+		} catch (error) {
+			if (!(error instanceof MCPTaskLimitError)) {
+				controller.abort(error);
+				throw error;
+			}
+		}
+		this.logger.debug(`Tool '${name}' outlived its sync window at a task cap; answering synchronously.`);
+		if (requestSignal.aborted) followRequest();
+		else requestSignal.addEventListener("abort", followRequest, { once: true });
+		const outcome = await settled;
+		requestSignal.removeEventListener("abort", followRequest);
+		if ("error" in outcome) throw outcome.error;
+		return outcome;
+	}
+	/**
+	* Creates the task (durably, before answering) and hands its work to the store. `initialAttempt`
+	* builds the run of an execution that already started under the request; it stays in this
+	* process. Rejects with {@link MCPTaskLimitError}, creating nothing, at a task cap.
+	*/
+	async startToolTask(ctx, requestContext, name, args, taskMode, { resume, initialAttempt, rootSpan }) {
+		const context = {
+			toolName: name,
+			args,
+			requestContext: this.persistTaskRequestContext(name, requestContext),
+			...resume && { resume }
+		};
+		const params = {
+			ttlMs: taskMode.ttlMs,
+			principal: principalOf(ctx, requestContext),
+			context,
+			limits: this.tasks.limits,
+			...rootSpan && { trace: {
+				traceId: rootSpan.traceId,
+				spanId: rootSpan.id
+			} }
+		};
+		const { store, task } = await this.createTask(ctx, requestContext, params, initialAttempt !== void 0);
+		store.run(task.taskId, this.toolTaskWork(context), { initialAttempt: initialAttempt && this.tracedInitialAttempt(name, initialAttempt(), params.trace, task.taskId, requestContext) });
+		this.logger.debug(`Tool '${name}' continues as task.`);
+		return taskHandleResult(task);
+	}
+	/** The request context a task keeps for its later attempts. */
+	persistTaskRequestContext(name, requestContext) {
+		const { persisted, dropped } = persistableRequestContext(requestContext);
+		if (dropped.length > 0) this.logger.warn(`Tool task '${name}' can't persist request context keys; runs from the task won't see them`, {
+			tool: name,
+			keys: dropped
+		});
+		return persisted;
+	}
+	/** Creates a task durably. `pinned` keeps its first attempt on this worker, which already runs it. */
+	async createTask(ctx, requestContext, params, pinned) {
+		const store = this.taskStore instanceof SelectingMCPTaskStore ? await this.taskStore.resolve() : this.taskStore;
+		return {
+			store,
+			task: store instanceof BackgroundTaskMCPTaskStore ? await store.create(params, {
+				pinToWorker: pinned,
+				clientLabel: clientLabelOf(ctx, requestContext)
+			}) : store instanceof InMemoryMCPTaskStore ? await store.create(params, { clientLabel: clientLabelOf(ctx, requestContext) }) : await store.create(params)
+		};
+	}
+	/**
+	* The work of a tool task, rebuilt from nothing but what the task's `context` records, so a store
+	* can dispatch it again after a restart. Each attempt runs the tool once; an answered suspension
+	* runs it again with `resumeData`, as everywhere else in Mastra.
+	*/
+	toolTaskWork(context) {
+		const name = context.toolName;
+		return async (attempt) => {
+			const tool = this.convertedTools[name];
+			if (!tool) throw new Error(`Tool '${name}' is no longer served`);
+			const requestContext = new RequestContext(Object.entries(context.requestContext));
+			try {
+				await this.enforceToolExecutionFGA(name, requestContext);
+			} catch (error) {
+				return this.toolErrorOutcome(name, error);
+			}
+			let { resumeData, suspendPayload } = context.resume ?? {};
+			if (attempt.resume) {
+				const [key] = Object.keys(attempt.resume.inputResponses);
+				const answer = inputResponse(attempt.resume.inputResponses, key);
+				if (answer.kind !== "elicit") return completed(errorResult$1(`Unsupported input response for tool '${name}'`));
+				if (answer.action !== "accept") return completed(errorResult$1(`Tool '${name}' was ${answer.action === "decline" ? "declined" : "cancelled"}`));
+				resumeData = answer.content ?? {};
+				suspendPayload = attempt.resume.suspendPayload;
+			}
+			const span = attempt.trace && this.openTaskSpan(`task attempt ${name} #${attempt.trace.attempt}`, attempt.trace, {
+				requestContext,
+				input: context.args,
+				mcpMethod: "tools/call",
+				targetName: name,
+				metadata: {
+					mcpTaskKey: attempt.trace.taskKey,
+					attempt: attempt.trace.attempt,
+					resumed: attempt.trace.resumed,
+					recovered: attempt.trace.recovered
+				}
+			});
+			return this.endAttemptSpan(span, attempt.signal, (async () => {
+				try {
+					const execution = await this.runTool(name, tool, context.args, {
+						requestContext,
+						abortSignal: attempt.signal,
+						resumeData,
+						suspendPayload,
+						tracingContext: span ? { currentSpan: span } : void 0
+					});
+					return this.toTaskOutcome(name, tool, execution);
+				} catch (error) {
+					return this.toolErrorOutcome(name, error);
+				}
+			})());
+		};
+	}
+	/**
+	* Opens a span in a task's trace, as a child of the task's root (the `tools/call` that created
+	* it), from any process. Uses the resume parentage workflows and agents use: the root id becomes
+	* the span's Mastra parent, so storage keeps one tree. `tracingOptions.parentSpanId` would not:
+	* it only correlates with an external system, and storage would record another root.
+	*/
+	openTaskSpan(name, trace, options) {
+		return getOrCreateSpan({
+			type: SpanType.MCP_SERVER_REQUEST,
+			name,
+			entityType: EntityType.MCP_SERVER,
+			entityId: this.id,
+			entityName: this.name,
+			input: options.input,
+			attributes: {
+				mcpMethod: options.mcpMethod,
+				...options.targetName !== void 0 && { targetName: options.targetName },
+				mcpServer: this.name,
+				serverVersion: this.version
+			},
+			metadata: options.metadata,
+			tracingOptions: { traceId: trace.traceId },
+			resumedFromSpanId: trace.spanId,
+			requestContext: options.requestContext,
+			mastra: this.mastra
+		});
+	}
+	/** Ends an attempt's span with how the attempt ended, and passes the outcome on. */
+	async endAttemptSpan(span, signal, outcome) {
+		if (!span) return outcome;
+		try {
+			const result = await outcome;
+			if (signal?.aborted) span.end({ metadata: { mcpTaskStatus: "cancelled" } });
+			else if (result.status === "input_required") span.end({ metadata: { mcpTaskStatus: "input_required" } });
+			else if (result.result.isError) span.error({
+				error: new MastraError({
+					id: "MCP_SERVER_TASK_ATTEMPT_FAILED",
+					domain: ErrorDomain.MCP,
+					category: ErrorCategory.USER,
+					text: result.result.content.map((c) => c.type === "text" ? c.text : "").filter(Boolean).join("\n")
+				}),
+				metadata: { mcpTaskStatus: "completed" }
+			});
+			else span.end({
+				output: result.result,
+				metadata: { mcpTaskStatus: "completed" }
+			});
+			return result;
+		} catch (error) {
+			if (signal?.aborted) span.end({ metadata: { mcpTaskStatus: "cancelled" } });
+			else span.error({
+				error,
+				endTree: true,
+				metadata: { mcpTaskStatus: "failed" }
+			});
+			throw error;
+		}
+	}
+	/**
+	* A first run already under way (an `'auto'` tool's or workflow's, under the request, or a
+	* workflow run started under `opened`) as attempt 1 of its task: the attempt span ends with that run.
+	*/
+	tracedInitialAttempt(name, initialAttempt, trace, taskId, requestContext, opened) {
+		if (!trace) return initialAttempt;
+		const span = opened ?? this.openTaskSpan(`task attempt ${name} #1`, trace, {
+			requestContext,
+			...firstAttemptSpan(name, taskId)
+		});
+		const aborted = new AbortController();
+		return {
+			outcome: this.endAttemptSpan(span, aborted.signal, initialAttempt.outcome),
+			abort: (reason) => {
+				aborted.abort(reason);
+				initialAttempt.abort(reason);
+			}
+		};
+	}
+	toTaskOutcome(name, tool, execution) {
+		if (execution.status === "suspended") {
+			this.logger.debug(`Tool task '${name}' requires client input.`);
+			return {
+				status: "input_required",
+				inputRequests: { [`${INPUT_KEY}-${randomUUID()}`]: this.inputRequestForm(name, execution.suspendPayload, execution.resumeSchema) },
+				suspendPayload: execution.suspendPayload
+			};
+		}
+		if (tool.mcp?.toolType === "agent" && execution.output?.finishReason === "suspended") return completed(errorResult$1(`Agent '${name.slice(4)}' paused for tool approval or input, which MCP tasks don't support yet`));
+		return completed(this.toCallToolResult(name, tool, execution.output));
+	}
+	/** A tool that throws inside a task completes it with `isError`, as a synchronous call would answer. */
+	toolErrorOutcome(name, error) {
+		return completed(errorResult$1(JSON.stringify(this.toolError(name, error).toJSON())));
+	}
+	/**
+	* Starts the run behind a `run_<key>` task. `'auto'` answers synchronously when the run finishes
+	* within `syncWindowMs`; a run that suspends or outlasts the window continues as a task.
+	*/
+	async startWorkflowTask(ctx, requestContext, name, args, taskMode, tracingContext) {
+		const workflowKey = name.slice(4);
+		const workflow = this.workflowFor(workflowKey);
+		if (!workflow) throw new Error(`Workflow '${workflowKey}' is not served`);
+		const input = validateToolInput(workflow.inputSchema, args, name);
+		if (input.error) {
+			this.logger.warn(`Tool '${name}' rejected its input.`, { error: input.error.message });
+			return errorResult$1(input.error.message);
+		}
+		const context = {
+			toolName: name,
+			kind: "workflow",
+			workflowKey,
+			runId: randomUUID(),
+			requestContext: this.persistTaskRequestContext(name, requestContext)
+		};
+		const rootSpan = tracingContext.currentSpan;
+		const params = {
+			ttlMs: taskMode.ttlMs,
+			principal: principalOf(ctx, requestContext),
+			context,
+			limits: this.tasks.limits,
+			...rootSpan && { trace: {
+				traceId: rootSpan.traceId,
+				spanId: rootSpan.id
+			} }
+		};
+		const start = (runTracing) => {
+			const run = workflow.createRun({ runId: context.runId });
+			const result = run.then((started) => started.start({
+				inputData: input.data,
+				requestContext,
+				tracingContext: runTracing
+			}));
+			const cancel = () => void run.then((started) => started.cancel()).catch((error) => this.logger.warn("Could not cancel workflow run", {
+				tool: name,
+				error
+			}));
+			this.executingRuns.set(context.runId, cancel);
+			const done = () => this.executingRuns.delete(context.runId);
+			result.then(done, done);
+			return {
+				result,
+				cancel
+			};
+		};
+		if (taskMode.mode === "always") {
+			let created;
+			try {
+				created = await this.createTask(ctx, requestContext, params, true);
+			} catch (error) {
+				if (error instanceof MCPTaskLimitError) return errorResult$1(taskLimitMessage(error));
+				throw error;
+			}
+			const { store, task } = created;
+			const span = params.trace && this.openTaskSpan(`task attempt ${name} #1`, params.trace, firstAttemptSpan(name, task.taskId));
+			const live = start(span ? { currentSpan: span } : tracingContext);
+			store.run(task.taskId, this.workflowTaskWork(context), { initialAttempt: this.tracedInitialAttempt(name, this.liveWorkflowAttempt(workflow, context, live.result), params.trace, task.taskId, requestContext, span) });
+			this.logger.debug(`Workflow tool '${name}' runs as task.`);
+			return taskHandleResult(task);
+		}
+		const live = start(tracingContext);
+		const requestSignal = ctx.mcpReq.signal;
+		const followRequest = () => live.cancel();
+		if (requestSignal.aborted) followRequest();
+		else requestSignal.addEventListener("abort", followRequest, { once: true });
+		const settled = live.result.then((view) => ({ view }), (error) => ({ error }));
+		let timer;
+		const deadline = new Promise((resolve) => {
+			timer = setTimeout(() => resolve("timeout"), taskMode.syncWindowMs);
+		});
+		const winner = await Promise.race([settled, deadline]);
+		clearTimeout(timer);
+		requestSignal.removeEventListener("abort", followRequest);
+		if (winner !== "timeout") {
+			if ("error" in winner) throw winner.error;
+			const outcome = this.workflowRunOutcome(workflow, context, winner.view);
+			if (outcome?.status === "completed") return outcome.result;
+		}
+		try {
+			const { store, task } = await this.createTask(ctx, requestContext, params, true);
+			store.run(task.taskId, this.workflowTaskWork(context), { initialAttempt: this.tracedInitialAttempt(name, this.liveWorkflowAttempt(workflow, context, live.result), params.trace, task.taskId, requestContext) });
+			this.logger.debug(`Workflow tool '${name}' continues as task.`);
+			return taskHandleResult(task);
+		} catch (error) {
+			if (!(error instanceof MCPTaskLimitError)) {
+				live.cancel();
+				throw error;
+			}
+			this.logger.debug(`Workflow tool '${name}' outlived its sync window at the open task cap.`);
+			if (requestSignal.aborted) followRequest();
+			else requestSignal.addEventListener("abort", followRequest, { once: true });
+			const late = await settled;
+			requestSignal.removeEventListener("abort", followRequest);
+			if ("error" in late) throw late.error;
+			const outcome = this.workflowRunOutcome(workflow, context, late.view);
+			if (outcome?.status === "completed") return outcome.result;
+			live.cancel();
+			return errorResult$1(taskLimitMessage(error));
+		}
+	}
+	/** The first attempt of a workflow task: the run this request started, in this process. */
+	liveWorkflowAttempt(workflow, context, result) {
+		const controller = new AbortController();
+		return {
+			outcome: result.then((view) => this.workflowRunOutcome(workflow, context, view) ?? this.watchWorkflowRun(workflow, context, controller.signal), (error) => this.toolErrorOutcome(context.toolName, error)),
+			abort: (reason) => controller.abort(reason)
+		};
+	}
+	/**
+	* The work of a workflow task, rebuilt from its context. It never starts the run: a first attempt
+	* dispatched again (after a restart) re-attaches to it, and an answered suspension resumes it.
+	*/
+	workflowTaskWork(context) {
+		const name = context.toolName;
+		return async (attempt) => {
+			const workflow = this.workflowFor(context.workflowKey);
+			if (!workflow) throw new Error(`Workflow '${context.workflowKey}' is no longer served`);
+			const requestContext = new RequestContext(Object.entries(context.requestContext));
+			try {
+				await this.enforceToolExecutionFGA(name, requestContext);
+			} catch (error) {
+				return this.toolErrorOutcome(name, error);
+			}
+			const span = attempt.trace && this.openTaskSpan(`task attempt ${name} #${attempt.trace.attempt}`, attempt.trace, {
+				requestContext,
+				mcpMethod: "tools/call",
+				targetName: name,
+				metadata: {
+					mcpTaskKey: attempt.trace.taskKey,
+					attempt: attempt.trace.attempt,
+					resumed: attempt.trace.resumed,
+					recovered: attempt.trace.recovered
+				}
+			});
+			return this.endAttemptSpan(span, attempt.signal, attempt.resume ? this.resumeWorkflowRun(workflow, context, attempt, requestContext, span) : this.watchWorkflowRun(workflow, context, attempt.signal));
+		};
+	}
+	async resumeWorkflowRun(workflow, context, attempt, requestContext, span) {
+		const { inputResponses, suspendPayload } = attempt.resume;
+		const [key] = Object.keys(inputResponses);
+		const answer = inputResponse(inputResponses, key);
+		const label = `Workflow '${context.workflowKey}'`;
+		if (answer.kind !== "elicit") return completed(errorResult$1(`Unsupported input response for ${label}`));
+		if (answer.action !== "accept") {
+			await this.cancelWorkflowRun(context);
+			return completed(errorResult$1(`${label} was ${answer.action === "decline" ? "declined" : "cancelled"}`));
+		}
+		const current = await workflow.getWorkflowRunById(context.runId, { withNestedWorkflows: false });
+		if (!current) throw new Error(`${label} run '${context.runId}' was lost`);
+		const answered = suspendPayload;
+		if (!isStillSuspended({
+			status: current.status,
+			steps: current.steps
+		}, answered)) return this.watchWorkflowRun(workflow, context, attempt.signal);
+		const run = await workflow.createRun({ runId: context.runId });
+		let view;
+		this.executingRuns.set(context.runId, () => void run.cancel().catch((error) => this.logger.warn("Could not cancel workflow run", {
+			tool: context.toolName,
+			error
+		})));
+		try {
+			view = await run.resume({
+				step: answered.step,
+				resumeData: answer.content ?? {},
+				requestContext,
+				...span && { tracingContext: { currentSpan: span } }
+			});
+		} catch (error) {
+			if (isResumeClaimLost(error)) return this.watchWorkflowRun(workflow, context, attempt.signal);
+			const now = await workflow.getWorkflowRunById(context.runId, { withNestedWorkflows: false });
+			if (now && !isStillSuspended({
+				status: now.status,
+				steps: now.steps
+			}, answered)) return this.watchWorkflowRun(workflow, context, attempt.signal);
+			return this.toolErrorOutcome(context.toolName, error);
+		} finally {
+			this.executingRuns.delete(context.runId);
+		}
+		return this.workflowRunOutcome(workflow, context, view) ?? this.watchWorkflowRun(workflow, context, attempt.signal);
+	}
+	/**
+	* Polls the run until it finishes or suspends on a step the client can answer. The only way to
+	* follow a run from any instance, whichever engine runs it.
+	*/
+	async watchWorkflowRun(workflow, context, signal) {
+		let first = true;
+		for (;;) {
+			signal.throwIfAborted();
+			const state = await workflow.getWorkflowRunById(context.runId, { withNestedWorkflows: false });
+			if (!state || first && state.status === "pending") throw new Error(`Workflow '${context.workflowKey}' run '${context.runId}' was lost`);
+			first = false;
+			const outcome = this.workflowRunOutcome(workflow, context, {
+				status: state.status,
+				input: state.payload,
+				steps: state.steps,
+				result: state.result,
+				error: state.error
+			});
+			if (outcome) return outcome;
+			await sleep(WORKFLOW_POLL_INTERVAL_MS, signal);
+		}
+	}
+	/**
+	* What a run's state means for its task, or `undefined` while there is nothing to report: the
+	* run is still going, or waits on a step whose `resumeSchema` no input request can present (the
+	* task stays `working` until the run is resumed some other way).
+	*/
+	workflowRunOutcome(workflow, context, view) {
+		const label = `Workflow '${context.workflowKey}'`;
+		switch (view.status) {
+			case "success":
+			case "bailed": return completed({
+				isError: false,
+				content: [{
+					type: "text",
+					text: JSON.stringify(runSummary(view))
+				}]
+			});
+			case "failed": return completed(errorResult$1(`${label} failed: ${runErrorMessage(view)}`));
+			case "tripwire": return completed(errorResult$1(`${label} was blocked: ${runErrorMessage(view)}`));
+			case "canceled": return completed(errorResult$1(`${label} run was cancelled`));
+			case "suspended": {
+				const suspended = firstSuspendedStep(workflow, view);
+				if (!suspended) return void 0;
+				const requestedSchema = this.representableForm(suspended.step?.resumeSchema);
+				if (!requestedSchema) return void 0;
+				this.logger.debug(`Workflow task '${context.toolName}' requires client input.`);
+				return {
+					status: "input_required",
+					inputRequests: { [`${INPUT_KEY}-${randomUUID()}`]: this.inputRequestForm(context.toolName, suspended.payload, requestedSchema) },
+					suspendPayload: {
+						step: suspended.path,
+						suspendedAt: suspended.suspendedAt
+					}
+				};
+			}
+			default: return;
+		}
+	}
+	/**
+	* Cancels the task's run, for a declined input or the store's onCancel (`tasks/cancel`, TTL
+	* expiry), on whichever instance that happens. A run executing in this process is cancelled here.
+	* A run executing in another process is left alone: writing `canceled` under it doesn't stop it,
+	* its next write overwrites the status, and its own cancel would then find it `canceled` and do
+	* nothing. A run that waits (suspended, pending) is cancelled in storage. A finished run is left alone.
+	*/
+	async cancelWorkflowRun(context) {
+		const local = this.executingRuns.get(context.runId);
+		if (local) return local();
+		const workflow = this.workflowFor(context.workflowKey);
+		if (!workflow) return;
+		try {
+			const state = await workflow.getWorkflowRunById(context.runId, { withNestedWorkflows: false });
+			if (!state || isFinalRunStatus(state.status) || state.status === "running") return;
+			await (await workflow.createRun({ runId: context.runId })).cancel();
+		} catch (error) {
+			this.logger.warn("Could not cancel workflow run", {
+				tool: context.toolName,
+				error
+			});
+		}
+	}
+	workflowFor(key) {
+		return this.workflows?.[key];
+	}
 	/**
 	* Runs one round of a tool. The tool sees the same `suspend` / `resumeData` /
 	* `suspendPayload` vocabulary as under an agent or workflow; nothing else is
@@ -20836,7 +23770,7 @@ var MCPServer = class extends MCPServerBase {
 			skipToolSpan: true,
 			requestContext: options.requestContext,
 			tracingContext: options.tracingContext,
-			abortSignal: options.mcp?.extra.signal,
+			abortSignal: options.abortSignal ?? options.mcp?.extra.signal,
 			...options.mcp ? { mcp: options.mcp } : {},
 			suspend: async (payload, suspendOptions) => {
 				suspension = {
@@ -21157,6 +24091,65 @@ var MCPServer = class extends MCPServerBase {
 			this.httpHandler = void 0;
 			this.nodeHandler = void 0;
 		}
+		if (this.taskStore instanceof SelectingMCPTaskStore) this.taskStore.close();
+		await this.backgroundTaskStore?.close();
+	}
+	/** Whether the id was given (in the config, or as a Mastra registration key) rather than generated per process. */
+	hasStableId = false;
+	setId(id) {
+		super.setId(id);
+		if (this.id === id) this.hasStableId = true;
+	}
+	/** @internal */
+	__registerMastra(mastra) {
+		super.__registerMastra(mastra);
+		const prepared = this.backgroundTaskStore;
+		if (!this.prepareBackgroundTaskStore() || !(this.taskStore instanceof SelectingMCPTaskStore)) return;
+		if (!prepared) this.taskStore.reselect();
+		this.taskStore.resolve().catch((error) => this.logger.debug(`MCP server '${this.name}' could not choose its task store yet`, { error }));
+	}
+	/**
+	* Builds the background-task store and registers an executor for every task tool, when tasks
+	* are on, no store was passed in, and Mastra has background tasks.
+	*/
+	prepareBackgroundTaskStore() {
+		if (this.backgroundTaskStore) return this.backgroundTaskStore;
+		if (!this.tasks.enabled || this.tasks.store) return void 0;
+		const manager = this.mastra?.backgroundTaskManager;
+		if (!manager) return void 0;
+		const store = new BackgroundTaskMCPTaskStore({
+			manager,
+			serverId: this.id,
+			workFor: (context) => isWorkflowTaskContext(context) ? this.workflowTaskWork(context) : this.toolTaskWork(context),
+			onCancel: (context) => isWorkflowTaskContext(context) ? this.cancelWorkflowRun(context) : void 0,
+			recoverFor: (name) => this.tasks.modeFor(name, this.convertedTools[name]?.mcp?.toolType).recover,
+			logger: () => this.logger
+		});
+		for (const [name, tool] of Object.entries(this.convertedTools)) if (this.tasks.modeFor(name, tool.mcp?.toolType).mode !== "off") store.registerTool(name);
+		this.backgroundTaskStore = store;
+		return store;
+	}
+	/**
+	* Mastra's background tasks when the storage keeps per-row expiry (so a task's TTL, not the
+	* global cleanup, decides when it is deleted); an in-memory store otherwise.
+	*/
+	async selectTaskStore() {
+		const manager = this.mastra?.backgroundTaskManager;
+		if (manager) {
+			const storage = await manager.getStorage();
+			if (storage.supportsTaskExpiry === true) {
+				const prepared = this.backgroundTaskStore;
+				const store = this.prepareBackgroundTaskStore();
+				if (!this.hasStableId) this.logger.warn(`MCP server '${this.name}' keeps tasks in Mastra storage under the generated id '${this.id}', which changes on every start: other instances and restarts won't find its tasks. Pass \`id\` to the MCPServer, or register it under a key in Mastra's \`mcpServers\`.`);
+				store.startSweeping();
+				if (!prepared) this.logger.warn(`MCP server '${this.name}' serves tasks from Mastra background tasks that started after it was registered; tasks created before a restart may not have been recovered`);
+				return store;
+			}
+			this.logger.warn(`MCP server '${this.name}' keeps tasks in memory: the background tasks storage (${storage.constructor.name}) does not support task expiry. Upgrade the storage adapter to serve tasks across instances.`);
+			await this.backgroundTaskStore?.close();
+			this.backgroundTaskStore = void 0;
+		}
+		return new InMemoryMCPTaskStore({ onCancel: (context) => isWorkflowTaskContext(context) ? this.cancelWorkflowRun(context) : void 0 });
 	}
 	getServerInfo() {
 		return {
@@ -21282,6 +24275,32 @@ var MCPServer = class extends MCPServerBase {
 		this.eventsInspector ??= createEventsInspector(this.eventsDeps());
 		return this.eventsInspector;
 	}
+	/**
+	* Which tools run as MCP tasks and whether the task store can be listed, or `undefined` when
+	* no tool runs as a task. Used by Studio.
+	* @experimental
+	*/
+	getTasksInfo() {
+		if (!this.tasks.enabled) return void 0;
+		return tasksInfo(this.tasks, this.taskToolTypes());
+	}
+	/**
+	* Lists, cancels and answers this server's tasks across principals, through the task store's
+	* admin view, or `undefined` when no tool runs as a task or the store can't be listed. Used by
+	* Studio; there is no protocol equivalent of the listing.
+	* @experimental
+	*/
+	getTasksInspector() {
+		if (!this.getTasksInfo()?.listable) return void 0;
+		this.tasksInspector ??= createTasksInspector(async () => {
+			if (this.taskStore instanceof SelectingMCPTaskStore) return this.taskStore.admin();
+			return isMCPTaskStoreAdmin(this.taskStore) ? this.taskStore : void 0;
+		});
+		return this.tasksInspector;
+	}
+	taskToolTypes() {
+		return Object.entries(this.convertedTools).map(([name, tool]) => [name, tool.mcp?.toolType]);
+	}
 	eventsDeps() {
 		return {
 			registry: this.eventRegistry,
@@ -21296,6 +24315,10 @@ var MCPServer = class extends MCPServerBase {
 function isRegistrableTool(tool) {
 	return !!tool && typeof tool === "object" && "id" in tool && typeof tool.id === "string";
 }
+function taskLimitMessage({ scope, limit, kind }) {
+	if (kind === "retained") return scope === "principal" ? `Too many recent tasks for this client (limit ${limit}). Try again once older tasks expire.` : `Too many recent tasks on this server (limit ${limit}). Try again later.`;
+	return scope === "principal" ? `Too many open tasks for this client (limit ${limit}). Wait for one to finish or cancel one.` : `Too many open tasks on this server (limit ${limit}). Try again later.`;
+}
 function errorResult$1(text) {
 	return {
 		content: [{
@@ -21305,6 +24328,75 @@ function errorResult$1(text) {
 		isError: true
 	};
 }
+/** The span options of a task's first attempt, minus its request context. */
+function firstAttemptSpan(name, taskId) {
+	return {
+		mcpMethod: "tools/call",
+		targetName: name,
+		metadata: {
+			mcpTaskKey: taskKeyOf(taskId),
+			attempt: 1,
+			resumed: false,
+			recovered: false
+		}
+	};
+}
+function completed(result) {
+	return {
+		status: "completed",
+		result
+	};
+}
+/** How often a workflow task reads its run's state while it runs elsewhere. */
+const WORKFLOW_POLL_INTERVAL_MS = 1e3;
+function formValidation(message, requestedSchema) {
+	return specTypeSchemas.ElicitRequestFormParams["~standard"].validate({
+		message,
+		requestedSchema
+	});
+}
+/** `run.resume()` lost to another resume, or found the run no longer suspended. */
+function isResumeClaimLost(error) {
+	return error instanceof MastraError && (error.id === "WORKFLOW_RESUME_ALREADY_CLAIMED" || error.id === "WORKFLOW_RUN_NOT_SUSPENDED");
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Whether this request's client declared the Tasks extension; only 2026-07-28 requests carry it. */
+function clientDeclaredTasks(ctx) {
+	const envelope = ctx.mcpReq.envelope;
+	return hasTasksCapability(envelope?.[CLIENT_CAPABILITIES_META_KEY]);
+}
+/** The request context a task keeps. Bearer tokens are dropped so they are never stored with the task. */
+function persistableRequestContext(requestContext) {
+	const { authInfo, [MASTRA_AUTH_TOKEN_KEY]: _authToken, ...rest } = requestContext.toJSON();
+	let stripped = rest;
+	if (authInfo && typeof authInfo === "object") {
+		const { token: _token, ...withoutToken } = authInfo;
+		stripped = {
+			...rest,
+			authInfo: withoutToken
+		};
+	} else if (authInfo !== void 0) stripped = {
+		...rest,
+		authInfo
+	};
+	const persisted = JSON.parse(JSON.stringify(stripped));
+	return {
+		persisted,
+		dropped: [...requestContext.keys()].filter((key) => typeof key === "string" && key !== MASTRA_AUTH_TOKEN_KEY && requestContext.get(key) !== void 0 && !(key in persisted))
+	};
+}
 /** The tool's MCP App URI; the nested key wins over the flat one, as in ext-apps' `getToolUiResourceUri`. */
 function uiResourceUri(meta) {
 	return (meta?.ui)?.resourceUri || meta?.[RESOURCE_URI_META_KEY] || void 0;
@@ -22014,6 +25106,6 @@ var MCPEventsSignalProvider = class MCPEventsSignalProvider extends SignalProvid
 		else console.warn(`[${this.id}] ${info.key}:`, error);
 	}
 };
-export { InMemoryMCPEventCursorStore, InMemoryOAuthStorage, InMemoryWebhookSubscriptionStore, InternalMastraMCPClient, MCPClient, MCPClientServerProxy, MCPEventsSignalProvider, MCPOAuthClientProvider, MCPServer, MCP_CALL_TOOL_CONTENT, MCP_CALL_TOOL_META, MCP_CLIENT_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION, ServerEventActions, ServerPromptActions, ServerResourceActions, ServerToolActions, UnauthorizedError, auth, buildDiscoveryUrls, createIntrospectionValidator, createOAuthCallbackServer, createOAuthMiddleware, createSimpleTokenProvider, createStaticTokenValidator, defineEvent, discoverAuthorizationServerMetadata, discoverOAuthMetadata, discoverOAuthProtectedResourceMetadata, exchangeAuthorization, extractBearerToken, extractResourceMetadataUrl, generateProtectedResourceMetadata, generateWWWAuthenticateHeader, getCallbackUrlCandidates, getMcpCallToolContent, getMcpCallToolMeta, parseErrorResponse, refreshAuthorization, selectResourceURL, startAuthorization, traceContextFromMeta, traceContextToMeta };
+export { InMemoryMCPEventCursorStore, InMemoryMCPTaskStore, InMemoryOAuthStorage, InMemoryWebhookSubscriptionStore, InternalMastraMCPClient, MCPClient, MCPClientServerProxy, MCPEventsSignalProvider, MCPOAuthClientProvider, MCPServer, MCPTaskLimitError, MCP_CALL_TOOL_CONTENT, MCP_CALL_TOOL_META, MCP_CLIENT_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION, ServerEventActions, ServerPromptActions, ServerResourceActions, ServerToolActions, UnauthorizedError, auth, buildDiscoveryUrls, createIntrospectionValidator, createOAuthCallbackServer, createOAuthMiddleware, createSimpleTokenProvider, createStaticTokenValidator, defineEvent, discoverAuthorizationServerMetadata, discoverOAuthMetadata, discoverOAuthProtectedResourceMetadata, exchangeAuthorization, extractBearerToken, extractResourceMetadataUrl, generateProtectedResourceMetadata, generateWWWAuthenticateHeader, getCallbackUrlCandidates, getMcpCallToolContent, getMcpCallToolMeta, isMCPTaskStoreAdmin, isWorkflowTaskContext, parseErrorResponse, principalKeyOf, refreshAuthorization, selectResourceURL, startAuthorization, taskKeyOf, traceContextFromMeta, traceContextToMeta };
 
 //# sourceMappingURL=index.js.map