@mastra/mcp 2.0.0-alpha.4 → 2.0.0

package/dist/index.js

@@ -18,7 +18,7 @@ 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 { ProtocolError, ProtocolErrorCode as ProtocolErrorCode$1, Server, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse, specTypeSchemas } from "@modelcontextprotocol/server";
+import { CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, ProtocolError, ProtocolErrorCode as ProtocolErrorCode$1, Server, createMcpHandler, createRequestStateCodec, inputRequired, inputResponse, specTypeSchemas } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 //#region \0rolldown/runtime.js
 var __defProp$3 = Object.defineProperty;
@@ -23251,21 +23251,23 @@ var InternalMastraMCPClient = class extends MastraBase {
 	}
 	async connectStdio(command) {
 		this.log("debug", `Using Stdio transport for command: ${command}`);
+		const transport = new StdioClientTransport({
+			command,
+			args: this.serverConfig.args,
+			env: this.buildStdioEnv(),
+			stderr: this.serverConfig.stderr,
+			cwd: this.serverConfig.cwd
+		});
 		try {
-			this.transport = new StdioClientTransport({
-				command,
-				args: this.serverConfig.args,
-				env: this.buildStdioEnv(),
-				stderr: this.serverConfig.stderr,
-				cwd: this.serverConfig.cwd
-			});
-			await this.client.connect(this.transport, {
+			await this.client.connect(transport, {
 				timeout: this.serverConfig.timeout ?? this.timeout,
 				prior: this.priorDiscovery
 			});
+			this.transport = transport;
 			this.log("debug", `Successfully connected to MCP server via Stdio`);
 		} catch (e) {
 			this.log("error", e instanceof Error ? e.stack || e.message : JSON.stringify(e));
+			await transport.close().catch(() => {});
 			throw e;
 		}
 	}
@@ -23448,11 +23450,20 @@ var InternalMastraMCPClient = class extends MastraBase {
 				this.clientConnectionOnClose = connectionOnClose;
 				this.client.onclose = connectionOnClose;
 			} catch (e) {
+				if (!this.transport) this.unregisterProcessHooks();
 				this.isConnected = null;
 				this.priorDiscovery = void 0;
 				reject(e);
 			}
 		});
