@agentauditai/mcp-server 0.0.0-stage → 2.0.0

package/dist/sdk/src/batch.js

@@ -0,0 +1,370 @@
+"use strict";
+// AgentAudit AI — Batch anchoring
+// Buffers action_refs (docs/EVIDENCE_SCHEMA.md) and anchors them on-chain as a
+// single Merkle root via AuditVault v2 commitBatch.
+// EU AI Act: Art. 12 (record-keeping), Art. 19 (log retention)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchBuffer = exports.FileBatchStore = exports.MemoryBatchStore = exports.EVIDENCE_SCHEMA = void 0;
+exports.canonicalize = canonicalize;
+exports.sha256Hex = sha256Hex;
+exports.computeActionRef = computeActionRef;
+exports.encodeScopeSegment = encodeScopeSegment;
+exports.toolCallScope = toolCallScope;
+exports.dataReadScope = dataReadScope;
+exports.llmCallScope = llmCallScope;
+exports.llmDecisionPreimage = llmDecisionPreimage;
+exports.hashPair = hashPair;
+exports.buildMerkleLevels = buildMerkleLevels;
+exports.merkleRoot = merkleRoot;
+exports.merkleProof = merkleProof;
+exports.verifyMerkleProof = verifyMerkleProof;
+exports.resolveBatchBuffer = resolveBatchBuffer;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const ethers_1 = require("ethers");
+// ─── JCS (RFC 8785) ───────────────────────────────────────────────────────────
+/**
+ * RFC 8785 JSON Canonicalization Scheme.
+ * Strings and numbers use ECMAScript JSON.stringify serialization (as RFC 8785
+ * specifies); object keys are sorted by UTF-16 code units (Array#sort default).
+ */
+function canonicalize(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error(`JCS: non-finite number ${value}`);
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return "[" + value.map(canonicalize).join(",") + "]";
+    }
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).filter((k) => obj[k] !== undefined).sort();
+        return "{" + keys.map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+    }
+    throw new Error(`JCS: unsupported type ${typeof value}`);
+}
+/** Lowercase hex SHA-256 of the UTF-8 bytes of `value`, no prefix */
+function sha256Hex(value) {
+    return (0, crypto_1.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+// ─── Evidence Schema v1 ───────────────────────────────────────────────────────
+exports.EVIDENCE_SCHEMA = "agentaudit-evidence-v1";
+/** Copy only the four preimage fields — envelope fields must never leak in */
+function pickPreimage(p) {
+    return {
+        action_type: p.action_type,
+        agent_id: p.agent_id,
+        scope: p.scope,
+        timestamp_ms: p.timestamp_ms,
+    };
+}
+/** action_ref = SHA-256(JCS(preimage)), as 0x-prefixed bytes32 hex */
+function computeActionRef(preimage) {
+    if (!Number.isSafeInteger(preimage.timestamp_ms)) {
+        throw new Error("timestamp_ms must be an integer (Unix ms)");
+    }
+    return "0x" + sha256Hex(canonicalize(pickPreimage(preimage)));
+}
+/** Percent-encode the characters that would break a scope segment */
+function encodeScopeSegment(segment) {
+    return segment.replace(/%/g, "%25").replace(/:/g, "%3A");
+}
+/** §2.1 — tool_call:<tool>:result_hash:<sha256> */
+function toolCallScope(tool, resultHash) {
+    return `tool_call:${encodeScopeSegment(tool)}:result_hash:${resultHash}`;
+}
+/** §2.2 — data_read:<endpoint>:<dataset_version>:<result_hash> */
+function dataReadScope(endpoint, datasetVersion, resultHash) {
+    return `data_read:${encodeScopeSegment(endpoint)}:${encodeScopeSegment(datasetVersion)}:${resultHash}`;
+}
+/** §2.3 — llm_call:<model>:record_hash:<sha256(JCS(record))> */
+function llmCallScope(model, record) {
+    return `llm_call:${encodeScopeSegment(model)}:record_hash:${sha256Hex(canonicalize(record))}`;
+}
+/** Preimage for an LLM decision logged by the SDK wrappers */
+function llmDecisionPreimage(agentId, model, record, timestampMs = Date.now()) {
+    return {
+        action_type: "LLM_DECISION",
+        agent_id: String(agentId),
+        scope: llmCallScope(model, record),
+        timestamp_ms: timestampMs,
+    };
+}
+// ─── Merkle tree (matches AuditVault v2 _verifyMerkle) ───────────────────────
+//
+// Leaves:  action_ref values as-is (the contract does not re-hash leaves).
+// Nodes:   keccak256(abi.encodePacked(min(a, b), max(a, b))) — sorted pairs.
+// Odd:     an unpaired last node is promoted unchanged to the next level.
+const BYTES32 = /^0x[0-9a-f]{64}$/;
+function assertBytes32(value, label) {
+    const v = value.toLowerCase();
+    if (!BYTES32.test(v))
+        throw new Error(`${label} is not a bytes32 hex string: ${value}`);
+    return v;
+}
+function hashPair(a, b) {
+    const [lo, hi] = BigInt(a) <= BigInt(b) ? [a, b] : [b, a];
+    return ethers_1.ethers.keccak256(ethers_1.ethers.concat([lo, hi]));
+}
+/** All tree levels, leaves first, root level last */
+function buildMerkleLevels(leaves) {
+    if (leaves.length === 0)
+        throw new Error("Merkle tree needs at least one leaf");
+    const levels = [leaves.map((l) => assertBytes32(l, "leaf"))];
+    while (levels[levels.length - 1].length > 1) {
+        const cur = levels[levels.length - 1];
+        const next = [];
+        for (let i = 0; i < cur.length; i += 2) {
+            next.push(i + 1 < cur.length ? hashPair(cur[i], cur[i + 1]) : cur[i]);
+        }
+        levels.push(next);
+    }
+    return levels;
+}
+function merkleRoot(leaves) {
+    const levels = buildMerkleLevels(leaves);
+    return levels[levels.length - 1][0];
+}
+/** Sibling path for leaf `index`; levels where the node was promoted are skipped */
+function merkleProof(levels, index) {
+    if (index < 0 || index >= levels[0].length)
+        throw new Error(`leaf index ${index} out of range`);
+    const proof = [];
+    let idx = index;
+    for (let l = 0; l < levels.length - 1; l++) {
+        const sibling = idx ^ 1;
+        if (sibling < levels[l].length)
+            proof.push(levels[l][sibling]);
+        idx >>= 1;
+    }
+    return proof;
+}
+/** Off-chain mirror of AuditVault._verifyMerkle */
+function verifyMerkleProof(leaf, proof, root) {
+    let computed = leaf.toLowerCase();
+    for (const sibling of proof)
+        computed = hashPair(computed, sibling.toLowerCase());
+    return computed === root.toLowerCase();
+}
+class MemoryBatchStore {
+    constructor() {
+        this.records = new Map();
+    }
+    async put(record) {
+        this.records.set(record.batch_id, record);
+        return `memory://${record.batch_id}`;
+    }
+    async get(batchId) {
+        return this.records.get(batchId) ?? null;
+    }
+}
+exports.MemoryBatchStore = MemoryBatchStore;
+/** Writes one JSON file per batch: <dir>/<batch_id>.json */
+class FileBatchStore {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    file(batchId) {
+        return path.resolve(this.dir, `${batchId}.json`);
+    }
+    async put(record) {
+        await fs_1.promises.mkdir(this.dir, { recursive: true });
+        const file = this.file(record.batch_id);
+        await fs_1.promises.writeFile(file, JSON.stringify(record, null, 2) + "\n", "utf8");
+        return `file://${file}`;
+    }
+    async get(batchId) {
+        try {
+            return JSON.parse(await fs_1.promises.readFile(this.file(batchId), "utf8"));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return null;
+            throw err;
+        }
+    }
+}
+exports.FileBatchStore = FileBatchStore;
+/**
+ * Collects action_refs and anchors them as one Merkle root per batch.
+ * Flushes on maxEntries, on maxAgeSeconds after the first entry, or on flush().
+ * Flushes are serialized; a failed flush re-queues its entries for retry.
+ */
+class BatchBuffer {
+    constructor(config) {
+        this.pending = [];
+        this.flushChain = Promise.resolve();
+        this.index = new Map();
+        this.batches = new Map();
+        this.committer = config.committer;
+        this.agentAddress = ethers_1.ethers.getAddress(config.agentAddress);
+        this.store = config.store ?? new MemoryBatchStore();
+        this.maxEntries = config.maxEntries ?? 50;
+        this.maxAgeMs = (config.maxAgeSeconds ?? 60) * 1000;
+        this.complianceScore = config.complianceScore ?? 0;
+        this.onError = config.onError ?? ((err) => console.error("[BatchBuffer] flush failed:", err.message));
+        if (!Number.isInteger(this.maxEntries) || this.maxEntries < 1) {
+            throw new Error("maxEntries must be a positive integer");
+        }
+        if (!(this.maxAgeMs > 0))
+            throw new Error("maxAgeSeconds must be positive");
+        if (!Number.isInteger(this.complianceScore) || this.complianceScore < 0 || this.complianceScore > 100) {
+            throw new Error("complianceScore must be an integer 0–100");
+        }
+    }
+    /** Number of entries waiting for the next flush */
+    get size() {
+        return this.pending.length;
+    }
+    /**
+     * Buffer one action. Resolves once buffered — or, if this entry fills the
+     * batch, once that flush completes (so commit errors reach the caller).
+     */
+    async add(preimage, record) {
+        const actionRef = computeActionRef(preimage);
+        this.pending.push({ action_ref: actionRef, preimage: pickPreimage(preimage), record });
+        if (this.pending.length >= this.maxEntries) {
+            await this.flush();
+        }
+        else {
+            this._armTimer();
+        }
+        return { actionRef };
+    }
+    /** Anchor everything buffered now. Resolves null if there was nothing to flush. */
+    flush() {
+        const run = this.flushChain.then(() => this._flush());
+        this.flushChain = run.catch(() => undefined);
+        return run;
+    }
+    /** Stop the timer and flush whatever is left */
+    async close() {
+        this._clearTimer();
+        return this.flush();
+    }
+    /** Proof for a committed action_ref; null if unknown or still pending */
+    getInclusionProof(actionRef) {
+        const loc = this.index.get(actionRef.toLowerCase());
+        if (!loc)
+            return null;
+        const batch = this.batches.get(loc.batchId);
+        return {
+            leaf: batch.levels[0][loc.leafIndex],
+            proof: merkleProof(batch.levels, loc.leafIndex),
+            root: loc.batchId,
+            batchId: loc.batchId,
+            batchIndex: batch.batchIndex,
+            agentAddress: this.agentAddress,
+            txHash: batch.txHash,
+        };
+    }
+    // ─── Internals ──────────────────────────────────────────────────────────────
+    async _flush() {
+        this._clearTimer();
+        if (this.pending.length === 0)
+            return null;
+        const entries = this.pending;
+        this.pending = [];
+        try {
+            const levels = buildMerkleLevels(entries.map((e) => e.action_ref));
+            const root = levels[levels.length - 1][0];
+            const record = {
+                schema: exports.EVIDENCE_SCHEMA,
+                batch_id: root,
+                agent_address: this.agentAddress,
+                merkle_root: root,
+                leaf_hash: "sha256(jcs(preimage))",
+                node_hash: "keccak256(sorted_pair)",
+                odd_node: "promote",
+                created_at_ms: Date.now(),
+                entries,
+            };
+            const contentURI = await this.store.put(record);
+            const { txHash, batchIndex } = await this.committer.commitBatch({
+                agentAddress: this.agentAddress,
+                merkleRoot: root,
+                contentURI,
+                eventCount: entries.length,
+                complianceScore: this.complianceScore,
+            });
+            this.batches.set(root, { levels, batchIndex, txHash });
+            entries.forEach((e, i) => this.index.set(e.action_ref, { batchId: root, leafIndex: i }));
+            return { batchId: root, merkleRoot: root, contentURI, eventCount: entries.length, txHash, batchIndex };
+        }
+        catch (err) {
+            // Keep the evidence: put the entries back in front of anything added meanwhile
+            this.pending = entries.concat(this.pending);
+            this._armTimer();
+            throw err;
+        }
+    }
+    _armTimer() {
+        if (this.timer)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.flush().catch((err) => this.onError(err));
+        }, this.maxAgeMs);
+        // Never keep the process alive just to flush
+        this.timer.unref?.();
+    }
+    _clearTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+}
+exports.BatchBuffer = BatchBuffer;
+/** Build (or reuse) the buffer a wrapper logs into */
+function resolveBatchBuffer(sdk, options = {}) {
+    if (options.buffer)
+        return options.buffer;
+    sdk.assertBatchAnchoring?.();
+    return new BatchBuffer({
+        committer: sdk,
+        agentAddress: options.agentAddress ?? sdk.getAddress(),
+        store: options.store,
+        maxEntries: options.maxEntries,
+        maxAgeSeconds: options.maxAgeSeconds,
+        complianceScore: options.complianceScore,
+        onError: options.onError,
+    });
+}