snow-flow 3.0.8 → 3.0.10

package/dist/orchestration/distributed-orchestrator.d.ts

@@ -1,131 +0,0 @@
-/**
- * Main Distributed Orchestrator
- *
- * The central orchestrator that coordinates external Claude Code instances
- * using MCPX protocol, intelligent task distribution, and distributed state management.
- */
-import { EventEmitter } from 'events';
-import { DistributedOrchestrator, OrchestrationSession, SessionConfig, TaskSpecification, OrchestrationResult, DistributionResult, ExecutionUpdate, SharedState, StateUpdate, SyncResult, ServiceDefinition, DiscoveryCriteria, ServiceChangeCallback, ClaudeCodeInstance, HealthStatus } from './interfaces/distributed-orchestration.interface';
-export declare class SnowFlowDistributedOrchestrator extends EventEmitter implements DistributedOrchestrator {
-    private sessions;
-    private mcpxProtocol;
-    private taskDistributor;
-    private agentDiscovery;
-    private stateManager;
-    private instanceId;
-    private config;
-    private healthMonitor;
-    private metricsCollector;
-    constructor(config: OrchestratorConfig);
-    createSession(config: SessionConfig): Promise<OrchestrationSession>;
-    getSession(sessionId: string): Promise<OrchestrationSession | null>;
-    terminateSession(sessionId: string): Promise<void>;
-    listSessions(): Promise<OrchestrationSession[]>;
-    registerAgent(agent: ClaudeCodeInstance): Promise<void>;
-    deregisterAgent(agentId: string): Promise<void>;
-    getAvailableAgents(criteria?: DiscoveryCriteria): Promise<ClaudeCodeInstance[]>;
-    getAgentHealth(agentId: string): Promise<HealthStatus>;
-    orchestrateTask(task: TaskSpecification, session: OrchestrationSession): Promise<OrchestrationResult>;
-    distributeTask(task: TaskSpecification, suggestedAgents: ClaudeCodeInstance[]): Promise<DistributionResult>;
-    monitorExecution(sessionId: string): AsyncIterable<ExecutionUpdate>;
-    pauseExecution(sessionId: string): Promise<void>;
-    resumeExecution(sessionId: string): Promise<void>;
-    cancelExecution(sessionId: string, reason: string): Promise<void>;
-    getSharedState(sessionId: string): Promise<SharedState>;
-    updateSharedState(sessionId: string, updates: StateUpdate[]): Promise<void>;
-    syncState(sessionId: string, targetAgents: string[]): Promise<SyncResult>;
-    discoverServices(criteria: DiscoveryCriteria): Promise<ServiceDefinition[]>;
-    watchServices(criteria: DiscoveryCriteria, callback: ServiceChangeCallback): Promise<string>;
-    private executeDistributedTasks;
-    private executeTaskAssignment;
-    private aggregateResults;
-    private updateSessionMetrics;
-    private generateRecommendations;
-    private cancelRunningTasks;
-    private cleanupSessionResources;
-    private isRetryableError;
-    private setupEventHandlers;
-    private startPeriodicMaintenance;
-    private cleanupExpiredSessions;
-    private performHealthChecks;
-    private collectMetrics;
-    private generateInstanceId;
-    private generateSessionId;
-    private sleep;
-    getInstanceId(): string;
-    getAgent(agentId: string): Promise<ClaudeCodeInstance | undefined>;
-}
-interface OrchestratorConfig {
-    instanceId?: string;
-    mode: 'internal' | 'external' | 'hybrid';
-    security: SecurityConfig;
-    discovery: DiscoveryConfig;
-    stateManagement: StateManagementConfig;
-    health: HealthConfig;
-    metrics: MetricsConfig;
-    monitoringInterval?: number;
-    maintenanceInterval?: number;
-    sessionTTL?: number;
-}
-interface SecurityConfig {
-    enableAuthentication: boolean;
-    enableEncryption: boolean;
-    trustedAgents: string[];
-    rateLimiting: {
-        enabled: boolean;
-        maxRequestsPerMinute: number;
-    };
-}
-interface DiscoveryConfig {
-    healthCheck: {
-        interval: number;
-        timeout: number;
-    };
-    announcement: {
-        enabled: boolean;
-        services: string[];
-    };
-    discoveryInterval: number;
-}
-interface StateManagementConfig {
-    storage: {
-        type: 'memory' | 'redis' | 'mongodb';
-        connectionString?: string;
-        options: Record<string, any>;
-    };
-    conflictResolution: {
-        defaultStrategy: 'last_write_wins' | 'vector_clock';
-        strategies: Record<string, any>;
-    };
-    eventBus: {
-        type: 'memory' | 'redis' | 'kafka';
-        connectionString?: string;
-        options: Record<string, any>;
-    };
-    consensus: {
-        algorithm: 'raft' | 'pbft';
-        quorumSize: number;
-        timeoutMs: number;
-    };
-    replication: {
-        factor: number;
-        consistency: 'sync' | 'async';
-        zones: string[];
-    };
-    syncInterval: number;
-}
-interface HealthConfig {
-    interval: number;
-    timeout: number;
-    retries: number;
-}
-interface MetricsConfig {
-    enabled: boolean;
-    interval: number;
-    exporters: string[];
-}
-declare class OrchestrationError extends Error {
-    constructor(message: string);
-}
-export { OrchestrationError };
-//# sourceMappingURL=distributed-orchestrator.d.ts.map