@juspay/neurolink 7.29.2 → 7.29.3

package/dist/lib/utils/providerHealth.js

@@ -445,265 +445,210 @@ export class ProviderHealthChecker {
      */
     static async checkProviderSpecificConfig(providerName, healthStatus) {
         switch (providerName) {
-            case AIProviderName.VERTEX: {
-                logger.debug("Starting Vertex AI health check", {
-                    providerName,
-                });
-                // Check for Google Cloud project ID (with fallbacks)
-                const projectId = process.env.GOOGLE_PROJECT_ID ||
-                    process.env.GOOGLE_CLOUD_PROJECT_ID ||
-                    process.env.GOOGLE_VERTEX_PROJECT ||
-                    process.env.GOOGLE_CLOUD_PROJECT ||
-                    process.env.VERTEX_PROJECT_ID;
-                logger.debug("Project ID validation", {
-                    hasProjectId: !!projectId,
-                });
-                if (!projectId) {
-                    healthStatus.configurationIssues.push("Google Cloud project ID not set");
-                    healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
-                }
-                // Check for authentication with proper file existence validation
-                // This aligns with the authentication logic fix in googleVertex.ts
-                let hasValidAuth = false;
-                logger.debug("Authentication validation starting", {
-                    hasGoogleApplicationCredentials: !!process.env.GOOGLE_APPLICATION_CREDENTIALS,
-                });
-                // Check for principal account authentication first (recommended for production)
-                // BUT CRITICALLY: Also verify the file actually exists
-                if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-                    const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-                    logger.debug("Checking GOOGLE_APPLICATION_CREDENTIALS file");
-                    // Check if the credentials file actually exists
-                    let fileExists = false;
-                    try {
-                        const { promises: fs } = await import("fs");
-                        try {
-                            await fs.access(credentialsPath);
-                            fileExists = true;
-                        }
-                        catch {
-                            fileExists = false;
-                        }
-                        logger.debug("File existence check completed", {
-                            fileExists,
-                        });
-                    }
-                    catch (error) {
-                        logger.debug("File existence check failed", {
-                            error: String(error),
-                        });
-                        healthStatus.warning = `Failed to check credentials file existence: ${error}`;
-                        fileExists = false;
-                    }
-                    if (fileExists) {
-                        // Validate file format
-                        const fileName = basename(credentialsPath);
-                        const jsonFilePattern = /\.json(\.\w+)?$/;
-                        if (!jsonFilePattern.test(fileName)) {
-                            healthStatus.warning =
-                                "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file (e.g., 'credentials.json' or 'key.json.backup')";
-                        }
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file validated", {
-                            fileName,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file missing, falling back to individual env vars");
-                        // Fall through to check individual environment variables
-                    }
-                }
-                else {
-                    logger.debug("GOOGLE_APPLICATION_CREDENTIALS not set, checking individual env vars");
-                }
-                // Fallback to individual credentials for development and production
-                // Enhanced to check ALL required fields from the .env file configuration
-                if (!hasValidAuth) {
-                    const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
-                    const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
-                        process.env.GOOGLE_AUTH_PRIVATE_KEY);
-                    logger.debug("Individual credentials check", {
-                        hasServiceAccountKey,
-                        hasGoogleAuthClientEmail: !!process.env.GOOGLE_AUTH_CLIENT_EMAIL,
-                        hasGoogleAuthPrivateKey: !!process.env.GOOGLE_AUTH_PRIVATE_KEY,
-                        hasIndividualCredentials,
-                    });
-                    if (hasServiceAccountKey || hasIndividualCredentials) {
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("Individual credentials validated successfully", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        logger.debug("Individual credentials validation failed", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                        });
-                    }
-                }
-                // Final validation
-                if (!hasValidAuth) {
-                    healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
-                    healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
-                    logger.debug("Final auth validation FAILED", {
-                        hasValidAuth,
-                    });
-                }
-                else {
-                    logger.debug("Final auth validation SUCCESS", {
-                        hasValidAuth,
-                    });
-                }
-                // Mark as configured if we have both project ID and auth
-                if (projectId && hasValidAuth) {
-                    healthStatus.isConfigured = true;
-                    logger.debug("Vertex AI health check PASSED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
-                else {
-                    logger.debug("Vertex AI health check FAILED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
+            case AIProviderName.VERTEX:
+                await this.checkVertexAIConfig(healthStatus);
                 break;
-            }
-            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 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,
-                    });
-                }
+            case AIProviderName.BEDROCK:
+                await this.checkBedrockConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.AZURE: {
-                // Check Azure OpenAI endpoint
-                const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
-                if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
-                    healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
-                }
-                // Check for deployment name
-                if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
-                    healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
-                }
+            case AIProviderName.AZURE:
+                await this.checkAzureConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.OLLAMA: {
-                // Check if custom endpoint is set
-                const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
-                if (!ollamaBase.startsWith("http")) {
-                    healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
-                    healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
-                }
+            case AIProviderName.OLLAMA:
+                await this.checkOllamaConfig(healthStatus);
                 break;
+        }
+    }
+    /**
+     * Check Vertex AI configuration
+     */
+    static async checkVertexAIConfig(healthStatus) {
+        logger.debug("Starting Vertex AI health check");
+        const projectId = this.getVertexProjectId();
+        if (!projectId) {
+            healthStatus.configurationIssues.push("Google Cloud project ID not set");
+            healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
+        }
+        const hasValidAuth = await this.checkVertexAuthentication(healthStatus);
+        if (projectId && hasValidAuth) {
+            healthStatus.isConfigured = true;
+            logger.debug("Vertex AI health check PASSED");
+        }
+        else {
+            logger.debug("Vertex AI health check FAILED");
+        }
+    }
+    /**
+     * Get Vertex AI project ID from environment variables
+     */
+    static getVertexProjectId() {
+        return (process.env.GOOGLE_PROJECT_ID ||
+            process.env.GOOGLE_CLOUD_PROJECT_ID ||
+            process.env.GOOGLE_VERTEX_PROJECT ||
+            process.env.GOOGLE_CLOUD_PROJECT ||
+            process.env.VERTEX_PROJECT_ID);
+    }
+    /**
+     * Check Vertex AI authentication
+     */
+    static async checkVertexAuthentication(healthStatus) {
+        let hasValidAuth = false;
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+            hasValidAuth = await this.checkGoogleApplicationCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            hasValidAuth = this.checkIndividualGoogleCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
+            healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
+        }
+        return hasValidAuth;
+    }
+    /**
+     * Check Google Application Credentials file
+     */
+    static async checkGoogleApplicationCredentials(healthStatus) {
+        const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        if (!credentialsPath) {
+            healthStatus.warning =
+                "GOOGLE_APPLICATION_CREDENTIALS environment variable not set";
+            return false;
+        }
+        try {
+            const { promises: fs } = await import("fs");
+            await fs.access(credentialsPath);
+            const fileName = basename(credentialsPath);
+            const jsonFilePattern = /\.json(\.\w+)?$/;
+            if (!jsonFilePattern.test(fileName)) {
+                healthStatus.warning =
+                    "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file";
             }
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        catch {
+            healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
+            return false;
+        }
+    }
+    /**
+     * Check individual Google credentials
+     */
+    static checkIndividualGoogleCredentials(healthStatus) {
+        const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
+        const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+            process.env.GOOGLE_AUTH_PRIVATE_KEY);
+        if (hasServiceAccountKey || hasIndividualCredentials) {
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check AWS Bedrock configuration
+     */
+    static async checkBedrockConfig(healthStatus) {
+        logger.debug("Starting AWS Bedrock comprehensive health check");
+        this.checkAWSRegion(healthStatus);
+        this.checkAWSCredentials(healthStatus);
+        this.checkBedrockModels(healthStatus);
+        this.checkBedrockEndpoint(healthStatus);
+        if (healthStatus.configurationIssues.length === 0) {
+            healthStatus.hasApiKey = true;
+            logger.debug("AWS Bedrock configuration appears valid");
+        }
+    }
+    /**
+     * Check AWS region configuration
+     */
+    static checkAWSRegion(healthStatus) {
+        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",
+        ];
+        if (!awsRegion) {
+            healthStatus.configurationIssues.push("AWS_REGION not set");
+            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
+     */
+    static checkAWSCredentials(healthStatus) {
+        const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+        const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+        const awsProfile = process.env.AWS_PROFILE;
+        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 Bedrock models
+     */
+    static checkBedrockModels(healthStatus) {
+        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",
+        ];
+        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.includes(bedrockModel)) {
+            healthStatus.recommendations.push(`Consider using a popular Bedrock model: ${supportedModels.slice(0, 3).join(", ")}`);
+        }
+    }
+    /**
+     * Check Bedrock endpoint
+     */
+    static checkBedrockEndpoint(healthStatus) {
+        const bedrockEndpoint = process.env.BEDROCK_ENDPOINT_URL;
+        if (bedrockEndpoint && !bedrockEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("BEDROCK_ENDPOINT_URL should use HTTPS");
+            healthStatus.recommendations.push("Update BEDROCK_ENDPOINT_URL to use HTTPS protocol");
+        }
+    }
+    /**
+     * Check Azure OpenAI configuration
+     */
+    static async checkAzureConfig(healthStatus) {
+        const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
+        }
+        if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
+            healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
+        }
+    }
+    /**
+     * Check Ollama configuration
+     */
+    static async checkOllamaConfig(healthStatus) {
+        const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
+        if (!ollamaBase.startsWith("http")) {
+            healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
+            healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
         }
     }
     /**

package/dist/lib/utils/providerUtils.js

@@ -107,7 +107,7 @@ async function isProviderAvailable(providerName) {
             }
             return false;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -116,7 +116,7 @@ async function isProviderAvailable(providerName) {
         await provider.generate({ prompt: "test", maxTokens: 1 });
         return true;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }

package/dist/lib/utils/timeout.js

@@ -214,14 +214,17 @@ export class TimeoutManager {
     generateOperationId(operation) {
         return `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
-    createTimeoutPromise(timeoutMs, operationId) {
+    createTimeoutPromise(timeoutMs, _operationId) {
         let timer;
         const promise = new Promise((_, reject) => {
             timer = setTimeout(() => {
                 reject(new TimeoutError(`Operation timeout after ${timeoutMs}ms`, timeoutMs));
             }, timeoutMs);
         });
-        return { promise, timer: timer };
+        if (!timer) {
+            throw new Error("Failed to create timeout timer");
+        }
+        return { promise, timer };
     }
     registerTimeout(operationId, timer, controller, cleanup) {
         this.activeTimeouts.set(operationId, { timer, controller, cleanup });
@@ -291,7 +294,9 @@ export async function* withStreamingTimeout(generator, timeout, provider) {
         }
     }
     finally {
-        clearTimeout(timeoutId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
     }
 }
 /**

package/dist/mcp/externalServerManager.js

@@ -357,6 +357,9 @@ export class ExternalServerManager extends EventEmitter {
             // Start the server
             await this.startServer(serverId);
             const finalInstance = this.servers.get(serverId);
+            if (!finalInstance) {
+                throw new Error(`Server ${serverId} not found after registration`);
+            }
             // Convert RuntimeMCPServerInfo to ExternalMCPServerInstance for return
             const convertedInstance = {
                 config: finalInstance.config,
@@ -927,11 +930,18 @@ export class ExternalServerManager extends EventEmitter {
                     serverId: serverId,
                     category: detectCategory({ isExternal: true, serverId }),
                 };
-                registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
-                    execute: async (params) => await this.executeTool(serverId, toolName, params, {
-                        timeout: this.config.defaultTimeout,
-                    }),
-                }));
+                try {
+                    registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
+                        execute: async (params, _context) => {
+                            // Execute tool via ExternalServerManager for proper lifecycle management
+                            return await this.executeTool(serverId, toolName, params, { timeout: this.config.defaultTimeout });
+                        },
+                    }));
+                    mcpLogger.debug(`[ExternalServerManager] Registered tool with main registry: ${toolId}`);
+                }
+                catch (registrationError) {
+                    mcpLogger.warn(`[ExternalServerManager] Failed to register tool ${toolId} with main registry:`, registrationError);
+                }
             }
             const results = await Promise.allSettled(registrations);
             const ok = results.filter((r) => r.status === "fulfilled").length;
@@ -1009,7 +1019,6 @@ export class ExternalServerManager extends EventEmitter {
             }
         }
         catch (error) {
-            const duration = Date.now() - startTime;
             instance.metrics.totalErrors++;
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
             throw error;

package/dist/mcp/factory.js

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

package/dist/mcp/index.d.ts

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

package/dist/mcp/index.js

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

package/dist/mcp/mcpCircuitBreaker.js

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

package/dist/mcp/mcpClientFactory.js

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

package/dist/mcp/registry.d.ts

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

package/dist/mcp/registry.js

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