codecrucible-synth/dist/core/agents/agent-communication-protocol.d.ts

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

/**
 * Agent Communication Protocol - Semantic Kernel & AutoGen Inspired
 * Implements modern agent-to-agent communication patterns for CodeCrucible Synth
 *
 * Features:
 * - Agent lifecycle management and discovery
 * - Message passing and subscription patterns
 * - Orchestration strategies (Sequential, Parallel, Democratic, Hierarchical)
 * - Event-driven communication with telemetry integration
 * - Agent conversation management and memory
 * - Capability negotiation and task delegation
 * - Multi-agent coordination and consensus building
 */
import { EventEmitter } from 'events';
export interface Agent {
    id: string;
    name: string;
    type: string;
    capabilities: AgentCapability[];
    metadata: AgentMetadata;
    status: AgentStatus;
    invoke(messages: Message[]): Promise<AgentResponse>;
    canHandle(task: AgentTask): boolean;
    subscribe(eventType: string, handler: MessageHandler): void;
    unsubscribe(eventType: string, handler: MessageHandler): void;
    publishMessage(targetAgentId: string, message: Message): Promise<void>;
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
}
export interface AgentCapability {
    name: string;
    type: 'analysis' | 'generation' | 'execution' | 'validation' | 'coordination';
    confidence: number;
    prerequisites?: string[];
    exclusiveWith?: string[];
}
export interface AgentMetadata {
    version: string;
    description: string;
    expertise: string[];
    languages: string[];
    maxConcurrentTasks: number;
    averageResponseTime: number;
    successRate: number;
    lastActive: Date;
}
export type AgentStatus = 'initializing' | 'active' | 'busy' | 'idle' | 'error' | 'shutdown';
export interface Message {
    id: string;
    type: MessageType;
    sender: string;
    recipient: string;
    content: any;
    metadata: MessageMetadata;
    timestamp: Date;
    correlationId?: string;
    conversationId?: string;
}
export type MessageType = 'task-request' | 'task-response' | 'task-delegation' | 'capability-inquiry' | 'capability-response' | 'coordination-request' | 'consensus-vote' | 'status-update' | 'error-notification' | 'system-event';
export interface MessageMetadata {
    priority: 'low' | 'medium' | 'high' | 'critical';
    timeout?: number;
    expectsResponse: boolean;
    maxRetries?: number;
    securityContext?: string;
}
export interface AgentResponse {
    success: boolean;
    content: any;
    metadata: ResponseMetadata;
    followUpActions?: FollowUpAction[];
}
export interface ResponseMetadata {
    processingTime: number;
    confidence: number;
    usedCapabilities: string[];
    resourceUsage: ResourceUsage;
    quality: number;
}
export interface ResourceUsage {
    memory: number;
    cpu: number;
    network: number;
    tokens?: number;
}
export interface FollowUpAction {
    type: 'delegate' | 'coordinate' | 'validate' | 'escalate';
    targetAgent?: string;
    task: AgentTask;
    priority: number;
}
export interface AgentTask {
    id: string;
    type: TaskType;
    description: string;
    requirements: TaskRequirement[];
    constraints: TaskConstraint[];
    expectedOutput: string;
    deadline?: Date;
    priority: number;
}
export type TaskType = 'code-analysis' | 'code-generation' | 'security-audit' | 'performance-optimization' | 'testing' | 'documentation' | 'coordination' | 'validation';
export interface TaskRequirement {
    type: 'capability' | 'resource' | 'data' | 'permission';
    value: string;
    mandatory: boolean;
}
export interface TaskConstraint {
    type: 'time' | 'memory' | 'security' | 'quality';
    value: any;
    enforced: boolean;
}
export type MessageHandler = (message: Message) => Promise<void>;
export interface OrchestrationStrategy {
    name: string;
    type: 'sequential' | 'parallel' | 'democratic' | 'hierarchical' | 'consensus';
    orchestrate(agents: Agent[], task: AgentTask): Promise<OrchestrationResult>;
}
export interface OrchestrationResult {
    success: boolean;
    results: AgentResponse[];
    consensus?: ConsensusResult;
    executionPlan: ExecutionStep[];
    totalTime: number;
    errors: string[];
}
export interface ConsensusResult {
    agreement: boolean;
    confidence: number;
    dissenting: string[];
    finalDecision: any;
    votingResults: VoteResult[];
}
export interface VoteResult {
    agentId: string;
    vote: 'yes' | 'no' | 'abstain';
    confidence: number;
    reasoning?: string;
}
export interface ExecutionStep {
    step: number;
    agentId: string;
    task: AgentTask;
    startTime: Date;
    endTime?: Date;
    result?: AgentResponse;
}
export interface IAgentRegistry {
    registerAgent(agent: Agent): Promise<void>;
    unregisterAgent(agentId: string): Promise<void>;
    findAgents(criteria: AgentSearchCriteria): Promise<Agent[]>;
    getAgent(agentId: string): Promise<Agent | null>;
    discoverCapabilities(taskType: TaskType): Promise<AgentCapability[]>;
    getAllAgents(): Promise<Agent[]>;
}
export interface AgentSearchCriteria {
    type?: string;
    capabilities?: string[];
    status?: AgentStatus;
    minConfidence?: number;
    maxResponseTime?: number;
    tags?: string[];
}
export interface ConversationManager {
    startConversation(participants: string[], topic: string): Promise<string>;
    addMessage(conversationId: string, message: Message): Promise<void>;
    getConversationHistory(conversationId: string): Promise<Message[]>;
    endConversation(conversationId: string): Promise<void>;
    summarizeConversation(conversationId: string): Promise<ConversationSummary>;
    extractKeyDecisions(conversationId: string): Promise<Decision[]>;
    findSimilarConversations(topic: string): Promise<ConversationMatch[]>;
}
export interface ConversationSummary {
    id: string;
    topic: string;
    participants: string[];
    duration: number;
    keyPoints: string[];
    decisions: Decision[];
    actionItems: ActionItem[];
    sentiment: 'positive' | 'negative' | 'neutral';
}
export interface Decision {
    id: string;
    description: string;
    participants: string[];
    consensus: boolean;
    timestamp: Date;
    rationale: string;
}
export interface ActionItem {
    id: string;
    description: string;
    assignee: string;
    deadline?: Date;
    status: 'pending' | 'in-progress' | 'completed' | 'cancelled';
}
export interface ConversationMatch {
    conversationId: string;
    similarity: number;
    topic: string;
    participants: string[];
}
/**
 * Agent Communication Protocol Implementation
 */
