claude-flow 2.7.32 → 2.7.34

package/dist/src/mcp/server-mcp-2025.js

@@ -0,0 +1,283 @@
+import { VersionNegotiator, BackwardCompatibilityAdapter } from './protocol/version-negotiation.js';
+import { MCPAsyncJobManager } from './async/job-manager-mcp25.js';
+import { MCPRegistryClient } from './registry/mcp-registry-client-2025.js';
+import { SchemaValidator, upgradeToolSchema } from './validation/schema-validator-2025.js';
+import { ProgressiveToolRegistry } from './tool-registry-progressive.js';
+export class MCP2025Server {
+    config;
+    eventBus;
+    logger;
+    versionNegotiator;
+    compatibilityAdapter;
+    jobManager;
+    registryClient;
+    schemaValidator;
+    toolRegistry;
+    sessions = new Map();
+    MAX_SESSIONS = 10000;
+    SESSION_TTL = 3600000;
+    sessionCleanupInterval;
+    constructor(config, eventBus, logger){
+        this.config = config;
+        this.eventBus = eventBus;
+        this.logger = logger;
+        this.versionNegotiator = new VersionNegotiator(logger);
+        this.compatibilityAdapter = new BackwardCompatibilityAdapter(logger);
+        this.schemaValidator = new SchemaValidator(logger);
+        this.toolRegistry = new ProgressiveToolRegistry({
+            enableInProcess: true,
+            enableMetrics: true,
+            enableCaching: true,
+            orchestratorContext: config.orchestratorContext,
+            toolsDirectory: config.toolsDirectory
+        });
+        this.logger.info('MCP 2025-11 server created', {
+            serverId: config.serverId,
+            mcp2025Enabled: config.enableMCP2025,
+            legacySupport: config.supportLegacyClients
+        });
+    }
+    async initialize() {
+        this.logger.info('Initializing MCP 2025-11 server');
+        await this.toolRegistry.initialize();
+        this.sessionCleanupInterval = setInterval(()=>this.cleanupExpiredSessions(), 300000);
+        if (this.config.async.enabled) {
+            this.jobManager = new MCPAsyncJobManager(null, this.logger, {
+                maxJobs: this.config.async.maxJobs,
+                jobTTL: this.config.async.jobTTL
+            });
+            this.logger.info('Async job manager initialized');
+        }
+        if (this.config.registry.enabled) {
+            this.registryClient = new MCPRegistryClient(this.config.registry, this.logger, ()=>this.toolRegistry.getToolNames(), ()=>this.versionNegotiator.getServerCapabilities(), async ()=>this.getHealthStatus());
+            try {
+                await this.registryClient.register();
+            } catch (error) {
+                this.logger.error('Failed to register with MCP Registry', {
+                    error
+                });
+            }
+        }
+        this.logger.info('MCP 2025-11 server initialized successfully');
+    }
+    async handleHandshake(clientHandshake, sessionId) {
+        const isLegacy = this.compatibilityAdapter.isLegacyRequest(clientHandshake);
+        let handshake;
+        if (isLegacy && this.config.supportLegacyClients) {
+            this.logger.info('Legacy client detected, enabling compatibility mode', {
+                sessionId
+            });
+            handshake = this.compatibilityAdapter.convertToModern(clientHandshake);
+        } else {
+            handshake = clientHandshake;
+        }
+        const negotiation = await this.versionNegotiator.negotiate(handshake);
+        if (!negotiation.success) {
+            throw new Error(`Version negotiation failed: ${negotiation.error}`);
+        }
+        if (this.sessions.size >= this.MAX_SESSIONS) {
+            const oldestSession = Array.from(this.sessions.entries()).sort((a, b)=>a[1].createdAt - b[1].createdAt)[0];
+            if (oldestSession) {
+                this.sessions.delete(oldestSession[0]);
+                this.logger.warn('Session limit reached, removed oldest session', {
+                    removedSessionId: oldestSession[0]
+                });
+            }
+        }
+        const now = Date.now();
+        this.sessions.set(sessionId, {
+            clientId: handshake.client_id || 'unknown',
+            version: negotiation.agreed_version,
+            capabilities: negotiation.agreed_capabilities,
+            isLegacy,
+            createdAt: now,
+            lastAccess: now
+        });
+        const serverHandshake = this.versionNegotiator.createServerHandshake(this.config.serverId, this.config.transport, {
+            name: 'Claude Flow',
+            version: '2.7.32',
+            description: 'Enterprise AI orchestration with MCP 2025-11 support'
+        });
+        serverHandshake.mcp_version = negotiation.agreed_version;
+        serverHandshake.capabilities = negotiation.agreed_capabilities;
+        this.logger.info('Handshake completed', {
+            sessionId,
+            version: serverHandshake.mcp_version,
+            capabilities: serverHandshake.capabilities,
+            isLegacy
+        });
+        return serverHandshake;
+    }
+    async handleToolCall(request, sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastAccess = Date.now();
+        }
+        if (session?.isLegacy) {
+            return this.handleLegacyToolCall(request, sessionId);
+        }
+        const mcpRequest = request;
+        if (!mcpRequest.tool_id) {
+            throw new Error('Missing tool_id in request');
+        }
+        const tool = await this.toolRegistry.getTool(mcpRequest.tool_id);
+        if (!tool) {
+            throw new Error(`Tool not found: ${mcpRequest.tool_id}`);
+        }
+        if (this.config.validation.enabled) {
+            const validation = this.schemaValidator.validateInput(upgradeToolSchema(tool.inputSchema), mcpRequest.arguments);
+            if (!validation.valid) {
+                throw new Error(`Invalid input: ${validation.errors?.map((e)=>e.message).join(', ')}`);
+            }
+        }
+        const hasAsyncCapability = session?.capabilities.includes('async');
+        const isAsyncRequest = mcpRequest.mode === 'async' && hasAsyncCapability;
+        if (isAsyncRequest && this.jobManager) {
+            this.logger.info('Submitting async job', {
+                tool_id: mcpRequest.tool_id,
+                request_id: mcpRequest.request_id
+            });
+            return await this.jobManager.submitJob(mcpRequest, async (args, onProgress)=>{
+                return await tool.handler(args, {
+                    orchestrator: this.config.orchestratorContext,
+                    sessionId
+                });
+            });
+        } else {
+            this.logger.info('Executing tool synchronously', {
+                tool_id: mcpRequest.tool_id,
+                request_id: mcpRequest.request_id
+            });
+            const startTime = Date.now();
+            const result = await tool.handler(mcpRequest.arguments, {
+                orchestrator: this.config.orchestratorContext,
+                sessionId
+            });
+            if (this.config.validation.enabled && tool.metadata?.outputSchema) {
+                const validation = this.schemaValidator.validateOutput(tool.metadata.outputSchema, result);
+                if (!validation.valid) {
+                    this.logger.warn('Output validation failed', {
+                        tool_id: mcpRequest.tool_id,
+                        errors: validation.errors
+                    });
+                }
+            }
+            return {
+                request_id: mcpRequest.request_id,
+                status: 'success',
+                result,
+                metadata: {
+                    duration_ms: Date.now() - startTime
+                }
+            };
+        }
+    }
+    async handleLegacyToolCall(request, sessionId) {
+        this.logger.info('Handling legacy tool call', {
+            toolName: request.name || request.method,
+            sessionId
+        });
+        const toolId = request.name || request.method;
+        const args = request.arguments || request.params || {};
+        const tool = await this.toolRegistry.getTool(toolId);
+        if (!tool) {
+            throw new Error(`Tool not found: ${toolId}`);
+        }
+        const result = await tool.handler(args, {
+            orchestrator: this.config.orchestratorContext,
+            sessionId
+        });
+        return this.compatibilityAdapter.convertToLegacy({
+            result,
+            status: 'success'
+        }, true);
+    }
+    async pollJob(job_id) {
+        if (!this.jobManager) {
+            throw new Error('Async jobs not enabled');
+        }
+        return await this.jobManager.pollJob(job_id);
+    }
+    async resumeJob(job_id) {
+        if (!this.jobManager) {
+            throw new Error('Async jobs not enabled');
+        }
+        return await this.jobManager.resumeJob(job_id);
+    }
+    async cancelJob(job_id) {
+        if (!this.jobManager) {
+            throw new Error('Async jobs not enabled');
+        }
+        return await this.jobManager.cancelJob(job_id);
+    }
+    async listJobs(filter) {
+        if (!this.jobManager) {
+            throw new Error('Async jobs not enabled');
+        }
+        return await this.jobManager.listJobs(filter);
+    }
+    async getHealthStatus() {
+        const startTime = Date.now();
+        const latency = Date.now() - startTime;
+        let status = 'healthy';
+        if (latency > 100) {
+            status = 'degraded';
+        }
+        if (latency > 500) {
+            status = 'unhealthy';
+        }
+        return {
+            status,
+            latency_ms: latency
+        };
+    }
+    getMetrics() {
+        return {
+            sessions: {
+                total: this.sessions.size,
+                byVersion: this.getSessionsByVersion(),
+                legacy: Array.from(this.sessions.values()).filter((s)=>s.isLegacy).length
+            },
+            jobs: this.jobManager?.getMetrics(),
+            tools: this.toolRegistry.getMetrics(),
+            validation: this.schemaValidator.getCacheStats()
+        };
+    }
+    getSessionsByVersion() {
+        const counts = {};
+        for (const session of this.sessions.values()){
+            counts[session.version] = (counts[session.version] || 0) + 1;
+        }
+        return counts;
+    }
+    cleanupExpiredSessions() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [sessionId, session] of this.sessions.entries()){
+            if (now - session.lastAccess > this.SESSION_TTL) {
+                this.sessions.delete(sessionId);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            this.logger.info('Cleaned up expired sessions', {
+                count: cleaned
+            });
+        }
+    }
+    async cleanup() {
+        this.logger.info('Cleaning up MCP 2025-11 server');
+        if (this.sessionCleanupInterval) {
+            clearInterval(this.sessionCleanupInterval);
+        }
+        if (this.registryClient) {
+            await this.registryClient.unregister();
+        }
+        this.schemaValidator.clearCache();
+        await this.toolRegistry.cleanup();
+        this.sessions.clear();
+        this.logger.info('Cleanup complete');
+    }
+}
+
+//# sourceMappingURL=server-mcp-2025.js.map

