vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
178 lines • 5.94 kB
TypeScript
import { EventEmitter } from 'events';
import { Agent, TaskAssignment, AgentStatus } from '../types/agent.js';
import { AtomicTask } from '../types/task.js';
export type WorkloadDistributionStrategy = 'round_robin' | 'least_loaded' | 'capability_first' | 'performance_based' | 'intelligent_hybrid';
export interface AgentAssignmentConfig {
strategy: WorkloadDistributionStrategy;
maxTasksPerAgent: number;
workloadBalanceThreshold: number;
capabilityMatchWeight: number;
performanceWeight: number;
availabilityWeight: number;
predictiveLoadingEnabled: boolean;
autoRebalanceEnabled: boolean;
rebalanceInterval?: number;
}
export interface AgentAssignmentResult {
success: boolean;
assignment?: TaskAssignment;
error?: string;
score?: number;
alternatives?: {
agentId: string;
score: number;
}[];
}
export interface AgentRegistrationResult {
success: boolean;
error?: string;
}
export interface WorkloadImbalanceResult {
isImbalanced: boolean;
imbalanceRatio: number;
overloadedAgents: string[];
underloadedAgents: string[];
severity: 'low' | 'medium' | 'high' | 'critical';
}
export interface TaskRedistributionSuggestion {
fromAgent: string;
toAgent: string;
tasksToMove: string[];
expectedImprovement: number;
reasoning: string;
}
export interface PerformanceStats {
totalAgents: number;
activeAgents: number;
averageSuccessRate: number;
averageCompletionTime: number;
totalTasksCompleted: number;
taskThroughput: number;
}
export interface TaskCompletionPrediction {
estimatedCompletionTime: number;
confidence: number;
factors: {
agentPerformance: number;
taskComplexity: number;
currentLoad: number;
historicalData: number;
};
}
export interface BestAgentResult {
agentId: string;
score: number;
reasoning: string;
confidence: number;
}
export interface WorkloadTrendPrediction {
timeHorizon: number;
agentUtilization: Record<string, number>;
expectedBottlenecks: string[];
recommendations: string[];
}
export interface RealTimeMetrics {
totalAgents: number;
activeAgents: number;
averageLoad: number;
taskThroughput: number;
currentStrategy: WorkloadDistributionStrategy;
lastUpdateTime: Date;
}
export interface AssignmentEfficiency {
successfulAssignments: number;
failedAssignments: number;
averageAssignmentTime: number;
capabilityMatchRate: number;
performanceUtilization: number;
}
export interface WorkloadRebalanceResult {
success: boolean;
redistributions: number;
affectedAgents: string[];
improvementScore: number;
error?: string;
}
export interface ScalingRecommendations {
currentCapacity: number;
recommendedCapacity: number;
reasoning: string;
urgency: 'low' | 'medium' | 'high' | 'critical';
timeframe: string;
}
export interface TaskOptimizationResult {
success: boolean;
assignments: {
taskId: string;
agentId: string;
score: number;
}[];
totalScore: number;
error?: string;
}
export interface ConfigurationRecommendations {
currentPerformance: number;
suggestedChanges: {
parameter: string;
currentValue: unknown;
suggestedValue: unknown;
reasoning: string;
expectedImprovement: number;
}[];
expectedImprovement: number;
}
export declare class IntelligentAgentAssignmentService extends EventEmitter {
private config;
private agents;
private assignments;
private performanceHistory;
private roundRobinIndex;
private statistics;
private rebalanceTimer?;
private disposed;
constructor(config?: Partial<AgentAssignmentConfig>);
registerAgent(agent: Agent): AgentRegistrationResult;
unregisterAgent(agentId: string): AgentRegistrationResult;
getAgent(agentId: string): Agent | undefined;
updateAgentStatus(agentId: string, status: AgentStatus): boolean;
assignTask(task: AtomicTask): Promise<AgentAssignmentResult>;
findBestAgent(task: AtomicTask): Promise<BestAgentResult | null>;
getPerformanceStats(): PerformanceStats;
predictTaskCompletion(agentId: string, task: AtomicTask): TaskCompletionPrediction;
detectWorkloadImbalance(): WorkloadImbalanceResult;
suggestTaskRedistribution(): TaskRedistributionSuggestion[];
rebalanceWorkload(): Promise<WorkloadRebalanceResult>;
predictWorkloadTrends(timeHorizon: number): WorkloadTrendPrediction;
getScalingRecommendations(): ScalingRecommendations;
optimizeForUpcomingTasks(tasks: AtomicTask[]): Promise<TaskOptimizationResult>;
getRealTimeMetrics(): RealTimeMetrics;
getAssignmentEfficiency(): AssignmentEfficiency;
checkAndEmitWorkloadEvents(): Promise<void>;
updateStrategy(strategy: WorkloadDistributionStrategy): void;
updateWorkloadThreshold(threshold: number): void;
getConfiguration(): AgentAssignmentConfig;
getConfigurationRecommendations(): ConfigurationRecommendations;
getActiveAssignments(): TaskAssignment[];
dispose(): void;
private validateConfig;
private validateTask;
private isAgentEligible;
private calculateAgentScore;
private calculateCapabilityScore;
private calculatePerformanceScore;
private calculateAvailabilityScore;
private calculateAgentLoad;
private calculateTaskComplexity;
private calculateTaskThroughput;
private calculateOverallPerformance;
private generateAssignmentReasoning;
private calculateConfidence;
private mapTaskTypeToCapabilities;
private mapTaskPriorityToAssignmentPriority;
private selectRoundRobinAgent;
private selectLeastLoadedAgent;
private selectCapabilityFirstAgent;
private selectPerformanceBasedAgent;
private startAutoRebalancing;
}
//# sourceMappingURL=intelligent-agent-assignment.d.ts.map