nuwax-mcp-stdio-proxy 1.4.9 → 1.4.10

package/dist/index.js

@@ -23118,6 +23118,12 @@ var ResilientTransportWrapper = class {
   mcpClient = null;
   heartbeatTimer = null;
   consecutiveFailures = 0;
+  /** Captured MCP initialize request for replay on reconnect */
+  initializeMessage = null;
+  /** Captured MCP notifications/initialized for replay on reconnect */
+  initializedNotification = null;
+  /** Pending re-initialize promise resolver */
+  pendingReInit = null;
   state = "idle";
   /** Current retry attempt count (reset on successful connect) */
   retryAttempt = 0;
@@ -23184,9 +23190,27 @@ var ResilientTransportWrapper = class {
       this.state = "connected";
       this.consecutiveFailures = 0;
       this.consecutivePingTimeouts = 0;
-      this.retryAttempt = 0;
       this.heartbeatOkCount = 0;
       this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u2705 Connected via ${this.activeTransport.constructor.name}`);
+      if (!initial && this.initializeMessage) {
+        this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Re-initializing MCP session...`);
+        try {
+          await this.performReInitialize();
+          this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u2705 MCP session re-initialized`);
+        } catch (err) {
+          this.retryAttempt++;
+          const delay = this.getBackoffDelay();
+          this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] \u274C Re-initialize failed: ${err}`);
+          this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
+          this.state = "reconnecting";
+          this.cleanupTransport();
+          setTimeout(() => {
+            this.performConnect();
+          }, delay);
+          return;
+        }
+      }
+      this.retryAttempt = 0;
       this.flushQueue();
       if (!initial) {
         this.startHeartbeat();
@@ -23202,6 +23226,43 @@ var ResilientTransportWrapper = class {
       }, delay);
     }
   }
