agentcheck-sdk 1.0.1 → 2.0.0

package/dist/trust.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Trust Engine - Agent trust scoring and outcome tracking.
+ *
+ * Tier: Atom (single responsibility: compute and track agent trust scores)
+ *
+ * Computes a trust score (0.0 to 1.0) per agent based on execution history.
+ * The score drives dynamic layer routing in LayerRouter.
+ *
+ * Score formula:
+ *   score = successRate * ageFactor * violationPenalty
+ *
+ * Where:
+ *   - successRate: fraction of successes in the last 100 outcomes
+ *   - ageFactor: min(1.0, historySize / 20) - new agents get lower trust
+ *   - violationPenalty: 0.9 ^ violationCount
+ *
+ * Tier assignment:
+ *   - "high":   score >= highThreshold (default 0.8)
+ *   - "medium": lowThreshold <= score < highThreshold
+ *   - "low":    score < lowThreshold (default 0.5)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustEngine = void 0;
+const HISTORY_WINDOW = 100;
+class TrustEngine {
+    constructor(highThreshold = 0.8, lowThreshold = 0.5) {
+        /**
+         * Compute and track trust scores for agents.
+         *
+         * Maintains per-agent execution history and recomputes scores after
+         * each recorded outcome. New agents receive a default medium-trust
+         * score until enough history accumulates.
+         *
+         * Usage:
+         *   const engine = new TrustEngine();
+         *   engine.recordOutcome("bot-001", true);
+         *   const score = engine.getScore("bot-001");
+         *   // TrustScore { agentId: "bot-001", score: 0.05, tier: "low", ... }
+         */
+        this.scores = new Map();
+        this.history = new Map();
+        this.violations = new Map();
+        this.high = highThreshold;
+        this.low = lowThreshold;
+    }
+    /**
+     * Return the current trust score for an agent.
+     *
+     * If the agent has no recorded history, returns a default medium-trust
+     * score with a score value halfway between the two thresholds.
+     *
+     * @param agentId - The agent identifier.
+     * @returns TrustScore with score, tier, and diagnostic factors.
+     */
+    getScore(agentId) {
+        const cached = this.scores.get(agentId);
+        if (cached)
+            return cached;
+        const defaultScore = (this.high + this.low) / 2.0;
+        return {
+            agentId,
+            score: defaultScore,
+            tier: "medium",
+            factors: { historySize: 0, note: "no history - default medium" },
+        };
+    }
+    /**
+     * Record one execution outcome and recompute the trust score.
+     *
+     * @param agentId - The agent identifier.
+     * @param success - True if the execution completed without error or
+     *   violation, false otherwise.
+     * @param details - Optional details. When details.violation is true,
+     *   the violation counter increments.
+     */
+    recordOutcome(agentId, success, details) {
+        // Update history (keep last HISTORY_WINDOW outcomes)
+        const hist = this.history.get(agentId) ?? [];
+        hist.push(success);
+        if (hist.length > HISTORY_WINDOW)
+            hist.shift();
+        this.history.set(agentId, hist);
+        // Track violations separately from plain failures
+        if (details?.violation) {
+            this.violations.set(agentId, (this.violations.get(agentId) ?? 0) + 1);
+        }
+        // Recompute and cache
+        const score = this.computeScore(agentId);
+        const tier = this.scoreToTier(score);
+        const histLen = hist.length;
+        const violationCount = this.violations.get(agentId) ?? 0;
+        this.scores.set(agentId, {
+            agentId,
+            score: Math.round(score * 10000) / 10000,
+            tier,
+            factors: {
+                successRate: Math.round((hist.filter(Boolean).length / histLen) * 10000) / 10000,
+                historySize: histLen,
+                violationCount,
+                ageFactor: Math.round(Math.min(1.0, histLen / 20.0) * 10000) / 10000,
+            },
+        });
+    }
+    /**
+     * Reset all trust data for an agent.
+     *
+     * Removes history, violation count, and cached score so the agent
+     * reverts to default medium trust on the next call to getScore().
+     *
+     * @param agentId - The agent identifier.
+     */
+    reset(agentId) {
+        this.history.delete(agentId);
+        this.violations.delete(agentId);
+        this.scores.delete(agentId);
+    }
+    /**
+     * Return the cached scores for all tracked agents.
+     *
+     * @returns Map of agentId to TrustScore. Only includes agents with at
+     *   least one recorded outcome.
+     */
+    allScores() {
+        return new Map(this.scores);
+    }
+    // -- Private helpers --
+    computeScore(agentId) {
+        const hist = this.history.get(agentId);
+        if (!hist || hist.length === 0)
+            return (this.high + this.low) / 2.0;
+        const successRate = hist.filter(Boolean).length / hist.length;
+        const ageFactor = Math.min(1.0, hist.length / 20.0);
+        const violationCount = this.violations.get(agentId) ?? 0;
+        const violationPenalty = Math.pow(0.9, violationCount);
+        return successRate * ageFactor * violationPenalty;
+    }
+    scoreToTier(score) {
+        if (score >= this.high)
+            return "high";
+        if (score >= this.low)
+            return "medium";
+        return "low";
+    }
+}
+exports.TrustEngine = TrustEngine;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentcheck-sdk",
-  "version": "1.0.1",
-  "description": "Record what your AI agent is allowed to do",
+  "version": "2.0.0",
+  "description": "AI Agent Delegation Governance SDK - Zero Trust verification, PQC audit, dynamic safety routing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [