claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
186 lines • 4.22 kB
TypeScript
/**
* V3 Swarm Types
* Modernized type system for swarm coordination
*/
import type { ISwarmConfig, ISwarmState, SwarmTopology, CoordinationStatus } from '../core/interfaces/coordinator.interface.js';
import type { IAgent } from '../core/interfaces/agent.interface.js';
/**
* Swarm initialization options
*/
export interface SwarmInitOptions extends ISwarmConfig {
name?: string;
description?: string;
initialAgents?: string[];
warmup?: boolean;
warmupTasks?: number;
}
/**
* Swarm initialization result
*/
export interface SwarmInitResult {
state: ISwarmState;
agents: IAgent[];
startupTime: number;
ready: boolean;
}
/**
* Swarm scaling options
*/
export interface SwarmScaleOptions {
targetSize: number;
agentType?: string;
timeout?: number;
graceful?: boolean;
}
/**
* Swarm scaling result
*/
export interface SwarmScaleResult {
previousSize: number;
currentSize: number;
agentsAdded: string[];
agentsRemoved: string[];
duration: number;
success: boolean;
}
/**
* Swarm coordination message
*/
export interface SwarmMessage<T = unknown> {
id: string;
type: string;
source: string;
target?: string | 'broadcast';
payload: T;
timestamp: Date;
correlationId?: string;
replyTo?: string;
ttl?: number;
}
/**
* Swarm consensus request
*/
export interface ConsensusRequest<T = unknown> {
topic: string;
options: T[];
requiredVotes: number | 'majority' | 'all';
timeout: number;
voters?: string[];
}
/**
* Swarm consensus response
*/
export interface ConsensusResponse<T = unknown> {
topic: string;
decision: T | null;
votes: Map<string, T>;
consensus: boolean;
votingDuration: number;
participatingAgents: string[];
}
/**
* Distributed lock state
*/
export interface DistributedLock {
resourceId: string;
holderId: string;
acquiredAt: Date;
expiresAt: Date;
renewCount: number;
}
/**
* Lock acquisition result
*/
export interface LockAcquisitionResult {
acquired: boolean;
lock?: DistributedLock;
waitTime?: number;
error?: Error;
}
/**
* Deadlock detection result
*/
export interface DeadlockDetectionResult {
detected: boolean;
agents: string[];
resources: string[];
cycle?: string[][];
suggestedResolution?: string;
}
/**
* Swarm metrics
*/
export interface SwarmMetrics {
topology: SwarmTopology;
status: CoordinationStatus;
agentCount: number;
activeAgentCount: number;
taskCount: number;
completedTasks: number;
failedTasks: number;
throughput: number;
avgLatencyMs: number;
p95LatencyMs: number;
p99LatencyMs: number;
successRate: number;
resourceUtilization: number;
messagesSent: number;
messagesReceived: number;
consensusRounds: number;
locksAcquired: number;
deadlocksDetected: number;
uptime: number;
timestamp: Date;
}
/**
* Swarm event payloads
*/
export interface SwarmEventPayloads {
'swarm:initialized': {
state: ISwarmState;
config: ISwarmConfig;
};
'swarm:scaled': {
result: SwarmScaleResult;
};
'swarm:topology:changed': {
previousTopology: SwarmTopology;
currentTopology: SwarmTopology;
};
'swarm:status:changed': {
previousStatus: CoordinationStatus;
currentStatus: CoordinationStatus;
};
'swarm:message:sent': {
message: SwarmMessage;
};
'swarm:message:received': {
message: SwarmMessage;
};
'swarm:consensus:started': {
request: ConsensusRequest;
};
'swarm:consensus:completed': {
response: ConsensusResponse;
};
'swarm:lock:acquired': {
lock: DistributedLock;
};
'swarm:lock:released': {
resourceId: string;
holderId: string;
duration: number;
};
'swarm:deadlock:detected': {
result: DeadlockDetectionResult;
};
'swarm:shutdown': {
reason: string;
graceful: boolean;
};
}
/**
* Topology configuration presets
*/
export declare const TopologyPresets: Record<SwarmTopology, Partial<ISwarmConfig>>;
//# sourceMappingURL=swarm.types.d.ts.map