import { Agent } from '../services/agent';
import { Message } from './agent';
import { ProjectContext } from './index';
export interface SMEAgentDefinition {
    id: string;
    name: string;
    role: string;
    expertise: string[];
    capabilities: string[];
    description: string;
    maxConcurrency: number;
    priority: number;
    dependencies?: string[];
    conflictsWith?: string[];
    complianceStandards?: string[];
    requirements?: any[];
    resourceRequirements: {
        memory: 'low' | 'medium' | 'high';
        compute: 'low' | 'medium' | 'high';
        network: boolean;
    };
}
export interface TaskDefinition {
    id: string;
    type: string;
    description: string;
    priority: 'low' | 'medium' | 'high' | 'urgent';
    complexity: 'simple' | 'moderate' | 'complex' | 'expert';
    estimatedDuration: number;
    dependencies?: string[];
    requiredExpertise: string[];
    context?: Record<string, any>;
    deadline?: Date;
    parallel: boolean;
}
export interface AgentTask {
    id: string;
    taskId: string;
    agentId: string;
    assignedAgent?: string;
    type?: string;
    description?: string;
    completedAt?: Date;
    status: 'pending' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
    startTime?: Date;
    endTime?: Date;
    createdAt: Date;
    progress: number;
    result?: any;
    error?: Error | string;
    logs: TaskLog[];
    dependencies: string[];
    assignedAt: Date;
}
export interface TaskLog {
    timestamp: Date;
    level: 'debug' | 'info' | 'warn' | 'error';
    message: string;
    agentId: string;
    taskId: string;
    metadata?: Record<string, any>;
}
export interface AgentInstance {
    id: string;
    definition: SMEAgentDefinition;
    agent: Agent<any, any>;
    status: 'idle' | 'busy' | 'error' | 'shutdown';
    currentTask?: string;
    taskHistory: string[];
    lastUsed?: Date;
    isActive: boolean;
    cleanup: () => Promise<void>;
    performance: {
        tasksCompleted: number;
        successRate: number;
        averageCompletionTime: number;
        lastActive: Date;
    };
    health: {
        uptime: number;
        memoryUsage: number;
        errorCount: number;
        lastHealthCheck: Date;
    };
}
export interface CommunicationMessage {
    id: string;
    fromAgent: string;
    toAgent: string | 'broadcast' | 'orchestrator';
    type: 'request' | 'response' | 'notification' | 'coordination' | 'handoff';
    content: any;
    timestamp: Date;
    priority: 'low' | 'medium' | 'high';
    requiresResponse: boolean;
    parentMessageId?: string;
    metadata?: Record<string, any>;
}
export interface WorkflowDefinition {
    id: string;
    name: string;
    description: string;
    stages: WorkflowStage[];
    parallelExecution: boolean;
    errorHandling: 'stop' | 'continue' | 'retry';
    timeout: number;
}
export interface WorkflowStage {
    id: string;
    name: string;
    agentType: string;
    tasks: string[];
    dependencies?: string[];
    parallel: boolean;
    optional: boolean;
    retryCount: number;
    timeout: number;
}
export interface OrchestratorContext {
    projectContext?: ProjectContext;
    userSession: {
        id: string;
        startTime: Date;
        preferences: UserPreferences;
        history: Message[];
    };
    systemState: {
        activeAgents: number;
        activeTasks: number;
        systemLoad: number;
        availableResources: ResourcePool;
    };
    coordination: {
        taskQueue: TaskDefinition[];
        completedTasks: AgentTask[];
        blockedTasks: AgentTask[];
        agentAssignments: Map<string, string[]>;
    };
}
export interface UserPreferences {
    verbosity: 'minimal' | 'normal' | 'detailed' | 'debug';
    concurrency: number;
    timeout: number;
    autoApprove: boolean;
    preferredAgents?: string[];
    expertise: 'beginner' | 'intermediate' | 'expert';
}
export interface ResourcePool {
    maxConcurrentAgents: number;
    maxConcurrentTasks: number;
    memoryLimit: number;
    networkBandwidth: number;
    computeCapacity: number;
}
export interface TaskResult {
    taskId: string;
    agentId: string;
    success: boolean;
    result?: any;
    error?: Error;
    duration: number;
    resourcesUsed: {
        memory: number;
        compute: number;
        network: number;
    };
    quality: {
        score: number;
        metrics: Record<string, number>;
        feedback?: string;
    };
}
export interface CoordinationEvent {
    type: 'task_assigned' | 'task_completed' | 'task_failed' | 'agent_error' | 'resource_conflict' | 'dependency_resolved';
    timestamp: Date;
    agentId?: string;
    taskId?: string;
    details: Record<string, any>;
    severity: 'info' | 'warning' | 'error' | 'critical';
}
export interface AgentCapability {
    name: string;
    version: string;
    description: string;
    inputSchema: Record<string, any>;
    outputSchema: Record<string, any>;
    quality: number;
    reliability: number;
    performance: number;
}
export interface DelegationStrategy {
    name: string;
    algorithm: 'round_robin' | 'least_busy' | 'expertise_match' | 'performance_based' | 'random';
    parameters: Record<string, any>;
    fallbackStrategy?: string;
}
export interface ConflictResolution {
    type: 'resource' | 'dependency' | 'priority' | 'capability';
    strategy: 'queue' | 'preempt' | 'split' | 'merge' | 'escalate';
    parameters: Record<string, any>;
}
export interface DynamicAgentCreationRequest {
    requiredExpertise: string[];
    taskDescription: string;
    urgency: 'low' | 'medium' | 'high' | 'critical';
    estimatedDuration: number;
    resourceRequirements: {
        memory: 'low' | 'medium' | 'high';
        compute: 'low' | 'medium' | 'high';
        network: boolean;
    };
    complianceRequirements: string[];
    collaborationNeeds?: string[];
}
export interface DynamicAgentTemplate {
    id: string;
    name: string;
    role: string;
    expertise: string[];
    capabilities: string[];
    description: string;
    instructions: string;
    tools?: Array<{
        name: string;
        description: string;
        parameters: Record<string, any>;
    }>;
    maxConcurrency: number;
    priority: number;
    complianceStandards: string[];
    resourceRequirements: {
        memory: 'low' | 'medium' | 'high';
        compute: 'low' | 'medium' | 'high';
        network: boolean;
    };
    createdAt: Date;
    lastUsed?: Date;
    createdBy: 'system' | 'user' | 'orchestrator';
    parentAgents?: string[];
    version: string;
}
export type OrchestratorEvent = {
    type: 'agent_registered';
    agent: SMEAgentDefinition;
} | {
    type: 'agent_unregistered';
    agentId: string;
} | {
    type: 'dynamic_agent_created';
    agent: DynamicAgentTemplate;
} | {
    type: 'dynamic_agent_cached';
    agentId: string;
} | {
    type: 'task_created';
    task: TaskDefinition;
} | {
    type: 'task_assigned';
    task: AgentTask;
} | {
    type: 'task_started';
    taskId: string;
    agentId: string;
} | {
    type: 'task_progress';
    taskId: string;
    progress: number;
} | {
    type: 'task_completed';
    result: TaskResult;
} | {
    type: 'task_failed';
    taskId: string;
    error: Error;
} | {
    type: 'coordination_required';
    agents: string[];
    reason: string;
} | {
    type: 'conflict_detected';
    conflictType: string;
    parties: string[];
} | {
    type: 'workflow_started';
    workflowId: string;
} | {
    type: 'workflow_completed';
    workflowId: string;
    results: TaskResult[];
} | {
    type: 'system_overload';
    metrics: Record<string, number>;
} | {
    type: 'agent_communication';
    message: CommunicationMessage;
};
export interface OrchestratorMetrics {
    totalTasks: number;
    completedTasks: number;
    failedTasks: number;
    averageTaskDuration: number;
    agentUtilization: Record<string, number>;
    systemThroughput: number;
    errorRate: number;
    resourceEfficiency: number;
    userSatisfaction: number;
    responseTime: number;
}
export interface UserRequest {
    id: string;
    type: string;
    content: string;
    context: Record<string, any>;
    timestamp: Date;
    priority: 'low' | 'medium' | 'high';
    userId?: string;
}
export interface OrchestratorResponse {
    requestId: string;
    result: any;
    agents: string[];
    executionTime: number;
    success: boolean;
    errors?: string[];
    metadata?: Record<string, any>;
}
export interface ExecutionPlan {
    id: string;
    tasks: ExecutionTask[];
    phases: ExecutionPhase[];
    dependencies: TaskDependency[];
    estimatedDuration: number;
    priority: 'low' | 'medium' | 'high';
    resources: string[];
}
export interface ExecutionPhase {
    id: string;
    name: string;
    description: string;
    tasks: string[];
    dependencies: string[];
    estimatedDuration: number;
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
    parallel: boolean;
}
export interface ExecutionTask {
    id: string;
    name: string;
    description: string;
    agent: string;
    estimatedDuration: number;
    status: 'pending' | 'in_progress' | 'completed' | 'failed';
    dependencies: string[];
}
export interface TaskDependency {
    taskId: string;
    dependsOn: string;
    type: 'hard' | 'soft';
}
//# sourceMappingURL=orchestrator.d.ts.map