nuwax-mcp-stdio-proxy 1.4.7 → 1.4.8

package/dist/bridge.js

@@ -177,8 +177,7 @@ export class PersistentMcpBridge {
                     }
                     return t;
                 },
-                pingIntervalMs: entry.config.pingIntervalMs,
-                pingTimeoutMs: entry.config.pingTimeoutMs,
+                pingIntervalMs: 0, // No heartbeat for stdio — child process close/error events handle detection
             });
             const client = new Client({ name: 'nuwax-persistent-bridge', version: '1.0.0' }, { capabilities: {} });
             // Handle transport close → auto restart
@@ -195,10 +194,6 @@ export class PersistentMcpBridge {
             // Connect client to transport (this starts the subprocess)
             await wrapper.start();
             await client.connect(wrapper);
-            // Enable heartbeat monitoring AFTER the MCP initialize handshake
-            // completes — sending pings before initialize causes "Server not
-            // initialized" errors from the MCP server.
-            wrapper.enableHeartbeat();
             entry.client = client;
             entry.transport = wrapper;
             // List tools (cached)

package/dist/detect.d.ts

@@ -1,14 +1,20 @@
 /**
  * Protocol auto-detection — determine whether a URL serves Streamable HTTP or SSE
+ *
+ * Aligned with workspace/mcp-proxy (Rust) detection logic:
+ * - Only probe Streamable HTTP (POST initialize)
+ * - Default to SSE if probe fails
  */
 /**
  * Detect the MCP transport protocol of a remote URL.
  *
- * Strategy:
- * 1. Try Streamable HTTP first: send a JSON-RPC initialize POST.
- *    If the server responds with 200 and JSON, it's streamable-http.
- *    Then clean up the orphan session via DELETE.
- * 2. If that fails, try SSE: send a GET and check for text/event-stream content-type.
- * 3. Default to 'stream' (Streamable HTTP) if both probes fail.
+ * Strategy (matches Rust mcp-proxy):
+ * 1. Send a JSON-RPC initialize POST to probe for Streamable HTTP.
+ * 2. Check 4 criteria — any match means streamable-http:
+ *    a. Response has `mcp-session-id` header
+ *    b. Content-Type is `text/event-stream` with 2xx status
+ *    c. Response body is valid JSON-RPC 2.0
+ *    d. Status is 406 Not Acceptable
+ * 3. If probe fails or no criteria match → default to SSE.
  */
 export declare function detectProtocol(url: string, headers?: Record<string, string>): Promise<'sse' | 'stream'>;

package/dist/detect.js

@@ -1,20 +1,25 @@
 /**
  * Protocol auto-detection — determine whether a URL serves Streamable HTTP or SSE
+ *
+ * Aligned with workspace/mcp-proxy (Rust) detection logic:
+ * - Only probe Streamable HTTP (POST initialize)
+ * - Default to SSE if probe fails
  */
 import { logInfo, logWarn } from './logger.js';
 /**
  * Detect the MCP transport protocol of a remote URL.
  *
- * Strategy:
- * 1. Try Streamable HTTP first: send a JSON-RPC initialize POST.
- *    If the server responds with 200 and JSON, it's streamable-http.
- *    Then clean up the orphan session via DELETE.
- * 2. If that fails, try SSE: send a GET and check for text/event-stream content-type.
- * 3. Default to 'stream' (Streamable HTTP) if both probes fail.
+ * Strategy (matches Rust mcp-proxy):
+ * 1. Send a JSON-RPC initialize POST to probe for Streamable HTTP.
+ * 2. Check 4 criteria — any match means streamable-http:
+ *    a. Response has `mcp-session-id` header
+ *    b. Content-Type is `text/event-stream` with 2xx status
+ *    c. Response body is valid JSON-RPC 2.0
+ *    d. Status is 406 Not Acceptable
+ * 3. If probe fails or no criteria match → default to SSE.
  */
 export async function detectProtocol(url, headers) {
     logInfo(`Auto-detecting protocol for ${url}...`);
-    // 1. Try Streamable HTTP — POST a JSON-RPC initialize request
     try {
         const reqHeaders = {
             'Content-Type': 'application/json',
@@ -22,7 +27,7 @@ export async function detectProtocol(url, headers) {
             ...headers,
         };
         const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 10_000);
+        const timeout = setTimeout(() => controller.abort(), 5_000);
         const res = await fetch(url, {
             method: 'POST',
             headers: reqHeaders,
@@ -39,57 +44,61 @@ export async function detectProtocol(url, headers) {
             signal: controller.signal,
         });
         clearTimeout(timeout);
-        const ct = res.headers.get('content-type') || '';
-        if (res.ok && (ct.includes('application/json') || ct.includes('text/event-stream'))) {
-            logInfo(`Detected streamable-http protocol for ${url}`);
-            // Consume body to avoid socket hang
+        // Check 1: mcp-session-id header (definitive Streamable HTTP marker)
+        if (res.headers.get('mcp-session-id')) {
+            logInfo(`Detected streamable-http protocol for ${url} (mcp-session-id header)`);
+            cleanupSession(url, res.headers.get('mcp-session-id'), headers);
             await res.text().catch(() => { });
-            // Clean up orphan session — fire-and-forget DELETE so the server
-            // can discard the half-initialized session we created during probing.
-            // Not awaited: cleanup is best-effort and must not block detection.
-            const sessionId = res.headers.get('mcp-session-id');
-            if (sessionId) {
-                fetch(url, {
-                    method: 'DELETE',
-                    headers: { 'mcp-session-id': sessionId, ...headers },
-                    signal: AbortSignal.timeout(5_000),
-                }).catch(() => { });
-            }
             return 'stream';
         }
-        await res.text().catch(() => { });
-    }
-    catch {
-        // Streamable HTTP probe failed, try SSE
-    }
-    // 2. Try SSE — GET and check for event-stream
-    try {
-        const reqHeaders = {
-            Accept: 'text/event-stream',
-            ...headers,
-        };
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 10_000);
-        const res = await fetch(url, {
-            method: 'GET',
-            headers: reqHeaders,
-            signal: controller.signal,
-        });
         const ct = res.headers.get('content-type') || '';
-        if (ct.includes('text/event-stream')) {
-            // Detected SSE — abort the stream before clearing the timeout
-            clearTimeout(timeout);
-            logInfo(`Detected SSE protocol for ${url}`);
+        // Check 2: text/event-stream content-type with success status
+        if (ct.includes('text/event-stream') && res.ok) {
+            logInfo(`Detected streamable-http protocol for ${url} (event-stream response)`);
+            cleanupSession(url, res.headers.get('mcp-session-id'), headers);
+            // Abort the stream to free the connection
             controller.abort();
-            return 'sse';
+            return 'stream';
+        }
+        // Read body for JSON-RPC check
+        let bodyText = '';
+        try {
+            bodyText = await res.text();
+        }
+        catch { /* ignore */ }
+        // Check 3: valid JSON-RPC 2.0 response
+        try {
+            const json = JSON.parse(bodyText);
+            if (json && json.jsonrpc === '2.0') {
+                logInfo(`Detected streamable-http protocol for ${url} (JSON-RPC 2.0 response)`);
+                cleanupSession(url, res.headers.get('mcp-session-id'), headers);
+                return 'stream';
+            }
+        }
+        catch { /* not JSON */ }
+        // Check 4: 406 Not Acceptable (may indicate Streamable HTTP)
+        if (res.status === 406) {
+            logInfo(`Detected streamable-http protocol for ${url} (406 Not Acceptable)`);
+            return 'stream';
         }
-        clearTimeout(timeout);
-        await res.text().catch(() => { });
     }
     catch {
-        // SSE probe failed
+        // Probe failed (timeout, connection refused, etc.)
     }
-    // 3. Default to streamable-http
-    logWarn(`Could not auto-detect protocol for ${url}, defaulting to streamable-http`);
-    return 'stream';
+    // Default to SSE (matches Rust mcp-proxy behavior)
+    logWarn(`Could not detect streamable-http for ${url}, defaulting to SSE`);
+    return 'sse';
+}
+/**
+ * Clean up orphan session — fire-and-forget DELETE so the server
+ * can discard the half-initialized session we created during probing.
+ */
+function cleanupSession(url, sessionId, headers) {
+    if (!sessionId)
+        return;
+    fetch(url, {
+        method: 'DELETE',
+        headers: { 'mcp-session-id': sessionId, ...headers },
+        signal: AbortSignal.timeout(5_000),
+    }).catch(() => { });
 }

package/dist/index.js

@@ -23040,7 +23040,7 @@ var ResilientTransportWrapper = class {
   mcpClient = null;
   heartbeatTimer = null;
   consecutiveFailures = 0;
-  state = "connecting";
+  state = "idle";
   // Handlers required by the Transport interface
   onclose;
   onerror;
@@ -23051,7 +23051,17 @@ var ResilientTransportWrapper = class {
   pendingPings = /* @__PURE__ */ new Map();
   constructor(options) {
     this.log = options.logger ?? defaultLogger;
-    this.options = { ...DEFAULT_OPTIONS, logger: this.log, ...options };
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      logger: this.log,
+      connectParams: options.connectParams,
+      ...options.name !== void 0 && { name: options.name },
+      ...options.pingIntervalMs !== void 0 && { pingIntervalMs: options.pingIntervalMs },
+      ...options.pingTimeoutMs !== void 0 && { pingTimeoutMs: options.pingTimeoutMs },
+      ...options.maxConsecutiveFailures !== void 0 && { maxConsecutiveFailures: options.maxConsecutiveFailures },
+      ...options.reconnectDelayMs !== void 0 && { reconnectDelayMs: options.reconnectDelayMs },
+      ...options.maxQueueSize !== void 0 && { maxQueueSize: options.maxQueueSize }
+    };
   }
   /**
    * Initializes the transport and connects to the backend
@@ -23071,7 +23081,7 @@ var ResilientTransportWrapper = class {
   /**
    * Enable heartbeat monitoring. Call this AFTER the MCP client has
    * completed its initialize handshake (client.connect()), otherwise
-   * the server will reject ping requests with "Server not initialized".
+   * the server will reject requests with "Server not initialized".
    */
   enableHeartbeat() {
     this.startHeartbeat();
@@ -23083,6 +23093,7 @@ var ResilientTransportWrapper = class {
       await this.activeTransport.start();
       this.state = "connected";
       this.consecutiveFailures = 0;
+      this.consecutivePingTimeouts = 0;
       this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
       this.flushQueue();
       if (!initial) {
@@ -23143,52 +23154,46 @@ var ResilientTransportWrapper = class {
   }
   /** Track consecutive ping timeouts (no response at all, not even an error) */
   consecutivePingTimeouts = 0;
-  /** If server doesn't support ping, auto-disable heartbeat after maxConsecutiveFailures timeouts */
-  pingDisabled = false;
   async checkHealth() {
     if (this.state !== "connected" || !this.activeTransport) return;
-    if (this.pingDisabled) return;
     try {
-      const pingId = `respl-ping-${Date.now()}`;
+      const healthId = `respl-ping-${Date.now()}`;
       const responsePromise = new Promise((resolve) => {
-        this.pendingPings.set(pingId, resolve);
+        this.pendingPings.set(healthId, resolve);
         setTimeout(() => {
-          if (this.pendingPings.has(pingId)) {
-            this.pendingPings.delete(pingId);
+          if (this.pendingPings.has(healthId)) {
+            this.pendingPings.delete(healthId);
             resolve(false);
           }
         }, this.options.pingTimeoutMs);
       });
-      let sendFailed = false;
       try {
-        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F493} Sending heartbeat ping (id: ${pingId})`);
+        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F493} Sending heartbeat (id: ${healthId})`);
         await this.activeTransport.send({
           jsonrpc: "2.0",
-          id: pingId,
-          method: "ping"
+          id: healthId,
+          method: "tools/list",
+          params: {}
         });
       } catch (sendErr) {
-        sendFailed = true;
         throw sendErr;
       }
       const success2 = await responsePromise;
       if (!success2) {
         this.consecutivePingTimeouts++;
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
         if (this.consecutivePingTimeouts >= this.options.maxConsecutiveFailures) {
-          this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Server does not respond to ping. Disabling heartbeat monitoring.`);
-          this.pingDisabled = true;
-          this.stopHeartbeat();
-          return;
+          this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Force reconnecting.`);
+          this.triggerReconnect();
         }
-        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Ping timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
         return;
       }
-      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F496} Heartbeat successful (id: ${pingId})`);
+      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F496} Heartbeat OK (id: ${healthId})`);
       this.consecutiveFailures = 0;
       this.consecutivePingTimeouts = 0;
     } catch (err) {
       this.consecutiveFailures++;
-      this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F494} Heartbeat error (attempt ${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
+      this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F494} Heartbeat error (${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
       if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
         this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat failures reached. Force reconnecting.`);
         this.triggerReconnect();
@@ -23274,6 +23279,8 @@ var ResilientTransportWrapper = class {
 };
 
 // src/transport.ts
+var DEFAULT_STDIO_CONNECTION_TIMEOUT_MS = 6e4;
+var DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 3e4;
 async function withTimeout(promise2, ms, message) {
   let timeoutId;
   const timeoutPromise = new Promise((_, reject) => {
@@ -23327,19 +23334,19 @@ async function connectStdio(id, entry, baseEnv) {
       }
       return t;
     },
-    pingIntervalMs: entry.pingIntervalMs,
-    pingTimeoutMs: entry.pingTimeoutMs
+    // No heartbeat for stdio — child process close/error events handle detection
+    pingIntervalMs: 0
   });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
+  const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_STDIO_CONNECTION_TIMEOUT_MS;
   try {
     await withTimeout(
       (async () => {
         await wrapper.start();
         await client.connect(wrapper);
-        wrapper.enableHeartbeat();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -23375,6 +23382,7 @@ async function connectStreamable(id, entry) {
     pingTimeoutMs: entry.pingTimeoutMs
   });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
+  const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
   try {
     await withTimeout(
       (async () => {
@@ -23382,8 +23390,8 @@ async function connectStreamable(id, entry) {
         await client.connect(wrapper);
         wrapper.enableHeartbeat();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -23419,6 +23427,7 @@ async function connectSse(id, entry) {
     pingTimeoutMs: entry.pingTimeoutMs
   });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
+  const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
   try {
     await withTimeout(
       (async () => {
@@ -23426,8 +23435,8 @@ async function connectSse(id, entry) {
         await client.connect(wrapper);
         wrapper.enableHeartbeat();
       })(),
-      5e3,
-      `Connection initialization timed out after 5s`
+      timeoutMs,
+      `Connection initialization timed out after ${timeoutMs / 1e3}s`
     );
   } catch (err) {
     try {
@@ -24105,7 +24114,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.7";
+var PKG_VERSION = "1.4.8";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -24190,7 +24199,7 @@ async function detectProtocol(url2, headers) {
       ...headers
     };
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const timeout = setTimeout(() => controller.abort(), 5e3);
     const res = await fetch(url2, {
       method: "POST",
       headers: reqHeaders,
@@ -24207,52 +24216,51 @@ async function detectProtocol(url2, headers) {
       signal: controller.signal
     });
     clearTimeout(timeout);
-    const ct = res.headers.get("content-type") || "";
-    if (res.ok && (ct.includes("application/json") || ct.includes("text/event-stream"))) {
-      logInfo(`Detected streamable-http protocol for ${url2}`);
+    if (res.headers.get("mcp-session-id")) {
+      logInfo(`Detected streamable-http protocol for ${url2} (mcp-session-id header)`);
+      cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
       await res.text().catch(() => {
       });
-      const sessionId = res.headers.get("mcp-session-id");
-      if (sessionId) {
-        fetch(url2, {
-          method: "DELETE",
-          headers: { "mcp-session-id": sessionId, ...headers },
-          signal: AbortSignal.timeout(5e3)
-        }).catch(() => {
-        });
-      }
       return "stream";
     }
-    await res.text().catch(() => {
-    });
-  } catch {
-  }
-  try {
-    const reqHeaders = {
-      Accept: "text/event-stream",
-      ...headers
-    };
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    const res = await fetch(url2, {
-      method: "GET",
-      headers: reqHeaders,
-      signal: controller.signal
-    });
     const ct = res.headers.get("content-type") || "";
-    if (ct.includes("text/event-stream")) {
-      clearTimeout(timeout);
-      logInfo(`Detected SSE protocol for ${url2}`);
+    if (ct.includes("text/event-stream") && res.ok) {
+      logInfo(`Detected streamable-http protocol for ${url2} (event-stream response)`);
+      cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
       controller.abort();
-      return "sse";
+      return "stream";
+    }
+    let bodyText = "";
+    try {
+      bodyText = await res.text();
+    } catch {
+    }
+    try {
+      const json2 = JSON.parse(bodyText);
+      if (json2 && json2.jsonrpc === "2.0") {
+        logInfo(`Detected streamable-http protocol for ${url2} (JSON-RPC 2.0 response)`);
+        cleanupSession(url2, res.headers.get("mcp-session-id"), headers);
+        return "stream";
+      }
+    } catch {
+    }
+    if (res.status === 406) {
+      logInfo(`Detected streamable-http protocol for ${url2} (406 Not Acceptable)`);
+      return "stream";
     }
-    clearTimeout(timeout);
-    await res.text().catch(() => {
-    });
   } catch {
   }
-  logWarn(`Could not auto-detect protocol for ${url2}, defaulting to streamable-http`);
-  return "stream";
+  logWarn(`Could not detect streamable-http for ${url2}, defaulting to SSE`);
+  return "sse";
+}
+function cleanupSession(url2, sessionId, headers) {
+  if (!sessionId) return;
+  fetch(url2, {
+    method: "DELETE",
+    headers: { "mcp-session-id": sessionId, ...headers },
+    signal: AbortSignal.timeout(5e3)
+  }).catch(() => {
+  });
 }
 
 // src/modes/stdio.ts
@@ -24271,52 +24279,69 @@ async function runStdio(config2, allowTools, denyTools) {
   const toolToClient = /* @__PURE__ */ new Map();
   const toolToServer = /* @__PURE__ */ new Map();
   const toolsByName = /* @__PURE__ */ new Map();
-  for (const [id, entry] of entries) {
-    try {
-      let connected;
-      if (isSseEntry(entry)) {
-        connected = await connectSse(id, entry);
-      } else if (isStreamableEntry(entry)) {
-        connected = await connectStreamable(id, entry);
-      } else if (needsProtocolDetection(entry)) {
-        const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
-        if (detected === "sse") {
-          connected = await connectSse(id, { ...entry, transport: "sse" });
-        } else {
+  const connectableEntries = entries.filter(([id, entry]) => {
+    if (entry.persistent) {
+      logWarn(`Skipping persistent server "${id}" (handled by PersistentMcpBridge)`);
+      return false;
+    }
+    return true;
+  });
+  const results = await Promise.allSettled(
+    connectableEntries.map(async ([id, entry]) => {
+      try {
+        let connected;
+        if (isSseEntry(entry)) {
+          connected = await connectSse(id, entry);
+        } else if (isStreamableEntry(entry)) {
           connected = await connectStreamable(id, entry);
+        } else if (needsProtocolDetection(entry)) {
+          const detected = await detectProtocol(entry.url, buildRequestHeaders(entry));
+          if (detected === "sse") {
+            connected = await connectSse(id, { ...entry, transport: "sse" });
+          } else {
+            connected = await connectStreamable(id, entry);
+          }
+        } else {
+          connected = await connectStdio(id, entry, baseEnv);
         }
-      } else {
-        connected = await connectStdio(id, entry, baseEnv);
-      }
-      const { client, cleanup } = connected;
-      clients.set(id, client);
-      cleanups.set(id, cleanup);
-      let serverTools = await discoverTools(client);
-      if (entry.allowTools || entry.denyTools) {
-        const perFilter = {};
-        if (entry.allowTools) perFilter.allowTools = new Set(entry.allowTools);
-        if (entry.denyTools) perFilter.denyTools = new Set(entry.denyTools);
-        const before = serverTools.length;
-        serverTools = filterTools(serverTools, perFilter);
-        if (serverTools.length !== before) {
-          logInfo(`Server "${id}": filtered ${before} \u2192 ${serverTools.length} tool(s)`);
-        }
-      }
-      logInfo(
-        `Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? " \u2014 " + serverTools.map((t) => t.name).join(", ") : ""}`
-      );
-      for (const tool of serverTools) {
-        if (toolToClient.has(tool.name)) {
-          logWarn(
-            `Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`
-          );
-        }
-        toolToClient.set(tool.name, client);
-        toolToServer.set(tool.name, id);
-        toolsByName.set(tool.name, tool);
+        return { id, entry, connected };
+      } catch (e) {
+        throw new Error(`Server "${id}": ${e}`);
       }
-    } catch (e) {
-      logError(`Failed to connect to server "${id}": ${e}`);
+    })
+  );
+  for (const result of results) {
+    if (result.status === "rejected") {
+      logError(`Failed to connect: ${result.reason}`);
+      continue;
+    }
+    const { id, entry, connected } = result.value;
+    const { client, cleanup } = connected;
+    clients.set(id, client);
+    cleanups.set(id, cleanup);
+    let serverTools = await discoverTools(client);
+    if (entry.allowTools || entry.denyTools) {
+      const perFilter = {};
+      if (entry.allowTools) perFilter.allowTools = new Set(entry.allowTools);
+      if (entry.denyTools) perFilter.denyTools = new Set(entry.denyTools);
+      const before = serverTools.length;
+      serverTools = filterTools(serverTools, perFilter);
+      if (serverTools.length !== before) {
+        logInfo(`Server "${id}": filtered ${before} \u2192 ${serverTools.length} tool(s)`);
+      }
+    }
+    logInfo(
+      `Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? " \u2014 " + serverTools.map((t) => t.name).join(", ") : ""}`
+    );
+    for (const tool of serverTools) {
+      if (toolToClient.has(tool.name)) {
+        logWarn(
+          `Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`
+        );
+      }
+      toolToClient.set(tool.name, client);
+      toolToServer.set(tool.name, id);
+      toolsByName.set(tool.name, tool);
     }
   }
   if (clients.size === 0) {
@@ -25829,8 +25854,8 @@ var PersistentMcpBridge = class {
           }
           return t;
         },
-        pingIntervalMs: entry.config.pingIntervalMs,
-        pingTimeoutMs: entry.config.pingTimeoutMs
+        pingIntervalMs: 0
+        // No heartbeat for stdio — child process close/error events handle detection
       });
       const client = new Client(
         { name: "nuwax-persistent-bridge", version: "1.0.0" },
@@ -25848,7 +25873,6 @@ var PersistentMcpBridge = class {
       };
       await wrapper.start();
       await client.connect(wrapper);
-      wrapper.enableHeartbeat();
       entry.client = client;
       entry.transport = wrapper;
       const result = await client.listTools();

package/dist/modes/stdio.js

@@ -24,7 +24,16 @@ export async function runStdio(config, allowTools, denyTools) {
     const toolToClient = new Map();
     const toolToServer = new Map();
     const toolsByName = new Map();
-    for (const [id, entry] of entries) {
+    // Filter out persistent entries (handled by PersistentMcpBridge, not this proxy)
+    const connectableEntries = entries.filter(([id, entry]) => {
+        if (entry.persistent) {
+            logWarn(`Skipping persistent server "${id}" (handled by PersistentMcpBridge)`);
+            return false;
+        }
+        return true;
+    });
+    // Connect to all servers in parallel
+    const results = await Promise.allSettled(connectableEntries.map(async ([id, entry]) => {
         try {
             let connected;
             if (isSseEntry(entry)) {
@@ -46,36 +55,43 @@ export async function runStdio(config, allowTools, denyTools) {
             else {
                 connected = await connectStdio(id, entry, baseEnv);
             }
-            const { client, cleanup } = connected;
-            clients.set(id, client);
-            cleanups.set(id, cleanup);
-            let serverTools = await discoverTools(client);
-            // Per-server tool filtering (allowTools/denyTools in config entry)
-            if (entry.allowTools || entry.denyTools) {
-                const perFilter = {};
-                if (entry.allowTools)
-                    perFilter.allowTools = new Set(entry.allowTools);
-                if (entry.denyTools)
-                    perFilter.denyTools = new Set(entry.denyTools);
-                const before = serverTools.length;
-                serverTools = filterTools(serverTools, perFilter);
-                if (serverTools.length !== before) {
-                    logInfo(`Server "${id}": filtered ${before} → ${serverTools.length} tool(s)`);
-                }
-            }
-            logInfo(`Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? ' — ' + serverTools.map((t) => t.name).join(', ') : ''}`);
-            for (const tool of serverTools) {
-                if (toolToClient.has(tool.name)) {
-                    logWarn(`Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`);
-                }
-                toolToClient.set(tool.name, client);
-                toolToServer.set(tool.name, id);
-                toolsByName.set(tool.name, tool);
-            }
+            return { id, entry, connected };
         }
         catch (e) {
-            logError(`Failed to connect to server "${id}": ${e}`);
-            // Continue with remaining servers — partial startup is acceptable
+            throw new Error(`Server "${id}": ${e}`);
+        }
+    }));
+    for (const result of results) {
+        if (result.status === 'rejected') {
+            logError(`Failed to connect: ${result.reason}`);
+            continue;
+        }
+        const { id, entry, connected } = result.value;
+        const { client, cleanup } = connected;
+        clients.set(id, client);
+        cleanups.set(id, cleanup);
+        let serverTools = await discoverTools(client);
+        // Per-server tool filtering (allowTools/denyTools in config entry)
+        if (entry.allowTools || entry.denyTools) {
+            const perFilter = {};
+            if (entry.allowTools)
+                perFilter.allowTools = new Set(entry.allowTools);
+            if (entry.denyTools)
+                perFilter.denyTools = new Set(entry.denyTools);
+            const before = serverTools.length;
+            serverTools = filterTools(serverTools, perFilter);
+            if (serverTools.length !== before) {
+                logInfo(`Server "${id}": filtered ${before} → ${serverTools.length} tool(s)`);
+            }
+        }
+        logInfo(`Server "${id}": ${serverTools.length} tool(s)${serverTools.length > 0 ? ' — ' + serverTools.map((t) => t.name).join(', ') : ''}`);
+        for (const tool of serverTools) {
+            if (toolToClient.has(tool.name)) {
+                logWarn(`Tool "${tool.name}" from "${id}" shadows existing tool from "${toolToServer.get(tool.name)}"`);
+            }
+            toolToClient.set(tool.name, client);
+            toolToServer.set(tool.name, id);
+            toolsByName.set(tool.name, tool);
         }
     }
     if (clients.size === 0) {

package/dist/resilient.d.ts

@@ -61,7 +61,7 @@ export declare class ResilientTransportWrapper implements Transport {
     /**
      * Enable heartbeat monitoring. Call this AFTER the MCP client has
      * completed its initialize handshake (client.connect()), otherwise
-     * the server will reject ping requests with "Server not initialized".
+     * the server will reject requests with "Server not initialized".
      */
     enableHeartbeat(): void;
     private performConnect;
@@ -70,8 +70,6 @@ export declare class ResilientTransportWrapper implements Transport {
     private stopHeartbeat;
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     private consecutivePingTimeouts;
-    /** If server doesn't support ping, auto-disable heartbeat after maxConsecutiveFailures timeouts */
-    private pingDisabled;
     private checkHealth;
     private triggerReconnect;
     private flushQueue;

package/dist/resilient.js

@@ -26,7 +26,7 @@ export class ResilientTransportWrapper {
     mcpClient = null;
     heartbeatTimer = null;
     consecutiveFailures = 0;
-    state = 'connecting';
+    state = 'idle';
     // Handlers required by the Transport interface
     onclose;
     onerror;
@@ -37,7 +37,21 @@ export class ResilientTransportWrapper {
     pendingPings = new Map();
     constructor(options) {
         this.log = options.logger ?? defaultLogger;
-        this.options = { ...DEFAULT_OPTIONS, logger: this.log, ...options };
+        // Build options by starting from defaults and only overriding with
+        // explicitly provided values. Spreading { pingIntervalMs: undefined }
+        // would clobber the default 20000, causing setInterval(fn, undefined)
+        // → interval ~0ms (fires every tick).
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            logger: this.log,
+            connectParams: options.connectParams,
+            ...(options.name !== undefined && { name: options.name }),
+            ...(options.pingIntervalMs !== undefined && { pingIntervalMs: options.pingIntervalMs }),
+            ...(options.pingTimeoutMs !== undefined && { pingTimeoutMs: options.pingTimeoutMs }),
+            ...(options.maxConsecutiveFailures !== undefined && { maxConsecutiveFailures: options.maxConsecutiveFailures }),
+            ...(options.reconnectDelayMs !== undefined && { reconnectDelayMs: options.reconnectDelayMs }),
+            ...(options.maxQueueSize !== undefined && { maxQueueSize: options.maxQueueSize }),
+        };
     }
     /**
      * Initializes the transport and connects to the backend
@@ -58,7 +72,7 @@ export class ResilientTransportWrapper {
     /**
      * Enable heartbeat monitoring. Call this AFTER the MCP client has
      * completed its initialize handshake (client.connect()), otherwise
-     * the server will reject ping requests with "Server not initialized".
+     * the server will reject requests with "Server not initialized".
      */
     enableHeartbeat() {
         this.startHeartbeat();
@@ -71,6 +85,7 @@ export class ResilientTransportWrapper {
             await this.activeTransport.start();
             this.state = 'connected';
             this.consecutiveFailures = 0;
+            this.consecutivePingTimeouts = 0;
             this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
             // Flush any queued messages
             this.flushQueue();
@@ -112,7 +127,7 @@ export class ResilientTransportWrapper {
             }
         };
         transport.onmessage = (message) => {
-            // Intercept our own ping responses here (both success and error responses)
+            // Intercept our own heartbeat responses (tools/list used as health check)
             if ('id' in message && typeof message.id === 'string' && message.id.startsWith('respl-ping-')) {
                 const resolve = this.pendingPings.get(message.id);
                 if (resolve) {
@@ -143,64 +158,54 @@ export class ResilientTransportWrapper {
     }
     /** Track consecutive ping timeouts (no response at all, not even an error) */
     consecutivePingTimeouts = 0;
-    /** If server doesn't support ping, auto-disable heartbeat after maxConsecutiveFailures timeouts */
-    pingDisabled = false;
     async checkHealth() {
         if (this.state !== 'connected' || !this.activeTransport)
             return;
-        if (this.pingDisabled)
-            return;
         try {
-            // Send raw ping JSON-RPC
-            const pingId = `respl-ping-${Date.now()}`;
+            // Use tools/list as health check (all MCP servers must support it).
+            // Unlike ping, which is optional and many servers ignore, tools/list
+            // is a required MCP method — matching Rust mcp-proxy behavior.
+            const healthId = `respl-ping-${Date.now()}`;
             const responsePromise = new Promise((resolve) => {
-                this.pendingPings.set(pingId, resolve);
+                this.pendingPings.set(healthId, resolve);
                 setTimeout(() => {
-                    if (this.pendingPings.has(pingId)) {
-                        this.pendingPings.delete(pingId);
+                    if (this.pendingPings.has(healthId)) {
+                        this.pendingPings.delete(healthId);
                         resolve(false); // Timeout
                     }
                 }, this.options.pingTimeoutMs);
             });
-            // Try to send ping — if send() throws, the transport itself is broken
-            let sendFailed = false;
+            // Try to send tools/list — if send() throws, the transport itself is broken
             try {
-                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💓 Sending heartbeat ping (id: ${pingId})`);
+                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💓 Sending heartbeat (id: ${healthId})`);
                 await this.activeTransport.send({
                     jsonrpc: '2.0',
-                    id: pingId,
-                    method: 'ping',
+                    id: healthId,
+                    method: 'tools/list',
+                    params: {},
                 });
             }
             catch (sendErr) {
-                sendFailed = true;
                 throw sendErr; // Transport broken, treat as real failure
             }
             const success = await responsePromise;
             if (!success) {
-                // Ping was sent successfully but timed out — server might not support ping
                 this.consecutivePingTimeouts++;
+                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Heartbeat timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
                 if (this.consecutivePingTimeouts >= this.options.maxConsecutiveFailures) {
-                    // Server consistently never responds to ping — it probably doesn't support
-                    // the ping method. Auto-disable heartbeat instead of reconnecting, since
-                    // the transport is likely healthy (sends succeed, no errors from transport).
-                    this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Server does not respond to ping. Disabling heartbeat monitoring.`);
-                    this.pingDisabled = true;
-                    this.stopHeartbeat();
-                    return;
+                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat timeouts reached. Force reconnecting.`);
+                    this.triggerReconnect();
                 }
-                // Still count as a failure for logging, but don't reconnect yet
-                this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Ping timeout (${this.consecutivePingTimeouts}/${this.options.maxConsecutiveFailures})`);
                 return;
             }
             // Got a response — server is alive
