@juspay/neurolink 7.29.1 → 7.29.2

package/dist/lib/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/lib/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/lib/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
      */

package/dist/lib/mcp/toolRegistry.js

@@ -8,9 +8,10 @@ import { randomUUID } from "crypto";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { detectCategory, createMCPServerInfo } from "../utils/mcpDefaults.js";
+import { FlexibleToolValidator } from "./flexibleToolValidator.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
-    toolImpls = new Map(); // Store actual tool implementations
+    toolImplementations = new Map(); // Store actual tool implementations
     toolExecutionStats = new Map();
     builtInServerInfos = []; // DIRECT storage for MCPServerInfo
     constructor() {
@@ -38,7 +39,7 @@ export class MCPToolRegistry extends MCPRegistry {
                 category: detectCategory({ isBuiltIn: true, serverId: "direct" }),
             };
             this.tools.set(toolId, toolInfo);
-            this.toolImpls.set(toolId, {
+            this.toolImplementations.set(toolId, {
                 execute: async (params, context) => {
                     try {
                         // Direct tools from AI SDK expect their specific parameter structure
@@ -153,7 +154,7 @@ export class MCPToolRegistry extends MCPRegistry {
             // Register only with fully-qualified toolId to avoid collisions
             this.tools.set(toolId, toolInfo);
             // Store the actual tool implementation for execution using toolId as key
-            this.toolImpls.set(toolId, {
+            this.toolImplementations.set(toolId, {
                 execute: tool.execute ||
                     (async () => {
                         throw new Error(`Tool ${tool.name} has no execute function`);
@@ -234,9 +235,9 @@ export class MCPToolRegistry extends MCPRegistry {
                 ...context,
             };
             // Get the tool implementation using the resolved toolId
-            const toolImpl = this.toolImpls.get(toolId);
+            const toolImpl = this.toolImplementations.get(toolId);
             registryLogger.debug(`Looking for tool '${toolName}' (toolId: '${toolId}'), found: ${!!toolImpl}, type: ${typeof toolImpl?.execute}`);
-            registryLogger.debug(`Available tools:`, Array.from(this.toolImpls.keys()));
+            registryLogger.debug(`Available tools:`, Array.from(this.toolImplementations.keys()));
             if (!toolImpl || typeof toolImpl?.execute !== "function") {
                 throw new Error(`Tool '${toolName}' implementation not found or not executable`);
             }
@@ -450,55 +451,25 @@ export class MCPToolRegistry extends MCPRegistry {
      * Register a tool with implementation directly
      * This is used for external MCP server tools
      */
-    registerTool(toolId, toolInfo, toolImpl) {
+    async registerTool(toolId, toolInfo, toolImpl) {
         registryLogger.debug(`Registering tool: ${toolId}`);
-        // Import validation functions synchronously - they are pure functions
-        let validateTool;
-        let isToolNameAvailable;
-        let suggestToolNames;
-        try {
-            // Try ES module import first
-            const toolRegistrationModule = require("../sdk/toolRegistration.js");
-            ({ validateTool, isToolNameAvailable, suggestToolNames } =
-                toolRegistrationModule);
-        }
-        catch (error) {
-            // Fallback: skip validation if import fails (graceful degradation)
-            registryLogger.warn("Tool validation module not available, skipping advanced validation", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            // Create minimal validation functions
-            validateTool = () => { }; // No-op
-            isToolNameAvailable = () => true; // Allow all names
-            suggestToolNames = () => ["alternative_tool"];
-        }
-        // Check if tool name is available (not reserved)
-        if (!isToolNameAvailable(toolId)) {
-            const suggestions = suggestToolNames(toolId);
-            registryLogger.error(`Tool registration failed for ${toolId}: Name not available`);
-            throw new Error(`Tool name '${toolId}' is not available (reserved or invalid format). ` +
-                `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+        // Universal safety validation using FlexibleToolValidator
+        // Only blocks truly dangerous cases to support maximum MCP tool compatibility
+        const validation = FlexibleToolValidator.validateToolInfo(toolId, {
+            description: toolInfo.description,
+            serverId: toolInfo.serverId,
+        });
+        if (!validation.isValid) {
+            registryLogger.error(`Tool registration failed for ${toolId}: ${validation.error}`);
+            throw new Error(`Tool validation failed: ${validation.error}`);
         }
-        // Create a simplified tool object for validation
-        const toolForValidation = {
-            description: toolInfo.description || "",
-            execute: async () => "",
-            parameters: undefined,
-            metadata: {
-                category: toolInfo.category,
-                serverId: toolInfo.serverId,
-            },
-        };
-        // Use comprehensive validation logic
-        try {
-            validateTool(toolId, toolForValidation);
-        }
-        catch (error) {
-            registryLogger.error(`Tool registration failed for ${toolId}:`, error instanceof Error ? error.message : String(error));
-            throw error;
+        // Log any warnings but allow registration to proceed
+        if (validation.warnings && validation.warnings.length > 0) {
+            registryLogger.warn(`Tool registration warnings for ${toolId}:`, validation.warnings);
         }
+        registryLogger.debug(`✅ Tool '${toolId}' passed flexible validation - registration proceeding`);
         this.tools.set(toolId, toolInfo);
-        this.toolImpls.set(toolId, toolImpl);
+        this.toolImplementations.set(toolId, toolImpl);
         registryLogger.debug(`Successfully registered tool: ${toolId}`);
     }
     /**
@@ -509,6 +480,7 @@ export class MCPToolRegistry extends MCPRegistry {
         let removed = false;
         if (this.tools.has(toolName)) {
             this.tools.delete(toolName);
+            this.toolImplementations.delete(toolName); // Fix memory leak
             this.toolExecutionStats.delete(toolName);
             registryLogger.info(`Removed tool: ${toolName}`);
             removed = true;
@@ -518,6 +490,7 @@ export class MCPToolRegistry extends MCPRegistry {
             for (const [toolId, tool] of Array.from(this.tools.entries())) {
                 if (tool.name === toolName) {
                     this.tools.delete(toolId);
+                    this.toolImplementations.delete(toolId); // Fix memory leak
                     this.toolExecutionStats.delete(toolId);
                     registryLogger.info(`Removed tool: ${toolId}`);
                     removed = true;
@@ -567,6 +540,8 @@ export class MCPToolRegistry extends MCPRegistry {
         for (const [toolId, tool] of this.tools.entries()) {
             if (tool.serverId === serverId) {
                 this.tools.delete(toolId);
+                this.toolImplementations.delete(toolId); // Fix memory leak
+                this.toolExecutionStats.delete(toolId); // Fix memory leak
                 removedTools.push(toolId);
             }
         }

package/dist/lib/neurolink.d.ts

@@ -54,6 +54,8 @@ export declare class NeuroLink {
      * @param toolName - Name of the tool
      * @param startTime - Timestamp when tool execution started
      * @param success - Whether the tool execution was successful
+     * @param result - The result of the tool execution (optional)
+     * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
     private conversationMemory?;