snow-flow 3.0.9 → 3.0.10

package/dist/orchestration/discovery/service-discovery.js

@@ -1,808 +0,0 @@
-"use strict";
-/**
- * Service Discovery System
- *
- * Handles automatic discovery and registration of Claude Code instances and MCP servers
- * in the distributed orchestration environment.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPDiscoveryError = exports.AgentDiscoveryError = exports.MCPServiceDiscovery = exports.AgentDiscoveryService = void 0;
-const events_1 = require("events");
-const distributed_orchestration_interface_1 = require("../interfaces/distributed-orchestration.interface");
-const logger_1 = require("../../utils/logger");
-class AgentDiscoveryService extends events_1.EventEmitter {
-    constructor(config) {
-        super();
-        // Watch management
-        this.watchMappings = new Map();
-        this.discoveryConfig = config;
-        this.registry = new InMemoryServiceRegistry();
-        this.healthChecker = new HealthChecker(config.healthCheck);
-        this.announcer = new ServiceAnnouncer(config.announcement);
-        this.capabilityMatcher = new CapabilityMatcher();
-        this.loadMonitor = new LoadMonitor();
-        this.startPeriodicDiscovery();
-    }
-    // ========================================
-    // Agent Discovery
-    // ========================================
-    async discoverAgents(criteria = {}) {
-        logger_1.logger.info('🔍 Starting agent discovery', { criteria });
-        try {
-            // 1. Query registry for available services
-            const services = await this.registry.findServices('claude-code-agent', criteria);
-            logger_1.logger.info(`📋 Found ${services.length} registered services`);
-            // 2. Convert services to Claude Code instances
-            const instances = await this.convertServicesToInstances(services);
-            // 3. Filter by health status
-            const healthyInstances = await this.filterHealthyAgents(instances);
-            logger_1.logger.info(`💚 ${healthyInstances.length} healthy instances found`);
-            // 4. Apply discovery filters
-            const filteredInstances = this.applyFilters(healthyInstances, criteria.filters || []);
-            // 5. Sort by capability match and performance
-            const sortedInstances = await this.sortByRelevance(filteredInstances, criteria);
-            logger_1.logger.info(`✅ Discovery completed: ${sortedInstances.length} agents available`);
-            this.emit('agents:discovered', { agents: sortedInstances, criteria });
-            return sortedInstances;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Agent discovery failed', { error: error.message });
-            throw new AgentDiscoveryError(`Discovery failed: ${error.message}`);
-        }
-    }
-    async discoverAgentsByCapability(capabilities) {
-        const criteria = {
-            capabilities,
-            healthStatus: 'healthy'
-        };
-        const agents = await this.discoverAgents(criteria);
-        // Score by capability match
-        return agents
-            .map(agent => ({
-            agent,
-            score: this.capabilityMatcher.scoreMatch(agent.capabilities, capabilities)
-        }))
-            .sort((a, b) => b.score - a.score)
-            .map(item => item.agent);
-    }
-    async discoverAgentsByRegion(regions) {
-        const regionMap = new Map();
-        for (const region of regions) {
-            const criteria = {
-                regions: [region],
-                healthStatus: 'healthy'
-            };
-            const agents = await this.discoverAgents(criteria);
-            regionMap.set(region, agents);
-        }
-        return regionMap;
-    }
-    // ========================================
-    // Service Registration
-    // ========================================
-    async announceService(instance) {
-        logger_1.logger.info(`📢 Announcing Claude Code instance: ${instance.id}`, {
-            endpoint: instance.endpoint,
-            capabilities: instance.capabilities.length
-        });
-        try {
-            const serviceDefinition = {
-                id: instance.id,
-                name: 'claude-code-agent',
-                endpoint: instance.endpoint,
-                metadata: {
-                    ...instance.metadata,
-                    capabilities: instance.capabilities,
-                    authentication: instance.authentication,
-                    announcedAt: new Date()
-                },
-                health: {
-                    check: `${instance.endpoint}/health`,
-                    interval: this.discoveryConfig.healthCheck.interval,
-                    timeout: this.discoveryConfig.healthCheck.timeout,
-                    retries: 3,
-                    gracePeriod: 30000
-                },
-                tags: this.extractTags(instance),
-                capabilities: instance.capabilities,
-                registeredAt: new Date(),
-                lastSeen: new Date()
-            };
-            await this.registry.register(serviceDefinition);
-            // Start health monitoring for this instance
-            await this.healthChecker.startMonitoring(serviceDefinition);
-            logger_1.logger.info(`✅ Successfully announced service: ${instance.id}`);
-            this.emit('service:announced', { instance, serviceDefinition });
-        }
-        catch (error) {
-            logger_1.logger.error(`❌ Failed to announce service: ${instance.id}`, { error: error.message });
-            throw new ServiceAnnouncementError(`Announcement failed: ${error.message}`);
-        }
-    }
-    async deannounceService(instanceId) {
-        logger_1.logger.info(`📴 Deannouncing service: ${instanceId}`);
-        try {
-            await this.registry.deregister(instanceId);
-            await this.healthChecker.stopMonitoring(instanceId);
-            logger_1.logger.info(`✅ Successfully deannounced service: ${instanceId}`);
-            this.emit('service:deannounced', { instanceId });
-        }
-        catch (error) {
-            logger_1.logger.error(`❌ Failed to deannounce service: ${instanceId}`, { error: error.message });
-            throw error;
-        }
-    }
-    // ========================================
-    // Continuous Discovery
-    // ========================================
-    async watchAgents(criteria, callback) {
-        logger_1.logger.info('👁️ Starting agent watch', { criteria });
-        const watchId = this.generateWatchId();
-        // Initial discovery
-        const initialAgents = await this.discoverAgents(criteria);
-        callback(initialAgents);
-        // Set up continuous watching
-        const serviceWatchId = await this.registry.watchServices('claude-code-agent', async (event) => {
-            logger_1.logger.debug('🔄 Service registry event received', { type: event.type, serviceId: event.service.id });
-            // Re-discover agents when services change
-            const updatedAgents = await this.discoverAgents(criteria);
-            callback(updatedAgents);
-        });
-        // Store watch mapping for cleanup
-        this.storeWatchMapping(watchId, serviceWatchId);
-        return watchId;
-    }
-    async unwatchAgents(watchId) {
-        logger_1.logger.info(`🛑 Stopping agent watch: ${watchId}`);
-        const serviceWatchId = this.getServiceWatchId(watchId);
-        if (serviceWatchId) {
-            await this.registry.unwatchServices(serviceWatchId);
-            this.cleanupWatchMapping(watchId);
-        }
-    }
-    // ========================================
-    // Health Management
-    // ========================================
-    async filterHealthyAgents(instances) {
-        const healthChecks = await Promise.allSettled(instances.map(instance => this.healthChecker.checkHealth(instance)));
-        return instances.filter((instance, index) => {
-            const result = healthChecks[index];
-            if (result.status === 'fulfilled' && result.value.healthy) {
-                return true;
-            }
-            else {
-                logger_1.logger.warn(`🩺 Health check failed for agent: ${instance.id}`, {
-                    reason: result.status === 'rejected' ? result.reason : result.value.reason
-                });
-                return false;
-            }
-        });
-    }
-    // ========================================
-    // Utility Methods
-    // ========================================
-    async convertServicesToInstances(services) {
-        return services.map(service => ({
-            id: service.id,
-            endpoint: service.endpoint,
-            capabilities: service.capabilities || [],
-            status: this.determineInstanceStatus(service),
-            metadata: {
-                region: service.metadata.region || 'unknown',
-                version: service.metadata.version || '1.0.0',
-                maxConcurrentTasks: service.metadata.maxConcurrentTasks || 5,
-                specializations: service.metadata.specializations || [],
-                performanceMetrics: service.metadata.performanceMetrics || this.getDefaultMetrics(),
-                tags: service.metadata.tags || {}
-            },
-            healthcheck: {
-                lastSeen: service.lastSeen,
-                responseTime: service.metadata.responseTime || 0,
-                errorRate: service.metadata.errorRate || 0,
-                consecutiveFailures: service.metadata.consecutiveFailures || 0
-            },
-            authentication: service.metadata.authentication || {}
-        }));
-    }
-    determineInstanceStatus(service) {
-        const timeSinceLastSeen = Date.now() - service.lastSeen.getTime();
-        if (timeSinceLastSeen > 300000) { // 5 minutes
-            return distributed_orchestration_interface_1.InstanceStatus.OFFLINE;
-        }
-        else if (timeSinceLastSeen > 60000) { // 1 minute
-            return distributed_orchestration_interface_1.InstanceStatus.UNREACHABLE;
-        }
-        else {
-            return service.metadata.status || distributed_orchestration_interface_1.InstanceStatus.ACTIVE;
-        }
-    }
-    extractTags(instance) {
-        const tags = ['claude-code', 'agent'];
-        // Add capability-based tags
-        instance.capabilities.forEach(cap => {
-            tags.push(`domain:${cap.domain}`);
-            tags.push(`proficiency:${cap.proficiencyLevel}`);
-            cap.specialization.forEach(spec => tags.push(`specialization:${spec}`));
-        });
-        // Add metadata tags
-        if (instance.metadata.region) {
-            tags.push(`region:${instance.metadata.region}`);
-        }
-        if (instance.metadata.version) {
-            tags.push(`version:${instance.metadata.version}`);
-        }
-        return tags;
-    }
-    applyFilters(instances, filters) {
-        return instances.filter(instance => {
-            return filters.every(filter => this.evaluateFilter(instance, filter));
-        });
-    }
-    evaluateFilter(instance, filter) {
-        const value = this.getPropertyValue(instance, filter.property);
-        switch (filter.operator) {
-            case 'equals':
-                return value === filter.value;
-            case 'contains':
-                return String(value).toLowerCase().includes(String(filter.value).toLowerCase());
-            case 'greater_than':
-                return Number(value) > Number(filter.value);
-            case 'less_than':
-                return Number(value) < Number(filter.value);
-            default:
-                return true;
-        }
-    }
-    getPropertyValue(instance, property) {
-        const path = property.split('.');
-        let value = instance;
-        for (const key of path) {
-            value = value?.[key];
-            if (value === undefined)
-                break;
-        }
-        return value;
-    }
-    async sortByRelevance(instances, criteria) {
-        const scoredInstances = instances.map(instance => ({
-            instance,
-            score: this.calculateRelevanceScore(instance, criteria)
-        }));
-        return scoredInstances
-            .sort((a, b) => b.score - a.score)
-            .map(item => item.instance);
-    }
-    calculateRelevanceScore(instance, criteria) {
-        let score = 0.5; // Base score
-        // Capability match score
-        if (criteria.capabilities && criteria.capabilities.length > 0) {
-            const capabilityScore = this.capabilityMatcher.scoreMatch(instance.capabilities, criteria.capabilities);
-            score += capabilityScore * 0.4;
-        }
-        // Performance score
-        const performanceScore = this.calculatePerformanceScore(instance);
-        score += performanceScore * 0.3;
-        // Health score
-        const healthScore = this.calculateHealthScore(instance);
-        score += healthScore * 0.2;
-        // Load score
-        const loadScore = this.loadMonitor.getLoadScore(instance.id);
-        score += loadScore * 0.1;
-        return Math.min(Math.max(score, 0), 1);
-    }
-    calculatePerformanceScore(instance) {
-        const metrics = instance.metadata.performanceMetrics;
-        const responseTimeScore = Math.max(0, 1 - (metrics.averageResponseTime / 10000));
-        const throughputScore = Math.min(1, metrics.throughput / 100);
-        const errorRateScore = Math.max(0, 1 - (metrics.errorRate * 10));
-        return (responseTimeScore + throughputScore + errorRateScore) / 3;
-    }
-    calculateHealthScore(instance) {
-        const timeSinceLastSeen = Date.now() - instance.healthcheck.lastSeen.getTime();
-        const timeScore = Math.max(0, 1 - (timeSinceLastSeen / 300000)); // 5 minute max
-        const failureScore = Math.max(0, 1 - (instance.healthcheck.consecutiveFailures * 0.2));
-        return (timeScore + failureScore) / 2;
-    }
-    startPeriodicDiscovery() {
-        const interval = this.discoveryConfig.discoveryInterval || 60000; // 1 minute default
-        setInterval(async () => {
-            try {
-                logger_1.logger.debug('🔄 Running periodic discovery sweep');
-                // Discover all agents and emit updates
-                const agents = await this.discoverAgents();
-                this.emit('discovery:sweep', { agents, timestamp: new Date() });
-            }
-            catch (error) {
-                logger_1.logger.warn('⚠️ Periodic discovery sweep failed', { error: error.message });
-            }
-        }, interval);
-    }
-    getDefaultMetrics() {
-        return {
-            averageResponseTime: 1000,
-            throughput: 10,
-            errorRate: 0.01,
-            cpuUtilization: 0.5,
-            memoryUtilization: 0.5,
-            taskCompletionRate: 0.95
-        };
-    }
-    generateWatchId() {
-        return `watch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-    storeWatchMapping(watchId, serviceWatchId) {
-        this.watchMappings.set(watchId, serviceWatchId);
-    }
-    getServiceWatchId(watchId) {
-        return this.watchMappings.get(watchId);
-    }
-    cleanupWatchMapping(watchId) {
-        this.watchMappings.delete(watchId);
-    }
-}
-exports.AgentDiscoveryService = AgentDiscoveryService;
-// ========================================
-// MCP Service Discovery
-// ========================================
-class MCPServiceDiscovery extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.mcpRegistry = new MCPRegistry();
-        this.capabilityMatcher = new CapabilityMatcher();
-        this.performanceTracker = new MCPPerformanceTracker();
-    }
-    async discoverMCPServers(requirements) {
-        logger_1.logger.info('🔍 Discovering MCP servers', { requirements });
-        try {
-            // 1. Query registry for available MCP servers
-            const availableServers = await this.mcpRegistry.listServers();
-            logger_1.logger.info(`📋 Found ${availableServers.length} registered MCP servers`);
-            // 2. Filter by capability requirements
-            const compatibleServers = await this.capabilityMatcher.filterMCPServers(availableServers, requirements.capabilities);
-            logger_1.logger.info(`🔧 ${compatibleServers.length} servers match capability requirements`);
-            // 3. Filter by performance requirements
-            const performanceFiltered = await this.filterByPerformance(compatibleServers, requirements.performance || []);
-            // 4. Score and rank servers
-            const rankedServers = this.rankMCPServers(performanceFiltered, requirements);
-            logger_1.logger.info(`✅ MCP discovery completed: ${rankedServers.length} servers available`);
-            this.emit('mcp:discovered', { servers: rankedServers, requirements });
-            return rankedServers;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ MCP discovery failed', { error: error.message });
-            throw new MCPDiscoveryError(`MCP discovery failed: ${error.message}`);
-        }
-    }
-    async registerMCPServer(serverInfo) {
-        logger_1.logger.info(`📢 Registering MCP server: ${serverInfo.name}`, {
-            endpoint: serverInfo.endpoint,
-            capabilities: serverInfo.capabilities.length
-        });
-        try {
-            // 1. Validate MCP server capabilities
-            const validation = await this.validateMCPServer(serverInfo);
-            if (!validation.valid) {
-                throw new MCPValidationError(`Invalid MCP server: ${validation.reason}`);
-            }
-            // 2. Introspect capabilities if not provided
-            if (serverInfo.capabilities.length === 0) {
-                serverInfo.capabilities = await this.introspectCapabilities(serverInfo);
-            }
-            // 3. Register with enhanced metadata
-            await this.mcpRegistry.register({
-                ...serverInfo,
-                discoveredAt: new Date(),
-                lastValidated: new Date()
-            });
-            // 4. Start performance monitoring
-            await this.performanceTracker.startTracking(serverInfo);
-            logger_1.logger.info(`✅ Successfully registered MCP server: ${serverInfo.name}`);
-            this.emit('mcp:registered', { serverInfo });
-        }
-        catch (error) {
-            logger_1.logger.error(`❌ Failed to register MCP server: ${serverInfo.name}`, { error: error.message });
-            throw error;
-        }
-    }
-    async deregisterMCPServer(serverId) {
-        logger_1.logger.info(`📴 Deregistering MCP server: ${serverId}`);
-        try {
-            await this.mcpRegistry.deregister(serverId);
-            await this.performanceTracker.stopTracking(serverId);
-            logger_1.logger.info(`✅ Successfully deregistered MCP server: ${serverId}`);
-            this.emit('mcp:deregistered', { serverId });
-        }
-        catch (error) {
-            logger_1.logger.error(`❌ Failed to deregister MCP server: ${serverId}`, { error: error.message });
-            throw error;
-        }
-    }
-    async filterByPerformance(servers, requirements) {
-        if (requirements.length === 0)
-            return servers;
-        return servers.filter(server => {
-            const performance = this.performanceTracker.getPerformance(server.id);
-            return requirements.every(req => this.meetsPerformanceRequirement(performance, req));
-        });
-    }
-    meetsPerformanceRequirement(performance, requirement) {
-        if (!performance)
-            return false;
-        switch (requirement.metric) {
-            case 'response_time':
-                return performance.averageResponseTime <= requirement.threshold;
-            case 'throughput':
-                return performance.throughput >= requirement.threshold;
-            case 'availability':
-                return performance.availability >= requirement.threshold;
-            default:
-                return true;
-        }
-    }
-    rankMCPServers(servers, requirements) {
-        return servers
-            .map(server => ({
-            server,
-            score: this.calculateMCPScore(server, requirements)
-        }))
-            .sort((a, b) => b.score - a.score)
-            .map(item => item.server);
-    }
-    calculateMCPScore(server, requirements) {
-        let score = 0.5; // Base score
-        // Capability match score
-        const capabilityScore = this.capabilityMatcher.scoreMCPMatch(server.capabilities, requirements.capabilities);
-        score += capabilityScore * 0.6;
-        // Performance score
-        const performance = this.performanceTracker.getPerformance(server.id);
-        if (performance) {
-            const performanceScore = this.calculateMCPPerformanceScore(performance);
-            score += performanceScore * 0.3;
-        }
-        // Recency score (prefer recently updated servers)
-        const recencyScore = this.calculateRecencyScore(server);
-        score += recencyScore * 0.1;
-        return Math.min(Math.max(score, 0), 1);
-    }
-    calculateMCPPerformanceScore(performance) {
-        const responseTimeScore = Math.max(0, 1 - (performance.averageResponseTime / 5000)); // 5s max
-        const throughputScore = Math.min(1, performance.throughput / 50); // 50 req/s max
-        const availabilityScore = performance.availability;
-        return (responseTimeScore + throughputScore + availabilityScore) / 3;
-    }
-    calculateRecencyScore(server) {
-        const daysSinceUpdate = (Date.now() - server.lastValidated.getTime()) / (1000 * 60 * 60 * 24);
-        return Math.max(0, 1 - (daysSinceUpdate / 30)); // 30 days max
-    }
-    async validateMCPServer(serverInfo) {
-        try {
-            // Basic validation checks
-            if (!serverInfo.endpoint) {
-                return { valid: false, reason: 'Missing endpoint' };
-            }
-            if (!serverInfo.name) {
-                return { valid: false, reason: 'Missing name' };
-            }
-            // Try to connect and validate
-            const client = new MCPClient(serverInfo.endpoint);
-            const connectionTest = await client.testConnection();
-            if (!connectionTest.success) {
-                return { valid: false, reason: `Connection failed: ${connectionTest.error}` };
-            }
-            return { valid: true };
-        }
-        catch (error) {
-            return { valid: false, reason: `Validation error: ${error.message}` };
-        }
-    }
-    async introspectCapabilities(serverInfo) {
-        logger_1.logger.info(`🔍 Introspecting capabilities for: ${serverInfo.name}`);
-        try {
-            const client = new MCPClient(serverInfo.endpoint);
-            // Get available tools and resources
-            const [tools, resources] = await Promise.all([
-                client.listTools(),
-                client.listResources()
-            ]);
-            const capabilities = [];
-            // Convert tools to capabilities
-            tools.forEach(tool => {
-                capabilities.push({
-                    type: 'tool',
-                    name: tool.name,
-                    description: tool.description || '',
-                    schema: tool.inputSchema,
-                    metadata: { tool }
-                });
-            });
-            // Convert resources to capabilities
-            resources.forEach(resource => {
-                capabilities.push({
-                    type: 'resource',
-                    name: resource.name,
-                    description: resource.description || '',
-                    metadata: { resource }
-                });
-            });
-            logger_1.logger.info(`✅ Introspected ${capabilities.length} capabilities`);
-            return capabilities;
-        }
-        catch (error) {
-            logger_1.logger.warn(`⚠️ Failed to introspect capabilities for ${serverInfo.name}`, { error: error.message });
-            return [];
-        }
-    }
-}
-exports.MCPServiceDiscovery = MCPServiceDiscovery;
-// ========================================
-// Supporting Classes
-// ========================================
-class InMemoryServiceRegistry {
-    constructor() {
-        this.services = new Map();
-        this.watchers = new Map();
-    }
-    async register(service) {
-        const existing = this.services.get(service.id);
-        this.services.set(service.id, service);
-        const eventType = existing ? 'updated' : 'registered';
-        this.notifyWatchers({
-            type: eventType,
-            service,
-            timestamp: new Date()
-        });
-    }
-    async deregister(serviceId) {
-        const service = this.services.get(serviceId);
-        if (service) {
-            this.services.delete(serviceId);
-            this.notifyWatchers({
-                type: 'deregistered',
-                service,
-                timestamp: new Date()
-            });
-        }
-    }
-    async findServices(serviceName, criteria) {
-        const services = Array.from(this.services.values())
-            .filter(service => service.name === serviceName);
-        if (!criteria)
-            return services;
-        return services.filter(service => {
-            // Apply criteria filters
-            if (criteria.tags && !criteria.tags.every(tag => service.tags.includes(tag))) {
-                return false;
-            }
-            if (criteria.regions && !criteria.regions.includes(service.metadata.region)) {
-                return false;
-            }
-            if (criteria.healthStatus === 'healthy' && !this.isHealthy(service)) {
-                return false;
-            }
-            return true;
-        });
-    }
-    async watchServices(serviceName, callback) {
-        const watchId = `watch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        this.watchers.set(watchId, { callback, filter: serviceName });
-        return watchId;
-    }
-    async unwatchServices(watchId) {
-        this.watchers.delete(watchId);
-    }
-    notifyWatchers(event) {
-        this.watchers.forEach(({ callback, filter }) => {
-            if (event.service.name === filter) {
-                callback(event);
-            }
-        });
-    }
-    isHealthy(service) {
-        const timeSinceLastSeen = Date.now() - service.lastSeen.getTime();
-        return timeSinceLastSeen < 120000; // 2 minutes
-    }
-}
-class HealthChecker {
-    constructor(config) {
-        this.config = config;
-        this.monitoringIntervals = new Map();
-    }
-    async checkHealth(instance) {
-        try {
-            const response = await fetch(`${instance.endpoint}/health`, {
-                method: 'GET',
-                timeout: this.config.timeout,
-                headers: {
-                    'User-Agent': 'snow-flow-discovery/1.0'
-                }
-            });
-            const healthy = response.ok;
-            const responseTime = Date.now(); // Would measure actual response time
-            return {
-                healthy,
-                responseTime,
-                details: healthy ? undefined : `HTTP ${response.status}: ${response.statusText}`
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                responseTime: this.config.timeout,
-                details: error.message
-            };
-        }
-    }
-    async startMonitoring(service) {
-        const interval = setInterval(async () => {
-            // Health monitoring logic would go here
-            logger_1.logger.debug(`💓 Health check for service: ${service.id}`);
-        }, service.health.interval);
-        this.monitoringIntervals.set(service.id, interval);
-    }
-    async stopMonitoring(serviceId) {
-        const interval = this.monitoringIntervals.get(serviceId);
-        if (interval) {
-            clearInterval(interval);
-            this.monitoringIntervals.delete(serviceId);
-        }
-    }
-}
-class ServiceAnnouncer {
-    constructor(config) {
-        this.config = config;
-    }
-    async announce(service) {
-        // Implementation would handle service announcement
-        // to configured discovery services (Consul, etcd, etc.)
-    }
-}
-class CapabilityMatcher {
-    scoreMatch(agentCapabilities, requiredCapabilities) {
-        if (requiredCapabilities.length === 0)
-            return 1;
-        const agentSpecs = agentCapabilities.flatMap(cap => cap.specialization);
-        let matches = 0;
-        for (const required of requiredCapabilities) {
-            const bestMatch = agentSpecs.find(spec => this.calculateSimilarity(required, spec) > 0.7);
-            if (bestMatch)
-                matches++;
-        }
-        return matches / requiredCapabilities.length;
-    }
-    async filterMCPServers(servers, requiredCapabilities) {
-        return servers.filter(server => {
-            const serverCapabilities = server.capabilities.map(cap => cap.name);
-            return requiredCapabilities.every(req => serverCapabilities.some(cap => cap.toLowerCase().includes(req.toLowerCase())));
-        });
-    }
-    scoreMCPMatch(serverCapabilities, requiredCapabilities) {
-        if (requiredCapabilities.length === 0)
-            return 1;
-        const serverNames = serverCapabilities.map(cap => cap.name);
-        let matches = 0;
-        for (const required of requiredCapabilities) {
-            const bestMatch = serverNames.find(name => this.calculateSimilarity(required, name) > 0.7);
-            if (bestMatch)
-                matches++;
-        }
-        return matches / requiredCapabilities.length;
-    }
-    calculateSimilarity(str1, str2) {
-        // Simple similarity calculation
-        const lower1 = str1.toLowerCase();
-        const lower2 = str2.toLowerCase();
-        if (lower1 === lower2)
-            return 1;
-        if (lower1.includes(lower2) || lower2.includes(lower1))
-            return 0.8;
-        // Could implement more sophisticated similarity algorithms
-        return 0;
-    }
-}
-class LoadMonitor {
-    constructor() {
-        this.loadScores = new Map();
-    }
-    getLoadScore(instanceId) {
-        return this.loadScores.get(instanceId) || 0.5;
-    }
-    updateLoadScore(instanceId, score) {
-        this.loadScores.set(instanceId, score);
-    }
-}
-class MCPRegistry {
-    constructor() {
-        this.servers = new Map();
-    }
-    async listServers() {
-        return Array.from(this.servers.values());
-    }
-    async register(serverInfo) {
-        this.servers.set(serverInfo.id, serverInfo);
-    }
-    async deregister(serverId) {
-        this.servers.delete(serverId);
-    }
-    async getServer(serverId) {
-        return this.servers.get(serverId);
-    }
-}
-class MCPPerformanceTracker {
-    constructor() {
-        this.performance = new Map();
-    }
-    async startTracking(serverInfo) {
-        this.performance.set(serverInfo.id, {
-            averageResponseTime: 1000,
-            throughput: 10,
-            availability: 0.99
-        });
-    }
-    async stopTracking(serverId) {
-        this.performance.delete(serverId);
-    }
-    getPerformance(serverId) {
-        return this.performance.get(serverId);
-    }
-}
-class MCPClient {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-    }
-    async testConnection() {
-        try {
-            const response = await fetch(`${this.endpoint}/mcp`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: 1,
-                    method: 'initialize',
-                    params: { protocolVersion: '2024-11-05', capabilities: {} }
-                })
-            });
-            return { success: response.ok };
-        }
-        catch (error) {
-            return { success: false, error: error.message };
-        }
-    }
-    async listTools() {
-        // Implementation would call MCP listTools
-        return [];
-    }
-    async listResources() {
-        // Implementation would call MCP listResources
-        return [];
-    }
-}
-// ========================================
-// Error Classes
-// ========================================
-class AgentDiscoveryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AgentDiscoveryError';
-    }
-}
-exports.AgentDiscoveryError = AgentDiscoveryError;
-class ServiceAnnouncementError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ServiceAnnouncementError';
-    }
-}
-class MCPDiscoveryError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'MCPDiscoveryError';
-    }
-}
-exports.MCPDiscoveryError = MCPDiscoveryError;
-class MCPValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'MCPValidationError';
-    }
-}
-//# sourceMappingURL=service-discovery.js.map