+  /**
+   * Replay the MCP initialize handshake on a reconnected transport.
+   * Sends the captured `initialize` request with a unique internal ID,
+   * waits for the response, then sends `notifications/initialized`.
+   */
+  async performReInitialize() {
+    if (!this.activeTransport || !this.initializeMessage) {
+      throw new Error("No transport or no captured initialize message");
+    }
+    const initId = `respl-init-${Date.now()}`;
+    const initRequest = {
+      ...this.initializeMessage,
+      id: initId
+    };
+    const initPromise = new Promise((resolve) => {
+      this.pendingReInit = resolve;
+      setTimeout(() => {
+        if (this.pendingReInit) {
+          this.pendingReInit = null;
+          resolve(false);
+        }
+      }, this.options.pingTimeoutMs);
+    });
+    try {
+      await this.activeTransport.send(initRequest);
+    } catch (err) {
+      this.pendingReInit = null;
+      throw err;
+    }
+    const success2 = await initPromise;
+    if (!success2) {
+      throw new Error("Re-initialize timed out");
+    }
+    if (this.initializedNotification) {
+      await this.activeTransport.send(this.initializedNotification);
+    }
+  }
   bindInnerTransport(transport) {
     transport.onclose = () => {
       if (this.state !== "closed") {
@@ -23220,6 +23281,13 @@ var ResilientTransportWrapper = class {
       }
     };
     transport.onmessage = (message) => {
+      if ("id" in message && typeof message.id === "string" && message.id.startsWith("respl-init-")) {
+        if (this.pendingReInit) {
+          this.pendingReInit(true);
+          this.pendingReInit = null;
+        }
+        return;
+      }
       if ("id" in message && typeof message.id === "string" && message.id.startsWith("respl-ping-")) {
         const resolve = this.pendingPings.get(message.id);
         if (resolve) {
@@ -23299,12 +23367,9 @@ var ResilientTransportWrapper = class {
     }
   }
   /**
-   * Close the current transport and schedule a reconnect with exponential backoff.
+   * Detach handlers from and close the current active transport.
    */
-  triggerReconnect() {
-    if (this.state === "reconnecting" || this.state === "closed") return;
-    this.state = "reconnecting";
-    this.stopHeartbeat();
+  cleanupTransport() {
     if (this.activeTransport) {
       this.activeTransport.onclose = void 0;
       this.activeTransport.onerror = void 0;
@@ -23314,6 +23379,15 @@ var ResilientTransportWrapper = class {
       }
       this.activeTransport = null;
     }
+  }
+  /**
+   * Close the current transport and schedule a reconnect with exponential backoff.
+   */
+  triggerReconnect() {
+    if (this.state === "reconnecting" || this.state === "closed") return;
+    this.state = "reconnecting";
+    this.stopHeartbeat();
+    this.cleanupTransport();
     const delay = this.getBackoffDelay();
     this.retryAttempt++;
     this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] \u{1F504} Closed. Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
@@ -23354,6 +23428,10 @@ var ResilientTransportWrapper = class {
       this.messageQueue.push(message);
       return;
     }
+    if ("method" in message) {
+      if (message.method === "initialize") this.initializeMessage = message;
+      else if (message.method === "notifications/initialized") this.initializedNotification = message;
+    }
     if (!this.activeTransport) {
       throw new Error("No active transport to send message");
     }
@@ -24217,7 +24295,7 @@ var StdioServerTransport = class {
 
 // src/constants.ts
 var PKG_NAME = "nuwax-mcp-stdio-proxy";
-var PKG_VERSION = "1.4.9";
+var PKG_VERSION = "1.4.10";
 
 // src/shared.ts
 async function discoverTools(client) {

package/dist/resilient.d.ts

@@ -47,6 +47,12 @@ export declare class ResilientTransportWrapper implements Transport {
     private mcpClient;
     private heartbeatTimer;
     private consecutiveFailures;
+    /** Captured MCP initialize request for replay on reconnect */
+    private initializeMessage;
+    /** Captured MCP notifications/initialized for replay on reconnect */
+    private initializedNotification;
+    /** Pending re-initialize promise resolver */
+    private pendingReInit;
     private state;
     /** Current retry attempt count (reset on successful connect) */
     private retryAttempt;
@@ -77,6 +83,12 @@ export declare class ResilientTransportWrapper implements Transport {
      */
     enableHeartbeat(): void;
     private performConnect;
+    /**
+     * Replay the MCP initialize handshake on a reconnected transport.
+     * Sends the captured `initialize` request with a unique internal ID,
+     * waits for the response, then sends `notifications/initialized`.
+     */
+    private performReInitialize;
     private bindInnerTransport;
     private startHeartbeat;
     private stopHeartbeat;
@@ -85,6 +97,10 @@ export declare class ResilientTransportWrapper implements Transport {
     /** Successful heartbeat counter (for reducing log volume) */
     private heartbeatOkCount;
     private checkHealth;
+    /**
+     * Detach handlers from and close the current active transport.
+     */
+    private cleanupTransport;
     /**
      * Close the current transport and schedule a reconnect with exponential backoff.
      */

package/dist/resilient.js

@@ -30,6 +30,12 @@ export class ResilientTransportWrapper {
     mcpClient = null;
     heartbeatTimer = null;
     consecutiveFailures = 0;
+    /** Captured MCP initialize request for replay on reconnect */
+    initializeMessage = null;
+    /** Captured MCP notifications/initialized for replay on reconnect */
+    initializedNotification = null;
+    /** Pending re-initialize promise resolver */
+    pendingReInit = null;
     state = 'idle';
     /** Current retry attempt count (reset on successful connect) */
     retryAttempt = 0;
@@ -103,9 +109,33 @@ export class ResilientTransportWrapper {
             this.state = 'connected';
             this.consecutiveFailures = 0;
             this.consecutivePingTimeouts = 0;
-            this.retryAttempt = 0;
             this.heartbeatOkCount = 0;
             this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] ✅ Connected via ${this.activeTransport.constructor.name}`);
+            // On reconnect, replay MCP initialize handshake before doing anything else.
+            // The server requires initialize + notifications/initialized before accepting
+            // any other requests (tools/list, etc).
+            if (!initial && this.initializeMessage) {
+                this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Re-initializing MCP session...`);
+                try {
+                    await this.performReInitialize();
+                    this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] ✅ MCP session re-initialized`);
+                }
+                catch (err) {
+                    // Re-initialize failed — treat as a connect failure, preserve backoff
+                    this.retryAttempt++;
+                    const delay = this.getBackoffDelay();
+                    this.log.error(`[McpProxy] [ResilientTransport:${this.options.name}] ❌ Re-initialize failed: ${err}`);
+                    this.log.info(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
+                    this.state = 'reconnecting';
+                    this.cleanupTransport();
+                    setTimeout(() => {
+                        this.performConnect();
+                    }, delay);
+                    return;
+                }
+            }
+            // Reset retry count only after successful connect + re-initialize
+            this.retryAttempt = 0;
             // Flush any queued messages
             this.flushQueue();
             // Only start heartbeat on reconnects — initial connections need
@@ -127,6 +157,46 @@ export class ResilientTransportWrapper {
             }, delay);
         }
     }
+    /**
+     * Replay the MCP initialize handshake on a reconnected transport.
+     * Sends the captured `initialize` request with a unique internal ID,
+     * waits for the response, then sends `notifications/initialized`.
+     */
+    async performReInitialize() {
+        if (!this.activeTransport || !this.initializeMessage) {
+            throw new Error('No transport or no captured initialize message');
+        }
+        const initId = `respl-init-${Date.now()}`;
+        // Build the re-initialize request using the original params but with our internal ID
+        const initRequest = {
+            ...this.initializeMessage,
+            id: initId,
+        };
+        const initPromise = new Promise((resolve) => {
+            this.pendingReInit = resolve;
+            setTimeout(() => {
+                if (this.pendingReInit) {
+                    this.pendingReInit = null;
+                    resolve(false); // Timeout
+                }
+            }, this.options.pingTimeoutMs);
+        });
+        try {
+            await this.activeTransport.send(initRequest);
+        }
+        catch (err) {
+            this.pendingReInit = null;
+            throw err;
+        }
+        const success = await initPromise;
+        if (!success) {
+            throw new Error('Re-initialize timed out');
+        }
+        // Send notifications/initialized if we captured it
+        if (this.initializedNotification) {
+            await this.activeTransport.send(this.initializedNotification);
+        }
+    }
     bindInnerTransport(transport) {
         transport.onclose = () => {
             // If the inner transport closes but we are not intentionally closed
@@ -148,6 +218,14 @@ export class ResilientTransportWrapper {
             }
         };
         transport.onmessage = (message) => {
+            // Intercept re-initialize responses (don't forward to Client)
+            if ('id' in message && typeof message.id === 'string' && message.id.startsWith('respl-init-')) {
+                if (this.pendingReInit) {
+                    this.pendingReInit(true);
+                    this.pendingReInit = null;
+                }
+                return;
+            }
             // 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);
@@ -239,16 +317,10 @@ export class ResilientTransportWrapper {
         }
     }
     /**
-     * Close the current transport and schedule a reconnect with exponential backoff.
+     * Detach handlers from and close the current active transport.
      */
-    triggerReconnect() {
-        if (this.state === 'reconnecting' || this.state === 'closed')
-            return;
-        this.state = 'reconnecting';
-        this.stopHeartbeat();
-        // Clean up old transport
+    cleanupTransport() {
         if (this.activeTransport) {
-            // Avoid triggering our own onclose
             this.activeTransport.onclose = undefined;
             this.activeTransport.onerror = undefined;
             try {
@@ -257,6 +329,16 @@ export class ResilientTransportWrapper {
             catch { /* ignore */ }
             this.activeTransport = null;
         }
+    }
+    /**
+     * Close the current transport and schedule a reconnect with exponential backoff.
+     */
+    triggerReconnect() {
+        if (this.state === 'reconnecting' || this.state === 'closed')
+            return;
+        this.state = 'reconnecting';
+        this.stopHeartbeat();
+        this.cleanupTransport();
         const delay = this.getBackoffDelay();
         this.retryAttempt++;
         this.log.warn(`[McpProxy] [ResilientTransport:${this.options.name}] 🔄 Closed. Retrying in ${delay}ms (attempt ${this.retryAttempt})...`);
@@ -301,6 +383,13 @@ export class ResilientTransportWrapper {
             this.messageQueue.push(message);
             return;
         }
+        // Capture initialize handshake messages for replay on reconnect
+        if ('method' in message) {
+            if (message.method === 'initialize')
+                this.initializeMessage = message;
+            else if (message.method === 'notifications/initialized')
+                this.initializedNotification = message;
+        }
         if (!this.activeTransport) {
             throw new Error('No active transport to send message');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuwax-mcp-stdio-proxy",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "description": "TypeScript MCP proxy — aggregates multiple MCP servers (stdio + streamable-http + SSE) with convert & proxy modes",
   "type": "module",
   "bin": {