fix(mcp-adapters): preserve timeout from RunnableConfig in MCP tool calls (#9165)

Co-authored-by: Hunter Lovell <[email protected]>

Author: pawel-twardziak

.changeset/stale-carrots-trade.md

@@ -0,0 +1,6 @@
+---
+"@langchain/core": patch
+"@langchain/mcp-adapters": patch
+---
+
+fix(mcp-adapters): preserve timeout from RunnableConfig in MCP tool calls

libs/langchain-core/src/runnables/config.ts

@@ -176,7 +176,18 @@ export function ensureConfig<CallOptions extends RunnableConfig>(
     if (empty.timeout <= 0) {
       throw new Error("Timeout must be a positive number");
     }
-    const timeoutSignal = AbortSignal.timeout(empty.timeout);
+    const originalTimeoutMs = empty.timeout;
+    const timeoutSignal = AbortSignal.timeout(originalTimeoutMs);
+    // Preserve the numeric timeout for downstream consumers that need to pass
+    // an explicit timeout value to underlying SDKs in addition to an AbortSignal.
+    // We store it in metadata to avoid changing the public config shape.
+    if (!empty.metadata) {
+      empty.metadata = {};
+    }
+    // Do not overwrite if already set upstream.
+    if (empty.metadata.timeoutMs === undefined) {
+      empty.metadata.timeoutMs = originalTimeoutMs;
+    }
     if (empty.signal !== undefined) {
       if ("any" in AbortSignal) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

libs/langchain-mcp-adapters/src/tests/client.test.ts

@@ -1247,6 +1247,43 @@ describe("MultiServerMCPClient Integration Tests", () => {
   });
 
   describe("Timeout Configuration", () => {
+    it("http smoke test: should honor timeout when shorter than sleepMsec", async () => {
+      const { baseUrl } = await testServers.createHTTPServer(
+        "timeout-smoke-test",
+        {
+          disableStreamableHttp: false,
+          supportSSEFallback: false,
+        }
+      );
+
+      const client = new MultiServerMCPClient({
+        "timeout-server": {
+          transport: "http",
+          url: `${baseUrl}/mcp`,
+        },
+      });
+
+      try {
+        const tools = await client.getTools();
+        const testTool = tools.find((t) => t.name.includes("sleep_tool"));
+        expect(testTool).toBeDefined();
+
+        // Set a timeout that is lower than the sleep duration and ensure it is honored.
+        await expect(
+          testTool!.invoke(
+            { sleepMsec: 500 },
+            {
+              timeout: 10,
+            }
+          )
+        ).rejects.toThrowError(
+          /TimeoutError: The operation was aborted due to timeout/
+        );
+      } finally {
+        await client.close();
+      }
+    });
+
     it.each(["http", "sse"] as const)(
       "%s should respect RunnableConfig timeout for tool calls",
       async (transport: "http" | "sse") => {
@@ -1378,6 +1415,39 @@ describe("MultiServerMCPClient Integration Tests", () => {
       }
     );
 
+    it.each(["http", "sse"] as const)(
+      "%s should pass explicit per-call timeout through RunnableConfig",
+      async (transport) => {
+        const { baseUrl } = await testServers.createHTTPServer("timeout-test", {
+          disableStreamableHttp: transport === "sse",
+          supportSSEFallback: transport === "sse",
+        });
+
+        const client = new MultiServerMCPClient({
+          "timeout-server": {
+            transport,
+            url: `${baseUrl}/${transport === "http" ? "mcp" : "sse"}`,
+          },
+        });
+
+        try {
+          const tools = await client.getTools();
+          const testTool = tools.find((t) => t.name.includes("sleep_tool"));
+          expect(testTool).toBeDefined();
+
+          // Set a per-call timeout longer than the server default to ensure it is honored
+          // The server sleep is 1500ms; we set timeout to 2000ms so it should succeed
+          const result = await testTool!.invoke(
+            { sleepMsec: 1500 },
+            { timeout: 2000 }
+          );
+          expect(result).toContain("done");
+        } finally {
+          await client.close();
+        }
+      }
+    );
+
     it.each(["http", "sse"] as const)(
       "%s should throw timeout error when tool call exceeds configured timeout from constructor options",
       async (transport) => {

libs/langchain-mcp-adapters/src/tools.ts

@@ -600,8 +600,13 @@ async function _callTool({
     debugLog(`INFO: Calling tool ${toolName}(${JSON.stringify(args)})`);
 
     // Extract timeout from RunnableConfig and pass to MCP SDK
+    // Note: ensureConfig() converts timeout into an AbortSignal and deletes the timeout field.
+    // To preserve the numeric timeout for SDKs that accept an explicit timeout value, we read
+    // it from metadata.timeoutMs if present, falling back to any direct timeout.
+    const numericTimeout =
+      (config?.metadata?.timeoutMs as number | undefined) ?? config?.timeout;
     const requestOptions: RequestOptions = {
-      ...(config?.timeout ? { timeout: config.timeout } : {}),
+      ...(numericTimeout ? { timeout: numericTimeout } : {}),
       ...(config?.signal ? { signal: config.signal } : {}),
       ...(onProgress
         ? {