@gotza02/seq-thinking 1.1.5 → 1.1.7

package/src/swarm-coordinator.ts

@@ -1,772 +0,0 @@
-/**
- * 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';
-import { Logger } from './utils/logger.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', excludeAgentIds: string[] = []) {
-    const availableAgents = this.registry.getAvailableAgents()
-      .filter(a => !excludeAgentIds.includes(a.config.id))
-      .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 globalRetries = 0;
-    let lastError: any = null;
-    const maxGlobalRetries = maxRetries * 2; // Allow attempts across multiple agents
-    const failedAgents = new Set<string>();
-
-    while (globalRetries < maxGlobalRetries) {
-      const task = this.taskQueue.getTask(taskId);
-      if (!task) throw new Error(`Task not found: ${taskId}`);
-
-      // Auto-reassignment logic if not assigned
-      if (!task.assignedAgentId) {
-        const agent = this.taskAssigner.assignTask(task, 'adaptive', Array.from(failedAgents));
-        if (agent) {
-          this.taskQueue.assignTask(task.id, agent.config.id);
-          this.registry.updateAgentStatus(agent.config.id, AgentStatus.BUSY);
-          Logger.info(`Reassigned task ${taskId} to agent ${agent.config.id}`);
-        } else {
-          // No more agents available
-          Logger.warn(`No suitable agent found for task ${taskId} (Agents tried: ${Array.from(failedAgents).join(', ')})`);
-          break; 
-        }
-      }
-
-      // Check assignment validity
-      if (!task.assignedAgentId) {
-         break; // Should be handled above, but safety check
-      }
-
-      const agentState = this.registry.getAgent(task.assignedAgentId);
-      if (!agentState || !agentState.instance) {
-         // Agent gone? Treat as failure
-         failedAgents.add(task.assignedAgentId);
-         task.assignedAgentId = null;
-         globalRetries++;
-         continue;
-      }
-
-      this.taskQueue.startTask(taskId);
-      
-      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;
-        globalRetries++;
-        Logger.warn(`Task ${taskId} failed with agent ${task.assignedAgentId} (attempt ${globalRetries}/${maxGlobalRetries})`, { error });
-        
-        // Mark agent as failed for this task and unassign
-        if (task.assignedAgentId) {
-             failedAgents.add(task.assignedAgentId);
-             this.registry.updateAgentStatus(task.assignedAgentId, AgentStatus.IDLE);
-             task.assignedAgentId = null; // Unassign to trigger reassignment
-        }
-
-        task.status = TaskStatus.PENDING; // Reset status for next attempt
-        
-        // Wait a bit before next loop
-        await new Promise(resolve => setTimeout(resolve, 500 * globalRetries));
-      }
-    }
-
-    const processingTime = 0;
-    this.taskQueue.failTask(taskId, String(lastError));
-    // Final cleanup if task is still assigned
-    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
-    };
-  }
-}