@mastra/client-js 1.47.0-alpha.3 → 1.47.0-alpha.5

package/dist/index.cjs

@@ -365,6 +365,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
 /**
@@ -559,43 +586,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");
 	}
@@ -1325,8 +1370,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(params.output) : void 0,
 			experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
 			requestContext: parseClientRequestContext(params.requestContext),
@@ -1335,9 +1382,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) {
@@ -1386,8 +1435,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 ? {
@@ -1401,20 +1452,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 }) {
@@ -1650,7 +1705,7 @@ var Agent = class extends BaseResource {
 				throw new Error(error);
 			}
 		});
-		onFinish?.({
+		await onFinish?.({
 			message,
 			finishReason,
 			usage
@@ -1669,8 +1724,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,
@@ -1911,29 +1980,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;
@@ -1945,7 +2048,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) {
@@ -1953,26 +2056,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 ?? []) {
@@ -1999,6 +2108,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;
@@ -2066,6 +2176,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 ? {
@@ -2081,7 +2192,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);
 							}
@@ -2095,22 +2206,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) => {
@@ -2118,14 +2230,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;
 	}
@@ -2222,11 +2336,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,
@@ -2256,11 +2367,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,
@@ -2300,11 +2408,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,
@@ -2334,11 +2439,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,
@@ -2408,11 +2510,8 @@ var Agent = class extends BaseResource {
 				schema: (0, _mastra_schema_compat_schema.standardSchemaToJSONSchema)((0, _mastra_schema_compat_schema.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,
@@ -2471,11 +2570,8 @@ var Agent = class extends BaseResource {
 				schema: (0, _mastra_schema_compat_schema.standardSchemaToJSONSchema)((0, _mastra_schema_compat_schema.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,
@@ -2520,32 +2616,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) {
@@ -2577,6 +2682,7 @@ var Agent = class extends BaseResource {
 										}
 									}
 								});
+								if (isAborted()) return;
 								const writer = writable.getWriter();
 								try {
 									await writer.write(new TextEncoder().encode("a:" + JSON.stringify({
@@ -2606,21 +2712,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;
 	}
@@ -3948,12 +4054,27 @@ var A2AV1 = class extends BaseResource {
 			}
 		}));
 	}
+	async createTaskPushNotificationConfig(params) {
+		const result = await this.rpc("CreateTaskPushNotificationConfig", _mastra_core_a2a_v1.TaskPushNotificationConfig.toJSON(params));
+		return _mastra_core_a2a_v1.TaskPushNotificationConfig.fromJSON(result);
+	}
+	async getTaskPushNotificationConfig(params) {
+		const result = await this.rpc("GetTaskPushNotificationConfig", _mastra_core_a2a_v1.GetTaskPushNotificationConfigRequest.toJSON(params));
+		return _mastra_core_a2a_v1.TaskPushNotificationConfig.fromJSON(result);
+	}
+	async listTaskPushNotificationConfigs(params) {
+		const result = await this.rpc("ListTaskPushNotificationConfigs", _mastra_core_a2a_v1.ListTaskPushNotificationConfigsRequest.toJSON(params));
+		return _mastra_core_a2a_v1.ListTaskPushNotificationConfigsResponse.fromJSON(result);
+	}
+	async deleteTaskPushNotificationConfig(params) {
+		await this.rpc("DeleteTaskPushNotificationConfig", _mastra_core_a2a_v1.DeleteTaskPushNotificationConfigRequest.toJSON(params));
+	}
 	async getAgentCard() {
 		const card = await this.request(`/.well-known/${this.agentId}/agent-card.json`, { headers: { "A2A-Version": "1.0" } });
 		return _mastra_core_a2a_v1.AgentCard.fromJSON(card);
 	}
 	async sendMessage(params) {
-		const result = await this.rpc("message/send", _mastra_core_a2a_v1.SendMessageRequest.toJSON(params));
+		const result = await this.rpc("SendMessage", _mastra_core_a2a_v1.SendMessageRequest.toJSON(params));
 		return _mastra_core_a2a_v1.SendMessageResponse.fromJSON(result);
 	}
 	async *sendMessageStream(params) {
@@ -3963,7 +4084,7 @@ var A2AV1 = class extends BaseResource {
 			body: {
 				jsonrpc: "2.0",
 				id: crypto.randomUUID(),
-				method: "message/stream",
+				method: "SendStreamingMessage",
 				params: _mastra_core_a2a_v1.SendMessageRequest.toJSON(params)
 			},
 			stream: true
@@ -3971,15 +4092,15 @@ var A2AV1 = class extends BaseResource {
 		for await (const event of processA2AStream(await requireResponseBody(response, "message/stream"))) yield _mastra_core_a2a_v1.StreamResponse.fromJSON(event);
 	}
 	async getTask(params) {
-		const result = await this.rpc("tasks/get", _mastra_core_a2a_v1.GetTaskRequest.toJSON(params));
+		const result = await this.rpc("GetTask", _mastra_core_a2a_v1.GetTaskRequest.toJSON(params));
 		return _mastra_core_a2a_v1.Task.fromJSON(result);
 	}
 	async listTasks(params) {
-		const result = await this.rpc("tasks/list", _mastra_core_a2a_v1.ListTasksRequest.toJSON(params));
+		const result = await this.rpc("ListTasks", _mastra_core_a2a_v1.ListTasksRequest.toJSON(params));
 		return _mastra_core_a2a_v1.ListTasksResponse.fromJSON(result);
 	}
 	async cancelTask(params) {
-		const result = await this.rpc("tasks/cancel", _mastra_core_a2a_v1.CancelTaskRequest.toJSON(params));
+		const result = await this.rpc("CancelTask", _mastra_core_a2a_v1.CancelTaskRequest.toJSON(params));
 		return _mastra_core_a2a_v1.Task.fromJSON(result);
 	}
 	async *resubscribeTask(params) {
@@ -3989,7 +4110,7 @@ var A2AV1 = class extends BaseResource {
 			body: {
 				jsonrpc: "2.0",
 				id: crypto.randomUUID(),
-				method: "tasks/resubscribe",
+				method: "SubscribeToTask",
 				params: _mastra_core_a2a_v1.SubscribeToTaskRequest.toJSON(params)
 			},
 			stream: true
@@ -4398,6 +4519,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.
 	*
@@ -6976,6 +7115,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);