codecrucible-synth/dist/core/agents/agent-ecosystem.d.ts

Production-Ready AI Development Platform with Multi-Voice Synthesis, Smithery MCP Integration, Enterprise Security, and Zero-Timeout Reliability

/**
 * Agent Ecosystem for CodeCrucible Synth
 * Production-ready specialized agents based on the multi-voice synthesis architecture
 * Each agent represents a different perspective and expertise domain
 */
import { EventEmitter } from 'events';
import { WorkflowOrchestrator } from '../workflow/workflow-orchestrator.js';
import { AdvancedToolOrchestrator } from '../tools/advanced-tool-orchestrator.js';
import { VectorRAGSystem } from '../rag/vector-rag-system.js';
import { IntelligentModelRouter } from '../routing/intelligent-model-router.js';
export interface Agent {
    id: string;
    name: string;
    role: AgentRole;
    personality: AgentPersonality;
    capabilities: AgentCapability[];
    expertise: ExpertiseDomain[];
    status: AgentStatus;
    configuration: AgentConfiguration;
    initialize(): Promise<void>;
    process(request: AgentRequest): Promise<AgentResponse>;
    collaborate(agents: Agent[], task: CollaborativeTask): Promise<CollaborativeResponse>;
    learn(feedback: AgentFeedback): Promise<void>;
    shutdown(): Promise<void>;
}
export interface AgentRole {
    type: 'explorer' | 'analyzer' | 'implementor' | 'maintainer' | 'security' | 'optimizer' | 'tester' | 'architect' | 'reviewer';
    description: string;
    responsibilities: string[];
    authority: 'advisory' | 'decision-making' | 'implementation' | 'review';
    scope: 'local' | 'project' | 'system' | 'global';
}
export interface AgentPersonality {
    approach: 'methodical' | 'creative' | 'pragmatic' | 'perfectionist' | 'innovative' | 'conservative' | 'aggressive';
    communication: 'detailed' | 'concise' | 'technical' | 'narrative' | 'analytical';
    riskTolerance: 'low' | 'medium' | 'high';
    decisionStyle: 'quick' | 'deliberate' | 'collaborative' | 'independent';
    learningStyle: 'experiential' | 'theoretical' | 'collaborative' | 'observational';
}
export interface AgentCapability {
    name: string;
    level: 'novice' | 'intermediate' | 'expert' | 'master';
    description: string;
    tools: string[];
    prerequisites?: string[];
    learnable: boolean;
}
export interface ExpertiseDomain {
    area: string;
    level: number;
    technologies: string[];
    frameworks: string[];
    patterns: string[];
    experience: ExperienceMetric[];
}
export interface ExperienceMetric {
    task: string;
    successRate: number;
    avgQuality: number;
    timeSpent: number;
    complexity: number;
    lastPerformed: Date;
}
export interface AgentStatus {
    state: 'idle' | 'busy' | 'learning' | 'collaborating' | 'offline' | 'error';
    currentTask?: string;
    workload: number;
    availability: boolean;
    lastActivity: Date;
    health: AgentHealth;
}
export interface AgentHealth {
    performance: number;
    errorRate: number;
    responseTime: number;
    memoryUsage: number;
    issueCount: number;
    lastHealthCheck: Date;
}
export interface AgentConfiguration {
    modelPreferences: ModelPreference[];
    behaviorSettings: BehaviorSettings;
    collaborationSettings: CollaborationSettings;
    learningSettings: LearningSettings;
    resourceLimits: ResourceLimits;
}
export interface ModelPreference {
    providerId: string;
    modelId: string;
    priority: number;
    useCase: string[];
    configuration: Record<string, any>;
}
export interface BehaviorSettings {
    verbosity: 'minimal' | 'normal' | 'detailed' | 'verbose';
    responseStyle: 'direct' | 'explanatory' | 'tutorial' | 'conversational';
    errorHandling: 'strict' | 'permissive' | 'adaptive';
    optimizationLevel: 'speed' | 'quality' | 'balanced';
}
export interface CollaborationSettings {
    preferredTeamSize: number;
    leadershipStyle: 'democratic' | 'authoritative' | 'laissez-faire' | 'situational';
    communicationFrequency: 'minimal' | 'regular' | 'frequent' | 'continuous';
    conflictResolution: 'consensus' | 'voting' | 'authority' | 'escalation';
}
export interface LearningSettings {
    adaptationRate: number;
    feedbackSensitivity: number;
    explorationRate: number;
    memoryRetention: number;
    learningMethods: string[];
}
export interface ResourceLimits {
    maxMemoryUsage: number;
    maxProcessingTime: number;
    maxConcurrentTasks: number;
    maxToolsPerTask: number;
    costBudget: number;
}
export interface AgentRequest {
    id: string;
    type: 'analysis' | 'implementation' | 'review' | 'optimization' | 'testing' | 'documentation' | 'planning';
    content: string;
    context?: AgentContext;
    constraints?: AgentConstraints;
    priority: 'low' | 'medium' | 'high' | 'critical';
    deadline?: Date;
    requester: string;
}
export interface AgentContext {
    project?: ProjectContext;
    codebase?: CodebaseContext;
    session?: SessionContext;
    previous?: PreviousInteraction[];
    environment?: EnvironmentContext;
}
export interface ProjectContext {
    name: string;
    type: string;
    technologies: string[];
    architecture: string;
    conventions: Record<string, any>;
    constraints: string[];
}
export interface CodebaseContext {
    languages: string[];
    frameworks: string[];
    patterns: string[];
    size: number;
    complexity: number;
    quality: number;
    coverage: number;
}
export interface SessionContext {
    sessionId: string;
    duration: number;
    interactions: number;
    mood: 'positive' | 'neutral' | 'frustrated' | 'confused';
    goals: string[];
}
export interface PreviousInteraction {
    timestamp: Date;
    request: string;
    response: string;
    outcome: 'success' | 'partial' | 'failure';
    feedback?: string;
}
export interface EnvironmentContext {
    os: string;
    tools: string[];
    resources: ResourceAvailability;
    constraints: string[];
}
export interface ResourceAvailability {
    cpu: number;
    memory: number;
    disk: number;
    network: number;
}
export interface AgentConstraints {
    timeLimit?: number;
    memoryLimit?: number;
    costLimit?: number;
    qualityThreshold?: number;
    approvedTools?: string[];
    forbiddenActions?: string[];
}
export interface AgentResponse {
    id: string;
    requestId: string;
    agentId: string;
    content: string;
    confidence: number;
    reasoning: string;
    suggestions?: string[];
    alternatives?: string[];
    warnings?: string[];
    metadata: ResponseMetadata;
    actions?: AgentAction[];
    collaboration?: CollaborationRequest;
}
export interface ResponseMetadata {
    processingTime: number;
    tokensUsed: number;
    toolsUsed: string[];
    modelsUsed: string[];
    qualityScore: number;
    complexity: number;
    resources: ResourceUsage;
}
export interface ResourceUsage {
    cpu: number;
    memory: number;
    cost: number;
    apiCalls: number;
}
export interface AgentAction {
    type: 'file_create' | 'file_modify' | 'file_delete' | 'command_execute' | 'analysis_run' | 'test_run';
    target: string;
    parameters: Record<string, any>;
    confirmation?: boolean;
    reversible: boolean;
}
export interface CollaborationRequest {
    type: 'review' | 'assistance' | 'validation' | 'brainstorm' | 'implementation';
    targetAgents: string[];
    content: string;
    urgency: 'low' | 'medium' | 'high';
}
export interface CollaborativeTask {
    id: string;
    title: string;
    description: string;
    type: 'analysis' | 'implementation' | 'review' | 'architecture' | 'optimization';
    complexity: number;
    participants: string[];
    coordinator: string;
    phases: TaskPhase[];
    dependencies: string[];
    deadline?: Date;
}
export interface TaskPhase {
    id: string;
    name: string;
    description: string;
    assignedAgent: string;
    dependencies: string[];
    estimatedDuration: number;
    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
    deliverables: string[];
}
export interface CollaborativeResponse {
    taskId: string;
    phases: PhaseResult[];
    synthesis: CollaborativeSynthesis;
    consensus: ConsensusMeasure;
    finalRecommendation: string;
    metadata: CollaborativeMetadata;
}
export interface PhaseResult {
    phaseId: string;
    agentId: string;
    result: AgentResponse;
    quality: number;
    confidence: number;
    issues?: string[];
}
export interface CollaborativeSynthesis {
    approach: 'consensus' | 'best_of' | 'hybrid' | 'weighted_average';
    weights: Record<string, number>;
    conflicts: ConflictResolution[];
    finalOutput: string;
    confidenceScore: number;
}
export interface ConflictResolution {
    issue: string;
    positions: Array<{
        agent: string;
        position: string;
        reasoning: string;
    }>;
    resolution: string;
    method: 'voting' | 'authority' | 'compromise' | 'expert_decision';
}
export interface ConsensusMeasure {
    agreement: number;
    conflicts: number;
    convergence: number;
    stability: number;
}
export interface CollaborativeMetadata {
    totalTime: number;
    participationLevel: Record<string, number>;
    communicationRounds: number;
    decisionsReached: number;
    escalationsRequired: number;
}
export interface AgentFeedback {
    requestId: string;
    responseId: string;
    rating: number;
    qualityAspects: QualityFeedback;
    suggestions: string[];
    issues: string[];
    timestamp: Date;
    feedbackProvider: string;
}
export interface QualityFeedback {
    accuracy: number;
    completeness: number;
    clarity: number;
    relevance: number;
    efficiency: number;
}
export declare class AgentEcosystem extends EventEmitter {
    private logger;
    private agents;
    private toolOrchestrator;
    private ragSystem;
    private modelRouter;
    private collaborationManager;
    private learningEngine;
    private performanceMonitor;
    constructor(_workflowOrchestrator: WorkflowOrchestrator, toolOrchestrator: AdvancedToolOrchestrator, ragSystem: VectorRAGSystem, modelRouter: IntelligentModelRouter);
    /**
     * Initialize the agent ecosystem
     */
    initialize(): Promise<void>;
    /**
     * Process a request through the ecosystem
     */
    processRequest(request: AgentRequest): Promise<AgentResponse>;
    /**
     * Execute a collaborative task
     */
    executeCollaborativeTask(task: CollaborativeTask): Promise<CollaborativeResponse>;
    /**
     * Get agent by ID
     */
    getAgent(agentId: string): Agent | undefined;
    /**
     * Get all agents
     */
    getAllAgents(): Agent[];
    /**
     * Get agents by role
     */
    getAgentsByRole(role: string): Agent[];
    /**
     * Get available agents
     */
    getAvailableAgents(): Agent[];
    /**
     * Add custom agent
     */
    addAgent(agent: Agent): Promise<void>;
    /**
     * Remove agent
     */
    removeAgent(agentId: string): Promise<void>;
    /**
     * Get ecosystem statistics
     */
    getEcosystemStats(): EcosystemStats;
    /**
     * Shutdown the ecosystem
     */
    shutdown(): Promise<void>;
    /**
     * Private Methods
     */
    private createSpecializedAgents;
    private selectAgent;
    private handleCollaboration;
    private synthesizeCollaborativeResponse;
    private getAgentDistribution;
    private calculateAverageWorkload;
}
interface EcosystemStats {
    totalAgents: number;
    activeAgents: number;
    agentsByRole: Record<string, number>;
    averageWorkload: number;
    performanceMetrics: PerformanceMonitorStats;
    collaborationStats: CollaborationStats;
    learningProgress: LearningStats;
}
interface CollaborationStats {
    totalTasks: number;
    completedTasks: number;
    averageParticipants: number;
    averageDuration: number;
    successRate: number;
}
interface LearningStats {
    totalAgentsLearning: number;
    averageImprovement: number;
    feedbackVolume: number;
    learningVelocity: number;
}
interface PerformanceMonitorStats {
    averageResponseTime: number;
    averageQuality: number;
    totalRequests: number;
    systemHealth: number;
}
export {};
//# sourceMappingURL=agent-ecosystem.d.ts.map