+		this.registerProcessHooks();
+		return this.isConnected;
+	}
+	/**
+	* Installs the process-exit and signal handlers that tear this client down when the
+	* host process goes away. Idempotent, so repeated connects add at most one of each.
+	*/
+	registerProcessHooks() {
 		if (!this.exitHookUnsubscribe) this.exitHookUnsubscribe = asyncExitHook(async () => {
 			this.log("debug", `Disconnecting MCP server during exit`);
 			await this.disconnect();
@@ -23465,7 +23476,25 @@ var InternalMastraMCPClient = class extends MastraBase {
 			this.sigHupHandler = () => gracefulExit();
 			process.on("SIGHUP", this.sigHupHandler);
 		}
-		return this.isConnected;
+	}
+	/**
+	* Removes whatever {@link registerProcessHooks} installed. Keyed on the handlers this
+	* client actually registered rather than on connection state, so a client that never
+	* reached a transport still releases its process listeners.
+	*/
+	unregisterProcessHooks() {
+		if (this.exitHookUnsubscribe) {
+			this.exitHookUnsubscribe();
+			this.exitHookUnsubscribe = void 0;
+		}
+		if (this.sigTermHandler) {
+			process.off("SIGTERM", this.sigTermHandler);
+			this.sigTermHandler = void 0;
+		}
+		if (this.sigHupHandler) {
+			process.off("SIGHUP", this.sigHupHandler);
+			this.sigHupHandler = void 0;
+		}
 	}
 	/**
 	* Gets the stderr stream of the child process, if using stdio transport with `stderr: 'pipe'`.
@@ -23510,6 +23539,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 		this.closePendingAuthTransport();
 		if (!this.transport) {
 			await this.detachStaleClientTransport();
+			this.unregisterProcessHooks();
 			this.log("debug", "Disconnect called but no transport was connected.");
 			return;
 		}
@@ -23527,18 +23557,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 			this.transport = void 0;
 			this.isConnected = null;
 			this.serverInstructions = void 0;
-			if (this.exitHookUnsubscribe) {
-				this.exitHookUnsubscribe();
-				this.exitHookUnsubscribe = void 0;
-			}
-			if (this.sigTermHandler) {
-				process.off("SIGTERM", this.sigTermHandler);
-				this.sigTermHandler = void 0;
-			}
-			if (this.sigHupHandler) {
-				process.off("SIGHUP", this.sigHupHandler);
-				this.sigHupHandler = void 0;
-			}
+			this.unregisterProcessHooks();
 		}
 	}
 	/**
@@ -26396,6 +26415,95 @@ var MCPServer = class extends MCPServerBase {
 		this.registerPromptHandlers(server);
 		return server;
 	}
+	/**
+	* Registers `method` under an `MCP_SERVER_REQUEST` span, so every request the
+	* server answers is recorded — including the list and read methods that never
+	* reach a tool, and requests that fail before any work is done.
+	*/
+	setTracedHandler(server, method, handler) {
+		server.setRequestHandler(method, async (request, ctx) => {
+			const params = request.params;
+			let requestContext;
+			try {
+				requestContext = await toRequestContext(ctx, this.mapAuthInfoToUser);
+			} catch (error) {
+				this.startRequestSpan(method, params, {
+					server,
+					ctx
+				})?.error({ error });
+				throw error;
+			}
+			const requestSpan = this.startRequestSpan(method, params, {
+				server,
+				ctx,
+				requestContext
+			});
+			let reportedError;
+			return this.traceRequest(requestSpan, () => handler(request, ctx, {
+				requestSpan,
+				requestContext,
+				reportError: (error) => {
+					reportedError = error;
+				}
+			}), () => reportedError);
+		});
+	}
+	/**
+	* Opens the span for one served request. `connection` is absent for
+	* {@link executeTool}, which is called in-process and negotiates nothing.
+	*/
+	startRequestSpan(method, params, connection) {
+		const envelope = connection?.ctx?.mcpReq.envelope;
+		const protocolVersion = envelope?.[PROTOCOL_VERSION_META_KEY] ?? connection?.server?.getNegotiatedProtocolVersion();
+		const client = envelope?.[CLIENT_INFO_META_KEY] ?? connection?.server?.getClientVersion();
+		const target = params?.name ?? params?.uri;
+		const targetName = typeof target === "string" ? target : void 0;
+		return getOrCreateSpan({
+			type: SpanType.MCP_SERVER_REQUEST,
+			name: targetName ? `${method} ${targetName}` : method,
+			entityType: EntityType.MCP_SERVER,
+			entityId: this.id,
+			entityName: this.name,
+			input: params,
+			attributes: {
+				mcpMethod: method,
+				targetName,
+				mcpServer: this.name,
+				serverVersion: this.version,
+				mcpProtocolVersion: typeof protocolVersion === "string" ? protocolVersion : void 0,
+				clientName: client?.name,
+				clientVersion: client?.version
+			},
+			tracingContext: {},
+			requestContext: connection?.requestContext,
+			mastra: this.mastra
+		});
+	}
+	/**
+	* Runs `fn` under a request span. Only the protocol's own `isError` marks a
+	* failure; the rest of a result is opaque handler output that may legitimately
+	* carry any field. A thrown error ends the whole span tree and is rethrown.
+	*/
+	async traceRequest(requestSpan, fn, getReportedError) {
+		try {
+			const result = await fn();
+			const errorResult = result;
+			if (errorResult?.isError) requestSpan?.error({ error: getReportedError?.() ?? new MastraError({
+				id: "MCP_SERVER_REQUEST_FAILED",
+				domain: ErrorDomain.MCP,
+				category: ErrorCategory.USER,
+				text: errorResult.content?.map((c) => c.text).filter(Boolean).join("\n")
+			}) });
+			else requestSpan?.end({ output: result });
+			return result;
+		} catch (error) {
+			requestSpan?.error({
+				error,
+				endTree: true
+			});
+			throw error;
+		}
+	}
 	/** Answers a suspended round: one keyed form derived from the handler's `resumeSchema`. */
 	async inputRequired(ctx, requestContext, suspension) {
 		const payload = suspension.suspendPayload;
@@ -26420,9 +26528,8 @@ var MCPServer = class extends MCPServerBase {
 			})
 		});
 	}