export declare class AgentCommunicationProtocol extends EventEmitter {
    private registry;
    private conversationManager;
    private orchestrationStrategies;
    private activeConversations;
    private messageQueue;
    private telemetry;
    constructor(registry: IAgentRegistry, conversationManager: ConversationManager);
    /**
     * Initialize built-in orchestration strategies
     */
    private initializeOrchestrationStrategies;
    /**
     * Setup event handlers for telemetry and monitoring
     */
    private setupEventHandlers;
    /**
     * Orchestrate a task across multiple agents
     */
    orchestrateTask(task: AgentTask, strategyName?: string, agentCriteria?: AgentSearchCriteria): Promise<OrchestrationResult>;
    /**
     * Send message between agents
     */
    sendMessage(senderId: string, recipientId: string, content: any, type?: MessageType, metadata?: Partial<MessageMetadata>): Promise<Message>;
    /**
     * Start a multi-agent conversation
     */
    startConversation(participants: string[], topic: string, orchestrationStrategy?: string): Promise<string>;
    /**
     * Facilitate agent capability negotiation
     */
    negotiateCapabilities(task: AgentTask, candidateAgents: string[]): Promise<CapabilityNegotiationResult>;
    /**
     * Get orchestration strategies
     */
    getOrchestrationStrategies(): string[];
    /**
     * Get active conversations
     */
    getActiveConversations(): ConversationContext[];
    /**
     * Private: Process individual message
     */
    private processMessage;
    /**
     * Handle task request messages
     */
    private handleTaskRequest;
    /**
     * Handle capability inquiry messages
     */
    private handleCapabilityInquiry;
    /**
     * Handle coordination request messages
     */
    private handleCoordinationRequest;
    /**
     * Calculate capability confidence for a task
     */
    private calculateCapabilityConfidence;
    /**
     * Estimate resource requirements
     */
    private estimateResourceRequirements;
    /**
     * Generate unique message ID
     */
    private generateMessageId;
}
interface ConversationContext {
    id: string;
    participants: string[];
    topic: string;
    strategy: string;
    startTime: Date;
    active: boolean;
    messageCount: number;
}
interface CapabilityNegotiation {
    agentId: string;
    canHandle: boolean;
    capabilities: AgentCapability[];
    confidence: number;
    estimatedTime: number;
    resourceRequirements: ResourceUsage;
}
interface CapabilityNegotiationResult {
    task: AgentTask;
    negotiations: CapabilityNegotiation[];
    bestMatch: CapabilityNegotiation | null;
    alternatives: CapabilityNegotiation[];
    totalCandidates: number;
}
export declare function createAgentCommunicationProtocol(registry: IAgentRegistry, conversationManager: ConversationManager): AgentCommunicationProtocol;
export default AgentCommunicationProtocol;
//# sourceMappingURL=agent-communication-protocol.d.ts.map