agent-inspect 6.28.0 → 6.29.1

package/packages/core/dist/checks.cjs

@@ -1462,6 +1462,76 @@ function evaluateControlRules(events, rules, runEvidence2, observationNames) {
   return findings;
 }
 
+// packages/core/src/checks/canonical-equality.ts
+var DEFAULT_MAX_DEPTH = 8;
+var DEFAULT_MAX_BYTES = 16384;
+function sortKeysDeep(input, depth, maxDepth) {
+  if (depth > maxDepth) {
+    throw new Error("AI_CHECK_CANONICAL_DEPTH_EXCEEDED");
+  }
+  if (input === null || typeof input !== "object") return input;
+  if (Array.isArray(input)) {
+    return input.map((item) => sortKeysDeep(item, depth + 1, maxDepth));
+  }
+  const record = input;
+  const out = {};
+  for (const key of Object.keys(record).sort()) {
+    out[key] = sortKeysDeep(record[key], depth + 1, maxDepth);
+  }
+  return out;
+}
+function encodeCanonicalStructured(value, limits) {
+  const maxDepth = DEFAULT_MAX_DEPTH;
+  const maxBytes = DEFAULT_MAX_BYTES;
+  try {
+    const sorted = sortKeysDeep(value, 0, maxDepth);
+    const encoded = JSON.stringify(sorted);
+    if (encoded === void 0) {
+      return {
+        ok: false,
+        reason: "Value is not JSON-serializable for canonical comparison.",
+        code: "AI_CHECK_CANONICAL_UNSERIALIZABLE"
+      };
+    }
+    if (Buffer.byteLength(encoded, "utf8") > maxBytes) {
+      return {
+        ok: false,
+        reason: "Canonical structured value exceeds bounded size limit.",
+        code: "AI_CHECK_CANONICAL_SIZE_EXCEEDED"
+      };
+    }
+    return { ok: true, value: encoded };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message === "AI_CHECK_CANONICAL_DEPTH_EXCEEDED") {
+      return {
+        ok: false,
+        reason: "Canonical structured value exceeds bounded depth limit.",
+        code: "AI_CHECK_CANONICAL_DEPTH_EXCEEDED"
+      };
+    }
+    return {
+      ok: false,
+      reason: "Canonical structured encoding failed.",
+      code: "AI_CHECK_CANONICAL_UNSERIALIZABLE"
+    };
+  }
+}
+function canonicalStructuredEqual(left, right, limits) {
+  const a = encodeCanonicalStructured(left);
+  if (!a.ok) return { equal: false, reason: a.reason, code: a.code };
+  const b = encodeCanonicalStructured(right);
+  if (!b.ok) return { equal: false, reason: b.reason, code: b.code };
+  if (a.value !== b.value) {
+    return {
+      equal: false,
+      reason: "Canonical structured values differ.",
+      code: "AI_CHECK_CANONICAL_NOT_EQUAL"
+    };
+  }
+  return { equal: true };
+}
+
 // packages/core/src/checks/tool-arguments.ts
 function decodeToken(token) {
   return token.replace(/~1/g, "/").replace(/~0/g, "~");
@@ -1507,7 +1577,7 @@ function jsonType(value) {
   return typeof value;
 }
 function valuesEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
+  return canonicalStructuredEqual(left, right).equal === true;
 }
 function extractToolArgumentPayload(event) {
   const attrs2 = event.attributes ?? {};
@@ -1980,11 +2050,9 @@ function argumentDigestOf(event) {
 function argumentFingerprint(event) {
   const payload = extractToolArgumentPayload(event);
   if (payload.present) {
-    try {
-      return { kind: "structured", value: JSON.stringify(payload.value) };
-    } catch {
-      return { kind: "missing" };
-    }
+    const encoded = encodeCanonicalStructured(payload.value);
+    if (!encoded.ok) return { kind: "missing" };
+    return { kind: "structured", value: encoded.value };
   }
   const digest = argumentDigestOf(event);
   if (digest) return { kind: "digest", value: digest };
@@ -2079,19 +2147,84 @@ function llmReferencesTool(llm, toolEvent, requireExplicit) {
   if (toolCallId && refs.has(toolCallId)) return true;
   return false;
 }
+function attemptIdOf2(event) {
+  const value = workflowFor2(event).attemptId;
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function hasDuplicateAttemptIds2(members) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of members) {
+    const id = attemptIdOf2(event);
+    if (!id) continue;
+    if (seen.has(id)) return true;
+    seen.add(id);
+  }
+  return false;
+}
+function findRetryTarget(members, retryOf) {
+  return members.find(
+    (candidate) => candidate.eventId === retryOf || attemptIdOf2(candidate) === retryOf || workflowFor2(candidate).operationId === retryOf
+  );
+}
 function groupToolAttempts(events, toolName2) {
+  const members = events.filter(
+    (event) => event.kind === "TOOL" && resolveCanonicalToolName(event) === toolName2
+  );
+  const parent = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    if (!parent.has(id)) parent.set(id, id);
+    return id;
+  };
+  const find = (id) => {
+    ensure(id);
+    let cur = id;
+    while (parent.get(cur) !== cur) {
+      cur = parent.get(cur);
+    }
+    let walk = id;
+    while (parent.get(walk) !== cur) {
+      const next = parent.get(walk);
+      parent.set(walk, cur);
+      walk = next;
+    }
+    return cur;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const nodeId = (event) => {
+    const operationId = workflowFor2(event).operationId;
+    if (typeof operationId === "string" && operationId.trim() !== "") {
+      return `op:${operationId.trim()}`;
+    }
+    return `event:${event.eventId}`;
+  };
+  for (const event of members) {
+    ensure(nodeId(event));
+  }
+  for (const event of members) {
+    const retryOf = workflowFor2(event).retryOf;
+    if (typeof retryOf !== "string" || retryOf.trim() === "") continue;
+    const target = findRetryTarget(members, retryOf.trim());
+    if (target) {
+      union(nodeId(event), nodeId(target));
+    }
+  }
   const groups = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (event.kind !== "TOOL") continue;
-    if (resolveCanonicalToolName(event) !== toolName2) continue;
-    const workflow = workflowFor2(event);
-    const key = workflow.operationId ?? `__tool__:${toolName2}`;
+  for (const event of members) {
+    const key = find(nodeId(event));
     const list = groups.get(key) ?? [];
     list.push(event);
     groups.set(key, list);
   }
   return groups;
 }
+function latestAttempt(ordered) {
+  if (ordered.length === 0) return void 0;
+  return ordered[ordered.length - 1];
+}
 function evaluateRecoveryOperations(events, operations) {
   const findings = [];
   const llmEvents = events.filter((event) => event.kind === "LLM");
@@ -2114,6 +2247,17 @@ function evaluateRecoveryOperations(events, operations) {
     }
     for (const [operationKey, members] of groups) {
       const ordered = sortByTime2(members);
+      if (hasDuplicateAttemptIds2(members)) {
+        findings.push(
+          fail3(
+            "contract.retry.operations.duplicate-attempt-id",
+            `Tool ${operation.tool} operation ${operationKey} has duplicate attemptId values.`,
+            members.slice(0, 4).map(eventEvidence2),
+            "unique attemptId",
+            "duplicate"
+          )
+        );
+      }
       if (operation.maxAttempts !== void 0) {
         const count = countOperationAttempts(members);
         if (count > operation.maxAttempts) {
@@ -2150,8 +2294,21 @@ function evaluateRecoveryOperations(events, operations) {
       let sawEarlierError = false;
       let sawLaterOkAfterError = false;
       let lastOk;
+      let identityUnavailable = false;
       for (const event of ordered) {
         const classification = classifyRetryAttempt(event, prior, members);
+        if (classification.kind === "unknown") {
+          identityUnavailable = true;
+          findings.push(
+            fail3(
+              "contract.retry.operations.attempt-identity",
+              `Tool ${operation.tool} operation ${operationKey} has ambiguous attempt identity (${classification.reason}).`,
+              [eventEvidence2(event)],
+              "explicit operationId/attemptId/retryOf chronology",
+              { code: "AI_CHECK_RECOVERY_ATTEMPT_IDENTITY_UNAVAILABLE", reason: classification.reason }
+            )
+          );
+        }
         const isRetry = classification.kind === "retry";
         if (isRetry && operation.requireFailureBeforeRetry) {
           const earlierFailure = prior.some(
@@ -2186,6 +2343,16 @@ function evaluateRecoveryOperations(events, operations) {
                 )
               );
             }
+          } else {
+            findings.push(
+              fail3(
+                "contract.retry.operations.retryable-error",
+                `Retry of tool ${operation.tool} has no prior error code evidence.`,
+                [eventEvidence2(event)],
+                [...allowed],
+                null
+              )
+            );
           }
         }
         if (isRetry && (operation.requireSameArguments === true || operation.requireSameArguments === "structured-or-digest")) {
@@ -2203,6 +2370,16 @@ function evaluateRecoveryOperations(events, operations) {
                 )
               );
             }
+          } else {
+            findings.push(
+              fail3(
+                "contract.retry.operations.same-arguments",
+                "Structured or digest argument evidence unavailable for same-arguments check.",
+                [eventEvidence2(event)],
+                "matching structured args or digests",
+                { code: "AI_CHECK_RECOVERY_ARGUMENT_EVIDENCE_UNAVAILABLE" }
+              )
+            );
           }
         }
         if (event.status === "error") {
@@ -2215,23 +2392,23 @@ function evaluateRecoveryOperations(events, operations) {
         }
         prior.push(event);
       }
+      const latest = latestAttempt(ordered);
       if (operation.requireTerminalSuccess) {
-        const hasOk = ordered.some((event) => event.status === "ok");
-        if (!hasOk) {
+        if (!latest || latest.status !== "ok") {
           findings.push(
             fail3(
               "contract.retry.operations.terminal-success",
-              `Tool ${operation.tool} operation ${operationKey} has no terminal ok success.`,
+              `Tool ${operation.tool} operation ${operationKey} does not terminate with ok on the latest attempt.`,
               ordered.slice(0, 4).map(eventEvidence2),
-              "ok",
-              ordered.map((event) => event.status)
+              "latest attempt ok",
+              latest?.status ?? "missing"
             )
           );
         }
       }
       if (operation.requireRecoveredFailureVisible) {
-        const hasOk = ordered.some((event) => event.status === "ok");
-        if (ordered.length > 1 && hasOk && !sawLaterOkAfterError) {
+        const latestOk = latest?.status === "ok";
+        if (ordered.length > 1 && latestOk && !sawLaterOkAfterError) {
           findings.push(
             fail3(
               "contract.retry.operations.recovered-failure-visible",
@@ -2244,21 +2421,36 @@ function evaluateRecoveryOperations(events, operations) {
         }
       }
       const dependency = operation.successfulResultDependency;
-      if (dependency?.consumerKind === "LLM" && lastOk) {
-        const requireExplicit = dependency.requireExplicitReference === true;
-        const referenced = llmEvents.some(
-          (llmEvent) => llmReferencesTool(llmEvent, lastOk, requireExplicit)
-        );
-        if (!referenced) {
-          findings.push(
-            fail3(
-              "contract.retry.operations.successful-result-dependency",
-              requireExplicit ? `Successful ${operation.tool} result is not explicitly referenced by a later LLM event.` : `Successful ${operation.tool} result has no later LLM consumer.`,
-              [eventEvidence2(lastOk)],
-              "LLM reference to successful tool event",
-              { code: "AI_CHECK_RECOVERY_RESULT_DEPENDENCY_MISSING" }
-            )
-          );
+      if (dependency?.consumerKind === "LLM") {
+        const successForDependency = latest?.status === "ok" ? latest : identityUnavailable ? void 0 : lastOk;
+        if (successForDependency) {
+          if (sideEffectClass === "write" && isUnevaluableWriteCompletion(successForDependency) && !hasIdempotencyEvidence2(successForDependency)) {
+            findings.push(
+              fail3(
+                "contract.retry.operations.successful-result-dependency",
+                `Successful ${operation.tool} result dependency is unevaluable because write completion evidence is unavailable.`,
+                [eventEvidence2(successForDependency)],
+                "LLM reference to successful tool event",
+                { code: "AI_CHECK_RECOVERY_WRITE_COMPLETION_UNAVAILABLE" }
+              )
+            );
+          } else {
+            const requireExplicit = dependency.requireExplicitReference === true;
+            const referenced = llmEvents.some(
+              (llmEvent) => llmReferencesTool(llmEvent, successForDependency, requireExplicit)
+            );
+            if (!referenced) {
+              findings.push(
+                fail3(
+                  "contract.retry.operations.successful-result-dependency",
+                  requireExplicit ? `Successful ${operation.tool} result is not explicitly referenced by a later LLM event.` : `Successful ${operation.tool} result has no later LLM consumer.`,
+                  [eventEvidence2(successForDependency)],
+                  "LLM reference to successful tool event",
+                  { code: "AI_CHECK_RECOVERY_RESULT_DEPENDENCY_MISSING" }
+                )
+              );
+            }
+          }
         }
       }
     }
@@ -3332,6 +3524,9 @@ var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
   "output",
   "total",
   "cached",
+  "cachewrite",
+  "cache_write",
+  "reasoning",
   "input_tokens",
   "inputtokens",
   "output_tokens",
@@ -3341,7 +3536,13 @@ var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
   "prompt_tokens",
   "prompttokens",
   "completion_tokens",
-  "completiontokens"
+  "completiontokens",
+  "cache_read",
+  "cacheread",
+  "cache_creation",
+  "cachecreation",
+  "reasoning_tokens",
+  "reasoningtokens"
 ]);
 var DEFAULT_SECRET_PATTERNS = [
   { id: "bearer-token", pattern: /Bearer\s+[A-Za-z0-9._~+/-]{12,}=*/ },