nuwax-mcp-stdio-proxy 1.4.6 → 1.4.7

package/dist/index.js

@@ -23019,7 +23019,272 @@ function getDefaultEnvironment() {
   return env;
 }
 
+// src/resilient.ts
+var DEFAULT_OPTIONS = {
+  pingIntervalMs: 2e4,
+  maxConsecutiveFailures: 3,
+  pingTimeoutMs: 5e3,
+  reconnectDelayMs: 3e3,
+  maxQueueSize: 100,
+  name: "remote"
+};
+var defaultLogger = {
+  info: (...args) => logInfo(args.map(String).join(" ")),
+  warn: (...args) => logWarn(args.map(String).join(" ")),
+  error: (...args) => logError(args.map(String).join(" "))
+};
+var ResilientTransportWrapper = class {
+  options;
+  log;
+  activeTransport = null;
+  mcpClient = null;
+  heartbeatTimer = null;
+  consecutiveFailures = 0;
+  state = "connecting";
+  // Handlers required by the Transport interface
+  onclose;
+  onerror;
+  onmessage;
+  // Queue for messages sent while reconnecting
+  messageQueue = [];
+  // Pending ping requests awaiting a response
+  pendingPings = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.log = options.logger ?? defaultLogger;
+    this.options = { ...DEFAULT_OPTIONS, logger: this.log, ...options };
+  }
+  /**
+   * Initializes the transport and connects to the backend
+   *
+   * This method is idempotent - if the transport is already connected or
+   * connecting, subsequent calls will return immediately without creating
+   * duplicate connections. This is important because MCP SDK's client.connect()
+   * internally calls transport.start(), and we also call it explicitly in bridge.ts.
+   */
+  async start() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.state = "connecting";
+    await this.performConnect(true);
+  }
+  /**
+   * 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".
+   */
+  enableHeartbeat() {
+    this.startHeartbeat();
+  }
+  async performConnect(initial = false) {
+    try {
+      this.activeTransport = await this.options.connectParams();
+      this.bindInnerTransport(this.activeTransport);
+      await this.activeTransport.start();
+      this.state = "connected";
+      this.consecutiveFailures = 0;
+      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Connected via ${this.activeTransport.constructor.name}`);
+      this.flushQueue();
+      if (!initial) {
+        this.startHeartbeat();
+      }
+    } catch (err) {
+      this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Connect failed: ${err}`);
+      if (initial) {
+        this.state = "closed";
+        throw err;
+      }
+      this.triggerReconnect();
+    }
+  }
+  bindInnerTransport(transport) {
+    transport.onclose = () => {
+      if (this.state !== "closed") {
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Inner transport closed unexpectedly. Reconnecting...`);
+        this.triggerReconnect();
+      }
+    };
+    transport.onerror = (error2) => {
+      if (this.state !== "closed") {
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Inner transport error: ${error2.message}`);
+        if (this.state === "connecting") {
+          if (this.onerror) this.onerror(error2);
+          return;
+        }
+        this.triggerReconnect();
+      }
+    };
+    transport.onmessage = (message) => {
+      if ("id" in message && typeof message.id === "string" && message.id.startsWith("respl-ping-")) {
+        const resolve = this.pendingPings.get(message.id);
+        if (resolve) {
+          resolve(true);
+          this.pendingPings.delete(message.id);
+        }
+        return;
+      }
+      if (this.onmessage) {
+        this.onmessage(message);
+      }
+    };
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    if (this.options.pingIntervalMs <= 0) return;
+    this.heartbeatTimer = setInterval(() => {
+      this.checkHealth();
+    }, this.options.pingIntervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /** 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 responsePromise = new Promise((resolve) => {
+        this.pendingPings.set(pingId, resolve);
+        setTimeout(() => {
+          if (this.pendingPings.has(pingId)) {
+            this.pendingPings.delete(pingId);
+            resolve(false);
+          }
+        }, this.options.pingTimeoutMs);
+      });
+      let sendFailed = false;
+      try {
+        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F493} Sending heartbeat ping (id: ${pingId})`);
+        await this.activeTransport.send({
+          jsonrpc: "2.0",
+          id: pingId,
+          method: "ping"
+        });
+      } catch (sendErr) {
+        sendFailed = true;
+        throw sendErr;
+      }
+      const success2 = await responsePromise;
+      if (!success2) {
+        this.consecutivePingTimeouts++;
+        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.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.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}`);
+      if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+        this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Max consecutive heartbeat failures reached. Force reconnecting.`);
+        this.triggerReconnect();
+      }
+    }
+  }
+  triggerReconnect() {
+    if (this.state === "reconnecting" || this.state === "closed") return;
+    this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Triggering reconnect (previous state: ${this.state})`);
+    this.state = "reconnecting";
+    this.stopHeartbeat();
+    if (this.activeTransport) {
+      this.activeTransport.onclose = void 0;
+      this.activeTransport.onerror = void 0;
+      try {
+        this.activeTransport.close();
+      } catch {
+      }
+      this.activeTransport = null;
+    }
+    setTimeout(() => {
+      this.performConnect();
+    }, this.options.reconnectDelayMs);
+  }
+  async flushQueue() {
+    if (!this.activeTransport || this.state !== "connected") return;
+    if (this.messageQueue.length > 0) {
+      this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] Flushing ${this.messageQueue.length} queued requests...`);
+    }
+    const queueToFlush = [...this.messageQueue];
+    this.messageQueue = [];
+    for (let i = 0; i < queueToFlush.length; i++) {
+      const msg = queueToFlush[i];
+      try {
+        await this.activeTransport.send(msg);
+      } catch (e) {
+        this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] Error flushing queue: ${e}`);
+        const failedAndRemaining = queueToFlush.slice(i);
+        this.messageQueue = [...failedAndRemaining, ...this.messageQueue];
+        this.triggerReconnect();
+        break;
+      }
+    }
+  }
+  // --- Transport Interface Methods ---
+  async send(message) {
+    if (this.state === "closed") {
+      throw new Error("Transport is closed");
+    }
+    if (this.state === "reconnecting" || this.state === "connecting") {
+      if (this.messageQueue.length >= this.options.maxQueueSize) {
+        this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] Message queue full, dropping oldest request.`);
+        this.messageQueue.shift();
+      }
+      this.messageQueue.push(message);
+      return;
+    }
+    if (!this.activeTransport) {
+      throw new Error("No active transport to send message");
+    }
+    try {
+      await this.activeTransport.send(message);
+    } catch (err) {
+      this.messageQueue.push(message);
+      this.triggerReconnect();
+    }
+  }
+  async close() {
+    if (this.state === "closed") return;
+    this.state = "closed";
+    this.stopHeartbeat();
+    this.messageQueue = [];
+    if (this.activeTransport) {
+      this.activeTransport.onclose = void 0;
+      this.activeTransport.onerror = void 0;
+      await this.activeTransport.close();
+      this.activeTransport = null;
+    }
+    if (this.onclose) {
+      this.onclose();
+    }
+  }
+};
+
 // src/transport.ts
+async function withTimeout(promise2, ms, message) {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(new Error(message)), ms);
+  });
+  try {
+    return await Promise.race([promise2, timeoutPromise]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
 function buildBaseEnv() {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -23042,28 +23307,53 @@ function buildRequestHeaders(entry) {
 }
 async function connectStdio(id, entry, baseEnv) {
   logInfo(`Connecting to "${id}" (stdio): ${entry.command} ${(entry.args || []).join(" ")}`);
-  const transport = new CustomStdioClientTransport({
-    command: entry.command,
-    args: entry.args || [],
-    env: { ...baseEnv, ...entry.env || {} },
-    stderr: "pipe"
-  });
-  if (transport.stderr) {
-    transport.stderr.on("data", (chunk) => {
-      const text = chunk.toString().trim();
-      if (text) {
-        process.stderr.write(`[child:${id}] ${text}
+  const wrapper = new ResilientTransportWrapper({
+    name: id,
+    connectParams: async () => {
+      const t = new CustomStdioClientTransport({
+        command: entry.command,
+        args: entry.args || [],
+        env: { ...baseEnv, ...entry.env || {} },
+        stderr: "pipe"
+      });
+      if (t.stderr) {
+        t.stderr.on("data", (chunk) => {
+          const text = chunk.toString().trim();
+          if (text) {
+            process.stderr.write(`[child:${id}] ${text}
 `);
+          }
+        });
       }
-    });
-  }
+      return t;
+    },
+    pingIntervalMs: entry.pingIntervalMs,
+    pingTimeoutMs: entry.pingTimeoutMs
+  });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
-  await client.connect(transport);
+  try {
+    await withTimeout(
+      (async () => {
+        await wrapper.start();
+        await client.connect(wrapper);
+        wrapper.enableHeartbeat();
+      })(),
+      5e3,
+      `Connection initialization timed out after 5s`
+    );
+  } catch (err) {
+    try {
+      await wrapper.close();
+    } catch {
+    }
+    throw err;
+  }
   return {
     client,
+    transport: wrapper,
     cleanup: async () => {
       try {
-        await transport.close();
+        await wrapper.close();
       } catch {
       }
     }
@@ -23073,17 +23363,41 @@ async function connectStreamable(id, entry) {
   logInfo(`Connecting to "${id}" (streamable-http): ${entry.url}`);
   const headers = buildRequestHeaders(entry);
   const url2 = new URL(entry.url);
-  const transport = new StreamableHTTPClientTransport(
-    url2,
-    headers ? { requestInit: { headers } } : void 0
-  );
+  const wrapper = new ResilientTransportWrapper({
+    name: id,
+    connectParams: async () => {
+      return new StreamableHTTPClientTransport(
+        url2,
+        headers ? { requestInit: { headers } } : void 0
+      );
+    },
+    pingIntervalMs: entry.pingIntervalMs,
+    pingTimeoutMs: entry.pingTimeoutMs
+  });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
-  await client.connect(transport);
+  try {
+    await withTimeout(
+      (async () => {
+        await wrapper.start();
+        await client.connect(wrapper);
+        wrapper.enableHeartbeat();
+      })(),
+      5e3,
+      `Connection initialization timed out after 5s`
+    );
+  } catch (err) {
+    try {
+      await wrapper.close();
+    } catch {
+    }
+    throw err;
+  }
   return {
     client,
+    transport: wrapper,
     cleanup: async () => {
       try {
-        await transport.close();
+        await wrapper.close();
       } catch {
       }
     }
@@ -23093,17 +23407,41 @@ async function connectSse(id, entry) {
   logInfo(`Connecting to "${id}" (sse): ${entry.url}`);
   const headers = buildRequestHeaders(entry);
   const url2 = new URL(entry.url);
-  const transport = new SSEClientTransport(
-    url2,
-    headers ? { requestInit: { headers } } : void 0
-  );
+  const wrapper = new ResilientTransportWrapper({
+    name: id,
+    connectParams: async () => {
+      return new SSEClientTransport(
+        url2,
+        headers ? { requestInit: { headers } } : void 0
+      );
+    },
+    pingIntervalMs: entry.pingIntervalMs,
+    pingTimeoutMs: entry.pingTimeoutMs
+  });
   const client = new Client({ name: `proxy-${id}`, version: "1.0.0" });
-  await client.connect(transport);
+  try {
+    await withTimeout(
+      (async () => {
+        await wrapper.start();
+        await client.connect(wrapper);
+        wrapper.enableHeartbeat();
+      })(),
+      5e3,
+      `Connection initialization timed out after 5s`
+    );
+  } catch (err) {
+    try {
+      await wrapper.close();
+    } catch {
+    }
+    throw err;
+  }
   return {
     client,
+    transport: wrapper,
     cleanup: async () => {
       try {
-        await transport.close();
+        await wrapper.close();
       } catch {
       }
     }
@@ -23767,7 +24105,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.6";
+var PKG_VERSION = "1.4.7";
 
 // src/shared.ts
 async function discoverTools(client) {
@@ -24074,11 +24412,11 @@ async function runConvert(args) {
   const entryId = "remote";
   let connected;
   if (protocol === "sse") {
-    const sseEntry = { url: targetUrl, transport: "sse" };
+    const sseEntry = { url: targetUrl, transport: "sse", pingIntervalMs: args.pingIntervalMs, pingTimeoutMs: args.pingTimeoutMs };
     if (targetHeaders) sseEntry.headers = targetHeaders;
     connected = await connectSse(entryId, sseEntry);
   } else {
-    const streamEntry = { url: targetUrl };
+    const streamEntry = { url: targetUrl, pingIntervalMs: args.pingIntervalMs, pingTimeoutMs: args.pingTimeoutMs };
     if (targetHeaders) streamEntry.headers = targetHeaders;
     connected = await connectStreamable(entryId, streamEntry);
   }
@@ -25354,7 +25692,7 @@ var StreamableHTTPServerTransport = class {
 };
 
 // src/bridge.ts
-var LOG_TAG = "[PersistentMcpBridge]";
+var LOG_TAG = "[McpProxy] [PersistentMcpBridge]";
 var BASE_RESTART_COOLDOWN_MS = 5e3;
 var MAX_RESTART_ATTEMPTS = 5;
 var MAX_BODY_SIZE = 10 * 1024 * 1024;
@@ -25473,36 +25811,46 @@ var PersistentMcpBridge = class {
   async spawnAndConnect(id, entry) {
     try {
       this.log.info(`${LOG_TAG} Spawning server "${id}": ${entry.config.command} ${(entry.config.args || []).join(" ")}`);
-      const transport = new CustomStdioClientTransport({
-        command: entry.config.command,
-        args: entry.config.args || [],
-        env: entry.config.env,
-        stderr: "pipe"
+      const wrapper = new ResilientTransportWrapper({
+        name: id,
+        logger: this.log,
+        connectParams: async () => {
+          const t = new CustomStdioClientTransport({
+            command: entry.config.command,
+            args: entry.config.args || [],
+            env: entry.config.env,
+            stderr: "pipe"
+          });
+          if (t.stderr) {
+            t.stderr.on("data", (chunk) => {
+              const text = chunk.toString().trim();
+              if (text) this.log.info(`${LOG_TAG} [${id}:stderr] ${text}`);
+            });
+          }
+          return t;
+        },
+        pingIntervalMs: entry.config.pingIntervalMs,
+        pingTimeoutMs: entry.config.pingTimeoutMs
       });
       const client = new Client(
         { name: "nuwax-persistent-bridge", version: "1.0.0" },
         { capabilities: {} }
       );
-      transport.onclose = () => {
+      wrapper.onclose = () => {
         this.log.warn(`${LOG_TAG} Server "${id}" transport closed`);
         entry.healthy = false;
         if (this.running && !entry.restarting) {
           this.scheduleRestart(id, entry);
         }
       };
-      transport.onerror = (err) => {
+      wrapper.onerror = (err) => {
         this.log.error(`${LOG_TAG} Server "${id}" transport error:`, err.message);
       };
-      await client.connect(transport);
+      await wrapper.start();
+      await client.connect(wrapper);
+      wrapper.enableHeartbeat();
       entry.client = client;
-      entry.transport = transport;
-      const stderrStream = transport.stderr;
-      if (stderrStream) {
-        stderrStream.on("data", (chunk) => {
-          const text = chunk.toString().trim();
-          if (text) this.log.info(`${LOG_TAG} [${id}:stderr] ${text}`);
-        });
-      }
+      entry.transport = wrapper;
       const result = await client.listTools();
       entry.tools = result.tools;
       entry.healthy = true;
@@ -25840,6 +26188,8 @@ function parseConvertArgs(args) {
   let protocol;
   let allowTools;
   let denyTools;
+  let pingIntervalMs;
+  let pingTimeoutMs;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--config" && i + 1 < args.length) {
@@ -25862,6 +26212,20 @@ function parseConvertArgs(args) {
     } else if (arg === "--deny-tools" && i + 1 < args.length) {
       i++;
       denyTools = args[i].split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "--ping-interval" && i + 1 < args.length) {
+      i++;
+      pingIntervalMs = parseInt(args[i], 10);
+      if (isNaN(pingIntervalMs)) {
+        logError(`Invalid ping interval: "${args[i]}"`);
+        process.exit(1);
+      }
+    } else if (arg === "--ping-timeout" && i + 1 < args.length) {
+      i++;
+      pingTimeoutMs = parseInt(args[i], 10);
+      if (isNaN(pingTimeoutMs)) {
+        logError(`Invalid ping timeout: "${args[i]}"`);
+        process.exit(1);
+      }
     } else if (!arg.startsWith("-") && !url2) {
       url2 = arg;
     } else {
@@ -25879,7 +26243,7 @@ function parseConvertArgs(args) {
     logError("Cannot use both --allow-tools and --deny-tools");
     process.exit(1);
   }
-  return { mode: "convert", url: url2, config: config2, name, protocol, allowTools, denyTools };
+  return { mode: "convert", url: url2, config: config2, name, protocol, allowTools, denyTools, pingIntervalMs, pingTimeoutMs };
 }
 function parseProxyArgs(args) {
   let port;
@@ -25972,6 +26336,8 @@ function printConvertUsage() {
   logError("  --protocol <sse|stream>        Protocol type (auto-detect if omitted)");
   logError("  --allow-tools <TOOLS>          Tool whitelist (comma-separated)");
   logError("  --deny-tools <TOOLS>           Tool blacklist (comma-separated)");
+  logError("  --ping-interval <MS>           Heartbeat ping interval (default: 20000)");
+  logError("  --ping-timeout <MS>            Heartbeat ping timeout (default: 5000)");
 }
 function printProxyUsage() {
   logError(`Usage: nuwax-mcp-stdio-proxy proxy --port <PORT> --config '{"mcpServers":{...}}'`);

package/dist/modes/convert.d.ts

@@ -12,5 +12,7 @@ export interface ConvertArgs {
     protocol?: 'sse' | 'stream';
     allowTools?: string[];
     denyTools?: string[];
+    pingIntervalMs?: number;
+    pingTimeoutMs?: number;
 }
 export declare function runConvert(args: ConvertArgs): Promise<void>;

package/dist/modes/convert.js

@@ -67,13 +67,13 @@ export async function runConvert(args) {
     const entryId = 'remote';
     let connected;
     if (protocol === 'sse') {
-        const sseEntry = { url: targetUrl, transport: 'sse' };
+        const sseEntry = { url: targetUrl, transport: 'sse', pingIntervalMs: args.pingIntervalMs, pingTimeoutMs: args.pingTimeoutMs };
         if (targetHeaders)
             sseEntry.headers = targetHeaders;
         connected = await connectSse(entryId, sseEntry);
     }
     else {
-        const streamEntry = { url: targetUrl };
+        const streamEntry = { url: targetUrl, pingIntervalMs: args.pingIntervalMs, pingTimeoutMs: args.pingTimeoutMs };
         if (targetHeaders)
             streamEntry.headers = targetHeaders;
         connected = await connectStreamable(entryId, streamEntry);

package/dist/resilient.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Resilient Transport Wrapper for MCP
+ *
+ * Provides heartbeat monitoring, automatic reconnection, and request queueing
+ * for MCP transports (HTTP, SSE, Stdio).
+ */
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+/** Logger interface — compatible with console, electron-log, and BridgeLogger */
+export interface ResilientLogger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export interface ResilientTransportOptions {
+    /** Connection factory function */
+    connectParams: () => Promise<Transport>;
+    /** Heartbeat check interval (ms). Default: 20000 */
+    pingIntervalMs?: number;
+    /** Max consecutive failures before reconnecting. Default: 3 */
+    maxConsecutiveFailures?: number;
+    /** Timeout for checking ping or listTools (ms). Default: 5000 */
+    pingTimeoutMs?: number;
+    /** Backoff delay before reconnect attempt (ms). Default: 3000 */
+    reconnectDelayMs?: number;
+    /** Max queued requests during reconnect. Default: 100 */
+    maxQueueSize?: number;
+    /** Server name/ID for logging */
+    name?: string;
+    /**
+     * Optional custom logger. When running inside the Electron main process
+     * (e.g. PersistentMcpBridge), pass electron-log so heartbeat/reconnect
+     * logs appear in main.log alongside other application logs.
+     * Defaults to the built-in stderr logger (logger.js).
+     */
+    logger?: ResilientLogger;
+}
+export declare class ResilientTransportWrapper implements Transport {
+    private options;
+    private log;
+    private activeTransport;
+    private mcpClient;
+    private heartbeatTimer;
+    private consecutiveFailures;
+    private state;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    private messageQueue;
+    private pendingPings;
+    constructor(options: ResilientTransportOptions);
+    /**
+     * Initializes the transport and connects to the backend
+     *
+     * This method is idempotent - if the transport is already connected or
+     * connecting, subsequent calls will return immediately without creating
+     * duplicate connections. This is important because MCP SDK's client.connect()
+     * internally calls transport.start(), and we also call it explicitly in bridge.ts.
+     */
+    start(): Promise<void>;
+    /**
+     * 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".
+     */
+    enableHeartbeat(): void;
+    private performConnect;
+    private bindInnerTransport;
+    private startHeartbeat;
+    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;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}