anon-identity/dist/mcp/matching/agent-matcher.d.ts

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

/**
 * Agent Matcher for MCP
 *
 * Embedding-based agent matching and capability discovery
 */
import { EventEmitter } from 'events';
import { MessageRouter } from '../routing/message-router';
import { AuthManager } from '../security/auth-manager';
import { AuditLogger } from '../security/audit-logger';
/**
 * Agent capabilities profile
 */
export interface AgentCapabilityProfile {
    agentDID: string;
    name: string;
    description: string;
    capabilities: string[];
    expertise: string[];
    availableActions: string[];
    performance: {
        averageResponseTime: number;
        successRate: number;
        reliability: number;
        costEfficiency: number;
    };
    constraints: {
        maxConcurrentTasks: number;
        workingHours?: {
            start: string;
            end: string;
            timezone: string;
        };
        dataRestrictions: string[];
        geographicLimitations: string[];
    };
    embedding?: number[];
    lastUpdated: Date;
    trustLevel: number;
}
/**
 * Task description for matching
 */
export interface TaskDescription {
    id: string;
    title: string;
    description: string;
    requiredCapabilities: string[];
    preferredCapabilities?: string[];
    priority: 'low' | 'medium' | 'high' | 'critical';
    constraints: {
        maxCost?: number;
        maxDuration?: number;
        minTrustLevel?: number;
        dataClassification?: 'public' | 'internal' | 'confidential' | 'restricted';
        requiredCertifications?: string[];
    };
    context: {
        domain: string;
        urgency: boolean;
        complexity: 'simple' | 'moderate' | 'complex' | 'expert';
        estimatedDuration: number;
    };
    embedding?: number[];
}
/**
 * Match result
 */
export interface AgentMatch {
    agent: AgentCapabilityProfile;
    score: number;
    confidence: number;
    reasoning: string;
    capabilityAlignment: {
        required: {
            capability: string;
            match: boolean;
            strength: number;
        }[];
        preferred: {
            capability: string;
            match: boolean;
            strength: number;
        }[];
        additional: {
            capability: string;
            strength: number;
        }[];
    };
    riskAssessment: {
        level: 'low' | 'medium' | 'high';
        factors: string[];
        mitigations: string[];
    };
    estimatedMetrics: {
        cost: number;
        duration: number;
        successProbability: number;
    };
}
/**
 * Matching configuration
 */
export interface MatchingConfig {
    embeddingModel: string;
    similarityThreshold: number;
    maxResults: number;
    weightings: {
        capabilityMatch: number;
        performance: number;
        availability: number;
        cost: number;
        trust: number;
        experience: number;
    };
    enableSemanticMatching: boolean;
    enableLearning: boolean;
    cacheEmbeddings: boolean;
}
/**
 * Agent Matcher
 */
export declare class AgentMatcher extends EventEmitter {
    private messageRouter;
    private authManager;
    private auditLogger;
    private config;
    private agentProfiles;
    private taskEmbeddings;
    private agentEmbeddings;
    private matchHistory;
    private semanticCache;
    constructor(messageRouter: MessageRouter, authManager: AuthManager, auditLogger: AuditLogger, config?: MatchingConfig);
    /**
     * Register agent profile
     */
    registerAgent(profile: Omit<AgentCapabilityProfile, 'embedding' | 'lastUpdated'>): Promise<void>;
    /**
     * Update agent profile
     */
    updateAgent(agentDID: string, updates: Partial<AgentCapabilityProfile>): Promise<void>;
    /**
     * Find matching agents for task
     */
    findMatches(task: TaskDescription): Promise<AgentMatch[]>;
    /**
     * Find semantically similar agents
     */
    findSimilarAgents(agentDID: string, options?: {
        includeInactive?: boolean;
        maxResults?: number;
        minSimilarity?: number;
    }): Promise<Array<{
        agent: AgentCapabilityProfile;
        similarity: number;
    }>>;
    /**
     * Recommend agents based on context
     */
    recommendAgents(context: {
        domain: string;
        urgency: boolean;
        complexity: 'simple' | 'moderate' | 'complex' | 'expert';
        budget?: number;
        requiredCertifications?: string[];
    }, options?: {
        maxResults?: number;
        diversityFactor?: number;
    }): Promise<AgentMatch[]>;
    /**
     * Generate agent embedding
     */
    private generateAgentEmbedding;
    /**
     * Generate task embedding
     */
    private generateTaskEmbedding;
    /**
     * Generate embedding using LLM
     */
    private generateEmbedding;
    /**
     * Generate simple embedding (fallback)
     */
    private generateSimpleEmbedding;
    /**
     * Generate simple task embedding
     */
    private generateSimpleTaskEmbedding;
    /**
     * Score agent match against task
     */
    private scoreAgentMatch;
    /**
     * Calculate capability alignment
     */
    private calculateCapabilityAlignment;
    /**
     * Calculate capability strength
     */
    private calculateCapabilityStrength;
    /**
     * Calculate performance score
     */
    private calculatePerformanceScore;
    /**
     * Calculate availability score
     */
    private calculateAvailabilityScore;
    /**
     * Calculate cost score
     */
    private calculateCostScore;
    /**
     * Calculate experience score
     */
    private calculateExperienceScore;
    /**
     * Get complexity score
     */
    private getComplexityScore;
    /**
     * Calculate confidence
     */
    private calculateConfidence;
    /**
     * Generate match reasoning
     */
    private generateMatchReasoning;
    /**
     * Assess risk
     */
    private assessRisk;
    /**
     * Estimate task metrics
     */
    private estimateTaskMetrics;
    /**
     * Estimate task cost
     */
    private estimateTaskCost;
    /**
     * Estimate task duration
     */
    private estimateTaskDuration;
    /**
     * Estimate duration by complexity
     */
    private estimateDurationByComplexity;
    /**
     * Get available agents
     */
    private getAvailableAgents;
    /**
     * Check data restrictions
     */
    private hasDataRestrictions;
    /**
     * Apply learning adjustments
     */
    private applyLearningAdjustments;
    /**
     * Diversify results
     */
    private diversifyResults;
    /**
     * Calculate cosine similarity
     */
    private calculateCosineSimilarity;
    /**
     * Hash string to number
     */
    private hashString;
    /**
     * Record match outcome for learning
     */
    recordMatchOutcome(taskId: string, selectedAgentDID: string, outcome: 'success' | 'failure' | 'partial', actualMetrics: {
        cost: number;
        duration: number;
        quality: number;
    }): Promise<void>;
    /**
     * Update agent performance
     */
    private updateAgentPerformance;
    /**
     * Load agent profiles
     */
    private loadAgentProfiles;
    /**
     * Save agent profiles
     */
    private saveAgentProfiles;
    /**
     * Get matching statistics
     */
    getStatistics(): {
        totalProfiles: number;
        totalMatches: number;
        averageMatchScore: number;
        successRate: number;
        embeddingCacheSize: number;
    };
    /**
     * Shutdown
     */
    shutdown(): void;
}
export default AgentMatcher;
//# sourceMappingURL=agent-matcher.d.ts.map