-	async serverRequest(ctx, method, name, args, resumeSchema) {
+	async serverRequest(ctx, requestContext, method, name, args, resumeSchema) {
 		const argsHash = hashArguments(args);
-		const requestContext = await toRequestContext(ctx, this.mapAuthInfoToUser);
 		const continuation = readContinuation(ctx, requestContext, {
 			method,
 			name,
@@ -26448,11 +26555,10 @@ var MCPServer = class extends MCPServerBase {
 		};
 	}
 	registerToolHandlers(server) {
-		server.setRequestHandler("tools/list", async (_request, ctx) => {
-			const requestContext = await toRequestContext(ctx, this.mapAuthInfoToUser);
-			return { tools: (await this.authorizedToolEntries(requestContext)).map(([name, tool]) => this.toMCPTool(name, tool)) };
+		this.setTracedHandler(server, "tools/list", async (_request, _ctx, trace) => {
+			return { tools: (await this.authorizedToolEntries(trace.requestContext)).map(([name, tool]) => this.toMCPTool(name, tool)) };
 		});
-		server.setRequestHandler("tools/call", async (request, ctx) => {
+		this.setTracedHandler(server, "tools/call", async (request, ctx, trace) => {
 			const name = request.params.name;
 			const tool = this.convertedTools[name];
 			if (!tool) {
@@ -26461,43 +26567,25 @@ var MCPServer = class extends MCPServerBase {
 			}
 			const args = request.params.arguments ?? {};
 			const argsHash = hashArguments(args);
-			const requestContext = await toRequestContext(ctx, this.mapAuthInfoToUser);
+			const requestContext = trace.requestContext;
 			const continuation = readContinuation(ctx, requestContext, {
 				method: "tools/call",
 				name,
 				argsHash
 			});
 			const mcp = toToolExecutionContext(ctx, this.name);
-			const span = getOrCreateSpan({
-				type: SpanType.TOOL_CALL,
-				name: `tool: '${name}'`,
-				input: args,
-				entityType: EntityType.TOOL,
-				entityId: name,
-				entityName: name,
-				attributes: {
-					toolType: "tool",
-					toolDescription: tool.description
-				},
-				requestContext,
-				mastra: this.mastra
-			});
 			const startedAt = Date.now();
 			try {
 				await this.enforceToolExecutionFGA(name, requestContext);
-				if (continuation && continuation.outcome !== "accept") {
-					span?.end({ attributes: { success: false } });
-					return errorResult(`Tool '${name}' was ${continuation.outcome === "decline" ? "declined" : "cancelled"}`);
-				}
+				if (continuation && continuation.outcome !== "accept") return errorResult(`Tool '${name}' was ${continuation.outcome === "decline" ? "declined" : "cancelled"}`);
 				const execution = await this.runTool(name, tool, args, {
 					requestContext,
 					mcp,
-					tracingContext: { currentSpan: span },
+					tracingContext: { currentSpan: trace.requestSpan },
 					resumeData: continuation?.resumeData,
 					suspendPayload: continuation?.suspendPayload
 				});
 				if (execution.status === "suspended") {
-					span?.end({ attributes: { success: true } });
 					this.logger.debug(`Tool '${name}' requires client input.`);
 					return this.inputRequired(ctx, requestContext, {
 						method: "tools/call",
@@ -26509,17 +26597,9 @@ var MCPServer = class extends MCPServerBase {
 					});
 				}
 				const result = this.toCallToolResult(name, tool, execution.output);
-				span?.end({
-					output: execution.output,
-					attributes: { success: !result.isError }
-				});
 				this.logger.info(`Tool '${name}' finished in ${Date.now() - startedAt}ms.`);
 				return result;
 			} catch (error) {
-				span?.error({
-					error,
-					attributes: { success: false }
-				});
 				if (error instanceof ProtocolError) throw error;
 				this.logger.error("Tool execution failed", {
 					tool: name,
@@ -26531,6 +26611,7 @@ var MCPServer = class extends MCPServerBase {
 					category: ErrorCategory.USER,
 					details: { toolName: name }
 				}, error);
+				trace.reportError(mastraError);
 				return errorResult(JSON.stringify(mastraError.toJSON()));
 			}
 		});
@@ -26546,6 +26627,7 @@ var MCPServer = class extends MCPServerBase {
 		const output = await tool.execute(args, {
 			toolCallId: "",
 			messages: [],
+			skipToolSpan: true,
 			requestContext: options.requestContext,
 			tracingContext: options.tracingContext,
 			abortSignal: options.mcp?.extra.signal,
@@ -26599,19 +26681,19 @@ var MCPServer = class extends MCPServerBase {
 		const options = this.resourceOptions;
 		const hasAppResources = this.appResourceList.length > 0;
 		if (!options && !hasAppResources) return;
-		const listResources = async (ctx) => [...this.appResourceList, ...await options?.listResources({
+		const listResources = async (ctx, requestContext) => [...this.appResourceList, ...await options?.listResources({
 			extra: toToolExecutionContext(ctx, this.name).extra,
-			requestContext: await toRequestContext(ctx, this.mapAuthInfoToUser)
+			requestContext
 		}) ?? []];
-		server.setRequestHandler("resources/list", async (_request, ctx) => ({ resources: await listResources(ctx) }));
-		server.setRequestHandler("resources/read", async (request, ctx) => {
+		this.setTracedHandler(server, "resources/list", async (_request, ctx, trace) => ({ resources: await listResources(ctx, trace.requestContext) }));
+		this.setTracedHandler(server, "resources/read", async (request, ctx, trace) => {
 			const uri = request.params.uri;
-			const resource = (await listResources(ctx)).find((r) => r.uri === uri);
+			const resource = (await listResources(ctx, trace.requestContext)).find((r) => r.uri === uri);
 			if (!resource) throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Resource not found: ${uri}`);
 			const html = this.appResourceHtml.get(uri);
 			if (html !== void 0) return { contents: [this.resourceContents(resource, { text: html })] };
 			if (!options) throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Resource not found: ${uri}`);
-			const { request: serverRequest, continuation, suspended, argsHash } = await this.serverRequest(ctx, "resources/read", uri, {}, options.resumeSchema);
+			const { request: serverRequest, continuation, suspended, argsHash } = await this.serverRequest(ctx, trace.requestContext, "resources/read", uri, {}, options.resumeSchema);
 			if (continuation && continuation.outcome !== "accept") throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Reading '${uri}' was ${continuation.outcome}ed`);
 			const result = await options.getResourceContent({
 				uri,
@@ -26629,9 +26711,9 @@ var MCPServer = class extends MCPServerBase {
 			if (result === void 0) throw new Error(`Resource '${uri}' returned no content`);
 			return { contents: (Array.isArray(result) ? result : [result]).map((content) => this.resourceContents(resource, content)) };
 		});
-		if (options?.resourceTemplates) server.setRequestHandler("resources/templates/list", async (_request, ctx) => ({ resourceTemplates: await options.resourceTemplates({
+		if (options?.resourceTemplates) this.setTracedHandler(server, "resources/templates/list", async (_request, ctx, trace) => ({ resourceTemplates: await options.resourceTemplates({
 			extra: toToolExecutionContext(ctx, this.name).extra,
-			requestContext: await toRequestContext(ctx, this.mapAuthInfoToUser)
+			requestContext: trace.requestContext
 		}) }));
 	}
 	resourceContents(resource, content) {
@@ -26653,22 +26735,22 @@ var MCPServer = class extends MCPServerBase {
 	registerPromptHandlers(server) {
 		const options = this.promptOptions;
 		if (!options) return;
-		const listPrompts = async (ctx) => {
+		const listPrompts = async (ctx, requestContext) => {
 			const prompts = await options.listPrompts({
 				extra: toToolExecutionContext(ctx, this.name).extra,
-				requestContext: await toRequestContext(ctx, this.mapAuthInfoToUser)
+				requestContext
 			});
 			for (const prompt of prompts) PromptSchema.parse(prompt);
 			return prompts;
 		};
-		server.setRequestHandler("prompts/list", async (_request, ctx) => ({ prompts: await listPrompts(ctx) }));
+		this.setTracedHandler(server, "prompts/list", async (_request, ctx, trace) => ({ prompts: await listPrompts(ctx, trace.requestContext) }));
 		if (!options.getPromptMessages) return;
-		server.setRequestHandler("prompts/get", async (request, ctx) => {
+		this.setTracedHandler(server, "prompts/get", async (request, ctx, trace) => {
 			const { name, arguments: args } = request.params;
-			const prompt = (await listPrompts(ctx)).find((p) => p.name === name);
+			const prompt = (await listPrompts(ctx, trace.requestContext)).find((p) => p.name === name);
 			if (!prompt) throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Prompt "${name}" not found`);
 			for (const arg of prompt.arguments ?? []) if (arg.required && (args?.[arg.name] === void 0 || args?.[arg.name] === null)) throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Missing required argument: ${arg.name}`);
-			const { request: serverRequest, continuation, suspended, argsHash } = await this.serverRequest(ctx, "prompts/get", name, args ?? {}, options.resumeSchema);
+			const { request: serverRequest, continuation, suspended, argsHash } = await this.serverRequest(ctx, trace.requestContext, "prompts/get", name, args ?? {}, options.resumeSchema);
 			if (continuation && continuation.outcome !== "accept") throw new ProtocolError(ProtocolErrorCode$1.InvalidParams, `Prompt "${name}" was ${continuation.outcome}ed`);
 			const messages = await options.getPromptMessages({
 				name,
@@ -26881,52 +26963,58 @@ var MCPServer = class extends MCPServerBase {
 	* arguments with `resumeData` and `suspendPayload`.
 	*/
 	async executeTool(toolId, args, executionContext = {}) {
-		const tool = this.convertedTools[toolId];
-		if (!tool) {
-			this.logger.warn("Unknown tool requested", {
-				tool: toolId,
-				server: this.name
-			});
-			throw new MastraError({
-				id: "MCP_SERVER_TOOL_EXECUTE_PREPARATION_FAILED",
-				domain: ErrorDomain.MCP,
-				category: ErrorCategory.USER,
-				text: `Unknown tool: ${toolId}`,
-				details: { toolId }
-			});
-		}
 		const requestContext = executionContext.requestContext ?? new RequestContext();
-		await this.enforceToolExecutionFGA(toolId, requestContext);
-		try {
-			const execution = await this.runTool(toolId, tool, args, {
-				requestContext,
-				tracingContext: { currentSpan: void 0 },
-				resumeData: executionContext.resumeData,
-				suspendPayload: executionContext.suspendPayload
-			});
-			if (execution.status === "completed" && isValidationError(execution.output)) throw new MastraError({
-				id: "MCP_SERVER_TOOL_INVALID_INPUT",
-				domain: ErrorDomain.MCP,
-				category: ErrorCategory.USER,
-				text: execution.output.message,
-				details: { toolId }
-			});
-			this.logger.info("Tool executed successfully", { tool: toolId });
-			return execution;
-		} catch (error) {
-			if (error instanceof MastraError && error.id === "MCP_SERVER_TOOL_INVALID_INPUT") throw error;
-			const mastraError = new MastraError({
-				id: "MCP_SERVER_TOOL_EXECUTE_FAILED",
-				domain: ErrorDomain.MCP,
-				category: ErrorCategory.USER,
-				details: {
-					toolId,
-					args: JSON.stringify(args)
-				}
-			}, error);
-			this.logger.trackException(mastraError);
-			throw mastraError;
-		}
+		const requestSpan = this.startRequestSpan("tools/call", {
+			name: toolId,
+			arguments: args
+		}, { requestContext });
+		return this.traceRequest(requestSpan, async () => {
+			const tool = this.convertedTools[toolId];
+			if (!tool) {
+				this.logger.warn("Unknown tool requested", {
+					tool: toolId,
+					server: this.name
+				});
+				throw new MastraError({
+					id: "MCP_SERVER_TOOL_EXECUTE_PREPARATION_FAILED",
+					domain: ErrorDomain.MCP,
+					category: ErrorCategory.USER,
+					text: `Unknown tool: ${toolId}`,
+					details: { toolId }
+				});
+			}
+			await this.enforceToolExecutionFGA(toolId, requestContext);
+			try {
+				const execution = await this.runTool(toolId, tool, args, {
+					requestContext,
+					tracingContext: { currentSpan: requestSpan },
+					resumeData: executionContext.resumeData,
+					suspendPayload: executionContext.suspendPayload
+				});
+				if (execution.status === "completed" && isValidationError(execution.output)) throw new MastraError({
+					id: "MCP_SERVER_TOOL_INVALID_INPUT",
+					domain: ErrorDomain.MCP,
+					category: ErrorCategory.USER,
+					text: execution.output.message,
+					details: { toolId }
+				});
+				this.logger.info("Tool executed successfully", { tool: toolId });
+				return execution;
+			} catch (error) {
+				if (error instanceof MastraError && error.id === "MCP_SERVER_TOOL_INVALID_INPUT") throw error;
+				const mastraError = new MastraError({
+					id: "MCP_SERVER_TOOL_EXECUTE_FAILED",
+					domain: ErrorDomain.MCP,
+					category: ErrorCategory.USER,
+					details: {
+						toolId,
+						args: JSON.stringify(args)
+					}
+				}, error);
+				this.logger.trackException(mastraError);
+				throw mastraError;
+			}
+		});
 	}
 	/** Reads an `ui://` app resource; application resources require a protocol request. */
 	async readResource(uri) {