anon-identity/dist/mcp/security/audit-logger.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

/**
 * Audit Logger for MCP
 *
 * Comprehensive audit logging for all LLM interactions with compliance support
 */
import { EventEmitter } from 'events';
import { AuditConfig, AuditExportFormat, LLMRequest, LLMResponse, UsageInfo, FunctionCall } from '../types';
import { MemoryStorageProvider } from '../../storage/providers/memory-storage-provider';
/**
 * Audit log entry
 */
export interface AuditLogEntry {
    id: string;
    timestamp: Date;
    eventType: AuditEventType;
    agentDID: string;
    sessionId?: string;
    requestId?: string;
    provider?: string;
    model?: string;
    action: string;
    resource?: string;
    status: 'success' | 'failure' | 'error';
    duration?: number;
    metadata: {
        ip?: string;
        userAgent?: string;
        requestSize?: number;
        responseSize?: number;
        error?: string;
        usage?: UsageInfo;
        functionCalls?: FunctionCall[];
        tags?: string[];
    };
    hash?: string;
    previousHash?: string;
}
/**
 * Audit event types
 */
export declare enum AuditEventType {
    AUTH_SUCCESS = "auth.success",
    AUTH_FAILURE = "auth.failure",
    AUTH_TOKEN_CREATED = "auth.token.created",
    AUTH_TOKEN_REFRESHED = "auth.token.refreshed",
    AUTH_SESSION_CREATED = "auth.session.created",
    AUTH_SESSION_EXPIRED = "auth.session.expired",
    AUTHZ_GRANTED = "authz.granted",
    AUTHZ_DENIED = "authz.denied",
    PERMISSION_CHANGED = "permission.changed",
    LLM_REQUEST = "llm.request",
    LLM_RESPONSE = "llm.response",
    LLM_ERROR = "llm.error",
    LLM_FUNCTION_CALL = "llm.function_call",
    LLM_STREAMING_START = "llm.streaming.start",
    LLM_STREAMING_END = "llm.streaming.end",
    PROVIDER_CONNECTED = "provider.connected",
    PROVIDER_DISCONNECTED = "provider.disconnected",
    PROVIDER_ERROR = "provider.error",
    PROVIDER_FAILOVER = "provider.failover",
    SECURITY_ALERT = "security.alert",
    RATE_LIMIT_EXCEEDED = "rate_limit.exceeded",
    CREDENTIAL_ACCESSED = "credential.accessed",
    CREDENTIAL_ROTATED = "credential.rotated",
    SYSTEM_START = "system.start",
    SYSTEM_SHUTDOWN = "system.shutdown",
    CONFIG_CHANGED = "config.changed"
}
/**
 * Audit query options
 */
export interface AuditQueryOptions {
    startDate?: Date;
    endDate?: Date;
    agentDID?: string;
    sessionId?: string;
    eventTypes?: AuditEventType[];
    status?: string;
    provider?: string;
    limit?: number;
    offset?: number;
    sortBy?: 'timestamp' | 'duration' | 'requestSize';
    sortOrder?: 'asc' | 'desc';
}
/**
 * Audit statistics
 */
export interface AuditStatistics {
    totalEvents: number;
    eventsByType: Record<AuditEventType, number>;
    eventsByStatus: Record<string, number>;
    eventsByProvider: Record<string, number>;
    eventsByAgent: Record<string, number>;
    averageResponseTime: number;
    totalTokensUsed: number;
    totalCost: number;
    errorRate: number;
}
/**
 * Compliance report
 */
export interface ComplianceReport {
    period: {
        start: Date;
        end: Date;
    };
    summary: {
        totalRequests: number;
        successRate: number;
        averageResponseTime: number;
        totalCost: number;
        uniqueAgents: number;
        topAgents: Array<{
            agentDID: string;
            requests: number;
        }>;
        topModels: Array<{
            model: string;
            requests: number;
        }>;
    };
    security: {
        authFailures: number;
        authzDenials: number;
        securityAlerts: number;
        rateLimitViolations: number;
    };
    usage: {
        totalTokens: number;
        tokensByProvider: Record<string, number>;
        costByProvider: Record<string, number>;
        functionCalls: number;
    };
    compliance: {
        dataRetentionCompliant: boolean;
        auditTrailIntegrity: boolean;
        unauthorizedAccessAttempts: number;
    };
}
/**
 * Audit Logger
 */
export declare class AuditLogger extends EventEmitter {
    private config;
    private logs;
    private indexByAgent;
    private indexBySession;
    private indexByDate;
    private storageProvider;
    private hashChain;
    private retentionTimer?;
    constructor(config: AuditConfig, storageProvider?: MemoryStorageProvider);
    /**
     * Log LLM request
     */
    logRequest(request: LLMRequest, agentDID: string, sessionId?: string): Promise<string>;
    /**
     * Log LLM response
     */
    logResponse(response: LLMResponse, request: LLMRequest, duration: number): Promise<string>;
    /**
     * Log authentication event
     */
    logAuthentication(agentDID: string, success: boolean, method: string, error?: string): Promise<string>;
    /**
     * Log authorization event
     */
    logAuthorization(agentDID: string, resource: string, action: string, granted: boolean, reasons?: string[]): Promise<string>;
    /**
     * Log security alert
     */
    logSecurityAlert(type: string, agentDID: string, details: any): Promise<string>;
    /**
     * Add log entry
     */
    private addLogEntry;
    /**
     * Update indices
     */
    private updateIndices;
    /**
     * Calculate hash for log entry
     */
    private calculateHash;
    /**
     * Query audit logs
     */
    query(options?: AuditQueryOptions): Promise<AuditLogEntry[]>;
    /**
     * Get statistics
     */
    getStatistics(options?: AuditQueryOptions): Promise<AuditStatistics>;
    /**
     * Generate compliance report
     */
    generateComplianceReport(startDate: Date, endDate: Date): Promise<ComplianceReport>;
    /**
     * Export logs
     */
    export(format: AuditExportFormat, options?: AuditQueryOptions): Promise<string>;
    /**
     * Export as CSV
     */
    private exportCSV;
    /**
     * Export as Syslog
     */
    private exportSyslog;
    /**
     * Load logs from storage
     */
    private loadLogs;
    /**
     * Persist log to storage
     */
    private persistLog;
    /**
     * Start retention cleanup timer
     */
    private startRetentionCleanup;
    /**
     * Clean up old logs
     */
    private cleanupOldLogs;
    /**
     * Verify audit trail integrity
     */
    verifyIntegrity(): Promise<{
        valid: boolean;
        errors: string[];
    }>;
    /**
     * Shutdown audit logger
     */
    shutdown(): void;
}
export default AuditLogger;
//# sourceMappingURL=audit-logger.d.ts.map