@mastra/mcp 1.16.0 → 1.17.0-alpha.1

package/dist/index.js

@@ -23741,25 +23741,31 @@ onListChanged: async (serverName, handler) => {
 	* }
 	* ```
 	*/
-	async listToolsWithErrors() {
+	async listToolsWithErrors(options) {
 		this.addToInstanceCache();
 		const connectedTools = {};
 		const errors = {};
+		const durations = {};
 		const settled = await this.discoverAcrossServers((serverName) => this.getToolsForServer(serverName), {
 			errorId: "MCP_CLIENT_GET_TOOLS_FAILED",
 			logMessage: "Failed to list tools from server:"
-		});
-		for (const { serverName, value, error } of settled) {
+		}, options);
+		for (const { serverName, value, error, duration } of settled) {
+			durations[serverName] = duration;
 			if (error !== void 0) {
 				errors[serverName] = error;
 				continue;
 			}
 			for (const [toolName, toolConfig] of Object.entries(value)) connectedTools[`${serverName}_${toolName}`] = toolConfig;
 		}
-		return {
+		const result = {
 			tools: connectedTools,
 			errors
 		};
+		return options ? {
+			...result,
+			durations
+		} : result;
 	}
 	/**
 	* Returns toolsets organized by server name for dynamic tool injection.
@@ -23804,25 +23810,31 @@ onListChanged: async (serverName, handler) => {
 	* }
 	* ```
 	*/
