@mastra/mcp 2.9.0-alpha.1 → 2.9.0-alpha.3

package/dist/index.js

@@ -15844,6 +15844,16 @@ function shouldDetachPersistentTransportRequest(init) {
 		return false;
 	}
 }
+/** Whether a request body is a single JSON-RPC response: the client's reply to a server request. */
+function isJsonRpcResponseBody(body) {
+	if (typeof body !== "string") return false;
+	try {
+		const message = JSON.parse(body);
+		return typeof message === "object" && message !== null && !Array.isArray(message) && !("method" in message) && "id" in message && ("result" in message || "error" in message);
+	} catch {
+		return false;
+	}
+}
 const TASK_WAIT_ERROR_IDS = {
 	timeout: "MCP_CLIENT_TOOL_TASK_TIMEOUT",
 	expired: "MCP_CLIENT_TOOL_TASK_EXPIRED",
@@ -16072,6 +16082,19 @@ var InternalMastraMCPClient = class extends MastraBase {
 	clientConnectionOnClose;
 	_authState;
 	operationContextStore = new AsyncLocalStorage();
+	/**
+	* The requestContext of the tool call whose execution opened the connection. Only the
+	* transport's fetch reads it, so the handshake and the streams the connection keeps open are
+	* sent as that call. Messages arriving on those streams are delivered outside it, so server logs
+	* are not labelled with it and requests their handlers send are not sent as that call.
+	*/
+	connectionContextStore = new AsyncLocalStorage();
+	/**
+	* The connection context of the transport a server message arrived on, as it was when that
+	* transport was created, set while the message is delivered. The transport's fetch reads it only for the client's replies to server requests,
+	* which belong to the connection rather than to the handler that produced them.
+	*/
+	replyContextStore = new AsyncLocalStorage();
 	exitHookUnsubscribe;
 	sigTermHandler;
 	sigHupHandler;
@@ -16264,7 +16287,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 		if (allowedHosts !== void 0) assertHostAllowed(url, allowedHosts);
 		const policyUserFetch = userFetch && allowedHosts !== void 0 ? wrapFetchWithHostPolicy(userFetch, allowedHosts) : void 0;
 		const fetch = (requestUrl, init) => {
-			const requestContext = this.operationContextStore.getStore() ?? null;
+			const requestContext = this.fetchRequestContext(init);
 			const executeFetch = () => {
 				if (allowedHosts === void 0) return userFetch ? userFetch(requestUrl, init, requestContext) : globalThis.fetch(requestUrl, init);
 				if (policyUserFetch) return policyUserFetch(requestUrl, init, requestContext);
@@ -16279,6 +16302,7 @@ var InternalMastraMCPClient = class extends MastraBase {
 			fetch
 		});
 		observeEventStreamRequests(transport, this.noteEventStreamSent);
+		this.deliverOutsideConnectionContext(transport);
 		this.connectingTransport = transport;
 		try {
 			this.assertSameLifecycle(generation);
@@ -16300,6 +16324,59 @@ var InternalMastraMCPClient = class extends MastraBase {
 		}
 	}
 	/**
+	* Connects as a tool call: the handshake and the streams the connection keeps open reach the
+	* transport's fetch with the call's requestContext, through the connection context. Any enclosing
+	* operation scope is exited first. It would take priority in fetch, and the new streams and stdio
+	* child would deliver every later server message in it.
+	*/
+	connectAsCall(requestContext, connect) {
+		return this.operationContextStore.exit(() => this.connectionContextStore.run(requestContext, connect));
+	}
+	/**
+	* The requestContext the transport's fetch passes on for an outgoing request. An operation scope
+	* owns its requests, even when its requestContext is null. Outside one, the handshake and the
+	* streams the connection keeps open use the connection context, and a reply to a server request
+	* uses the context of the connection that delivered the request.
+	*/
+	fetchRequestContext(init) {
+		const operationContext = this.operationContextStore.getStore();
+		if (operationContext !== void 0) return operationContext;
+		const connectionContext = this.connectionContextStore.getStore();
+		if (connectionContext !== void 0) return connectionContext;
+		const replyContext = this.replyContextStore.getStore();
+		if (replyContext !== void 0 && isJsonRpcResponseBody(init?.body)) return replyContext;
+		return null;
+	}
+	/**
+	* Delivers every message the server sends outside the connection context, from the handshake on.
+	* A server log, notification or request arriving on a stream the opening call started belongs to
+	* no call, so a request its handler sends must not be sent as that call. The client's reply to a
+	* server request still is, through `replyContextStore`.
+	*
+	* The reply context is the connection context this transport was created in, captured once. Read
+	* at delivery time, it would carry over to a connection that a handler of an older connection's
+	* message opens, such as a `reconnectServer()` from a server log callback.
+	*
+	* The SDK assigns `onmessage` during `connect()` and swaps it while probing the server, so every
+	* assignment is wrapped. A handler that wraps an already wrapped one (`interceptTaskResults`, or
+	* the probe restoring its saved handler) runs with the same reply context.
+	*/
+	deliverOutsideConnectionContext(transport) {
+		const replyContext = this.connectionContextStore.getStore() ?? null;
+		let deliver;
+		Object.defineProperty(transport, "onmessage", {
+			configurable: true,
+			enumerable: true,
+			get: () => deliver,
+			set: (handler) => {
+				deliver = handler && ((message, extra) => {
+					const dispatch = () => handler.call(transport, message, extra);
+					this.connectionContextStore.exit(() => this.replyContextStore.run(replyContext, dispatch));
+				});
+			}
+		});
+	}
+	/**
 	* Detaches whatever transport is still attached to the underlying SDK Client.
 	*
 	* The SDK assigns its internal `_transport` before `transport.start()` and never
@@ -16637,7 +16714,8 @@ var InternalMastraMCPClient = class extends MastraBase {
 				this.serverImplementation = void 0;
 			}
 			this.assertSameLifecycle(generation);
-			await this.connect(generation);
+			const callContext = this.operationContextStore.getStore();
+			await (callContext === void 0 ? this.connect(generation) : this.connectAsCall(callContext, () => this.connect(generation)));
 			this.log("debug", "Successfully reconnected to MCP server");
 		})();
 		this.reconnectPromise = reconnectPromise;
@@ -17130,8 +17208,8 @@ var InternalMastraMCPClient = class extends MastraBase {
 				},
 				...tool.outputSchema ? { toModelOutput: createStructuredToolToModelOutput() } : {},
 				execute: async (input, context) => {
-					if (serverMeta.connectFirst) await this.connect();
 					const operationContext = context?.requestContext ?? null;
+					if (serverMeta.connectFirst) await this.connectAsCall(operationContext, () => this.connect());
 					return this.operationContextStore.run(operationContext, async () => {
 						const suspendHost = context?.agent ?? context?.workflow;
 						const toolCallSpan = context?.tracingContext?.currentSpan;
@@ -19070,6 +19148,7 @@ onListChanged: async (serverName, handler) => {
 			errorId: "MCP_CLIENT_GET_TOOLS_FAILED",
 			logMessage: "Failed to list tools from server:"
 		}, options);
+		const keySources = /* @__PURE__ */ new Map();
 		for (const { serverName, value, error, duration } of settled) {
 			durations[serverName] = duration;
 			if (error !== void 0) {
@@ -19077,7 +19156,7 @@ onListChanged: async (serverName, handler) => {
 				errorDetails[serverName] = error;
 				continue;
 			}
-			for (const [toolName, toolConfig] of Object.entries(value)) connectedTools[`${serverName}_${toolName}`] = toolConfig;
+			for (const [toolName, toolConfig] of Object.entries(value)) this.setNamespacedTool(connectedTools, keySources, serverName, toolName, toolConfig);
 		}
 		const result = {
 			tools: connectedTools,
@@ -19249,16 +19328,18 @@ onListChanged: async (serverName, handler) => {
 	async toolsFromDefinitions({ definitions: catalog }) {
 		const configuredServers = new Set(Object.keys(this.serverConfigs));
 		const tools = {};
+		const keySources = /* @__PURE__ */ new Map();
 		for (const [serverName, definitions] of Object.entries(catalog)) {
 			if (!configuredServers.has(serverName)) {
 				this.logger.warn("Skipping cached MCP tool definitions for a server that is no longer configured", { serverName });
 				continue;
 			}
 			for (const [toolName, definition] of Object.entries(modelVisibleDefinitions(definitions))) try {
-				tools[`${serverName}_${toolName}`] = await this.toolFromDefinition({
+				const tool = await this.toolFromDefinition({
 					serverName,
 					definition
 				});
+				this.setNamespacedTool(tools, keySources, serverName, toolName, tool);
 			} catch (error) {
 				if (!(error instanceof MastraError && error.id === "MCP_CLIENT_INVALID_TOOL_INPUT_SCHEMA")) throw error;
 			}
@@ -19319,6 +19400,28 @@ onListChanged: async (serverName, handler) => {
 		} : result;
 	}
 	/**
+	* Stores a tool under its `serverName_toolName` key. Server and tool names can both contain `_`,
+	* so two different pairs can produce one key (`local` + `x_status` and `local_x` + `status`).
+	* The later pair keeps the key, as before; this logs a warning instead of dropping a tool silently.
+	*/
+	setNamespacedTool(tools, keySources, serverName, toolName, tool) {
+		const key = `${serverName}_${toolName}`;
+		const replaced = keySources.get(key);
+		if (replaced) this.logger.warn(`MCP tool key "${key}" from server "${serverName}" (tool "${toolName}") replaces the tool from server "${replaced.serverName}" (tool "${replaced.toolName}"), which produces the same key. Only the tool from "${serverName}" is kept. Rename one of the servers in \`servers\` to keep both.`, {
+			key,
+			replaced,
+			replacedBy: {
+				serverName,
+				toolName
+			}
+		});
+		keySources.set(key, {
+			serverName,
+			toolName
+		});
+		tools[key] = tool;
+	}
+	/**
 	* Runs a per-server discovery `operation` against every configured server
 	* concurrently, isolating and logging per-server failures. Results are
 	* returned in configuration order (`Object.keys(serverConfigs)`) so callers