mcp-filter 1.0.1 → 1.0.2

package/dist/features/discovery/discovery-handler.js

@@ -1,629 +0,0 @@
-import { SearchPhase } from "./search-phase.js";
-import { SimpleRAG } from "./simple-rag.js";
-import { ConfigInitializer } from "./config-init.js";
-import { logger } from "../../logger.js";
-import { z } from "zod";
-import { RequestSchema, ResultSchema } from "@modelcontextprotocol/sdk/types.js";
-// Zod schemas for custom request methods
-const DiscoverToolsRequestSchema = RequestSchema.extend({
-    method: z.literal("discover_tools"),
-    params: z.object({
-        query: z.string().optional(),
-        serverId: z.string().optional(),
-        initialized: z.boolean().optional(),
-        limit: z.number().int().positive().optional(),
-    }).optional(),
-});
-const CallToolRequestSchema = RequestSchema.extend({
-    method: z.literal("call_tool"),
-    params: z.object({
-        toolName: z.string(),
-        toolArguments: z.record(z.any()).optional(),
-        serverId: z.string().optional(),
-    }),
-});
-const InitRequestSchema = RequestSchema.extend({
-    method: z.literal("initialize_mcp_servers"),
-    params: z.object({
-        configPath: z.string().optional(),
-        servers: z.array(z.object({
-            id: z.string(),
-            transport: z.any(),
-            filters: z.object({
-                include: z.array(z.string()).optional(),
-                exclude: z.array(z.string()).optional(),
-            }).optional(),
-            enabled: z.boolean().optional(),
-        })).optional(),
-    }).optional(),
-});
-// Result schemas for custom methods
-const DiscoverToolsResultSchema = ResultSchema.extend({
-    tools: z.array(z.object({
-        name: z.string(),
-        serverId: z.string(),
-        description: z.string(),
-        initialized: z.boolean(),
-        arguments: z.array(z.object({
-            name: z.string(),
-            description: z.string(),
-        })).optional(),
-    })),
-    servers: z.array(z.object({
-        id: z.string(),
-        initialized: z.boolean(),
-        toolCount: z.number(),
-        short_description: z.string().optional(),
-        methodNames: z.array(z.string()).optional(),
-    })),
-    summary: z.object({
-        totalTools: z.number(),
-        searchEnabled: z.boolean(),
-        message: z.string(),
-    }).optional(),
-});
-// Init result is a union: either instructions (not initialized) or summary (initialized)
-const InitResultSchema = ResultSchema.extend({
-    initialized: z.boolean(),
-}).and(z.union([
-    // Not initialized - has instructions with RGC prompt
-    z.object({
-        initialized: z.literal(false),
-        instructions: z.object({
-            summary: z.string(),
-            role: z.string().optional(),
-            goal: z.string().optional(),
-            context: z.string().optional(),
-            servers: z.array(z.string()).optional(),
-            steps: z.array(z.object({
-                step: z.number(),
-                action: z.string(),
-                reason: z.string().optional(),
-                note: z.string().optional(),
-            })),
-            important: z.string(),
-            validationErrors: z.object({
-                message: z.string(),
-                errors: z.array(z.string()),
-                help: z.string(),
-            }).optional(),
-            toolOverrides: z.object({
-                note: z.string(),
-                example: z.string(),
-            }).optional(),
-        }),
-    }),
-    // Initialized - has summary with concise server-level format
-    z.object({
-        initialized: z.literal(true),
-        summary: z.object({
-            totalTools: z.number(),
-            connectedServers: z.array(z.object({
-                id: z.string(),
-                short_description: z.string().optional(),
-                toolCount: z.number(),
-                methodNames: z.array(z.string()).optional(),
-            })),
-            erroredServers: z.array(z.object({
-                id: z.string(),
-                short_description: z.string().optional(),
-                error: z.string().optional(),
-            })),
-        }),
-        descriptionPrompt: z.object({
-            role: z.string(),
-            goal: z.string(),
-            context: z.string(),
-            examples: z.array(z.string()),
-        }),
-        searchEnabled: z.boolean(),
-        message: z.string(),
-    }),
-]));
-/**
- * Handles discovery-related MCP methods
- */
-export class DiscoveryHandler {
-    serverManager;
-    initializationTracker;
-    overrideManager;
-    searchPhase;
-    simpleRAG;
-    configInitializer;
-    validationErrors;
-    constructor(serverManager, initializationTracker, overrideManager, validationErrors) {
-        this.serverManager = serverManager;
-        this.initializationTracker = initializationTracker;
-        this.overrideManager = overrideManager;
-        this.searchPhase = new SearchPhase();
-        this.simpleRAG = new SimpleRAG();
-        this.configInitializer = new ConfigInitializer();
-        this.validationErrors = validationErrors;
-    }
-    /**
-     * Register discovery methods with the MCP server
-     */
-    registerHandlers(server) {
-        // #region agent log
-        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:64', message: 'registerHandlers entry', data: { serverExists: !!server }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-        // #endregion
-        // Register discover-tools method
-        // #region agent log
-        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:67', message: 'registering discover-tools handler', data: { schemaType: typeof DiscoverToolsRequestSchema }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-        // #endregion
-        // Register discover-tools method with result schema validation
-        server.setRequestHandler(DiscoverToolsRequestSchema, async (request) => {
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:71', message: 'discover-tools handler called', data: { hasParams: !!request.params }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            const params = request.params;
-            const result = await this.discoverTools(params || {});
-            // Validate result against schema
-            const validatedResult = DiscoverToolsResultSchema.parse(result);
-            return validatedResult;
-        });
-        // Register initialize_mcp_servers method with result schema validation
-        // #region agent log
-        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:79', message: 'registering initialize_mcp_servers handler', data: { schemaType: typeof InitRequestSchema }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-        // #endregion
-        server.setRequestHandler(InitRequestSchema, async (request) => {
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:83', message: 'initialize_mcp_servers handler called', data: { hasParams: !!request.params }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            const params = request.params;
-            const result = await this.init(params?.configPath, params?.servers);
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:226', message: 'init result before validation', data: { initialized: result.initialized, hasSummary: !!result.summary, hasInstructions: !!result.instructions, hasDescriptionPrompt: !!result.descriptionPrompt, hasSearchEnabled: typeof result.searchEnabled, hasMessage: !!result.message, summaryKeys: result.initialized ? Object.keys(result.summary || {}) : undefined, topLevelKeys: Object.keys(result) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            // Validate result against schema
-            const validatedResult = InitResultSchema.parse(result);
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:230', message: 'init result validated', data: { initialized: validatedResult.initialized }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            return validatedResult;
-        });
-        // Register call_tool method
-        server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const params = request.params;
-            return await this.callTool(params);
-        });
-        // #region agent log
-        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:96', message: 'registerHandlers completed', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run2', hypothesisId: 'D' }) }).catch(() => { });
-        // #endregion
-    }
-    /**
-     * Call a specific tool from an upstream MCP server
-     */
-    async callTool(params) {
-        const servers = params.serverId
-            ? [this.serverManager.getServer(params.serverId)].filter((s) => s !== null && s !== undefined)
-            : this.serverManager.getEnabledServers();
-        const searchedServerNames = [];
-        const uninitializedServerNames = [];
-        // Find server with tool
-        for (const server of servers) {
-            if (!server)
-                continue;
-            if (!this.initializationTracker.isInitialized(server.id)) {
-                uninitializedServerNames.push(server.id);
-                continue;
-            }
-            searchedServerNames.push(server.id);
-            try {
-                const tools = await server.client.listTools();
-                const tool = tools.tools.find((t) => t.name === params.toolName);
-                if (tool && !server.filter.shouldExclude(tool.name)) {
-                    // Execute tool
-                    return await server.client.callTool({
-                        name: params.toolName,
-                        arguments: params.toolArguments || {},
-                    });
-                }
-            }
-            catch (error) {
-                // Continue searching
-            }
-        }
-        // Check if it's an uninitialized server issue
-        if (uninitializedServerNames.length > 0) {
-            const error = this.initializationTracker.createInitializationError(uninitializedServerNames[0]);
-            throw new Error(`${error.error.message}\n\n${JSON.stringify(error.initializationInstructions, null, 2)}`);
-        }
-        // Build error message with server names
-        const serverList = searchedServerNames.length > 0
-            ? ` Searched servers: ${searchedServerNames.join(", ")}.`
-            : "";
-        throw new Error(`Tool '${params.toolName}' not found or excluded.${serverList}`);
-    }
-    /**
-     * Discover tools across all configured servers
-     */
-    async discoverTools(params) {
-        // Check if we have any servers configured
-        const allServers = this.serverManager.getAllServers();
-        if (allServers.length === 0) {
-            // Return empty response if no servers configured
-            return {
-                tools: [],
-                servers: [],
-                summary: {
-                    totalTools: 0,
-                    searchEnabled: false,
-                    message: "No servers configured. Call discover_tools to initialize.",
-                },
-            };
-        }
-        // Check if servers need initialization - if so, initialize them first
-        const uninitializedServers = allServers.filter((server) => !this.initializationTracker.isInitialized(server.id));
-        if (uninitializedServers.length > 0) {
-            // Initialize servers by calling init() internally
-            await this.init();
-            // Continue with tool discovery even if some servers failed to initialize
-        }
-        const tools = [];
-        const servers = params.serverId
-            ? [this.serverManager.getServer(params.serverId)].filter(Boolean)
-            : this.serverManager.getEnabledServers();
-        for (const server of servers) {
-            if (!server)
-                continue;
-            const isInitialized = this.initializationTracker.isInitialized(server.id);
-            // Filter by initialization state if specified
-            if (params.initialized !== undefined && params.initialized !== isInitialized) {
-                continue;
-            }
-            try {
-                if (!isInitialized) {
-                    // Return placeholder for uninitialized servers
-                    continue;
-                }
-                const upstreamTools = await server.client.listTools();
-                const filteredTools = server.filter.filterList(upstreamTools.tools);
-                for (const tool of filteredTools) {
-                    // Apply overrides
-                    const toolWithOverrides = this.overrideManager.applyOverrides(server.id, tool, true // Use brief descriptions
-                    );
-                    // Extract arguments
-                    const arguments_ = tool.inputSchema?.properties
-                        ? Object.entries(tool.inputSchema.properties).map(([name, prop]) => ({
-                            name,
-                            description: typeof prop === "object" && "description" in prop
-                                ? prop.description || ""
-                                : "",
-                        }))
-                        : undefined;
-                    tools.push({
-                        name: tool.name,
-                        serverId: server.id,
-                        description: toolWithOverrides.description || "",
-                        initialized: true,
-                        arguments: arguments_,
-                    });
-                }
-            }
-            catch (error) {
-                logger.error(`Error discovering tools from server ${server.id}: ${error}`);
-            }
-        }
-        // Apply search if query provided - always use both algorithms
-        let searchResults = tools;
-        if (params.query) {
-            const searchableTools = tools.map((t) => ({
-                name: t.name,
-                description: t.description,
-                serverId: t.serverId,
-            }));
-            // Always use both phase (keyword) and RAG (semantic) search
-            const ragResults = this.simpleRAG.search(searchableTools.map((t) => ({
-                name: t.name,
-                description: t.description,
-            })), params.query);
-            // Calculate phase (keyword) search scores using same logic as fuzzySearch
-            const queryLower = params.query.toLowerCase();
-            const phaseScoredResults = [];
-            for (const tool of searchableTools) {
-                // Filter by serverId if specified
-                if (params.serverId && tool.serverId !== params.serverId) {
-                    continue;
-                }
-                let score = 0;
-                // Exact match in name
-                if (tool.name.toLowerCase() === queryLower) {
-                    score = 1.0;
-                }
-                // Name contains query
-                else if (tool.name.toLowerCase().includes(queryLower)) {
-                    score = 0.8;
-                }
-                // Description contains query
-                else if (tool.description?.toLowerCase().includes(queryLower)) {
-                    score = 0.6;
-                }
-                // Simple substring match
-                else {
-                    const nameWords = tool.name.toLowerCase().split(/[_\-\s]+/);
-                    const queryWords = queryLower.split(/[_\-\s]+/);
-                    let matches = 0;
-                    for (const qw of queryWords) {
-                        if (nameWords.some((nw) => nw.includes(qw) || qw.includes(nw))) {
-                            matches++;
-                        }
-                    }
-                    if (matches > 0) {
-                        score = matches / Math.max(nameWords.length, queryWords.length);
-                    }
-                }
-                // Include if score > 0 (no threshold filtering, we'll combine with RAG)
-                if (score > 0) {
-                    phaseScoredResults.push({ tool, score });
-                }
-            }
-            // Build score map: tool key -> max confidence score from either algorithm
-            const scoreMap = new Map();
-            const toolMap = new Map(tools.map((t) => [`${t.name}:${t.serverId}`, t]));
-            // Add phase search scores
-            for (const result of phaseScoredResults) {
-                const key = `${result.tool.name}:${result.tool.serverId}`;
-                scoreMap.set(key, Math.max(scoreMap.get(key) ?? 0, result.score));
-            }
-            // Add RAG search scores (already has scores)
-            for (const result of ragResults) {
-                const matching = tools.find((t) => t.name === result.tool.name);
-                if (matching) {
-                    const key = `${matching.name}:${matching.serverId}`;
-                    scoreMap.set(key, Math.max(scoreMap.get(key) ?? 0, result.score));
-                }
-            }
-            // Combine results: include tools from either algorithm, sorted by highest confidence
-            const scoredResults = Array.from(scoreMap.entries())
-                .map(([key, score]) => ({
-                tool: toolMap.get(key),
-                score,
-            }))
-                .filter((r) => r.tool !== undefined)
-                .sort((a, b) => b.score - a.score) // Sort by confidence descending
-                .map((r) => r.tool);
-            searchResults = scoredResults;
-        }
-        // Apply limit (default: 3) - results are already sorted by highest confidence
-        const limit = params.limit ?? 3;
-        const limitedResults = searchResults.slice(0, limit);
-        // Build server status
-        const serverStatus = this.serverManager
-            .getEnabledServers()
-            .map((server) => {
-            const shortDescription = server.config.short_description ||
-                server.config.shortDescription ||
-                undefined;
-            const serverTools = searchResults.filter((t) => t.serverId === server.id);
-            return {
-                id: server.id,
-                initialized: this.initializationTracker.isInitialized(server.id),
-                toolCount: serverTools.length,
-                short_description: shortDescription && shortDescription.length < 100 ? shortDescription : undefined,
-                methodNames: serverTools.map((t) => t.name),
-            };
-        });
-        // If initialized and no query, return summary format
-        const allInitialized = serverStatus.every((s) => s.initialized);
-        if (allInitialized && !params.query) {
-            return {
-                tools: limitedResults,
-                servers: serverStatus,
-                summary: {
-                    totalTools: searchResults.length,
-                    searchEnabled: true,
-                    message: `Found ${searchResults.length} tool(s) across ${serverStatus.length} server(s). Showing ${limitedResults.length} of ${searchResults.length} (limit: ${limit}). Use query parameter for semantic search.`,
-                },
-            };
-        }
-        return {
-            tools: limitedResults,
-            servers: serverStatus,
-        };
-    }
-    /**
-     * Single unified method: returns initialization instructions if not initialized,
-     * or returns tool summaries from config if initialized
-     */
-    async init(configPath, servers) {
-        const allServers = this.serverManager.getAllServers();
-        // Stage 1: No config file - no servers configured
-        if (allServers.length === 0) {
-            const initError = this.initializationTracker.createConfigInitError();
-            return {
-                initialized: false,
-                instructions: {
-                    summary: initError.initializationInstructions.summary,
-                    role: initError.initializationInstructions.role,
-                    goal: initError.initializationInstructions.goal,
-                    context: initError.initializationInstructions.context,
-                    steps: initError.initializationInstructions.steps,
-                    important: initError.initializationInstructions.important,
-                },
-            };
-        }
-        // Stage 2: Invalid config file - validation errors exist
-        if (this.validationErrors && !this.validationErrors.valid) {
-            const invalidConfigError = this.initializationTracker.createInvalidConfigError(this.validationErrors.formattedErrors || []);
-            return {
-                initialized: false,
-                instructions: {
-                    summary: invalidConfigError.summary,
-                    role: invalidConfigError.role,
-                    goal: invalidConfigError.goal,
-                    context: invalidConfigError.context,
-                    steps: invalidConfigError.steps,
-                    important: invalidConfigError.important,
-                    validationErrors: invalidConfigError.validationErrors,
-                },
-            };
-        }
-        // Stage 3: Valid config but servers not initialized
-        const uninitializedServers = allServers.filter((server) => !this.initializationTracker.isInitialized(server.id));
-        // #region agent log
-        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:506', message: 'Stage 3 check', data: { allServersCount: allServers.length, uninitializedCount: uninitializedServers.length, uninitializedIds: uninitializedServers.map(s => s.id), initializationStatus: allServers.map(s => ({ id: s.id, initialized: this.initializationTracker.isInitialized(s.id) })) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
-        // #endregion
-        if (uninitializedServers.length > 0) {
-            // Actually connect to servers when discover_tools is called (code performs initialization)
-            // Retry connection up to 3 times with delays for servers that might not be ready
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:510', message: 'Stage 3 connecting servers', data: { uninitializedIds: uninitializedServers.map(s => s.id) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            for (const server of uninitializedServers) {
-                let connected = false;
-                for (let attempt = 0; attempt < 3; attempt++) {
-                    try {
-                        // #region agent log
-                        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:515', message: 'connection attempt', data: { serverId: server.id, attempt: attempt + 1 }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
-                        // #endregion
-                        await this.serverManager.connectServer(server.id);
-                        // #region agent log
-                        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:518', message: 'connection attempt succeeded', data: { serverId: server.id, attempt: attempt + 1, isInitialized: this.initializationTracker.isInitialized(server.id) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
-                        // #endregion
-                        connected = true;
-                        break;
-                    }
-                    catch (error) {
-                        // #region agent log
-                        fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:522', message: 'connection attempt failed', data: { serverId: server.id, attempt: attempt + 1, errorMessage: error instanceof Error ? error.message : String(error) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
-                        // #endregion
-                        if (attempt < 2) {
-                            // Wait a bit before retrying
-                            await new Promise(resolve => setTimeout(resolve, 500));
-                        }
-                        else {
-                            logger.error(`Failed to connect to server ${server.id} after ${attempt + 1} attempts: ${error}`);
-                        }
-                    }
-                }
-                if (!connected) {
-                    // #region agent log
-                    fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:530', message: 'server connection failed after retries', data: { serverId: server.id, isInitialized: this.initializationTracker.isInitialized(server.id) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
-                    // #endregion
-                    logger.warn(`Server ${server.id} could not be connected after retries`);
-                }
-            }
-            // After connecting, check if all servers are now initialized
-            const stillUninitialized = allServers.filter((server) => !this.initializationTracker.isInitialized(server.id));
-            // #region agent log
-            fetch('http://127.0.0.1:7243/ingest/198b6a8b-7e4f-4c81-a922-32b1e2e171c8', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'discovery-handler.ts:535', message: 'Stage 3 after connection attempts', data: { stillUninitializedCount: stillUninitialized.length, stillUninitializedIds: stillUninitialized.map(s => s.id), initializationStatus: allServers.map(s => ({ id: s.id, initialized: this.initializationTracker.isInitialized(s.id) })) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
-            // #endregion
-            if (stillUninitialized.length > 0) {
-                // Some servers failed to initialize - return instructions
-                const instructions = this.initializationTracker.createInitInstructions(stillUninitialized.map((s) => s.id));
-                return {
-                    initialized: false,
-                    instructions: {
-                        summary: instructions.summary,
-                        role: instructions.role,
-                        goal: instructions.goal,
-                        context: instructions.context,
-                        servers: instructions.servers,
-                        steps: instructions.steps,
-                        important: instructions.important,
-                        toolOverrides: instructions.toolOverrides,
-                    },
-                };
-            }
-            // All servers initialized - fall through to Stage 4
-        }
-        // Stage 4: All servers are initialized - return concise server-level summaries
-        // Check if config file needs to be created (for backward compatibility)
-        const needsConfig = servers && servers.length > 0;
-        if (needsConfig) {
-            const path = configPath || ".mcp-filter.json";
-            try {
-                await this.configInitializer.initConfig(path, servers);
-            }
-            catch (error) {
-                logger.error(`Failed to create config file: ${error}`);
-                // Continue even if config creation fails
-            }
-        }
-        // Collect server information for concise summaries and RGC prompt
-        const connectedServers = [];
-        const erroredServers = [];
-        const serverInfoForPrompt = [];
-        let totalTools = 0;
-        for (const server of allServers) {
-            // Only process initialized servers
-            if (!this.initializationTracker.isInitialized(server.id)) {
-                // Server not initialized - add to errored servers
-                const shortDescription = server.config.short_description ||
-                    server.config.shortDescription ||
-                    undefined;
-                erroredServers.push({
-                    id: server.id,
-                    short_description: shortDescription && shortDescription.length < 100 ? shortDescription : undefined,
-                    error: "Server not initialized",
-                });
-                continue;
-            }
-            try {
-                const toolsResponse = await server.client.listTools();
-                const filteredTools = server.filter.filterList(toolsResponse.tools);
-                const toolNames = filteredTools.map((t) => t.name);
-                totalTools += toolNames.length;
-                // Get short_description from config if available
-                // Check both new format (mcpServers) and old format (servers) config
-                const shortDescription = server.config.short_description ||
-                    server.config.shortDescription ||
-                    undefined;
-                connectedServers.push({
-                    id: server.id,
-                    short_description: shortDescription && shortDescription.length < 100 ? shortDescription : undefined,
-                    toolCount: toolNames.length,
-                    toolNames,
-                });
-                serverInfoForPrompt.push({
-                    id: server.id,
-                    toolNames,
-                });
-            }
-            catch (error) {
-                logger.error(`Error listing tools from server ${server.id}: ${error}`);
-                const shortDescription = server.config.short_description ||
-                    server.config.shortDescription ||
-                    undefined;
-                erroredServers.push({
-                    id: server.id,
-                    short_description: shortDescription && shortDescription.length < 100 ? shortDescription : undefined,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        // Create RGC prompt for generating short_description
-        const descriptionPrompt = this.initializationTracker.createShortDescriptionPrompt(serverInfoForPrompt);
-        return {
-            initialized: true,
-            summary: {
-                totalTools,
-                connectedServers: connectedServers.map((s) => ({
-                    id: s.id,
-                    short_description: s.short_description,
-                    toolCount: s.toolCount,
-                    methodNames: s.toolNames,
-                })),
-                erroredServers: erroredServers.map((s) => ({
-                    id: s.id,
-                    short_description: s.short_description,
-                    error: s.error,
-                })),
-            },
-            descriptionPrompt: {
-                role: descriptionPrompt.role,
-                goal: descriptionPrompt.goal,
-                context: descriptionPrompt.context,
-                examples: descriptionPrompt.examples,
-            },
-            searchEnabled: true,
-            message: `Found ${totalTools} tool(s) across ${connectedServers.length} server(s). Use discover_tools with query parameter for semantic search.\n\n` +
-                `OPTIONAL: Optimize tool names and descriptions using 'toolOverrides' in .mcp-filter.json. ` +
-                `Only optimize when necessary: non-English names, excessively long names (>50 chars), or unclear descriptions. ` +
-                `Don't optimize if names are already short, clear, and in English. ` +
-                `Only include information the LLM doesn't already know - remove obvious information that's clear from the name.`,
-        };
-    }
-}
-//# sourceMappingURL=discovery-handler.js.map