agent-inspect 6.31.21 → 6.31.23

package/packages/core/dist/checks.cjs

@@ -1704,6 +1704,84 @@ function evaluateToolArgumentValue(value, check, evidencePresent) {
   };
 }
 
+// packages/core/src/persisted/delivery-identity.ts
+var DELIVERY_CONFLICT_ATTR = "agent_inspect.delivery_conflict";
+var DELIVERY_EVENT_BASE_ATTR = "agent_inspect.delivery_event_base";
+var IDENTITY_CONFLICT_ATTR = {
+  /** Comma-separated field names when a conflict survives lossy bounding. */
+  fields: "agent_inspect.identity_conflict.fields"
+};
+var MAX_CONFLICT_FIELDS = 8;
+var MAX_DELIVERY_BASE_LEN = 500;
+function stripReaderDeliveryDiscriminator(eventId, attributes) {
+  if (!eventId) return eventId;
+  const rawBase = attributes?.[DELIVERY_EVENT_BASE_ATTR];
+  if (typeof rawBase !== "string" || rawBase.trim() === "") return eventId;
+  const base = rawBase.trim().slice(0, MAX_DELIVERY_BASE_LEN);
+  if (eventId === base) return base;
+  const prefix = `${base}:`;
+  if (!eventId.startsWith(prefix)) return eventId;
+  const suffix = eventId.slice(prefix.length);
+  if (/^\d+$/.test(suffix)) return base;
+  return eventId;
+}
+function canonicalDigest(value) {
+  if (value === void 0) return null;
+  const encoded = encodeCanonicalStructured(value);
+  return encoded.ok ? encoded.value : `unencodable:${encoded.code}`;
+}
+function capturedContentDigest(attributes) {
+  if (!attributes || typeof attributes !== "object") {
+    return { args: null, result: null };
+  }
+  const nested = attributes.metadata && typeof attributes.metadata === "object" ? attributes.metadata : void 0;
+  const args = attributes.arguments ?? attributes.args ?? attributes.input ?? nested?.arguments ?? nested?.args ?? nested?.input;
+  const result = attributes.result ?? attributes.output ?? attributes.response ?? nested?.result ?? nested?.output ?? nested?.response;
+  return {
+    args: args === void 0 ? null : canonicalDigest(args),
+    result: result === void 0 ? null : canonicalDigest(result)
+  };
+}
+function timeKey(fields) {
+  if (typeof fields.startedAt === "string" && fields.startedAt.trim() !== "") {
+    return fields.startedAt;
+  }
+  if (typeof fields.timestamp === "string" && fields.timestamp.trim() !== "") {
+    return fields.timestamp;
+  }
+  if (typeof fields.timestamp === "number" && Number.isFinite(fields.timestamp)) {
+    return String(fields.timestamp);
+  }
+  return null;
+}
+function deliverySemanticFingerprint(fields) {
+  const content = capturedContentDigest(fields.attributes);
+  return JSON.stringify({
+    stableEventId: stripReaderDeliveryDiscriminator(fields.eventId, fields.attributes),
+    runId: fields.runId,
+    kind: fields.kind,
+    name: fields.name,
+    status: fields.status ?? null,
+    parentId: fields.parentId ?? null,
+    sourceType: fields.sourceType ?? null,
+    time: timeKey(fields),
+    operationId: fields.operationId ?? null,
+    attemptId: fields.attemptId ?? null,
+    attemptNumber: fields.attemptNumber ?? null,
+    retryOf: fields.retryOf ?? null,
+    argsDigest: content.args,
+    resultDigest: content.result
+  });
+}
+function identityConflictFieldsFromAttributes(attributes) {
+  const raw = attributes?.[IDENTITY_CONFLICT_ATTR.fields];
+  if (typeof raw !== "string" || raw.trim() === "") return [];
+  return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0).slice(0, MAX_CONFLICT_FIELDS);
+}
+function hasDeliveryConflictMarker(attributes) {
+  return attributes?.[DELIVERY_CONFLICT_ATTR] === true;
+}
+
 // packages/core/src/checks/retry-safety.ts
 function fail2(ruleId, message, evidence, expected, actual) {
   return {
@@ -1759,7 +1837,7 @@ function attemptIdOf(event) {
 }
 function countOperationAttempts(members) {
   const identified = /* @__PURE__ */ new Set();
-  let unidentified = 0;
+  const unidentifiedFingerprints = /* @__PURE__ */ new Set();
   for (const event of members) {
     if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
     const id = attemptIdOf(event);
@@ -1767,13 +1845,13 @@ function countOperationAttempts(members) {
       identified.add(id);
       continue;
     }
-    unidentified += 1;
+    unidentifiedFingerprints.add(redeliveryFingerprint(event));
   }
   if (identified.size > 0) {
-    return identified.size + unidentified;
+    return identified.size + unidentifiedFingerprints.size;
   }
   const numbered = /* @__PURE__ */ new Set();
-  let unnumbered = 0;
+  const unnumberedFingerprints = /* @__PURE__ */ new Set();
   for (const event of members) {
     if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
     const num = attemptNumberOf(event);
@@ -1781,12 +1859,12 @@ function countOperationAttempts(members) {
       numbered.add(num);
       continue;
     }
-    unnumbered += 1;
+    unnumberedFingerprints.add(redeliveryFingerprint(event));
   }
   if (numbered.size > 0) {
-    return numbered.size + unnumbered;
+    return numbered.size + unnumberedFingerprints.size;
   }
-  return unnumbered;
+  return unnumberedFingerprints.size;
 }
 function classifyRetryAttempt(event, priorOrdered, allMembers) {
   const workflow = workflowFor(event);
@@ -1838,19 +1916,55 @@ function classifyRetryAttempt(event, priorOrdered, allMembers) {
 }
 function redeliveryFingerprint(event) {
   const workflow = workflowFor(event);
-  const stableEventId = (event.eventId ?? "").replace(/:\d+$/, "");
-  return JSON.stringify({
-    stableEventId,
+  return deliverySemanticFingerprint({
+    eventId: event.eventId ?? "",
     runId: event.runId,
     kind: event.kind,
     name: event.name,
     status: event.status,
+    parentId: event.parentId,
+    timestamp: event.timestamp,
+    startedAt: event.startedAt,
+    sourceType: event.source?.type,
+    attributes: event.attributes && typeof event.attributes === "object" ? event.attributes : void 0,
     operationId: workflow.operationId ?? null,
     attemptId: workflow.attemptId ?? null,
     attemptNumber: workflow.attemptNumber ?? null,
     retryOf: workflow.retryOf ?? null
   });
 }
+var IDENTITY_KEYS = ["operationId", "attemptId", "retryOf", "attemptNumber"];
+function identityValuesEqual(a, b) {
+  if (typeof a === "number" && typeof b === "number") {
+    return Number.isFinite(a) && Number.isFinite(b) && a === b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.trim() === b.trim();
+  }
+  return a === b;
+}
+function directNestedIdentityConflicts(event) {
+  const attrs2 = event.attributes;
+  if (!attrs2 || typeof attrs2 !== "object") return [];
+  const nested = attrs2.metadata && typeof attrs2.metadata === "object" && !Array.isArray(attrs2.metadata) ? attrs2.metadata : void 0;
+  const conflicts = [];
+  if (nested) {
+    for (const key of IDENTITY_KEYS) {
+      const direct = attrs2[key];
+      const nestedValue = nested[key];
+      if (direct === void 0 || nestedValue === void 0) continue;
+      if (!identityValuesEqual(direct, nestedValue)) {
+        conflicts.push(key);
+      }
+    }
+  }
+  for (const key of identityConflictFieldsFromAttributes(attrs2)) {
+    if (IDENTITY_KEYS.includes(key) && !conflicts.includes(key)) {
+      conflicts.push(key);
+    }
+  }
+  return conflicts;
+}
 function hasConflictingAttemptIdReuse(members) {
   const byAttempt = /* @__PURE__ */ new Map();
   for (const event of members) {
@@ -1866,6 +1980,31 @@ function hasConflictingAttemptIdReuse(members) {
   }
   return false;
 }
+function hasConflictingEventIdReuse(members) {
+  const byEventId = /* @__PURE__ */ new Map();
+  for (const event of members) {
+    if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
+    const eventId = event.eventId;
+    if (!eventId) continue;
+    if (hasDeliveryConflictMarker(event.attributes)) {
+      return true;
+    }
+    const fingerprints = byEventId.get(eventId) ?? /* @__PURE__ */ new Set();
+    fingerprints.add(redeliveryFingerprint(event));
+    byEventId.set(eventId, fingerprints);
+  }
+  for (const fingerprints of byEventId.values()) {
+    if (fingerprints.size > 1) return true;
+  }
+  return false;
+}
+function hasIdentityRepresentationConflict(members) {
+  for (const event of members) {
+    if (event.kind !== "TOOL" && event.kind !== "LLM") continue;
+    if (directNestedIdentityConflicts(event).length > 0) return true;
+  }
+  return false;
+}
 function evaluateRetrySafetyRules(events, rules, _runEvidence) {
   const findings = [];
   const byOperation = /* @__PURE__ */ new Map();
@@ -1873,13 +2012,14 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     const workflow = workflowFor(event);
     const operationId = workflow.operationId;
     if (!operationId) continue;
-    const list = byOperation.get(operationId) ?? [];
-    list.push(event);
-    byOperation.set(operationId, list);
+    const key = `${event.runId}\0${operationId}`;
+    const group = byOperation.get(key) ?? { operationId, members: [] };
+    group.members.push(event);
+    byOperation.set(key, group);
   }
   if (rules.maxAttempts !== void 0) {
-    for (const [operationId, members] of byOperation) {
-      if (hasConflictingAttemptIdReuse(members)) {
+    for (const { operationId, members } of byOperation.values()) {
+      if (hasConflictingAttemptIdReuse(members) || hasConflictingEventIdReuse(members)) {
         findings.push(
           fail2(
             "contract.retry.duplicate-attempt-id",
@@ -1890,6 +2030,31 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
           )
         );
       }
+      if (hasIdentityRepresentationConflict(members)) {
+        findings.push(
+          fail2(
+            "contract.retry.ambiguous-identity",
+            `Operation ${operationId} has conflicting direct vs nested identity fields; strict identity cannot pass.`,
+            members.slice(0, 4).map(eventEvidence),
+            "agreeing identity representation",
+            "direct/nested conflict"
+          )
+        );
+      }
+      const toolish = members.filter((event) => event.kind === "TOOL" || event.kind === "LLM");
+      const hasAttemptId = toolish.some((event) => attemptIdOf(event) !== void 0);
+      const missingAttemptId = toolish.some((event) => attemptIdOf(event) === void 0);
+      if (hasAttemptId && missingAttemptId) {
+        findings.push(
+          fail2(
+            "contract.retry.ambiguous-identity",
+            `Operation ${operationId} has partial attempt identity; strict identity conformance cannot pass.`,
+            members.slice(0, 4).map(eventEvidence),
+            "complete attempt identity",
+            "partial attemptId coverage"
+          )
+        );
+      }
       const count = countOperationAttempts(members);
       if (count > rules.maxAttempts) {
         findings.push(
@@ -1905,7 +2070,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     }
   }
   if (rules.requireTerminalResult) {
-    for (const [operationId, members] of byOperation) {
+    for (const { operationId, members } of byOperation.values()) {
       const hasTerminal = members.some((event) => event.status === "ok" || event.status === "error");
       if (!hasTerminal) {
         findings.push(
@@ -1925,7 +2090,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
       const workflow = workflowFor(event);
       const fallbackOf = workflow.fallbackOf;
       if (!fallbackOf) continue;
-      const prior = byOperation.get(fallbackOf) ?? [];
+      const prior = byOperation.get(`${event.runId}\0${fallbackOf}`)?.members ?? [];
       const fallbackStart = eventTime(event);
       const earlierFailure = prior.some(
         (candidate) => candidate.status === "error" && eventTime(candidate) !== "" && fallbackStart !== "" && eventTime(candidate) < fallbackStart
@@ -1952,7 +2117,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     for (const event of toolEvents) {
       const name = resolveCanonicalToolName(event);
       const workflow = workflowFor(event);
-      const key = `${workflow.operationId ?? name}::${name}`;
+      const key = `${event.runId}::${workflow.operationId ?? name}::${name}`;
       const list = byToolOp.get(key) ?? [];
       list.push(event);
       byToolOp.set(key, list);
@@ -2010,7 +2175,7 @@ function evaluateRetrySafetyRules(events, rules, _runEvidence) {
     }
   }
   if (rules.requireRecoveredFailureVisible) {
-    for (const [operationId, members] of byOperation) {
+    for (const { operationId, members } of byOperation.values()) {
       const ordered = sortByTime(members);
       const toolish = ordered.filter(
         (event) => (event.kind === "TOOL" || event.kind === "LLM") && (event.status === "ok" || event.status === "error")
@@ -2269,14 +2434,7 @@ function attemptIdOf2(event) {
   return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
 }
 function hasDuplicateAttemptIds(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;
+  return hasConflictingAttemptIdReuse(members) || hasConflictingEventIdReuse(members);
 }
 function findRetryTarget(members, retryOf) {
   return members.find(