@elizaos/plugin-trust 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,862 @@
+import { UUID, Role, Service, IAgentRuntime, Action as Action$1, WorldSettings, Provider, Evaluator, Plugin } from '@elizaos/core';
+
+/**
+ * Core trust dimensions based on interpersonal trust theory
+ */
+interface TrustDimensions {
+    /** Consistency in behavior and promise keeping (0-100) */
+    reliability: number;
+    /** Ability to perform tasks and provide value (0-100) */
+    competence: number;
+    /** Adherence to ethical principles (0-100) */
+    integrity: number;
+    /** Good intentions towards others (0-100) */
+    benevolence: number;
+    /** Open and honest communication (0-100) */
+    transparency: number;
+}
+/**
+ * Evidence types that impact trust scores
+ */
+declare enum TrustEvidenceType {
+    PROMISE_KEPT = "PROMISE_KEPT",
+    HELPFUL_ACTION = "HELPFUL_ACTION",
+    CONSISTENT_BEHAVIOR = "CONSISTENT_BEHAVIOR",
+    VERIFIED_IDENTITY = "VERIFIED_IDENTITY",
+    COMMUNITY_CONTRIBUTION = "COMMUNITY_CONTRIBUTION",
+    SUCCESSFUL_TRANSACTION = "SUCCESSFUL_TRANSACTION",
+    PROMISE_BROKEN = "PROMISE_BROKEN",
+    HARMFUL_ACTION = "HARMFUL_ACTION",
+    INCONSISTENT_BEHAVIOR = "INCONSISTENT_BEHAVIOR",
+    SUSPICIOUS_ACTIVITY = "SUSPICIOUS_ACTIVITY",
+    FAILED_VERIFICATION = "FAILED_VERIFICATION",
+    SPAM_BEHAVIOR = "SPAM_BEHAVIOR",
+    SECURITY_VIOLATION = "SECURITY_VIOLATION",
+    IDENTITY_CHANGE = "IDENTITY_CHANGE",
+    ROLE_CHANGE = "ROLE_CHANGE",
+    CONTEXT_SWITCH = "CONTEXT_SWITCH"
+}
+/**
+ * A piece of evidence that affects trust
+ */
+interface TrustEvidence {
+    type: TrustEvidenceType;
+    timestamp: number;
+    /** Impact on trust score (-100 to +100) */
+    impact: number;
+    /** Weight/importance of this evidence (0-1) */
+    weight: number;
+    /** Optional description of the evidence */
+    description: string;
+    /** Entity who reported/created this evidence */
+    reportedBy: UUID;
+    /** Whether this evidence has been verified */
+    verified: boolean;
+    /** Context where this evidence occurred */
+    context: TrustContext;
+    targetEntityId: UUID;
+    evaluatorId: UUID;
+    metadata?: any;
+}
+/**
+ * Trust profile for an entity
+ */
+interface TrustProfile {
+    /** Entity this profile belongs to */
+    entityId: UUID;
+    /** Core trust dimensions */
+    dimensions: TrustDimensions;
+    /** Overall trust score (0-100) */
+    overallTrust: number;
+    /** Confidence in the trust score (0-1) */
+    confidence: number;
+    /** Number of interactions used to calculate trust */
+    interactionCount: number;
+    /** Evidence supporting this trust profile */
+    evidence: TrustEvidence[];
+    /** When this profile was last calculated */
+    lastCalculated: number;
+    /** Method used to calculate trust */
+    calculationMethod: string;
+    /** Trust trend over time */
+    trend: {
+        direction: 'increasing' | 'decreasing' | 'stable';
+        changeRate: number;
+        lastChangeAt: number;
+    };
+    evaluatorId: UUID;
+}
+/**
+ * Context for trust calculations
+ */
+interface TrustContext {
+    /** Who is evaluating trust */
+    evaluatorId: UUID;
+    /** Specific context for evaluation */
+    worldId?: UUID;
+    roomId?: UUID;
+    platform?: string;
+    /** Type of action being considered */
+    action?: string;
+    /** Time window for evidence consideration */
+    timeWindow?: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Result of a trust-based decision
+ */
+interface TrustDecision {
+    allowed: boolean;
+    trustScore: number;
+    requiredScore: number;
+    /** Which dimensions were evaluated */
+    dimensionsChecked: Partial<TrustDimensions>;
+    /** Reason for the decision */
+    reason: string;
+    /** Suggestions for building trust if denied */
+    suggestions?: string[];
+}
+/**
+ * Configuration for trust requirements
+ */
+interface TrustRequirements {
+    /** Minimum overall trust score */
+    minimumTrust: number;
+    /** Required dimension scores */
+    dimensions?: {
+        reliability?: number;
+        competence?: number;
+        integrity?: number;
+        benevolence?: number;
+        transparency?: number;
+    };
+    /** Required evidence types */
+    requiredEvidence?: TrustEvidenceType[];
+    /** Minimum interaction count */
+    minimumInteractions?: number;
+    /** Required confidence level */
+    minimumConfidence?: number;
+}
+/**
+ * Trust interaction to be recorded
+ */
+interface TrustInteraction {
+    sourceEntityId: UUID;
+    targetEntityId: UUID;
+    type: TrustEvidenceType;
+    timestamp: number;
+    impact: number;
+    details?: {
+        description?: string;
+        messageId?: UUID;
+        roomId?: UUID;
+        [key: string]: any;
+    };
+    context?: TrustContext;
+}
+/**
+ * Trust calculation configuration
+ */
+interface TrustCalculationConfig {
+    /** How much recent evidence is weighted vs old */
+    recencyBias: number;
+    /** How fast evidence decays over time */
+    evidenceDecayRate: number;
+    /** Minimum evidence required for confidence */
+    minimumEvidenceCount: number;
+    /** How much to weight verified vs unverified evidence */
+    verificationMultiplier: number;
+    /** Dimension weights for overall score */
+    dimensionWeights: {
+        reliability: number;
+        competence: number;
+        integrity: number;
+        benevolence: number;
+        transparency: number;
+    };
+}
+
+/**
+ * Context for permission evaluation
+ */
+interface PermissionContext {
+    worldId?: UUID;
+    roomId?: UUID;
+    platform?: string;
+    serverId?: string;
+    channelId?: string;
+    timestamp?: number;
+}
+/**
+ * Permission that can be granted
+ */
+interface Permission {
+    action: string;
+    resource: string;
+    context?: PermissionContext;
+    constraints?: PermissionConstraint[];
+}
+/**
+ * Constraint on a permission
+ */
+interface PermissionConstraint {
+    type: 'time_window' | 'usage_limit' | 'trust_required' | 'role_required' | 'custom';
+    value: any;
+    description?: string;
+}
+/**
+ * Result of a permission check
+ */
+interface PermissionDecision {
+    allowed: boolean;
+    /** How the decision was made */
+    method: 'role-based' | 'trust-based' | 'delegated' | 'elevated' | 'denied';
+    /** Which role or trust level granted access */
+    grantedBy?: {
+        type: 'role' | 'trust';
+        value: Role | number;
+        context?: PermissionContext;
+    };
+    /** Reason for the decision */
+    reason: string;
+    /** Suggestions if denied */
+    suggestions?: string[];
+    /** Conditions that must be met */
+    conditions?: string[];
+    /** Audit trail */
+    auditInfo?: {
+        decidedAt: number;
+        evaluatorId: UUID;
+        evidence?: any[];
+    };
+}
+/**
+ * Request for elevated permissions
+ */
+interface ElevationRequest {
+    entityId: UUID;
+    requestedPermission: Permission;
+    justification: string;
+    duration?: number;
+    context: PermissionContext;
+}
+/**
+ * Result of an elevation request
+ */
+interface ElevationResult {
+    granted: boolean;
+    elevationId?: UUID;
+    expiresAt?: number;
+    conditions?: string[];
+    reason?: string;
+    trustDeficit?: number;
+    suggestions?: string[];
+}
+/**
+ * Access request for evaluation
+ */
+interface AccessRequest {
+    entityId: UUID;
+    action: string;
+    resource: string;
+    context: PermissionContext;
+    metadata?: Record<string, any>;
+}
+/**
+ * Complete access decision with all details
+ */
+interface AccessDecision extends PermissionDecision {
+    request: AccessRequest;
+    evaluatedAt: number;
+    ttl?: number;
+    securityChecks?: {
+        promptInjection: boolean;
+        socialEngineering: boolean;
+        anomalyDetection: boolean;
+    };
+}
+
+interface SecurityContext extends PermissionContext {
+    entityId?: UUID;
+    requestedAction?: string;
+    messageHistory?: string[];
+}
+interface SecurityCheck {
+    detected: boolean;
+    confidence: number;
+    type: 'prompt_injection' | 'social_engineering' | 'anomaly' | 'none';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    action: 'block' | 'require_verification' | 'allow' | 'log_only';
+    details?: string;
+}
+interface ThreatAssessment extends SecurityCheck {
+    recommendation?: string;
+}
+interface SecurityEvent {
+    id?: UUID;
+    type: SecurityEventType;
+    entityId: UUID;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    context: PermissionContext;
+    details: any;
+    timestamp?: number;
+    handled?: boolean;
+}
+declare enum SecurityEventType {
+    PROMPT_INJECTION_ATTEMPT = "prompt_injection_attempt",
+    SOCIAL_ENGINEERING_ATTEMPT = "social_engineering_attempt",
+    PRIVILEGE_ESCALATION_ATTEMPT = "privilege_escalation_attempt",
+    ANOMALOUS_REQUEST = "anomalous_request",
+    TRUST_MANIPULATION = "trust_manipulation",
+    IDENTITY_SPOOFING = "identity_spoofing",
+    MULTI_ACCOUNT_ABUSE = "multi_account_abuse",
+    CREDENTIAL_THEFT_ATTEMPT = "credential_theft_attempt",
+    PHISHING_ATTEMPT = "phishing_attempt",
+    IMPERSONATION_ATTEMPT = "impersonation_attempt",
+    COORDINATED_ATTACK = "coordinated_attack",
+    MALICIOUS_LINK_CAMPAIGN = "malicious_link_campaign"
+}
+interface PatternDetection {
+    type: 'multi_account' | 'phishing' | 'impersonation' | 'coordination' | 'credential_theft';
+    confidence: number;
+    evidence: string[];
+    relatedEntities?: UUID[];
+    recommendation: string;
+}
+interface MultiAccountDetection extends PatternDetection {
+    type: 'multi_account';
+    primaryAccount: UUID;
+    linkedAccounts: UUID[];
+    linkageEvidence: {
+        typingPattern: number;
+        timingPattern: number;
+        vocabularyPattern: number;
+        behaviorPattern: number;
+    };
+}
+interface PhishingDetection extends PatternDetection {
+    type: 'phishing';
+    maliciousLinks?: string[];
+    targetedEntities: UUID[];
+    campaignId?: string;
+}
+interface ImpersonationDetection extends PatternDetection {
+    type: 'impersonation';
+    impersonator: string;
+    impersonated: string;
+    visualSimilarity: number;
+    timingCoincidence: number;
+}
+interface CoordinationDetection extends PatternDetection {
+    type: 'coordination';
+    coordinatedEntities: UUID[];
+    timeWindow: number;
+    correlationScore: number;
+}
+interface CredentialTheftDetection extends PatternDetection {
+    type: 'credential_theft';
+    sensitivePatterns: string[];
+    attemptedTheft: string[];
+    potentialVictims: UUID[];
+}
+interface BehavioralProfile {
+    entityId: UUID;
+    typingSpeed: number;
+    vocabularyComplexity: number;
+    messageLength: {
+        mean: number;
+        stdDev: number;
+    };
+    activeHours: number[];
+    commonPhrases: string[];
+    interactionPatterns: Map<string, number>;
+}
+interface Message {
+    id: UUID;
+    entityId: UUID;
+    content: string;
+    timestamp: number;
+    roomId?: UUID;
+    replyTo?: UUID;
+}
+interface Action {
+    id: UUID;
+    entityId: UUID;
+    type: string;
+    timestamp: number;
+    target?: string;
+    result?: 'success' | 'failure';
+}
+
+interface CredentialThreatDetection {
+    detected: boolean;
+    confidence: number;
+    threatType: 'credential_request' | 'phishing' | 'social_engineering' | 'none';
+    sensitiveData: string[];
+    recommendation: string;
+}
+declare class CredentialProtector extends Service {
+    static serviceType: "credential-protector";
+    capabilityDescription: string;
+    private securityModule;
+    private readonly SENSITIVE_PATTERNS;
+    private readonly THEFT_REQUEST_PATTERNS;
+    private readonly LEGITIMATE_CONTEXTS;
+    constructor();
+    initialize(runtime: IAgentRuntime, securityModule: any): Promise<void>;
+    stop(): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    /**
+     * Scan message for credential theft attempts
+     */
+    scanForCredentialTheft(message: string, entityId: UUID, context: SecurityContext): Promise<CredentialThreatDetection>;
+    /**
+     * Protect sensitive data by redacting it
+     */
+    protectSensitiveData(content: string): Promise<string>;
+    /**
+     * Alert potential victims of credential theft
+     */
+    alertPotentialVictims(threatActor: UUID, victims: UUID[], threatDetails: CredentialThreatDetection): Promise<void>;
+    /**
+     * Analyze a conversation for credential theft patterns
+     */
+    analyzeConversation(messages: Array<{
+        entityId: UUID;
+        content: string;
+        timestamp: number;
+    }>, context: SecurityContext): Promise<{
+        overallThreat: number;
+        suspiciousEntities: UUID[];
+        recommendations: string[];
+    }>;
+    /**
+     * Private helper methods
+     */
+    private detectSensitiveData;
+    private isLegitimateContext;
+    private hasPhishingIndicators;
+    private logThreatEvent;
+}
+
+declare class TrustEngine extends Service {
+    static serviceType: "trust-engine";
+    capabilityDescription: string;
+    private trustConfig;
+    private profileCache;
+    private cacheTimeout;
+    private trustProfiles;
+    private interactions;
+    constructor(config?: Partial<TrustCalculationConfig>);
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    /**
+     * Calculate trust profile for an entity
+     */
+    calculateTrust(subjectId: UUID, context: TrustContext): Promise<TrustProfile>;
+    /**
+     * Records a trust interaction
+     */
+    recordInteraction(interaction: TrustInteraction): Promise<void>;
+    /**
+     * Evaluate if an action is allowed based on trust
+     */
+    evaluateTrustDecision(entityId: UUID, requirements: TrustRequirements, context: TrustContext): Promise<TrustDecision>;
+    /**
+     * Calculate trust dimensions from evidence
+     */
+    private calculateDimensions;
+    /**
+     * Calculate overall trust score from dimensions
+     */
+    private calculateOverallTrust;
+    /**
+     * Calculate confidence based on evidence quantity and consistency
+     */
+    private calculateConfidence;
+    /**
+     * Calculate age weight for evidence based on recency
+     */
+    private calculateAgeWeight;
+    /**
+     * Analyze trust trend over time
+     */
+    private analyzeTrend;
+    /**
+     * Load evidence from storage
+     */
+    private loadEvidence;
+    /**
+     * Save trust profile to storage
+     */
+    private saveTrustProfile;
+    /**
+     * Save evidence to storage
+     */
+    private saveEvidence;
+    /**
+     * Clear cache for an entity
+     */
+    private clearCacheForEntity;
+    /**
+     * Generate suggestions for building trust
+     */
+    private generateTrustBuildingSuggestions;
+    /**
+     * Generate suggestions for improving specific dimensions
+     */
+    private generateDimensionSuggestions;
+    /**
+     * Evaluates trust for an entity (simplified API for actions)
+     */
+    evaluateTrust(entityId: UUID, evaluatorId: UUID, context?: Partial<TrustContext>): Promise<TrustProfile>;
+    /**
+     * Get recent trust interactions for an entity
+     */
+    getRecentInteractions(entityId: UUID, limit?: number): Promise<TrustInteraction[]>;
+    /**
+     * Gets recent security incidents for a room
+     */
+    getRecentSecurityIncidents(roomId: UUID, hours?: number): Promise<any[]>;
+    /**
+     * Assesses the current threat level for a room
+     */
+    assessThreatLevel(roomId: UUID): Promise<number>;
+    /**
+     * Analyzes a message for security concerns
+     */
+    analyzeMessage(text: string, entityId: UUID, context: any): Promise<any>;
+    /**
+     * Gets security recommendations based on threat level
+     */
+    getSecurityRecommendations(threatLevel: number): string[];
+}
+
+declare class SecurityModule {
+    private runtime;
+    private trustEngine;
+    private behavioralProfiles;
+    private messageHistory;
+    private actionHistory;
+    private readonly INJECTION_PATTERNS;
+    private readonly URGENCY_KEYWORDS;
+    private readonly AUTHORITY_KEYWORDS;
+    private readonly INTIMIDATION_KEYWORDS;
+    private readonly CREDENTIAL_PATTERNS;
+    private readonly PHISHING_INDICATORS;
+    constructor();
+    /**
+     * Initialize the security module
+     */
+    initialize(runtime: IAgentRuntime, trustEngine: any): Promise<void>;
+    /**
+     * Detect prompt injection attempts
+     */
+    detectPromptInjection(message: string, context: SecurityContext): Promise<SecurityCheck>;
+    /**
+     * Detect social engineering attempts
+     */
+    detectSocialEngineering(message: string, context: SecurityContext): Promise<SecurityCheck>;
+    /**
+     * Assess overall threat level
+     */
+    assessThreatLevel(context: SecurityContext): Promise<ThreatAssessment>;
+    /**
+     * Get recent security incidents
+     */
+    getRecentSecurityIncidents(roomId?: UUID, hours?: number): Promise<SecurityEvent[]>;
+    /**
+     * Log security event (now public)
+     */
+    logSecurityEvent(event: Omit<SecurityEvent, 'id' | 'timestamp' | 'handled'>): Promise<void>;
+    /**
+     * Analyze social engineering factors
+     */
+    private analyzeSocialEngineeringFactors;
+    /**
+     * Calculate keyword score
+     */
+    private calculateKeywordScore;
+    /**
+     * Detect liking manipulation
+     */
+    private detectLikingManipulation;
+    /**
+     * Detect reciprocity manipulation
+     */
+    private detectReciprocityManipulation;
+    /**
+     * Detect commitment manipulation
+     */
+    private detectCommitmentManipulation;
+    /**
+     * Detect social proof manipulation
+     */
+    private detectSocialProofManipulation;
+    /**
+     * Detect scarcity manipulation
+     */
+    private detectScarcityManipulation;
+    /**
+     * Calculate overall social engineering risk
+     */
+    private calculateSocialEngineeringRisk;
+    /**
+     * Analyze semantic patterns
+     */
+    private analyzeSemantics;
+    /**
+     * Log trust impact from security events
+     */
+    logTrustImpact(entityId: UUID, event: SecurityEventType, impact: number, context?: {
+        worldId?: UUID;
+    }): Promise<void>;
+    /**
+     * Maps security events to trust evidence types
+     */
+    private mapSecurityEventToTrustEvidence;
+    /**
+     * Enhanced pattern detection capabilities
+     */
+    /**
+     * Detect multi-account manipulation
+     */
+    detectMultiAccountPattern(entities: UUID[], timeWindow?: number): Promise<MultiAccountDetection | null>;
+    /**
+     * Detect credential theft attempts
+     */
+    detectCredentialTheft(message: string, entityId: UUID, context: SecurityContext): Promise<CredentialTheftDetection | null>;
+    /**
+     * Detect phishing campaigns
+     */
+    detectPhishing(messages: Message[], entityId: UUID): Promise<PhishingDetection | null>;
+    /**
+     * Detect impersonation attempts
+     */
+    detectImpersonation(username: string, existingUsers: string[]): Promise<ImpersonationDetection | null>;
+    /**
+     * Detect coordinated activity
+     */
+    detectCoordinatedActivity(entities: UUID[], timeWindow?: number): Promise<CoordinationDetection | null>;
+    /**
+     * Helper methods for pattern detection
+     */
+    private getBehavioralProfiles;
+    private buildBehavioralProfile;
+    private calculateProfileSimilarities;
+    private calculateVariance;
+    private checkSynchronizedActions;
+    private getRecentActions;
+    private detectSuspiciousLinks;
+    private extractLinks;
+    private calculateStringSimilarity;
+    private calculateVisualSimilarity;
+    private levenshteinDistance;
+    /**
+     * Store message for analysis
+     */
+    storeMessage(message: Message): Promise<void>;
+    /**
+     * Store action for analysis
+     */
+    storeAction(action: Action): Promise<void>;
+}
+
+declare class ContextualPermissionSystem {
+    private runtime;
+    private trustEngine;
+    private securityModule;
+    private permissionCache;
+    private contextualRoles;
+    private delegations;
+    private elevations;
+    constructor();
+    initialize(runtime: IAgentRuntime, trustEngine: TrustEngine, securityModule: SecurityModule): Promise<void>;
+    hasPermission(entityId: UUID, permission: Permission, context: PermissionContext): Promise<boolean>;
+    checkAccess(request: AccessRequest): Promise<AccessDecision>;
+    private checkRolePermissions;
+    private checkTrustPermissions;
+    private checkDelegatedPermissions;
+    requestElevation(request: ElevationRequest): Promise<AccessDecision>;
+    private createDecision;
+    private roleHasPermission;
+    private getEntityRoles;
+    private generateDenialReason;
+}
+
+declare class LLMEvaluator extends Service {
+    static serviceType: "llm-evaluator";
+    capabilityDescription: string;
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Evaluate potential security threats using LLM
+     */
+    evaluateSecurityThreat(message: string, context: SecurityContext, history?: string[]): Promise<SecurityCheck>;
+    /**
+     * Evaluate trust-related decisions using LLM
+     */
+    evaluateTrustAction(action: string, actor: UUID, context: TrustContext, trustScore: number): Promise<{
+        allowed: boolean;
+        confidence: number;
+        reasoning: string;
+        suggestions?: string[];
+    }>;
+    /**
+     * Analyze behavioral patterns using LLM
+     */
+    analyzeBehavior(messages: string[], actions: any[], entityId: UUID): Promise<{
+        patterns: string[];
+        anomalies: string[];
+        riskScore: number;
+        personality: string;
+    }>;
+    private determineAction;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+}
+
+/**
+ * Represents an action to update the role of a user within a server.
+ * @typedef {Object} Action
+ * @property {string} name - The name of the action.
+ * @property {string[]} similes - The similar actions that can be performed.
+ * @property {string} description - A description of the action and its purpose.
+ * @property {Function} validate - A function to validate the action before execution.
+ * @property {Function} handler - A function to handle the execution of the action.
+ * @property {ActionExample[][]} examples - Examples demonstrating how the action can be used.
+ */
+declare const updateRoleAction: Action$1;
+
+/**
+ * Gets settings state from world metadata
+ */
+/**
+ * Retrieves the settings for a specific world from the database.
+ * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+ * @param {string} serverId - The ID of the server.
+ * @returns {Promise<WorldSettings | null>} The settings of the world, or null if not found.
+ */
+declare function getWorldSettings(runtime: IAgentRuntime, serverId: string): Promise<WorldSettings | null>;
+/**
+ * Updates settings state in world metadata
+ */
+declare function updateWorldSettings(runtime: IAgentRuntime, serverId: string, worldSettings: WorldSettings): Promise<boolean>;
+/**
+ * Enhanced settings action with improved state management and logging
+ * Updated to use world metadata instead of cache
+ */
+declare const updateSettingsAction: Action$1;
+
+declare const recordTrustInteractionAction: Action$1;
+
+declare const evaluateTrustAction: Action$1;
+
+declare const requestElevationAction: Action$1;
+
+/**
+ * Role provider that retrieves roles in the server based on the provided runtime, message, and state.
+ * * @type { Provider }
+ * @property { string } name - The name of the role provider.
+ * @property { string } description - A brief description of the role provider.
+ * @property { Function } get - Asynchronous function that retrieves and processes roles in the server.
+ * @param { IAgentRuntime } runtime - The agent runtime object.
+ * @param { Memory } message - The message memory object.
+ * @param { State } state - The state object.
+ * @returns {Promise<ProviderResult>} The result containing roles data, values, and text.
+ */
+/**
+ * A provider for retrieving and formatting the role hierarchy in a server.
+ * @type {Provider}
+ */
+declare const roleProvider: Provider;
+
+/**
+ * Creates an settings provider with the given configuration
+ * Updated to use world metadata instead of cache
+ */
+declare const settingsProvider: Provider;
+
+declare const trustProfileProvider: Provider;
+
+declare const securityStatusProvider: Provider;
+
+declare const reflectionEvaluator: Evaluator;
+
+declare const trustChangeEvaluator: Evaluator;
+
+type TrustEngineService = InstanceType<typeof TrustEngine>;
+type SecurityModuleService = InstanceType<typeof SecurityModule>;
+type ContextualPermissionSystemService = InstanceType<typeof ContextualPermissionSystem>;
+type CredentialProtectorService = InstanceType<typeof CredentialProtector>;
+type LLMEvaluatorService = InstanceType<typeof LLMEvaluator>;
+
+declare class TrustEngineServiceWrapper extends Service {
+    static readonly serviceType = "trust-engine";
+    readonly capabilityDescription = "Multi-dimensional trust scoring and evidence-based trust evaluation";
+    trustEngine: TrustEngine;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    calculateTrust(entityId: UUID, context: TrustContext): Promise<TrustProfile>;
+    getRecentInteractions(entityId: UUID, limit?: number): Promise<TrustInteraction[]>;
+    evaluateTrustDecision(entityId: UUID, requirements: TrustRequirements, context: TrustContext): Promise<TrustDecision>;
+}
+declare class SecurityModuleServiceWrapper extends Service {
+    static readonly serviceType = "security-module";
+    readonly capabilityDescription = "Security threat detection and trust-based security analysis";
+    securityModule: SecurityModule;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    detectPromptInjection(content: string, context: SecurityContext): Promise<SecurityCheck>;
+    assessThreatLevel(context: SecurityContext): Promise<ThreatAssessment>;
+    logTrustImpact(entityId: UUID, event: SecurityEventType, impact: number, context?: Partial<TrustContext>): Promise<void>;
+    storeMessage(message: any): Promise<void>;
+    storeAction(action: any): Promise<void>;
+    detectMultiAccountPattern(entities: UUID[], timeWindow?: number): Promise<any>;
+    detectImpersonation(username: string, existingUsers: string[]): Promise<any>;
+    detectPhishing(messages: any[], entityId: UUID): Promise<any>;
+}
+declare class CredentialProtectorServiceWrapper extends Service {
+    static readonly serviceType = "credential-protector";
+    readonly capabilityDescription = "Detects and prevents credential theft attempts, protects sensitive data";
+    credentialProtector: CredentialProtector;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    scanForCredentialTheft(message: string, entityId: UUID, context: SecurityContext): Promise<CredentialThreatDetection>;
+    protectSensitiveData(content: string): Promise<string>;
+    alertPotentialVictims(threatActor: UUID, victims: UUID[], threatDetails: any): Promise<void>;
+}
+declare class ContextualPermissionSystemServiceWrapper extends Service {
+    static readonly serviceType = "contextual-permissions";
+    readonly capabilityDescription = "Context-aware permission management with trust-based access control";
+    permissionSystem: ContextualPermissionSystem;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    checkAccess(request: AccessRequest): Promise<AccessDecision>;
+    hasPermission(entityId: UUID, permission: Permission, context: PermissionContext): Promise<boolean>;
+}
+declare class LLMEvaluatorServiceWrapper extends Service {
+    static readonly serviceType = "llm-evaluator";
+    readonly capabilityDescription = "LLM-based evaluation for trust and security decisions";
+    llmEvaluator: LLMEvaluator;
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    evaluateSecurityThreat(message: string, context: SecurityContext, history?: string[]): Promise<SecurityCheck>;
+    evaluateTrustAction(action: string, actor: UUID, context: TrustContext, trustScore: number): Promise<{
+        allowed: boolean;
+        confidence: number;
+        reasoning: string;
+        suggestions?: string[];
+    }>;
+    analyzeBehavior(messages: string[], actions: any[], entityId: UUID): Promise<{
+        patterns: string[];
+        anomalies: string[];
+        riskScore: number;
+        personality: string;
+    }>;
+}
+declare const trustPlugin: Plugin;
+
+export { type AccessDecision, type AccessRequest, type Action, type BehavioralProfile, ContextualPermissionSystem, type ContextualPermissionSystemService, ContextualPermissionSystemServiceWrapper, type CoordinationDetection, CredentialProtector, type CredentialProtectorService, CredentialProtectorServiceWrapper, type CredentialTheftDetection, type ElevationRequest, type ElevationResult, type ImpersonationDetection, LLMEvaluator, type LLMEvaluatorService, LLMEvaluatorServiceWrapper, type Message, type MultiAccountDetection, type PatternDetection, type Permission, type PermissionContext, type PermissionDecision, type PhishingDetection, type SecurityCheck, type SecurityContext, type SecurityEvent, SecurityEventType, SecurityModule, type SecurityModuleService, SecurityModuleServiceWrapper, type ThreatAssessment, type TrustCalculationConfig, type TrustContext, type TrustDecision, type TrustDimensions, TrustEngine, type TrustEngineService, TrustEngineServiceWrapper, type TrustEvidence, TrustEvidenceType, type TrustInteraction, type TrustProfile, type TrustRequirements, trustPlugin as default, evaluateTrustAction, getWorldSettings, recordTrustInteractionAction, reflectionEvaluator, requestElevationAction, roleProvider, securityStatusProvider, settingsProvider, trustChangeEvaluator, trustProfileProvider, updateRoleAction, updateSettingsAction, updateWorldSettings };