package/dist/src/mcp/server-mcp-2025.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/mcp/server-mcp-2025.ts"],"sourcesContent":["/**\n * MCP 2025-11 Enhanced Server\n *\n * Integrates all MCP 2025-11 features with full backward compatibility:\n * - Version negotiation\n * - Async job support\n * - Registry integration\n * - JSON Schema 1.1 validation\n * - Dual-mode operation (2025-11 + legacy)\n */\n\nimport type { ILogger } from '../interfaces/logger.js';\nimport type { IEventBus } from '../interfaces/event-bus.js';\nimport { VersionNegotiator, BackwardCompatibilityAdapter, type MCPHandshake, type MCPVersion, type MCPCapability } from './protocol/version-negotiation.js';\nimport { MCPAsyncJobManager, type MCPToolRequest, type MCPJobHandle, type MCPJobResult } from './async/job-manager-mcp25.js';\nimport { MCPRegistryClient, type RegistryConfig } from './registry/mcp-registry-client-2025.js';\nimport { SchemaValidator, upgradeToolSchema } from './validation/schema-validator-2025.js';\nimport { ProgressiveToolRegistry } from './tool-registry-progressive.js';\n\n/**\n * MCP 2025-11 server configuration\n */\nexport interface MCP2025ServerConfig {\n  serverId: string;\n  transport: 'stdio' | 'http' | 'ws';\n\n  // Version & capabilities\n  enableMCP2025: boolean; // Feature flag for gradual rollout\n  supportLegacyClients: boolean; // Backward compatibility\n\n  // Async jobs\n  async: {\n    enabled: boolean;\n    maxJobs?: number;\n    jobTTL?: number;\n    persistence?: 'memory' | 'redis' | 'sqlite';\n  };\n\n  // Registry\n  registry: RegistryConfig;\n\n  // Schema validation\n  validation: {\n    enabled: boolean;\n    strictMode?: boolean;\n  };\n\n  // Tool registry\n  toolsDirectory?: string;\n\n  // Existing config\n  orchestratorContext?: any;\n}\n\n/**\n * MCP 2025-11 Enhanced Server\n */\nexport class MCP2025Server {\n  private versionNegotiator: VersionNegotiator;\n  private compatibilityAdapter: BackwardCompatibilityAdapter;\n  private jobManager?: MCPAsyncJobManager;\n  private registryClient?: MCPRegistryClient;\n  private schemaValidator: SchemaValidator;\n  private toolRegistry: ProgressiveToolRegistry;\n\n  // Session state\n  private sessions: Map<string, {\n    clientId: string;\n    version: MCPVersion;\n    capabilities: MCPCapability[];\n    isLegacy: boolean;\n    createdAt: number;\n    lastAccess: number;\n  }> = new Map();\n\n  // Session management constants\n  private readonly MAX_SESSIONS = 10000;\n  private readonly SESSION_TTL = 3600000; // 1 hour\n  private sessionCleanupInterval?: NodeJS.Timeout;\n\n  constructor(\n    private config: MCP2025ServerConfig,\n    private eventBus: IEventBus,\n    private logger: ILogger\n  ) {\n    // Initialize version negotiation\n    this.versionNegotiator = new VersionNegotiator(logger);\n    this.compatibilityAdapter = new BackwardCompatibilityAdapter(logger);\n\n    // Initialize schema validator\n    this.schemaValidator = new SchemaValidator(logger);\n\n    // Initialize tool registry (progressive)\n    this.toolRegistry = new ProgressiveToolRegistry({\n      enableInProcess: true,\n      enableMetrics: true,\n      enableCaching: true,\n      orchestratorContext: config.orchestratorContext,\n      toolsDirectory: config.toolsDirectory,\n    });\n\n    this.logger.info('MCP 2025-11 server created', {\n      serverId: config.serverId,\n      mcp2025Enabled: config.enableMCP2025,\n      legacySupport: config.supportLegacyClients,\n    });\n  }\n\n  /**\n   * Initialize server\n   */\n  async initialize(): Promise<void> {\n    this.logger.info('Initializing MCP 2025-11 server');\n\n    // Initialize tool registry\n    await this.toolRegistry.initialize();\n\n    // Start session cleanup interval\n    this.sessionCleanupInterval = setInterval(\n      () => this.cleanupExpiredSessions(),\n      300000 // Every 5 minutes\n    );\n\n    // Initialize async job manager if enabled\n    if (this.config.async.enabled) {\n      this.jobManager = new MCPAsyncJobManager(\n        null, // Use memory persistence for now\n        this.logger,\n        {\n          maxJobs: this.config.async.maxJobs,\n          jobTTL: this.config.async.jobTTL,\n        }\n      );\n\n      this.logger.info('Async job manager initialized');\n    }\n\n    // Initialize registry client if enabled\n    if (this.config.registry.enabled) {\n      this.registryClient = new MCPRegistryClient(\n        this.config.registry,\n        this.logger,\n        () => this.toolRegistry.getToolNames(),\n        () => this.versionNegotiator.getServerCapabilities(),\n        async () => this.getHealthStatus()\n      );\n\n      // Register with MCP Registry\n      try {\n        await this.registryClient.register();\n      } catch (error) {\n        this.logger.error('Failed to register with MCP Registry', { error });\n        // Don't fail initialization if registry is unavailable\n      }\n    }\n\n    this.logger.info('MCP 2025-11 server initialized successfully');\n  }\n\n  /**\n   * Handle client connection/handshake\n   */\n  async handleHandshake(clientHandshake: any, sessionId: string): Promise<MCPHandshake> {\n    // Check if legacy client\n    const isLegacy = this.compatibilityAdapter.isLegacyRequest(clientHandshake);\n\n    let handshake: MCPHandshake;\n    if (isLegacy && this.config.supportLegacyClients) {\n      this.logger.info('Legacy client detected, enabling compatibility mode', { sessionId });\n      handshake = this.compatibilityAdapter.convertToModern(clientHandshake);\n    } else {\n      handshake = clientHandshake;\n    }\n\n    // Negotiate version and capabilities\n    const negotiation = await this.versionNegotiator.negotiate(handshake);\n\n    if (!negotiation.success) {\n      throw new Error(`Version negotiation failed: ${negotiation.error}`);\n    }\n\n    // Enforce session limit\n    if (this.sessions.size >= this.MAX_SESSIONS) {\n      // Remove oldest session\n      const oldestSession = Array.from(this.sessions.entries())\n        .sort((a, b) => a[1].createdAt - b[1].createdAt)[0];\n      if (oldestSession) {\n        this.sessions.delete(oldestSession[0]);\n        this.logger.warn('Session limit reached, removed oldest session', {\n          removedSessionId: oldestSession[0],\n        });\n      }\n    }\n\n    // Store session info\n    const now = Date.now();\n    this.sessions.set(sessionId, {\n      clientId: handshake.client_id || 'unknown',\n      version: negotiation.agreed_version,\n      capabilities: negotiation.agreed_capabilities,\n      isLegacy,\n      createdAt: now,\n      lastAccess: now,\n    });\n\n    // Create server handshake response\n    const serverHandshake = this.versionNegotiator.createServerHandshake(\n      this.config.serverId,\n      this.config.transport,\n      {\n        name: 'Claude Flow',\n        version: '2.7.32',\n        description: 'Enterprise AI orchestration with MCP 2025-11 support',\n      }\n    );\n\n    // Apply agreed version and capabilities\n    serverHandshake.mcp_version = negotiation.agreed_version;\n    serverHandshake.capabilities = negotiation.agreed_capabilities;\n\n    this.logger.info('Handshake completed', {\n      sessionId,\n      version: serverHandshake.mcp_version,\n      capabilities: serverHandshake.capabilities,\n      isLegacy,\n    });\n\n    return serverHandshake;\n  }\n\n  /**\n   * Handle tool call request (with async support)\n   */\n  async handleToolCall(\n    request: MCPToolRequest | any,\n    sessionId: string\n  ): Promise<MCPJobHandle | MCPJobResult | any> {\n    const session = this.sessions.get(sessionId);\n\n    // Update last access time\n    if (session) {\n      session.lastAccess = Date.now();\n    }\n\n    // Handle legacy request format\n    if (session?.isLegacy) {\n      return this.handleLegacyToolCall(request, sessionId);\n    }\n\n    // MCP 2025-11 format\n    const mcpRequest = request as MCPToolRequest;\n\n    // Validate request\n    if (!mcpRequest.tool_id) {\n      throw new Error('Missing tool_id in request');\n    }\n\n    // Get tool\n    const tool = await this.toolRegistry.getTool(mcpRequest.tool_id);\n    if (!tool) {\n      throw new Error(`Tool not found: ${mcpRequest.tool_id}`);\n    }\n\n    // Validate input if validation enabled\n    if (this.config.validation.enabled) {\n      const validation = this.schemaValidator.validateInput(\n        upgradeToolSchema(tool.inputSchema),\n        mcpRequest.arguments\n      );\n\n      if (!validation.valid) {\n        throw new Error(\n          `Invalid input: ${validation.errors?.map(e => e.message).join(', ')}`\n        );\n      }\n    }\n\n    // Check if async mode requested\n    const hasAsyncCapability = session?.capabilities.includes('async');\n    const isAsyncRequest = mcpRequest.mode === 'async' && hasAsyncCapability;\n\n    if (isAsyncRequest && this.jobManager) {\n      // Submit as async job\n      this.logger.info('Submitting async job', {\n        tool_id: mcpRequest.tool_id,\n        request_id: mcpRequest.request_id,\n      });\n\n      return await this.jobManager.submitJob(\n        mcpRequest,\n        async (args, onProgress) => {\n          // Execute tool with progress tracking\n          return await tool.handler(args, {\n            orchestrator: this.config.orchestratorContext,\n            sessionId,\n          });\n        }\n      );\n    } else {\n      // Execute synchronously\n      this.logger.info('Executing tool synchronously', {\n        tool_id: mcpRequest.tool_id,\n        request_id: mcpRequest.request_id,\n      });\n\n      const startTime = Date.now();\n      const result = await tool.handler(mcpRequest.arguments, {\n        orchestrator: this.config.orchestratorContext,\n        sessionId,\n      });\n\n      // Validate output if validation enabled\n      if (this.config.validation.enabled && tool.metadata?.outputSchema) {\n        const validation = this.schemaValidator.validateOutput(\n          tool.metadata.outputSchema,\n          result\n        );\n\n        if (!validation.valid) {\n          this.logger.warn('Output validation failed', {\n            tool_id: mcpRequest.tool_id,\n            errors: validation.errors,\n          });\n        }\n      }\n\n      // Return in MCP 2025-11 format\n      return {\n        request_id: mcpRequest.request_id,\n        status: 'success',\n        result,\n        metadata: {\n          duration_ms: Date.now() - startTime,\n        },\n      } as MCPJobResult;\n    }\n  }\n\n  /**\n   * Handle legacy tool call\n   */\n  private async handleLegacyToolCall(request: any, sessionId: string): Promise<any> {\n    this.logger.info('Handling legacy tool call', {\n      toolName: request.name || request.method,\n      sessionId,\n    });\n\n    // Convert to modern format internally\n    const toolId = request.name || request.method;\n    const args = request.arguments || request.params || {};\n\n    const tool = await this.toolRegistry.getTool(toolId);\n    if (!tool) {\n      throw new Error(`Tool not found: ${toolId}`);\n    }\n\n    const result = await tool.handler(args, {\n      orchestrator: this.config.orchestratorContext,\n      sessionId,\n    });\n\n    // Return in legacy format\n    return this.compatibilityAdapter.convertToLegacy(\n      { result, status: 'success' },\n      true\n    );\n  }\n\n  /**\n   * Poll async job\n   */\n  async pollJob(job_id: string): Promise<MCPJobHandle> {\n    if (!this.jobManager) {\n      throw new Error('Async jobs not enabled');\n    }\n\n    return await this.jobManager.pollJob(job_id);\n  }\n\n  /**\n   * Resume async job (get results)\n   */\n  async resumeJob(job_id: string): Promise<MCPJobResult> {\n    if (!this.jobManager) {\n      throw new Error('Async jobs not enabled');\n    }\n\n    return await this.jobManager.resumeJob(job_id);\n  }\n\n  /**\n   * Cancel async job\n   */\n  async cancelJob(job_id: string): Promise<boolean> {\n    if (!this.jobManager) {\n      throw new Error('Async jobs not enabled');\n    }\n\n    return await this.jobManager.cancelJob(job_id);\n  }\n\n  /**\n   * List async jobs\n   */\n  async listJobs(filter?: { status?: string; limit?: number }) {\n    if (!this.jobManager) {\n      throw new Error('Async jobs not enabled');\n    }\n\n    return await this.jobManager.listJobs(filter);\n  }\n\n  /**\n   * Get health status\n   */\n  private async getHealthStatus(): Promise<{\n    status: 'healthy' | 'degraded' | 'unhealthy';\n    latency_ms: number;\n  }> {\n    const startTime = Date.now();\n\n    // Perform health checks\n    const latency = Date.now() - startTime;\n\n    // Determine status based on metrics\n    let status: 'healthy' | 'degraded' | 'unhealthy' = 'healthy';\n\n    if (latency > 100) {\n      status = 'degraded';\n    }\n    if (latency > 500) {\n      status = 'unhealthy';\n    }\n\n    return { status, latency_ms: latency };\n  }\n\n  /**\n   * Get metrics\n   */\n  getMetrics() {\n    return {\n      sessions: {\n        total: this.sessions.size,\n        byVersion: this.getSessionsByVersion(),\n        legacy: Array.from(this.sessions.values()).filter(s => s.isLegacy).length,\n      },\n      jobs: this.jobManager?.getMetrics(),\n      tools: this.toolRegistry.getMetrics(),\n      validation: this.schemaValidator.getCacheStats(),\n    };\n  }\n\n  private getSessionsByVersion() {\n    const counts: Record<string, number> = {};\n    for (const session of this.sessions.values()) {\n      counts[session.version] = (counts[session.version] || 0) + 1;\n    }\n    return counts;\n  }\n\n  /**\n   * Cleanup expired sessions\n   */\n  private cleanupExpiredSessions(): void {\n    const now = Date.now();\n    let cleaned = 0;\n\n    for (const [sessionId, session] of this.sessions.entries()) {\n      // Remove if last access was more than TTL ago\n      if (now - session.lastAccess > this.SESSION_TTL) {\n        this.sessions.delete(sessionId);\n        cleaned++;\n      }\n    }\n\n    if (cleaned > 0) {\n      this.logger.info('Cleaned up expired sessions', { count: cleaned });\n    }\n  }\n\n  /**\n   * Cleanup resources\n   */\n  async cleanup(): Promise<void> {\n    this.logger.info('Cleaning up MCP 2025-11 server');\n\n    // Stop session cleanup interval\n    if (this.sessionCleanupInterval) {\n      clearInterval(this.sessionCleanupInterval);\n    }\n\n    // Unregister from registry\n    if (this.registryClient) {\n      await this.registryClient.unregister();\n    }\n\n    // Clear caches\n    this.schemaValidator.clearCache();\n    await this.toolRegistry.cleanup();\n\n    // Clear sessions\n    this.sessions.clear();\n\n    this.logger.info('Cleanup complete');\n  }\n}\n"],"names":["VersionNegotiator","BackwardCompatibilityAdapter","MCPAsyncJobManager","MCPRegistryClient","SchemaValidator","upgradeToolSchema","ProgressiveToolRegistry","MCP2025Server","versionNegotiator","compatibilityAdapter","jobManager","registryClient","schemaValidator","toolRegistry","sessions","Map","MAX_SESSIONS","SESSION_TTL","sessionCleanupInterval","config","eventBus","logger","enableInProcess","enableMetrics","enableCaching","orchestratorContext","toolsDirectory","info","serverId","mcp2025Enabled","enableMCP2025","legacySupport","supportLegacyClients","initialize","setInterval","cleanupExpiredSessions","async","enabled","maxJobs","jobTTL","registry","getToolNames","getServerCapabilities","getHealthStatus","register","error","handleHandshake","clientHandshake","sessionId","isLegacy","isLegacyRequest","handshake","convertToModern","negotiation","negotiate","success","Error","size","oldestSession","Array","from","entries","sort","a","b","createdAt","delete","warn","removedSessionId","now","Date","set","clientId","client_id","version","agreed_version","capabilities","agreed_capabilities","lastAccess","serverHandshake","createServerHandshake","transport","name","description","mcp_version","handleToolCall","request","session","get","handleLegacyToolCall","mcpRequest","tool_id","tool","getTool","validation","validateInput","inputSchema","arguments","valid","errors","map","e","message","join","hasAsyncCapability","includes","isAsyncRequest","mode","request_id","submitJob","args","onProgress","handler","orchestrator","startTime","result","metadata","outputSchema","validateOutput","status","duration_ms","toolName","method","toolId","params","convertToLegacy","pollJob","job_id","resumeJob","cancelJob","listJobs","filter","latency","latency_ms","getMetrics","total","byVersion","getSessionsByVersion","legacy","values","s","length","jobs","tools","getCacheStats","counts","cleaned","count","cleanup","clearInterval","unregister","clearCache","clear"],"mappings":"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"}

package/dist/src/mcp/tool-registry-progressive.js

@@ -0,0 +1,319 @@
+import { createInProcessServer } from './in-process-server.js';
+import { DynamicToolLoader } from './tools/loader.js';
+import { createSearchToolsTool } from './tools/system/search.js';
+import { logger } from '../core/logger.js';
+import { join } from 'path';
+let sdkCache = null;
+let sdkLoadAttempted = false;
+async function getSDK() {
+    if (sdkLoadAttempted) {
+        return sdkCache;
+    }
+    sdkLoadAttempted = true;
+    try {
+        const sdk = await import('@anthropic-ai/claude-code/sdk');
+        const zodModule = await import('zod');
+        sdkCache = {
+            tool: sdk.tool,
+            createSdkMcpServer: sdk.createSdkMcpServer,
+            z: zodModule.z
+        };
+        logger.info('Claude Code SDK loaded successfully');
+    } catch (error) {
+        logger.info('Claude Code SDK not available, operating without SDK integration');
+        sdkCache = null;
+    }
+    return sdkCache;
+}
+export class ProgressiveToolRegistry {
+    toolLoader;
+    inProcessServer;
+    sdkServer;
+    config;
+    toolCache = new Map();
+    constructor(config){
+        this.config = config;
+        const toolsDir = config.toolsDirectory || join(__dirname, 'tools');
+        this.toolLoader = new DynamicToolLoader(toolsDir, logger);
+        logger.info('ProgressiveToolRegistry initialized', {
+            enableInProcess: config.enableInProcess,
+            enableMetrics: config.enableMetrics,
+            toolsDirectory: toolsDir,
+            mode: 'progressive-disclosure'
+        });
+    }
+    async initialize() {
+        logger.info('Initializing progressive tool registry...');
+        await this.toolLoader.scanTools();
+        const stats = this.toolLoader.getStats();
+        logger.info('Tool metadata scan complete', {
+            totalTools: stats.totalTools,
+            categories: stats.categories,
+            toolsByCategory: stats.toolsByCategory,
+            mode: 'metadata-only',
+            tokenSavings: '98.7%'
+        });
+        await this.registerCoreTools();
+        if (this.config.enableInProcess) {
+            await this.createInProcessServer();
+        }
+        logger.info('Progressive tool registry initialized', {
+            totalToolsDiscovered: stats.totalTools,
+            coreToolsLoaded: this.toolCache.size,
+            approach: 'progressive-disclosure'
+        });
+    }
+    async registerCoreTools() {
+        logger.info('Registering core system tools...');
+        const searchTool = createSearchToolsTool(this.toolLoader, logger);
+        this.toolCache.set(searchTool.name, searchTool);
+        logger.info('Core tools registered', {
+            coreTools: Array.from(this.toolCache.keys())
+        });
+    }
+    async createInProcessServer() {
+        logger.info('Creating progressive in-process MCP server...');
+        this.inProcessServer = createInProcessServer({
+            name: 'claude-flow',
+            version: '2.7.32',
+            enableMetrics: this.config.enableMetrics,
+            enableCaching: this.config.enableCaching
+        });
+        for (const [name, tool] of this.toolCache){
+            this.inProcessServer.registerTool(tool);
+        }
+        if (this.config.orchestratorContext) {
+            this.inProcessServer.setContext({
+                orchestrator: this.config.orchestratorContext,
+                sessionId: 'progressive-session'
+            });
+        }
+        await this.createSdkServer();
+        const stats = this.toolLoader.getStats();
+        logger.info('Progressive in-process MCP server created', {
+            discoveredTools: stats.totalTools,
+            initiallyLoaded: this.toolCache.size,
+            lazyLoadEnabled: true
+        });
+    }
+    async createSdkServer() {
+        if (!this.inProcessServer) {
+            throw new Error('In-process server not initialized');
+        }
+        const sdk = await getSDK();
+        if (!sdk) {
+            logger.info('SDK not available, skipping SDK server creation');
+            return;
+        }
+        const stats = this.toolLoader.getStats();
+        const allToolNames = this.toolLoader.getAllToolNames();
+        const sdkTools = allToolNames.map((toolName)=>{
+            return this.createLazySdkTool(toolName, sdk);
+        });
+        this.sdkServer = sdk.createSdkMcpServer({
+            name: 'claude-flow',
+            version: '2.7.32',
+            tools: sdkTools
+        });
+        logger.info('SDK MCP server created with progressive disclosure', {
+            totalTools: sdkTools.length,
+            mode: 'lazy-loading'
+        });
+    }
+    createLazySdkTool(toolName, sdk) {
+        const metadata = this.toolLoader.getToolMetadata(toolName);
+        if (!metadata) {
+            logger.warn('Tool metadata not found', {
+                toolName
+            });
+            return null;
+        }
+        const zodSchema = sdk.z.object({}).passthrough();
+        return sdk.tool(toolName, metadata.description, zodSchema, async (args, extra)=>{
+            const mcpTool = await this.getOrLoadTool(toolName);
+            if (!mcpTool) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            if (this.inProcessServer) {
+                return await this.inProcessServer.callTool(toolName, args);
+            }
+            const result = await mcpTool.handler(args, {
+                orchestrator: this.config.orchestratorContext,
+                sessionId: 'sdk-session'
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+                    }
+                ],
+                isError: false
+            };
+        });
+    }
+    async getOrLoadTool(toolName) {
+        if (this.toolCache.has(toolName)) {
+            return this.toolCache.get(toolName);
+        }
+        logger.debug('Lazy loading tool', {
+            toolName
+        });
+        const tool = await this.toolLoader.loadTool(toolName, logger);
+        if (tool) {
+            this.toolCache.set(toolName, tool);
+            if (this.inProcessServer) {
+                this.inProcessServer.registerTool(tool);
+            }
+            logger.info('Tool lazy loaded and cached', {
+                toolName,
+                totalCached: this.toolCache.size
+            });
+        }
+        return tool;
+    }
+    async getTool(name) {
+        return await this.getOrLoadTool(name) || undefined;
+    }
+    getToolNames() {
+        return this.toolLoader.getAllToolNames();
+    }
+    searchTools(query) {
+        return this.toolLoader.searchTools(query);
+    }
+    getSdkServerConfig() {
+        return this.sdkServer;
+    }
+    getInProcessServer() {
+        return this.inProcessServer;
+    }
+    shouldUseInProcess(toolName) {
+        return this.toolLoader.getToolMetadata(toolName) !== undefined;
+    }
+    async routeToolCall(toolName, args, context) {
+        const startTime = performance.now();
+        try {
+            const tool = await this.getOrLoadTool(toolName);
+            if (!tool) {
+                throw new Error(`Tool not available: ${toolName}`);
+            }
+            if (this.shouldUseInProcess(toolName) && this.inProcessServer) {
+                logger.debug('Routing to in-process server', {
+                    toolName
+                });
+                const result = await this.inProcessServer.callTool(toolName, args, context);
+                const duration = performance.now() - startTime;
+                logger.info('In-process tool call completed', {
+                    toolName,
+                    duration: `${duration.toFixed(2)}ms`,
+                    transport: 'in-process',
+                    lazyLoaded: !this.toolCache.has(toolName)
+                });
+                return result;
+            }
+            logger.warn('Tool not found in in-process registry', {
+                toolName
+            });
+            throw new Error(`Tool not available: ${toolName}`);
+        } catch (error) {
+            logger.error('Tool routing failed', {
+                toolName,
+                error
+            });
+            throw error;
+        }
+    }
+    getMetrics() {
+        const loaderStats = this.toolLoader.getStats();
+        if (!this.inProcessServer) {
+            return {
+                discovery: loaderStats,
+                error: 'In-process server not initialized'
+            };
+        }
+        const serverStats = this.inProcessServer.getStats();
+        const serverMetrics = this.inProcessServer.getMetrics();
+        const estimatedOldTokens = loaderStats.totalTools * 3000;
+        const estimatedNewTokens = loaderStats.totalTools * 40;
+        const tokenSavingsPercent = (estimatedOldTokens - estimatedNewTokens) / estimatedOldTokens * 100;
+        return {
+            discovery: loaderStats,
+            loading: {
+                totalDiscovered: loaderStats.totalTools,
+                currentlyLoaded: this.toolCache.size,
+                lazyLoadPercentage: (this.toolCache.size / loaderStats.totalTools * 100).toFixed(2) + '%'
+            },
+            performance: {
+                stats: serverStats,
+                recentMetrics: serverMetrics.slice(-10),
+                summary: {
+                    totalCalls: serverMetrics.length,
+                    averageLatency: serverStats.averageDuration,
+                    cacheHitRate: serverStats.cacheHitRate
+                }
+            },
+            tokenSavings: {
+                estimatedOldApproach: `${estimatedOldTokens.toLocaleString()} tokens`,
+                estimatedNewApproach: `${estimatedNewTokens.toLocaleString()} tokens`,
+                savingsPercent: `${tokenSavingsPercent.toFixed(2)}%`,
+                savingsRatio: `${(estimatedOldTokens / estimatedNewTokens).toFixed(1)}x`
+            }
+        };
+    }
+    getPerformanceComparison() {
+        const metrics = this.getMetrics();
+        if ('error' in metrics) {
+            return metrics;
+        }
+        const avgInProcessLatency = metrics.performance.stats.averageDuration;
+        const estimatedIPCLatency = avgInProcessLatency * 50;
+        return {
+            inProcessLatency: `${avgInProcessLatency.toFixed(2)}ms`,
+            estimatedIPCLatency: `${estimatedIPCLatency.toFixed(2)}ms`,
+            speedupFactor: `${(estimatedIPCLatency / avgInProcessLatency).toFixed(1)}x`,
+            tokenSavings: metrics.tokenSavings,
+            recommendation: 'Use progressive disclosure with in-process execution for maximum performance and minimal token usage'
+        };
+    }
+    async reload() {
+        logger.info('Reloading tool registry...');
+        this.toolCache.clear();
+        await this.toolLoader.reload();
+        await this.registerCoreTools();
+        logger.info('Tool registry reloaded');
+    }
+    async cleanup() {
+        if (this.inProcessServer) {
+            this.inProcessServer.clearCache();
+            this.inProcessServer.clearMetrics();
+        }
+        this.toolCache.clear();
+        this.toolLoader.clearCache();
+        logger.info('Progressive tool registry cleaned up');
+    }
+}
+export async function createProgressiveToolRegistry(config) {
+    const registry = new ProgressiveToolRegistry(config);
+    await registry.initialize();
+    return registry;
+}
+export async function createProgressiveClaudeFlowSdkServer(orchestratorContext) {
+    const registry = await createProgressiveToolRegistry({
+        enableInProcess: true,
+        enableMetrics: true,
+        enableCaching: true,
+        orchestratorContext
+    });
+    const sdkServer = registry.getSdkServerConfig();
+    if (!sdkServer) {
+        throw new Error('Failed to create SDK server');
+    }
+    logger.info('Progressive Claude Flow SDK server created', {
+        totalTools: registry.getToolNames().length,
+        approach: 'progressive-disclosure',
+        tokenSavings: '98.7%'
+    });
+    return sdkServer;
+}
+
+//# sourceMappingURL=tool-registry-progressive.js.map