@agent-inspect/mcp-server 6.20.0 → 6.22.0

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { runReadOnlyMcpServer } from './chunk-4FSMUSWK.mjs';
+import { runReadOnlyMcpServer } from './chunk-URVZD6JW.mjs';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';

package/dist/index.cjs

@@ -482,16 +482,16 @@ function pickRunMetadata(attributes) {
   return Object.keys(metadata).length > 0 ? metadata : void 0;
 }
 function resolveStepId(event) {
-  const attrs = event.attributes;
-  if (attrs && typeof attrs.stepId === "string" && attrs.stepId.trim() !== "") {
-    return attrs.stepId;
+  const attrs2 = event.attributes;
+  if (attrs2 && typeof attrs2.stepId === "string" && attrs2.stepId.trim() !== "") {
+    return attrs2.stepId;
   }
   return event.eventId;
 }
 function resolveStepType(event) {
-  const attrs = event.attributes;
-  if (attrs && typeof attrs.stepType === "string") {
-    const t = attrs.stepType;
+  const attrs2 = event.attributes;
+  if (attrs2 && typeof attrs2.stepType === "string") {
+    const t = attrs2.stepType;
     if (t === "run" || t === "llm" || t === "tool" || t === "decision" || t === "logic" || t === "state" || t === "custom") {
       return t;
     }
@@ -572,26 +572,26 @@ function fromLegacyStepCompleted(event) {
   return out;
 }
 function fromLegacyOutcomeObserved(event) {
-  const attrs = event.attributes ?? {};
-  const observedAtRaw = attrs.observedAt;
+  const attrs2 = event.attributes ?? {};
+  const observedAtRaw = attrs2.observedAt;
   const observedAt = typeof observedAtRaw === "string" ? Date.parse(observedAtRaw) : typeof observedAtRaw === "number" && Number.isFinite(observedAtRaw) ? observedAtRaw : resolveTimes(event).timestamp;
-  const status = attrs.outcomeStatus;
+  const status = attrs2.outcomeStatus;
   const out = {
     schemaVersion: "0.1",
     event: "outcome_observed",
     timestamp: observedAt,
     runId: event.runId,
-    outcomeId: typeof attrs.outcomeId === "string" ? attrs.outcomeId : event.eventId,
+    outcomeId: typeof attrs2.outcomeId === "string" ? attrs2.outcomeId : event.eventId,
     name: event.name,
-    expectation: typeof attrs.expectation === "string" ? attrs.expectation : event.name,
+    expectation: typeof attrs2.expectation === "string" ? attrs2.expectation : event.name,
     status: status === "passed" || status === "failed" || status === "unknown" || status === "skipped" ? status : "unknown",
     observedAt
   };
   if (event.parentId !== void 0) out.parentId = event.parentId;
-  if (typeof attrs.method === "string") out.method = attrs.method;
-  if (attrs.actual !== void 0) out.actual = attrs.actual;
+  if (typeof attrs2.method === "string") out.method = attrs2.method;
+  if (attrs2.actual !== void 0) out.actual = attrs2.actual;
   if (event.outputSummary !== void 0) out.actual = event.outputSummary;
-  if (attrs.evidence !== void 0) out.evidence = attrs.evidence;
+  if (attrs2.evidence !== void 0) out.evidence = attrs2.evidence;
   return out;
 }
 function fromNativeOutcome(event) {
@@ -976,6 +976,17 @@ var OBSERVED_OUTCOME_STATUSES = [
   "unknown",
   "skipped"
 ];
+var OBSERVED_OUTCOME_METHODS = [
+  "dom",
+  "accessibility",
+  "snapshot",
+  "network",
+  "storage",
+  "filesystem",
+  "database",
+  "queue",
+  "custom"
+];
 var OUTCOME_LEGACY_EVENT = "outcome_observed";
 
 // packages/core/src/outcomes/validate.ts
@@ -1988,6 +1999,63 @@ async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
   return metas;
 }
 
+// packages/core/src/sessions/metadata.ts
+function isNonEmptyString3(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function finitePositiveInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    return void 0;
+  }
+  return Math.trunc(value);
+}
+function extractSessionWorkflowMetadata(record) {
+  if (!record) return void 0;
+  const out = {};
+  let found = false;
+  const assignString = (key, value) => {
+    if (isNonEmptyString3(value)) {
+      out[key] = value.trim();
+      found = true;
+    }
+  };
+  assignString("sessionId", record.sessionId);
+  assignString("conversationId", record.conversationId);
+  assignString("groupId", record.groupId);
+  assignString("parentGroupId", record.parentGroupId);
+  assignString("retryOf", record.retryOf);
+  assignString("retryReason", record.retryReason);
+  assignString("handoffFrom", record.handoffFrom);
+  assignString("handoffTo", record.handoffTo);
+  assignString("subAgentId", record.subAgentId);
+  assignString("subAgentName", record.subAgentName);
+  assignString("jobId", record.jobId);
+  assignString("queueName", record.queueName);
+  assignString("workflowName", record.workflowName);
+  assignString("workflowStep", record.workflowStep);
+  assignString("toolCallId", record.toolCallId);
+  assignString("mcpToolCallId", record.mcpToolCallId);
+  assignString("linkedStepId", record.linkedStepId);
+  assignString("operationId", record.operationId);
+  assignString("attemptId", record.attemptId);
+  assignString("fallbackOf", record.fallbackOf);
+  assignString("idempotencyKey", record.idempotencyKey);
+  assignString("correlationId", record.correlationId);
+  assignString("requestId", record.requestId);
+  assignString("decisionId", record.decisionId);
+  const attempt = finitePositiveInt(record.attempt);
+  if (attempt !== void 0) {
+    out.attempt = attempt;
+    found = true;
+  }
+  const attemptNumber = finitePositiveInt(record.attemptNumber);
+  if (attemptNumber !== void 0) {
+    out.attemptNumber = attemptNumber;
+    found = true;
+  }
+  return found ? out : void 0;
+}
+
 // packages/core/src/bundle/safety-status.ts
 function aggregateBundleSafeStatus(statuses) {
   if (statuses.length === 0) return "UNKNOWN";
@@ -2200,17 +2268,17 @@ function stableJson(value, pretty) {
   const sorted = sortKeysDeep(value);
   return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
 }
-function compactAttributes(attrs, options) {
-  if (attrs === void 0) return {};
+function compactAttributes(attrs2, options) {
+  if (attrs2 === void 0) return {};
   const maxLen = options?.maxLength ?? 500;
   const redacted = options?.redacted ?? true;
   const out = {};
-  for (const key of Object.keys(attrs).sort()) {
+  for (const key of Object.keys(attrs2).sort()) {
     if (redacted && shouldRedactKey(key)) {
       out[key] = "[REDACTED]";
       continue;
     }
-    const v = attrs[key];
+    const v = attrs2[key];
     out[key] = compactValue(v, maxLen, redacted);
   }
   return out;
@@ -3021,10 +3089,10 @@ function projectLogicalEvents(events) {
   };
 }
 function resolveCanonicalToolName(event) {
-  const attrs = event.attributes;
-  const direct = pickString(attrs, ["toolName", "tool"]);
+  const attrs2 = event.attributes;
+  const direct = pickString(attrs2, ["toolName", "tool"]);
   if (direct) return direct;
-  const metadata = attrs?.metadata;
+  const metadata = attrs2?.metadata;
   if (isRecord6(metadata)) {
     const nested = pickString(metadata, ["toolName", "tool"]);
     if (nested) return nested;
@@ -3066,10 +3134,10 @@ function pickNumber(record, keys) {
   return void 0;
 }
 function eventMetadata(event) {
-  const attrs = isRecord7(event.attributes) ? event.attributes : void 0;
-  const nested = attrs !== void 0 && isRecord7(attrs.metadata) ? attrs.metadata : void 0;
+  const attrs2 = isRecord7(event.attributes) ? event.attributes : void 0;
+  const nested = attrs2 !== void 0 && isRecord7(attrs2.metadata) ? attrs2.metadata : void 0;
   return {
-    ...attrs ?? {},
+    ...attrs2 ?? {},
     ...nested ?? {}
   };
 }
@@ -3362,6 +3430,151 @@ function deriveFailureFacts(logicalEvents) {
   };
 }
 
+// packages/core/src/checks/relationship-facts.ts
+function attrs(event) {
+  return event.attributes && typeof event.attributes === "object" ? event.attributes : {};
+}
+function stringAttr(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function deriveRelationshipFacts(events) {
+  const relationships = [];
+  const diagnostics = [];
+  const byId = new Map(events.map((event) => [event.eventId, event]));
+  const seen = /* @__PURE__ */ new Set();
+  const push = (edge) => {
+    const key = `${edge.type}:${edge.fromEventId}:${edge.toEventId ?? ""}:${edge.externalRef ?? ""}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    relationships.push(edge);
+  };
+  for (const event of events) {
+    if (event.parentId) {
+      push({
+        type: "parent-child",
+        fromEventId: event.parentId,
+        toEventId: event.eventId,
+        confidence: byId.has(event.parentId) ? "explicit" : "unknown",
+        basis: ["persisted.parentId"]
+      });
+      if (!byId.has(event.parentId)) {
+        diagnostics.push({
+          code: "AI_RELATIONSHIP_PARENT_MISSING",
+          message: `parentId ${event.parentId} is not present in the event set.`,
+          eventId: event.eventId
+        });
+      }
+    }
+    const bag = attrs(event);
+    const meta = extractSessionWorkflowMetadata(bag) ?? {};
+    const nested = bag.metadata && typeof bag.metadata === "object" ? extractSessionWorkflowMetadata(bag.metadata) : void 0;
+    const workflow = { ...meta, ...nested };
+    if (workflow.retryOf) {
+      const target = events.find((candidate) => candidate.runId === workflow.retryOf);
+      push({
+        type: "retry-of",
+        fromEventId: event.eventId,
+        ...target ? { toEventId: target.eventId } : {},
+        externalRef: workflow.retryOf,
+        confidence: target ? "explicit" : "correlated",
+        basis: ["attributes.retryOf"]
+      });
+    }
+    const attemptOf = stringAttr(bag, "attemptOf") ?? stringAttr(bag, "operationId");
+    if (attemptOf && workflow.attempt !== void 0) {
+      push({
+        type: "attempt-of",
+        fromEventId: event.eventId,
+        externalRef: attemptOf,
+        confidence: "explicit",
+        basis: workflow.attempt !== void 0 ? ["attributes.attempt", "attributes.operationId"] : ["attributes.operationId"]
+      });
+    }
+    const fallbackOf = stringAttr(bag, "fallbackOf");
+    if (fallbackOf) {
+      push({
+        type: "fallback-of",
+        fromEventId: event.eventId,
+        externalRef: fallbackOf,
+        confidence: "explicit",
+        basis: ["attributes.fallbackOf"]
+      });
+    }
+    const remediationOf = stringAttr(bag, "remediationOf");
+    if (remediationOf) {
+      push({
+        type: "remediation-of",
+        fromEventId: event.eventId,
+        externalRef: remediationOf,
+        confidence: "explicit",
+        basis: ["attributes.remediationOf"]
+      });
+    }
+    const evidenceFor = stringAttr(bag, "evidenceFor");
+    if (evidenceFor) {
+      push({
+        type: "evidence-for",
+        fromEventId: event.eventId,
+        ...byId.has(evidenceFor) ? { toEventId: evidenceFor } : { externalRef: evidenceFor },
+        confidence: byId.has(evidenceFor) ? "explicit" : "correlated",
+        basis: ["attributes.evidenceFor"]
+      });
+    }
+    const acceptedBy = stringAttr(bag, "acceptedBy");
+    if (acceptedBy) {
+      push({
+        type: "accepted-by",
+        fromEventId: event.eventId,
+        ...byId.has(acceptedBy) ? { toEventId: acceptedBy } : { externalRef: acceptedBy },
+        confidence: byId.has(acceptedBy) ? "explicit" : "correlated",
+        basis: ["attributes.acceptedBy"]
+      });
+    }
+    const supersedes = stringAttr(bag, "supersedes");
+    if (supersedes) {
+      push({
+        type: "supersedes",
+        fromEventId: event.eventId,
+        ...byId.has(supersedes) ? { toEventId: supersedes } : { externalRef: supersedes },
+        confidence: byId.has(supersedes) ? "explicit" : "correlated",
+        basis: ["attributes.supersedes"]
+      });
+    }
+    const sourceLineage = stringAttr(bag, "sourceLineage") ?? stringAttr(bag, "sourceEventId");
+    if (sourceLineage) {
+      push({
+        type: "source-lineage",
+        fromEventId: event.eventId,
+        externalRef: sourceLineage,
+        confidence: "explicit",
+        basis: ["attributes.sourceLineage"]
+      });
+    }
+    const unsupported = stringAttr(bag, "relationshipType");
+    if (unsupported && unsupported !== "parent-child" && ![
+      "source-lineage",
+      "attempt-of",
+      "retry-of",
+      "fallback-of",
+      "remediation-of",
+      "evidence-for",
+      "accepted-by",
+      "supersedes"
+    ].includes(unsupported)) {
+      diagnostics.push({
+        code: "AI_RELATIONSHIP_UNSUPPORTED_TYPE",
+        message: `Unsupported relationshipType ${unsupported} was reported without flattening.`,
+        eventId: event.eventId
+      });
+    }
+  }
+  return {
+    relationships: Object.freeze(relationships),
+    diagnostics: Object.freeze(diagnostics)
+  };
+}
+
 // packages/core/src/checks/trace-facts.ts
 function summarizeSemanticParity(events) {
   const projection = projectLogicalEvents(events);
@@ -3448,6 +3661,7 @@ function buildTraceFacts(input) {
     toolsByName.set(name, Object.freeze([...list]));
   }
   const derived = deriveFailureFacts(projection.logicalEvents);
+  const relationship = deriveRelationshipFacts(events);
   const summary = summarizeSemanticParity(events);
   return {
     rawEvents: Object.freeze([...events]),
@@ -3461,10 +3675,15 @@ function buildTraceFacts(input) {
       failureRoleCounts: derived.failureRoleCounts
     },
     failureFacts: derived.failureFacts,
-    failuresByRole: derived.failuresByRole
+    failuresByRole: derived.failuresByRole,
+    relationships: relationship.relationships,
+    relationshipDiagnostics: relationship.diagnostics
   };
 }
 
+// packages/core/src/checks/contract.ts
+new Set(OBSERVED_OUTCOME_METHODS);
+
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -4640,20 +4859,20 @@ function parseIsoToMs3(iso) {
   return { ms: parsed, invalidTimestamp: false };
 }
 function mapPersistedSourceToInspect(event) {
-  const attrs = event.attributes ?? {};
+  const attrs2 = event.attributes ?? {};
   const sourceName = event.source.name;
   if (sourceName === "pino") {
     return {
       type: "pino",
-      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+      file: typeof attrs2.sourceFile === "string" ? attrs2.sourceFile : void 0,
+      line: typeof attrs2.sourceLine === "number" ? attrs2.sourceLine : void 0
     };
   }
   if (sourceName === "winston") {
     return {
       type: "winston",
-      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+      file: typeof attrs2.sourceFile === "string" ? attrs2.sourceFile : void 0,
+      line: typeof attrs2.sourceLine === "number" ? attrs2.sourceLine : void 0
     };
   }
   const mapType = (t) => {
@@ -4674,55 +4893,55 @@ function mapPersistedSourceToInspect(event) {
   };
   return {
     type: mapType(event.source.type),
-    file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
-    line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+    file: typeof attrs2.sourceFile === "string" ? attrs2.sourceFile : void 0,
+    line: typeof attrs2.sourceLine === "number" ? attrs2.sourceLine : void 0
   };
 }
 function buildInspectAttributes(event) {
-  const attrs = event.attributes !== void 0 ? { ...event.attributes } : {};
+  const attrs2 = event.attributes !== void 0 ? { ...event.attributes } : {};
   if (event.inputSummary !== void 0) {
-    attrs.inputSummary = event.inputSummary;
+    attrs2.inputSummary = event.inputSummary;
   }
   if (event.outputSummary !== void 0) {
-    attrs.outputSummary = event.outputSummary;
+    attrs2.outputSummary = event.outputSummary;
   }
   if (event.error) {
     if (event.error.name !== void 0) {
-      attrs.errorName = event.error.name;
+      attrs2.errorName = event.error.name;
     }
-    attrs.errorMessage = event.error.message;
+    attrs2.errorMessage = event.error.message;
     if (event.error.code !== void 0) {
-      attrs.errorCode = event.error.code;
+      attrs2.errorCode = event.error.code;
     }
   }
   if (event.tokenUsage) {
-    attrs.tokens = { ...event.tokenUsage };
+    attrs2.tokens = { ...event.tokenUsage };
   }
   if (event.source.type === "ai-sdk" || event.source.type === "otel") {
-    attrs.originalSourceType = event.source.type;
+    attrs2.originalSourceType = event.source.type;
   }
   if (event.source.name !== void 0) {
-    attrs.sourceName = event.source.name;
+    attrs2.sourceName = event.source.name;
   }
   if (event.source.version !== void 0) {
-    attrs.sourceVersion = event.source.version;
+    attrs2.sourceVersion = event.source.version;
   }
-  return attrs;
+  return attrs2;
 }
 function persistedInspectEventToInspectEvent(event) {
   if (!isPersistedInspectEvent(event)) {
     throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
   }
   const ts = parseIsoToMs3(event.timestamp);
-  const attrs = buildInspectAttributes(event);
+  const attrs2 = buildInspectAttributes(event);
   if (ts.invalidTimestamp) {
-    attrs.invalidTimestamp = true;
+    attrs2.invalidTimestamp = true;
   }
   let status;
   if (event.status === "running" || event.status === "ok" || event.status === "error") {
     status = event.status;
   } else if (event.status === "unknown") {
-    attrs.persistedStatus = "unknown";
+    attrs2.persistedStatus = "unknown";
   }
   const out = {
     eventId: event.eventId,
@@ -4732,7 +4951,7 @@ function persistedInspectEventToInspectEvent(event) {
     timestamp: ts.ms,
     confidence: event.confidence,
     source: mapPersistedSourceToInspect(event),
-    attributes: compactAttributes3(attrs)
+    attributes: compactAttributes3(attrs2)
   };
   if (event.parentId !== void 0) {
     out.parentId = event.parentId;
@@ -5075,13 +5294,13 @@ function persistedEventsForParsedTrace(parsed) {
 function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNonEmptyString3(value) {
+function isNonEmptyString4(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 function readStringField(record, keys) {
   for (const key of keys) {
     const value = record[key];
-    if (isNonEmptyString3(value)) return value;
+    if (isNonEmptyString4(value)) return value;
   }
   return void 0;
 }
@@ -5215,7 +5434,7 @@ function parseUnixNanoToIso(value) {
   return void 0;
 }
 function parseIsoTime(value) {
-  if (!isNonEmptyString3(value)) return void 0;
+  if (!isNonEmptyString4(value)) return void 0;
   const ms = Date.parse(value);
   if (!Number.isFinite(ms)) return void 0;
   return new Date(ms).toISOString();
@@ -6443,11 +6662,11 @@ function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen,
     depth + 1
   );
 }
-function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPreviewLength) {
-  if (!attrs || Object.keys(attrs).length === 0) {
-    return attrs;
+function redactEventAttributes(attrs2, redactor, maxMetadataValueLength, maxPreviewLength) {
+  if (!attrs2 || Object.keys(attrs2).length === 0) {
+    return attrs2;
   }
-  const redacted = redactor.redactRecord(attrs);
+  const redacted = redactor.redactRecord(attrs2);
   const seen = /* @__PURE__ */ new WeakSet();
   const bounded = boundAttributeValues(
     redacted,
@@ -6833,7 +7052,7 @@ function exportOpenInference(tree, options) {
       endNs = startNs + unixNano(ev.durationMs);
     }
     const { openInferenceKind } = mapInspectKindToOI(ev.kind, warnings);
-    const attrs = {
+    const attrs2 = {
       "openinference.span.kind": openInferenceKind,
       "agent_inspect.kind": ev.kind,
       "agent_inspect.confidence": ev.confidence,
@@ -6843,24 +7062,24 @@ function exportOpenInference(tree, options) {
       "agent_inspect.status": ev.status ?? "unset"
     };
     if (ev.durationMs !== void 0) {
-      attrs["agent_inspect.duration_ms"] = ev.durationMs;
+      attrs2["agent_inspect.duration_ms"] = ev.durationMs;
     }
     const meta = ev.attributes;
     if (meta?.model !== void 0 && typeof meta.model === "string") {
-      attrs["llm.model_name"] = meta.model;
+      attrs2["llm.model_name"] = meta.model;
     }
     const tokens = meta?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
       const inp = tokens.input;
       const outp = tokens.output;
-      if (typeof inp === "number") attrs["llm.token_count.prompt"] = inp;
-      if (typeof outp === "number") attrs["llm.token_count.completion"] = outp;
+      if (typeof inp === "number") attrs2["llm.token_count.prompt"] = inp;
+      if (typeof outp === "number") attrs2["llm.token_count.completion"] = outp;
     }
     if (includeAttributes && meta && typeof meta === "object") {
       for (const [k, v] of Object.entries(meta)) {
         if (k === "tokens" || k === "model") continue;
         if (v !== void 0 && v !== null && typeof v !== "object") {
-          attrs[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
+          attrs2[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
         }
       }
     }
@@ -6880,7 +7099,7 @@ function exportOpenInference(tree, options) {
       name: ev.name,
       start_time_unix_nano: startNs.toString(),
       end_time_unix_nano: endNs?.toString(),
-      attributes: attrs,
+      attributes: attrs2,
       status
     });
   }
@@ -6904,7 +7123,7 @@ function exportOpenInference(tree, options) {
 function hexFrom2(seed, byteLen) {
   return crypto__default.default.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
 }
-function stringAttr(key, value) {
+function stringAttr2(key, value) {
   return { key, value: { stringValue: value } };
 }
 function intAttr(key, value) {
@@ -6942,38 +7161,38 @@ function exportOtlpJson(tree, options) {
     if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
       endNs = String(Math.round(ev.timestamp * 1e6 + ev.durationMs * 1e6));
     }
-    const attrs = [
-      stringAttr("agent_inspect.kind", ev.kind),
-      stringAttr("agent_inspect.confidence", ev.confidence),
-      stringAttr("agent_inspect.source.type", ev.source.type),
-      stringAttr("agent_inspect.run_id", tree.runId),
-      stringAttr("agent_inspect.event_id", ev.eventId),
-      stringAttr("agent_inspect.status", ev.status ?? "unset")
+    const attrs2 = [
+      stringAttr2("agent_inspect.kind", ev.kind),
+      stringAttr2("agent_inspect.confidence", ev.confidence),
+      stringAttr2("agent_inspect.source.type", ev.source.type),
+      stringAttr2("agent_inspect.run_id", tree.runId),
+      stringAttr2("agent_inspect.event_id", ev.eventId),
+      stringAttr2("agent_inspect.status", ev.status ?? "unset")
     ];
     if (ev.durationMs !== void 0) {
-      attrs.push(intAttr("agent_inspect.duration_ms", ev.durationMs));
+      attrs2.push(intAttr("agent_inspect.duration_ms", ev.durationMs));
     }
     const op = genAiOperationName(ev.kind);
     if (op !== void 0) {
-      attrs.push(stringAttr("gen_ai.operation.name", op));
+      attrs2.push(stringAttr2("gen_ai.operation.name", op));
     }
     const meta = ev.attributes;
     if (meta?.model !== void 0 && typeof meta.model === "string") {
-      attrs.push(stringAttr("gen_ai.request.model", meta.model.slice(0, maxLen)));
+      attrs2.push(stringAttr2("gen_ai.request.model", meta.model.slice(0, maxLen)));
     }
     const tokens = meta?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
       const inp = tokens.input;
       const outp = tokens.output;
-      if (typeof inp === "number") attrs.push(intAttr("gen_ai.usage.input_tokens", inp));
-      if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
+      if (typeof inp === "number") attrs2.push(intAttr("gen_ai.usage.input_tokens", inp));
+      if (typeof outp === "number") attrs2.push(intAttr("gen_ai.usage.output_tokens", outp));
     }
     if (includeAttributes && meta && typeof meta === "object") {
       for (const [k, v] of Object.entries(meta)) {
         if (k === "tokens" || k === "model") continue;
         if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-          attrs.push(
-            stringAttr(
+          attrs2.push(
+            stringAttr2(
               `agent_inspect.preview.${k}`,
               typeof v === "string" ? v.slice(0, maxLen) : String(v)
             )
@@ -6995,7 +7214,7 @@ function exportOtlpJson(tree, options) {
       name: ev.name,
       kind: "SPAN_KIND_INTERNAL",
       startTimeUnixNano: startNs,
-      attributes: attrs,
+      attributes: attrs2,
       status: {
         code: statusCode,
         ...statusMessage !== void 0 ? { message: statusMessage } : {}
@@ -7013,7 +7232,7 @@ function exportOtlpJson(tree, options) {
     resourceSpans: [
       {
         resource: {
-          attributes: [stringAttr("service.name", "agent-inspect")]
+          attributes: [stringAttr2("service.name", "agent-inspect")]
         },
         scopeSpans: [
           {
@@ -7754,7 +7973,7 @@ var FLAGSHIP_TOOLS = [
   {
     name: "get_contract_failures",
     description: withUntrustedTraceWarning(
-      "Deterministic contract/check failures for one run."
+      "Deterministic run-status check failures for one run. Actor-scoped TraceContracts and observation provenance (scope / requireProvenance) are evaluated via the TypeScript agent-inspect/checks API (evaluateTraceContract), not this MCP tool."
     ),
     inputSchema: RUN_ID_SCHEMA
   },