stellar-cyber-mcp-agents/dist/types/agent.d.ts

Model Context Protocol (MCP) server for Stellar Cyber security operations with specialized multi-agent analysis capabilities

/**
 * Core types for the multi-agent system
 */
export declare enum AgentType {
    HUB = "hub",
    INVESTIGATION = "investigation",
    CORRELATION = "correlation",
    NETWORK_ANALYSIS = "network_analysis",
    MALWARE_ANALYSIS = "malware_analysis",
    CREDENTIAL_ANALYSIS = "credential_analysis",
    CAMPAIGN_DETECTION = "campaign_detection",
    WORKFLOW = "workflow"
}
export interface AgentId {
    readonly type: string;
    readonly instance: string;
    readonly uuid: string;
}
export interface AgentCapability {
    readonly name: string;
    readonly description: string;
    readonly inputSchema: any;
    readonly outputSchema: any;
}
export interface AgentMetadata {
    readonly id: AgentId;
    readonly name: string;
    readonly description: string;
    readonly version: string;
    readonly capabilities: AgentCapability[];
    readonly dependencies: string[];
    readonly resources: {
        readonly memory?: number;
        readonly cpu?: number;
    };
}
export interface AgentStatus {
    readonly id: AgentId;
    readonly state: AgentState;
    readonly health: AgentHealth;
    readonly lastHeartbeat: Date;
    readonly uptime: number;
    readonly activeRequests: number;
    readonly totalRequests: number;
    readonly errors: number;
}
export declare enum AgentState {
    INITIALIZING = "initializing",
    READY = "ready",
    BUSY = "busy",
    ERROR = "error",
    STOPPING = "stopping",
    STOPPED = "stopped"
}
export declare enum AgentHealth {
    HEALTHY = "healthy",
    DEGRADED = "degraded",
    UNHEALTHY = "unhealthy",
    CRITICAL = "critical"
}
export interface AgentRequest {
    readonly id: string;
    readonly sourceAgentId: AgentId;
    readonly targetAgentId: AgentId;
    readonly capability: string;
    readonly payload: any;
    readonly priority: RequestPriority;
    readonly timeout: number;
    readonly correlationId?: string;
    readonly timestamp: Date;
}
export interface AgentResponse {
    readonly requestId: string;
    readonly sourceAgentId: AgentId;
    readonly success: boolean;
    readonly result?: any;
    readonly error?: {
        readonly code: string;
        readonly message: string;
        readonly details?: any;
    };
    readonly timestamp: Date;
    readonly processingTime: number;
}
export declare enum RequestPriority {
    LOW = 1,
    MEDIUM = 2,
    HIGH = 3,
    CRITICAL = 4
}
export interface AgentEvent {
    readonly id: string;
    readonly sourceAgentId: AgentId;
    readonly type: AgentEventType;
    readonly data: any;
    readonly timestamp: Date;
}
export declare enum AgentEventType {
    AGENT_STARTED = "agent_started",
    AGENT_STOPPED = "agent_stopped",
    AGENT_ERROR = "agent_error",
    AGENT_HEARTBEAT = "agent_heartbeat",
    REQUEST_RECEIVED = "request_received",
    REQUEST_PROCESSED = "request_processed",
    CAPABILITY_ADDED = "capability_added",
    CAPABILITY_REMOVED = "capability_removed"
}
export interface AgentConfiguration {
    readonly id: AgentId;
    readonly settings: Record<string, any>;
    readonly resources: {
        readonly maxMemory?: number;
        readonly maxCpu?: number;
        readonly maxConcurrentRequests?: number;
    };
    readonly timeouts: {
        readonly requestTimeout: number;
        readonly heartbeatInterval: number;
        readonly healthCheckInterval: number;
    };
}
export interface AgentRegistry {
    registerAgent(metadata: AgentMetadata): Promise<void>;
    unregisterAgent(agentId: AgentId): Promise<void>;
    getAgent(agentId: AgentId): Promise<AgentMetadata | null>;
    listAgents(): Promise<AgentMetadata[]>;
    findAgentsByCapability(capability: string): Promise<AgentMetadata[]>;
    updateAgentStatus(status: AgentStatus): Promise<void>;
    getAgentStatus(agentId: AgentId): Promise<AgentStatus | null>;
    getAllAgentStatuses(): Promise<AgentStatus[]>;
    subscribeToEvents(callback: (event: AgentEvent) => void): void;
    unsubscribeFromEvents(callback: (event: AgentEvent) => void): void;
    getRegistryStats(): Promise<{
        totalAgents: number;
        activeAgents: number;
        capabilities: number;
        averageUptime: number;
        totalRequests: number;
        totalErrors: number;
    }>;
}
export interface AgentCommunicationChannel {
    sendRequest(request: AgentRequest): Promise<AgentResponse>;
    subscribeToRequests(agentId: AgentId, callback: (request: AgentRequest) => Promise<AgentResponse>): void;
    unsubscribeFromRequests(agentId: AgentId): void;
    broadcastEvent(event: AgentEvent): Promise<void>;
    subscribeToEvents(callback: (event: AgentEvent) => void): void;
    close(): Promise<void>;
    getChannelStats(): {
        activeHandlers: number;
        pendingRequests: number;
        queuedRequests: number;
        totalQueues: number;
    };
}
export interface AgentContext {
    readonly requestId: string;
    readonly sourceAgentId: AgentId;
    readonly correlationId?: string;
    readonly timestamp: Date;
    readonly metadata: Record<string, any>;
}
export interface AgentLifecycle {
    initialize(): Promise<void>;
    start(): Promise<void>;
    stop(): Promise<void>;
    destroy(): Promise<void>;
    healthCheck(): Promise<AgentHealth>;
}
export interface AgentLogger {
    debug(message: string, meta?: any): void;
    info(message: string, meta?: any): void;
    warn(message: string, meta?: any): void;
    error(message: string, meta?: any): void;
    fatal(message: string, meta?: any): void;
}
export interface AgentMetrics {
    incrementCounter(name: string, value?: number): void;
    recordGauge(name: string, value: number): void;
    recordHistogram(name: string, value: number): void;
    recordTimer(name: string, duration: number): void;
    getMetrics?(): any;
}
export declare abstract class BaseAgent implements AgentLifecycle {
    protected readonly metadata: AgentMetadata;
    protected readonly registry: AgentRegistry;
    protected readonly channel: AgentCommunicationChannel;
    protected readonly logger: AgentLogger;
    protected readonly metrics: AgentMetrics;
    protected state: AgentState;
    protected health: AgentHealth;
    constructor(metadata: AgentMetadata, registry: AgentRegistry, channel: AgentCommunicationChannel, logger: AgentLogger, metrics: AgentMetrics);
    abstract initialize(): Promise<void>;
    abstract start(): Promise<void>;
    abstract stop(): Promise<void>;
    abstract destroy(): Promise<void>;
    abstract healthCheck(): Promise<AgentHealth>;
    protected abstract handleRequest(request: AgentRequest, context: AgentContext): Promise<any>;
    getId(): AgentId;
    getMetadata(): AgentMetadata;
    getState(): AgentState;
    getHealth(): AgentHealth;
    protected setState(state: AgentState): void;
    protected setHealth(health: AgentHealth): void;
    protected emitEvent(type: AgentEventType, data: any): void;
}
//# sourceMappingURL=agent.d.ts.map