@gotza02/seq-thinking 1.1.0

package/src/swarm-coordinator.ts

@@ -0,0 +1,744 @@
+/**
+ * Swarm Coordinator
+ * Handles agent registration, task queueing, message brokering, consensus, and conflict resolution.
+ */
+import {
+  MessageType,
+  ConsensusAlgorithm,
+  ConflictResolutionStrategy,
+  AgentConfig,
+  AgentCapability,
+  Task,
+  TaskResult,
+  SwarmMessage,
+  ConsensusVote,
+  ConsensusResult,
+  Conflict,
+  ConflictResolution,
+  ConflictPosition,
+  TaskStatus,
+  AgentStatus,
+  ConflictStatus
+} from './types/index.js';
+import { BaseAgent } from './agents/base-agent.js';
+
+import { PersistenceManager } from './utils/persistence.js';
+
+/**
+ * Registry to track all agents in the swarm
+ */
+export class AgentRegistry {
+  private agents = new Map<string, {
+    config: AgentConfig;
+    status: AgentStatus;
+    currentTasks: string[];
+    performanceHistory: { taskId: string; quality: number; timeMs: number; timestamp: Date }[];
+    instance?: BaseAgent;
+  }>();
+
+  private agentsByType = new Map<string, Set<string>>();
+  private agentsByCapability = new Map<string, Set<string>>();
+  private persistence: PersistenceManager | null = null;
+
+  constructor(persistenceDir?: string) {
+    if (persistenceDir) {
+      this.persistence = new PersistenceManager(persistenceDir);
+    }
+  }
+
+  async initialize() {
+    if (this.persistence) {
+      await this.persistence.initialize(['agents']);
+      await this.loadAgents();
+    }
+  }
+
+  private async loadAgents() {
+    if (!this.persistence) return;
+    const ids = await this.persistence.list('agents');
+    for (const id of ids) {
+      const savedData = await this.persistence.load<any>('agents', id);
+      if (savedData) {
+        // We only persist the config and metadata, instances must be re-registered
+        const agent = {
+          config: savedData.config,
+          status: AgentStatus.OFFLINE, // Loaded agents start offline until instances are registered
+          currentTasks: [],
+          performanceHistory: savedData.performanceHistory || [],
+        };
+        this.agents.set(id, agent);
+        this.indexAgent(agent.config);
+      }
+    }
+  }
+
+  private indexAgent(config: AgentConfig) {
+    if (!this.agentsByType.has(config.type)) {
+      this.agentsByType.set(config.type, new Set());
+    }
+    this.agentsByType.get(config.type)!.add(config.id);
+
+    for (const capability of config.capabilities) {
+      if (!this.agentsByCapability.has(capability.name)) {
+        this.agentsByCapability.set(capability.name, new Set());
+      }
+      this.agentsByCapability.get(capability.name)!.add(config.id);
+    }
+  }
+
+  async registerAgent(config: AgentConfig, instance?: BaseAgent) {
+    const agent = {
+      config,
+      status: AgentStatus.IDLE, // Default to IDLE for registered agents
+      currentTasks: [],
+      performanceHistory: [],
+      instance
+    };
+    this.agents.set(config.id, agent);
+    this.indexAgent(config);
+
+    if (this.persistence) {
+      await this.persistence.save('agents', config.id, {
+        config,
+        performanceHistory: agent.performanceHistory
+      });
+    }
+
+    return agent;
+  }
+
+  async unregisterAgent(agentId: string) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return false;
+
+    this.agents.delete(agentId);
+    this.agentsByType.get(agent.config.type)?.delete(agentId);
+
+    for (const capability of agent.config.capabilities) {
+      this.agentsByCapability.get(capability.name)?.delete(agentId);
+    }
+
+    if (this.persistence) {
+      await this.persistence.delete('agents', agentId);
+    }
+
+    return true;
+  }
+
+  getAgent(agentId: string) {
+    return this.agents.get(agentId);
+  }
+
+  getAgentsByType(type: string) {
+    const ids = this.agentsByType.get(type);
+    if (!ids) return [];
+    return Array.from(ids)
+      .map(id => this.agents.get(id))
+      .filter((a): a is any => a !== undefined);
+  }
+
+  getAgentsByCapability(capability: string) {
+    const ids = this.agentsByCapability.get(capability);
+    if (!ids) return [];
+    return Array.from(ids)
+      .map(id => this.agents.get(id))
+      .filter((a): a is any => a !== undefined);
+  }
+
+  getAllAgents() {
+    return Array.from(this.agents.values());
+  }
+
+  getAvailableAgents() {
+    return this.getAllAgents().filter(a => a.status === AgentStatus.IDLE);
+  }
+
+  updateAgentStatus(agentId: string, status: AgentStatus) {
+    const agent = this.agents.get(agentId);
+    if (agent) agent.status = status;
+  }
+
+  recordPerformance(agentId: string, taskId: string, quality: number, timeMs: number) {
+    const agent = this.agents.get(agentId);
+    if (agent) {
+      agent.performanceHistory.push({ taskId, quality, timeMs, timestamp: new Date() });
+    }
+  }
+}
+
+/**
+ * Broker for swarm communication
+ */
+export class MessageBroker {
+  private messages = new Map<string, SwarmMessage>();
+  private subscriptions = new Map<string, Set<(message: SwarmMessage) => void>>();
+
+  sendMessage(message: Partial<SwarmMessage> & { type: MessageType; senderId: string; payload: any }): SwarmMessage {
+    const fullMessage: SwarmMessage = {
+      id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      timestamp: new Date(),
+      type: message.type,
+      senderId: message.senderId,
+      recipientId: message.recipientId || null,
+      payload: message.payload,
+      context: message.context || {},
+      metadata: message.metadata || { priority: 1, ttl: 60000, retryCount: 0 }
+    };
+
+    this.messages.set(fullMessage.id, fullMessage);
+
+    if (fullMessage.recipientId) {
+      this.deliverToRecipient(fullMessage);
+    } else {
+      this.broadcast(fullMessage);
+    }
+
+    return fullMessage;
+  }
+
+  public broadcast(message: SwarmMessage) {
+    const subscribers = this.subscriptions.get('broadcast');
+    if (subscribers) {
+      subscribers.forEach(callback => {
+        try { callback(message); } catch (e) { /* ignore */ }
+      });
+    }
+  }
+
+  public deliverToRecipient(message: SwarmMessage) {
+    if (!message.recipientId) return;
+    const subscribers = this.subscriptions.get(message.recipientId);
+    if (subscribers) {
+      subscribers.forEach(callback => {
+        try { callback(message); } catch (e) { /* ignore */ }
+      });
+    }
+  }
+
+  subscribe(agentId: string, callback: (message: SwarmMessage) => void) {
+    if (!this.subscriptions.has(agentId)) {
+      this.subscriptions.set(agentId, new Set());
+    }
+    this.subscriptions.get(agentId)!.add(callback);
+    return () => { this.subscriptions.get(agentId)?.delete(callback); };
+  }
+}
+
+/**
+ * Manager for task lifecycle
+ */
+export class TaskQueueManager {
+  private tasks = new Map<string, Task>();
+  private pendingQueue: string[] = [];
+
+  createTask(type: string, description: string, input: any, requirements: any, context: any = { dependencies: [] }) {
+    const task: Task = {
+      id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      type,
+      description,
+      input,
+      context,
+      requirements,
+      assignedAgentId: null,
+      status: TaskStatus.PENDING,
+      result: null,
+      metadata: { createdAt: new Date() }
+    };
+    this.tasks.set(task.id, task);
+    this.pendingQueue.push(task.id);
+    return task;
+  }
+
+  assignTask(taskId: string, agentId: string) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== TaskStatus.PENDING) return null;
+
+    task.assignedAgentId = agentId;
+    task.status = TaskStatus.ASSIGNED;
+    task.metadata.assignedAt = new Date();
+
+    const index = this.pendingQueue.indexOf(taskId);
+    if (index > -1) this.pendingQueue.splice(index, 1);
+
+    return task;
+  }
+
+  startTask(taskId: string) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== TaskStatus.ASSIGNED) return null;
+
+    task.status = TaskStatus.IN_PROGRESS;
+    task.metadata.startedAt = new Date();
+    return task;
+  }
+
+  completeTask(taskId: string, result: TaskResult) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+
+    task.status = TaskStatus.COMPLETED;
+    task.result = result;
+    task.metadata.completedAt = new Date();
+  }
+
+  failTask(taskId: string, error: string) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+
+    task.status = TaskStatus.FAILED;
+    task.result = {
+      taskId,
+      agentId: task.assignedAgentId || 'unknown',
+      success: false,
+      output: null,
+      confidence: 0,
+      processingTimeMs: 0,
+      metadata: { tokensUsed: 0, reasoningSteps: 0, intermediateResults: [], error }
+    };
+    task.metadata.completedAt = new Date();
+  }
+
+  getTask(taskId: string) {
+    return this.tasks.get(taskId);
+  }
+
+  getTasksByStatus(status: TaskStatus) {
+    return Array.from(this.tasks.values()).filter(t => t.status === status);
+  }
+
+  getPendingTasks() {
+    return this.getTasksByStatus(TaskStatus.PENDING);
+  }
+
+  getInProgressTasks() {
+    return this.getTasksByStatus(TaskStatus.IN_PROGRESS);
+  }
+
+  getCompletedTasks() {
+    return this.getTasksByStatus(TaskStatus.COMPLETED);
+  }
+}
+
+/**
+ * Strategy for assigning tasks to agents
+ */
+export class TaskAssigner {
+  private lastAssignmentIndex = new Map<string, number>();
+
+  constructor(private registry: AgentRegistry) {}
+
+  assignTask(task: Task, strategy: string = 'adaptive') {
+    const availableAgents = this.registry.getAvailableAgents()
+      .filter(a => this.hasRequiredCapabilities(a, task.requirements?.requiredCapabilities || task.requiredCapabilities || []));
+
+    if (availableAgents.length === 0) return null;
+
+    switch (strategy) {
+      case 'round_robin':
+        return this.roundRobin(availableAgents, task.type);
+      case 'capability_based':
+        return this.capabilityBased(availableAgents, task);
+      case 'load_balanced':
+        return this.loadBalanced(availableAgents);
+      default:
+        // Default to best capable
+        return this.capabilityBased(availableAgents, task);
+    }
+  }
+
+  private hasRequiredCapabilities(agent: any, required: string[]) {
+    const agentCaps = agent.config.capabilities.map((c: any) => c.name);
+    return required.every(cap => agentCaps.includes(cap));
+  }
+
+  private roundRobin(agents: any[], taskType: string) {
+    const lastIndex = this.lastAssignmentIndex.get(taskType) ?? -1;
+    const nextIndex = (lastIndex + 1) % agents.length;
+    this.lastAssignmentIndex.set(taskType, nextIndex);
+    return agents[nextIndex];
+  }
+
+  private capabilityBased(agents: any[], task: Task) {
+    return agents.reduce((best, current) => {
+      const bestScore = this.calculateCapabilityScore(best, task);
+      const currentScore = this.calculateCapabilityScore(current, task);
+      return currentScore > bestScore ? current : best;
+    });
+  }
+
+  private calculateCapabilityScore(agent: any, task: Task) {
+    const requiredCaps = task.requirements?.requiredCapabilities || task.requiredCapabilities || [];
+    if (requiredCaps.length === 0) return 1.0;
+
+    const agentCaps = agent.config.capabilities;
+    let score = 0;
+    for (const reqCap of requiredCaps) {
+      const cap = agentCaps.find((c: any) => c.name === reqCap);
+      if (cap) score += cap.confidence;
+    }
+    return score / requiredCaps.length;
+  }
+
+  private loadBalanced(agents: any[]) {
+    return agents.reduce((best, current) =>
+      current.currentTasks.length < best.currentTasks.length ? current : best
+    );
+  }
+}
+
+/**
+ * Engine for reaching consensus among agents
+ */
+export class ConsensusEngine {
+  async reachConsensus(
+    proposalId: string,
+    algorithm: ConsensusAlgorithm,
+    votes: ConsensusVote[],
+    minAgreementRatio: number = 0.67,
+    maxRounds: number = 1
+  ): Promise<ConsensusResult> {
+    const counts = new Map<any, number>();
+    for (const vote of votes) {
+      counts.set(vote.vote, (counts.get(vote.vote) || 0) + vote.confidence);
+    }
+
+    let winner: any = null;
+    let maxCount = 0;
+    for (const [option, count] of counts) {
+      if (count > maxCount) {
+        maxCount = count;
+        winner = option;
+      }
+    }
+
+    const totalWeight = Array.from(counts.values()).reduce((a, b) => a + b, 0);
+    const agreementRatio = totalWeight > 0 ? maxCount / totalWeight : 0;
+
+    return {
+      proposalId,
+      algorithm,
+      winningOption: winner,
+      confidence: votes.length > 0 ? votes.reduce((s, v) => s + v.confidence, 0) / votes.length : 0,
+      votes,
+      agreementRatio,
+      dissentingOpinions: votes.filter(v => v.vote !== winner).map(v => ({
+        agentId: v.agentId,
+        opinion: v.vote,
+        reasoning: v.reasoning
+      })),
+      metadata: {
+        rounds: maxRounds,
+        totalVotingTimeMs: 0,
+        convergenceRate: agreementRatio
+      }
+    };
+  }
+}
+
+/**
+ * Resolver for conflicts between agents
+ */
+export class ConflictResolver {
+  private conflicts = new Map<string, Conflict>();
+
+  identifyConflict(type: string, description: string, positions: ConflictPosition[]) {
+    const conflict: Conflict = {
+      id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      type,
+      description,
+      involvedAgents: positions.map(p => p.agentId),
+      conflictingPositions: positions,
+      status: ConflictStatus.DETECTED,
+      resolution: null,
+      metadata: { createdAt: new Date() }
+    };
+    this.conflicts.set(conflict.id, conflict);
+    return conflict;
+  }
+
+  resolveConflict(conflictId: string, strategy: ConflictResolutionStrategy, resolverAgentId: string) {
+    const conflict = this.conflicts.get(conflictId);
+    if (!conflict) throw new Error(`Conflict not found: ${conflictId}`);
+
+    conflict.status = ConflictStatus.RESOLVING;
+
+    let resolution: ConflictResolution;
+    switch (strategy) {
+      case ConflictResolutionStrategy.ARBITRATION:
+        const highest = conflict.conflictingPositions.reduce((max, p) => p.confidence > max.confidence ? p : max);
+        resolution = {
+          strategy: ConflictResolutionStrategy.ARBITRATION,
+          result: highest.position,
+          confidence: highest.confidence,
+          reasoning: highest.reasoning || 'Highest confidence position'
+        };
+        break;
+      case ConflictResolutionStrategy.VOTING:
+        const votes = new Map<any, number>();
+        for (const pos of conflict.conflictingPositions) {
+          votes.set(pos.position, (votes.get(pos.position) || 0) + pos.confidence);
+        }
+        let winner: any = null;
+        let maxVotes = 0;
+        for (const [pos, count] of votes) {
+          if (count > maxVotes) {
+            maxVotes = count;
+            winner = pos;
+          }
+        }
+        resolution = {
+          strategy: ConflictResolutionStrategy.VOTING,
+          result: winner,
+          confidence: conflict.conflictingPositions.length > 0 ? maxVotes / conflict.conflictingPositions.length : 0,
+          reasoning: 'Majority vote'
+        };
+        break;
+      default:
+        resolution = {
+          strategy: strategy,
+          result: conflict.conflictingPositions[0]?.position,
+          confidence: 0.5,
+          reasoning: `Resolved via ${strategy}`
+        };
+    }
+
+    conflict.resolution = resolution;
+    conflict.status = ConflictStatus.RESOLVED;
+    conflict.metadata.resolvedAt = new Date();
+    conflict.metadata.resolutionStrategy = strategy;
+    conflict.metadata.resolverAgentId = resolverAgentId;
+
+    return { conflict, resolution };
+  }
+
+  getConflict(conflictId: string) {
+    return this.conflicts.get(conflictId);
+  }
+
+  getAllConflicts() {
+    return Array.from(this.conflicts.values());
+  }
+}
+
+/**
+ * Orchestrates all swarm activities
+ */
+export class SwarmCoordinator {
+  public registry: AgentRegistry;
+  public messageBroker = new MessageBroker();
+  public taskQueue = new TaskQueueManager();
+  public taskAssigner: TaskAssigner;
+  public consensusEngine = new ConsensusEngine();
+  public conflictResolver = new ConflictResolver();
+
+  constructor(persistenceDir?: string) {
+    this.registry = new AgentRegistry(persistenceDir);
+    this.taskAssigner = new TaskAssigner(this.registry);
+  }
+
+  async initialize() {
+    await this.registry.initialize();
+  }
+
+  async registerAgent(agentOrConfig: BaseAgent | AgentConfig) {
+    if (agentOrConfig instanceof BaseAgent || typeof (agentOrConfig as any).execute === 'function') {
+      const agent = agentOrConfig as BaseAgent;
+      return await this.registry.registerAgent(agent.config, agent);
+    }
+    return await this.registry.registerAgent(agentOrConfig as AgentConfig);
+  }
+
+  getAllAgents() {
+    return this.registry.getAllAgents();
+  }
+
+  async unregisterAgent(agentId: string) {
+    return await this.registry.unregisterAgent(agentId);
+  }
+
+  submitTask(type: string, description: string, input: any, requirements: any, strategy: string = 'adaptive') {
+    const task = this.taskQueue.createTask(type, description, input, requirements);
+    const agent = this.taskAssigner.assignTask(task, strategy);
+
+    if (agent) {
+      this.taskQueue.assignTask(task.id, agent.config.id);
+      this.registry.updateAgentStatus(agent.config.id, AgentStatus.BUSY);
+    }
+    return { task, assignedAgent: agent };
+  }
+
+  async executeTask(taskId: string, maxRetries: number = 3) {
+    let retries = 0;
+    let lastError: any = null;
+
+    while (retries < maxRetries) {
+      const task = this.taskQueue.getTask(taskId);
+      if (!task) throw new Error(`Task not found: ${taskId}`);
+
+      if (!task.assignedAgentId) {
+        throw new Error(`Task ${taskId} is not assigned to any agent`);
+      }
+
+      const agentState = this.registry.getAgent(task.assignedAgentId);
+      if (!agentState || !agentState.instance) {
+        throw new Error(`Agent execution instance not found for agent: ${task.assignedAgentId}`);
+      }
+
+      this.taskQueue.startTask(taskId);
+      const startTime = Date.now();
+      
+      try {
+        const result = await agentState.instance.execute(task);
+        this.taskQueue.completeTask(taskId, result);
+        this.registry.updateAgentStatus(task.assignedAgentId, AgentStatus.IDLE);
+        this.registry.recordPerformance(task.assignedAgentId, taskId, result.confidence, result.processingTimeMs);
+        return result;
+      } catch (error) {
+        lastError = error;
+        retries++;
+        console.warn(`Task ${taskId} failed (attempt ${retries}/${maxRetries}):`, error);
+        
+        if (retries < maxRetries) {
+          // Wait before retry
+          await new Promise(resolve => setTimeout(resolve, 1000 * retries));
+          // Reset status to ASSIGNED for retry
+          task.status = TaskStatus.ASSIGNED;
+        }
+      }
+    }
+
+    const processingTime = 0;
+    this.taskQueue.failTask(taskId, String(lastError));
+    const task = this.taskQueue.getTask(taskId);
+    if (task?.assignedAgentId) {
+      this.registry.updateAgentStatus(task.assignedAgentId, AgentStatus.IDLE);
+    }
+
+    const result: TaskResult = {
+      taskId,
+      agentId: task?.assignedAgentId || 'unknown',
+      success: false,
+      output: null,
+      confidence: 0,
+      processingTimeMs: processingTime,
+      metadata: { tokensUsed: 0, reasoningSteps: 0, intermediateResults: [], error: String(lastError) }
+    };
+    return result;
+  }
+
+  async reachConsensus(
+    proposal: any,
+    options: any[],
+    algorithm: ConsensusAlgorithm = ConsensusAlgorithm.WEIGHTED_VOTE,
+    participatingAgents?: string[],
+    minAgreementRatio: number = 0.67,
+    maxRounds: number = 3,
+    context: any = {}
+  ): Promise<ConsensusResult> {
+    const agentIds = participatingAgents || this.registry.getAllAgents().map(a => a.config.id);
+    const proposalId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+
+    const votes: ConsensusVote[] = [];
+    const startTime = Date.now();
+
+    const votePromises = agentIds.map(async (agentId) => {
+      const agentState = this.registry.getAgent(agentId);
+      if (!agentState || !agentState.instance) return null;
+
+      // Enhanced context for consensus voting
+      const task = this.taskQueue.createTask(
+        'consensus_vote',
+        `Vote on proposal: ${typeof proposal === 'string' ? proposal : JSON.stringify(proposal)}`,
+        { 
+          proposal, 
+          options, 
+          proposalId, 
+          algorithm,
+          context: {
+            ...context,
+            swarmStats: this.getSwarmStats(),
+            previousVotes: votes.map(v => ({ agentId: v.agentId, vote: v.vote }))
+          }
+        },
+        { requiredCapabilities: ['consensus_vote'], minConfidence: 0, maxTimeMs: 10000 }
+      );
+
+      this.taskQueue.assignTask(task.id, agentId);
+      this.registry.updateAgentStatus(agentId, AgentStatus.BUSY);
+
+      try {
+        const result = await agentState.instance.execute(task);
+        this.taskQueue.completeTask(task.id, result);
+        this.registry.updateAgentStatus(agentId, AgentStatus.IDLE);
+
+        if (result.success && result.output) {
+          const output = result.output as any;
+          return {
+            agentId,
+            proposalId,
+            vote: output.vote ?? options[0],
+            confidence: result.confidence,
+            reasoning: output.reasoning || 'No reasoning provided',
+            timestamp: new Date()
+          } as ConsensusVote;
+        }
+      } catch (error) {
+        this.taskQueue.failTask(task.id, String(error));
+        this.registry.updateAgentStatus(agentId, AgentStatus.IDLE);
+      }
+      return null;
+    });
+
+    const results = await Promise.all(votePromises);
+    for (const res of results) {
+      if (res) votes.push(res);
+    }
+
+    const consensus = await this.consensusEngine.reachConsensus(proposalId, algorithm, votes, minAgreementRatio, 1);
+    consensus.metadata.totalVotingTimeMs = Date.now() - startTime;
+
+    return consensus;
+  }
+
+  identifyConflict(type: string, description: string, positions: ConflictPosition[]) {
+    return this.conflictResolver.identifyConflict(type, description, positions);
+  }
+
+  resolveConflict(conflictId: string, strategy: ConflictResolutionStrategy, resolverAgentId?: string) {
+    return this.conflictResolver.resolveConflict(conflictId, strategy, resolverAgentId || 'coordinator');
+  }
+
+  broadcastMessage(senderId: string, payload: any) {
+    return this.messageBroker.sendMessage({
+      type: MessageType.BROADCAST,
+      senderId,
+      recipientId: null,
+      payload,
+      context: {},
+      metadata: { priority: 1, ttl: 60000, retryCount: 0 }
+    });
+  }
+
+  sendDirectMessage(senderId: string, recipientId: string, payload: any) {
+    return this.messageBroker.sendMessage({
+      type: MessageType.DIRECT,
+      senderId,
+      recipientId,
+      payload,
+      context: {},
+      metadata: { priority: 1, ttl: 60000, retryCount: 0 }
+    });
+  }
+
+  getSwarmStats() {
+    return {
+      totalAgents: this.registry.getAllAgents().length,
+      availableAgents: this.registry.getAvailableAgents().length,
+      busyAgents: this.registry.getAllAgents().filter(a => a.status === AgentStatus.BUSY).length,
+      pendingTasks: this.taskQueue.getPendingTasks().length,
+      inProgressTasks: this.taskQueue.getInProgressTasks().length,
+      completedTasks: this.taskQueue.getCompletedTasks().length,
+      activeConflicts: this.conflictResolver.getAllConflicts().filter(c => c.status !== ConflictStatus.RESOLVED).length
+    };
+  }
+}