snow-flow 3.0.8 → 3.0.10

package/dist/orchestration/distribution/task-distribution-engine.d.ts

@@ -1,53 +0,0 @@
-/**
- * Intelligent Task Distribution Engine
- *
- * Distributes tasks across external Claude Code instances using advanced algorithms
- * for optimal performance, load balancing, and resource utilization.
- */
-import { EventEmitter } from 'events';
-import { TaskSpecification, ClaudeCodeInstance, DistributionPlan, TaskRequirements } from '../interfaces/distributed-orchestration.interface.js';
-export declare class IntelligentTaskDistributor extends EventEmitter {
-    private agentPool;
-    private loadBalancers;
-    private taskAnalyzer;
-    private affinityManager;
-    private performanceTracker;
-    private costOptimizer;
-    constructor();
-    distributeTask(task: TaskSpecification): Promise<DistributionPlan>;
-    findSuitableAgents(requirements: TaskRequirements): Promise<ClaudeCodeInstance[]>;
-    private meetsCapabilityRequirements;
-    private meetsResourceRequirements;
-    private meetsConstraints;
-    private isHealthy;
-    private scoreAgent;
-    private calculateCapabilityScore;
-    private calculateCapabilityMatch;
-    private calculatePerformanceScore;
-    private calculateLoadScore;
-    private calculateProximityScore;
-    private calculateCostScore;
-    private selectLoadBalancer;
-    private createExecutionPlan;
-    private identifyExecutionPhases;
-    private generateFallbackPlan;
-    private validateDistributionPlan;
-    private initializeLoadBalancers;
-    private stringSimilarity;
-    private evaluateConstraint;
-    private calculateReliabilityScore;
-    private buildDependencyGraph;
-    private topologicalSort;
-    private calculateTotalDuration;
-    private calculateParallelizationScore;
-    private calculateResourceUsage;
-    private validateResourceAllocation;
-    private validateDeadlines;
-    private validateCapabilities;
-    private validateConstraints;
-}
-declare class TaskDistributionError extends Error {
-    constructor(message: string);
-}
-export { TaskDistributionError };
-//# sourceMappingURL=task-distribution-engine.d.ts.map

package/dist/orchestration/distribution/task-distribution-engine.js

