mark-improving-agent 2.2.8 → 2.2.9

package/VERSION

@@ -1 +1 @@
-2.2.8
+2.2.9

package/dist/core/collaboration/index.js

@@ -3,3 +3,4 @@ export * from './agentic-loop.js';
 export * from './multi-agent-system.js';
 export { createMCPProtocol } from './mcp-protocol.js';
 export { createPeerReviewSystem } from './peer-review.js';
+export { createTrustScorer, TrustScorer } from './trust-scorer.js';

package/dist/core/collaboration/trust-scorer.js

@@ -0,0 +1,374 @@
+/**
+ * Multi-Agent Trust Scoring System
+ *
+ * Provides trust and quality scoring for AI agents based on their
+ * task performance, peer reviews, and capability assessments.
+ * Includes EU AI Act compliance metrics.
+ *
+ * @module collaboration/trust-scorer
+ * @fileoverview Trust scoring system for multi-agent collaboration
+ */
+import { createLogger } from '../../utils/logger.js';
+import { createPeerReviewSystem } from './peer-review.js';
+const logger = createLogger('[TrustScorer]');
+/**
+ * Trust score level based on numeric score
+ */
+export var TrustLevel;
+(function (TrustLevel) {
+    TrustLevel["UNTRUSTED"] = "untrusted";
+    TrustLevel["LOW"] = "low";
+    TrustLevel["MEDIUM"] = "medium";
+    TrustLevel["HIGH"] = "high";
+    TrustLevel["TRUSTED"] = "trusted";
+})(TrustLevel || (TrustLevel = {}));
+/**
+ * EU AI Act risk categories
+ */
+export var AIActRiskCategory;
+(function (AIActRiskCategory) {
+    AIActRiskCategory["UNacceptable_Risk"] = "unacceptable-risk";
+    AIActRiskCategory["HIGH_RISK"] = "high-risk";
+    AIActRiskCategory["LIMITED_RISK"] = "limited-risk";
+    AIActRiskCategory["MINIMAL_RISK"] = "minimal-risk";
+})(AIActRiskCategory || (AIActRiskCategory = {}));
+/**
+ * Trust Scorer class
+ */
+export class TrustScorer {
+    config;
+    agentProfiles = new Map();
+    scoringEvents = [];
+    peerReviewSystem;
+    constructor(config = {}) {
+        this.config = {
+            minTasksForTrustScore: config.minTasksForTrustScore ?? 5,
+            taskSuccessWeight: config.taskSuccessWeight ?? 0.4,
+            peerReviewWeight: config.peerReviewWeight ?? 0.35,
+            capabilityWeight: config.capabilityWeight ?? 0.25,
+            decayRatePerDay: config.decayRatePerDay ?? 0.01,
+            trustLevelThresholds: config.trustLevelThresholds ?? {
+                untrusted: 0,
+                low: 20,
+                medium: 40,
+                high: 70,
+                trusted: 85
+            }
+        };
+        this.peerReviewSystem = createPeerReviewSystem({
+            consensusThreshold: 0.6,
+            requiredReviewers: 3,
+            enableArbitration: false
+        });
+        logger.info('TrustScorer initialized', this.config);
+    }
+    /**
+     * Register a new agent in the trust system
+     */
+    registerAgent(agentId, agentName) {
+        const profile = {
+            agentId,
+            agentName,
+            trustScore: 50, // Start with neutral score
+            trustLevel: TrustLevel.MEDIUM,
+            successfulTasks: 0,
+            failedTasks: 0,
+            successRate: 0,
+            avgPeerScore: 0.5,
+            reviewCount: 0,
+            capabilities: new Map(),
+            aiActCategory: AIActRiskCategory.MINIMAL_RISK,
+            registeredAt: Date.now(),
+            lastActivityAt: Date.now(),
+            isActive: true
+        };
+        this.agentProfiles.set(agentId, profile);
+        logger.info(`Agent registered: ${agentId} (${agentName})`);
+        return profile;
+    }
+    /**
+     * Record a task outcome for an agent
+     */
+    recordTaskOutcome(agentId, taskId, success, metadata) {
+        const profile = this.getOrCreateProfile(agentId);
+        if (success) {
+            profile.successfulTasks++;
+        }
+        else {
+            profile.failedTasks++;
+        }
+        profile.lastActivityAt = Date.now();
+        profile.successRate = profile.successfulTasks / (profile.successfulTasks + profile.failedTasks);
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: success ? 'task_success' : 'task_failure',
+            timestamp: Date.now(),
+            referenceId: taskId,
+            scoreDelta: success ? 1 : -1,
+            metadata
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Task outcome recorded: ${agentId} - ${taskId} - ${success ? 'SUCCESS' : 'FAILURE'}`);
+    }
+    /**
+     * Record a peer review for an agent
+     */
+    recordPeerReview(agentId, reviewId, score, // 0-1
+    reviewerId) {
+        const profile = this.getOrCreateProfile(agentId);
+        const totalScore = profile.avgPeerScore * profile.reviewCount + score;
+        profile.reviewCount++;
+        profile.avgPeerScore = totalScore / profile.reviewCount;
+        profile.lastActivityAt = Date.now();
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: 'peer_review',
+            timestamp: Date.now(),
+            referenceId: reviewId,
+            scoreDelta: score - 0.5,
+            metadata: { reviewerId }
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Peer review recorded: ${agentId} - Review: ${reviewerId} - Score: ${score.toFixed(2)}`);
+    }
+    /**
+     * Update capability quality score for an agent
+     */
+    updateCapabilityScore(agentId, capability, qualityScore, assessmentCount = 1) {
+        const profile = this.getOrCreateProfile(agentId);
+        const existing = profile.capabilities.get(capability);
+        const newScore = existing
+            ? {
+                capability,
+                qualityScore: (existing.qualityScore * existing.assessmentCount + qualityScore) / (existing.assessmentCount + assessmentCount),
+                assessmentCount: existing.assessmentCount + assessmentCount,
+                lastUpdated: Date.now(),
+                trend: qualityScore > existing.qualityScore ? 'positive' : qualityScore < existing.qualityScore ? 'negative' : 'stable'
+            }
+            : {
+                capability,
+                qualityScore,
+                assessmentCount,
+                lastUpdated: Date.now(),
+                trend: 'stable'
+            };
+        profile.capabilities.set(capability, newScore);
+        profile.lastActivityAt = Date.now();
+        const event = {
+            eventId: `evt_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            agentId,
+            eventType: 'capability_assessment',
+            timestamp: Date.now(),
+            metadata: { capability, qualityScore }
+        };
+        this.scoringEvents.push(event);
+        this.recalculateTrustScore(agentId);
+        logger.info(`Capability updated: ${agentId} - ${capability}: ${qualityScore}`);
+    }
+    /**
+     * Set EU AI Act risk category for an agent
+     */
+    setAIActCategory(agentId, category) {
+        const profile = this.getOrCreateProfile(agentId);
+        profile.aiActCategory = category;
+        logger.info(`AI Act category set: ${agentId} - ${category}`);
+    }
+    /**
+     * Get trust scoring result for an agent
+     */
+    getTrustScore(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile) {
+            return null;
+        }
+        const recentEvents = this.scoringEvents
+            .filter(e => e.agentId === agentId)
+            .slice(-10);
+        const breakdown = this.calculateScoreBreakdown(profile);
+        return {
+            profile: { ...profile, capabilities: new Map(profile.capabilities) },
+            recentEvents,
+            breakdown
+        };
+    }
+    /**
+     * Get trust level from numeric score
+     */
+    getTrustLevel(score) {
+        const { trustLevelThresholds } = this.config;
+        if (score >= trustLevelThresholds.trusted)
+            return TrustLevel.TRUSTED;
+        if (score >= trustLevelThresholds.high)
+            return TrustLevel.HIGH;
+        if (score >= trustLevelThresholds.medium)
+            return TrustLevel.MEDIUM;
+        if (score >= trustLevelThresholds.low)
+            return TrustLevel.LOW;
+        return TrustLevel.UNTRUSTED;
+    }
+    /**
+     * Get or create agent profile
+     */
+    getOrCreateProfile(agentId) {
+        let profile = this.agentProfiles.get(agentId);
+        if (!profile) {
+            profile = this.registerAgent(agentId, agentId);
+        }
+        return profile;
+    }
+    /**
+     * Recalculate trust score for an agent
+     */
+    recalculateTrustScore(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return;
+        const breakdown = this.calculateScoreBreakdown(profile);
+        profile.trustScore = Math.max(0, Math.min(100, Math.round(breakdown.finalScore)));
+        profile.trustLevel = this.getTrustLevel(profile.trustScore);
+    }
+    /**
+     * Calculate score breakdown for an agent
+     */
+    calculateScoreBreakdown(profile) {
+        const totalTasks = profile.successfulTasks + profile.failedTasks;
+        // Task success score (requires minimum tasks)
+        let taskScore = 50;
+        if (totalTasks >= this.config.minTasksForTrustScore) {
+            taskScore = profile.successRate * 100;
+        }
+        // Peer review score (already 0-1, scale to 0-100)
+        const peerReviewScore = profile.avgPeerScore * 100;
+        // Capability score
+        let capabilityScore = 50;
+        if (profile.capabilities.size > 0) {
+            const totalCapabilityScore = Array.from(profile.capabilities.values())
+                .reduce((sum, cap) => sum + cap.qualityScore, 0);
+            capabilityScore = totalCapabilityScore / profile.capabilities.size;
+        }
+        // Calculate weighted final score
+        const weightedScore = (taskScore * this.config.taskSuccessWeight +
+            peerReviewScore * this.config.peerReviewWeight +
+            capabilityScore * this.config.capabilityWeight);
+        // Apply decay for inactivity
+        const daysInactive = (Date.now() - profile.lastActivityAt) / (1000 * 60 * 60 * 24);
+        const decayPenalty = Math.min(30, daysInactive * this.config.decayRatePerDay * 100);
+        const finalScore = Math.max(0, weightedScore - decayPenalty);
+        return {
+            taskScore: Math.round(taskScore * 100) / 100,
+            peerReviewScore: Math.round(peerReviewScore * 100) / 100,
+            capabilityScore: Math.round(capabilityScore * 100) / 100,
+            decayPenalty: Math.round(decayPenalty * 100) / 100,
+            finalScore: Math.round(finalScore * 100) / 100
+        };
+    }
+    /**
+     * Get all registered agents sorted by trust score
+     */
+    getAllAgents() {
+        return Array.from(this.agentProfiles.values())
+            .sort((a, b) => b.trustScore - a.trustScore);
+    }
+    /**
+     * Get agents by trust level
+     */
+    getAgentsByLevel(level) {
+        return Array.from(this.agentProfiles.values())
+            .filter(p => p.trustLevel === level);
+    }
+    /**
+     * Get high-risk agents (EU AI Act)
+     */
+    getHighRiskAgents() {
+        return Array.from(this.agentProfiles.values())
+            .filter(p => p.aiActCategory === AIActRiskCategory.HIGH_RISK ||
+            p.aiActCategory === AIActRiskCategory.UNacceptable_Risk);
+    }
+    /**
+     * Check if agent meets trust threshold for a task
+     */
+    meetsTrustThreshold(agentId, minTrustLevel) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return false;
+        const levels = [
+            TrustLevel.UNTRUSTED,
+            TrustLevel.LOW,
+            TrustLevel.MEDIUM,
+            TrustLevel.HIGH,
+            TrustLevel.TRUSTED
+        ];
+        return levels.indexOf(profile.trustLevel) >= levels.indexOf(minTrustLevel);
+    }
+    /**
+     * Get scoring events for an agent
+     */
+    getEvents(agentId, limit = 50) {
+        return this.scoringEvents
+            .filter(e => e.agentId === agentId)
+            .slice(-limit);
+    }
+    /**
+     * Get system statistics
+     */
+    getSystemStats() {
+        const profiles = Array.from(this.agentProfiles.values());
+        const avgTrustScore = profiles.length > 0
+            ? profiles.reduce((sum, p) => sum + p.trustScore, 0) / profiles.length
+            : 0;
+        const agentsByLevel = {
+            [TrustLevel.UNTRUSTED]: 0,
+            [TrustLevel.LOW]: 0,
+            [TrustLevel.MEDIUM]: 0,
+            [TrustLevel.HIGH]: 0,
+            [TrustLevel.TRUSTED]: 0
+        };
+        profiles.forEach(p => agentsByLevel[p.trustLevel]++);
+        return {
+            totalAgents: profiles.length,
+            avgTrustScore: Math.round(avgTrustScore * 100) / 100,
+            agentsByLevel,
+            highRiskCount: this.getHighRiskAgents().length,
+            totalEvents: this.scoringEvents.length
+        };
+    }
+    /**
+     * Export profile data for compliance
+     */
+    exportForCompliance(agentId) {
+        const profile = this.agentProfiles.get(agentId);
+        if (!profile)
+            return null;
+        return {
+            agentId: profile.agentId,
+            agentName: profile.agentName,
+            trustScore: profile.trustScore,
+            trustLevel: profile.trustLevel,
+            aiActCategory: profile.aiActCategory,
+            capabilities: Array.from(profile.capabilities.entries()).map(([cap, score]) => ({
+                capability: cap,
+                qualityScore: score.qualityScore,
+                assessmentCount: score.assessmentCount,
+                trend: score.trend
+            })),
+            registeredAt: new Date(profile.registeredAt).toISOString(),
+            lastActivityAt: new Date(profile.lastActivityAt).toISOString(),
+            complianceCheck: {
+                hasRequiredAssessments: profile.reviewCount >= 3,
+                meetsMinimumTrust: profile.trustScore >= 40,
+                highRiskClassification: profile.aiActCategory === AIActRiskCategory.HIGH_RISK
+            }
+        };
+    }
+}
+/**
+ * Create a trust scoring system instance
+ */
+export function createTrustScorer(config) {
+    logger.info('Creating TrustScorer instance');
+    return new TrustScorer(config);
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.2.8';
+export const VERSION = '2.2.9';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.2.8",
+  "version": "2.2.9",
   "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
   "type": "module",
   "main": "./dist/index.js",