@monoes/mcp 1.0.6 → 2.24.0

package/dist/server.js

@@ -3,154 +3,10 @@
  *
  * High-performance MCP server implementation
  */
-import { EventEmitter } from 'node:events';
-import { arch, platform } from 'node:os';
-import { createConnectionPool } from './connection-pool.js';
-import { createPromptRegistry } from './prompt-registry.js';
-import { createRateLimiter } from './rate-limiter.js';
-import { createResourceRegistry } from './resource-registry.js';
-import { createSamplingManager } from './sampling.js';
-import { createSessionManager } from './session-manager.js';
-import { createTaskManager } from './task-manager.js';
-import { createToolRegistry } from './tool-registry.js';
+import { MCPServerRouting } from './server-routing.js';
 import { createTransport } from './transport/index.js';
 import { ErrorCodes, MCPServerError } from './types.js';
-const DEFAULT_CONFIG = {
-    name: 'Monomind MCP Server V1',
-    version: '3.0.0',
-    transport: 'stdio',
-    host: 'localhost',
-    port: 3000,
-    enableMetrics: true,
-    enableCaching: true,
-    cacheTTL: 10000,
-    logLevel: 'info',
-    requestTimeout: 30000,
-    maxRequestSize: 10 * 1024 * 1024,
-};
-export class MCPServer extends EventEmitter {
-    logger;
-    orchestrator;
-    swarmCoordinator;
-    config;
-    toolRegistry;
-    sessionManager;
-    resourceRegistry;
-    promptRegistry;
-    taskManager;
-    connectionPool;
-    rateLimiter;
-    samplingManager;
-    transport;
-    running = false;
-    startTime;
-    startupDuration;
-    // Fallback singleton session, used only for transports that are inherently
-    // single-client (stdio, in-process) where the transport never supplies a
-    // connectionId to handleRequest/handleNotification.
-    currentSession;
-    // connectionId -> session, for multi-client transports (http, websocket).
-    // Without this, every connection shared `currentSession` above and a
-    // second client's `initialize` would silently reassign the session out
-    // from under the first client (issue #93).
-    connectionSessions = new Map();
-    // sessionId -> (uri -> subscriptionId). The registry-issued subscriptionId
-    // must be retained so resources/unsubscribe (and session teardown) can call
-    // resourceRegistry.unsubscribe(id) — without it callbacks leak and phantom
-    // notifications fire after unsubscribe (issue #92).
-    resourceSubscriptions = new Map();
-    serverInfo = {
-        name: 'Monomind MCP Server V1',
-        version: '3.0.0',
-    };
-    // MCP 2025-11-25 protocol version
-    protocolVersion = {
-        major: 2025,
-        minor: 11,
-        patch: 25,
-    };
-    // Full MCP 2025-11-25 capabilities
-    capabilities = {
-        logging: { level: 'info' },
-        tools: { listChanged: true },
-        resources: { listChanged: true, subscribe: true },
-        prompts: { listChanged: true },
-        sampling: {},
-    };
-    requestStats = {
-        total: 0,
-        successful: 0,
-        failed: 0,
-        totalResponseTime: 0,
-    };
-    constructor(config, logger, orchestrator, swarmCoordinator) {
-        super();
-        this.logger = logger;
-        this.orchestrator = orchestrator;
-        this.swarmCoordinator = swarmCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.toolRegistry = createToolRegistry(logger);
-        this.sessionManager = createSessionManager(logger, {
-            maxSessions: 100,
-            sessionTimeout: 30 * 60 * 1000,
-        });
-        this.resourceRegistry = createResourceRegistry(logger, {
-            enableSubscriptions: true,
-            cacheEnabled: true,
-            cacheTTL: 60000,
-        });
-        this.promptRegistry = createPromptRegistry(logger);
-        this.taskManager = createTaskManager(logger, {
-            maxConcurrentTasks: 10,
-            taskTimeout: 300000,
-        });
-        this.rateLimiter = createRateLimiter(logger, {
-            requestsPerSecond: 100,
-            burstSize: 200,
-            perSessionLimit: 50,
-        });
-        this.samplingManager = createSamplingManager(logger);
-        if (this.config.connectionPool) {
-            this.connectionPool = createConnectionPool(this.config.connectionPool, logger, this.config.transport);
-        }
-        this.setupEventHandlers();
-    }
-    /**
-     * Get resource registry for external registration
-     */
-    getResourceRegistry() {
-        return this.resourceRegistry;
-    }
-    /**
-     * Get prompt registry for external registration
-     */
-    getPromptRegistry() {
-        return this.promptRegistry;
-    }
-    /**
-     * Get task manager for async operations
-     */
-    getTaskManager() {
-        return this.taskManager;
-    }
-    /**
-     * Get rate limiter for configuration
-     */
-    getRateLimiter() {
-        return this.rateLimiter;
-    }
-    /**
-     * Get sampling manager for LLM provider registration
-     */
-    getSamplingManager() {
-        return this.samplingManager;
-    }
-    /**
-     * Register an LLM provider for sampling
-     */
-    registerLLMProvider(provider, isDefault = false) {
-        this.samplingManager.registerProvider(provider, isDefault);
-    }
+export class MCPServer extends MCPServerRouting {
     async start() {
         if (this.running) {
             throw new MCPServerError('Server already running');
@@ -242,73 +98,6 @@ export class MCPServer extends EventEmitter {
             throw error;
         }
     }
-    registerTool(tool) {
-        return this.toolRegistry.register(tool);
-    }
-    registerTools(tools) {
-        return this.toolRegistry.registerBatch(tools);
-    }
-    unregisterTool(name) {
-        return this.toolRegistry.unregister(name);
-    }
-    async getHealthStatus() {
-        try {
-            const transportHealth = this.transport
-                ? await this.transport.getHealthStatus()
-                : { healthy: false, error: 'Transport not initialized' };
-            const sessionMetrics = this.sessionManager.getSessionMetrics();
-            const poolStats = this.connectionPool?.getStats();
-            const metrics = {
-                registeredTools: this.toolRegistry.getToolCount(),
-                totalRequests: this.requestStats.total,
-                successfulRequests: this.requestStats.successful,
-                failedRequests: this.requestStats.failed,
-                totalSessions: sessionMetrics.total,
-                activeSessions: sessionMetrics.active,
-                ...(transportHealth.metrics || {}),
-            };
-            if (poolStats) {
-                metrics.poolConnections = poolStats.totalConnections;
-                metrics.poolIdleConnections = poolStats.idleConnections;
-                metrics.poolBusyConnections = poolStats.busyConnections;
-            }
-            return {
-                healthy: this.running && transportHealth.healthy,
-                error: transportHealth.error,
-                metrics,
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    }
-    getMetrics() {
-        const sessionMetrics = this.sessionManager.getSessionMetrics();
-        const registryStats = this.toolRegistry.getStats();
-        return {
-            totalRequests: this.requestStats.total,
-            successfulRequests: this.requestStats.successful,
-            failedRequests: this.requestStats.failed,
-            averageResponseTime: this.requestStats.total > 0
-                ? this.requestStats.totalResponseTime / this.requestStats.total
-                : 0,
-            activeSessions: sessionMetrics.active,
-            toolInvocations: Object.fromEntries(registryStats.topTools.map((t) => [t.name, t.calls])),
-            errors: {},
-            lastReset: this.startTime || new Date(),
-            startupTime: this.startupDuration,
-            uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-        };
-    }
-    getSessions() {
-        return this.sessionManager.getActiveSessions();
-    }
-    getSession(sessionId) {
-        return this.sessionManager.getSession(sessionId);
-    }
     terminateSession(sessionId) {
         const result = this.sessionManager.closeSession(sessionId, 'Terminated by server');
         if (this.currentSession?.id === sessionId) {
@@ -321,59 +110,6 @@ export class MCPServer extends EventEmitter {
         }
         return result;
     }
-    /**
-     * Resolve the session bound to a connection without creating one.
-     * Multi-client transports (http, websocket) pass a `connectionId`, which is
-     * looked up in `connectionSessions`. Single-client transports (stdio,
-     * in-process) omit it, falling back to the `currentSession` singleton.
-     */
-    getSessionForConnection(connectionId) {
-        if (connectionId) {
-            return this.connectionSessions.get(connectionId);
-        }
-        return this.currentSession;
-    }
-    /**
-     * Bind a newly-created session to a connection: per-connectionId when the
-     * transport supports multiple clients, otherwise the singleton fallback.
-     */
-    bindSessionToConnection(session, connectionId) {
-        if (connectionId) {
-            this.connectionSessions.set(connectionId, session);
-        }
-        else {
-            this.currentSession = session;
-        }
-    }
-    /**
-     * Tear down the session owned by a connection when the transport reports
-     * that connection has closed — prevents closed clients' sessions (and any
-     * resource subscriptions) from lingering until the idle-timeout sweep.
-     */
-    closeConnectionSession(connectionId) {
-        const session = this.connectionSessions.get(connectionId);
-        this.connectionSessions.delete(connectionId);
-        if (session) {
-            // closeSession emits 'session:closed', which purges the session's
-            // resource subscriptions (see setupEventHandlers).
-            this.sessionManager.closeSession(session.id, 'Connection closed');
-        }
-    }
-    /**
-     * Detach every registry subscription owned by a session. Called whenever a
-     * session ends (terminated, connection closed, expired, server stopped) so
-     * no update callback outlives its session (issue #92).
-     */
-    purgeSessionSubscriptions(sessionId) {
-        const sessionSubs = this.resourceSubscriptions.get(sessionId);
-        if (!sessionSubs) {
-            return;
-        }
-        for (const subscriptionId of sessionSubs.values()) {
-            this.resourceRegistry.unsubscribe(subscriptionId);
-        }
-        this.resourceSubscriptions.delete(sessionId);
-    }
     async handleRequest(request, connectionId) {
         const startTime = performance.now();
         this.requestStats.total++;
@@ -468,579 +204,6 @@ export class MCPServer extends EventEmitter {
             result,
         };
     }
-    async routeRequest(request, connectionId) {
-        switch (request.method) {
-            // Tool methods
-            case 'tools/list':
-                return this.handleToolsList(request);
-            case 'tools/call':
-                return this.handleToolsCall(request, connectionId);
-            // Resource methods (MCP 2025-11-25)
-            case 'resources/list':
-                return this.handleResourcesList(request);
-            case 'resources/read':
-                return this.handleResourcesRead(request);
-            case 'resources/subscribe':
-                return this.handleResourcesSubscribe(request, connectionId);
-            case 'resources/unsubscribe':
-                return this.handleResourcesUnsubscribe(request, connectionId);
-            // Prompt methods (MCP 2025-11-25)
-            case 'prompts/list':
-                return this.handlePromptsList(request);
-            case 'prompts/get':
-                return this.handlePromptsGet(request);
-            // Task methods (MCP 2025-11-25)
-            case 'tasks/status':
-                return this.handleTasksStatus(request);
-            case 'tasks/cancel':
-                return this.handleTasksCancel(request);
-            // Completion (MCP 2025-11-25)
-            case 'completion/complete':
-                return this.handleCompletion(request);
-            // Logging (MCP 2025-11-25)
-            case 'logging/setLevel':
-                return this.handleLoggingSetLevel(request);
-            // Sampling (MCP 2025-11-25)
-            case 'sampling/createMessage':
-                return this.handleSamplingCreateMessage(request, connectionId);
-            // Utility
-            case 'ping':
-                return {
-                    jsonrpc: '2.0',
-                    id: request.id,
-                    result: { pong: true, timestamp: Date.now() },
-                };
-            default:
-                // Check if it's a direct tool call
-                if (this.toolRegistry.hasTool(request.method)) {
-                    return this.handleToolExecution(request, connectionId);
-                }
-                return this.createErrorResponse(request.id, ErrorCodes.METHOD_NOT_FOUND, `Method not found: ${request.method}`);
-        }
-    }
-    handleToolsList(request) {
-        const tools = this.toolRegistry.listTools().map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: this.toolRegistry.getTool(t.name)?.inputSchema,
-        }));
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { tools },
-        };
-    }
-    async handleToolsCall(request, connectionId) {
-        const params = request.params;
-        if (!params?.name) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Tool name is required');
-        }
-        const context = {
-            sessionId: this.getSessionForConnection(connectionId)?.id || 'unknown',
-            requestId: request.id,
-            orchestrator: this.orchestrator,
-            swarmCoordinator: this.swarmCoordinator,
-        };
-        const result = await this.toolRegistry.execute(params.name, params.arguments || {}, context);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    async handleToolExecution(request, connectionId) {
-        const context = {
-            sessionId: this.getSessionForConnection(connectionId)?.id || 'unknown',
-            requestId: request.id,
-            orchestrator: this.orchestrator,
-            swarmCoordinator: this.swarmCoordinator,
-        };
-        const result = await this.toolRegistry.execute(request.method, request.params || {}, context);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    // ============================================================================
-    // Resource Handlers (MCP 2025-11-25)
-    // ============================================================================
-    handleResourcesList(request) {
-        const params = request.params;
-        const result = this.resourceRegistry.list(params?.cursor);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    async handleResourcesRead(request) {
-        const params = request.params;
-        if (!params?.uri) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Resource URI is required');
-        }
-        try {
-            const result = await this.resourceRegistry.read(params.uri);
-            return {
-                jsonrpc: '2.0',
-                id: request.id,
-                result,
-            };
-        }
-        catch (error) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, error instanceof Error ? error.message : 'Resource read failed');
-        }
-    }
-    handleResourcesSubscribe(request, connectionId) {
-        const params = request.params;
-        const sessionId = this.getSessionForConnection(connectionId)?.id;
-        if (!params?.uri) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Resource URI is required');
-        }
-        if (!sessionId) {
-            return this.createErrorResponse(request.id, ErrorCodes.SERVER_NOT_INITIALIZED, 'No active session');
-        }
-        try {
-            // Track subscription for this session
-            let sessionSubs = this.resourceSubscriptions.get(sessionId);
-            if (!sessionSubs) {
-                sessionSubs = new Map();
-                this.resourceSubscriptions.set(sessionId, sessionSubs);
-            }
-            // Re-subscribing the same URI replaces the previous subscription —
-            // otherwise the old callback would keep firing with no way to reach it.
-            const existingId = sessionSubs.get(params.uri);
-            if (existingId) {
-                this.resourceRegistry.unsubscribe(existingId);
-            }
-            const subscriptionId = this.resourceRegistry.subscribe(params.uri, (uri, _content) => {
-                // Send notification when resource updates
-                this.sendNotification('notifications/resources/updated', { uri });
-            });
-            sessionSubs.set(params.uri, subscriptionId);
-            return {
-                jsonrpc: '2.0',
-                id: request.id,
-                result: { subscriptionId },
-            };
-        }
-        catch (error) {
-            return this.createErrorResponse(request.id, ErrorCodes.INTERNAL_ERROR, error instanceof Error ? error.message : 'Subscription failed');
-        }
-    }
-    handleResourcesUnsubscribe(request, connectionId) {
-        const params = request.params;
-        const sessionId = this.getSessionForConnection(connectionId)?.id;
-        if (!params?.uri) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Resource URI is required');
-        }
-        if (sessionId) {
-            const sessionSubs = this.resourceSubscriptions.get(sessionId);
-            const subscriptionId = sessionSubs?.get(params.uri);
-            if (sessionSubs && subscriptionId) {
-                // Actually detach the registry callback — just forgetting the URI
-                // locally left the callback live, producing phantom notifications
-                // (issue #92).
-                this.resourceRegistry.unsubscribe(subscriptionId);
-                sessionSubs.delete(params.uri);
-                if (sessionSubs.size === 0) {
-                    this.resourceSubscriptions.delete(sessionId);
-                }
-            }
-        }
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { success: true },
-        };
-    }
-    // ============================================================================
-    // Prompt Handlers (MCP 2025-11-25)
-    // ============================================================================
-    handlePromptsList(request) {
-        const params = request.params;
-        const result = this.promptRegistry.list(params?.cursor);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result,
-        };
-    }
-    async handlePromptsGet(request) {
-        const params = request.params;
-        if (!params?.name) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Prompt name is required');
-        }
-        try {
-            const result = await this.promptRegistry.get(params.name, params.arguments);
-            return {
-                jsonrpc: '2.0',
-                id: request.id,
-                result,
-            };
-        }
-        catch (error) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, error instanceof Error ? error.message : 'Prompt get failed');
-        }
-    }
-    // ============================================================================
-    // Task Handlers (MCP 2025-11-25)
-    // ============================================================================
-    handleTasksStatus(request) {
-        const params = request.params;
-        if (params?.taskId) {
-            const task = this.taskManager.getTask(params.taskId);
-            if (!task) {
-                return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, `Task not found: ${params.taskId}`);
-            }
-            return {
-                jsonrpc: '2.0',
-                id: request.id,
-                result: task,
-            };
-        }
-        // Return all tasks
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { tasks: this.taskManager.getAllTasks() },
-        };
-    }
-    handleTasksCancel(request) {
-        const params = request.params;
-        if (!params?.taskId) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Task ID is required');
-        }
-        const success = this.taskManager.cancelTask(params.taskId, params.reason);
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { success },
-        };
-    }
-    // ============================================================================
-    // Completion Handler (MCP 2025-11-25)
-    // ============================================================================
-    handleCompletion(request) {
-        const params = request.params;
-        if (!params?.ref || !params?.argument) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Completion reference and argument are required');
-        }
-        // Basic completion implementation - can be extended
-        const completions = [];
-        if (params.ref.type === 'ref/prompt') {
-            // Get prompt argument completions
-            const prompt = this.promptRegistry.getPrompt(params.ref.name || '');
-            if (prompt?.arguments) {
-                for (const arg of prompt.arguments) {
-                    if (arg.name === params.argument.name) {
-                        // Could add domain-specific completions here
-                    }
-                }
-            }
-        }
-        else if (params.ref.type === 'ref/resource') {
-            // Get resource URI completions
-            const { resources } = this.resourceRegistry.list();
-            for (const resource of resources) {
-                if (resource.uri.startsWith(params.argument.value)) {
-                    completions.push(resource.uri);
-                }
-            }
-        }
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: {
-                completion: {
-                    values: completions.slice(0, 10),
-                    total: completions.length,
-                    hasMore: completions.length > 10,
-                },
-            },
-        };
-    }
-    // ============================================================================
-    // Logging Handler (MCP 2025-11-25)
-    // ============================================================================
-    handleLoggingSetLevel(request) {
-        const params = request.params;
-        if (!params?.level) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'Log level is required');
-        }
-        // Update capabilities
-        this.capabilities.logging = { level: params.level };
-        this.logger.info('Log level updated', { level: params.level });
-        return {
-            jsonrpc: '2.0',
-            id: request.id,
-            result: { success: true },
-        };
-    }
-    // ============================================================================
-    // Sampling Handler (MCP 2025-11-25)
-    // ============================================================================
-    async handleSamplingCreateMessage(request, connectionId) {
-        const params = request.params;
-        if (!params?.messages || !params?.maxTokens) {
-            return this.createErrorResponse(request.id, ErrorCodes.INVALID_PARAMS, 'messages and maxTokens are required');
-        }
-        // Check if sampling is available
-        const available = await this.samplingManager.isAvailable();
-        if (!available) {
-            return this.createErrorResponse(request.id, ErrorCodes.INTERNAL_ERROR, 'No LLM provider available for sampling');
-        }
-        try {
-            const result = await this.samplingManager.createMessage({
-                messages: params.messages.map((m) => ({
-                    role: m.role,
-                    content: m.content,
-                })),
-                maxTokens: params.maxTokens,
-                systemPrompt: params.systemPrompt,
-                modelPreferences: params.modelPreferences,
-                includeContext: params.includeContext,
-                temperature: params.temperature,
-                stopSequences: params.stopSequences,
-                metadata: params.metadata,
-            }, {
-                sessionId: this.getSessionForConnection(connectionId)?.id || 'unknown',
-                serverId: this.serverInfo.name,
-            });
-            return {
-                jsonrpc: '2.0',
-                id: request.id,
-                result,
-            };
-        }
-        catch (error) {
-            return this.createErrorResponse(request.id, ErrorCodes.INTERNAL_ERROR, error instanceof Error ? error.message : 'Sampling failed');
-        }
-    }
-    // ============================================================================
-    // Notification Sender
-    // ============================================================================
-    async sendNotification(method, params) {
-        if (this.transport?.sendNotification) {
-            await this.transport.sendNotification({
-                jsonrpc: '2.0',
-                method,
-                params,
-            });
-        }
-    }
-    getOrCreateSession(connectionId) {
-        const existing = this.getSessionForConnection(connectionId);
-        if (existing) {
-            return existing;
-        }
-        // A client is calling a non-initialize method on a connection that never
-        // sent `initialize` (or whose session already expired). Create a fresh
-        // session bound to this specific connection rather than reusing/
-        // overwriting another client's session.
-        const session = this.sessionManager.createSession(this.config.transport);
-        this.bindSessionToConnection(session, connectionId);
-        return session;
-    }
-    createErrorResponse(id, code, message) {
-        return {
-            jsonrpc: '2.0',
-            id,
-            error: { code, message },
-        };
-    }
-    async registerBuiltInTools() {
-        this.registerTool({
-            name: 'system/info',
-            description: 'Get system information',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => ({
-                name: this.serverInfo.name,
-                version: this.serverInfo.version,
-                platform: platform(),
-                arch: arch(),
-                runtime: 'Node.js',
-                uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-            }),
-            category: 'system',
-        });
-        this.registerTool({
-            name: 'system/health',
-            description: 'Get system health status',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => await this.getHealthStatus(),
-            category: 'system',
-            cacheable: true,
-            cacheTTL: 2000,
-        });
-        this.registerTool({
-            name: 'system/metrics',
-            description: 'Get server metrics',
-            inputSchema: { type: 'object', properties: {} },
-            handler: async () => this.getMetrics(),
-            category: 'system',
-            cacheable: true,
-            cacheTTL: 1000,
-        });
-        this.registerTool({
-            name: 'tools/list-detailed',
-            description: 'List all registered tools with details',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    category: { type: 'string', description: 'Filter by category' },
-                },
-            },
-            handler: async (input) => {
-                const params = input;
-                if (params.category) {
-                    return this.toolRegistry.getByCategory(params.category);
-                }
-                return this.toolRegistry.listTools();
-            },
-            category: 'system',
-        });
-        this.logger.info('Built-in tools registered', {
-            count: 4,
-        });
-    }
-    // P2-1: Populate the Resources registry with system-level resources.
-    // The registry scaffolding always shipped empty — these adapter registrations
-    // surface monomind's state to MCP clients as app-driven context.
-    registerBuiltInResources() {
-        this.resourceRegistry.registerResource({
-            uri: 'monomind://system/status',
-            name: 'System Status',
-            description: 'Current monomind MCP server health, uptime, and tool count',
-            mimeType: 'application/json',
-        }, async (uri) => [
-            {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify({
-                    status: 'running',
-                    uptime: this.startTime ? Date.now() - this.startTime.getTime() : 0,
-                    tools: this.toolRegistry.listTools().length,
-                    version: this.serverInfo.version,
-                }, null, 2),
-            },
-        ]);
-        this.resourceRegistry.registerResource({
-            uri: 'monomind://system/metrics',
-            name: 'Server Metrics',
-            description: 'Request count, cache hit rate, error rate',
-            mimeType: 'application/json',
-        }, async (uri) => [
-            {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify(this.getMetrics(), null, 2),
-            },
-        ]);
-        this.resourceRegistry.registerResource({
-            uri: 'monomind://system/tools',
-            name: 'Tool Inventory',
-            description: 'Complete list of registered MCP tools with categories',
-            mimeType: 'application/json',
-        }, async (uri) => [
-            {
-                uri,
-                mimeType: 'application/json',
-                text: JSON.stringify(this.toolRegistry.listTools(), null, 2),
-            },
-        ]);
-        this.logger.info('Built-in resources registered', { count: 3 });
-    }
-    // P2-2: Populate the Prompts registry with curated workflow templates.
-    // These give MCP clients pre-built prompt structures for common dev tasks.
-    registerBuiltInPrompts() {
-        this.promptRegistry.register({
-            name: 'monomind:research-plan',
-            description: 'Generate a structured research plan for a topic',
-            arguments: [{ name: 'topic', description: 'The research topic', required: true }],
-            handler: async (args) => [
-                {
-                    role: 'user',
-                    content: {
-                        type: 'text',
-                        text: `Research plan for: ${args.topic ?? '(unspecified)'}\n\n1. Define scope and key questions\n2. Identify sources and prior work\n3. Outline methodology\n4. Execute research (parallel agents if appropriate)\n5. Synthesize findings\n6. Review and refine`,
-                    },
-                },
-            ],
-        });
-        this.promptRegistry.register({
-            name: 'monomind:pr-review',
-            description: 'Structured pull-request review checklist',
-            arguments: [{ name: 'changes', description: 'Description of the changes', required: true }],
-            handler: async (args) => [
-                {
-                    role: 'user',
-                    content: {
-                        type: 'text',
-                        text: `PR Review checklist for: ${args.changes ?? '(unspecified)'}\n\n- [ ] Correctness: does the code do what it claims?\n- [ ] Tests: are there tests covering the changes?\n- [ ] Security: any input validation gaps?\n- [ ] Performance: any O(n²) or unnecessary allocations?\n- [ ] Docs: are relevant docs updated?\n- [ ] Breaking changes: any removed APIs or changed behavior?\n- [ ] Honesty: any fabricated metrics or misleading output?`,
-                    },
-                },
-            ],
-        });
-        this.promptRegistry.register({
-            name: 'monomind:debug-protocol',
-            description: 'Systematic root-cause debugging protocol (4-phase)',
-            arguments: [
-                {
-                    name: 'symptom',
-                    description: 'Description of the bug or unexpected behavior',
-                    required: true,
-                },
-            ],
-            handler: async (args) => [
-                {
-                    role: 'user',
-                    content: {
-                        type: 'text',
-                        text: `Debug protocol for: ${args.symptom ?? '(unspecified)'}\n\nPhase 1 — REPRODUCE: Write a test that triggers the bug. Verify it fails.\nPhase 2 — ISOLATE: Binary-search the cause. What's the smallest change that triggers it?\nPhase 3 — FIX: Make the test pass with the minimal code change.\nPhase 4 — VERIFY: Run the full test suite. Confirm no regressions.`,
-                    },
-                },
-            ],
-        });
-        this.logger.info('Built-in prompts registered', { count: 3 });
-    }
-    setupEventHandlers() {
-        this.toolRegistry.on('tool:registered', (name) => {
-            this.emit('tool:registered', name);
-        });
-        this.toolRegistry.on('tool:called', (data) => {
-            this.emit('tool:called', data);
-        });
-        this.toolRegistry.on('tool:completed', (data) => {
-            this.emit('tool:completed', data);
-        });
-        this.toolRegistry.on('tool:error', (data) => {
-            this.emit('tool:error', data);
-        });
-        this.sessionManager.on('session:created', (session) => {
-            this.emit('session:created', session);
-        });
-        this.sessionManager.on('session:closed', (data) => {
-            this.purgeSessionSubscriptions(data.session.id);
-            this.emit('session:closed', data);
-        });
-        this.sessionManager.on('session:expired', (session) => {
-            this.purgeSessionSubscriptions(session.id);
-            // Drop references to the expired session — otherwise `currentSession` /
-            // `connectionSessions` keep pointing at a session the manager has
-            // already reaped, and subsequent updateActivity calls fail silently
-            // against the ghost (issue #93).
-            if (this.currentSession?.id === session.id) {
-                this.currentSession = undefined;
-            }
-            for (const [connectionId, s] of this.connectionSessions) {
-                if (s.id === session.id) {
-                    this.connectionSessions.delete(connectionId);
-                }
-            }
-            this.emit('session:expired', session);
-        });
-    }
 }
 export function createMCPServer(config, logger, orchestrator, swarmCoordinator) {
     return new MCPServer(config, logger, orchestrator, swarmCoordinator);