-	async listToolsetsWithErrors() {
+	async listToolsetsWithErrors(options) {
 		this.addToInstanceCache();
 		const connectedToolsets = {};
 		const errors = {};
+		const durations = {};
 		const settled = await this.discoverAcrossServers((serverName) => this.getToolsForServer(serverName), {
 			errorId: "MCP_CLIENT_GET_TOOLSETS_FAILED",
 			logMessage: "Failed to list toolsets from server:"
-		});
-		for (const { serverName, value, error } of settled) {
+		}, options);
+		for (const { serverName, value, error, duration } of settled) {
+			durations[serverName] = duration;
 			if (error !== void 0) {
 				errors[serverName] = error;
 				continue;
 			}
 			connectedToolsets[serverName] = value;
 		}
-		return {
+		const result = {
 			toolsets: connectedToolsets,
 			errors
 		};
+		return options ? {
+			...result,
+			durations
+		} : result;
 	}
 	/**
 	* Discovers every configured server's tools as plain, serializable definitions.
@@ -23856,27 +23868,33 @@ onListChanged: async (serverName, handler) => {
 	* Useful when caching a catalog, since it lets you avoid persisting a partial manifest that
 	* silently omits a server which happened to be down at discovery time.
 	*/
-	async listToolDefinitionsWithErrors() {
+	async listToolDefinitionsWithErrors(options) {
 		this.addToInstanceCache();
 		const definitions = {};
 		const errors = {};
+		const durations = {};
 		const settled = await this.discoverAcrossServers(async (serverName) => {
 			return (await this.getConnectedClientForServer(serverName)).toolDefinitions();
 		}, {
 			errorId: "MCP_CLIENT_GET_TOOL_DEFINITIONS_FAILED",
 			logMessage: "Failed to list tool definitions from server:"
-		});
-		for (const { serverName, value, error } of settled) {
+		}, options);
+		for (const { serverName, value, error, duration } of settled) {
+			durations[serverName] = duration;
 			if (error !== void 0) {
 				errors[serverName] = error;
 				continue;
 			}
 			definitions[serverName] = value;
 		}
-		return {
+		const result = {
 			definitions,
 			errors
 		};
+		return options ? {
+			...result,
+			durations
+		} : result;
 	}
 	/**
 	* Rebuilds an executable Mastra tool from a cached {@link SerializableMCPToolDefinition}.
@@ -23940,14 +23958,21 @@ onListChanged: async (serverName, handler) => {
 	* Backs `listTools`/`listToolsets`, `resources.list`/`templates`, and
 	* `prompts.list`.
 	*/
-	async discoverAcrossServers(operation, onError) {
+	async discoverAcrossServers(operation, onError, options) {
 		const serverNames = Object.keys(this.serverConfigs);
 		return Promise.all(serverNames.map(async (serverName) => {
+			const startedAt = performance.now();
+			let timer;
 			try {
+				const operationPromise = operation(serverName);
 				return {
 					serverName,
-					value: await operation(serverName),
-					error: void 0
+					value: options?.perServerTimeoutMs === void 0 ? await operationPromise : await Promise.race([operationPromise, new Promise((_, reject) => {
+						timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Discovery timed out after ${options.perServerTimeoutMs}ms`)), options.perServerTimeoutMs);
+						timer.unref?.();
+					})]),
+					error: void 0,
+					duration: performance.now() - startedAt
 				};
 			} catch (error) {
 				const mastraError = new MastraError({
@@ -23961,8 +23986,11 @@ onListChanged: async (serverName, handler) => {
 				return {
 					serverName,
 					value: void 0,
-					error: error instanceof Error ? error.message : String(error)
+					error: error instanceof Error ? error.message : String(error),
+					duration: performance.now() - startedAt
 				};
+			} finally {
+				clearTimeout(timer);
 			}
 		}));
 	}
@@ -26506,6 +26534,8 @@ var MCPServer = class extends MCPServerBase {
 	stdioTransport;
 	sseTransport;
 	sseHonoTransports;
+	/** Auth info for the in-flight Hono SSE message POST, keyed by session id. */
+	sseHonoAuthInfo = /* @__PURE__ */ new Map();
 	streamableHTTPTransports = /* @__PURE__ */ new Map();
 	httpServerInstances = /* @__PURE__ */ new Map();
 	resourceOptions;
@@ -27682,7 +27712,7 @@ var MCPServer = class extends MCPServerBase {
 	* export default app;
 	* ```
 	*/
-	async startHonoSSE({ url, ssePath, messagePath, context }) {
+	async startHonoSSE({ url, ssePath, messagePath, context, authInfo }) {
 		const honoContext = context;
 		try {
 			if (url.pathname === ssePath) return streamSSE(honoContext, async (stream) => {
@@ -27697,6 +27727,8 @@ var MCPServer = class extends MCPServerBase {
 				this.logger.debug("Received message for sessionId", { sessionId });
 				if (!sessionId) return honoContext.text("No sessionId provided", 400);
 				if (!this.sseHonoTransports.has(sessionId)) return honoContext.text(`No transport found for sessionId ${sessionId}`, 400);
+				if (authInfo) this.sseHonoAuthInfo.set(sessionId, authInfo);
+				else this.sseHonoAuthInfo.delete(sessionId);
 				const message = await this.sseHonoTransports.get(sessionId)?.handlePostMessage(honoContext);
 				if (!message) return honoContext.text("Transport not found", 400);
 				return message;
@@ -28049,12 +28081,22 @@ var MCPServer = class extends MCPServerBase {
 		stream.onAbort(() => {
 			this.logger.debug("SSE Transport aborted with sessionId:", { sessionId });
 			this.sseHonoTransports.delete(sessionId);
+			this.sseHonoAuthInfo.delete(sessionId);
 		});
 		try {
 			await this.server.connect(sseTransport);
+			const onmessage = sseTransport.onmessage?.bind(sseTransport);
+			if (onmessage) sseTransport.onmessage = (message, extra) => {
+				const authInfo = this.sseHonoAuthInfo.get(sessionId);
+				onmessage(message, authInfo ? {
+					...extra,
+					authInfo
+				} : extra);
+			};
 			this.server.onclose = async () => {
 				this.logger.debug("SSE Transport closed with sessionId:", { sessionId });
 				this.sseHonoTransports.delete(sessionId);
+				this.sseHonoAuthInfo.delete(sessionId);
 				await this.server.close();
 			};
 			while (true) {