anon-identity/dist/mcp/delegation/llm-delegation-engine.d.ts

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

/**
 * LLM-Assisted Delegation Engine for MCP
 *
 * Intelligent delegation decision making using large language models
 */
import { EventEmitter } from 'events';
import { MessageRouter } from '../routing/message-router';
import { AuthManager } from '../security/auth-manager';
import { AuditLogger } from '../security/audit-logger';
/**
 * Delegation request
 */
export interface DelegationRequest {
    requestId: string;
    parentAgentDID: string;
    targetAgentDID: string;
    requestedScopes: string[];
    purpose: string;
    context: string;
    duration?: number;
    constraints?: Record<string, any>;
    urgency: 'low' | 'medium' | 'high' | 'critical';
    requestedAt: Date;
    metadata?: Record<string, any>;
}
/**
 * Delegation decision
 */
export interface DelegationDecision {
    requestId: string;
    decision: 'approve' | 'deny' | 'approve_with_modifications' | 'request_more_info';
    confidence: number;
    reasoning: string;
    suggestedScopes?: string[];
    suggestedConstraints?: Record<string, any>;
    suggestedDuration?: number;
    warnings: string[];
    riskAssessment: {
        level: 'low' | 'medium' | 'high' | 'critical';
        factors: string[];
        mitigations: string[];
    };
    decidedAt: Date;
    reviewRequired: boolean;
    additionalInfo?: {
        questions: string[];
        expectedResponseTime: number;
    };
}
/**
 * Policy interpretation
 */
export interface PolicyInterpretation {
    policyId: string;
    summary: string;
    applicableRules: Array<{
        rule: string;
        description: string;
        impact: 'allow' | 'restrict' | 'modify';
        severity: 'info' | 'warning' | 'error';
    }>;
    requirements: string[];
    restrictions: string[];
    recommendations: string[];
    exceptions: Array<{
        condition: string;
        action: string;
        justification: string;
    }>;
    complianceLevel: number;
}
/**
 * Scope recommendation
 */
export interface ScopeRecommendation {
    requestedScopes: string[];
    recommendedScopes: string[];
    reasoning: string;
    alternatives: Array<{
        scopes: string[];
        rationale: string;
        tradeoffs: string[];
    }>;
    minimumScopes: string[];
    maximumScopes: string[];
    riskLevel: 'low' | 'medium' | 'high';
}
/**
 * Agent profile
 */
export interface AgentProfile {
    did: string;
    name: string;
    type: 'user' | 'service' | 'autonomous' | 'assistant';
    trustLevel: number;
    capabilities: string[];
    permissions: string[];
    history: {
        totalDelegations: number;
        successfulDelegations: number;
        revokedDelegations: number;
        averageDelegationDuration: number;
        lastActivity: Date;
    };
    riskFactors: string[];
}
/**
 * Decision context
 */
export interface DecisionContext {
    parentAgent: AgentProfile;
    targetAgent?: AgentProfile;
    organizationalPolicies: any[];
    systemPolicies: any[];
    currentDelegations: Array<{
        targetAgent: string;
        scopes: string[];
        grantedAt: Date;
        expiresAt: Date;
    }>;
    systemLoad: {
        cpu: number;
        memory: number;
        activeAgents: number;
    };
    securityLevel: 'normal' | 'elevated' | 'high' | 'maximum';
    timeOfDay: string;
    workingHours: boolean;
}
/**
 * LLM Delegation Engine
 */
export declare class LLMDelegationEngine extends EventEmitter {
    private messageRouter;
    private authManager;
    private auditLogger;
    private config;
    private functionRegistry;
    constructor(messageRouter: MessageRouter, authManager: AuthManager, auditLogger: AuditLogger, config?: {
        defaultProvider: string;
        decisionTimeout: number;
        requireHumanApproval: boolean;
        minConfidenceThreshold: number;
        maxDelegationDepth: number;
        auditAllDecisions: boolean;
    });
    /**
     * Make delegation decision using LLM
     */
    makeDelegationDecision(request: DelegationRequest, context: DecisionContext): Promise<DelegationDecision>;
    /**
     * Interpret policy using LLM
     */
    interpretPolicy(policyDocument: any, context: DecisionContext, specificScenario?: string): Promise<PolicyInterpretation>;
    /**
     * Generate scope recommendations
     */
    recommendScopes(requestedScopes: string[], purpose: string, context: DecisionContext, availableScopes: string[]): Promise<ScopeRecommendation>;
    /**
     * Process natural language delegation request
     */
    processNaturalLanguageRequest(naturalLanguageRequest: string, requestingAgentDID: string, context: DecisionContext): Promise<DelegationRequest>;
    /**
     * Build decision prompt
     */
    private buildDecisionPrompt;
    /**
     * Build policy interpretation prompt
     */
    private buildPolicyInterpretationPrompt;
    /**
     * Build scope recommendation prompt
     */
    private buildScopeRecommendationPrompt;
    /**
     * Build natural language prompt
     */
    private buildNaturalLanguagePrompt;
    /**
     * Process decision response from LLM
     */
    private processDecisionResponse;
    /**
     * Audit decision
     */
    private auditDecision;
    /**
     * Map urgency to priority
     */
    private mapUrgencyToPriority;
    /**
     * Initialize delegation-specific functions
     */
    private initializeDelegationFunctions;
    /**
     * Get delegation statistics
     */
    getStatistics(): {
        totalDecisions: number;
        approvalRate: number;
        averageConfidence: number;
        riskDistribution: Record<string, number>;
        humanReviewRate: number;
    };
    /**
     * Shutdown
     */
    shutdown(): void;
}
export default LLMDelegationEngine;
//# sourceMappingURL=llm-delegation-engine.d.ts.map