@@ -1,586 +0,0 @@
-"use strict";
-/**
- * Intelligent Task Distribution Engine
- *
- * Distributes tasks across external Claude Code instances using advanced algorithms
- * for optimal performance, load balancing, and resource utilization.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskDistributionError = exports.IntelligentTaskDistributor = void 0;
-const events_1 = require("events");
-const distributed_orchestration_interface_js_1 = require("../interfaces/distributed-orchestration.interface.js");
-const logger_js_1 = require("../../utils/logger.js");
-class IntelligentTaskDistributor extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.agentPool = new ExternalAgentPool();
-        this.loadBalancers = this.initializeLoadBalancers();
-        this.taskAnalyzer = new TaskAnalyzer();
-        this.affinityManager = new AffinityManager();
-        this.performanceTracker = new PerformanceTracker();
-        this.costOptimizer = new CostOptimizer();
-    }
-    // ========================================
-    // Main Distribution Logic
-    // ========================================
-    async distributeTask(task) {
-        logger_js_1.logger.info(`🎯 Starting task distribution for: ${task.name}`, {
-            taskId: task.id,
-            type: task.type
-        });
-        try {
-            // 1. Analyze task requirements and complexity
-            const analysis = await this.taskAnalyzer.analyze(task);
-            logger_js_1.logger.info(`📊 Task analysis completed`, {
-                complexity: analysis.complexity,
-                requiredCapabilities: analysis.requirements.capabilities.length,
-                estimatedAgents: analysis.estimatedAgentCount
-            });
-            // 2. Find suitable agents based on capabilities
-            const candidates = await this.findSuitableAgents(analysis.requirements);
-            if (candidates.length === 0) {
-                throw new TaskDistributionError(`No suitable agents found for task: ${task.id}`);
-            }
-            logger_js_1.logger.info(`🔍 Found ${candidates.length} suitable agents`);
-            // 3. Apply load balancing to optimize distribution
-            const loadBalancer = this.selectLoadBalancer(task, analysis);
-            const loadBalancedAssignments = await loadBalancer.optimize(candidates, task);
-            // 4. Apply affinity rules and constraints
-            const affinityOptimized = await this.affinityManager.apply(loadBalancedAssignments, task.affinityRules || []);
-            // 5. Optimize for cost if specified
-            const costOptimized = await this.costOptimizer.optimize(affinityOptimized, task);
-            // 6. Create execution plan with phases
-            const executionPlan = await this.createExecutionPlan(costOptimized, analysis);
-            // 7. Generate fallback plan
-            const fallbackPlan = await this.generateFallbackPlan(task, candidates);
-            const distributionPlan = {
-                taskId: task.id,
-                assignments: costOptimized,
-                executionOrder: executionPlan.phases,
-                estimated: {
-                    totalDuration: executionPlan.estimatedDuration,
-                    parallelization: executionPlan.parallelizationScore,
-                    resourceUsage: executionPlan.resourceUsage
-                },
-                fallbackPlan
-            };
-            // 8. Validate distribution plan
-            await this.validateDistributionPlan(distributionPlan, task);
-            logger_js_1.logger.info(`✅ Task distribution completed`, {
-                taskId: task.id,
-                assignments: distributionPlan.assignments.length,
-                estimatedDuration: distributionPlan.estimated.totalDuration,
-                parallelization: distributionPlan.estimated.parallelization
-            });
-            this.emit('task:distributed', { task, plan: distributionPlan });
-            return distributionPlan;
-        }
-        catch (error) {
-            logger_js_1.logger.error(`❌ Task distribution failed for: ${task.id}`, {
-                error: error.message
-            });
-            this.emit('task:distribution_failed', { task, error });
-            throw error;
-        }
-    }
-    // ========================================
-    // Agent Discovery and Matching
-    // ========================================
-    async findSuitableAgents(requirements) {
-        const allAgents = await this.agentPool.getAvailableAgents();
-        const suitableAgents = allAgents
-            .filter(agent => this.meetsCapabilityRequirements(agent, requirements))
-            .filter(agent => this.meetsResourceRequirements(agent, requirements))
-            .filter(agent => this.meetsConstraints(agent, requirements))
-            .filter(agent => this.isHealthy(agent));
-        // Score and sort agents by suitability
-        const scoredAgents = suitableAgents
-            .map(agent => ({
-            agent,
-            score: this.scoreAgent(agent, requirements)
-        }))
-            .sort((a, b) => b.score - a.score)
-            .map(item => item.agent);
-        return scoredAgents;
-    }
-    meetsCapabilityRequirements(agent, requirements) {
-        const agentCapabilities = agent.capabilities.flatMap(cap => cap.specialization);
-        return requirements.capabilities.every(req => agentCapabilities.some(cap => cap.toLowerCase().includes(req.toLowerCase()) ||
-            req.toLowerCase().includes(cap.toLowerCase())));
-    }
-    meetsResourceRequirements(agent, requirements) {
-        for (const requirement of requirements.resources) {
-            const agentResource = agent.capabilities.find(cap => cap.resourceRequirements.some(res => res.type === requirement.type));
-            if (!agentResource && requirement.amount && requirement.amount > 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-    meetsConstraints(agent, requirements) {
-        for (const constraint of requirements.constraints) {
-            if (!this.evaluateConstraint(agent, constraint)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    isHealthy(agent) {
-        return agent.status === distributed_orchestration_interface_js_1.InstanceStatus.ACTIVE || agent.status === distributed_orchestration_interface_js_1.InstanceStatus.IDLE;
-    }
-    // ========================================
-    // Agent Scoring Algorithm
-    // ========================================
-    scoreAgent(agent, requirements) {
-        let score = 0;
-        // Capability match score (40% weight)
-        const capabilityScore = this.calculateCapabilityScore(agent, requirements);
-        score += capabilityScore * 0.4;
-        // Performance score (25% weight)
-        const performanceScore = this.calculatePerformanceScore(agent);
-        score += performanceScore * 0.25;
-        // Load score (20% weight) - inverse of current load
-        const loadScore = this.calculateLoadScore(agent);
-        score += loadScore * 0.2;
-        // Geographic proximity score (10% weight)
-        const proximityScore = this.calculateProximityScore(agent);
-        score += proximityScore * 0.1;
-        // Cost efficiency score (5% weight)
-        const costScore = this.calculateCostScore(agent);
-        score += costScore * 0.05;
-        return Math.min(Math.max(score, 0), 1); // Normalize to 0-1
-    }
-    calculateCapabilityScore(agent, requirements) {
-        const requiredCapabilities = requirements.capabilities;
-        const agentCapabilities = agent.capabilities.flatMap(cap => cap.specialization);
-        let matches = 0;
-        for (const required of requiredCapabilities) {
-            const bestMatch = agentCapabilities.find(agentCap => this.calculateCapabilityMatch(required, agentCap) > 0.7);
-            if (bestMatch)
-                matches++;
-        }
-        return requiredCapabilities.length > 0 ? matches / requiredCapabilities.length : 0;
-    }
-    calculateCapabilityMatch(required, available) {
-        // Simple string similarity - in production, would use more sophisticated matching
-        const similarity = this.stringSimilarity(required.toLowerCase(), available.toLowerCase());
-        return similarity;
-    }
-    calculatePerformanceScore(agent) {
-        const metrics = agent.metadata.performanceMetrics;
-        // Normalize metrics to 0-1 scores
-        const responseTimeScore = Math.max(0, 1 - (metrics.averageResponseTime / 10000)); // 10s max
-        const throughputScore = Math.min(1, metrics.throughput / 100); // 100 tasks/hour max
-        const errorRateScore = Math.max(0, 1 - (metrics.errorRate * 10)); // 10% max error rate
-        const completionRateScore = metrics.taskCompletionRate;
-        return (responseTimeScore + throughputScore + errorRateScore + completionRateScore) / 4;
-    }
-    calculateLoadScore(agent) {
-        const currentTasks = this.performanceTracker.getCurrentTaskCount(agent.id);
-        const maxTasks = agent.metadata.maxConcurrentTasks;
-        return Math.max(0, 1 - (currentTasks / maxTasks));
-    }
-    calculateProximityScore(agent) {
-        // Would calculate based on geographic distance, network latency, etc.
-        // For now, return neutral score
-        return 0.5;
-    }
-    calculateCostScore(agent) {
-        // Would calculate based on compute costs, data transfer costs, etc.
-        // For now, return neutral score
-        return 0.5;
-    }
-    // ========================================
-    // Load Balancer Selection
-    // ========================================
-    selectLoadBalancer(task, analysis) {
-        // Select based on task characteristics
-        if (analysis.complexity > 0.8) {
-            return new CapabilityWeightedLoadBalancer(this.performanceTracker);
-        }
-        else if (analysis.hasGeographicRequirements) {
-            return new GeographicAffinityLoadBalancer();
-        }
-        else if (analysis.estimatedAgentCount > 5) {
-            return new AIOptimizedLoadBalancer(this.performanceTracker);
-        }
-        else {
-            return new RoundRobinLoadBalancer();
-        }
-    }
-    // ========================================
-    // Execution Plan Creation
-    // ========================================
-    async createExecutionPlan(assignments, analysis) {
-        const phases = await this.identifyExecutionPhases(assignments, analysis);
-        const estimatedDuration = this.calculateTotalDuration(phases);
-        const parallelizationScore = this.calculateParallelizationScore(phases);
-        const resourceUsage = this.calculateResourceUsage(assignments);
-        return {
-            phases,
-            estimatedDuration,
-            parallelizationScore,
-            resourceUsage
-        };
-    }
-    async identifyExecutionPhases(assignments, analysis) {
-        const phases = [];
-        const dependencyGraph = this.buildDependencyGraph(assignments);
-        // Topological sort to identify execution order
-        const sortedLevels = this.topologicalSort(dependencyGraph);
-        for (let level = 0; level < sortedLevels.length; level++) {
-            const tasksAtLevel = sortedLevels[level];
-            const canRunInParallel = tasksAtLevel.length > 1 && !analysis.hasStrictOrdering;
-            phases.push({
-                id: `phase_${level}`,
-                type: canRunInParallel ? 'parallel' : 'sequential',
-                tasks: tasksAtLevel.map(task => task.taskPortion.id),
-                estimatedDuration: Math.max(...tasksAtLevel.map(t => t.estimatedEnd.getTime() - t.estimatedStart.getTime())),
-                dependencies: level > 0 ? [`phase_${level - 1}`] : []
-            });
-        }
-        return phases;
-    }
-    // ========================================
-    // Fallback Planning
-    // ========================================
-    async generateFallbackPlan(task, availableAgents) {
-        // Create a simpler, more conservative fallback plan
-        const fallbackAgents = availableAgents
-            .filter(agent => agent.status === distributed_orchestration_interface_js_1.InstanceStatus.ACTIVE)
-            .sort((a, b) => this.calculateReliabilityScore(b) - this.calculateReliabilityScore(a))
-            .slice(0, Math.min(3, availableAgents.length)); // Max 3 agents for fallback
-        const loadBalancer = new RoundRobinLoadBalancer();
-        const assignments = await loadBalancer.optimize(fallbackAgents, task);
-        return {
-            taskId: task.id,
-            assignments,
-            executionOrder: [{
-                    id: 'fallback_phase',
-                    type: 'sequential',
-                    tasks: assignments.map(a => a.taskPortion.id),
-                    estimatedDuration: Math.max(...assignments.map(a => a.estimatedEnd.getTime() - a.estimatedStart.getTime())),
-                    dependencies: []
-                }],
-            estimated: {
-                totalDuration: Math.max(...assignments.map(a => a.estimatedEnd.getTime() - a.estimatedStart.getTime())),
-                parallelization: 0.3, // Conservative parallelization
-                resourceUsage: this.calculateResourceUsage(assignments)
-            }
-        };
-    }
-    // ========================================
-    // Validation
-    // ========================================
-    async validateDistributionPlan(plan, task) {
-        const validations = [
-            this.validateResourceAllocation(plan, task),
-            this.validateDeadlines(plan, task),
-            this.validateCapabilities(plan, task),
-            this.validateConstraints(plan, task)
-        ];
-        const results = await Promise.all(validations);
-        const failures = results.filter(r => !r.valid);
-        if (failures.length > 0) {
-            throw new TaskDistributionError(`Distribution plan validation failed: ${failures.map(f => f.reason).join(', ')}`);
-        }
-    }
-    // ========================================
-    // Load Balancing Implementations
-    // ========================================
-    initializeLoadBalancers() {
-        const balancers = new Map();
-        balancers.set('round_robin', {
-            name: 'round_robin',
-            type: 'round_robin',
-            parameters: {}
-        });
-        balancers.set('capability_weighted', {
-            name: 'capability_weighted',
-            type: 'capability_based',
-            parameters: { weightFactor: 0.8 }
-        });
-        balancers.set('geographic_affinity', {
-            name: 'geographic_affinity',
-            type: 'geographic',
-            parameters: { maxLatency: 100 }
-        });
-        return balancers;
-    }
-    // ========================================
-    // Utility Methods
-    // ========================================
-    stringSimilarity(str1, str2) {
-        // Simple Levenshtein distance-based similarity
-        const len1 = str1.length;
-        const len2 = str2.length;
-        const matrix = Array(len2 + 1).fill(null).map(() => Array(len1 + 1).fill(null));
-        for (let i = 0; i <= len1; i++)
-            matrix[0][i] = i;
-        for (let j = 0; j <= len2; j++)
-            matrix[j][0] = j;
-        for (let j = 1; j <= len2; j++) {
-            for (let i = 1; i <= len1; i++) {
-                const substitutionCost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-                matrix[j][i] = Math.min(matrix[j][i - 1] + 1, // deletion
-                matrix[j - 1][i] + 1, // insertion
-                matrix[j - 1][i - 1] + substitutionCost // substitution
-                );
-            }
-        }
-        const maxLen = Math.max(len1, len2);
-        return maxLen === 0 ? 1 : (maxLen - matrix[len2][len1]) / maxLen;
-    }
-    evaluateConstraint(agent, constraint) {
-        // Implementation would evaluate specific constraint types
-        return true; // Simplified for now
-    }
-    calculateReliabilityScore(agent) {
-        const metrics = agent.metadata.performanceMetrics;
-        const healthScore = agent.healthcheck.consecutiveFailures === 0 ? 1 :
-            Math.max(0, 1 - (agent.healthcheck.consecutiveFailures * 0.1));
-        return (metrics.taskCompletionRate + healthScore) / 2;
-    }
-    buildDependencyGraph(assignments) {
-        // Build dependency graph from task assignments
-        // Implementation would create actual dependency relationships
-        return new Map();
-    }
-    topologicalSort(graph) {
-        // Topological sort implementation
-        // Returns assignments grouped by execution level
-        return [];
-    }
-    calculateTotalDuration(phases) {
-        return phases.reduce((total, phase) => total + phase.estimatedDuration, 0);
-    }
-    calculateParallelizationScore(phases) {
-        const parallelPhases = phases.filter(p => p.type === 'parallel').length;
-        return phases.length > 0 ? parallelPhases / phases.length : 0;
-    }
-    calculateResourceUsage(assignments) {
-        return {
-            cpu: assignments.reduce((total, a) => total + (a.resourceAllocation.find(r => r.type === 'cpu')?.amount || 0), 0),
-            memory: assignments.reduce((total, a) => total + (a.resourceAllocation.find(r => r.type === 'memory')?.amount || 0), 0),
-            network: 0, // Would calculate network usage
-            storage: 0, // Would calculate storage usage
-            apiCalls: 0 // Would estimate API calls
-        };
-    }
-    async validateResourceAllocation(plan, task) {
-        // Validate that resource allocation is realistic
-        return { valid: true };
-    }
-    async validateDeadlines(plan, task) {
-        // Validate that deadlines can be met
-        if (task.deadline) {
-            const estimatedCompletion = new Date(Date.now() + plan.estimated.totalDuration);
-            if (estimatedCompletion > task.deadline) {
-                return {
-                    valid: false,
-                    reason: `Estimated completion (${estimatedCompletion}) exceeds deadline (${task.deadline})`
-                };
-            }
-        }
-        return { valid: true };
-    }
-    async validateCapabilities(plan, task) {
-        // Validate that all required capabilities are covered
-        const requiredCapabilities = task.requirements.capabilities;
-        const assignedCapabilities = new Set();
-        for (const assignment of plan.assignments) {
-            const agent = await this.agentPool.getAgent(assignment.agentId);
-            if (agent) {
-                agent.capabilities.forEach(cap => {
-                    cap.specialization.forEach(spec => assignedCapabilities.add(spec));
-                });
-            }
-        }
-        const missingCapabilities = requiredCapabilities.filter(req => !Array.from(assignedCapabilities).some(assigned => assigned.toLowerCase().includes(req.toLowerCase())));
-        if (missingCapabilities.length > 0) {
-            return {
-                valid: false,
-                reason: `Missing required capabilities: ${missingCapabilities.join(', ')}`
-            };
-        }
-        return { valid: true };
-    }
-    async validateConstraints(plan, task) {
-        // Validate that all constraints are satisfied
-        return { valid: true };
-    }
-}
-exports.IntelligentTaskDistributor = IntelligentTaskDistributor;
-// ========================================
-// Supporting Classes
-// ========================================
-class ExternalAgentPool {
-    constructor() {
-        this.agents = new Map();
-    }
-    async getAvailableAgents() {
-        return Array.from(this.agents.values())
-            .filter(agent => agent.status === distributed_orchestration_interface_js_1.InstanceStatus.ACTIVE || agent.status === distributed_orchestration_interface_js_1.InstanceStatus.IDLE);
-    }
-    async getAgent(agentId) {
-        return this.agents.get(agentId);
-    }
-    async addAgent(agent) {
-        this.agents.set(agent.id, agent);
-    }
-    async removeAgent(agentId) {
-        this.agents.delete(agentId);
-    }
-}
-class TaskAnalyzer {
-    async analyze(task) {
-        const complexity = this.calculateComplexity(task);
-        const estimatedAgentCount = this.estimateAgentCount(task, complexity);
-        const hasGeographicRequirements = this.checkGeographicRequirements(task);
-        const hasStrictOrdering = this.checkStrictOrdering(task);
-        return {
-            complexity,
-            estimatedAgentCount,
-            hasGeographicRequirements,
-            hasStrictOrdering,
-            requirements: task.requirements
-        };
-    }
-    calculateComplexity(task) {
-        let complexity = 0.3; // Base complexity
-        // Factor in number of dependencies
-        complexity += Math.min(task.dependencies.length * 0.1, 0.3);
-        // Factor in number of required capabilities
-        complexity += Math.min(task.requirements.capabilities.length * 0.05, 0.2);
-        // Factor in resource requirements
-        complexity += Math.min(task.requirements.resources.length * 0.1, 0.2);
-        return Math.min(complexity, 1.0);
-    }
-    estimateAgentCount(task, complexity) {
-        const baseAgents = 1;
-        const complexityAgents = Math.ceil(complexity * 3);
-        const capabilityAgents = Math.ceil(task.requirements.capabilities.length / 2);
-        return Math.min(Math.max(baseAgents, complexityAgents, capabilityAgents), 8);
-    }
-    checkGeographicRequirements(task) {
-        return task.requirements.constraints.some(constraint => constraint.type === 'resource' &&
-            constraint.description.toLowerCase().includes('geographic'));
-    }
-    checkStrictOrdering(task) {
-        return task.dependencies.length > 0 ||
-            task.requirements.constraints.some(constraint => constraint.type === 'dependency');
-    }
-}
-class AffinityManager {
-    async apply(assignments, rules) {
-        if (rules.length === 0)
-            return assignments;
-        let optimizedAssignments = [...assignments];
-        for (const rule of rules) {
-            optimizedAssignments = await this.applyAffinityRule(optimizedAssignments, rule);
-        }
-        return optimizedAssignments;
-    }
-    async applyAffinityRule(assignments, rule) {
-        // Implementation would apply specific affinity rules
-        // For now, return unchanged assignments
-        return assignments;
-    }
-}
-class PerformanceTracker {
-    constructor() {
-        this.taskCounts = new Map();
-    }
-    getCurrentTaskCount(agentId) {
-        return this.taskCounts.get(agentId) || 0;
-    }
-    incrementTaskCount(agentId) {
-        const current = this.getCurrentTaskCount(agentId);
-        this.taskCounts.set(agentId, current + 1);
-    }
-    decrementTaskCount(agentId) {
-        const current = this.getCurrentTaskCount(agentId);
-        this.taskCounts.set(agentId, Math.max(0, current - 1));
-    }
-}
-class CostOptimizer {
-    async optimize(assignments, task) {
-        // Implementation would optimize for cost efficiency
-        // For now, return unchanged assignments
-        return assignments;
-    }
-}
-// ========================================
-// Load Balancer Implementations
-// ========================================
-class IntelligentLoadBalancer {
-}
-class RoundRobinLoadBalancer extends IntelligentLoadBalancer {
-    async optimize(candidates, task) {
-        const assignments = [];
-        const agentCount = Math.min(candidates.length, 3); // Limit to 3 agents for round-robin
-        for (let i = 0; i < agentCount; i++) {
-            const agent = candidates[i];
-            assignments.push({
-                agentId: agent.id,
-                taskPortion: {
-                    id: `portion_${i}`,
-                    parentTaskId: task.id,
-                    work: this.createWorkPortion(task, i, agentCount),
-                    inputs: task.requirements.inputs,
-                    expectedOutputs: task.outputs,
-                    dependencies: task.dependencies
-                },
-                priority: 1,
-                estimatedStart: new Date(),
-                estimatedEnd: new Date(Date.now() + (task.estimatedDuration || 300000)),
-                resourceAllocation: []
-            });
-        }
-        return assignments;
-    }
-    createWorkPortion(task, index, total) {
-        return {
-            type: task.type,
-            portion: `${index + 1}/${total}`,
-            description: `${task.description} (Part ${index + 1} of ${total})`
-        };
-    }
-}
-class CapabilityWeightedLoadBalancer extends IntelligentLoadBalancer {
-    constructor(performanceTracker) {
-        super();
-        this.performanceTracker = performanceTracker;
-    }
-    async optimize(candidates, task) {
-        // Implementation would weight assignments based on capabilities
-        return new RoundRobinLoadBalancer().optimize(candidates, task);
-    }
-}
-class GeographicAffinityLoadBalancer extends IntelligentLoadBalancer {
-    async optimize(candidates, task) {
-        // Implementation would optimize for geographic proximity
-        return new RoundRobinLoadBalancer().optimize(candidates, task);
-    }
-}
-class AIOptimizedLoadBalancer extends IntelligentLoadBalancer {
-    constructor(performanceTracker) {
-        super();
-        this.performanceTracker = performanceTracker;
-    }
-    async optimize(candidates, task) {
-        // Implementation would use ML models for optimization
-        return new RoundRobinLoadBalancer().optimize(candidates, task);
-    }
-}
-// ========================================
-// Error Classes
-// ========================================
-class TaskDistributionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'TaskDistributionError';
-    }
-}
-exports.TaskDistributionError = TaskDistributionError;
-//# sourceMappingURL=task-distribution-engine.js.map