@juspay/neurolink 12.7.6 → 12.7.8

package/dist/core/baseProvider.js

@@ -1260,7 +1260,18 @@ export class BaseProvider {
         // never enforced on this path, and enforcing them now would break
         // long-running generations that have always been allowed.
         const descriptorGenerateMs = PROVIDER_DESCRIPTORS_BY_NAME.get(this.providerName)?.timeouts?.generateMs;
-        const effectiveTimeout = options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000);
+        // An explicit, valid turnTimeoutMs is the caller's whole-turn contract
+        // and owns this hard abort; `timeout` then keeps its per-model-call
+        // meaning (it reaches the model layer via providerOptions.neurolink).
+        // Before this, `timeout` alone bounded the ENTIRE multi-step loop, so a
+        // caller asking for a 40-minute turn of 5-minute calls was killed at 5
+        // minutes flat — mid-loop, dressed as "Request was aborted.".
+        const hasValidTurnTimeout = typeof options.turnTimeoutMs === "number" &&
+            Number.isFinite(options.turnTimeoutMs) &&
+            options.turnTimeoutMs > 0;
+        const effectiveTimeout = hasValidTurnTimeout
+            ? options.turnTimeoutMs
+            : (options.timeout ?? Math.max(descriptorGenerateMs ?? 0, 180_000));
         const timeoutController = createTimeoutController(effectiveTimeout, this.providerName, "generate");
         const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
         const composedOptions = composedSignal
