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

The timeout value from RunnableConfig was being lost when calling MCP tools because ensureConfig() converts it to an AbortSignal and removes the numeric timeout field. This prevented the MCP SDK from receiving explicit timeout values.

Changes:
  - Store original timeout in metadata.__lc_originalTimeoutMs in ensureConfig()
  - Retrieve and pass numeric timeout to MCP SDK RequestOptions in _callTool()
  - Add integration test verifying per-call timeout is properly honored

This ensures MCP tools respect timeouts passed through RunnableConfig, allowing callers to override default timeouts on a per-call basis.

Author: pawel-twardziak

langchain-core/src/runnables/config.ts

@@ -179,7 +179,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.__lc_originalTimeoutMs === undefined) {
+      empty.metadata.__lc_originalTimeoutMs = originalTimeoutMs;
+    }
     if (empty.signal !== undefined) {
       if ("any" in AbortSignal) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

libs/langchain-mcp-adapters/__tests__/client.int.test.ts

@@ -1352,6 +1352,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 server options",
       async (transport) => {

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

@@ -433,8 +433,14 @@ async function _callTool({
     getDebugLog()(`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.__lc_originalTimeoutMs if present, falling back to any direct timeout.
+    const numericTimeout =
+      (config?.metadata?.__lc_originalTimeoutMs as number | undefined) ??
+      config?.timeout;
     const requestOptions: RequestOptions = {
-      ...(config?.timeout ? { timeout: config.timeout } : {}),
+      ...(numericTimeout ? { timeout: numericTimeout } : {}),
       ...(config?.signal ? { signal: config.signal } : {}),
     };