@mastra/client-js 1.47.0-alpha.1 → 1.47.0-alpha.10

package/dist/index.js

@@ -5,7 +5,7 @@ import { standardSchemaToJSONSchema, toStandardSchema } from "@mastra/schema-com
 import { RequestContext, RequestContext as RequestContext$1 } from "@mastra/core/request-context";
 import { zodToJsonSchema } from "@mastra/schema-compat/zod-to-json";
 import { MastraA2AError } from "@mastra/core/a2a/client";
-import { AgentCard, CancelTaskRequest, GetTaskRequest, ListTasksRequest, ListTasksResponse, SendMessageRequest, SendMessageResponse, StreamResponse, SubscribeToTaskRequest, Task } from "@mastra/core/a2a/v1";
+import { AgentCard, CancelTaskRequest, DeleteTaskPushNotificationConfigRequest, GetTaskPushNotificationConfigRequest, GetTaskRequest, ListTaskPushNotificationConfigsRequest, ListTaskPushNotificationConfigsResponse, ListTasksRequest, ListTasksResponse, SendMessageRequest, SendMessageResponse, StreamResponse, SubscribeToTaskRequest, Task, TaskPushNotificationConfig } from "@mastra/core/a2a/v1";
 import canonicalize from "canonicalize";
 import { base64url, compactVerify, decodeProtectedHeader, importJWK, importSPKI, importX509 } from "jose";
 //#region src/observability/collector.ts
@@ -341,6 +341,33 @@ function buildTenancyQuery(tenancy) {
 	const queryString = searchParams.toString();
 	return queryString ? `?${queryString}` : "";
 }
+/**
+* Merges multiple optional abort signals into one. Returns `undefined` when no
+* signals are provided, the single signal when only one is provided, and a
+* combined signal otherwise. Uses `AbortSignal.any` when available and falls
+* back to a manual listener merge for runtimes that lack it.
+*/
+function mergeAbortSignals(...signals) {
+	const defined = signals.filter((signal) => signal !== void 0);
+	if (defined.length === 0) return void 0;
+	if (defined.length === 1) return defined[0];
+	if (typeof AbortSignal.any === "function") return AbortSignal.any(defined);
+	const controller = new AbortController();
+	const alreadyAborted = defined.find((signal) => signal.aborted);
+	if (alreadyAborted) {
+		controller.abort(alreadyAborted.reason);
+		return controller.signal;
+	}
+	const cleanup = () => {
+		for (const signal of defined) signal.removeEventListener("abort", onAbort);
+	};
+	function onAbort() {
+		cleanup();
+		controller.abort(this.reason);
+	}
+	for (const signal of defined) signal.addEventListener("abort", onAbort);
+	return controller.signal;
+}
 //#endregion
 //#region src/utils/client-tool-model-output.ts
 /**
@@ -535,43 +562,61 @@ var BaseResource = class {
 	*/
 	async request(path, options = {}) {
 		let lastError = null;
-		const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {}, credentials, fetch: customFetch } = this.options;
+		const { baseUrl, retries: defaultRetries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {}, credentials, fetch: customFetch } = this.options;
+		const { retries: requestRetries, ...fetchOptions } = options;
+		const retries = requestRetries ?? defaultRetries;
+		if (!Number.isSafeInteger(retries) || retries < 0) throw new RangeError("retries must be a non-negative safe integer");
+		const signal = mergeAbortSignals(this.options.abortSignal, fetchOptions.signal);
 		const fetchFn = customFetch || fetch;
 		let delay = backoffMs;
 		const fullPath = `${this.apiPrefix}${path}`;
