@mastra/mcp 1.16.0 → 1.17.0-alpha.0

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);
 			}
 		}));
 	}