@juspay/neurolink 7.29.1 → 7.29.2

package/dist/lib/utils/providerConfig.js

@@ -359,9 +359,10 @@ export function createAnthropicBaseConfig() {
 // =============================================================================
 /**
  * Gets AWS Region with default fallback
+ * Supports both AWS_REGION and AWS_DEFAULT_REGION for broader compatibility
  */
 export function getAWSRegion() {
-    return process.env.AWS_REGION || "us-east-1";
+    return (process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1");
 }
 /**
  * Gets AWS Session Token if available

package/dist/lib/utils/providerHealth.js

@@ -130,6 +130,14 @@ export class ProviderHealthChecker {
      */
     static async checkEnvironmentConfiguration(providerName, healthStatus) {
         const requiredEnvVars = this.getRequiredEnvironmentVariables(providerName);
+        logger.debug(`[ProviderHealthChecker] Checking environment configuration for ${providerName}`, {
+            requiredEnvVars,
+            presentEnvVars: requiredEnvVars.map((envVar) => ({
+                name: envVar,
+                present: !!process.env[envVar],
+                hasValue: !!(process.env[envVar] && process.env[envVar].trim() !== ""),
+            })),
+        });
         let allConfigured = true;
         const missingVars = [];
         for (const envVar of requiredEnvVars) {
@@ -140,6 +148,12 @@ export class ProviderHealthChecker {
             }
         }
         healthStatus.isConfigured = allConfigured;
+        logger.debug(`[ProviderHealthChecker] Environment configuration result for ${providerName}`, {
+            isConfigured: allConfigured,
+            missingVars,
+            totalRequired: requiredEnvVars.length,
+            totalMissing: missingVars.length,
+        });
         if (!allConfigured) {
             healthStatus.configurationIssues.push(`Missing required environment variables: ${missingVars.join(", ")}`);
             healthStatus.recommendations.push(`Set the following environment variables: ${missingVars.join(", ")}`);
@@ -211,6 +225,12 @@ export class ProviderHealthChecker {
             }
             return;
         }
+        // Providers that don't use API keys directly
+        if (providerName === AIProviderName.OLLAMA ||
+            providerName === AIProviderName.BEDROCK) {
+            healthStatus.hasApiKey = true;
+            return;
+        }
         // 🔧 STANDARD HANDLING FOR OTHER PROVIDERS
         const apiKeyVar = this.getApiKeyEnvironmentVariable(providerName);
         const apiKey = process.env[apiKeyVar];
@@ -342,7 +362,9 @@ export class ProviderHealthChecker {
             case AIProviderName.GOOGLE_AI:
                 return ["GOOGLE_AI_API_KEY"];
             case AIProviderName.BEDROCK:
-                return ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"];
+                // Bedrock credentials are resolved via AWS SDK default provider chain.
+                // Region/auth validated in provider-specific checks.
+                return [];
             case AIProviderName.AZURE:
                 return ["AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT"];
             case AIProviderName.OLLAMA:
@@ -556,13 +578,109 @@ export class ProviderHealthChecker {
                 }
                 break;
             }
-            case AIProviderName.BEDROCK:
-                // Check AWS region
-                if (!process.env.AWS_REGION) {
+            case AIProviderName.BEDROCK: {
+                logger.debug("Starting AWS Bedrock comprehensive health check", {
+                    providerName,
+                });
+                // Check AWS region configuration
+                const awsRegion = process.env.AWS_REGION;
+                const validBedrockRegions = [
+                    "us-east-1",
+                    "us-west-2",
+                    "ap-southeast-1",
+                    "ap-northeast-1",
+                    "eu-central-1",
+                    "eu-west-1",
+                    "ap-south-1",
+                ];
+                logger.debug("AWS Region validation", {
+                    hasAwsRegion: !!awsRegion,
+                    awsRegion: awsRegion || "not set",
+                    validBedrockRegions,
+                });
+                if (!awsRegion) {
                     healthStatus.configurationIssues.push("AWS_REGION not set");
-                    healthStatus.recommendations.push("Set AWS_REGION (e.g., us-east-1)");
+                    healthStatus.recommendations.push(`Set AWS_REGION to a Bedrock-supported region: ${validBedrockRegions.join(", ")}`);
+                }
+                else if (!validBedrockRegions.includes(awsRegion)) {
+                    healthStatus.configurationIssues.push(`AWS_REGION '${awsRegion}' may not support all Bedrock models`);
+                    healthStatus.recommendations.push(`Consider using a primary Bedrock region: ${validBedrockRegions.slice(0, 3).join(", ")}`);
+                }
+                // Check AWS credentials configuration
+                const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+                const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+                const awsSessionToken = process.env.AWS_SESSION_TOKEN;
+                const awsProfile = process.env.AWS_PROFILE;
+                logger.debug("AWS Credentials validation", {
+                    hasAccessKeyId: !!awsAccessKeyId,
+                    hasSecretAccessKey: !!awsSecretAccessKey,
+                    hasSessionToken: !!awsSessionToken,
+                    hasProfile: !!awsProfile,
+                    authMethod: awsProfile
+                        ? "AWS Profile"
+                        : awsAccessKeyId
+                            ? "Access Keys"
+                            : "None detected",
+                });
+                if (!awsAccessKeyId && !awsProfile) {
+                    healthStatus.configurationIssues.push("No AWS credentials found");
+                    healthStatus.recommendations.push("Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or configure AWS_PROFILE");
+                }
+                else if (awsAccessKeyId && !awsSecretAccessKey) {
+                    healthStatus.configurationIssues.push("AWS_ACCESS_KEY_ID set but AWS_SECRET_ACCESS_KEY missing");
+                    healthStatus.recommendations.push("Set AWS_SECRET_ACCESS_KEY to match your AWS_ACCESS_KEY_ID");
+                }
+                // Check for Bedrock-specific model configuration
+                const bedrockModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+                const supportedModels = [
+                    "anthropic.claude-3-sonnet-20240229-v1:0",
+                    "anthropic.claude-3-haiku-20240307-v1:0",
+                    "anthropic.claude-3-opus-20240229-v1:0",
+                    "anthropic.claude-v2:1",
+                    "amazon.titan-text-express-v1",
+                ];
+                logger.debug("Bedrock Model validation", {
+                    hasBedrockModel: !!bedrockModel,
+                    bedrockModel: bedrockModel || "not set",
+                    supportedModels: supportedModels.slice(0, 3),
+                });
+                if (!bedrockModel) {
+                    healthStatus.recommendations.push("Set BEDROCK_MODEL or BEDROCK_MODEL_ID for faster startup (e.g., anthropic.claude-3-sonnet-20240229-v1:0)");
+                }
+                else if (!supportedModels.some((model) => model === bedrockModel)) {
+                    healthStatus.recommendations.push(`Consider using a popular Bedrock model: ${supportedModels.slice(0, 3).join(", ")}`);
+                }
+                // Check for additional Bedrock configuration
+                const bedrockEndpoint = process.env.BEDROCK_ENDPOINT_URL;
+                if (bedrockEndpoint) {
+                    logger.debug("Custom Bedrock endpoint detected", {
+                        endpoint: bedrockEndpoint,
+                    });
+                    if (!bedrockEndpoint.startsWith("https://")) {
+                        healthStatus.configurationIssues.push("BEDROCK_ENDPOINT_URL should use HTTPS");
+                        healthStatus.recommendations.push("Update BEDROCK_ENDPOINT_URL to use HTTPS protocol");
+                    }
+                }
+                // AWS SDK Configuration checks
+                const awsConfig = {
+                    maxAttempts: process.env.AWS_MAX_ATTEMPTS,
+                    retryMode: process.env.AWS_RETRY_MODE,
+                    defaultsMode: process.env.AWS_DEFAULTS_MODE,
+                };
+                logger.debug("AWS SDK Configuration", {
+                    awsConfig,
+                    hasAdvancedConfig: Object.values(awsConfig).some(Boolean),
+                });
+                if (healthStatus.configurationIssues.length === 0) {
+                    healthStatus.hasApiKey = true;
+                    logger.debug("AWS Bedrock configuration appears valid", {
+                        region: awsRegion,
+                        hasCredentials: !!(awsAccessKeyId || awsProfile),
+                        hasModel: !!bedrockModel,
+                    });
                 }
                 break;
+            }
             case AIProviderName.AZURE: {
                 // Check Azure OpenAI endpoint
                 const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;

package/dist/mcp/externalServerManager.js

@@ -664,6 +664,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 +917,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 +927,16 @@ 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) => {
-                            // 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);
-                }
+                registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
+                    execute: async (params) => await this.executeTool(serverId, toolName, params, {
+                        timeout: this.config.defaultTimeout,
+                    }),
+                }));
             }
-            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);

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/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/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/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?;