-		for (let attempt = 0; attempt <= retries; attempt++) try {
-			const response = await fetchFn(`${baseUrl.replace(/\/$/, "")}${fullPath}`, {
-				...options,
-				headers: {
-					...options.body && !(options.body instanceof FormData) && (options.method === "POST" || options.method === "PUT" || options.method === "PATCH" || options.method === "DELETE") ? { "content-type": "application/json" } : {},
-					...headers,
-					...options.headers
-				},
-				signal: this.options.abortSignal,
-				credentials: options.credentials ?? credentials,
-				body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
-			});
-			if (!response.ok) {
-				const errorBody = await response.text();
-				let parsedBody;
-				let errorMessage = `HTTP error! status: ${response.status}`;
-				try {
-					parsedBody = JSON.parse(errorBody);
-					errorMessage += ` - ${JSON.stringify(parsedBody)}`;
-				} catch {
-					if (errorBody) errorMessage += ` - ${errorBody}`;
+		for (let attempt = 0; attempt <= retries; attempt++) {
+			if (signal?.aborted) throw signal.reason ?? new DOMException("This operation was aborted", "AbortError");
+			try {
+				const response = await fetchFn(`${baseUrl.replace(/\/$/, "")}${fullPath}`, {
+					...fetchOptions,
+					headers: {
+						...fetchOptions.body && !(fetchOptions.body instanceof FormData) && (fetchOptions.method === "POST" || fetchOptions.method === "PUT" || fetchOptions.method === "PATCH" || fetchOptions.method === "DELETE") ? { "content-type": "application/json" } : {},
+						...headers,
+						...fetchOptions.headers
+					},
+					signal,
+					credentials: fetchOptions.credentials ?? credentials,
+					body: fetchOptions.body instanceof FormData ? fetchOptions.body : fetchOptions.body ? JSON.stringify(fetchOptions.body) : void 0
+				});
+				if (!response.ok) {
+					const errorBody = await response.text();
+					let parsedBody;
+					let errorMessage = `HTTP error! status: ${response.status}`;
+					try {
+						parsedBody = JSON.parse(errorBody);
+						errorMessage += ` - ${JSON.stringify(parsedBody)}`;
+					} catch {
+						if (errorBody) errorMessage += ` - ${errorBody}`;
+					}
+					throw new MastraClientError(response.status, response.statusText, errorMessage, parsedBody);
 				}
-				throw new MastraClientError(response.status, response.statusText, errorMessage, parsedBody);
+				if (options.stream) return response;
+				return await response.json();
+			} catch (error) {
+				lastError = error;
+				if (signal?.aborted || error?.name === "AbortError") throw error;
+				const status = error.status;
+				if (status !== void 0 && status >= 400 && status < 500) throw error;
+				if (attempt === retries) break;
+				await new Promise((resolve, reject) => {
+					const timer = setTimeout(() => {
+						signal?.removeEventListener("abort", onAbort);
+						resolve();
+					}, delay);
+					const onAbort = () => {
+						clearTimeout(timer);
+						reject(signal?.reason ?? new DOMException("This operation was aborted", "AbortError"));
+					};
+					signal?.addEventListener("abort", onAbort, { once: true });
+				});
+				delay = Math.min(delay * 2, maxBackoffMs);
 			}
-			if (options.stream) return response;
-			return await response.json();
-		} catch (error) {
-			lastError = error;
-			const status = error.status;
-			if (status !== void 0 && status >= 400 && status < 500) throw error;
-			if (attempt === retries) break;
-			await new Promise((resolve) => setTimeout(resolve, delay));
-			delay = Math.min(delay * 2, maxBackoffMs);
 		}
 		throw lastError || /* @__PURE__ */ new Error("Request failed");
 	}
@@ -895,6 +940,11 @@ var Agent = class extends BaseResource {
 	* depending on the toolset's scope).
 	*
 	* @param threadId - Optional thread ID for thread-scoped browser sessions
+	*
+	* @remarks This is a browser-stream adapter compatibility endpoint, not a
+	* `SERVER_ROUTES` route. Its historical deployer implementation returns
+	* `{ success: true }`; no generated contract exists while the adapter owns it.
+	* The public `boolean` result remains broad for backwards compatibility.
 	*/
 	closeBrowser(threadId) {
 		return this.request(`/agents/${this.agentId}/browser/close`, {
@@ -1191,12 +1241,13 @@ var Agent = class extends BaseResource {
 	* @experimental Agent signals are experimental and may change in a future release.
 	*/
 	async abortThread(params) {
-		const { resourceId, threadId } = params;
+		const { resourceId, threadId, expectedRunId } = params;
 		return this.request(`/agents/${this.agentId}/threads/abort`, {
 			method: "POST",
 			body: {
 				resourceId,
-				threadId
+				threadId,
+				...expectedRunId === void 0 ? {} : { expectedRunId }
 			}
 		});
 	}
@@ -1296,8 +1347,10 @@ var Agent = class extends BaseResource {
 		return this.request(`/stored/agents/${encodeURIComponent(this.agentId)}/versions/compare?${queryParams.toString()}${contextString ? `&${contextString.slice(1)}` : ""}`);
 	}
 	async generateLegacy(params) {
+		const { abortSignal: perCallSignal, ...bodyParams } = params;
+		const abortSignal = mergeAbortSignals(this.options.abortSignal, perCallSignal);
 		const processedParams = {
-			...params,
+			...bodyParams,
 			output: params.output ? zodToJsonSchema$1(params.output) : void 0,
 			experimental_output: params.experimental_output ? zodToJsonSchema$1(params.experimental_output) : void 0,
 			requestContext: parseClientRequestContext(params.requestContext),
@@ -1306,9 +1359,11 @@ var Agent = class extends BaseResource {
 		const { resourceId, threadId, requestContext } = processedParams;
 		const response = await this.request(`/agents/${this.agentId}/generate-legacy`, {
 			method: "POST",
-			body: processedParams
+			body: processedParams,
+			signal: abortSignal
 		});
 		if (response.finishReason === "tool-calls") {
+			if (abortSignal?.aborted) throw abortSignal.reason ?? new DOMException("This operation was aborted", "AbortError");
 			const toolCalls = response.toolCalls;
 			if (!toolCalls || !Array.isArray(toolCalls)) return response;
 			for (const toolCall of toolCalls) {
@@ -1357,8 +1412,10 @@ var Agent = class extends BaseResource {
 			messages
 		};
 		const resolvedClientTools = params.clientToolsResolver?.() ?? params.clientTools;
+		const abortSignal = mergeAbortSignals(this.options.abortSignal, params.abortSignal);
 		const processedParams = {
 			...params,
+			abortSignal: void 0,
 			requestContext: parseClientRequestContext(params.requestContext),
 			clientTools: processClientTools(resolvedClientTools),
 			structuredOutput: params.structuredOutput ? {
@@ -1372,20 +1429,24 @@ var Agent = class extends BaseResource {
 		const threadId = typeof thread === "string" ? thread : thread?.id;
 		const response = await this.request(`/agents/${this.agentId}/generate`, {
 			method: "POST",
-			body: processedParams
-		});
-		if (response.finishReason === "tool-calls") return executeToolCallAndRespond({
-			response,
-			params: {
-				...params,
-				clientTools: resolvedClientTools
-			},
-			agentId: this.agentId,
-			resourceId,
-			threadId,
-			requestContext,
-			respondFn: this.generate.bind(this)
+			body: processedParams,
+			signal: abortSignal
 		});
+		if (response.finishReason === "tool-calls") {
+			if (abortSignal?.aborted) throw abortSignal.reason ?? new DOMException("This operation was aborted", "AbortError");
+			return executeToolCallAndRespond({
+				response,
+				params: {
+					...params,
+					clientTools: resolvedClientTools
+				},
+				agentId: this.agentId,
+				resourceId,
+				threadId,
+				requestContext,
+				respondFn: this.generate.bind(this)
+			});
+		}
 		return response;
 	}
 	async processChatResponse({ stream, update, onToolCall, onFinish, getCurrentDate = () => /* @__PURE__ */ new Date(), lastMessage }) {
@@ -1621,7 +1682,7 @@ var Agent = class extends BaseResource {
 				throw new Error(error);
 			}
 		});
-		onFinish?.({
+		await onFinish?.({
 			message,
 			finishReason,
 			usage
@@ -1640,8 +1701,22 @@ var Agent = class extends BaseResource {
 			requestContext: parseClientRequestContext(params.requestContext),
 			clientTools: processClientTools(params.clientToolsResolver?.() ?? params.clientTools)
 		};
-		const { readable, writable } = new TransformStream();
-		const response = await this.processStreamResponseLegacy(processedParams, writable);
+		const { readable: innerReadable, writable } = new TransformStream();
+		const abortController = new AbortController();
+		const signal = mergeAbortSignals(abortController.signal, params.abortSignal, this.options.abortSignal);
+		const innerReader = innerReadable.getReader();
+		const readable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await innerReader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			},
+			cancel(reason) {
+				abortController.abort(reason);
+				return innerReader.cancel(reason).catch(() => {});
+			}
+		});
+		const response = await this.processStreamResponseLegacy(processedParams, writable, signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -1882,29 +1957,63 @@ var Agent = class extends BaseResource {
 				}
 			}
 		});
-		onFinish?.({
+		await onFinish?.({
 			message,
 			finishReason,
 			usage
 		});
 	}
-	async processStreamResponse(processedParams, controller, route = "stream") {
+	/**
+	* Creates the consumer-facing stream for the streaming methods. Cancelling the
+	* returned stream (or aborting `externalSignal`) aborts the underlying request
+	* and stops any client-tool continuations.
+	*/
+	createCancellableStream(externalSignal) {
+		const abortController = new AbortController();
+		let readableController;
+		return {
+			readable: new ReadableStream({
+				start(controller) {
+					readableController = controller;
+				},
+				cancel(reason) {
+					abortController.abort(reason);
+				}
+			}),
+			controller: readableController,
+			signal: mergeAbortSignals(abortController.signal, externalSignal, this.options.abortSignal)
+		};
+	}
+	async processStreamResponse(processedParams, controller, route = "stream", signal) {
 		const { memory } = processedParams ?? {};
 		const { resource, thread } = memory ?? {};
 		const threadId = processedParams.threadId ?? (typeof thread === "string" ? thread : thread?.id);
 		const resourceId = processedParams.resourceId ?? resource;
-		let requestBody = processedParams;
+		const { abortSignal: _abortSignal, ...serializableParams } = processedParams;
+		let requestBody = serializableParams;
 		if (route === "resume-stream") {
-			const { messages: _messages, ...resumeStreamBody } = processedParams;
+			const { messages: _messages, ...resumeStreamBody } = serializableParams;
 			requestBody = resumeStreamBody;
 		}
 		const requestPath = route === "stream" && this.routeOverrides?.stream ? this.routeOverrides.stream : `/agents/${this.agentId}/${route}`;
 		const response = await this.request(requestPath, {
 			method: "POST",
 			body: requestBody,
-			stream: true
+			stream: true,
+			signal
 		});
 		if (!response.body) throw new Error("No response body");
+		const isAborted = () => Boolean(signal?.aborted);
+		const isAbortError = (error) => isAborted() || error?.name === "AbortError";
+		const safeClose = () => {
+			try {
+				controller.close();
+			} catch {}
+		};
+		const safeEnqueue = (chunk) => {
+			if (isAborted()) return;
+			controller.enqueue(chunk);
+		};
 		try {
 			let messages = [];
 			let streamRunId = processedParams.runId;
@@ -1916,7 +2025,7 @@ var Agent = class extends BaseResource {
 				const lines = pendingText.split("\n\n");
 				pendingText = isFinal ? "" : lines.pop() ?? "";
 				const readableLines = lines.filter((line) => line.trim() !== "[DONE]" && line.trim() !== "data: [DONE]").join("\n\n");
-				if (readableLines) controller.enqueue(new TextEncoder().encode(`${readableLines}\n\n`));
+				if (readableLines) safeEnqueue(new TextEncoder().encode(`${readableLines}\n\n`));
 			};
 			const pipePromise = streamForController.pipeTo(new WritableStream({
 				async write(chunk) {
@@ -1924,26 +2033,32 @@ var Agent = class extends BaseResource {
 						enqueueReadableText(decoder.decode(chunk, { stream: true }));
 					} catch (error) {
 						console.error("Error enqueueing to controller:", error);
-						controller.enqueue(chunk);
+						safeEnqueue(chunk);
 					}
 				},
 				close() {
 					enqueueReadableText(decoder.decode(), true);
 				}
-			})).catch((error) => {
-				console.error("Error piping to controller:", error);
+			}), { signal }).catch((error) => {
+				if (!isAbortError(error)) console.error("Error piping to controller:", error);
+				safeClose();
+			});
+			const onAbort = () => {
 				try {
-					controller.close();
+					controller.error(signal?.reason);
 				} catch {}
-			});
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const processingStream = signal ? streamForProcessing.pipeThrough(new TransformStream(), { signal }) : streamForProcessing;
 			this.processChatResponse_vNext({
-				stream: streamForProcessing,
+				stream: processingStream,
 				update: ({ message }) => {
 					const existingIndex = messages.findIndex((m) => m.id === message.id);
 					if (existingIndex !== -1) messages[existingIndex] = message;
 					else messages.push(message);
 				},
 				onFinish: async ({ finishReason, message }) => {
+					if (isAborted()) return;
 					if (finishReason === "tool-calls") {
 						const toolInvocationsById = /* @__PURE__ */ new Map();
 						for (const part of message?.parts ?? []) {
@@ -1970,6 +2085,7 @@ var Agent = class extends BaseResource {
 							const syntheticChunks = [];
 							const toolResultContents = [];
 							for (const toolCall of executableToolCalls) {
+								if (isAborted()) return;
 								const clientTool = processedParams.clientTools?.[toolCall.toolName];
 								const runId = streamRunId ?? toolCall.toolCallId;
 								let result;
@@ -2037,6 +2153,7 @@ var Agent = class extends BaseResource {
 							try {
 								await pipePromise;
 							} catch {}
+							if (isAborted()) return;
 							for (const synthetic of syntheticChunks) try {
 								const errorForSerialization = synthetic.type === "tool-error" ? synthetic.payload.error : void 0;
 								const serializedError = errorForSerialization instanceof Error ? {
@@ -2052,7 +2169,7 @@ var Agent = class extends BaseResource {
 									}
 								} : synthetic;
 								const sseLine = `data: ${JSON.stringify(payloadForWire)}\n\n`;
-								controller.enqueue(new TextEncoder().encode(sseLine));
+								safeEnqueue(new TextEncoder().encode(sseLine));
 							} catch (enqueueErr) {
 								console.error("Failed to enqueue synthetic tool-result chunk:", enqueueErr);
 							}
@@ -2066,22 +2183,23 @@ var Agent = class extends BaseResource {
 								toolResultMessage
 							];
 							const recursionRoute = route === "resume-stream" ? "stream" : route === "resume-stream-until-idle" ? "stream-until-idle" : route;
+							if (isAborted()) return;
 							try {
 								await this.processStreamResponse({
 									...processedParams,
 									messages: updatedMessages,
 									clientTools: processClientTools(processedParams.clientToolsResolver?.() ?? processedParams.clientTools)
-								}, controller, recursionRoute);
+								}, controller, recursionRoute, signal);
 							} catch (error) {
-								console.error("Error processing recursive stream response:", error);
+								if (!isAbortError(error)) console.error("Error processing recursive stream response:", error);
 							}
 						} else {
 							await pipePromise;
-							controller.close();
+							safeClose();
 						}
 					} else {
 						await pipePromise;
-						controller.close();
+						safeClose();
 					}
 				},
 				onStreamChunk: (chunk) => {
@@ -2089,14 +2207,16 @@ var Agent = class extends BaseResource {
 				},
 				lastMessage: void 0
 			}).catch(async (error) => {
-				console.error("Error processing stream response:", error);
+				if (!isAbortError(error)) console.error("Error processing stream response:", error);
 				try {
 					await pipePromise;
-					controller.close();
 				} catch {}
+				safeClose();
+			}).finally(() => {
+				signal?.removeEventListener("abort", onAbort);
 			});
 		} catch (error) {
-			console.error("Error processing stream response:", error);
+			if (!isAbortError(error)) console.error("Error processing stream response:", error);
 		}
 		return response;
 	}
@@ -2193,11 +2313,8 @@ var Agent = class extends BaseResource {
 			clientTools: processClientTools(params.clientToolsResolver?.() ?? params.clientTools),
 			structuredOutput
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController);
+		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "stream", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2227,11 +2344,8 @@ var Agent = class extends BaseResource {
 			clientTools: processClientTools(params.clientToolsResolver?.() ?? params.clientTools),
 			structuredOutput
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController, "stream-until-idle");
+		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "stream-until-idle", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2271,11 +2385,8 @@ var Agent = class extends BaseResource {
 			...rest,
 			requestContext: parseClientRequestContext(requestContext)
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController, "approve-tool-call");
+		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "approve-tool-call", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2305,11 +2416,8 @@ var Agent = class extends BaseResource {
 			...rest,
 			requestContext: parseClientRequestContext(requestContext)
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController, "decline-tool-call");
+		const { readable, controller: readableController, signal } = this.createCancellableStream(params.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "decline-tool-call", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2379,11 +2487,8 @@ var Agent = class extends BaseResource {
 				schema: standardSchemaToJSONSchema(toStandardSchema(options.structuredOutput.schema))
 			} : void 0
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream");
+		const { readable, controller: readableController, signal } = this.createCancellableStream(options.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2442,11 +2547,8 @@ var Agent = class extends BaseResource {
 				schema: standardSchemaToJSONSchema(toStandardSchema(options.structuredOutput.schema))
 			} : void 0
 		};
-		let readableController;
-		const readable = new ReadableStream({ start(controller) {
-			readableController = controller;
-		} });
-		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream-until-idle");
+		const { readable, controller: readableController, signal } = this.createCancellableStream(options.abortSignal);
+		const response = await this.processStreamResponse(processedParams, readableController, "resume-stream-until-idle", signal);
 		const streamResponse = new Response(readable, {
 			status: response.status,
 			statusText: response.statusText,
@@ -2491,32 +2593,41 @@ var Agent = class extends BaseResource {
 	/**
 	* Processes the stream response and handles tool calls
 	*/
-	async processStreamResponseLegacy(processedParams, writable) {
+	async processStreamResponseLegacy(processedParams, writable, signal) {
 		const { memory } = processedParams ?? {};
 		const { resource, thread } = memory ?? {};
 		const threadId = processedParams.threadId ?? (typeof thread === "string" ? thread : thread?.id);
 		const resourceId = processedParams.resourceId ?? resource;
+		const { abortSignal: _abortSignal, ...bodyParams } = processedParams ?? {};
+		const isAborted = () => signal?.aborted === true;
+		const isAbortError = (error) => isAborted() || error?.name === "AbortError";
 		const response = await this.request(this.routeOverrides?.stream ?? `/agents/${this.agentId}/stream-legacy`, {
 			method: "POST",
-			body: processedParams,
-			stream: true
+			body: bodyParams,
+			stream: true,
+			signal
 		});
 		if (!response.body) throw new Error("No response body");
 		try {
 			let toolCalls = [];
 			let messages = [];
 			const [streamForWritable, streamForProcessing] = response.body.tee();
-			streamForWritable.pipeTo(writable, { preventClose: true }).catch((error) => {
-				console.error("Error piping to writable stream:", error);
+			streamForWritable.pipeTo(writable, {
+				preventClose: true,
+				signal
+			}).catch((error) => {
+				if (!isAbortError(error)) console.error("Error piping to writable stream:", error);
 			});
+			const processingStream = signal ? streamForProcessing.pipeThrough(new TransformStream(), { signal }) : streamForProcessing;
 			this.processChatResponse({
-				stream: streamForProcessing,
+				stream: processingStream,
 				update: ({ message }) => {
 					const existingIndex = messages.findIndex((m) => m.id === message.id);
 					if (existingIndex !== -1) messages[existingIndex] = message;
 					else messages.push(message);
 				},
 				onFinish: async ({ finishReason, message }) => {
+					if (isAborted()) return;
 					if (finishReason === "tool-calls") {
 						const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
 						if (toolCall) {
@@ -2548,6 +2659,7 @@ var Agent = class extends BaseResource {
 										}
 									}
 								});
+								if (isAborted()) return;
 								const writer = writable.getWriter();
 								try {
 									await writer.write(new TextEncoder().encode("a:" + JSON.stringify({
@@ -2577,21 +2689,21 @@ var Agent = class extends BaseResource {
 									...processedParams,
 									clientTools: processClientTools(processedParams.clientToolsResolver?.() ?? processedParams.clientTools),
 									messages: updatedMessages
-								}, writable).catch((error) => {
-									console.error("Error processing stream response:", error);
+								}, writable, signal).catch((error) => {
+									if (!isAbortError(error)) console.error("Error processing stream response:", error);
 								});
 							}
 						}
 					} else setTimeout(() => {
-						writable.close();
+						writable.close().catch(() => {});
 					}, 0);
 				},
 				lastMessage: void 0
 			}).catch((error) => {
-				console.error("Error processing stream response:", error);
+				if (!isAbortError(error)) console.error("Error processing stream response:", error);
 			});
 		} catch (error) {
-			console.error("Error processing stream response:", error);
+			if (!isAbortError(error)) console.error("Error processing stream response:", error);
 		}
 		return response;
 	}
@@ -2667,6 +2779,22 @@ var Agent = class extends BaseResource {
 //#endregion
 //#region src/resources/memory-thread.ts
 /**
+* Serializes the message-listing filters both memory message routes accept. The network route
+* takes the same filters under a different path, so the two callers share one serializer.
+*/
+const memoryMessagesQuery = ({ agentId, resourceId, page, perPage, orderBy, filter, include, includeSystemReminders }) => {
+	const query = new URLSearchParams();
+	if (agentId) query.set("agentId", agentId);
+	if (resourceId) query.set("resourceId", resourceId);
+	if (page !== void 0) query.set("page", String(page));
+	if (perPage !== void 0) query.set("perPage", String(perPage));
+	if (orderBy) query.set("orderBy", JSON.stringify(orderBy));
+	if (filter) query.set("filter", JSON.stringify(filter));
+	if (include) query.set("include", JSON.stringify(include));
+	if (includeSystemReminders !== void 0) query.set("includeSystemReminders", String(includeSystemReminders));
+	return query;
+};
+/**
 * MemoryThread resource for interacting with memory threads.
 *
 * `agentId` is optional for read operations (`get`, `listMessages`) — when omitted the server
@@ -2742,18 +2870,11 @@ var MemoryThread = class extends BaseResource {
 	* @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
 	*/
 	listMessages(params = {}) {
-		const { page, perPage, orderBy, filter, include, resourceId, requestContext, includeSystemReminders } = params;
-		const queryParams = {};
-		if (this.agentId) queryParams.agentId = this.agentId;
-		if (resourceId) queryParams.resourceId = resourceId;
-		if (page !== void 0) queryParams.page = String(page);
-		if (perPage !== void 0) queryParams.perPage = String(perPage);
-		if (orderBy) queryParams.orderBy = JSON.stringify(orderBy);
-		if (filter) queryParams.filter = JSON.stringify(filter);
-		if (include) queryParams.include = JSON.stringify(include);
-		if (includeSystemReminders !== void 0) queryParams.includeSystemReminders = String(includeSystemReminders);
-		const queryString = new URLSearchParams(queryParams).toString();
-		const url = `/memory/threads/${this.threadId}/messages${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`;
+		const query = memoryMessagesQuery({
+			...params,
+			agentId: params.agentId ?? this.agentId
+		}).toString();
+		const url = `/memory/threads/${this.threadId}/messages${query ? `?${query}` : ""}${requestContextQueryString(params.requestContext, query ? "&" : "?")}`;
 		return this.request(url);
 	}
 	/**
@@ -3211,7 +3332,7 @@ var Run = class extends BaseResource {
 				resourceId: params.resourceId,
 				perStep: params.perStep
 			}
-		}).then(deserializeWorkflowError);
+		}).then((result) => deserializeWorkflowError(result));
 	}
 	/**
 	* Starts a workflow run and returns a stream
@@ -3293,7 +3414,7 @@ var Run = class extends BaseResource {
 				perStep: params.perStep,
 				forEachIndex: params.forEachIndex
 			}
-		}).then(deserializeWorkflowError);
+		}).then((result) => deserializeWorkflowError(result));
 	}
 	/**
 	* Resumes a suspended workflow step without waiting for the workflow to complete (fire-and-forget)
@@ -3377,7 +3498,7 @@ var Run = class extends BaseResource {
 				requestContext,
 				tracingOptions: params?.tracingOptions
 			}
-		}).then(deserializeWorkflowError);
+		}).then((result) => deserializeWorkflowError(result));
 	}
 	/**
 	* Time travels a workflow run synchronously without waiting for the workflow to complete
@@ -3407,7 +3528,7 @@ var Run = class extends BaseResource {
 				...params,
 				requestContext
 			}
-		}).then(deserializeWorkflowError);
+		}).then((result) => deserializeWorkflowError(result));
 	}
 	/**
 	* Time travels a workflow run and returns a stream
@@ -3919,12 +4040,27 @@ var A2AV1 = class extends BaseResource {
 			}
 		}));
 	}
+	async createTaskPushNotificationConfig(params) {
+		const result = await this.rpc("CreateTaskPushNotificationConfig", TaskPushNotificationConfig.toJSON(params));
+		return TaskPushNotificationConfig.fromJSON(result);
+	}
+	async getTaskPushNotificationConfig(params) {
+		const result = await this.rpc("GetTaskPushNotificationConfig", GetTaskPushNotificationConfigRequest.toJSON(params));
+		return TaskPushNotificationConfig.fromJSON(result);
+	}
+	async listTaskPushNotificationConfigs(params) {
+		const result = await this.rpc("ListTaskPushNotificationConfigs", ListTaskPushNotificationConfigsRequest.toJSON(params));
+		return ListTaskPushNotificationConfigsResponse.fromJSON(result);
+	}
+	async deleteTaskPushNotificationConfig(params) {
+		await this.rpc("DeleteTaskPushNotificationConfig", DeleteTaskPushNotificationConfigRequest.toJSON(params));
+	}
 	async getAgentCard() {
 		const card = await this.request(`/.well-known/${this.agentId}/agent-card.json`, { headers: { "A2A-Version": "1.0" } });
 		return AgentCard.fromJSON(card);
 	}
 	async sendMessage(params) {
-		const result = await this.rpc("message/send", SendMessageRequest.toJSON(params));
+		const result = await this.rpc("SendMessage", SendMessageRequest.toJSON(params));
 		return SendMessageResponse.fromJSON(result);
 	}
 	async *sendMessageStream(params) {
@@ -3934,7 +4070,7 @@ var A2AV1 = class extends BaseResource {
 			body: {
 				jsonrpc: "2.0",
 				id: crypto.randomUUID(),
-				method: "message/stream",
+				method: "SendStreamingMessage",
 				params: SendMessageRequest.toJSON(params)
 			},
 			stream: true
@@ -3942,15 +4078,15 @@ var A2AV1 = class extends BaseResource {
 		for await (const event of processA2AStream(await requireResponseBody(response, "message/stream"))) yield StreamResponse.fromJSON(event);
 	}
 	async getTask(params) {
-		const result = await this.rpc("tasks/get", GetTaskRequest.toJSON(params));
+		const result = await this.rpc("GetTask", GetTaskRequest.toJSON(params));
 		return Task.fromJSON(result);
 	}
 	async listTasks(params) {
-		const result = await this.rpc("tasks/list", ListTasksRequest.toJSON(params));
+		const result = await this.rpc("ListTasks", ListTasksRequest.toJSON(params));
 		return ListTasksResponse.fromJSON(result);
 	}
 	async cancelTask(params) {
-		const result = await this.rpc("tasks/cancel", CancelTaskRequest.toJSON(params));
+		const result = await this.rpc("CancelTask", CancelTaskRequest.toJSON(params));
 		return Task.fromJSON(result);
 	}
 	async *resubscribeTask(params) {
@@ -3960,7 +4096,7 @@ var A2AV1 = class extends BaseResource {
 			body: {
 				jsonrpc: "2.0",
 				id: crypto.randomUUID(),
-				method: "tasks/resubscribe",
+				method: "SubscribeToTask",
 				params: SubscribeToTaskRequest.toJSON(params)
 			},
 			stream: true
@@ -3993,13 +4129,14 @@ var MCPTool = class extends BaseResource {
 	/**
 	* Executes this specific tool on the MCP server.
 	* @param params - Parameters for tool execution, including data/args and optional requestContext.
-	* @returns Promise containing the result of the tool execution.
+	* On a 2026-07-28 server a tool can answer `{ status: 'suspended', suspendPayload, resumeSchema }`;
+	* call again with the same `data` plus `resumeData` (matching `resumeSchema`) and the echoed
+	* `suspendPayload` to continue it.
+	* @returns Promise containing `{ result }`, or the suspended shape described above.
 	*/
 	execute(params) {
-		const body = {};
-		if (params.data !== void 0) body.data = params.data;
-		if (params.requestContext !== void 0) body.requestContext = params.requestContext;
-		return this.request(`/mcp/${encodeURIComponent(this.serverId)}/tools/${encodeURIComponent(this.toolId)}/execute`, {
+		const { requestContext, ...body } = params;
+		return this.request(`/mcp/${encodeURIComponent(this.serverId)}/tools/${encodeURIComponent(this.toolId)}/execute${requestContextQueryString(requestContext)}`, {
 			method: "POST",
 			body
 		});
@@ -4017,23 +4154,29 @@ var AgentBuilder = class extends BaseResource {
 		this.actionId = actionId;
 	}
 	transformWorkflowResult(result) {
-		if (result.status === "success") return {
-			success: result.result.success || false,
-			applied: result.result.applied || false,
-			branchName: result.result.branchName,
-			message: result.result.message || "Agent builder action completed",
-			validationResults: result.result.validationResults,
-			error: result.result.error,
-			errors: result.result.errors,
-			stepResults: result.result.stepResults
-		};
-		else if (result.status === "failed") return {
-			success: false,
-			applied: false,
-			message: `Agent builder action failed: ${result.error.message}`,
-			error: result.error.message
-		};
-		else return {
+		if (result.status === "success") {
+			const actionResult = result.result;
+			return {
+				success: actionResult?.success ?? false,
+				applied: actionResult?.applied ?? false,
+				branchName: actionResult?.branchName,
+				message: actionResult?.message ?? "Agent builder action completed",
+				validationResults: actionResult?.validationResults,
+				error: actionResult?.error,
+				errors: actionResult?.errors,
+				stepResults: actionResult?.stepResults
+			};
+		}
+		if (result.status === "failed") {
+			const message = result.error?.message ?? "Agent builder action failed";
+			return {
+				success: false,
+				applied: false,
+				message: `Agent builder action failed: ${message}`,
+				error: message
+			};
+		}
+		return {
 			success: false,
 			applied: false,
 			message: "Agent builder action was suspended",
@@ -4229,7 +4372,7 @@ var AgentBuilder = class extends BaseResource {
 	* This calls `/agent-builder/:actionId`.
 	*/
 	async details() {
-		return await this.request(`/agent-builder/${this.actionId}`);
+		return this.request(`/agent-builder/${this.actionId}`);
 	}
 	/**
 	* Gets all runs for this agent builder action.
@@ -4362,6 +4505,24 @@ var Observability = class extends BaseResource {
 			body: params
 		});
 	}
+	/** Returns canonical and observed fields available to the advanced trace-query grammar. */
+	getTraceQueryFields(params, options) {
+		return this.request("/observability/traces/query/fields", {
+			method: "POST",
+			body: params,
+			retries: 0,
+			signal: options?.signal
+		});
+	}
+	/** Returns bounded string suggestions for one eligible trace-query field. */
+	getTraceQueryValues(params, options) {
+		return this.request("/observability/traces/query/values", {
+			method: "POST",
+			body: params,
+			retries: 0,
+			signal: options?.signal
+		});
+	}
 	/**
 	* Queries thread identities using eligible-trace and cross-trace predicates.
 	*
@@ -4458,7 +4619,7 @@ var Observability = class extends BaseResource {
 	deleteTraces(params) {
 		return this.request(`/observability/traces/delete`, {
 			method: "POST",
-			body: { traceIds: params.traceIds }
+			body: params
 		});
 	}
 	/**
@@ -6510,12 +6671,15 @@ var MastraClient = class extends BaseResource {
 	* @returns Promise containing the thread messages
 	*/
 	listThreadMessages(threadId, opts = {}) {
-		let url = "";
-		const includeSystemRemindersQuery = opts.includeSystemReminders === void 0 ? "" : `includeSystemReminders=${opts.includeSystemReminders}`;
-		if (opts.networkId) url = `/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}${includeSystemRemindersQuery ? `&${includeSystemRemindersQuery}` : ""}${requestContextQueryString(opts.requestContext, includeSystemRemindersQuery ? "&" : "&")}`;
-		else if (opts.agentId) url = `/memory/threads/${threadId}/messages?agentId=${opts.agentId}${includeSystemRemindersQuery ? `&${includeSystemRemindersQuery}` : ""}${requestContextQueryString(opts.requestContext, "&")}`;
-		else url = `/memory/threads/${threadId}/messages${includeSystemRemindersQuery ? `?${includeSystemRemindersQuery}` : ""}${requestContextQueryString(opts.requestContext, includeSystemRemindersQuery ? "&" : "?")}`;
-		return this.request(url);
+		if (opts.networkId) {
+			const query = memoryMessagesQuery(opts);
+			query.set("networkId", opts.networkId);
+			return this.request(`/memory/network/threads/${threadId}/messages?${query.toString()}${requestContextQueryString(opts.requestContext, "&")}`);
+		}
+		return this.getMemoryThread({
+			threadId,
+			agentId: opts.agentId
+		}).listMessages(opts);
 	}
 	deleteThread(threadId, opts) {
 		if (!opts || !!opts.agentId === !!opts.networkId) throw new Error("MastraClient.deleteThread() requires exactly one of agentId or networkId. The server cannot resolve which memory store owns the thread without one, and passing both is ambiguous.");
@@ -6940,6 +7104,14 @@ var MastraClient = class extends BaseResource {
 	queryTraces(params) {
 		return this.observability.queryTraces(params);
 	}
+	/** Returns canonical and observed fields available to the advanced trace-query grammar. */
+	getTraceQueryFields(params, options) {
+		return this.observability.getTraceQueryFields(params, options);
+	}
+	/** Returns bounded string suggestions for one eligible trace-query field. */
+	getTraceQueryValues(params, options) {
+		return this.observability.getTraceQueryValues(params, options);
+	}
 	/** Queries thread identities using eligible-trace and cross-trace predicates. */
 	queryTraceThreads(params) {
 		return this.observability.queryTraceThreads(params);