@bluefly/openstandardagents 0.1.9 → 0.2.5-RC

package/src/core/orchestrator/index.ts

@@ -1,611 +0,0 @@
-/**
- * OSSA Core Orchestrator - Production Platform
- * Enterprise-grade agent coordination with 360° feedback loop
- * Plan → Execute → Review → Judge → Learn → Govern
- */
-
-import { EventEmitter } from 'events';
-import { 
-  Agent, 
-  Workflow, 
-  Task, 
-  OrchestratorConfig,
-  AgentType,
-  TaskStatus,
-  AgentStatus,
-  MessageType
-} from '../../types/index.js';
-import { v4 as uuidv4 } from 'uuid';
-
-export interface FeedbackLoopPhase {
-  name: 'plan' | 'execute' | 'review' | 'judge' | 'learn' | 'govern';
-  agents: string[];
-  status: 'pending' | 'active' | 'completed' | 'failed';
-  startTime?: Date;
-  endTime?: Date;
-  budget: {
-    tokens: number;
-    used: number;
-  };
-  output?: any;
-}
-
-export interface WorkflowExecution {
-  id: string;
-  workflowId: string;
-  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-  phases: FeedbackLoopPhase[];
-  currentPhase: number;
-  budget: {
-    totalTokens: number;
-    usedTokens: number;
-    timeLimit: number; // in seconds
-  };
-  startTime: Date;
-  endTime?: Date;
-  metrics: {
-    agentsUsed: number;
-    tasksCompleted: number;
-    errors: number;
-    performance: any;
-  };
-}
-
-export interface AgentAllocation {
-  agentId: string;
-  agentType: AgentType;
-  allocatedTo: string; // workflow execution ID
-  phase: string;
-  resourceQuota: {
-    tokens: number;
-    timeout: number;
-  };
-  performance: {
-    tasksCompleted: number;
-    avgResponseTime: number;
-    errorRate: number;
-  };
-}
-
-export class OrchestratorPlatform extends EventEmitter {
-  private agents: Map<string, Agent> = new Map();
-  private workflows: Map<string, Workflow> = new Map();
-  private executions: Map<string, WorkflowExecution> = new Map();
-  private allocations: Map<string, AgentAllocation> = new Map();
-  private taskQueue: Task[] = [];
-  private config: OrchestratorConfig;
-  private healthMetrics: {
-    totalWorkflows: number;
-    activeExecutions: number;
-    avgExecutionTime: number;
-    resourceUtilization: number;
-    errorRate: number;
-  };
-
-  constructor(config: OrchestratorConfig) {
-    super();
-    this.config = config;
-    this.healthMetrics = {
-      totalWorkflows: 0,
-      activeExecutions: 0,
-      avgExecutionTime: 0,
-      resourceUtilization: 0,
-      errorRate: 0
-    };
-    this.initialize();
-  }
-
-  private async initialize(): Promise<void> {
-    console.log('[ORCHESTRATOR-PLATFORM] Initializing production orchestration engine...');
-    await this.loadAgents();
-    await this.setupMessageBus();
-    await this.startScheduler();
-    await this.initializeHealthMonitoring();
-    this.emit('orchestrator:ready');
-    console.log('[ORCHESTRATOR-PLATFORM] Production orchestration engine ready');
-  }
-
-  /**
-   * Register agent with production capabilities validation
-   */
-  async registerAgent(agent: Agent): Promise<void> {
-    // Validate agent capabilities for production
-    if (!this.validateAgentForProduction(agent)) {
-      throw new Error(`Agent ${agent.id} does not meet production requirements`);
-    }
-
-    this.agents.set(agent.id, agent);
-    this.emit('agent:registered', { 
-      agentId: agent.id, 
-      type: agent.type,
-      capabilities: agent.capabilities.length,
-      timestamp: new Date()
-    });
-    
-    console.log(`[ORCHESTRATOR-PLATFORM] Agent registered: ${agent.id} (${agent.type})`);
-  }
-
-  /**
-   * Execute workflow with 360° feedback loop coordination
-   */
-  async executeWorkflow(workflow: Workflow, budget?: {
-    tokens: number;
-    timeLimit: number;
-  }): Promise<string> {
-    const executionId = uuidv4();
-    const defaultBudget = {
-      tokens: budget?.tokens || 50000,
-      timeLimit: budget?.timeLimit || 3600
-    };
-
-    const execution: WorkflowExecution = {
-      id: executionId,
-      workflowId: workflow.id,
-      status: 'pending',
-      phases: this.initializeFeedbackLoopPhases(workflow),
-      currentPhase: 0,
-      budget: {
-        totalTokens: defaultBudget.tokens,
-        usedTokens: 0,
-        timeLimit: defaultBudget.timeLimit
-      },
-      startTime: new Date(),
-      metrics: {
-        agentsUsed: 0,
-        tasksCompleted: 0,
-        errors: 0,
-        performance: {}
-      }
-    };
-
-    this.executions.set(executionId, execution);
-    this.workflows.set(workflow.id, workflow);
-    this.healthMetrics.totalWorkflows++;
-    this.healthMetrics.activeExecutions++;
-
-    console.log(`[ORCHESTRATOR-PLATFORM] Starting workflow execution: ${executionId}`);
-    this.emit('workflow:started', { executionId, workflowId: workflow.id });
-
-    // Start execution in background
-    this.executeFeedbackLoop(executionId).catch(error => {
-      console.error(`[ORCHESTRATOR-PLATFORM] Workflow execution failed: ${executionId}`, error);
-      this.handleExecutionError(executionId, error);
-    });
-
-    return executionId;
-  }
-
-  /**
-   * Allocate agents to workflow execution with resource management
-   */
-  async allocateAgents(executionId: string, requirements: {
-    agentType: AgentType;
-    count: number;
-    capabilities: string[];
-    phase: string;
-  }): Promise<string[]> {
-    const execution = this.executions.get(executionId);
-    if (!execution) {
-      throw new Error(`Execution ${executionId} not found`);
-    }
-
-    const availableAgents = Array.from(this.agents.values())
-      .filter(agent => 
-        agent.type === requirements.agentType &&
-        agent.status === AgentStatus.IDLE &&
-        this.hasRequiredCapabilities(agent, requirements.capabilities)
-      )
-      .slice(0, requirements.count);
-
-    if (availableAgents.length < requirements.count) {
-      console.warn(`[ORCHESTRATOR-PLATFORM] Insufficient agents available. Required: ${requirements.count}, Available: ${availableAgents.length}`);
-    }
-
-    const allocatedAgentIds: string[] = [];
-    const tokensPerAgent = Math.floor(
-      (execution.budget.totalTokens - execution.budget.usedTokens) / 
-      (requirements.count || 1)
-    );
-
-    for (const agent of availableAgents) {
-      const allocation: AgentAllocation = {
-        agentId: agent.id,
-        agentType: agent.type,
-        allocatedTo: executionId,
-        phase: requirements.phase,
-        resourceQuota: {
-          tokens: tokensPerAgent,
-          timeout: 300000 // 5 minutes default
-        },
-        performance: {
-          tasksCompleted: 0,
-          avgResponseTime: 0,
-          errorRate: 0
-        }
-      };
-
-      this.allocations.set(`${agent.id}-${executionId}`, allocation);
-      allocatedAgentIds.push(agent.id);
-      
-      // Update agent status
-      agent.status = AgentStatus.BUSY;
-    }
-
-    execution.metrics.agentsUsed += allocatedAgentIds.length;
-    
-    console.log(`[ORCHESTRATOR-PLATFORM] Allocated ${allocatedAgentIds.length} agents to execution ${executionId}`);
-    this.emit('agents:allocated', { 
-      executionId, 
-      agentIds: allocatedAgentIds, 
-      phase: requirements.phase 
-    });
-
-    return allocatedAgentIds;
-  }
-
-  /**
-   * Execute 360° feedback loop: Plan → Execute → Review → Judge → Learn → Govern
-   */
-  private async executeFeedbackLoop(executionId: string): Promise<void> {
-    const execution = this.executions.get(executionId);
-    if (!execution) {
-      throw new Error(`Execution ${executionId} not found`);
-    }
-
-    execution.status = 'running';
-    
-    try {
-      for (let i = 0; i < execution.phases.length; i++) {
-        const phase = execution.phases[i];
-        execution.currentPhase = i;
-        
-        console.log(`[ORCHESTRATOR-PLATFORM] Executing phase: ${phase.name} for execution ${executionId}`);
-        
-        await this.executePhase(executionId, phase);
-        
-        // Check budget constraints
-        if (execution.budget.usedTokens >= execution.budget.totalTokens) {
-          console.warn(`[ORCHESTRATOR-PLATFORM] Token budget exceeded for execution ${executionId}`);
-          throw new Error('Token budget exceeded');
-        }
-        
-        // Check time constraints
-        const elapsed = Date.now() - execution.startTime.getTime();
-        if (elapsed > execution.budget.timeLimit * 1000) {
-          console.warn(`[ORCHESTRATOR-PLATFORM] Time limit exceeded for execution ${executionId}`);
-          throw new Error('Time limit exceeded');
-        }
-      }
-      
-      execution.status = 'completed';
-      execution.endTime = new Date();
-      this.healthMetrics.activeExecutions--;
-      
-      console.log(`[ORCHESTRATOR-PLATFORM] Workflow execution completed: ${executionId}`);
-      this.emit('workflow:completed', { executionId });
-      
-    } catch (error) {
-      execution.status = 'failed';
-      execution.endTime = new Date();
-      this.healthMetrics.activeExecutions--;
-      this.healthMetrics.errorRate++;
-      
-      console.error(`[ORCHESTRATOR-PLATFORM] Workflow execution failed: ${executionId}`, error);
-      this.emit('workflow:failed', { executionId, error });
-      throw error;
-    } finally {
-      await this.cleanupExecution(executionId);
-    }
-  }
-
-  /**
-   * Execute individual phase with agent coordination
-   */
-  private async executePhase(executionId: string, phase: FeedbackLoopPhase): Promise<void> {
-    phase.status = 'active';
-    phase.startTime = new Date();
-    
-    const agentRequirements = this.getPhaseAgentRequirements(phase.name);
-    const allocatedAgents = await this.allocateAgents(executionId, agentRequirements);
-    
-    phase.agents = allocatedAgents;
-    
-    // Coordinate agents for this phase
-    const phaseResults = await this.coordinatePhaseExecution(executionId, phase, allocatedAgents);
-    
-    phase.output = phaseResults;
-    phase.status = 'completed';
-    phase.endTime = new Date();
-    
-    console.log(`[ORCHESTRATOR-PLATFORM] Phase ${phase.name} completed for execution ${executionId}`);
-  }
-
-  /**
-   * Get agent requirements for each feedback loop phase
-   */
-  private getPhaseAgentRequirements(phaseName: string): {
-    agentType: AgentType;
-    count: number;
-    capabilities: string[];
-    phase: string;
-  } {
-    const phaseMap = {
-      plan: { agentType: AgentType.ORCHESTRATOR, count: 1, capabilities: ['planning', 'coordination'] },
-      execute: { agentType: AgentType.WORKER, count: 3, capabilities: ['implementation', 'processing'] },
-      review: { agentType: AgentType.CRITIC, count: 2, capabilities: ['analysis', 'validation'] },
-      judge: { agentType: AgentType.JUDGE, count: 1, capabilities: ['evaluation', 'decision'] },
-      learn: { agentType: AgentType.TRAINER, count: 1, capabilities: ['learning', 'optimization'] },
-      govern: { agentType: AgentType.GOVERNOR, count: 1, capabilities: ['governance', 'compliance'] }
-    };
-    
-    const requirements = phaseMap[phaseName as keyof typeof phaseMap];
-    return { ...requirements, phase: phaseName };
-  }
-
-  /**
-   * Coordinate agent execution within a phase
-   */
-  private async coordinatePhaseExecution(
-    executionId: string, 
-    phase: FeedbackLoopPhase, 
-    agentIds: string[]
-  ): Promise<any> {
-    console.log(`[ORCHESTRATOR-PLATFORM] Coordinating ${agentIds.length} agents for phase ${phase.name}`);
-    
-    const results: any[] = [];
-    const execution = this.executions.get(executionId)!;
-    
-    // Execute agents in parallel for most phases, sequentially for governance
-    if (phase.name === 'govern' || phase.name === 'judge') {
-      // Sequential execution for governance and judgment
-      for (const agentId of agentIds) {
-        const result = await this.executeAgentTask(executionId, agentId, phase);
-        results.push(result);
-      }
-    } else {
-      // Parallel execution for other phases
-      const promises = agentIds.map(agentId => 
-        this.executeAgentTask(executionId, agentId, phase)
-      );
-      const parallelResults = await Promise.allSettled(promises);
-      
-      parallelResults.forEach((result, index) => {
-        if (result.status === 'fulfilled') {
-          results.push(result.value);
-        } else {
-          console.error(`[ORCHESTRATOR-PLATFORM] Agent ${agentIds[index]} failed in phase ${phase.name}:`, result.reason);
-          execution.metrics.errors++;
-        }
-      });
-    }
-    
-    return {
-      phase: phase.name,
-      agentResults: results,
-      summary: this.summarizePhaseResults(phase.name, results)
-    };
-  }
-
-  /**
-   * Execute task for specific agent
-   */
-  private async executeAgentTask(executionId: string, agentId: string, phase: FeedbackLoopPhase): Promise<any> {
-    const agent = this.agents.get(agentId);
-    if (!agent) {
-      throw new Error(`Agent ${agentId} not found`);
-    }
-    
-    const allocation = this.allocations.get(`${agentId}-${executionId}`);
-    if (!allocation) {
-      throw new Error(`No allocation found for agent ${agentId} in execution ${executionId}`);
-    }
-    
-    const startTime = Date.now();
-    
-    try {
-      // Simulate agent task execution
-      // In production, this would call the actual agent via its protocol
-      const mockResult = {
-        agentId,
-        phase: phase.name,
-        status: 'completed',
-        tokensUsed: Math.floor(Math.random() * allocation.resourceQuota.tokens * 0.5),
-        output: `${phase.name} result from ${agentId}`
-      };
-      
-      const endTime = Date.now();
-      const duration = endTime - startTime;
-      
-      // Update metrics
-      const execution = this.executions.get(executionId)!;
-      execution.budget.usedTokens += mockResult.tokensUsed;
-      execution.metrics.tasksCompleted++;
-      
-      allocation.performance.tasksCompleted++;
-      allocation.performance.avgResponseTime = 
-        (allocation.performance.avgResponseTime + duration) / allocation.performance.tasksCompleted;
-      
-      console.log(`[ORCHESTRATOR-PLATFORM] Agent ${agentId} completed task in phase ${phase.name} (${duration}ms, ${mockResult.tokensUsed} tokens)`);
-      
-      return mockResult;
-      
-    } catch (error) {
-      allocation.performance.errorRate++;
-      throw error;
-    }
-  }
-
-  /**
-   * Summarize results from a phase
-   */
-  private summarizePhaseResults(phaseName: string, results: any[]): any {
-    return {
-      totalAgents: results.length,
-      successfulTasks: results.filter(r => r.status === 'completed').length,
-      totalTokensUsed: results.reduce((sum, r) => sum + (r.tokensUsed || 0), 0),
-      insights: `Phase ${phaseName} completed with ${results.length} agent contributions`
-    };
-  }
-
-  /**
-   * Initialize feedback loop phases for workflow
-   */
-  private initializeFeedbackLoopPhases(workflow: Workflow): FeedbackLoopPhase[] {
-    const phases: FeedbackLoopPhase[] = [
-      'plan', 'execute', 'review', 'judge', 'learn', 'govern'
-    ].map(name => ({
-      name: name as any,
-      agents: [],
-      status: 'pending',
-      budget: {
-        tokens: Math.floor(8000), // ~1/6 of total budget per phase
-        used: 0
-      }
-    }));
-    
-    return phases;
-  }
-
-  /**
-   * Validate agent meets production requirements
-   */
-  private validateAgentForProduction(agent: Agent): boolean {
-    // Production validation criteria
-    return (
-      agent.capabilities.length > 0 &&
-      agent.version !== undefined &&
-      agent.type !== undefined &&
-      agent.config !== undefined
-    );
-  }
-
-  /**
-   * Check if agent has required capabilities
-   */
-  private hasRequiredCapabilities(agent: Agent, requiredCapabilities: string[]): boolean {
-    const agentCapabilityNames = agent.capabilities.map(cap => cap.name);
-    return requiredCapabilities.every(required => 
-      agentCapabilityNames.includes(required)
-    );
-  }
-
-  /**
-   * Handle execution errors with recovery strategies
-   */
-  private handleExecutionError(executionId: string, error: any): void {
-    const execution = this.executions.get(executionId);
-    if (execution) {
-      execution.status = 'failed';
-      execution.endTime = new Date();
-      this.healthMetrics.activeExecutions--;
-      this.healthMetrics.errorRate++;
-    }
-    
-    console.error(`[ORCHESTRATOR-PLATFORM] Execution ${executionId} failed:`, error);
-    this.emit('execution:error', { executionId, error });
-  }
-
-  /**
-   * Cleanup resources after execution
-   */
-  private async cleanupExecution(executionId: string): Promise<void> {
-    // Release allocated agents
-    const allocationsToRemove: string[] = [];
-    
-    for (const [key, allocation] of this.allocations.entries()) {
-      if (allocation.allocatedTo === executionId) {
-        const agent = this.agents.get(allocation.agentId);
-        if (agent) {
-          agent.status = AgentStatus.IDLE;
-        }
-        allocationsToRemove.push(key);
-      }
-    }
-    
-    allocationsToRemove.forEach(key => this.allocations.delete(key));
-    
-    console.log(`[ORCHESTRATOR-PLATFORM] Cleaned up execution ${executionId}`);
-  }
-
-  /**
-   * Initialize health monitoring
-   */
-  private async initializeHealthMonitoring(): Promise<void> {
-    setInterval(() => {
-      this.updateHealthMetrics();
-      this.emit('health:update', this.getHealthStatus());
-    }, 30000); // Update every 30 seconds
-  }
-
-  /**
-   * Update health metrics
-   */
-  private updateHealthMetrics(): void {
-    const activeAgents = Array.from(this.agents.values())
-      .filter(agent => agent.status !== AgentStatus.OFFLINE).length;
-      
-    this.healthMetrics.resourceUtilization = 
-      activeAgents > 0 ? (this.healthMetrics.activeExecutions / activeAgents) * 100 : 0;
-  }
-
-  /**
-   * Get current health status
-   */
-  public getHealthStatus(): any {
-    return {
-      status: this.healthMetrics.activeExecutions > 0 ? 'active' : 'idle',
-      metrics: { ...this.healthMetrics },
-      agents: {
-        total: this.agents.size,
-        active: Array.from(this.agents.values())
-          .filter(agent => agent.status === AgentStatus.BUSY).length,
-        idle: Array.from(this.agents.values())
-          .filter(agent => agent.status === AgentStatus.IDLE).length
-      },
-      executions: {
-        active: this.healthMetrics.activeExecutions,
-        total: this.healthMetrics.totalWorkflows
-      },
-      timestamp: new Date()
-    };
-  }
-
-  /**
-   * Get execution status
-   */
-  public getExecutionStatus(executionId: string): WorkflowExecution | null {
-    return this.executions.get(executionId) || null;
-  }
-
-  /**
-   * List all active executions
-   */
-  public getActiveExecutions(): WorkflowExecution[] {
-    return Array.from(this.executions.values())
-      .filter(execution => execution.status === 'running');
-  }
-
-  private async scheduleWorkflowTasks(workflow: Workflow): Promise<void> {
-    // Legacy method - now handled by executeWorkflow
-    console.log('[ORCHESTRATOR-PLATFORM] scheduleWorkflowTasks deprecated - use executeWorkflow');
-  }
-
-  private async loadAgents(): Promise<void> {
-    console.log('[ORCHESTRATOR-PLATFORM] Loading agent registry...');
-    // In production, this would load from persistent storage
-  }
-
-  private async setupMessageBus(): Promise<void> {
-    console.log('[ORCHESTRATOR-PLATFORM] Setting up message bus...');
-    // Production message bus initialization
-  }
-
-  private async startScheduler(): Promise<void> {
-    console.log('[ORCHESTRATOR-PLATFORM] Starting task scheduler...');
-    // Production scheduler initialization
-  }
-}
-
-// Maintain backward compatibility
-export const Orchestrator = OrchestratorPlatform;
-export default OrchestratorPlatform;