@juspay/neurolink 13.8.0 → 13.8.2

package/dist/core/redisConversationMemoryManager.js

@@ -539,9 +539,6 @@ export class RedisConversationMemoryManager {
                         messageCount: conversation.messages.length,
                     });
                 }
-                if (this.redisConfig.ttl > 0) {
-                    await this.redisClient.expire(redisKey, this.redisConfig.ttl);
-                }
                 if (options.userId) {
                     await this.addUserSession(options.userId, options.sessionId);
                 }

package/dist/mcp/externalServerManager.js

@@ -8,7 +8,7 @@
  */
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
-import { MCPClientFactory } from "./mcpClientFactory.js";
+import { MCPClientFactory, terminateStartingStdioServers, } from "./mcpClientFactory.js";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
 import { toolRegistry } from "./toolRegistry.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
@@ -372,6 +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();
             process.kill(process.pid, signal);
         }
     });

package/dist/mcp/mcpClientFactory.d.ts

@@ -9,6 +9,12 @@ 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 { MCPTransportType, MCPServerInfo, MCPClientResult } from "../types/index.js";
+/**
+ * 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 declare const terminateStartingStdioServers: () => void;
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports

package/dist/mcp/mcpClientFactory.js

@@ -62,6 +62,48 @@ class StderrTail {
     }
 }
 const stderrTails = new WeakMap();
+/**
+ * Stdio servers that have been spawned but have not yet answered `initialize`.
+ *
+ * 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.
+ */
+const startingStdioTransports = new Set();
+let startingStdioExitHookInstalled = 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) {
+        if ("pid" in transport && typeof transport.pid === "number") {
+            try {
+                process.kill(transport.pid, "SIGTERM");
+            }
+            catch {
+                // Already gone.
+            }
+        }
+    }
+};
+const trackStartingStdioTransport = (transport) => {
+    if (!startingStdioExitHookInstalled) {
+        startingStdioExitHookInstalled = true;
+        process.on("exit", terminateStartingStdioServers);
+    }
+    startingStdioTransports.add(transport);
+    // Client.connect() chains an onclose that is already set rather than
+    // replacing it, and a spawn that fails still closes the transport.
+    transport.onclose = () => {
+        startingStdioTransports.delete(transport);
+    };
+};
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -223,6 +265,7 @@ 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}`, {
@@ -318,6 +361,7 @@ export class MCPClientFactory {
             cwd: config.cwd,
             stderr: "pipe",
         });
+        trackStartingStdioTransport(transport);
         const tail = new StderrTail();
         stderrTails.set(transport, tail);
         transport.stderr?.on("data", (chunk) => {

package/dist/neurolink.js

@@ -8993,8 +8993,6 @@ Current user's request: ${currentInput}`;
     async prepareStreamOptions(options, streamId, startTime, hrTimeStart) {
         // Initialize conversation memory if needed (for lazy loading)
         await this.initializeConversationMemoryForGeneration(streamId, startTime, hrTimeStart);
-        // Initialize MCP
-        await this.initializeMCP();
         // Memory retrieval
         if (this.shouldReadMemory(options.memory, options.context?.userId) &&
             options.context?.userId) {
@@ -9042,6 +9040,15 @@ Current user's request: ${currentInput}`;
         }
         // Auto-disable tools for Ollama models that don't support them
         await this.autoDisableOllamaStreamTools(options);
+        // generate() skips MCP when tools are disabled, so stream() must too:
+        // initialization loads the working directory's .mcp-config.json and waits
+        // for every stdio server it names before the request is sent, so an
+        // `npx -y …` entry on a slow npm registry stalls a stream that never
+        // needed a tool. Decided after the Ollama check above, which can turn
+        // tools off. Providers register themselves in AIProviderFactory.
+        if (!options.disableTools) {
+            await this.initializeMCP();
+        }
         // RAG Integration: If rag config is provided, prepare the RAG search tool
         if (options.rag?.files?.length) {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "13.8.0",
+  "version": "13.8.2",
   "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": {