snow-flow 3.0.9 → 3.0.10

package/dist/agents/coordinator.d.ts

@@ -1,200 +0,0 @@
-/**
- * Agent Coordination System
- * Manages inter-agent communication, task dependencies, and handoffs
- * Integrates with SQLite memory for persistent coordination state
- */
-import { EventEmitter } from 'eventemitter3';
-import { Agent, AgentMessage } from '../queen/types';
-import { QueenMemorySystem } from '../queen/queen-memory';
-export interface CoordinationContext {
-    sessionId: string;
-    objectiveId: string;
-    agents: Map<string, Agent>;
-    dependencies: Map<string, string[]>;
-    handoffs: Map<string, HandoffRequest>;
-    blockages: Map<string, BlockageInfo>;
-}
-export interface HandoffRequest {
-    id: string;
-    fromAgent: string;
-    toAgent: string;
-    artifactType: string;
-    artifactData: any;
-    status: 'pending' | 'accepted' | 'completed' | 'failed';
-    createdAt: Date;
-    completedAt?: Date;
-}
-export interface BlockageInfo {
-    agentId: string;
-    reason: string;
-    blockedTasks: string[];
-    dependencies: string[];
-    attemptedResolutions: string[];
-    createdAt: Date;
-}
-export interface CoordinationStrategy {
-    type: 'sequential' | 'parallel' | 'adaptive';
-    rules: CoordinationRule[];
-    fallbackStrategy?: string;
-}
-export interface CoordinationRule {
-    condition: string;
-    action: string;
-    priority: number;
-}
-export interface RecoveryStrategy {
-    errorType: string;
-    recoveryActions: RecoveryAction[];
-    maxRetries: number;
-}
-export interface RecoveryAction {
-    type: 'retry' | 'fallback' | 'reassign' | 'escalate';
-    config: Record<string, any>;
-}
-export declare class AgentCoordinator extends EventEmitter {
-    private memory;
-    private contexts;
-    private strategies;
-    private recoveryStrategies;
-    private messageQueue;
-    constructor(memory: QueenMemorySystem);
-    /**
-     * Create a new coordination context for an objective
-     */
-    createContext(sessionId: string, objectiveId: string): Promise<CoordinationContext>;
-    /**
-     * Register an agent with the coordinator
-     */
-    registerAgent(agent: Agent, objectiveId?: string): Promise<void>;
-    /**
-     * Manage task dependencies between agents
-     */
-    manageDependencies(objectiveId: string, taskId: string, dependencies: string[]): Promise<void>;
-    /**
-     * Coordinate handoff between agents
-     */
-    coordinateHandoff(fromAgentId: string, toAgentId: string, artifactType: string, artifactData: any): Promise<HandoffRequest>;
-    /**
-     * Handle agent blockage with recovery strategies
-     */
-    handleBlockage(agentId: string, reason: string, blockedTasks: string[]): Promise<void>;
-    /**
-     * Send message between agents
-     */
-    sendMessage(fromAgentId: string, toAgentId: string, messageType: AgentMessage['type'], content: any): Promise<void>;
-    /**
-     * Get pending messages for an agent
-     */
-    getAgentMessages(agentId: string): Promise<AgentMessage[]>;
-    /**
-     * Update handoff status
-     */
-    updateHandoffStatus(handoffId: string, status: HandoffRequest['status']): Promise<void>;
-    /**
-     * Get coordination status for an objective
-     */
-    getCoordinationStatus(objectiveId: string): Promise<{
-        agents: {
-            total: number;
-            active: number;
-            blocked: number;
-        };
-        handoffs: {
-            total: number;
-            pending: number;
-            completed: number;
-        };
-        dependencies: {
-            total: number;
-            satisfied: number;
-        };
-        blockages: number;
-    }>;
-    /**
-     * Apply coordination strategy
-     */
-    applyStrategy(objectiveId: string, strategyType: string): Promise<void>;
-    /**
-     * Terminate an agent
-     */
-    terminateAgent(agentId: string): Promise<void>;
-    /**
-     * Initialize default coordination strategies
-     */
-    private initializeDefaultStrategies;
-    /**
-     * Initialize recovery strategies for error handling
-     */
-    private initializeRecoveryStrategies;
-    /**
-     * Set up memory synchronization
-     */
-    private setupMemorySync;
-    /**
-     * Sync context to memory
-     */
-    private syncContextToMemory;
-    /**
-     * Check if dependencies are satisfied
-     */
-    private checkDependencySatisfaction;
-    /**
-     * Check if a specific dependency is satisfied
-     */
-    private isDependencySatisfied;
-    /**
-     * Find blocked dependencies
-     */
-    private findBlockedDependencies;
-    /**
-     * Attempt recovery for blocked agent
-     */
-    private attemptRecovery;
-    /**
-     * Find recovery strategy for error type
-     */
-    private findRecoveryStrategy;
-    /**
-     * Execute recovery action
-     */
-    private executeRecoveryAction;
-    /**
-     * Find available agent of specified type
-     */
-    private findAvailableAgent;
-    /**
-     * Reassign tasks from one agent to another
-     */
-    private reassignTasks;
-    /**
-     * Process pending messages for an agent
-     */
-    private processAgentMessages;
-    /**
-     * Evaluate strategy condition
-     */
-    private evaluateCondition;
-    /**
-     * Execute strategy action
-     */
-    private executeAction;
-    /**
-     * Generate unique ID
-     */
-    private generateId;
-    /**
-     * Get coordinator statistics
-     */
-    getStats(): Promise<{
-        activeContexts: number;
-        totalAgents: number;
-        activeHandoffs: number;
-        blockedAgents: number;
-        messagesInQueue: number;
-    }>;
-    /**
-     * Clean up completed contexts
-     */
-    cleanup(): Promise<void>;
-}
-//# sourceMappingURL=coordinator.d.ts.map