-            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💖 Heartbeat successful (id: ${pingId})`);
+            this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 💖 Heartbeat OK (id: ${healthId})`);
             this.consecutiveFailures = 0;
             this.consecutivePingTimeouts = 0;
         }
         catch (err) {
             this.consecutiveFailures++;
-            this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 💔 Heartbeat error (attempt ${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
+            this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 💔 Heartbeat error (${this.consecutiveFailures}/${this.options.maxConsecutiveFailures}): ${err}`);
             if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
                 this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat failures reached. Force reconnecting.`);
                 this.triggerReconnect();

package/dist/transport.js

@@ -7,6 +7,8 @@ import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { CustomStdioClientTransport } from './customStdio.js';
 import { logInfo } from './logger.js';
 import { ResilientTransportWrapper } from './resilient.js';
+const DEFAULT_STDIO_CONNECTION_TIMEOUT_MS = 60_000;
+const DEFAULT_HTTP_CONNECTION_TIMEOUT_MS = 30_000;
 /**
  * Helper to wrap a promise with a timeout
  */
@@ -73,16 +75,16 @@ export async function connectStdio(id, entry, baseEnv) {
             }
             return t;
         },
-        pingIntervalMs: entry.pingIntervalMs,
-        pingTimeoutMs: entry.pingTimeoutMs,
+        // No heartbeat for stdio — child process close/error events handle detection
+        pingIntervalMs: 0,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_STDIO_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
-            wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {
@@ -121,12 +123,13 @@ export async function connectStreamable(id, entry) {
         pingTimeoutMs: entry.pingTimeoutMs,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
             wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {
@@ -165,12 +168,13 @@ export async function connectSse(id, entry) {
         pingTimeoutMs: entry.pingTimeoutMs,
     });
     const client = new Client({ name: `proxy-${id}`, version: '1.0.0' });
+    const timeoutMs = entry.connectionTimeoutMs ?? DEFAULT_HTTP_CONNECTION_TIMEOUT_MS;
     try {
         await withTimeout((async () => {
             await wrapper.start();
             await client.connect(wrapper);
             wrapper.enableHeartbeat(); // Start heartbeat AFTER MCP initialize completes
-        })(), 5000, `Connection initialization timed out after 5s`);
+        })(), timeoutMs, `Connection initialization timed out after ${timeoutMs / 1000}s`);
     }
     catch (err) {
         try {

package/dist/types.d.ts

@@ -10,10 +10,8 @@ export interface StdioServerEntry {
     allowTools?: string[];
     /** 工具黑名单（排除指定工具） */
     denyTools?: string[];
-    /** Heartbeat ping interval configuration (ms) */
-    pingIntervalMs?: number;
-    /** Heartbeat ping timeout configuration (ms) */
-    pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 60000 for stdio. */
+    connectionTimeoutMs?: number;
 }
 /**
  * Streamable HTTP 类型: 连接远程 MCP server (Streamable HTTP)
@@ -34,6 +32,8 @@ export interface StreamableServerEntry {
     pingIntervalMs?: number;
     /** Heartbeat ping timeout configuration (ms) */
     pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 30000. */
+    connectionTimeoutMs?: number;
 }
 /**
  * SSE 类型: 连接远程 MCP server (Server-Sent Events)
@@ -53,6 +53,8 @@ export interface SseServerEntry {
     pingIntervalMs?: number;
     /** Heartbeat ping timeout configuration (ms) */
     pingTimeoutMs?: number;
+    /** Connection initialization timeout (ms). Defaults to 30000. */
+    connectionTimeoutMs?: number;
 }
 export type McpServerEntry = StdioServerEntry | StreamableServerEntry | SseServerEntry;
 export declare function isSseEntry(entry: McpServerEntry): entry is SseServerEntry;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {
-    "nuwax-mcp-stdio-proxy": "./dist/index.js"
+    "nuwax-mcp-stdio-proxy": "dist/index.js"
   },
   "main": "./dist/lib.js",
   "types": "./dist/lib.d.ts",