@juspay/neurolink 7.6.0 → 7.7.0

package/dist/neurolink.js

@@ -22,12 +22,19 @@ import { logger } from "./utils/logger.js";
 import { getBestProvider } from "./utils/providerUtils.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
 import { validateTool, createMCPServerFromTools, } from "./sdk/toolRegistration.js";
+// Factory processing imports
+import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryConfig, processStreamingFactoryOptions, createCleanStreamOptions, } from "./utils/factoryProcessing.js";
+// Enhanced error handling imports
+import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 // Core types imported from core/types.js
 export class NeuroLink {
     mcpInitialized = false;
     // Tool registration support
     customTools = new Map();
     inMemoryServers = new Map();
+    // Enhanced error handling support
+    toolCircuitBreakers = new Map();
+    toolExecutionMetrics = new Map();
     constructor() {
         // SDK always disables manual MCP config for security
         ProviderRegistry.setOptions({
@@ -42,6 +49,10 @@ export class NeuroLink {
         if (this.mcpInitialized) {
             return;
         }
+        // Track memory usage during MCP initialization
+        const { MemoryManager } = await import("./utils/performance.js");
+        const startMemory = MemoryManager.getMemoryUsageMB();
+        const initStartTime = Date.now();
         try {
             mcpLogger.debug("[NeuroLink] Starting isolated MCP initialization...");
             // Initialize tool registry with timeout protection
@@ -55,7 +66,18 @@ export class NeuroLink {
             // Register all providers with lazy loading support
             await ProviderRegistry.registerAllProviders();
             this.mcpInitialized = true;
-            mcpLogger.debug("[NeuroLink] MCP initialization completed successfully");
+            // Monitor memory usage and provide cleanup suggestions
+            const endMemory = MemoryManager.getMemoryUsageMB();
+            const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
+            const initTime = Date.now() - initStartTime;
+            mcpLogger.debug("[NeuroLink] MCP initialization completed successfully", {
+                initTime: `${initTime}ms`,
+                memoryUsed: `${memoryDelta}MB`,
+            });
+            // Suggest cleanup if initialization used significant memory
+            if (memoryDelta > 30) {
+                mcpLogger.debug("💡 Memory cleanup suggestion: MCP initialization used significant memory. Consider calling MemoryManager.forceGC() after heavy operations.");
+            }
         }
         catch (error) {
             mcpLogger.warn("[NeuroLink] MCP initialization failed", {
@@ -78,22 +100,46 @@ export class NeuroLink {
         if (!options.input?.text || typeof options.input.text !== "string") {
             throw new Error("Input text is required and must be a non-empty string");
         }
-        // Convert to internal TextGenerationOptions for compatibility
-        const textOptions = {
+        // Process factory configuration
+        const factoryResult = processFactoryOptions(options);
+        // Validate factory configuration if present
+        if (factoryResult.hasFactoryConfig && options.factoryConfig) {
+            const validation = validateFactoryConfig(options.factoryConfig);
+            if (!validation.isValid) {
+                logger.warn("Invalid factory configuration detected", {
+                    errors: validation.errors,
+                });
+                // Continue with warning rather than throwing - graceful degradation
+            }
+        }
+        // Convert to TextGenerationOptions using factory utilities
+        const baseOptions = {
             prompt: options.input.text,
             provider: options.provider,
             model: options.model,
             temperature: options.temperature,
             maxTokens: options.maxTokens,
             systemPrompt: options.systemPrompt,
-            disableTools: options.disableTools, // FIX: Pass disableTools flag
-            // 🔧 FIX: Include analytics and evaluation options!
+            disableTools: options.disableTools,
             enableAnalytics: options.enableAnalytics,
             enableEvaluation: options.enableEvaluation,
             context: options.context,
             evaluationDomain: options.evaluationDomain,
             toolUsageContext: options.toolUsageContext,
         };
+        // Apply factory enhancement using centralized utilities
+        const textOptions = enhanceTextGenerationOptions(baseOptions, factoryResult);
+        // Detect and execute domain-specific tools
+        const { toolResults, enhancedPrompt } = await this.detectAndExecuteTools(textOptions.prompt || options.input.text, factoryResult.domainType);
+        // Update prompt with tool results if available
+        if (enhancedPrompt !== textOptions.prompt) {
+            textOptions.prompt = enhancedPrompt;
+            logger.debug("Enhanced prompt with tool results", {
+                originalLength: options.input.text.length,
+                enhancedLength: enhancedPrompt.length,
+                toolResults: toolResults.length,
+            });
+        }
         // Use redesigned generation logic
         const textResult = await this.generateTextInternal(textOptions);
         // Convert back to GenerateResult
@@ -113,22 +159,19 @@ export class NeuroLink {
             toolExecutions: textResult.toolExecutions?.map((te) => {
                 const teRecord = te;
                 return {
-                    name: te.toolName || teRecord.name || "",
-                    input: teRecord.input ||
-                        teRecord.args ||
-                        {},
-                    output: teRecord.output ||
-                        teRecord.result ||
-                        (te.success ? "success" : "failed"),
-                    duration: te.executionTime || teRecord.duration || 0,
+                    name: teRecord.name || "", // ✅ BaseProvider now provides 'name'
+                    input: teRecord.input || {},
+                    output: teRecord.output || "success",
+                    duration: teRecord.duration || 0,
                 };
-            }),
+            }) || [],
             enhancedWithTools: textResult.enhancedWithTools,
             availableTools: textResult.availableTools?.map((tool) => {
                 const toolRecord = tool;
                 return {
                     name: tool.name || "",
                     description: tool.description || "",
+                    server: tool.server || "", // ✅ FIX: Include server property
                     parameters: toolRecord.parameters ||
                         toolRecord.schema ||
                         {},
@@ -147,6 +190,11 @@ export class NeuroLink {
                         .evaluationModel ?? "unknown",
                     evaluationTime: textResult.evaluation
                         .evaluationTime ?? Date.now(),
+                    // Include evaluationDomain from original options
+                    evaluationDomain: textResult.evaluation
+                        .evaluationDomain ??
+                        textOptions.evaluationDomain ??
+                        factoryResult.domainType,
                 }
                 : undefined,
         };
@@ -214,7 +262,7 @@ export class NeuroLink {
      */
     async tryMCPGeneration(options) {
         const functionTag = "NeuroLink.tryMCPGeneration";
-        const startTime = Date.now(); // 🔧 FIX: Add proper timing
+        const startTime = Date.now();
         try {
             // Initialize MCP if needed
             await this.initializeMCP();
@@ -229,13 +277,28 @@ export class NeuroLink {
             // Get available tools
             let availableTools = [];
             try {
-                const allTools = await toolRegistry.listTools();
-                availableTools = allTools.map((tool) => ({
+                // 1. Get MCP server tools (existing functionality)
+                const mcpTools = await toolRegistry.listTools();
+                const mappedMcpTools = mcpTools.map((tool) => ({
                     name: tool.name || "Unknown",
                     description: tool.description || "No description available",
-                    server: tool.server || "Unknown",
+                    server: tool.serverId || "Unknown", // Fix: use serverId instead of server
                     category: tool.category,
                 }));
+                // 2. ✅ NEW: Get custom tools from this NeuroLink instance
+                const customTools = Array.from(this.customTools.entries()).map(([name, tool]) => ({
+                    name,
+                    description: tool.description || "Custom tool",
+                    server: "custom",
+                    category: "user-defined",
+                }));
+                // 3. ✅ NEW: Combine all tools for AI generation
+                availableTools = [...mappedMcpTools, ...customTools];
+                logger.debug(`[${functionTag}] Available tools for AI generation:`, {
+                    mcpTools: mappedMcpTools.length,
+                    customTools: customTools.length,
+                    total: availableTools.length,
+                });
             }
             catch (error) {
                 mcpLogger.warn(`[${functionTag}] Failed to get tools`, { error });
@@ -249,7 +312,7 @@ export class NeuroLink {
                 ...options,
                 systemPrompt: enhancedSystemPrompt,
             });
-            const responseTime = Date.now() - startTime; // 🔧 FIX: Proper timing calculation
+            const responseTime = Date.now() - startTime;
             // Check if result is meaningful
             if (!result || !result.content || result.content.trim().length === 0) {
                 return null; // Let caller fall back to direct generation
@@ -261,6 +324,15 @@ export class NeuroLink {
                 usage: result.usage,
                 responseTime,
                 toolsUsed: result.toolsUsed || [],
+                toolExecutions: result.toolExecutions?.map((te) => {
+                    const teRecord = te;
+                    return {
+                        toolName: teRecord.name || "",
+                        executionTime: teRecord.duration || 0,
+                        success: true, // Assume success if tool executed (AI providers handle failures differently)
+                        serverId: teRecord.serverId || undefined,
+                    };
+                }) || [], // ✅ NEW: Add missing toolExecutions with proper format
                 enhancedWithTools: true,
                 availableTools: availableTools.length > 0 ? availableTools : undefined,
                 // Include analytics and evaluation from BaseProvider
@@ -360,6 +432,50 @@ export class NeuroLink {
         const toolPrompt = `\n\nYou have access to these additional tools if needed:\n${toolDescriptions}\n\nIMPORTANT: You are a general-purpose AI assistant. Answer all requests directly and creatively. These tools are optional helpers - use them only when they would genuinely improve your response. For creative tasks like storytelling, writing, or general conversation, respond naturally without requiring tools.`;
         return (originalSystemPrompt || "") + toolPrompt;
     }
+    /**
+     * Execute tools if available through centralized registry
+     * Simplified approach without domain detection - relies on tool registry
+     */
+    async detectAndExecuteTools(prompt, domainType) {
+        const functionTag = "NeuroLink.detectAndExecuteTools";
+        try {
+            // Simplified: Just return original prompt without complex detection
+            // Tools will be available through normal MCP flow when AI decides to use them
+            logger.debug(`[${functionTag}] Skipping automatic tool execution - relying on centralized registry`);
+            return { toolResults: [], enhancedPrompt: prompt };
+        }
+        catch (error) {
+            logger.error(`[${functionTag}] Tool detection/execution failed`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return { toolResults: [], enhancedPrompt: prompt };
+        }
+    }
+    /**
+     * Enhance prompt with tool results (domain-agnostic)
+     */
+    enhancePromptWithToolResults(prompt, toolResults) {
+        if (toolResults.length === 0) {
+            return prompt;
+        }
+        let enhancedPrompt = prompt;
+        for (const result of toolResults) {
+            if (result && typeof result === "object") {
+                enhancedPrompt += `\n\nTool Results:\n`;
+                // Handle any structured result generically
+                try {
+                    const resultStr = typeof result === "string"
+                        ? result
+                        : JSON.stringify(result, null, 2);
+                    enhancedPrompt += resultStr + "\n";
+                }
+                catch {
+                    enhancedPrompt += "Tool execution completed\n";
+                }
+            }
+        }
+        return enhancedPrompt;
+    }
     /**
      * BACKWARD COMPATIBILITY: Legacy streamText method
      * Internally calls stream() and converts result format
@@ -393,6 +509,27 @@ export class NeuroLink {
             options.input.text.trim() === "") {
             throw new Error("Stream options must include input.text as a non-empty string");
         }
+        // Process factory configuration for streaming
+        const factoryResult = processFactoryOptions(options);
+        const streamingResult = processStreamingFactoryOptions(options);
+        // Validate factory configuration if present
+        if (factoryResult.hasFactoryConfig && options.factoryConfig) {
+            const validation = validateFactoryConfig(options.factoryConfig);
+            if (!validation.isValid) {
+                mcpLogger.warn("Invalid factory configuration detected in stream", {
+                    errors: validation.errors,
+                });
+                // Continue with warning rather than throwing - graceful degradation
+            }
+        }
+        // Log factory processing results
+        if (factoryResult.hasFactoryConfig) {
+            mcpLogger.debug(`[${functionTag}] Factory configuration detected`, {
+                domainType: factoryResult.domainType,
+                enhancementType: factoryResult.enhancementType,
+                hasStreamingConfig: streamingResult.hasStreamingConfig,
+            });
+        }
         // Initialize MCP if needed
         await this.initializeMCP();
         // Context creation removed - was never used
@@ -400,6 +537,27 @@ export class NeuroLink {
         const providerName = options.provider === "auto" || !options.provider
             ? await getBestProvider()
             : options.provider;
+        // Prepare enhanced options for both success and fallback paths
+        let enhancedOptions = options;
+        if (factoryResult.hasFactoryConfig) {
+            enhancedOptions = {
+                ...options,
+                // Merge contexts instead of overriding to preserve provider-required context
+                context: {
+                    ...(options.context || {}),
+                    ...(factoryResult.processedContext || {}),
+                },
+                // Ensure evaluation is enabled when using factory patterns
+                enableEvaluation: options.enableEvaluation ?? true,
+                // Use domain type for evaluation if available
+                evaluationDomain: factoryResult.domainType || options.evaluationDomain,
+            };
+            mcpLogger.debug(`[${functionTag}] Enhanced stream options with factory config`, {
+                domainType: factoryResult.domainType,
+                enhancementType: factoryResult.enhancementType,
+                hasProcessedContext: !!factoryResult.processedContext,
+            });
+        }
         try {
             mcpLogger.debug(`[${functionTag}] Starting MCP-enabled streaming`, {
                 provider: providerName,
@@ -407,8 +565,10 @@ export class NeuroLink {
             });
             // Create provider using the same factory pattern as generate
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
-            // Call the provider's stream method directly
-            const streamResult = await provider.stream(options);
+            // Create clean options for provider (remove factoryConfig)
+            const cleanOptions = createCleanStreamOptions(enhancedOptions);
+            // Call the provider's stream method with clean options
+            const streamResult = await provider.stream(cleanOptions);
             // Extract the stream from the result
             const stream = streamResult.stream;
             const responseTime = Date.now() - startTime;
@@ -425,8 +585,17 @@ export class NeuroLink {
                 finishReason: streamResult.finishReason,
                 toolCalls: streamResult.toolCalls,
                 toolResults: streamResult.toolResults,
-                analytics: streamResult.analytics, // 🔧 FIX: Pass through analytics data
-                evaluation: streamResult.evaluation, // 🔧 FIX: Pass through evaluation data
+                analytics: streamResult.analytics,
+                evaluation: streamResult.evaluation
+                    ? {
+                        ...streamResult.evaluation,
+                        // Include evaluationDomain from factory configuration
+                        evaluationDomain: streamResult.evaluation
+                            ?.evaluationDomain ??
+                            enhancedOptions.evaluationDomain ??
+                            factoryResult.domainType,
+                    }
+                    : undefined,
                 metadata: {
                     streamId: `neurolink-${Date.now()}`,
                     startTime,
@@ -442,7 +611,9 @@ export class NeuroLink {
             // Use factory to create provider without MCP
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, false, // Disable MCP for fallback
             this);
-            const streamResult = await provider.stream(options);
+            // Create clean options for fallback provider (remove factoryConfig)
+            const cleanOptions = createCleanStreamOptions(enhancedOptions);
+            const streamResult = await provider.stream(cleanOptions);
             const responseTime = Date.now() - startTime;
             return {
                 stream: streamResult.stream,
@@ -452,8 +623,17 @@ export class NeuroLink {
                 finishReason: streamResult.finishReason,
                 toolCalls: streamResult.toolCalls,
                 toolResults: streamResult.toolResults,
-                analytics: streamResult.analytics, // 🔧 FIX: Pass through analytics data in fallback
-                evaluation: streamResult.evaluation, // 🔧 FIX: Pass through evaluation data in fallback
+                analytics: streamResult.analytics,
+                evaluation: streamResult.evaluation
+                    ? {
+                        ...streamResult.evaluation,
+                        // Include evaluationDomain in fallback stream
+                        evaluationDomain: streamResult.evaluation
+                            ?.evaluationDomain ??
+                            enhancedOptions.evaluationDomain ??
+                            factoryResult.domainType,
+                    }
+                    : undefined,
                 metadata: {
                     streamId: `neurolink-${Date.now()}`,
                     startTime,
@@ -493,12 +673,24 @@ export class NeuroLink {
         }
     }
     /**
-     * Register multiple tools at once
-     * @param tools - Object mapping tool names to configurations
+     * Register multiple tools at once - Supports both object and array formats
+     * @param tools - Object mapping tool names to configurations OR Array of tools with names
+     *
+     * Object format (existing): { toolName: SimpleTool, ... }
+     * Array format (Lighthouse compatible): [{ name: string, tool: SimpleTool }, ...]
      */
     registerTools(tools) {
-        for (const [name, tool] of Object.entries(tools)) {
-            this.registerTool(name, tool);
+        if (Array.isArray(tools)) {
+            // Handle array format (Lighthouse compatible)
+            for (const { name, tool } of tools) {
+                this.registerTool(name, tool);
+            }
+        }
+        else {
+            // Handle object format (existing compatibility)
+            for (const [name, tool] of Object.entries(tools)) {
+                this.registerTool(name, tool);
+            }
         }
     }
     /**
@@ -556,8 +748,8 @@ export class NeuroLink {
         return new Map(this.inMemoryServers);
     }
     /**
-     * Execute a specific tool by name (from git diff)
-     * Supports both custom tools and MCP server tools
+     * Execute a specific tool by name with robust error handling
+     * Supports both custom tools and MCP server tools with timeout, retry, and circuit breaker patterns
      * @param toolName - Name of the tool to execute
      * @param params - Parameters to pass to the tool
      * @param options - Execution options
@@ -565,98 +757,206 @@ export class NeuroLink {
      */
     async executeTool(toolName, params = {}, options) {
         const functionTag = "NeuroLink.executeTool";
+        const executionStartTime = Date.now();
+        // Set default options
+        const finalOptions = {
+            timeout: options?.timeout || 30000, // 30 second default timeout
+            maxRetries: options?.maxRetries || 2, // Default 2 retries for retriable errors
+            retryDelayMs: options?.retryDelayMs || 1000, // 1 second delay between retries
+        };
+        // Track memory usage for tool execution
+        const { MemoryManager } = await import("./utils/performance.js");
+        const startMemory = MemoryManager.getMemoryUsageMB();
+        // Get or create circuit breaker for this tool
+        if (!this.toolCircuitBreakers.has(toolName)) {
+            this.toolCircuitBreakers.set(toolName, new CircuitBreaker(5, 60000)); // 5 failures, 1 minute timeout
+        }
+        const circuitBreaker = this.toolCircuitBreakers.get(toolName);
+        // Initialize metrics for this tool if not exists
+        if (!this.toolExecutionMetrics.has(toolName)) {
+            this.toolExecutionMetrics.set(toolName, {
+                totalExecutions: 0,
+                successfulExecutions: 0,
+                failedExecutions: 0,
+                averageExecutionTime: 0,
+                lastExecutionTime: 0,
+            });
+        }
+        const metrics = this.toolExecutionMetrics.get(toolName);
+        metrics.totalExecutions++;
         try {
             mcpLogger.debug(`[${functionTag}] Executing tool: ${toolName}`, {
                 toolName,
                 params,
-                options,
+                options: finalOptions,
+                circuitBreakerState: circuitBreaker.getState(),
             });
-            // First check custom tools
-            if (this.customTools.has(toolName)) {
-                const tool = this.customTools.get(toolName);
-                const context = {
-                    sessionId: `direct-execution-${Date.now()}`,
-                    logger,
-                };
-                const startTime = Date.now();
-                const result = await tool.execute(params, context);
-                const executionTime = Date.now() - startTime;
-                mcpLogger.debug(`[${functionTag}] Custom tool executed successfully`, {
+            // Execute with circuit breaker, timeout, and retry logic
+            const result = await circuitBreaker.execute(async () => {
+                return await withRetry(async () => {
+                    return await withTimeout(this.executeToolInternal(toolName, params, finalOptions), finalOptions.timeout, ErrorFactory.toolTimeout(toolName, finalOptions.timeout));
+                }, {
+                    maxAttempts: finalOptions.maxRetries + 1, // +1 for initial attempt
+                    delayMs: finalOptions.retryDelayMs,
+                    isRetriable: isRetriableError,
+                    onRetry: (attempt, error) => {
+                        mcpLogger.warn(`[${functionTag}] Retrying tool execution (attempt ${attempt})`, {
+                            toolName,
+                            error: error.message,
+                            attempt,
+                        });
+                    },
+                });
+            });
+            // Update success metrics
+            const executionTime = Date.now() - executionStartTime;
+            metrics.successfulExecutions++;
+            metrics.lastExecutionTime = executionTime;
+            metrics.averageExecutionTime =
+                (metrics.averageExecutionTime * (metrics.successfulExecutions - 1) +
+                    executionTime) /
+                    metrics.successfulExecutions;
+            // Track memory usage
+            const endMemory = MemoryManager.getMemoryUsageMB();
+            const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
+            if (memoryDelta > 20) {
+                mcpLogger.warn(`Tool '${toolName}' used excessive memory: ${memoryDelta}MB`, {
                     toolName,
+                    memoryDelta,
                     executionTime,
                 });
-                return result;
             }
-            // Then check in-memory servers
-            for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
-                const server = serverConfig.server;
-                // Check if this server has the requested tool
-                if (server && server.tools) {
-                    const tool = server.tools instanceof Map
-                        ? server.tools.get(toolName)
-                        : server.tools[toolName];
-                    if (tool && typeof tool.execute === "function") {
-                        mcpLogger.debug(`[${functionTag}] Found tool in in-memory server: ${serverId}`);
-                        const startTime = Date.now();
-                        try {
-                            const result = await tool.execute(params);
-                            const executionTime = Date.now() - startTime;
-                            mcpLogger.debug(`[${functionTag}] Tool executed successfully`, {
-                                toolName,
-                                serverId,
-                                executionTime,
-                            });
-                            // Handle MCP-style results
-                            if (result && typeof result === "object" && "success" in result) {
-                                if (result.success) {
-                                    return result.data;
-                                }
-                                else {
-                                    throw new Error(result.error || "Tool execution failed");
-                                }
-                            }
-                            return result;
-                        }
-                        catch (toolError) {
-                            mcpLogger.error(`[${functionTag}] Tool execution failed`, {
-                                toolName,
-                                serverId,
-                                error: toolError instanceof Error
-                                    ? toolError.message
-                                    : String(toolError),
-                            });
-                            throw toolError;
-                        }
-                    }
+            mcpLogger.debug(`[${functionTag}] Tool executed successfully`, {
+                toolName,
+                executionTime,
+                memoryDelta,
+                circuitBreakerState: circuitBreaker.getState(),
+            });
+            return result;
+        }
+        catch (error) {
+            // Update failure metrics
+            metrics.failedExecutions++;
+            const executionTime = Date.now() - executionStartTime;
+            // Create structured error
+            let structuredError;
+            if (error instanceof NeuroLinkError) {
+                structuredError = error;
+            }
+            else if (error instanceof Error) {
+                // Categorize the error based on the message
+                if (error.message.includes("timeout")) {
+                    structuredError = ErrorFactory.toolTimeout(toolName, finalOptions.timeout);
+                }
+                else if (error.message.includes("not found")) {
+                    const availableTools = Array.from(this.customTools.keys());
+                    structuredError = ErrorFactory.toolNotFound(toolName, availableTools);
+                }
+                else if (error.message.includes("validation") ||
+                    error.message.includes("parameter")) {
+                    structuredError = ErrorFactory.invalidParameters(toolName, error, params);
+                }
+                else if (error.message.includes("network") ||
+                    error.message.includes("connection")) {
+                    structuredError = ErrorFactory.networkError(toolName, error);
+                }
+                else {
+                    structuredError = ErrorFactory.toolExecutionFailed(toolName, error);
+                }
+            }
+            else {
+                structuredError = ErrorFactory.toolExecutionFailed(toolName, new Error(String(error)));
+            }
+            // Add execution context to structured error
+            structuredError = new NeuroLinkError({
+                ...structuredError,
+                context: {
+                    ...structuredError.context,
+                    executionTime,
+                    params,
+                    options: finalOptions,
+                    circuitBreakerState: circuitBreaker.getState(),
+                    circuitBreakerFailures: circuitBreaker.getFailureCount(),
+                    metrics: { ...metrics },
+                },
+            });
+            // Log structured error
+            logStructuredError(structuredError);
+            throw structuredError;
+        }
+    }
+    /**
+     * Internal tool execution method (extracted for better error handling)
+     */
+    async executeToolInternal(toolName, params, options) {
+        const functionTag = "NeuroLink.executeToolInternal";
+        // First check custom tools
+        if (this.customTools.has(toolName)) {
+            const tool = this.customTools.get(toolName);
+            // Validate parameters if schema is available
+            if (tool.parameters) {
+                try {
+                    tool.parameters.parse(params);
+                }
+                catch (validationError) {
+                    throw ErrorFactory.invalidParameters(toolName, validationError, params);
                 }
             }
-            // If not found in custom tools or in-memory servers, try unified registry
+            const context = {
+                sessionId: `direct-execution-${Date.now()}`,
+                logger,
+            };
             try {
-                // Built-in tools initialization simplified
-                mcpLogger.debug(`[${functionTag}] MCP initialization simplified`);
-                // Create minimal execution context for external tools
-                const context = {
-                    sessionId: `neurolink-tool-${Date.now()}`,
-                    userId: "neurolink-user",
-                };
-                const result = (await toolRegistry.executeTool(toolName, params, context));
+                const result = await tool.execute(params, context);
                 return result;
             }
             catch (error) {
-                mcpLogger.warn(`[${functionTag}] External tool execution failed`, {
-                    toolName,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
+                throw ErrorFactory.toolExecutionFailed(toolName, error instanceof Error ? error : new Error(String(error)));
             }
         }
+        // Then check in-memory servers
+        for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
+            const server = serverConfig.server;
+            if (server && server.tools) {
+                const tool = server.tools instanceof Map
+                    ? server.tools.get(toolName)
+                    : server.tools[toolName];
+                if (tool && typeof tool.execute === "function") {
+                    try {
+                        const result = await tool.execute(params);
+                        // Handle MCP-style results
+                        if (result && typeof result === "object" && "success" in result) {
+                            if (result.success) {
+                                return result.data;
+                            }
+                            else {
+                                throw ErrorFactory.toolExecutionFailed(toolName, new Error(result.error || "Tool execution failed"), serverId);
+                            }
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        throw ErrorFactory.toolExecutionFailed(toolName, error instanceof Error ? error : new Error(String(error)), serverId);
+                    }
+                }
+            }
+        }
+        // If not found in custom tools or in-memory servers, try unified registry
+        try {
+            const context = {
+                sessionId: `neurolink-tool-${Date.now()}`,
+                userId: "neurolink-user",
+            };
+            const result = (await toolRegistry.executeTool(toolName, params, context));
+            return result;
+        }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            mcpLogger.error(`[${functionTag}] Tool execution failed: ${errorMessage}`, {
-                toolName,
-                error: errorMessage,
-            });
-            throw new Error(`Failed to execute tool '${toolName}': ${errorMessage}`);
+            // Check if tool was not found
+            if (error instanceof Error && error.message.includes("not found")) {
+                const availableTools = await this.getAllAvailableTools();
+                throw ErrorFactory.toolNotFound(toolName, availableTools.map((t) => t.name));
+            }
+            throw ErrorFactory.toolExecutionFailed(toolName, error instanceof Error ? error : new Error(String(error)));
         }
     }
     /**
@@ -664,10 +964,71 @@ export class NeuroLink {
      * @returns Array of available tools with metadata
      */
     async getAllAvailableTools() {
-        // MCP registry already includes direct tools, so just return MCP tools
-        // This prevents duplication since direct tools are auto-registered in MCP
-        const mcpTools = await toolRegistry.listTools();
-        return mcpTools;
+        // Track memory usage for tool listing operations
+        const { MemoryManager } = await import("./utils/performance.js");
+        const startMemory = MemoryManager.getMemoryUsageMB();
+        try {
+            // 1. Get MCP server tools (built-in direct tools)
+            const mcpToolsRaw = await toolRegistry.listTools();
+            const mcpTools = mcpToolsRaw.map((tool) => ({
+                ...tool,
+                toolName: tool.name, // Add toolName property for compatibility with tests
+                serverId: tool.serverId === "direct" ? "neurolink-direct" : tool.serverId, // Update serverId for test compatibility
+            }));
+            // 2. Get custom tools from this NeuroLink instance
+            const customTools = Array.from(this.customTools.entries()).map(([name, tool]) => ({
+                name,
+                toolName: name, // Add toolName property for compatibility with tests
+                description: tool.description || "Custom tool",
+                serverId: `custom-tool-${name}`, // Match the serverId pattern used in registerTool
+                category: "user-defined",
+                inputSchema: {},
+            }));
+            // 3. Get tools from in-memory MCP servers
+            const inMemoryTools = [];
+            for (const [serverId, serverConfig] of this.inMemoryServers.entries()) {
+                const server = serverConfig.server;
+                if (server && server.tools) {
+                    const tools = server.tools instanceof Map
+                        ? Object.fromEntries(server.tools)
+                        : server.tools;
+                    for (const [toolName, toolDef] of Object.entries(tools)) {
+                        const toolRecord = toolDef;
+                        inMemoryTools.push({
+                            name: toolName,
+                            toolName, // Add toolName property for compatibility with tests
+                            description: toolRecord.description || "In-memory MCP tool",
+                            serverId,
+                            category: serverConfig.category || "mcp-server",
+                            inputSchema: {},
+                        });
+                    }
+                }
+            }
+            // 4. Combine all tools
+            const allTools = [...mcpTools, ...customTools, ...inMemoryTools];
+            mcpLogger.debug("Tool discovery results", {
+                mcpTools: mcpTools.length,
+                customTools: customTools.length,
+                inMemoryTools: inMemoryTools.length,
+                total: allTools.length,
+            });
+            // Check memory usage after tool enumeration
+            const endMemory = MemoryManager.getMemoryUsageMB();
+            const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
+            if (memoryDelta > 10) {
+                mcpLogger.debug(`🔍 Tool listing used ${memoryDelta}MB memory (large tool registry detected)`);
+                // Suggest periodic cleanup for large tool registries
+                if (allTools.length > 100) {
+                    mcpLogger.debug("💡 Suggestion: Consider using tool categories or lazy loading for large tool sets");
+                }
+            }
+            return allTools;
+        }
+        catch (error) {
+            mcpLogger.error("Failed to list available tools", { error });
+            return [];
+        }
     }
     // ============================================================================
     // PROVIDER DIAGNOSTICS - SDK-First Architecture
@@ -677,10 +1038,10 @@ export class NeuroLink {
      * Primary method for provider health checking and diagnostics
      */
     async getProviderStatus(options) {
-        // 🔧 PERFORMANCE: Track memory and timing for provider status checks
+        // Track memory and timing for provider status checks
         const { MemoryManager } = await import("./utils/performance.js");
         const startMemory = MemoryManager.getMemoryUsageMB();
-        // CRITICAL FIX: Ensure providers are registered before testing
+        // Ensure providers are registered before testing
         if (!options?.quiet) {
             mcpLogger.debug("🔍 DEBUG: Initializing MCP for provider status...");
         }
@@ -703,7 +1064,7 @@ export class NeuroLink {
             "mistral",
             "litellm",
         ];
-        // 🚀 PERFORMANCE FIX: Test providers with controlled concurrency
+        // Test providers with controlled concurrency
         // This reduces total time from 16s (sequential) to ~3s (parallel) while preventing resource exhaustion
         const limit = pLimit(SYSTEM_LIMITS.DEFAULT_CONCURRENCY_LIMIT);
         const providerTests = providers.map((providerName) => limit(async () => {
@@ -797,7 +1158,7 @@ export class NeuroLink {
         }));
         // Wait for all provider tests to complete in parallel
         const results = await Promise.all(providerTests);
-        // 🔧 PERFORMANCE: Track memory usage and suggest cleanup if needed
+        // Track memory usage and suggest cleanup if needed
         const endMemory = MemoryManager.getMemoryUsageMB();
         const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
         if (!options?.quiet && memoryDelta > 20) {
@@ -835,15 +1196,6 @@ export class NeuroLink {
             disableTools: true,
         });
     }
-    /**
-     * Check if a provider has required environment variables configured
-     * @param providerName - Name of the provider to check
-     * @returns True if provider has required environment variables
-     */
-    async hasProviderEnvVars(providerName) {
-        const { hasProviderEnvVars } = await import("./utils/providerUtils.js");
-        return hasProviderEnvVars(providerName);
-    }
     /**
      * Get the best available AI provider based on configuration and availability
      * @param requestedProvider - Optional preferred provider name
@@ -923,6 +1275,216 @@ export class NeuroLink {
         // Simplified MCP server testing - unified registry removed
         return false; // No auto-discovery servers available
     }
+    // ==================== PROVIDER HEALTH CHECKING ====================
+    /**
+     * Check if a provider has the required environment variables configured
+     * @param providerName - Name of the provider to check
+     * @returns Promise resolving to true if provider has required env vars
+     */
+    async hasProviderEnvVars(providerName) {
+        const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
+        try {
+            const health = await ProviderHealthChecker.checkProviderHealth(providerName, { includeConnectivityTest: false, cacheResults: false });
+            return health.isConfigured && health.hasApiKey;
+        }
+        catch (error) {
+            logger.warn(`Provider env var check failed for ${providerName}`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
+    /**
+     * Perform comprehensive health check on a specific provider
+     * @param providerName - Name of the provider to check
+     * @param options - Health check options
+     * @returns Promise resolving to detailed health status
+     */
+    async checkProviderHealth(providerName, options = {}) {
+        const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
+        const health = await ProviderHealthChecker.checkProviderHealth(providerName, options);
+        return {
+            provider: health.provider,
+            isHealthy: health.isHealthy,
+            isConfigured: health.isConfigured,
+            hasApiKey: health.hasApiKey,
+            lastChecked: health.lastChecked,
+            error: health.error,
+            warning: health.warning,
+            responseTime: health.responseTime,
+            configurationIssues: health.configurationIssues,
+            recommendations: health.recommendations,
+        };
+    }
+    /**
+     * Check health of all supported providers
+     * @param options - Health check options
+     * @returns Promise resolving to array of health statuses for all providers
+     */
+    async checkAllProvidersHealth(options = {}) {
+        const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
+        const healthStatuses = await ProviderHealthChecker.checkAllProvidersHealth(options);
+        return healthStatuses.map((health) => ({
+            provider: health.provider,
+            isHealthy: health.isHealthy,
+            isConfigured: health.isConfigured,
+            hasApiKey: health.hasApiKey,
+            lastChecked: health.lastChecked,
+            error: health.error,
+            warning: health.warning,
+            responseTime: health.responseTime,
+            configurationIssues: health.configurationIssues,
+            recommendations: health.recommendations,
+        }));
+    }
+    /**
+     * Get a summary of provider health across all supported providers
+     * @returns Promise resolving to health summary statistics
+     */
+    async getProviderHealthSummary() {
+        const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
+        const healthStatuses = await ProviderHealthChecker.checkAllProvidersHealth({
+            cacheResults: true,
+            includeConnectivityTest: false,
+        });
+        const summary = ProviderHealthChecker.getHealthSummary(healthStatuses);
+        // Add recommendations based on the overall health
+        const recommendations = [];
+        if (summary.healthy === 0) {
+            recommendations.push("No providers are healthy. Check your environment configuration.");
+        }
+        else if (summary.healthy < 2) {
+            recommendations.push("Consider configuring additional providers for better reliability.");
+        }
+        if (summary.hasIssues > 0) {
+            recommendations.push("Some providers have configuration issues. Run checkAllProvidersHealth() for details.");
+        }
+        return {
+            ...summary,
+            recommendations,
+        };
+    }
+    /**
+     * Clear provider health cache (useful for re-testing after configuration changes)
+     * @param providerName - Optional specific provider to clear cache for
+     */
+    async clearProviderHealthCache(providerName) {
+        const { ProviderHealthChecker } = await import("./utils/providerHealth.js");
+        ProviderHealthChecker.clearHealthCache(providerName);
+    }
+    // ==================== TOOL EXECUTION DIAGNOSTICS ====================
+    /**
+     * Get execution metrics for all tools
+     * @returns Object with execution metrics for each tool
+     */
+    getToolExecutionMetrics() {
+        const metrics = {};
+        for (const [toolName, toolMetrics] of this.toolExecutionMetrics.entries()) {
+            metrics[toolName] = {
+                ...toolMetrics,
+                successRate: toolMetrics.totalExecutions > 0
+                    ? toolMetrics.successfulExecutions / toolMetrics.totalExecutions
+                    : 0,
+            };
+        }
+        return metrics;
+    }
+    /**
+     * Get circuit breaker status for all tools
+     * @returns Object with circuit breaker status for each tool
+     */
+    getToolCircuitBreakerStatus() {
+        const status = {};
+        for (const [toolName, circuitBreaker,] of this.toolCircuitBreakers.entries()) {
+            status[toolName] = {
+                state: circuitBreaker.getState(),
+                failureCount: circuitBreaker.getFailureCount(),
+                isHealthy: circuitBreaker.getState() === "closed",
+            };
+        }
+        return status;
+    }
+    /**
+     * Reset circuit breaker for a specific tool
+     * @param toolName - Name of the tool to reset circuit breaker for
+     */
+    resetToolCircuitBreaker(toolName) {
+        if (this.toolCircuitBreakers.has(toolName)) {
+            // Create a new circuit breaker (effectively resets it)
+            this.toolCircuitBreakers.set(toolName, new CircuitBreaker(5, 60000));
+            mcpLogger.info(`Circuit breaker reset for tool: ${toolName}`);
+        }
+    }
+    /**
+     * Clear all tool execution metrics
+     */
+    clearToolExecutionMetrics() {
+        this.toolExecutionMetrics.clear();
+        mcpLogger.info("All tool execution metrics cleared");
+    }
+    /**
+     * Get comprehensive tool health report
+     * @returns Detailed health report for all tools
+     */
+    getToolHealthReport() {
+        const tools = {};
+        let healthyCount = 0;
+        // Get all tool names from all sources
+        const allToolNames = new Set([
+            ...this.customTools.keys(),
+            ...Array.from(this.inMemoryServers.values()).flatMap((server) => server.server?.tools ? Object.keys(server.server.tools) : []),
+        ]);
+        for (const toolName of allToolNames) {
+            const metrics = this.toolExecutionMetrics.get(toolName);
+            const circuitBreaker = this.toolCircuitBreakers.get(toolName);
+            const successRate = metrics
+                ? metrics.totalExecutions > 0
+                    ? metrics.successfulExecutions / metrics.totalExecutions
+                    : 0
+                : 0;
+            const isHealthy = (!circuitBreaker || circuitBreaker.getState() === "closed") &&
+                successRate >= 0.8;
+            if (isHealthy) {
+                healthyCount++;
+            }
+            const issues = [];
+            const recommendations = [];
+            if (circuitBreaker && circuitBreaker.getState() === "open") {
+                issues.push("Circuit breaker is open due to repeated failures");
+                recommendations.push("Check tool implementation and fix underlying issues");
+            }
+            if (successRate < 0.8 && metrics && metrics.totalExecutions > 0) {
+                issues.push(`Low success rate: ${(successRate * 100).toFixed(1)}%`);
+                recommendations.push("Review error logs and improve tool reliability");
+            }
+            if (metrics && metrics.averageExecutionTime > 10000) {
+                issues.push("High average execution time");
+                recommendations.push("Optimize tool performance or increase timeout");
+            }
+            tools[toolName] = {
+                name: toolName,
+                isHealthy,
+                metrics: {
+                    totalExecutions: metrics?.totalExecutions || 0,
+                    successRate,
+                    averageExecutionTime: metrics?.averageExecutionTime || 0,
+                    lastExecutionTime: metrics?.lastExecutionTime || 0,
+                },
+                circuitBreaker: {
+                    state: circuitBreaker?.getState() || "closed",
+                    failureCount: circuitBreaker?.getFailureCount() || 0,
+                },
+                issues,
+                recommendations,
+            };
+        }
+        return {
+            totalTools: allToolNames.size,
+            healthyTools: healthyCount,
+            unhealthyTools: allToolNames.size - healthyCount,
+            tools,
+        };
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();