@juspay/neurolink 13.8.4 → 13.8.6

package/dist/mcp/externalServerManager.js

@@ -8,7 +8,7 @@
  */
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
-import { MCPClientFactory, terminateStartingStdioServers, } from "./mcpClientFactory.js";
+import { MCPClientFactory, terminateLiveStdioServers, } from "./mcpClientFactory.js";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
 import { toolRegistry } from "./toolRegistry.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
@@ -372,9 +372,9 @@ const shutdownOnSignal = (signal) => {
         // re-raise and nowhere else.
         if (!hadOtherListeners) {
             process.removeListener(signal, shutdownOnSignal);
-            // Dying of a signal runs no `exit` handler, and the cleanup above cannot
-            // reach a server whose handshake is still pending.
-            terminateStartingStdioServers();
+            // Dying of a signal runs no `exit` handler, and the cleanup above reaches
+            // only the servers a manager has recorded and that close when asked.
+            terminateLiveStdioServers();
             process.kill(process.pid, signal);
         }
     });

package/dist/mcp/mcpClientFactory.d.ts

@@ -14,7 +14,7 @@ import type { MCPTransportType, MCPServerInfo, MCPClientResult } from "../types/
  * `exit` event, and SIGTERM is delivered by the kernel even though this
  * process is already on its way out.
  */
-export declare const terminateStartingStdioServers: () => void;
+export declare const terminateLiveStdioServers: () => void;
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports

package/dist/mcp/mcpClientFactory.js

@@ -63,25 +63,29 @@ class StderrTail {
 }
 const stderrTails = new WeakMap();
 /**
- * Stdio servers that have been spawned but have not yet answered `initialize`.
+ * Stdio servers this process has spawned and has not yet seen close.
  *
- * Nothing that cleans up at exit can reach one: the manager learns of a client
- * and its transport only when `connect()` returns, and `process.exit()` runs
- * no async handler anyway. It is also the state a server is least likely to
- * notice its host going away, because `npx -y <pkg>` does not read its stdin
- * until the package has downloaded. Once a server has answered it is an
- * ordinary MCP server again and ends when its stdin closes, so it leaves this
- * set and the shutdown paths that already exist keep ownership of it.
+ * A transport is tracked from creation to close, not only until the server
+ * answers `initialize`, because two things leave a server running with nothing
+ * to stop it. Until the manager records the client, which happens only after
+ * `connect()` and the handshake, no shutdown path knows the server exists, and
+ * `npx -y <pkg>` does not read its stdin until the package has downloaded.
+ * After that, a server holding a timer, a connection pool or a file watcher
+ * ignores its stdin closing, and `process.exit()` runs neither `beforeExit`
+ * nor the manager's async shutdown.
+ *
+ * `transport.close()` takes a transport out through `onclose` once the child
+ * has exited, so a server the manager closed is not signalled again.
  */
-const startingStdioTransports = new Set();
-let startingStdioExitHookInstalled = false;
+const liveStdioTransports = new Set();
+let stdioExitHookInstalled = false;
 /**
  * Synchronous on purpose: it is the one thing that can run inside the
  * `exit` event, and SIGTERM is delivered by the kernel even though this
  * process is already on its way out.
  */
-export const terminateStartingStdioServers = () => {
-    for (const transport of startingStdioTransports) {
+export const terminateLiveStdioServers = () => {
+    for (const transport of liveStdioTransports) {
         if ("pid" in transport && typeof transport.pid === "number") {
             try {
                 process.kill(transport.pid, "SIGTERM");
@@ -92,16 +96,18 @@ export const terminateStartingStdioServers = () => {
         }
     }
 };
-const trackStartingStdioTransport = (transport) => {
-    if (!startingStdioExitHookInstalled) {
-        startingStdioExitHookInstalled = true;
-        process.on("exit", terminateStartingStdioServers);
+const trackStdioTransport = (transport) => {
+    if (!stdioExitHookInstalled) {
+        stdioExitHookInstalled = true;
+        process.on("exit", terminateLiveStdioServers);
     }
-    startingStdioTransports.add(transport);
+    liveStdioTransports.add(transport);
     // Client.connect() chains an onclose that is already set rather than
-    // replacing it, and a spawn that fails still closes the transport.
+    // replacing it, and the manager listens on client.onclose, so this one
+    // survives for the life of the connection. A spawn that fails still closes
+    // the transport.
     transport.onclose = () => {
-        startingStdioTransports.delete(transport);
+        liveStdioTransports.delete(transport);
     };
 };
 /**
@@ -265,7 +271,6 @@ export class MCPClientFactory {
             }
             // Connect with timeout
             await this.raceWithTimeout(client.connect(transport, { timeout }), timeout, `Client connection timeout for ${config.id}`);
-            startingStdioTransports.delete(transport);
             // Perform handshake to get server capabilities
             const serverCapabilities = await this.performHandshake(client, timeout);
             mcpLogger.debug(`[MCPClientFactory] Handshake completed for ${config.id}`, {
@@ -361,7 +366,7 @@ export class MCPClientFactory {
             cwd: config.cwd,
             stderr: "pipe",
         });
-        trackStartingStdioTransport(transport);
+        trackStdioTransport(transport);
         const tail = new StderrTail();
         stderrTails.set(transport, tail);
         transport.stderr?.on("data", (chunk) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "13.8.4",
+  "version": "13.8.6",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {