ai-runtime-engine 2.7.0 → 2.9.0

package/dist/security/redact.js

@@ -37,21 +37,33 @@ export function redactString(input) {
 }
 /** Deep-redact any value, returning a scrubbed clone. Non-plain objects are stringified defensively. */
 export function redact(value) {
-    return redactValue(value, new WeakSet());
+    return redactValue(value, new Set());
 }
-function redactValue(value, seen) {
+/**
+ * The `ancestors` set holds the objects on the CURRENT PATH, and each is removed on the way back out.
+ * A global visited-set would be wrong: it cannot tell a cycle from a DAG, so the second appearance of a
+ * merely SHARED object becomes the string `'[circular]'`. That is not cosmetic — a shared array turning
+ * into a string changes the shape of redacted data, and anything that then validates it (the persisted
+ * agent-task schema does) rejects the whole record. Only a genuine cycle reports `[circular]`.
+ */
+function redactValue(value, ancestors) {
     if (typeof value === 'string')
         return redactString(value);
     if (value === null || typeof value !== 'object')
         return value;
-    if (seen.has(value))
+    if (ancestors.has(value))
         return '[circular]';
-    seen.add(value);
-    if (Array.isArray(value))
-        return value.map((v) => redactValue(v, seen));
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-        out[k] = redactValue(v, seen);
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value))
+            return value.map((v) => redactValue(v, ancestors));
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = redactValue(v, ancestors);
+        }
+        return out;
+    }
+    finally {
+        ancestors.delete(value);
     }
-    return out;
 }

package/dist/util/hash.d.ts

@@ -0,0 +1,19 @@
+/**
+ * One short content hash, shared by everything that needs to ask "is this the same thing it was?".
+ *
+ * Phase 3.5 resume decisions turn on identity comparisons — is this the same agent definition, the same
+ * narrowed envelope, the same step input, the same MCP tool declaration — and each of those was about to
+ * grow its own hashing. They must agree, so there is exactly one implementation and one canonical JSON
+ * form: keys sorted at every depth, so `{a,b}` and `{b,a}` are the same object, which is the whole point
+ * when the thing being hashed came back from `JSON.parse`.
+ */
+/** 16 hex chars — the same width `checkpoint.ts` uses for file hashes. Identity, never security. */
+export declare function hash16(text: string): string;
+/**
+ * Stable JSON: object keys sorted at every depth, `undefined` dropped. Arrays keep their order (order is
+ * meaning in a plan's steps). Cycles are impossible in the persisted shapes this serves, and a stray one
+ * throws rather than hashing something arbitrary.
+ */
+export declare function canonicalJson(value: unknown): string;
+/** `hash16(canonicalJson(value))` — the form every identity check in Phase 3.5 uses. */
+export declare function hashOf(value: unknown): string;

package/dist/util/hash.js

@@ -0,0 +1,39 @@
+/**
+ * One short content hash, shared by everything that needs to ask "is this the same thing it was?".
+ *
+ * Phase 3.5 resume decisions turn on identity comparisons — is this the same agent definition, the same
+ * narrowed envelope, the same step input, the same MCP tool declaration — and each of those was about to
+ * grow its own hashing. They must agree, so there is exactly one implementation and one canonical JSON
+ * form: keys sorted at every depth, so `{a,b}` and `{b,a}` are the same object, which is the whole point
+ * when the thing being hashed came back from `JSON.parse`.
+ */
+import { createHash } from 'node:crypto';
+/** 16 hex chars — the same width `checkpoint.ts` uses for file hashes. Identity, never security. */
+export function hash16(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+/**
+ * Stable JSON: object keys sorted at every depth, `undefined` dropped. Arrays keep their order (order is
+ * meaning in a plan's steps). Cycles are impossible in the persisted shapes this serves, and a stray one
+ * throws rather than hashing something arbitrary.
+ */
+export function canonicalJson(value) {
+    const walk = (v) => {
+        if (v === null || typeof v !== 'object')
+            return v;
+        if (Array.isArray(v))
+            return v.map(walk);
+        const out = {};
+        for (const k of Object.keys(v).sort()) {
+            const child = v[k];
+            if (child !== undefined)
+                out[k] = walk(child);
+        }
+        return out;
+    };
+    return JSON.stringify(walk(value)) ?? 'null';
+}
+/** `hash16(canonicalJson(value))` — the form every identity check in Phase 3.5 uses. */
+export function hashOf(value) {
+    return hash16(canonicalJson(value));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-runtime-engine",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "AI Runtime \u2014 a provider-agnostic AI runtime and orchestration platform. Point it at whatever AI providers you have; it routes each task to the best available model. Ships the `ai-runtime` CLI and the `Runtime`/`AI` library API.",
   "type": "module",
   "license": "ISC",