Add Timeout config for the MCP Client tool

Author: jreyesr

packages/@n8n/nodes-langchain/nodes/mcp/McpClientTool/McpClientTool.node.test.ts

@@ -1,5 +1,6 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { mock } from 'jest-mock-extended';
 import {
 	NodeOperationError,
@@ -284,5 +285,39 @@ describe('McpClientTool', () => {
 				headers: { Accept: 'text/event-stream', Authorization: 'Bearer my-token' },
 			});
 		});
+
+		it('should support setting a timeout', async () => {
+			jest.spyOn(Client.prototype, 'connect').mockResolvedValue();
+			jest
+				.spyOn(Client.prototype, 'callTool')
+				.mockRejectedValue(
+					new McpError(ErrorCode.RequestTimeout, 'Request timed out', { timeout: 200 }),
+				);
+			jest.spyOn(Client.prototype, 'listTools').mockResolvedValue({
+				tools: [
+					{
+						name: 'SlowTool',
+						description: 'SlowTool throws a timeout',
+						inputSchema: { type: 'object', properties: { input: { type: 'string' } } },
+					},
+				],
+			});
+
+			const mockNode = mock<INode>({ typeVersion: 1 });
+			const supplyDataResult = await new McpClientTool().supplyData.call(
+				mock<ISupplyDataFunctions>({
+					getNode: jest.fn(() => mockNode),
+					logger: { debug: jest.fn(), error: jest.fn() },
+					addInputData: jest.fn(() => ({ index: 0 })),
+				}),
+				0,
+			);
+
+			const tools = (supplyDataResult.response as McpToolkit).getTools();
+
+			await expect(tools[0].invoke({ input: 'foo' })).rejects.toThrow(
+				'Failed to execute tool "SlowTool"',
+			);
+		});
 	});
 });

packages/@n8n/nodes-langchain/nodes/mcp/McpClientTool/McpClientTool.node.ts

@@ -173,6 +173,26 @@ export class McpClientTool implements INodeType {
 					},
 				},
 			},
+			{
+				displayName: 'Options',
+				name: 'options',
+				placeholder: 'Add Option',
+				description: 'Additional options to add',
+				type: 'collection',
+				default: {},
+				options: [
+					{
+						displayName: 'Timeout',
+						name: 'timeout',
+						type: 'number',
+						typeOptions: {
+							minValue: 1,
+						},
+						default: 60000,
+						description: 'Time in ms to wait for tool calls to finish',
+					},
+				],
+			},
 		],
 	};
 
@@ -188,6 +208,7 @@ export class McpClientTool implements INodeType {
 			itemIndex,
 		) as McpAuthenticationOption;
 		const sseEndpoint = this.getNodeParameter('sseEndpoint', itemIndex) as string;
+		const timeout = this.getNodeParameter('options.timeout', itemIndex, 60000) as number;
 		const node = this.getNode();
 		const { headers } = await getAuthHeaders(this, authentication);
 		const client = await connectMcpClient({
@@ -242,7 +263,7 @@ export class McpClientTool implements INodeType {
 			logWrapper(
 				mcpToolToDynamicTool(
 					tool,
-					createCallTool(tool.name, client.result, (error) => {
+					createCallTool(tool.name, client.result, timeout, (error) => {
 						this.logger.error(`McpClientTool: Tool "${tool.name}" failed to execute`, { error });
 						throw new NodeOperationError(node, `Failed to execute tool "${tool.name}"`, {
 							description: error,

packages/@n8n/nodes-langchain/nodes/mcp/McpClientTool/utils.ts

@@ -72,11 +72,13 @@ export const getErrorDescriptionFromToolCall = (result: unknown): string | undef
 };
 
 export const createCallTool =
-	(name: string, client: Client, onError: (error: string | undefined) => void) =>
+	(name: string, client: Client, timeout: number, onError: (error: string | undefined) => void) =>
 	async (args: IDataObject) => {
 		let result: Awaited<ReturnType<Client['callTool']>>;
 		try {
-			result = await client.callTool({ name, arguments: args }, CompatibilityCallToolResultSchema);
+			result = await client.callTool({ name, arguments: args }, CompatibilityCallToolResultSchema, {
+				timeout,
+			});
 		} catch (error) {
 			return onError(getErrorDescriptionFromToolCall(error));
 		}