@juspay/neurolink 9.30.0 → 9.31.0

package/dist/client/mcp/toolDiscoveryService.js

@@ -0,0 +1,798 @@
+/**
+ * Tool Discovery Service
+ * Automatically discovers and registers tools from external MCP servers
+ * Handles tool validation, transformation, and lifecycle management
+ */
+import { EventEmitter } from "events";
+import { mcpLogger } from "../utils/logger.js";
+import { globalCircuitBreakerManager, CircuitBreakerOpenError, } from "./mcpCircuitBreaker.js";
+import { isObject, isNullish } from "../utils/typeUtils.js";
+import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
+import { withTimeout } from "../utils/errorHandling.js";
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
+const mcpTracer = tracers.mcp;
+/**
+ * Default timeout for MCP tool execution operations in milliseconds.
+ * Configurable via MCP_TOOL_TIMEOUT env var.
+ */
+const DEFAULT_TOOL_TIMEOUT = Math.max(5000, Number(process.env.MCP_TOOL_TIMEOUT) || 60000);
+/**
+ * ToolDiscoveryService
+ * Handles automatic tool discovery and registration from external MCP servers
+ */
+export class ToolDiscoveryService extends EventEmitter {
+    serverToolStorage = new Map();
+    toolRegistry = new Map();
+    serverTools = new Map();
+    discoveryInProgress = new Set();
+    constructor() {
+        super();
+    }
+    /**
+     * Discover tools from an external MCP server
+     */
+    async discoverTools(serverId, client, timeout = DEFAULT_TOOL_TIMEOUT) {
+        const startTime = Date.now();
+        try {
+            // Prevent concurrent discovery for same server
+            if (this.discoveryInProgress.has(serverId)) {
+                return {
+                    success: false,
+                    error: `Discovery already in progress for server: ${serverId}`,
+                    toolCount: 0,
+                    tools: [],
+                    duration: Date.now() - startTime,
+                    serverId,
+                };
+            }
+            this.discoveryInProgress.add(serverId);
+            mcpLogger.info(`[ToolDiscoveryService] Starting tool discovery for server: ${serverId}`);
+            // Create circuit breaker for tool discovery
+            const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-discovery-${serverId}`, {
+                failureThreshold: 2,
+                resetTimeout: 60000,
+                operationTimeout: timeout,
+            });
+            // Discover tools with circuit breaker protection
+            const tools = await circuitBreaker.execute(async () => {
+                return await this.performToolDiscovery(serverId, client, timeout);
+            });
+            // Register discovered tools
+            const registeredTools = await this.registerDiscoveredTools(serverId, tools);
+            const result = {
+                success: true,
+                toolCount: registeredTools.length,
+                tools: registeredTools,
+                duration: Date.now() - startTime,
+                serverId,
+            };
+            // Emit discovery completed event
+            this.emit("discoveryCompleted", {
+                serverId,
+                toolCount: registeredTools.length,
+                duration: result.duration,
+                timestamp: new Date(),
+            });
+            mcpLogger.info(`[ToolDiscoveryService] Discovery completed for ${serverId}: ${registeredTools.length} tools`);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            mcpLogger.error(`[ToolDiscoveryService] Discovery failed for ${serverId}:`, error);
+            // Emit discovery failed event
+            this.emit("discoveryFailed", {
+                serverId,
+                error: errorMessage,
+                timestamp: new Date(),
+            });
+            return {
+                success: false,
+                error: errorMessage,
+                toolCount: 0,
+                tools: [],
+                duration: Date.now() - startTime,
+                serverId,
+            };
+        }
+        finally {
+            this.discoveryInProgress.delete(serverId);
+        }
+    }
+    /**
+     * Perform the actual tool discovery
+     */
+    async performToolDiscovery(serverId, client, timeout) {
+        // List tools from the MCP server
+        const listToolsPromise = client.listTools();
+        const timeoutPromise = this.createTimeoutPromise(timeout, "Tool discovery timeout");
+        const result = await Promise.race([listToolsPromise, timeoutPromise]);
+        if (!result || !result.tools) {
+            throw new Error("No tools returned from server");
+        }
+        mcpLogger.debug(`[ToolDiscoveryService] Discovered ${result.tools.length} tools from ${serverId}`);
+        return result.tools;
+    }
+    /**
+     * Register discovered tools
+     */
+    async registerDiscoveredTools(serverId, tools) {
+        const registeredTools = [];
+        // Clear existing tools for this server
+        this.clearServerTools(serverId);
+        for (const tool of tools) {
+            try {
+                const toolInfo = await this.createToolInfo(serverId, tool);
+                const validation = this.validateTool(toolInfo);
+                if (!validation.isValid) {
+                    mcpLogger.warn(`[ToolDiscoveryService] Skipping invalid tool ${tool.name} from ${serverId}:`, validation.errors);
+                    continue;
+                }
+                // Apply validation metadata
+                if (validation.metadata) {
+                    toolInfo.metadata = {
+                        ...toolInfo.metadata,
+                        ...validation.metadata,
+                    };
+                }
+                // Register the tool
+                const toolKey = this.createToolKey(serverId, tool.name);
+                this.toolRegistry.set(toolKey, toolInfo);
+                if (!this.serverToolStorage.has(serverId)) {
+                    this.serverToolStorage.set(serverId, []);
+                }
+                const serverTools = this.serverToolStorage.get(serverId);
+                if (!serverTools) {
+                    throw new Error(`Server tools storage not found for ${serverId}`);
+                }
+                // Add tool if not already present
+                if (!serverTools.find((t) => t.name === tool.name)) {
+                    serverTools.push({
+                        name: tool.name,
+                        description: tool.description || "",
+                        inputSchema: tool.inputSchema,
+                    });
+                }
+                // Track server tools (legacy)
+                if (!this.serverTools.has(serverId)) {
+                    this.serverTools.set(serverId, new Set());
+                }
+                const serverToolSet = this.serverTools.get(serverId);
+                if (serverToolSet) {
+                    serverToolSet.add(tool.name);
+                }
+                registeredTools.push(toolInfo);
+                // Emit tool registered event
+                this.emit("toolRegistered", {
+                    serverId,
+                    toolName: tool.name,
+                    toolInfo,
+                    timestamp: new Date(),
+                });
+                mcpLogger.debug(`[ToolDiscoveryService] Registered tool: ${tool.name} from ${serverId}`);
+            }
+            catch (error) {
+                mcpLogger.error(`[ToolDiscoveryService] Failed to register tool ${tool.name} from ${serverId}:`, error);
+            }
+        }
+        return registeredTools;
+    }
+    /**
+     * Create tool info from MCP tool definition
+     */
+    async createToolInfo(serverId, tool) {
+        return {
+            name: tool.name,
+            description: tool.description || "No description provided",
+            serverId,
+            inputSchema: tool.inputSchema,
+            isAvailable: true,
+            stats: {
+                totalCalls: 0,
+                successfulCalls: 0,
+                failedCalls: 0,
+                averageExecutionTime: 0,
+                lastExecutionTime: 0,
+            },
+            metadata: {
+                category: this.inferToolCategory(tool),
+                version: "1.0.0",
+                deprecated: false,
+            },
+        };
+    }
+    /**
+     * Infer tool category from tool definition
+     */
+    inferToolCategory(tool) {
+        const name = tool.name.toLowerCase();
+        const description = (tool.description || "").toLowerCase();
+        // Common patterns for categorization
+        if (name.includes("git") || description.includes("git")) {
+            return "version-control";
+        }
+        if (name.includes("file") ||
+            name.includes("read") ||
+            name.includes("write")) {
+            return "file-system";
+        }
+        if (name.includes("api") ||
+            name.includes("http") ||
+            name.includes("request")) {
+            return "api";
+        }
+        if (name.includes("data") ||
+            name.includes("query") ||
+            name.includes("search")) {
+            return "data";
+        }
+        if (name.includes("auth") ||
+            name.includes("login") ||
+            name.includes("token")) {
+            return "authentication";
+        }
+        if (name.includes("deploy") ||
+            name.includes("build") ||
+            name.includes("ci")) {
+            return "deployment";
+        }
+        return "general";
+    }
+    /**
+     * Validate a tool
+     */
+    validateTool(toolInfo) {
+        const errors = [];
+        const warnings = [];
+        // Use centralized validation for name
+        const nameError = validateToolName(toolInfo.name);
+        if (nameError) {
+            errors.push(nameError.message);
+        }
+        // Use centralized validation for description
+        const descriptionError = validateToolDescription(toolInfo.description);
+        if (descriptionError) {
+            warnings.push(descriptionError.message);
+        }
+        if (!toolInfo.serverId) {
+            errors.push("Server ID is required");
+        }
+        // Schema validation
+        if (toolInfo.inputSchema) {
+            try {
+                JSON.stringify(toolInfo.inputSchema);
+            }
+            catch {
+                errors.push("Input schema is not valid JSON");
+            }
+        }
+        // Infer metadata
+        const metadata = {
+            category: typeof toolInfo.metadata?.category === "string"
+                ? toolInfo.metadata.category
+                : "general",
+            complexity: this.inferComplexity(toolInfo),
+            requiresAuth: this.inferAuthRequirement(toolInfo),
+            isDeprecated: typeof toolInfo.metadata?.deprecated === "boolean"
+                ? toolInfo.metadata.deprecated
+                : false,
+        };
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            metadata,
+        };
+    }
+    /**
+     * Infer tool complexity
+     */
+    inferComplexity(toolInfo) {
+        const schema = toolInfo.inputSchema;
+        if (!schema || !schema.properties) {
+            return "simple";
+        }
+        const propertyCount = Object.keys(schema.properties).length;
+        if (propertyCount <= 2) {
+            return "simple";
+        }
+        else if (propertyCount <= 5) {
+            return "moderate";
+        }
+        else {
+            return "complex";
+        }
+    }
+    /**
+     * Infer if tool requires authentication
+     */
+    inferAuthRequirement(toolInfo) {
+        const name = toolInfo.name.toLowerCase();
+        const description = toolInfo.description.toLowerCase();
+        return (name.includes("auth") ||
+            name.includes("login") ||
+            name.includes("token") ||
+            description.includes("authentication") ||
+            description.includes("credentials") ||
+            description.includes("permission"));
+    }
+    /**
+     * Execute a tool
+     */
+    async executeTool(toolName, serverId, client, parameters, options = {}) {
+        const startTime = Date.now();
+        try {
+            const toolKey = this.createToolKey(serverId, toolName);
+            const toolInfo = this.toolRegistry.get(toolKey);
+            if (!toolInfo) {
+                throw new Error(`Tool '${toolName}' not found for server '${serverId}'`);
+            }
+            if (!toolInfo.isAvailable) {
+                throw new Error(`Tool '${toolName}' is not available`);
+            }
+            // Validate input parameters if requested
+            if (options.validateInput !== false) {
+                this.validateToolParameters(toolInfo, parameters);
+            }
+            mcpLogger.debug(`[ToolDiscoveryService] Executing tool: ${toolName} on ${serverId}`, {
+                parameters,
+            });
+            // Create circuit breaker for tool execution
+            const effectiveTimeout = options.timeout || DEFAULT_TOOL_TIMEOUT;
+            const circuitBreaker = globalCircuitBreakerManager.getBreaker(`tool-execution-${serverId}-${toolName}`, {
+                failureThreshold: 3,
+                resetTimeout: 30000,
+                operationTimeout: effectiveTimeout,
+            });
+            // Execute tool with circuit breaker protection
+            const result = await circuitBreaker.execute(async () => {
+                return mcpTracer.startActiveSpan("neurolink.mcp.callTool", {
+                    kind: SpanKind.CLIENT,
+                    attributes: {
+                        "mcp.server_id": serverId,
+                        "mcp.tool_name": toolName,
+                        "mcp.timeout_ms": effectiveTimeout,
+                    },
+                }, async (callSpan) => {
+                    try {
+                        const timeout = effectiveTimeout;
+                        const callResult = await withTimeout(client.callTool({
+                            name: toolName,
+                            arguments: parameters,
+                        }), timeout, new Error(`Tool execution timeout: ${toolName}`));
+                        callSpan.setStatus({ code: SpanStatusCode.OK });
+                        return callResult;
+                    }
+                    catch (err) {
+                        callSpan.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err.message,
+                        });
+                        callSpan.recordException(err);
+                        throw err;
+                    }
+                    finally {
+                        callSpan.end();
+                    }
+                });
+            });
+            const duration = Date.now() - startTime;
+            // Update tool statistics
+            this.updateToolStats(toolKey, true, duration);
+            // Validate output if requested
+            if (options.validateOutput !== false) {
+                this.validateToolOutput(result);
+            }
+            mcpLogger.debug(`[ToolDiscoveryService] Tool execution completed: ${toolName}`, {
+                duration,
+                hasContent: !!result.content,
+            });
+            return {
+                success: true,
+                data: result,
+                duration,
+                metadata: {
+                    toolName,
+                    serverId,
+                    timestamp: Date.now(),
+                },
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Update tool statistics
+            const toolKey = this.createToolKey(serverId, toolName);
+            this.updateToolStats(toolKey, false, duration);
+            // Circuit breaker open errors: return a structured isError result with
+            // actionable details so AI models understand the tool is temporarily
+            // unavailable and should NOT retry until the cooldown expires.
+            if (error instanceof CircuitBreakerOpenError) {
+                mcpLogger.warn(`[ToolDiscoveryService] Tool blocked by circuit breaker: ${toolName} on ${serverId}`, {
+                    breakerState: error.breakerState,
+                    retryAfter: error.retryAfter,
+                    retryAfterMs: error.retryAfterMs,
+                    failureCount: error.failureCount,
+                });
+                return {
+                    success: false,
+                    error: error.message,
+                    data: {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: `TOOL TEMPORARILY UNAVAILABLE: "${toolName}" has been disabled after ` +
+                                    `${error.failureCount} failures. ` +
+                                    `This is a circuit breaker protection — do NOT retry this tool. ` +
+                                    `It will become available again after ${Math.ceil(error.retryAfterMs / 1000)} seconds ` +
+                                    `(at ${error.retryAfter}). ` +
+                                    `Instead, inform the user that the operation failed and suggest trying again later.`,
+                            },
+                        ],
+                    },
+                    duration,
+                    metadata: {
+                        toolName,
+                        serverId,
+                        timestamp: Date.now(),
+                        circuitBreaker: {
+                            state: error.breakerState,
+                            retryAfter: error.retryAfter,
+                            retryAfterMs: error.retryAfterMs,
+                            failureCount: error.failureCount,
+                        },
+                    },
+                };
+            }
+            mcpLogger.error(`[ToolDiscoveryService] Tool execution failed: ${toolName}`, error);
+            return {
+                success: false,
+                error: errorMessage,
+                duration,
+                metadata: {
+                    toolName,
+                    serverId,
+                    timestamp: Date.now(),
+                },
+            };
+        }
+    }
+    /**
+     * Validate tool parameters
+     */
+    validateToolParameters(toolInfo, parameters) {
+        if (!toolInfo.inputSchema) {
+            return; // No schema to validate against
+        }
+        // Basic validation - check required properties
+        const schema = toolInfo.inputSchema;
+        if (schema.required && Array.isArray(schema.required)) {
+            for (const requiredProp of schema.required) {
+                if (typeof requiredProp === "string" && !(requiredProp in parameters)) {
+                    throw new Error(`Missing required parameter: ${requiredProp}`);
+                }
+            }
+        }
+        // Type validation for properties
+        if (schema.properties) {
+            for (const [propName, propSchema] of Object.entries(schema.properties)) {
+                if (propName in parameters) {
+                    this.validateParameterType(propName, parameters[propName], propSchema);
+                }
+            }
+        }
+    }
+    /**
+     * Validate parameter type
+     */
+    validateParameterType(name, value, schema) {
+        if (!schema.type) {
+            return; // No type constraint
+        }
+        const expectedType = schema.type;
+        const actualType = typeof value;
+        switch (expectedType) {
+            case "string":
+                if (actualType !== "string") {
+                    throw new Error(`Parameter '${name}' must be a string, got ${actualType}`);
+                }
+                break;
+            case "number":
+                if (actualType !== "number") {
+                    throw new Error(`Parameter '${name}' must be a number, got ${actualType}`);
+                }
+                break;
+            case "boolean":
+                if (actualType !== "boolean") {
+                    throw new Error(`Parameter '${name}' must be a boolean, got ${actualType}`);
+                }
+                break;
+            case "array":
+                if (!Array.isArray(value)) {
+                    throw new Error(`Parameter '${name}' must be an array, got ${actualType}`);
+                }
+                break;
+            case "object":
+                if (actualType !== "object" || value === null || Array.isArray(value)) {
+                    throw new Error(`Parameter '${name}' must be an object, got ${actualType}`);
+                }
+                break;
+        }
+    }
+    /**
+     * Validate tool output with enhanced type safety
+     */
+    validateToolOutput(result) {
+        // GENERIC ERROR HANDLING FOR ALL MCP TOOLS
+        // Different MCP servers return different error formats, so we should be permissive
+        // and let the AI handle any response format instead of throwing errors
+        // Only throw for truly invalid responses (null/undefined)
+        if (isNullish(result)) {
+            mcpLogger.debug("[ToolDiscoveryService] Tool returned null/undefined, treating as empty response");
+            // Even null responses can be valid for some tools - don't throw
+            return;
+        }
+        // Log what we received for debugging, but don't validate specific formats
+        mcpLogger.debug("[ToolDiscoveryService] Tool response received", {
+            type: typeof result,
+            isArray: Array.isArray(result),
+            isObject: isObject(result),
+            hasKeys: isObject(result) ? Object.keys(result).length : 0,
+            fullResponse: result, // Log the complete response, not a truncated sample
+        });
+        // COMPLETELY PERMISSIVE APPROACH:
+        // - Any response format is valid (objects, strings, arrays, booleans, numbers)
+        // - Even error responses are passed to the AI to handle
+        // - The AI can interpret error messages and retry with different approaches
+        // - This works with any MCP server regardless of their response format
+        // No validation or throwing - let the AI handle everything
+        return;
+    }
+    /**
+     * Update tool statistics
+     */
+    updateToolStats(toolKey, success, duration) {
+        const toolInfo = this.toolRegistry.get(toolKey);
+        if (!toolInfo) {
+            return;
+        }
+        toolInfo.stats.totalCalls++;
+        toolInfo.lastCalled = new Date();
+        toolInfo.stats.lastExecutionTime = duration;
+        if (success) {
+            toolInfo.stats.successfulCalls++;
+        }
+        else {
+            toolInfo.stats.failedCalls++;
+        }
+        // Update average execution time
+        const totalTime = toolInfo.stats.averageExecutionTime * (toolInfo.stats.totalCalls - 1) +
+            duration;
+        toolInfo.stats.averageExecutionTime = totalTime / toolInfo.stats.totalCalls;
+    }
+    /**
+     * Get tool by name and server
+     */
+    getTool(toolName, serverId) {
+        const toolKey = this.createToolKey(serverId, toolName);
+        return this.toolRegistry.get(toolKey);
+    }
+    /**
+     * Get all tools for a server
+     */
+    getServerTools(serverId) {
+        const serverTools = this.serverToolStorage.get(serverId);
+        if (serverTools) {
+            return serverTools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                serverId,
+                inputSchema: tool.inputSchema,
+                isAvailable: true,
+                stats: {
+                    totalCalls: 0,
+                    successfulCalls: 0,
+                    failedCalls: 0,
+                    averageExecutionTime: 0,
+                    lastExecutionTime: 0,
+                },
+            }));
+        }
+        // Fallback to legacy storage
+        const tools = [];
+        const serverToolNames = this.serverTools.get(serverId);
+        if (serverToolNames) {
+            for (const toolName of serverToolNames) {
+                const toolKey = this.createToolKey(serverId, toolName);
+                const toolInfo = this.toolRegistry.get(toolKey);
+                if (toolInfo) {
+                    tools.push(toolInfo);
+                }
+            }
+        }
+        return tools;
+    }
+    /**
+     * Get all registered tools
+     */
+    getAllTools() {
+        const allTools = [];
+        // Add tools from server-based storage (preferred)
+        for (const [serverId, serverTools] of this.serverToolStorage.entries()) {
+            for (const tool of serverTools) {
+                allTools.push({
+                    name: tool.name,
+                    description: tool.description,
+                    serverId,
+                    inputSchema: tool.inputSchema,
+                    isAvailable: true,
+                    stats: {
+                        totalCalls: 0,
+                        successfulCalls: 0,
+                        failedCalls: 0,
+                        averageExecutionTime: 0,
+                        lastExecutionTime: 0,
+                    },
+                });
+            }
+        }
+        // Fallback to legacy storage for any tools not in server-based storage
+        const legacyTools = Array.from(this.toolRegistry.values()).filter((tool) => !allTools.some((t) => t.name === tool.name && t.serverId === tool.serverId));
+        return [...allTools, ...legacyTools];
+    }
+    /**
+     * Clear tools for a server
+     */
+    clearServerTools(serverId) {
+        const serverTools = this.serverToolStorage.get(serverId);
+        if (serverTools) {
+            // Emit unregistered events for server-based tools
+            for (const tool of serverTools) {
+                this.emit("toolUnregistered", {
+                    serverId,
+                    toolName: tool.name,
+                    timestamp: new Date(),
+                });
+            }
+            this.serverToolStorage.delete(serverId);
+        }
+        // Legacy cleanup
+        const serverToolNames = this.serverTools.get(serverId);
+        if (serverToolNames) {
+            for (const toolName of serverToolNames) {
+                const toolKey = this.createToolKey(serverId, toolName);
+                this.toolRegistry.delete(toolKey);
+                // Emit tool unregistered event (only if not already emitted above)
+                if (!serverTools || !serverTools.find((t) => t.name === toolName)) {
+                    this.emit("toolUnregistered", {
+                        serverId,
+                        toolName,
+                        timestamp: new Date(),
+                    });
+                }
+            }
+            this.serverTools.delete(serverId);
+        }
+        mcpLogger.debug(`[ToolDiscoveryService] Cleared tools for server: ${serverId}`);
+    }
+    /**
+     * Update tool availability
+     */
+    updateToolAvailability(toolName, serverId, isAvailable) {
+        const toolKey = this.createToolKey(serverId, toolName);
+        const toolInfo = this.toolRegistry.get(toolKey);
+        if (toolInfo) {
+            toolInfo.isAvailable = isAvailable;
+            mcpLogger.debug(`[ToolDiscoveryService] Updated availability for ${toolName}: ${isAvailable}`);
+        }
+    }
+    /**
+     * Create tool key for registry
+     */
+    createToolKey(serverId, toolName) {
+        return `${serverId}:${toolName}`;
+    }
+    /**
+     * Create timeout promise
+     */
+    createTimeoutPromise(timeout, message) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(message));
+            }, timeout);
+        });
+    }
+    /**
+     * Destroy the tool discovery service and clean up all resources
+     * This method should be called when the service is no longer needed
+     * to prevent memory leaks from accumulated event listeners
+     *
+     * @example
+     * ```typescript
+     * const service = new ToolDiscoveryService();
+     * // ... use the service ...
+     * service.destroy(); // Clean up when done
+     * ```
+     */
+    destroy() {
+        mcpLogger.debug("[ToolDiscoveryService] Starting cleanup...");
+        // Clear all event listeners to prevent memory leaks
+        this.removeAllListeners();
+        // Clear all internal data structures
+        this.serverToolStorage.clear();
+        this.toolRegistry.clear();
+        this.serverTools.clear();
+        this.discoveryInProgress.clear();
+        mcpLogger.debug("[ToolDiscoveryService] Destroyed and cleaned up");
+    }
+    /**
+     * Reset statistics for all tools
+     * This clears execution counts, timing data, and other statistics
+     * while preserving the tool registrations themselves
+     */
+    resetStatistics() {
+        for (const toolInfo of this.toolRegistry.values()) {
+            toolInfo.stats = {
+                totalCalls: 0,
+                successfulCalls: 0,
+                failedCalls: 0,
+                averageExecutionTime: 0,
+                lastExecutionTime: 0,
+            };
+            toolInfo.lastCalled = undefined;
+        }
+        mcpLogger.debug("[ToolDiscoveryService] Statistics reset for all tools");
+    }
+    /**
+     * Get the count of active event listeners
+     * Useful for monitoring potential memory leaks
+     */
+    getListenerCount() {
+        const events = [
+            "discoveryCompleted",
+            "discoveryFailed",
+            "toolRegistered",
+            "toolUnregistered",
+        ];
+        let total = 0;
+        for (const event of events) {
+            total += this.listenerCount(event);
+        }
+        return total;
+    }
+    /**
+     * Get discovery statistics
+     */
+    getStatistics() {
+        const toolsByServer = {};
+        const toolsByCategory = {};
+        let availableTools = 0;
+        let unavailableTools = 0;
+        for (const toolInfo of this.toolRegistry.values()) {
+            // Count by server
+            toolsByServer[toolInfo.serverId] =
+                (toolsByServer[toolInfo.serverId] || 0) + 1;
+            // Count by category
+            const category = typeof toolInfo.metadata?.category === "string"
+                ? toolInfo.metadata.category
+                : "unknown";
+            toolsByCategory[category] = (toolsByCategory[category] || 0) + 1;
+            // Count availability
+            if (toolInfo.isAvailable) {
+                availableTools++;
+            }
+            else {
+                unavailableTools++;
+            }
+        }
+        return {
+            totalTools: this.toolRegistry.size,
+            availableTools,
+            unavailableTools,
+            totalServers: this.serverTools.size,
+            toolsByServer,
+            toolsByCategory,
+        };
+    }
+}