@juspay/neurolink 12.49.15 → 12.49.17

package/dist/mcp/mcpClientFactory.js

@@ -82,6 +82,10 @@ export class MCPClientFactory {
      * Enhanced with retry logic, rate limiting, and circuit breaker protection
      */
     static async createClient(config, timeout = DEFAULT_CLIENT_TIMEOUT) {
+        const connectionTimeout = config.httpOptions?.connectionTimeout;
+        if (connectionTimeout !== undefined) {
+            timeout = Math.min(timeout, connectionTimeout);
+        }
         const startTime = Date.now();
         const { traceId, parentSpanId } = getActiveTraceContext();
         const obsSpan = SpanSerializer.createSpan(SpanType.MCP_TRANSPORT, "mcp.connect", {
@@ -208,8 +212,17 @@ export class MCPClientFactory {
             const client = new Client(this.NEUROLINK_IMPLEMENTATION, {
                 capabilities: this.DEFAULT_CAPABILITIES,
             });
+            const requestTimeout = config.httpOptions?.requestTimeout;
+            if (requestTimeout !== undefined) {
+                const request = client.request.bind(client);
+                client.request = (payload, resultSchema, options) => request(payload, resultSchema, {
+                    ...options,
+                    timeout: Math.min(requestTimeout, options?.timeout ?? requestTimeout),
+                    maxTotalTimeout: Math.min(requestTimeout, options?.maxTotalTimeout ?? requestTimeout),
+                });
+            }
             // Connect with timeout
-            await this.raceWithTimeout(client.connect(transport), timeout, `Client connection timeout for ${config.id}`);
+            await this.raceWithTimeout(client.connect(transport, { timeout }), timeout, `Client connection timeout for ${config.id}`);
             // Perform handshake to get server capabilities
             const serverCapabilities = await this.performHandshake(client, timeout);
             mcpLogger.debug(`[MCPClientFactory] Handshake completed for ${config.id}`, {
@@ -331,7 +344,13 @@ export class MCPClientFactory {
         try {
             const url = new URL(config.url);
             const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
-            const transport = new SSEClientTransport(url);
+            const transportFetch = this.createEnhancedFetch(config, config.httpOptions?.requestTimeout ?? 60000);
+            const transport = new SSEClientTransport(url, {
+                requestInit: { headers: config.headers },
+                fetch: transportFetch,
+                // EventSource prefers this fetch over the transport-level hook for GET.
+                eventSourceInit: { fetch: transportFetch },
+            });
             return { transport };
         }
         catch (error) {
@@ -415,12 +434,25 @@ export class MCPClientFactory {
     /**
      * Create a fetch wrapper with timeout support
      */
-    static createFetchWithTimeout(timeoutMs) {
+    static createFetchWithTimeout(timeoutMs, transportFetch) {
         return async (input, init) => {
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
             try {
-                return await fetch(input, { ...init, signal: controller.signal });
+                const response = await transportFetch(input, {
+                    ...init,
+                    // EventSource requests "follow"; enforcing this here covers its GET
+                    // as well as MCP POSTs and prevents credentials crossing a redirect.
+                    redirect: "manual",
+                    signal: init?.signal
+                        ? AbortSignal.any([controller.signal, init.signal])
+                        : controller.signal,
+                });
+                if (response.status >= 300 && response.status < 400) {
+                    await response.body?.cancel();
+                    throw new Error("MCP transport redirects are not permitted");
+                }
+                return response;
             }
             finally {
                 clearTimeout(timeoutId);
@@ -431,7 +463,7 @@ export class MCPClientFactory {
      * Create an enhanced fetch function with timeout and optional retry
      */
     static createEnhancedFetch(config, timeoutMs, oauthProvider) {
-        const fetchWithTimeout = this.createFetchWithTimeout(timeoutMs);
+        const fetchWithTimeout = this.createFetchWithTimeout(timeoutMs, config.fetch ?? globalThis.fetch);
         return async (input, init) => {
             // If OAuth is configured, ensure we have valid tokens
             if (oauthProvider && config.auth?.type === "oauth2") {

package/dist/mcp/toolDiscoveryService.d.ts

@@ -28,8 +28,10 @@ export declare class ToolDiscoveryService extends EventEmitter {
     setOutputNormalizer(normalizer: McpOutputNormalizer): void;
     /**
      * Discover tools from an external MCP server
+     * Startup probes use the fresh connection directly under the same operation
+     * deadline, so an ordinary discovery cooldown cannot exhaust reconnects.
      */
-    discoverTools(serverId: string, client: Client, timeout?: number): Promise<ToolDiscoveryResult>;
+    discoverTools(serverId: string, client: Client, timeout?: number, isCurrentDiscovery?: () => boolean, startupDiscovery?: boolean): Promise<ToolDiscoveryResult>;
     /**
      * Perform the actual tool discovery
      */

package/dist/mcp/toolDiscoveryService.js

@@ -106,15 +106,21 @@ export class ToolDiscoveryService extends EventEmitter {
     }
     /**
      * Discover tools from an external MCP server
+     * Startup probes use the fresh connection directly under the same operation
+     * deadline, so an ordinary discovery cooldown cannot exhaust reconnects.
      */
-    async discoverTools(serverId, client, timeout = DEFAULT_TOOL_TIMEOUT) {
+    async discoverTools(serverId, client, timeout = DEFAULT_TOOL_TIMEOUT, isCurrentDiscovery = () => true, startupDiscovery = false) {
         return withSpan({
             name: "neurolink.mcp.discoverTools",
             tracer: tracers.mcp,
             attributes: { "mcp.server_id": serverId },
         }, async (span) => {
             const startTime = Date.now();
+            let ownsDiscovery = false;
             try {
+                if (!isCurrentDiscovery()) {
+                    throw new Error(`Discovery owner for '${serverId}' is no longer current`);
+                }
                 // Prevent concurrent discovery for same server
                 if (this.discoveryInProgress.has(serverId)) {
                     return {
@@ -127,19 +133,23 @@ export class ToolDiscoveryService extends EventEmitter {
                     };
                 }
                 this.discoveryInProgress.add(serverId);
+                ownsDiscovery = true;
                 mcpLogger.info(`[ToolDiscoveryService] Starting tool discovery for server: ${serverId}`);
-                // Create circuit breaker for tool discovery
-                const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-discovery-${serverId}`, {
-                    failureThreshold: 2,
-                    resetTimeout: 60000,
-                    operationTimeout: timeout,
-                });
-                // Discover tools with circuit breaker protection
-                const tools = await circuitBreaker.execute(async () => {
-                    return await this.performToolDiscovery(serverId, client, timeout);
-                });
+                const discover = () => this.performToolDiscovery(serverId, client, timeout);
+                // A new connection must get its bounded readiness probe even while
+                // the ordinary discovery breaker is cooling down. Its transport and
+                // operation deadlines still apply; real failures still reject startup.
+                const tools = startupDiscovery
+                    ? await discover()
+                    : await globalCircuitBreakerManager
+                        .getBreaker(`tool-discovery-${serverId}`, {
+                        failureThreshold: 2,
+                        resetTimeout: 60000,
+                        operationTimeout: timeout,
+                    })
+                        .execute(discover);
                 // Register discovered tools
-                const registeredTools = await this.registerDiscoveredTools(serverId, tools);
+                const registeredTools = await this.registerDiscoveredTools(serverId, tools, isCurrentDiscovery);
                 span.setAttribute("mcp.tools_discovered", registeredTools.length);
                 const result = {
                     success: true,
@@ -182,7 +192,9 @@ export class ToolDiscoveryService extends EventEmitter {
                 };
             }
             finally {
-                this.discoveryInProgress.delete(serverId);
+                if (ownsDiscovery) {
+                    this.discoveryInProgress.delete(serverId);
+                }
             }
         });
     }
@@ -201,13 +213,19 @@ export class ToolDiscoveryService extends EventEmitter {
     /**
      * Register discovered tools
      */
-    async registerDiscoveredTools(serverId, tools) {
+    async registerDiscoveredTools(serverId, tools, isCurrentDiscovery) {
         const registeredTools = [];
+        if (!isCurrentDiscovery()) {
+            throw new Error(`Discovery owner for '${serverId}' is no longer current`);
+        }
         // Clear existing tools for this server
         this.clearServerTools(serverId);
         for (const tool of tools) {
             try {
                 const toolInfo = await this.createToolInfo(serverId, tool);
+                if (!isCurrentDiscovery()) {
+                    throw new Error(`Discovery owner for '${serverId}' is no longer current`);
+                }
                 const validation = this.validateTool(toolInfo);
                 if (!validation.isValid) {
                     mcpLogger.warn(`[ToolDiscoveryService] Skipping invalid tool ${tool.name} from ${serverId}:`, validation.errors);
@@ -232,11 +250,7 @@ export class ToolDiscoveryService extends EventEmitter {
                 }
                 // Add tool if not already present
                 if (!serverTools.find((t) => t.name === tool.name)) {
-                    serverTools.push({
-                        name: tool.name,
-                        description: tool.description || "",
-                        inputSchema: tool.inputSchema,
-                    });
+                    serverTools.push(toolInfo);
                 }
                 // Track server tools (legacy)
                 if (!this.serverTools.has(serverId)) {
@@ -257,9 +271,15 @@ export class ToolDiscoveryService extends EventEmitter {
                 mcpLogger.debug(`[ToolDiscoveryService] Registered tool: ${tool.name} from ${serverId}`);
             }
             catch (error) {
+                if (!isCurrentDiscovery()) {
+                    throw error;
+                }
                 mcpLogger.error(`[ToolDiscoveryService] Failed to register tool ${tool.name} from ${serverId}:`, error);
             }
         }
+        if (!isCurrentDiscovery()) {
+            throw new Error(`Discovery owner for '${serverId}' is no longer current`);
+        }
         return registeredTools;
     }
     /**
@@ -271,6 +291,7 @@ export class ToolDiscoveryService extends EventEmitter {
             description: tool.description || "No description provided",
             serverId,
             inputSchema: tool.inputSchema,
+            ...(tool.annotations ? { annotations: { ...tool.annotations } } : {}),
             isAvailable: true,
             stats: {
                 totalCalls: 0,
@@ -782,6 +803,7 @@ export class ToolDiscoveryService extends EventEmitter {
                 description: tool.description,
                 serverId,
                 inputSchema: tool.inputSchema,
+                ...(tool.annotations ? { annotations: { ...tool.annotations } } : {}),
                 isAvailable: true,
                 stats: {
                     totalCalls: 0,
@@ -819,6 +841,7 @@ export class ToolDiscoveryService extends EventEmitter {
                     description: tool.description,
                     serverId,
                     inputSchema: tool.inputSchema,
+                    ...(tool.annotations ? { annotations: { ...tool.annotations } } : {}),
                     isAvailable: true,
                     stats: {
                         totalCalls: 0,

package/dist/neurolink.d.ts

@@ -6,7 +6,7 @@
  * Uses real MCP infrastructure for tool discovery and execution.
  */
 import type { DecisionCallerOptions, DecisionLimitsQuery, DecisionLimitsReading, DecisionOptions, DecisionResult, AgentDefinition, AgentNetworkConfig, AgentRunOptions, AgentRunOutcome, AgentToolRegistrationOptions, IsolatedAgentDefinition, NetworkExecutionInput, NetworkExecutionOptions, NetworkExecutionResult, NetworkStreamChunk, WorkerInstanceOptions } from "./types/index.js";
-import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, ArtifactStore, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult, StreamGenerationEndContext, ToolRoutingServerDescriptor, ToolDedupConfig, ToolConfig, KnowledgeEngineStatus, ChecklistState, ArtifactPageRequest, BankArtifactOptions, BankedArtifactRef, DelegateCollectRequest, DelegateCollectResult, DelegateHandle, DelegateRegistrationOptions, DelegateSpawnOptions, BackgroundCommandHandle, BackgroundCommandOptions, BackgroundCommandOutputPage, BackgroundCommandPageRequest, BackgroundCommandPolicy, BackgroundCommandStatus, GitToolResult, GitToolsetOptions } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
@@ -2150,6 +2150,7 @@ export declare class NeuroLink {
      * List all external MCP servers
      * @returns Array of server health information
      */
+    getExternalMCPServerHealth(): ExternalMCPServerHealth[];
     listExternalMCPServers(): Array<{
         serverId: string;
         status: string;

package/dist/neurolink.js

@@ -2306,6 +2306,9 @@ Current user's request: ${currentInput}`;
      * Setup event handlers for external server manager
      */
     setupExternalServerEventHandlers(constructorId) {
+        this.externalServerManager.on("healthCheck", (event) => {
+            this.emitter.emit("externalMCP:serverHealth", event);
+        });
         this.externalServerManager.on("connected", (event) => {
             logger.debug(`[NeuroLink] 🔗 EXTERNAL_SERVER_EVENT_CONNECTED`, {
                 constructorId,
@@ -12812,6 +12815,9 @@ Current user's request: ${currentInput}`;
      * List all external MCP servers
      * @returns Array of server health information
      */
+    getExternalMCPServerHealth() {
+        return this.externalServerManager.getServerStatuses();
+    }
     listExternalMCPServers() {
         const serverStatuses = this.externalServerManager.getServerStatuses();
         const allServers = this.externalServerManager.listServers();

package/dist/types/externalMcp.d.ts

@@ -10,7 +10,7 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 /**
  * Supported MCP transport protocols - imported from mcpTypes.js (canonical definition)
  */
-import type { MCPTransportType, MCPServerInfo, MCPServerReadiness } from "./mcp.js";
+import type { MCPTransportType, MCPServerInfo, MCPServerReadiness, MCPToolAnnotations } from "./mcp.js";
 export type { MCPTransportType } from "./mcp.js";
 /**
  * External MCP server configuration for process spawning
@@ -40,6 +40,8 @@ export type ExternalMCPServerConfig = {
     url?: string;
     /** HTTP headers for authentication and configuration (HTTP/SSE/WebSocket) */
     headers?: Record<string, string>;
+    /** Trusted HTTP/SSE egress hook, retained for every connection and request. */
+    fetch?: typeof globalThis.fetch;
     /** List of tool names to block/blacklist from this server */
     blockedTools?: string[];
     /** Additional metadata */
@@ -114,6 +116,8 @@ export type ExternalMCPToolInfo = {
     serverId: string;
     /** Input schema (JSON Schema) */
     inputSchema?: JsonObject;
+    /** Server-supplied behavior hints; absent annotations remain absent. */
+    annotations?: MCPToolAnnotations;
     /** Whether the tool is currently available */
     isAvailable: boolean;
     /** Tool metadata */
@@ -147,6 +151,12 @@ export type ExternalMCPServerHealth = {
     toolCount: number;
     /** Any health issues detected */
     issues: string[];
+    /** Consecutive failed connections or live health checks, reset on recovery. */
+    consecutiveFailures?: number;
+    /** Most recent connection/health error, absent after successful recovery. */
+    lastError?: string;
+    /** Next automatic retry deadline, absent when no retry is scheduled. */
+    nextRetryAt?: Date;
     /** Performance metrics */
     performance: {
         uptime: number;

package/dist/types/hitl.d.ts

@@ -22,6 +22,8 @@ export type HITLConfig = {
     allowArgumentModification?: boolean;
     /** Auto-approve requests when they timeout (default: false - rejects on timeout) */
     autoApproveOnTimeout?: boolean;
+    /** Exact tool names that require an explicit answer even when timeout auto-approval is enabled. */
+    autoApproveExclusions?: string[];
     /** Enable audit logging for compliance and debugging (default: false) */
     auditLogging?: boolean;
     /** Advanced custom rules for complex tool scenarios (default: []) */

package/dist/types/mcp.d.ts

@@ -54,6 +54,12 @@ export type MCPServerInfo = {
     env?: Record<string, string>;
     url?: string;
     headers?: Record<string, string>;
+    /**
+     * Trusted host-provided fetch for HTTP and SSE, including reconnects and tool
+     * calls. Use a guarded, DNS-pinned dispatcher for untrusted server URLs.
+     * Programmatic only: functions cannot be persisted in JSON configuration.
+     */
+    fetch?: typeof globalThis.fetch;
     /** HTTP transport-specific options */
     httpOptions?: MCPHTTPTransportOptions;
     timeout?: number;
@@ -132,12 +138,12 @@ export type MCPServerInfo = {
     };
 };
 /**
- * HTTP Transport Options for fine-grained control
+ * Transport deadlines (all transports), plus HTTP connection-pool options
  */
 export type MCPHTTPTransportOptions = {
-    /** Connection timeout in milliseconds (default: 30000) */
+    /** Explicit connection cap in milliseconds for every transport; absent retains the server/client startup budget. */
     connectionTimeout?: number;
-    /** Request timeout in milliseconds (default: 60000) */
+    /** Explicit whole-request cap in milliseconds for every transport; absent retains caller/server RPC limits (HTTP fetch defaults are separate). */
     requestTimeout?: number;
     /** Idle timeout for connection pool (default: 120000) */
     idleTimeout?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.49.15",
+  "version": "12.49.17",
   "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": {
@@ -83,6 +83,9 @@
     "test:harness-offline-timeout": "pnpm exec tsx test/continuous-test-suite-harness-offline-timeout.ts",
     "test:resolve-request-kind": "pnpm exec tsx test/continuous-test-suite-resolve-request-kind.ts",
     "test:mcp": "pnpm exec tsx test/continuous-test-suite-mcp-infra.ts",
+    "test:mcp:egress": "pnpm exec tsx test/continuous-test-suite-mcp-egress.ts",
+    "test:mcp:deadline-health": "pnpm exec tsx test/continuous-test-suite-mcp-deadline-health.ts",
+    "test:mcp:timeout-compat": "pnpm exec tsx test/continuous-test-suite-mcp-timeout-compat.ts",
     "test:tool-resolution": "pnpm exec tsx test/continuous-test-suite-tool-resolution.ts",
     "test:mcp:http": "pnpm exec tsx test/continuous-test-suite-mcp-http.ts",
     "test:mcp:sdk": "pnpm exec tsx test/continuous-test-suite-mcp-sdk.ts",
@@ -188,6 +191,7 @@
     "test:json-e2e": "pnpm exec tsx test/continuous-test-suite-json-e2e.ts",
     "test:workflow": "pnpm exec tsx test/continuous-test-suite-workflow.ts",
     "test:hitl": "pnpm exec tsx test/continuous-test-suite-hitl.ts",
+    "test:hitl:timeout-exclusions": "pnpm exec tsx test/continuous-test-suite-hitl-timeout-exclusions.ts",
     "test:tasks": "pnpm exec tsx test/continuous-test-suite-tasks.ts",
     "test:auth": "pnpm exec tsx test/continuous-test-suite-auth.ts",
     "test:autoresearch": "pnpm exec tsx test/continuous-test-suite-autoresearch.ts",
@@ -301,7 +305,8 @@
     "test:native-audio-model-aware": "pnpm exec tsx test/continuous-test-suite-native-audio-model-aware.ts",
     "test:cli-json-output": "pnpm exec tsx test/continuous-test-suite-cli-json-output.ts",
     "test:logging-guidelines": "pnpm exec tsx test/continuous-test-suite-logging-guidelines.ts",
-    "test:proxy-polyfills": "pnpm exec tsx test/continuous-test-suite-proxy-polyfills.ts"
+    "test:proxy-polyfills": "pnpm exec tsx test/continuous-test-suite-proxy-polyfills.ts",
+    "test:mcp:startup-readiness": "pnpm exec tsx test/continuous-test-suite-mcp-startup-readiness.ts"
   },
   "files": [
     "dist",