@@ -1270,6 +1281,24 @@ export class BaseProvider {
         try {
             generateResult = await this.executeGeneration(model, messages, tools, composedOptions);
         }
+        catch (error) {
+            // When OUR timer fired, provider SDKs typically normalize the abort
+            // into their own generic cancel shape (e.g. Anthropic's
+            // APIUserAbortError, "Request was aborted.") and discard the signal's
+            // reason. The TimeoutError on the signal is the honest identity —
+            // rethrow it so logs and abort classification see a timeout, not a
+            // caller cancel. A genuine caller abort (their signal fired) keeps its
+            // original shape even if our timer also expired in the race window.
+            const reason = timeoutController?.controller.signal.aborted
+                ? timeoutController.controller.signal.reason
+                : undefined;
+            if (reason instanceof TimeoutError &&
+                isAbortError(error) &&
+                options.abortSignal?.aborted !== true) {
+                throw reason;
+            }
+            throw error;
+        }
         finally {
             timeoutController?.cleanup();
         }

package/dist/mcp/externalServerManager.d.ts

@@ -13,6 +13,12 @@ export declare class ExternalServerManager extends EventEmitter {
     private servers;
     private config;
     private isShuttingDown;
+    /** Servers whose previous ping has not returned; the interval must not stack. */
+    private healthChecksInFlight;
+    /** Tool calls currently executing per server; a busy server is not a hung one. */
+    private inFlightToolCalls;
+    /** Consecutive pings missed while idle, per server. */
+    private unresponsiveChecks;
     private toolDiscovery;
     private enableMainRegistryIntegration;
     private hitlManager?;
@@ -94,6 +100,27 @@ export declare class ExternalServerManager extends EventEmitter {
      * Update server status and emit events
      */
     private updateServerStatus;
+    /**
+     * Hook the SDK client's lifecycle so the manager learns about the server
+     * dying from the object that actually owns the process.
+     *
+     * `client.onclose` fires when the stdio child closes or a network
+     * transport drops. It also fires during our own `stopServer()`, which is
+     * why every path into `handleConnectionLost` checks that the client is
+     * still the instance's current one and the status is still "connected":
+     * a close that arrives while stopping or restarting is intentional.
+     */
+    private attachClientLifecycle;
+    /**
+     * Transition a server whose connection is gone, exactly once.
+     *
+     * Reached from three places that can all observe the same death — the
+     * client's onclose, a failed health-check ping, and a tool call rejected
+     * with the SDK's connection-closed error — so it is idempotent on the
+     * (client, status) pair rather than trusting any one caller to be first.
+     */
+    private handleConnectionLost;
+    private trackToolCall;
     /**
      * Handle server errors
      */
@@ -111,7 +138,20 @@ export declare class ExternalServerManager extends EventEmitter {
      */
     private startHealthMonitoring;
     /**
-     * Perform health check on a server
+     * Perform a health check by pinging the server over its live transport.
+     *
+     * The previous check read `process.killed` — a flag Node sets only when we
+     * call `kill()` ourselves, on a process handle that was not even the
+     * server's — so it could never observe a server that died on its own.
+     *
+     * A ping that comes back with the SDK's connection-closed error is a
+     * definitive death and is handled immediately. A ping that merely times
+     * out is ambiguous: single-threaded servers (a Python MCP server running a
+     * synchronous tool) cannot answer while a tool call is executing, and
+     * restarting one mid-call would destroy the work in flight. So a timeout
+     * counts toward a restart only while the server has no tool call in
+     * flight, and only after UNRESPONSIVE_CHECKS_BEFORE_RESTART consecutive
+     * misses.
      */
     private performHealthCheck;
     /**

package/dist/mcp/externalServerManager.js

@@ -7,6 +7,7 @@
  * - Tool discovery and registration
  */
 import { EventEmitter } from "events";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { mcpLogger } from "../utils/logger.js";
 import { MCPClientFactory } from "./mcpClientFactory.js";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
@@ -47,6 +48,25 @@ function substituteEnvVariables(value) {
     }
     return value;
 }
+/**
+ * The two messages the MCP SDK produces when the transport underneath a
+ * request is gone: `Protocol._onclose` rejects every pending request with
+ * `MCP error -32000: Connection closed`, and `StdioClientTransport.send`
+ * throws a bare `Not connected` once the child has closed. Both are matched
+ * on the SDK's exact text so a tool's own error output that happens to
+ * mention a closed connection cannot be mistaken for the server dying.
+ */
+const CONNECTION_LOST_PATTERN = /^Not connected$|MCP error -32000: Connection closed/;
+function isConnectionLostError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return CONNECTION_LOST_PATTERN.test(message);
+}
+/**
+ * Consecutive idle health checks a server may fail to answer before it is
+ * treated as hung and restarted. Two, not one: a single missed ping right
+ * after a long tool call is the server draining its queue, not a wedge.
+ */
+const UNRESPONSIVE_CHECKS_BEFORE_RESTART = 2;
 /**
  * Sensitive CLI flag patterns whose following value should be masked in logs.
  */
@@ -193,6 +213,12 @@ export class ExternalServerManager extends EventEmitter {
     servers = new Map();
     config;
     isShuttingDown = false;
+    /** Servers whose previous ping has not returned; the interval must not stack. */
+    healthChecksInFlight = new Set();
+    /** Tool calls currently executing per server; a busy server is not a hung one. */
+    inFlightToolCalls = new Map();
+    /** Consecutive pings missed while idle, per server. */
+    unresponsiveChecks = new Map();
     toolDiscovery;
     enableMainRegistryIntegration;
     hitlManager; // Optional HITL manager for safety mechanisms
@@ -718,6 +744,7 @@ export class ExternalServerManager extends EventEmitter {
             const convertedInstance = {
                 config: finalInstance.config,
                 process: finalInstance.process,
+                pid: finalInstance.pid,
                 client: finalInstance.client,
                 transport: finalInstance.transportInstance,
                 status: finalInstance.status,
@@ -845,31 +872,16 @@ export class ExternalServerManager extends EventEmitter {
             instance.client = clientResult.client;
             instance.transportInstance = clientResult.transport;
             instance.process = clientResult.process || null;
+            instance.pid =
+                clientResult.transport instanceof StdioClientTransport
+                    ? (clientResult.transport.pid ?? undefined)
+                    : undefined;
             instance.capabilities = safeMetadataConversion(clientResult.capabilities);
             instance.startTime = new Date();
             instance.lastHealthCheck = new Date();
             instance.metrics.totalConnections++;
-            // Handle process events if there's a process
-            if (instance.process) {
-                instance.process.on("error", (error) => {
-                    mcpLogger.error(`[ExternalServerManager] Process error for ${serverId}:`, error);
-                    this.handleServerError(serverId, error);
-                });
-                instance.process.on("exit", (code, signal) => {
-                    mcpLogger.warn(`[ExternalServerManager] Process exited for ${serverId}`, {
-                        code,
-                        signal,
-                    });
-                    this.handleServerDisconnection(serverId, `Process exited with code ${code}`);
-                });
-                // Log stderr for debugging
-                instance.process.stderr?.on("data", (data) => {
-                    const message = data.toString().trim();
-                    if (message) {
-                        mcpLogger.debug(`[ExternalServerManager] ${serverId} stderr:`, message);
-                    }
-                });
-            }
+            this.unresponsiveChecks.delete(serverId);
+            this.attachClientLifecycle(serverId, clientResult.client, clientResult.transport);
             this.updateServerStatus(serverId, "connected");
             // Discover tools from the server
             await this.discoverServerTools(serverId);
@@ -938,10 +950,14 @@ export class ExternalServerManager extends EventEmitter {
             }
             // Clear server tools from discovery service
             this.toolDiscovery.clearServerTools(serverId);
-            // Close MCP client using factory cleanup
+            // Close MCP client using factory cleanup. This close is ours, not a
+            // crash: drop the lifecycle hooks first so the onclose it triggers
+            // cannot schedule a restart of a server we are deliberately stopping.
             if (instance.client && instance.transportInstance) {
+                instance.client.onclose = undefined;
+                instance.client.onerror = undefined;
                 try {
-                    await MCPClientFactory.closeClient(instance.client, instance.transportInstance, instance.process || undefined);
+                    await MCPClientFactory.closeClient(instance.client, instance.transportInstance);
                 }
                 catch (error) {
                     mcpLogger.debug(`[ExternalServerManager] Error closing client for ${serverId}:`, error);
@@ -949,6 +965,7 @@ export class ExternalServerManager extends EventEmitter {
                 instance.client = null;
                 instance.transportInstance = null;
                 instance.process = null;
+                instance.pid = undefined;
             }
             this.updateServerStatus(serverId, "stopped");
             span.setStatus({ code: SpanStatusCode.OK });
@@ -997,6 +1014,61 @@ export class ExternalServerManager extends EventEmitter {
         });
         mcpLogger.debug(`[ExternalServerManager] Status changed for ${serverId}: ${oldStatus} -> ${newStatus}`);
     }
+    /**
+     * Hook the SDK client's lifecycle so the manager learns about the server
+     * dying from the object that actually owns the process.
+     *
+     * `client.onclose` fires when the stdio child closes or a network
+     * transport drops. It also fires during our own `stopServer()`, which is
+     * why every path into `handleConnectionLost` checks that the client is
+     * still the instance's current one and the status is still "connected":
+     * a close that arrives while stopping or restarting is intentional.
+     */
+    attachClientLifecycle(serverId, client, transport) {
+        client.onclose = () => {
+            const instance = this.servers.get(serverId);
+            const pidNote = instance?.pid ? ` (pid ${instance.pid})` : "";
+            const stderrTail = MCPClientFactory.getStderrTail(transport);
+            const reason = stderrTail.length > 0
+                ? `Server process closed${pidNote}; last stderr: ${stderrTail.slice(-5).join(" | ")}`
+                : `Server process closed${pidNote}`;
+            this.handleConnectionLost(serverId, client, reason, stderrTail);
+        };
+        client.onerror = (error) => {
+            // Transport-level noise: a stdin EPIPE after the child died, a line on
+            // stdout that is not JSON-RPC. Diagnostic only — a fatal error is
+            // followed by onclose, and that is where state changes.
+            mcpLogger.warn(`[ExternalServerManager] Transport error for ${serverId}: ${error.message}`);
+        };
+    }
+    /**
+     * Transition a server whose connection is gone, exactly once.
+     *
+     * Reached from three places that can all observe the same death — the
+     * client's onclose, a failed health-check ping, and a tool call rejected
+     * with the SDK's connection-closed error — so it is idempotent on the
+     * (client, status) pair rather than trusting any one caller to be first.
+     */
+    handleConnectionLost(serverId, client, reason, stderrTail = []) {
+        const instance = this.servers.get(serverId);
+        if (!instance ||
+            instance.client !== client ||
+            instance.status !== "connected") {
+            return;
+        }
+        mcpLogger.warn(`[ExternalServerManager] Connection lost for ${serverId}: ${reason}`, stderrTail.length > 0 ? { stderrTail } : undefined);
+        instance.lastError = reason;
+        this.handleServerDisconnection(serverId, reason);
+    }
+    trackToolCall(serverId, delta) {
+        const next = (this.inFlightToolCalls.get(serverId) ?? 0) + delta;
+        if (next <= 0) {
+            this.inFlightToolCalls.delete(serverId);
+        }
+        else {
+            this.inFlightToolCalls.set(serverId, next);
+        }
+    }
     /**
      * Handle server errors
      */
@@ -1114,21 +1186,62 @@ export class ExternalServerManager extends EventEmitter {
         }, interval);
     }
     /**
-     * Perform health check on a server
+     * Perform a health check by pinging the server over its live transport.
+     *
+     * The previous check read `process.killed` — a flag Node sets only when we
+     * call `kill()` ourselves, on a process handle that was not even the
+     * server's — so it could never observe a server that died on its own.
+     *
+     * A ping that comes back with the SDK's connection-closed error is a
+     * definitive death and is handled immediately. A ping that merely times
+     * out is ambiguous: single-threaded servers (a Python MCP server running a
+     * synchronous tool) cannot answer while a tool call is executing, and
+     * restarting one mid-call would destroy the work in flight. So a timeout
+     * counts toward a restart only while the server has no tool call in
+     * flight, and only after UNRESPONSIVE_CHECKS_BEFORE_RESTART consecutive
+     * misses.
      */
     async performHealthCheck(serverId) {
         const instance = this.servers.get(serverId);
-        if (!instance || instance.status !== "connected") {
+        if (!instance || instance.status !== "connected" || !instance.client) {
+            return;
+        }
+        if (this.healthChecksInFlight.has(serverId)) {
             return;
         }
+        this.healthChecksInFlight.add(serverId);
+        const client = instance.client;
+        const interval = instance.config.healthCheckInterval ??
+            this.config.defaultHealthCheckInterval;
+        const pingTimeoutMs = Math.max(1, Math.min(instance.config.timeout || this.config.defaultTimeout, interval));
         const startTime = Date.now();
+        const issues = [];
+        let isHealthy = true;
+        let connectionLost = false;
+        let unresponsive = false;
         try {
-            // For now, simple process check
-            let isHealthy = true;
-            const issues = [];
-            if (instance.process && instance.process.killed) {
+            try {
+                await client.ping({ timeout: pingTimeoutMs });
+                this.unresponsiveChecks.delete(serverId);
+            }
+            catch (error) {
                 isHealthy = false;
-                issues.push("Process is killed");
+                if (isConnectionLostError(error)) {
+                    connectionLost = true;
+                    issues.push("connection closed");
+                }
+                else {
+                    const inFlight = this.inFlightToolCalls.get(serverId) ?? 0;
+                    if (inFlight > 0) {
+                        issues.push(`ping timed out after ${pingTimeoutMs}ms while ${inFlight} tool call(s) in flight`);
+                    }
+                    else {
+                        const misses = (this.unresponsiveChecks.get(serverId) ?? 0) + 1;
+                        this.unresponsiveChecks.set(serverId, misses);
+                        issues.push(`ping timed out after ${pingTimeoutMs}ms while idle (${misses}/${UNRESPONSIVE_CHECKS_BEFORE_RESTART})`);
+                        unresponsive = misses >= UNRESPONSIVE_CHECKS_BEFORE_RESTART;
+                    }
+                }
             }
             const responseTime = Date.now() - startTime;
             instance.lastHealthCheck = new Date();
@@ -1154,14 +1267,18 @@ export class ExternalServerManager extends EventEmitter {
                 health,
                 timestamp: new Date(),
             });
-            if (!isHealthy) {
+            if (connectionLost || unresponsive) {
+                this.handleConnectionLost(serverId, client, `Health check failed: ${issues.join(", ")}`);
+            }
+            else if (!isHealthy) {
                 mcpLogger.warn(`[ExternalServerManager] Health check failed for ${serverId}:`, issues);
-                this.handleServerError(serverId, new Error(`Health check failed: ${issues.join(", ")}`));
             }
         }
         catch (error) {
             mcpLogger.error(`[ExternalServerManager] Health check error for ${serverId}:`, error);
-            this.handleServerError(serverId, error instanceof Error ? error : new Error(String(error)));
+        }
+        finally {
+            this.healthChecksInFlight.delete(serverId);
         }
     }
     /**
@@ -1175,6 +1292,7 @@ export class ExternalServerManager extends EventEmitter {
         return {
             config: runtime.config,
             process: runtime.process,
+            pid: runtime.pid,
             client: runtime.client,
             transport: runtime.transportInstance,
             status: runtime.status,
@@ -1200,6 +1318,7 @@ export class ExternalServerManager extends EventEmitter {
             converted.set(serverId, {
                 config: runtime.config,
                 process: runtime.process,
+                pid: runtime.pid,
                 client: runtime.client,
                 transport: runtime.transportInstance,
                 status: runtime.status,
@@ -1427,7 +1546,8 @@ export class ExternalServerManager extends EventEmitter {
         if (!instance) {
             throw new Error(`Server '${serverId}' not found`);
         }
-        if (!instance.client) {
+        const client = instance.client;
+        if (!client) {
             throw new Error(`Server '${serverId}' is not connected`);
         }
         if (instance.status !== "connected") {
@@ -1487,11 +1607,18 @@ export class ExternalServerManager extends EventEmitter {
                 }
             }
             // Execute tool through discovery service (with potentially modified parameters)
-            const result = await this.toolDiscovery.executeTool(toolName, serverId, instance.client, finalParameters, {
-                timeout: options?.timeout ||
-                    instance.config.timeout ||
-                    this.config.defaultTimeout,
-            });
+            this.trackToolCall(serverId, 1);
+            let result;
+            try {
+                result = await this.toolDiscovery.executeTool(toolName, serverId, client, finalParameters, {
+                    timeout: options?.timeout ||
+                        instance.config.timeout ||
+                        this.config.defaultTimeout,
+                });
+            }
+            finally {
+                this.trackToolCall(serverId, -1);
+            }
             const duration = Date.now() - startTime;
             // Update metrics
             instance.metrics.totalToolCalls++;
@@ -1528,6 +1655,12 @@ export class ExternalServerManager extends EventEmitter {
                 /* telemetry should not break execution */
             }
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
+            // The SDK rejects with its connection-closed error when the server is
+            // gone. Without this transition the instance stayed "connected" and
+            // every later call failed the same way with no restart ever scheduled.
+            if (isConnectionLostError(error)) {
+                this.handleConnectionLost(serverId, client, `Connection lost during tool call '${toolName}': ${error instanceof Error ? error.message : String(error)}`);
+            }
             throw error;
         }
     }

package/dist/mcp/mcpClientFactory.d.ts

@@ -7,7 +7,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
-import { type ChildProcess } from "child_process";
+import type { ChildProcess } from "child_process";
 import type { MCPTransportType, MCPServerInfo, MCPClientResult } from "../types/index.js";
 /**
  * MCPClientFactory
@@ -25,12 +25,34 @@ export declare class MCPClientFactory {
      * Internal client creation logic
      */
     private static createClientInternal;
+    /**
+     * The most recent stderr lines written by the stdio server behind
+     * `transport`. Empty for network transports and for servers that have
+     * written nothing. Lines are captured from before the process is even
+     * started, so an early boot failure is included.
+     */
+    static getStderrTail(transport: Transport): string[];
     /**
      * Create transport based on configuration
      */
     private static createTransport;
     /**
-     * Create stdio transport with process spawning
+     * Create a stdio transport.
+     *
+     * The SDK's StdioClientTransport owns the server process: it spawns the
+     * child inside `client.connect()` and reports the child's death through
+     * `transport.onclose`, which the Client forwards as `client.onclose`. There
+     * is deliberately no `spawn()` here. An earlier "startup probe" launched
+     * the command a second time, and that duplicate — never spoken to, never
+     * closed — was the process every lifecycle hook ended up watching while
+     * the real server could die unnoticed. It also leaked as an orphan on
+     * every shutdown.
+     *
+     * stderr is piped rather than ignored so a crashing server's last lines
+     * survive to the disconnect log and the connect error. A pipe nobody reads
+     * would back-pressure the child once the buffer fills, so the tail
+     * listener is attached before `start()`; the SDK creates the stderr
+     * PassThrough in its constructor for exactly this reason.
      */
     private static createStdioTransport;
     /**