@juspay/neurolink 7.29.1 → 7.29.3

package/dist/mcp/externalServerManager.js

@@ -357,6 +357,9 @@ export class ExternalServerManager extends EventEmitter {
             // Start the server
             await this.startServer(serverId);
             const finalInstance = this.servers.get(serverId);
+            if (!finalInstance) {
+                throw new Error(`Server ${serverId} not found after registration`);
+            }
             // Convert RuntimeMCPServerInfo to ExternalMCPServerInstance for return
             const convertedInstance = {
                 config: finalInstance.config,
@@ -664,6 +667,9 @@ export class ExternalServerManager extends EventEmitter {
         const delay = Math.min(1000 *
             Math.pow(this.config.restartBackoffMultiplier, instance.reconnectAttempts - 1), 30000);
         mcpLogger.info(`[ExternalServerManager] Scheduling restart for ${serverId} in ${delay}ms (attempt ${instance.reconnectAttempts})`);
+        if (instance.restartTimer) {
+            return;
+        } // already scheduled
         instance.restartTimer = setTimeout(async () => {
             try {
                 await this.stopServer(serverId);
@@ -914,6 +920,7 @@ export class ExternalServerManager extends EventEmitter {
         }
         try {
             mcpLogger.debug(`[ExternalServerManager] Registering ${instance.toolsMap.size} tools with main registry for server: ${serverId}`);
+            const registrations = [];
             for (const [toolName, tool] of instance.toolsMap.entries()) {
                 const toolId = `${serverId}.${toolName}`;
                 const toolInfo = {
@@ -923,21 +930,23 @@ export class ExternalServerManager extends EventEmitter {
                     serverId: serverId,
                     category: detectCategory({ isExternal: true, serverId }),
                 };
-                // Register with main tool registry
                 try {
-                    toolRegistry.registerTool(toolId, toolInfo, {
-                        execute: async (params, context) => {
+                    registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
+                        execute: async (params, _context) => {
                             // Execute tool via ExternalServerManager for proper lifecycle management
                             return await this.executeTool(serverId, toolName, params, { timeout: this.config.defaultTimeout });
                         },
-                    });
+                    }));
                     mcpLogger.debug(`[ExternalServerManager] Registered tool with main registry: ${toolId}`);
                 }
                 catch (registrationError) {
                     mcpLogger.warn(`[ExternalServerManager] Failed to register tool ${toolId} with main registry:`, registrationError);
                 }
             }
-            mcpLogger.info(`[ExternalServerManager] Successfully registered ${instance.toolsMap.size} tools with main registry for ${serverId}`);
+            const results = await Promise.allSettled(registrations);
+            const ok = results.filter((r) => r.status === "fulfilled").length;
+            const failed = results.length - ok;
+            mcpLogger.info(`[ExternalServerManager] Registered ${ok}/${results.length} tools with main registry for ${serverId}${failed ? ` (${failed} failed)` : ""}`);
         }
         catch (error) {
             mcpLogger.error(`[ExternalServerManager] Failed to register tools with main registry for ${serverId}:`, error);
@@ -1010,7 +1019,6 @@ export class ExternalServerManager extends EventEmitter {
             }
         }
         catch (error) {
-            const duration = Date.now() - startTime;
             instance.metrics.totalErrors++;
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
             throw error;

package/dist/mcp/factory.js

@@ -116,7 +116,7 @@ export function validateTool(tool) {
         const validation = validateMCPTool(tool);
         return validation.isValid;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }

package/dist/mcp/flexibleToolValidator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * FlexibleToolValidator - Universal Safety Checks Only
+ *
+ * Following Anthropic's MCP specification which intentionally leaves tool naming flexible,
+ * this validator only blocks truly dangerous cases to support maximum MCP tool compatibility.
+ *
+ * Phase 1 Implementation:
+ * - Universal safety checks only (empty names, control characters, excessive length)
+ * - No context-specific validation or arbitrary pattern restrictions
+ * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
+ */
+export interface FlexibleValidationResult {
+    isValid: boolean;
+    error?: string;
+    warnings?: string[];
+}
+export declare class FlexibleToolValidator {
+    private static readonly MAX_TOOL_NAME_LENGTH;
+    private static readonly MIN_TOOL_NAME_LENGTH;
+    /**
+     * Validate tool name with universal safety checks only
+     *
+     * This method only blocks truly dangerous cases:
+     * 1. Empty or whitespace-only names
+     * 2. Control characters that could break systems
+     * 3. Excessively long names that could cause memory issues
+     *
+     * Everything else is allowed to support maximum MCP tool compatibility.
+     */
+    static validateToolName(toolId: string): FlexibleValidationResult;
+    /**
+     * Validate tool information with minimal safety checks
+     */
+    static validateToolInfo(toolId: string, toolInfo: {
+        description?: string;
+        serverId?: string;
+    }): FlexibleValidationResult;
+    /**
+     * Get information about what this validator checks
+     */
+    static getValidationInfo(): {
+        philosophy: string;
+        checks: string[];
+        whatIsAllowed: string[];
+        examples: {
+            valid: string[];
+            invalid: string[];
+        };
+    };
+}

package/dist/mcp/flexibleToolValidator.js

@@ -0,0 +1,161 @@
+/**
+ * FlexibleToolValidator - Universal Safety Checks Only
+ *
+ * Following Anthropic's MCP specification which intentionally leaves tool naming flexible,
+ * this validator only blocks truly dangerous cases to support maximum MCP tool compatibility.
+ *
+ * Phase 1 Implementation:
+ * - Universal safety checks only (empty names, control characters, excessive length)
+ * - No context-specific validation or arbitrary pattern restrictions
+ * - Designed to support ALL legitimate MCP tools (github.create_repo, filesystem.read_file, etc.)
+ */
+import { registryLogger } from "../utils/logger.js";
+export class FlexibleToolValidator {
+    // Universal safety limits (generous to support all legitimate tools)
+    static MAX_TOOL_NAME_LENGTH = 1000; // Much more generous than npm's 214
+    static MIN_TOOL_NAME_LENGTH = 1;
+    /**
+     * Validate tool name with universal safety checks only
+     *
+     * This method only blocks truly dangerous cases:
+     * 1. Empty or whitespace-only names
+     * 2. Control characters that could break systems
+     * 3. Excessively long names that could cause memory issues
+     *
+     * Everything else is allowed to support maximum MCP tool compatibility.
+     */
+    static validateToolName(toolId) {
+        const warnings = [];
+        // Safety Check 1: Empty or whitespace-only names
+        if (!toolId || typeof toolId !== "string") {
+            return {
+                isValid: false,
+                error: "Tool name is required and must be a string",
+            };
+        }
+        // Safety Check 2: Control characters that could break systems (check BEFORE trimming!)
+        // Only block truly dangerous control characters, not printable characters
+        //
+        // This regex blocks dangerous C0 control characters and DEL:
+        // - \x00-\x08: NULL, SOH, STX, ETX, EOT, ENQ, ACK, BEL, BS
+        // - \x0B: Vertical Tab (VT)
+        // - \x0C: Form Feed (FF)
+        // - \x0E-\x1F: SO, SI, DLE, DC1-4, NAK, SYN, ETB, CAN, EM, SUB, ESC, FS-US
+        // - \x7F: DEL
+        //
+        // Explicitly ALLOWS these printable control characters:
+        // - \x09: TAB (horizontal tab) - commonly used in text
+        // - \x0A: LF (line feed) - commonly used in text
+        // - \x0D: CR (carriage return) - commonly used in text
+        // eslint-disable-next-line no-control-regex
+        const hasControlCharacters = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(toolId);
+        if (hasControlCharacters) {
+            return {
+                isValid: false,
+                error: "Tool name contains control characters that could break systems",
+            };
+        }
+        const trimmedName = toolId.trim();
+        if (trimmedName.length === 0) {
+            return {
+                isValid: false,
+                error: "Tool name cannot be empty or whitespace-only",
+            };
+        }
+        // Safety Check 3: Length limits (very generous)
+        if (trimmedName.length < this.MIN_TOOL_NAME_LENGTH) {
+            return {
+                isValid: false,
+                error: `Tool name must be at least ${this.MIN_TOOL_NAME_LENGTH} character long`,
+            };
+        }
+        if (trimmedName.length > this.MAX_TOOL_NAME_LENGTH) {
+            return {
+                isValid: false,
+                error: `Tool name exceeds maximum length of ${this.MAX_TOOL_NAME_LENGTH} characters`,
+            };
+        }
+        // Optional warnings for unusual but not dangerous patterns
+        if (trimmedName !== toolId) {
+            warnings.push("Tool name has leading/trailing whitespace (will be trimmed)");
+        }
+        if (trimmedName.length > 200) {
+            warnings.push("Tool name is unusually long but allowed");
+        }
+        registryLogger.debug(`✅ FlexibleToolValidator: Tool '${toolId}' passed universal safety checks`);
+        return {
+            isValid: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Validate tool information with minimal safety checks
+     */
+    static validateToolInfo(toolId, toolInfo) {
+        // First validate the tool name
+        const nameValidation = this.validateToolName(toolId);
+        if (!nameValidation.isValid) {
+            return nameValidation;
+        }
+        const warnings = [...(nameValidation.warnings || [])];
+        // Minimal safety checks for tool info
+        if (toolInfo.description && typeof toolInfo.description !== "string") {
+            return {
+                isValid: false,
+                error: "Tool description must be a string if provided",
+            };
+        }
+        if (toolInfo.serverId && typeof toolInfo.serverId !== "string") {
+            return {
+                isValid: false,
+                error: "Tool serverId must be a string if provided",
+            };
+        }
+        registryLogger.debug(`✅ FlexibleToolValidator: Tool info for '${toolId}' passed validation`);
+        return {
+            isValid: true,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Get information about what this validator checks
+     */
+    static getValidationInfo() {
+        return {
+            philosophy: "Maximum flexibility with universal safety only - following Anthropic's MCP specification",
+            checks: [
+                "Empty or whitespace-only names",
+                "Excessive length (over 1000 characters)",
+                "Control characters that could break systems",
+            ],
+            whatIsAllowed: [
+                "Dots (github.create_repo, filesystem.read_file)",
+                "Hyphens and underscores (my-tool, user_helper)",
+                "Numbers (tool1, my_tool_v2)",
+                "Unicode characters (🚀_tool, café_manager)",
+                "Mixed case (createRepo, ReadFile)",
+                "Long descriptive names (enterprise_database_connection_manager)",
+                "Any legitimate MCP tool naming pattern",
+            ],
+            examples: {
+                valid: [
+                    "github.create_repo",
+                    "filesystem.read_file",
+                    "my-custom-tool",
+                    "user_helper",
+                    "tool1",
+                    "🚀_rocket_tool",
+                    "enterprise.database.connection.manager",
+                    "UPPERCASE_TOOL",
+                    "mixed_Case.Tool-Name_123",
+                ],
+                invalid: [
+                    "", // Empty
+                    "   ", // Whitespace only
+                    "tool\x00", // Control character
+                    "a".repeat(1001), // Too long
+                ],
+            },
+        };
+    }
+}

package/dist/mcp/index.d.ts

@@ -18,7 +18,7 @@ export declare function listMCPs(): Promise<McpMetadata[]>;
 /**
  * Execute an MCP operation - simplified
  */
-export declare function executeMCP<T = unknown>(name: string, config: unknown, args: unknown, context?: {
+export declare function executeMCP<T = unknown>(_name: string, _config: unknown, _args: unknown, _context?: {
     sessionId?: string;
     userId?: string;
 }): Promise<T>;

package/dist/mcp/index.js

@@ -21,7 +21,7 @@ export async function listMCPs() {
 /**
  * Execute an MCP operation - simplified
  */
-export async function executeMCP(name, config, args, context) {
+export async function executeMCP(_name, _config, _args, _context) {
     throw new Error("MCP execution not available - ecosystem removed");
 }
 /**

package/dist/mcp/mcpCircuitBreaker.js

@@ -285,7 +285,11 @@ export class CircuitBreakerManager {
             this.breakers.set(name, breaker);
             mcpLogger.debug(`[CircuitBreakerManager] Created circuit breaker: ${name}`);
         }
-        return this.breakers.get(name);
+        const breaker = this.breakers.get(name);
+        if (!breaker) {
+            throw new Error(`Circuit breaker ${name} not found after creation`);
+        }
+        return breaker;
     }
     /**
      * Remove a circuit breaker and clean up its resources

package/dist/mcp/mcpClientFactory.js

@@ -192,6 +192,9 @@ export class MCPClientFactory {
             throw new Error("Process failed to start or exited immediately");
         }
         // Create transport
+        if (!config.command) {
+            throw new Error(`Command is required for stdio transport`);
+        }
         const transport = new StdioClientTransport({
             command: config.command,
             args: config.args || [],

package/dist/mcp/registry.d.ts

@@ -44,15 +44,15 @@ export declare class MCPRegistry implements McpRegistry {
     /**
      * Register a server (compatible with new interface)
      */
-    registerServer(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
+    registerServer(serverId: string, serverConfig?: unknown, _context?: ExecutionContext): Promise<void>;
     /**
      * Execute a tool (mock implementation for tests)
      */
-    executeTool<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
+    executeTool<T = unknown>(toolName: string, args?: unknown, _context?: ExecutionContext): Promise<T>;
     /**
      * List all tools (compatible with new interface)
      */
-    listTools(context?: ExecutionContext): Promise<ToolInfo[]>;
+    listTools(_context?: ExecutionContext): Promise<ToolInfo[]>;
     /**
      * Register a server (legacy sync version)
      */

package/dist/mcp/registry.js

@@ -53,7 +53,7 @@ export class MCPRegistry {
     /**
      * Register a server (compatible with new interface)
      */
-    async registerServer(serverId, serverConfig, context) {
+    async registerServer(serverId, serverConfig, _context) {
         const plugin = {
             metadata: {
                 name: serverId,
@@ -74,14 +74,14 @@ export class MCPRegistry {
     /**
      * Execute a tool (mock implementation for tests)
      */
-    async executeTool(toolName, args, context) {
+    async executeTool(toolName, args, _context) {
         registryLogger.info(`Executing tool: ${toolName}`);
         return { result: `Mock execution of ${toolName}`, args };
     }
     /**
      * List all tools (compatible with new interface)
      */
-    async listTools(context) {
+    async listTools(_context) {
         const tools = this.list().map((plugin) => ({
             name: plugin.metadata.name,
             description: plugin.metadata.description || "No description",

package/dist/mcp/servers/aiProviders/aiAnalysisTools.js

@@ -78,7 +78,7 @@ const OptimizeParametersSchema = z.object({
  * AI Usage Analysis Tool
  * Analyzes AI usage patterns, token consumption, and cost optimization opportunities
  */
-const analyzeAIUsageTool = {
+const _analyzeAIUsageTool = {
     name: "analyze-ai-usage",
     description: "Analyze AI usage patterns, token consumption, and cost optimization opportunities",
     category: "ai-analysis",
@@ -163,7 +163,7 @@ const analyzeAIUsageTool = {
  * Provider Performance Benchmarking Tool
  * Benchmarks AI provider performance across latency, quality, and cost metrics
  */
-const benchmarkProviderPerformanceTool = {
+const _benchmarkProviderPerformanceTool = {
     name: "benchmark-provider-performance",
     description: "Benchmark AI provider performance across latency, quality, and cost metrics",
     category: "ai-analysis",
@@ -199,7 +199,7 @@ const benchmarkProviderPerformanceTool = {
                         });
                         if (result && result.usage) {
                             totalLatency += Date.now() - testStartTime;
-                            totalTokens += result.usage.totalTokens || 0;
+                            totalTokens += result.usage.total || 0;
                             successfulTests++;
                         }
                     }
@@ -210,7 +210,7 @@ const benchmarkProviderPerformanceTool = {
                         avgLatency: successfulTests > 0
                             ? Math.round(totalLatency / successfulTests)
                             : 0,
-                        totalTokens: totalTokens,
+                        total: totalTokens,
                         successRate: (successfulTests /
                             (testPrompts.length * typedParams.iterations)) *
                             100,
@@ -259,7 +259,7 @@ const benchmarkProviderPerformanceTool = {
  * Prompt Parameter Optimization Tool
  * Optimizes prompt parameters (temperature, max tokens) for better AI output quality and efficiency
  */
-const optimizePromptParametersTool = {
+const _optimizePromptParametersTool = {
     name: "optimize-prompt-parameters",
     description: "Optimize prompt parameters (temperature, max tokens) for better AI output quality and efficiency",
     category: "ai-optimization",

package/dist/mcp/servers/aiProviders/aiWorkflowTools.js

@@ -99,7 +99,7 @@ const debugAIOutputSchema = z.object({
 /**
  * Generate test cases for code functions
  */
-const generateTestCasesTool = {
+const _generateTestCasesTool = {
     name: "generate-test-cases",
     description: "Generate comprehensive test cases for code functions with various test types and frameworks",
     category: "ai-workflow",
@@ -203,7 +203,7 @@ Generate 3-5 comprehensive test cases covering the requested types.`;
 /**
  * Refactor code for improved quality
  */
-const refactorCodeTool = {
+const _refactorCodeTool = {
     name: "refactor-code",
     description: "AI-powered code refactoring for improved readability, performance, and maintainability",
     category: "ai-workflow",
@@ -316,7 +316,7 @@ Focus on real, actionable improvements based on the specified objectives.`;
 /**
  * Generate documentation from code
  */
-const generateDocumentationTool = {
+const _generateDocumentationTool = {
     name: "generate-documentation",
     description: "Automatically generate comprehensive documentation from code",
     category: "ai-workflow",
@@ -427,7 +427,7 @@ Focus on creating accurate, useful documentation that explains the code's purpos
 /**
  * Debug AI-generated output
  */
-const debugAIOutputTool = {
+const _debugAIOutputTool = {
     name: "debug-ai-output",
     description: "Analyze and debug AI-generated output to identify issues and suggest improvements",
     category: "ai-workflow",
@@ -549,13 +549,13 @@ Provide thorough, actionable analysis focused on improving AI output quality.`;
     },
 };
 // Helper functions
-function extractFunctionName(code) {
+function _extractFunctionName(code) {
     const match = code.match(/function\s+(\w+)|const\s+(\w+)\s*=|(\w+)\s*\(/);
     return match
         ? match[1] || match[2] || match[3] || "processData"
         : "processData";
 }
-function simulateRefactoring(code, objectives, styleGuide) {
+function _simulateRefactoring(code, objectives, _styleGuide) {
     // Simulate basic refactoring
     let refactored = code;
     if (objectives.includes("readability")) {

package/dist/mcp/servers/utilities/utilityServer.js

@@ -61,7 +61,7 @@ utilityServer.registerTool({
                     });
                     resultData.actualTimezone = timezone;
                 }
-                catch (tzError) {
+                catch {
                     const fallbackTimezone = "Asia/Kolkata";
                     logger.warn(`[Utility] Invalid timezone '${timezone}', falling back to ${fallbackTimezone}`);
                     resultData.localTime = now.toLocaleString("en-US", {

package/dist/mcp/toolDiscoveryService.js

@@ -6,7 +6,7 @@
 import { EventEmitter } from "events";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
-import { isObject, isNullish, } from "../utils/typeUtils.js";
+import { isObject, isNullish } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
 /**
  * ToolDiscoveryService
@@ -133,6 +133,9 @@ export class ToolDiscoveryService extends EventEmitter {
                     this.serverToolStorage.set(serverId, []);
                 }
                 const serverTools = this.serverToolStorage.get(serverId);
+                if (!serverTools) {
+                    throw new Error(`Server tools storage not found for ${serverId}`);
+                }
                 // Add tool if not already present
                 if (!serverTools.find((t) => t.name === tool.name)) {
                     serverTools.push({
@@ -145,7 +148,10 @@ export class ToolDiscoveryService extends EventEmitter {
                 if (!this.serverTools.has(serverId)) {
                     this.serverTools.set(serverId, new Set());
                 }
-                this.serverTools.get(serverId).add(tool.name);
+                const serverToolSet = this.serverTools.get(serverId);
+                if (serverToolSet) {
+                    serverToolSet.add(tool.name);
+                }
                 registeredTools.push(toolInfo);
                 // Emit tool registered event
                 this.emit("toolRegistered", {

package/dist/mcp/toolRegistry.d.ts

@@ -29,7 +29,7 @@ export interface ToolExecutionOptions {
 }
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
-    private toolImpls;
+    private toolImplementations;
     private toolExecutionStats;
     private builtInServerInfos;
     constructor();
@@ -122,7 +122,7 @@ export declare class MCPToolRegistry extends MCPRegistry {
      * Register a tool with implementation directly
      * This is used for external MCP server tools
      */
-    registerTool(toolId: string, toolInfo: ToolInfo, toolImpl: ToolImplementation): void;
+    registerTool(toolId: string, toolInfo: ToolInfo, toolImpl: ToolImplementation): Promise<void>;
     /**
      * Remove a tool
      */