@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/trust/services/TrustEngine.js

@@ -0,0 +1,621 @@
+import { logger } from "../../../logger.js";
+import { Service, } from "../../../types/index.js";
+import { stringToUuid } from "../../../utils.js";
+import { TrustEvidenceType, } from "../types/trust.js";
+import { getDb } from "./db.js";
+import { getTrustEvidence, insertTrustEvidence } from "./SecurityStore.js";
+/**
+ * Default configuration for trust calculations
+ */
+const DEFAULT_CONFIG = {
+    recencyBias: 0.7,
+    evidenceDecayRate: 0.5, // Points per day
+    minimumEvidenceCount: 3,
+    verificationMultiplier: 1.5,
+    dimensionWeights: {
+        reliability: 0.25,
+        competence: 0.2,
+        integrity: 0.25,
+        benevolence: 0.2,
+        transparency: 0.1,
+    },
+};
+/**
+ * Evidence impact mapping for different evidence types
+ */
+const EVIDENCE_IMPACT_MAP = {
+    // Positive evidence
+    [TrustEvidenceType.PROMISE_KEPT]: {
+        dimensions: { reliability: 15, integrity: 10 },
+        baseImpact: 10,
+    },
+    [TrustEvidenceType.HELPFUL_ACTION]: {
+        dimensions: { benevolence: 15, competence: 10 },
+        baseImpact: 8,
+    },
+    [TrustEvidenceType.CONSISTENT_BEHAVIOR]: {
+        dimensions: { reliability: 20, transparency: 10 },
+        baseImpact: 12,
+    },
+    [TrustEvidenceType.VERIFIED_IDENTITY]: {
+        dimensions: { transparency: 20, integrity: 10 },
+        baseImpact: 15,
+    },
+    [TrustEvidenceType.COMMUNITY_CONTRIBUTION]: {
+        dimensions: { benevolence: 20, competence: 15 },
+        baseImpact: 12,
+    },
+    [TrustEvidenceType.SUCCESSFUL_TRANSACTION]: {
+        dimensions: { reliability: 15, competence: 15 },
+        baseImpact: 10,
+    },
+    // Negative evidence
+    [TrustEvidenceType.PROMISE_BROKEN]: {
+        dimensions: { reliability: -25, integrity: -15 },
+        baseImpact: -15,
+    },
+    [TrustEvidenceType.HARMFUL_ACTION]: {
+        dimensions: { benevolence: -30, integrity: -20 },
+        baseImpact: -20,
+    },
+    [TrustEvidenceType.INCONSISTENT_BEHAVIOR]: {
+        dimensions: { reliability: -20, transparency: -15 },
+        baseImpact: -12,
+    },
+    [TrustEvidenceType.SUSPICIOUS_ACTIVITY]: {
+        dimensions: { integrity: -15, transparency: -20 },
+        baseImpact: -15,
+    },
+    [TrustEvidenceType.FAILED_VERIFICATION]: {
+        dimensions: { transparency: -25, integrity: -10 },
+        baseImpact: -10,
+    },
+    [TrustEvidenceType.SPAM_BEHAVIOR]: {
+        dimensions: { benevolence: -15, competence: -10 },
+        baseImpact: -10,
+    },
+    [TrustEvidenceType.SECURITY_VIOLATION]: {
+        dimensions: { integrity: -35, reliability: -20 },
+        baseImpact: -25,
+    },
+    // Neutral evidence
+    [TrustEvidenceType.IDENTITY_CHANGE]: {
+        dimensions: { transparency: -5 },
+        baseImpact: 0,
+    },
+    [TrustEvidenceType.ROLE_CHANGE]: {
+        dimensions: {},
+        baseImpact: 0,
+    },
+    [TrustEvidenceType.CONTEXT_SWITCH]: {
+        dimensions: {},
+        baseImpact: 0,
+    },
+};
+export class TrustEngine extends Service {
+    static serviceType = "trust-engine";
+    capabilityDescription = "Multi-dimensional trust scoring and evaluation system";
+    static ACTION_CONTEXT_WEIGHTS = {
+        financial: {
+            integrity: 0.35,
+            reliability: 0.3,
+            competence: 0.15,
+            benevolence: 0.1,
+            transparency: 0.1,
+        },
+        moderation: {
+            benevolence: 0.3,
+            integrity: 0.25,
+            competence: 0.2,
+            reliability: 0.15,
+            transparency: 0.1,
+        },
+        content_creation: {
+            competence: 0.3,
+            integrity: 0.2,
+            reliability: 0.2,
+            benevolence: 0.15,
+            transparency: 0.15,
+        },
+    };
+    trustConfig;
+    profileCache = new Map();
+    cacheTimeout = 5 * 60 * 1000; // 5 minutes
+    maxInteractionsInMemory = 500;
+    interactions = [];
+    rateLimits = new Map();
+    maxEvidencePerHour = 10;
+    constructor(config) {
+        super();
+        this.trustConfig = { ...DEFAULT_CONFIG, ...config };
+    }
+    async initialize(runtime) {
+        this.runtime = runtime;
+        logger.info({ trustConfig: this.trustConfig }, "[TrustEngine] Initialized with config:");
+    }
+    async stop() {
+        this.profileCache.clear();
+        logger.info("[TrustEngine] Stopped");
+    }
+    static async start(runtime) {
+        const service = new TrustEngine();
+        await service.initialize(runtime);
+        return service;
+    }
+    /**
+     * Calculate trust profile for an entity
+     */
+    async calculateTrust(subjectId, context) {
+        const cacheKey = `${context.evaluatorId}-${subjectId}`;
+        // Check cache
+        const cached = this.profileCache.get(cacheKey);
+        if (cached && Date.now() - cached.lastCalculated < this.cacheTimeout) {
+            return cached;
+        }
+        // Load evidence from components
+        const evidence = await this.loadEvidence(subjectId, context);
+        // Calculate dimensions
+        const dimensions = this.calculateDimensions(evidence);
+        // Resolve dimension weights (context-specific overrides or defaults)
+        const baseWeights = this.trustConfig.dimensionWeights;
+        const overrides = context.action
+            ? TrustEngine.ACTION_CONTEXT_WEIGHTS[context.action]
+            : undefined;
+        const activeWeights = overrides
+            ? {
+                reliability: overrides.reliability ?? baseWeights.reliability,
+                competence: overrides.competence ?? baseWeights.competence,
+                integrity: overrides.integrity ?? baseWeights.integrity,
+                benevolence: overrides.benevolence ?? baseWeights.benevolence,
+                transparency: overrides.transparency ?? baseWeights.transparency,
+            }
+            : baseWeights;
+        // Calculate overall trust with resolved weights
+        const overallTrust = this.calculateOverallTrust(dimensions, activeWeights);
+        // Calculate confidence
+        const confidence = this.calculateConfidence(evidence);
+        // Analyze trend
+        const trend = await this.analyzeTrend(subjectId, context, overallTrust);
+        const profile = {
+            entityId: subjectId,
+            dimensions,
+            overallTrust,
+            confidence,
+            interactionCount: evidence.length,
+            evidence: evidence.slice(0, 100), // Keep most recent 100
+            lastCalculated: Date.now(),
+            calculationMethod: "dimensional_aggregation_v1",
+            trend,
+            evaluatorId: context.evaluatorId,
+        };
+        // Save to cache and storage
+        this.profileCache.set(cacheKey, profile);
+        await this.saveTrustProfile(profile, context);
+        return profile;
+    }
+    /**
+     * Records a trust interaction
+     */
+    async recordInteraction(interaction) {
+        // Rate limit check
+        const rateCheck = this.checkRateLimit(interaction.targetEntityId, interaction.type);
+        if (!rateCheck.allowed) {
+            logger.warn({ entityId: interaction.targetEntityId, type: interaction.type }, "[TrustEngine] Rate limit exceeded, skipping interaction recording");
+            return;
+        }
+        // Apply diminishing returns weight to impact
+        if (rateCheck.weight < 1.0) {
+            interaction.impact = interaction.impact * rateCheck.weight;
+        }
+        this.interactions.push(interaction);
+        // Trim in-memory interactions to prevent unbounded growth
+        if (this.interactions.length > this.maxInteractionsInMemory) {
+            this.interactions = this.interactions.slice(-this.maxInteractionsInMemory);
+        }
+        // Invalidate cache entries for the affected entity
+        for (const key of this.profileCache.keys()) {
+            if (key.endsWith(`-${interaction.targetEntityId}`)) {
+                this.profileCache.delete(key);
+            }
+        }
+        logger.info({
+            type: interaction.type,
+            impact: interaction.impact,
+            source: interaction.sourceEntityId,
+            target: interaction.targetEntityId,
+        }, "[TrustEngine] Recorded interaction:");
+        // Persist to database
+        try {
+            const db = getDb(this.runtime);
+            await insertTrustEvidence(db, {
+                targetEntityId: interaction.targetEntityId,
+                sourceEntityId: interaction.sourceEntityId,
+                evaluatorId: interaction.context?.evaluatorId || this.runtime.agentId,
+                type: interaction.type,
+                impact: interaction.impact,
+                weight: rateCheck.weight,
+                description: interaction.details?.description || "",
+                verified: true,
+                context: (interaction.context ?? {}),
+            });
+        }
+        catch (err) {
+            logger.warn({ error: err }, "[TrustEngine] Failed to persist trust evidence to DB");
+        }
+    }
+    /**
+     * Evaluate if an action is allowed based on trust
+     */
+    async evaluateTrustDecision(entityId, requirements, context) {
+        const profile = await this.calculateTrust(entityId, context);
+        // Check overall trust
+        if (profile.overallTrust < requirements.minimumTrust) {
+            return {
+                allowed: false,
+                trustScore: profile.overallTrust,
+                requiredScore: requirements.minimumTrust,
+                dimensionsChecked: profile.dimensions,
+                reason: `Trust score ${profile.overallTrust} is below required ${requirements.minimumTrust}`,
+                suggestions: this.generateTrustBuildingSuggestions(profile, requirements),
+            };
+        }
+        // Check specific dimensions
+        if (requirements.dimensions) {
+            for (const [dimension, required] of Object.entries(requirements.dimensions)) {
+                const actual = profile.dimensions[dimension];
+                if (actual < required) {
+                    return {
+                        allowed: false,
+                        trustScore: profile.overallTrust,
+                        requiredScore: requirements.minimumTrust,
+                        dimensionsChecked: requirements.dimensions,
+                        reason: `${dimension} score ${actual} is below required ${required}`,
+                        suggestions: this.generateDimensionSuggestions(dimension),
+                    };
+                }
+            }
+        }
+        // Check interaction count
+        if (requirements.minimumInteractions &&
+            profile.interactionCount < requirements.minimumInteractions) {
+            return {
+                allowed: false,
+                trustScore: profile.overallTrust,
+                requiredScore: requirements.minimumTrust,
+                dimensionsChecked: profile.dimensions,
+                reason: `Insufficient interactions: ${profile.interactionCount} < ${requirements.minimumInteractions}`,
+                suggestions: ["Engage in more interactions to build history"],
+            };
+        }
+        // Check confidence
+        if (requirements.minimumConfidence &&
+            profile.confidence < requirements.minimumConfidence) {
+            return {
+                allowed: false,
+                trustScore: profile.overallTrust,
+                requiredScore: requirements.minimumTrust,
+                dimensionsChecked: profile.dimensions,
+                reason: `Trust confidence ${profile.confidence} is below required ${requirements.minimumConfidence}`,
+                suggestions: [
+                    "More consistent interactions needed to increase confidence",
+                ],
+            };
+        }
+        return {
+            allowed: true,
+            trustScore: profile.overallTrust,
+            requiredScore: requirements.minimumTrust,
+            dimensionsChecked: profile.dimensions,
+            reason: "All trust requirements met",
+        };
+    }
+    /**
+     * Check rate limiting for evidence recording
+     */
+    static DIMINISHING_WEIGHTS = [1.0, 0.75, 0.5, 0.25];
+    checkRateLimit(entityId, evidenceType) {
+        const now = Date.now();
+        const hourMs = 60 * 60 * 1000;
+        let entry = this.rateLimits.get(entityId);
+        if (!entry) {
+            entry = { count: 0, windowStart: now, typeHistory: new Map() };
+            this.rateLimits.set(entityId, entry);
+        }
+        // Reset window if more than 1 hour has passed
+        if (now - entry.windowStart > hourMs) {
+            entry.count = 0;
+            entry.windowStart = now;
+            entry.typeHistory.clear();
+            // Prune stale entries from other entities while we're here
+            for (const [key, val] of this.rateLimits) {
+                if (now - val.windowStart > hourMs * 2)
+                    this.rateLimits.delete(key);
+            }
+        }
+        if (entry.count >= this.maxEvidencePerHour) {
+            return { allowed: false, weight: 0 };
+        }
+        // Diminishing returns: 1st occurrence = 1.0, 2nd = 0.75, 3rd = 0.5, 4th+ = 0.25
+        const typeCount = entry.typeHistory.get(evidenceType) ?? 0;
+        const weight = TrustEngine.DIMINISHING_WEIGHTS[Math.min(typeCount, TrustEngine.DIMINISHING_WEIGHTS.length - 1)];
+        entry.count++;
+        entry.typeHistory.set(evidenceType, typeCount + 1);
+        return { allowed: true, weight };
+    }
+    /**
+     * Calculate trust dimensions from evidence
+     */
+    calculateDimensions(evidence) {
+        const dimensions = {
+            reliability: 50,
+            competence: 50,
+            integrity: 50,
+            benevolence: 50,
+            transparency: 50,
+        };
+        for (const ev of evidence) {
+            const impact = EVIDENCE_IMPACT_MAP[ev.type];
+            if (!impact)
+                continue;
+            // Apply age weight
+            const ageWeight = this.calculateAgeWeight(ev.timestamp);
+            // Apply verification multiplier
+            const verificationMultiplier = ev.verified
+                ? this.trustConfig.verificationMultiplier
+                : 1.0;
+            // Update dimensions
+            for (const [dimension, value] of Object.entries(impact.dimensions)) {
+                const adjustedValue = value * ev.weight * ageWeight * verificationMultiplier;
+                dimensions[dimension] = Math.max(0, Math.min(100, dimensions[dimension] + adjustedValue));
+            }
+        }
+        return dimensions;
+    }
+    /**
+     * Calculate overall trust score from dimensions
+     */
+    calculateOverallTrust(dimensions, weights = this.trustConfig
+        .dimensionWeights) {
+        let weightedSum = 0;
+        let totalWeight = 0;
+        for (const [dimension, value] of Object.entries(dimensions)) {
+            const weight = weights[dimension];
+            weightedSum += value * weight;
+            totalWeight += weight;
+        }
+        return Math.round(weightedSum / totalWeight);
+    }
+    /**
+     * Calculate confidence based on evidence quantity and consistency
+     */
+    calculateConfidence(evidence) {
+        if (evidence.length < this.trustConfig.minimumEvidenceCount) {
+            return 0;
+        }
+        // Base confidence from evidence count
+        const countConfidence = Math.min(1, evidence.length / 20);
+        // Consistency factor - how consistent is the evidence?
+        const positiveCount = evidence.filter((e) => e.impact > 0).length;
+        const negativeCount = evidence.filter((e) => e.impact < 0).length;
+        const consistency = 1 - Math.abs(positiveCount - negativeCount) / evidence.length;
+        // Recency factor - how recent is the evidence?
+        const recentEvidence = evidence.filter((e) => Date.now() - e.timestamp < 7 * 24 * 60 * 60 * 1000);
+        const recencyFactor = recentEvidence.length / evidence.length;
+        return countConfidence * 0.4 + consistency * 0.3 + recencyFactor * 0.3;
+    }
+    /**
+     * Calculate age weight for evidence based on recency
+     */
+    calculateAgeWeight(timestamp) {
+        const ageInDays = (Date.now() - timestamp) / (24 * 60 * 60 * 1000);
+        const decayFactor = Math.exp(-this.trustConfig.evidenceDecayRate * ageInDays);
+        // Blend with recency bias
+        return (this.trustConfig.recencyBias * decayFactor +
+            (1 - this.trustConfig.recencyBias) * 0.5);
+    }
+    /**
+     * Analyze trust trend over time
+     */
+    async analyzeTrend(entityId, context, currentScore) {
+        // Load historical trust scores
+        const components = await this.runtime.getComponents(entityId);
+        const historicalProfiles = components
+            .filter((c) => c.type === "trust_profile" && c.agentId === context.evaluatorId)
+            .map((c) => c.data)
+            .sort((a, b) => b.lastCalculated - a.lastCalculated)
+            .slice(0, 10);
+        if (historicalProfiles.length < 2) {
+            return {
+                direction: "stable",
+                changeRate: 0,
+                lastChangeAt: Date.now(),
+            };
+        }
+        // Calculate trend
+        const previousScore = historicalProfiles[0].overallTrust;
+        const oldestScore = historicalProfiles[historicalProfiles.length - 1].overallTrust;
+        const timeSpanDays = (Date.now() -
+            historicalProfiles[historicalProfiles.length - 1].lastCalculated) /
+            (24 * 60 * 60 * 1000);
+        const changeRate = (currentScore - oldestScore) / timeSpanDays;
+        let direction;
+        if (Math.abs(changeRate) < 0.5) {
+            direction = "stable";
+        }
+        else if (changeRate > 0) {
+            direction = "increasing";
+        }
+        else {
+            direction = "decreasing";
+        }
+        return {
+            direction,
+            changeRate: Math.round(changeRate * 10) / 10,
+            lastChangeAt: currentScore !== previousScore
+                ? Date.now()
+                : historicalProfiles[0].trend?.lastChangeAt || Date.now(),
+        };
+    }
+    /**
+     * Load evidence from storage
+     */
+    async loadEvidence(entityId, context) {
+        const components = await this.runtime.getComponents(entityId);
+        const evidenceComponents = components.filter((c) => c.type === "trust_evidence" &&
+            (!context.worldId || c.worldId === context.worldId) &&
+            (!context.roomId || c.roomId === context.roomId));
+        const evidence = [];
+        for (const component of evidenceComponents) {
+            const ev = component.data;
+            // Apply time window filter
+            if (context.timeWindow) {
+                if (ev.timestamp < context.timeWindow.start ||
+                    ev.timestamp > context.timeWindow.end) {
+                    continue;
+                }
+            }
+            evidence.push(ev);
+        }
+        // Also load from DB and merge (deduplicate by timestamp+type)
+        try {
+            const db = getDb(this.runtime);
+            const dbRows = await getTrustEvidence(db, entityId, context.evaluatorId);
+            const existingKeys = new Set(evidence.map((e) => `${e.timestamp}-${e.type}`));
+            for (const row of dbRows) {
+                const rowTimestamp = row.timestamp instanceof Date
+                    ? row.timestamp.getTime()
+                    : row.timestamp;
+                const key = `${rowTimestamp}-${row.type}`;
+                if (!existingKeys.has(key)) {
+                    evidence.push({
+                        type: row.type,
+                        timestamp: rowTimestamp,
+                        impact: row.impact,
+                        weight: row.weight ?? 1.0,
+                        description: row.description ?? "",
+                        reportedBy: row.sourceEntityId,
+                        targetEntityId: row.targetEntityId,
+                        verified: row.verified ?? false,
+                        context: row.context ?? {
+                            evaluatorId: context.evaluatorId,
+                        },
+                        evaluatorId: row.evaluatorId ?? context.evaluatorId,
+                    });
+                    existingKeys.add(key);
+                }
+            }
+        }
+        catch (err) {
+            logger.warn({ error: err }, "[TrustEngine] Failed to load trust evidence from DB");
+        }
+        return evidence.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /**
+     * Save trust profile to storage
+     */
+    async saveTrustProfile(profile, context) {
+        const componentId = stringToUuid(`trust-profile-${profile.entityId}-${context.evaluatorId}`);
+        const worldId = context.worldId || stringToUuid("trust-world");
+        await this.runtime.ensureWorldExists({
+            id: worldId,
+            name: "trust-world",
+            agentId: this.runtime.agentId,
+            messageServerId: stringToUuid("default"),
+            metadata: {},
+        });
+        // Check if component already exists
+        const existingComponent = await this.runtime.getComponent(profile.entityId, "trust_profile", worldId, context.evaluatorId);
+        const component = {
+            id: componentId,
+            type: "trust_profile",
+            agentId: context.evaluatorId,
+            entityId: profile.entityId,
+            roomId: context.roomId || stringToUuid("trust-global"),
+            worldId,
+            sourceEntityId: context.evaluatorId,
+            data: profile,
+            createdAt: existingComponent?.createdAt || Date.now(),
+        };
+        if (existingComponent) {
+            // Update existing component
+            await this.runtime.updateComponent(component);
+        }
+        else {
+            // Create new component
+            await this.runtime.createComponent(component);
+        }
+    }
+    /**
+     * Generate suggestions for building trust
+     */
+    generateTrustBuildingSuggestions(profile, requirements) {
+        const suggestions = [];
+        // Overall trust suggestions
+        if (profile.overallTrust < requirements.minimumTrust) {
+            const gap = requirements.minimumTrust - profile.overallTrust;
+            suggestions.push(`Build ${gap} more trust points through positive interactions`);
+        }
+        // Dimension-specific suggestions
+        const weakestDimension = Object.entries(profile.dimensions).sort(([, a], [, b]) => a - b)[0][0];
+        suggestions.push(...this.generateDimensionSuggestions(weakestDimension));
+        // Interaction count suggestions
+        if (profile.interactionCount < 10) {
+            suggestions.push("Engage in more conversations and activities");
+        }
+        return suggestions;
+    }
+    /**
+     * Generate suggestions for improving specific dimensions
+     */
+    generateDimensionSuggestions(dimension) {
+        const suggestions = {
+            reliability: [
+                "Keep your promises and commitments",
+                "Be consistent in your actions",
+                "Follow through on what you say",
+            ],
+            competence: [
+                "Demonstrate your skills through helpful contributions",
+                "Share valuable knowledge or resources",
+                "Complete tasks successfully",
+            ],
+            integrity: [
+                "Be honest and transparent in your communications",
+                "Admit mistakes when they happen",
+                "Follow community guidelines consistently",
+            ],
+            benevolence: [
+                "Help other community members",
+                "Show genuine interest in others' wellbeing",
+                "Contribute positively to discussions",
+            ],
+            transparency: [
+                "Be open about your intentions",
+                "Share information freely when appropriate",
+                "Verify your identity on multiple platforms",
+            ],
+        };
+        return (suggestions[dimension] || [
+            "Continue building trust through positive interactions",
+        ]);
+    }
+    /**
+     * Evaluates trust for an entity (simplified API for actions)
+     */
+    async evaluateTrust(entityId, evaluatorId, context) {
+        const fullContext = {
+            evaluatorId,
+            ...context,
+        };
+        return this.calculateTrust(entityId, fullContext);
+    }
+    /**
+     * Get recent trust interactions for an entity
+     * @param daysBack Number of days to look back (default: 10)
+     */
+    async getRecentInteractions(entityId, daysBack = 10) {
+        const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1000;
+        return this.interactions.filter((i) => (i.sourceEntityId === entityId || i.targetEntityId === entityId) &&
+            i.timestamp > cutoff);
+    }
+}

package/packages/typescript/src/features/trust/services/adminContext.d.ts

@@ -0,0 +1,3 @@
+import { type IAgentRuntime, type Memory, type State } from "../../../types/index.ts";
+export declare function resolveAdminContext(runtime: IAgentRuntime, message: Memory, state?: State): Promise<boolean>;
+//# sourceMappingURL=adminContext.d.ts.map

package/packages/typescript/src/features/trust/services/adminContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adminContext.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/services/adminContext.ts"],"names":[],"mappings":"AACA,OAAO,EAEN,KAAK,aAAa,EAClB,KAAK,MAAM,EAEX,KAAK,KAAK,EAEV,MAAM,yBAAyB,CAAC;AAEjC,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK,GACX,OAAO,CAAC,OAAO,CAAC,CAqClB"}

package/packages/typescript/src/features/trust/services/adminContext.js

@@ -0,0 +1,32 @@
+import { createUniqueUuid } from "../../../entities.js";
+import { ChannelType, Role, } from "../../../types/index.js";
+export async function resolveAdminContext(runtime, message, state) {
+    const ownerEntityId = runtime.getSetting("OWNER_ENTITY_ID");
+    if (ownerEntityId && message.entityId === ownerEntityId) {
+        return true;
+    }
+    const room = state?.data?.room ?? (await runtime.getRoom?.(message.roomId));
+    if (!room) {
+        return false;
+    }
+    // In direct user<->agent chats, the requester is trusted-admin context.
+    if (room.type === ChannelType.DM) {
+        return true;
+    }
+    if (room.type !== ChannelType.GROUP) {
+        return false;
+    }
+    const configuredWorldId = runtime.getSetting("WORLD_ID");
+    const worldId = (typeof room.worldId === "string" && room.worldId) ||
+        (typeof configuredWorldId === "string" && configuredWorldId) ||
+        (room.messageServerId
+            ? createUniqueUuid(runtime, room.messageServerId)
+            : undefined);
+    if (!worldId) {
+        return false;
+    }
+    const world = await runtime.getWorld(worldId);
+    const roles = world?.metadata?.roles ?? {};
+    const role = roles[message.entityId];
+    return role === Role.ADMIN || role === Role.OWNER;
+}

package/packages/typescript/src/features/trust/services/db.d.ts

@@ -0,0 +1,12 @@
+import type { IAgentRuntime } from "../../../types/index.ts";
+/**
+ * Minimal Drizzle-compatible DB interface.
+ * Uses a chainable query builder pattern matching drizzle-orm.
+ */
+export type DrizzleDB = Record<string, (...args: unknown[]) => any>;
+/**
+ * Get the Drizzle database instance from the runtime.
+ * @throws if the database is unavailable.
+ */
+export declare function getDb(runtime: IAgentRuntime): DrizzleDB;
+//# sourceMappingURL=db.d.ts.map

package/packages/typescript/src/features/trust/services/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/services/db.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;GAGG;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,GAAG,CAAC,CAAC;AAEpE;;;GAGG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,CAIvD"}

package/packages/typescript/src/features/trust/services/db.js

@@ -0,0 +1,10 @@
+/**
+ * Get the Drizzle database instance from the runtime.
+ * @throws if the database is unavailable.
+ */
+export function getDb(runtime) {
+    const db = runtime.db;
+    if (!db)
+        throw new Error("[plugin-trust] Database not available");
+    return db;
+}