@agent-inspect/mcp-server 6.18.0 → 6.19.1

package/dist/cli.cjs

@@ -1160,9 +1160,63 @@ async function extractMetadata(filePath, _quickScan) {
     createdAt: stats.birthtime
   };
 }
+var ROOT_STEP_DEPTH = 0;
+var MAX_RUN_SUMMARY_DEPTH = 1e3;
 function isNonNegativeFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
+function resolveParentStepId(step, steps) {
+  const parentId = step.parentId;
+  if (typeof parentId !== "string" || parentId.trim() === "") {
+    return void 0;
+  }
+  return steps.has(parentId) ? parentId : void 0;
+}
+function computeStepDepth(stepId, steps, depthCache) {
+  const cached = depthCache.get(stepId);
+  if (cached !== void 0) return cached;
+  const ancestry = [];
+  const ancestryIndexes = /* @__PURE__ */ new Map();
+  let currentStepId = stepId;
+  let resolvedDepth;
+  while (resolvedDepth === void 0) {
+    const cachedDepth = depthCache.get(currentStepId);
+    if (cachedDepth !== void 0) {
+      resolvedDepth = cachedDepth;
+      continue;
+    }
+    const cycleStart = ancestryIndexes.get(currentStepId);
+    if (cycleStart !== void 0) {
+      const cycleStepIds = ancestry.splice(cycleStart);
+      for (const cycleStepId of cycleStepIds) {
+        depthCache.set(cycleStepId, ROOT_STEP_DEPTH);
+      }
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    const currentStep = steps.get(currentStepId);
+    if (!currentStep) {
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    ancestryIndexes.set(currentStepId, ancestry.length);
+    ancestry.push(currentStepId);
+    const parentStepId = resolveParentStepId(currentStep, steps);
+    if (parentStepId === void 0) {
+      ancestry.pop();
+      depthCache.set(currentStepId, ROOT_STEP_DEPTH);
+      resolvedDepth = ROOT_STEP_DEPTH;
+      continue;
+    }
+    currentStepId = parentStepId;
+  }
+  ancestry.reverse();
+  for (const ancestorStepId of ancestry) {
+    resolvedDepth = Math.min(MAX_RUN_SUMMARY_DEPTH, resolvedDepth + 1);
+    depthCache.set(ancestorStepId, resolvedDepth);
+  }
+  return depthCache.get(stepId) ?? ROOT_STEP_DEPTH;
+}
 function buildRunSummary(events) {
   const started = events.find(
     (e) => e.event === "run_started"
@@ -1216,27 +1270,13 @@ function buildRunSummary(events) {
   let stepsWithKnownTotal = 0;
   let hasCachedTokens = false;
   const depthCache = /* @__PURE__ */ new Map();
-  const computeDepth = (stepId) => {
-    const cached = depthCache.get(stepId);
-    if (cached !== void 0) return cached;
-    const node = steps.get(stepId);
-    if (!node) return 0;
-    const parent = node.parentId;
-    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
-      depthCache.set(stepId, 0);
-      return 0;
-    }
-    const d = Math.min(1e3, computeDepth(parent) + 1);
-    depthCache.set(stepId, d);
-    return d;
-  };
   for (const [id, s] of steps.entries()) {
     totalSteps += 1;
     if (s.type === "llm") llmSteps += 1;
     else if (s.type === "tool") toolSteps += 1;
     else logicSteps += 1;
     if (s.status === "error") errorSteps += 1;
-    const depth = computeDepth(id);
+    const depth = computeStepDepth(id, steps, depthCache);
     if (depth > maxDepth) maxDepth = depth;
     if (typeof s.durationMs === "number" && Number.isFinite(s.durationMs)) {
       if (!longestStep || s.durationMs > longestStep.durationMs) {
@@ -3003,6 +3043,325 @@ function pickString(record, keys) {
   return void 0;
 }
 
+// packages/core/src/checks/derived-failure.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pickString2(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  return void 0;
+}
+function pickNumber(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+  }
+  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;
+  return {
+    ...attrs ?? {},
+    ...nested ?? {}
+  };
+}
+function canonicalName(event) {
+  if (event.kind === "TOOL") return resolveCanonicalToolName(event);
+  return event.name;
+}
+function linkKeys(event) {
+  const meta = eventMetadata(event);
+  const keys = [];
+  for (const key of ["linkedStepId", "toolCallId", "mcpToolCallId"]) {
+    const value = pickString2(meta, [key]);
+    if (value !== void 0) keys.push(`${key}:${value}`);
+  }
+  const stepId = pickString2(meta, ["stepId"]);
+  if (stepId !== void 0) keys.push(`stepId:${stepId}`);
+  return keys;
+}
+function buildRunContexts(logicalEvents) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of logicalEvents) {
+    const existing = byRun.get(event.runId) ?? {
+      runId: event.runId,
+      name: event.name
+    };
+    const meta = eventMetadata(event);
+    if (event.kind === "RUN" || existing.name === event.runId) {
+      existing.name = event.name || existing.name;
+    }
+    if (event.kind === "RUN" && event.status !== void 0 && event.status !== "running") {
+      existing.status = event.status;
+    }
+    existing.retryOf ??= pickString2(meta, ["retryOf"]);
+    existing.attempt ??= pickNumber(meta, ["attempt", "retryAttempt", "retryCount"]);
+    existing.sessionId ??= pickString2(meta, ["sessionId", "conversationId"]);
+    existing.groupId ??= pickString2(meta, ["groupId"]);
+    existing.parentGroupId ??= pickString2(meta, ["parentGroupId"]);
+    existing.fallbackOf ??= pickString2(meta, ["fallbackOf", "fallbackFrom"]);
+    byRun.set(event.runId, existing);
+  }
+  return byRun;
+}
+function sameCorrelationScope(a, b) {
+  if (a.sessionId && b.sessionId && a.sessionId === b.sessionId) return true;
+  if (a.groupId && b.groupId && a.groupId === b.groupId) return true;
+  if (a.parentGroupId && b.parentGroupId && a.parentGroupId === b.parentGroupId) {
+    return true;
+  }
+  return false;
+}
+function isSuccessful(event) {
+  return event.status === "ok";
+}
+function isFailure(event) {
+  return event.status === "error";
+}
+function compareEventOrder(a, b) {
+  const byTime = a.timestamp.localeCompare(b.timestamp);
+  if (byTime !== 0) return byTime;
+  return a.eventId.localeCompare(b.eventId);
+}
+function collectCandidates(failure, logicalEvents, runs) {
+  const failureRun = runs.get(failure.runId);
+  const failureLinks = new Set(linkKeys(failure));
+  const failureName = canonicalName(failure);
+  const failureAttempt = pickNumber(eventMetadata(failure), ["attempt", "retryAttempt", "retryCount"]) ?? failureRun?.attempt;
+  const candidates = [];
+  for (const event of logicalEvents) {
+    if (event.eventId === failure.eventId) continue;
+    if (event.status === "running") continue;
+    const eventRun = runs.get(event.runId);
+    const eventMeta = eventMetadata(event);
+    const sameRun = event.runId === failure.runId;
+    if (eventRun?.retryOf === failure.runId) {
+      candidates.push({
+        event,
+        basis: "retryOf",
+        confidence: "explicit",
+        viaRunId: event.runId
+      });
+      continue;
+    }
+    if (eventRun?.fallbackOf === failure.runId || pickString2(eventMeta, ["fallbackOf", "fallbackFrom"]) === failure.runId) {
+      candidates.push({
+        event,
+        basis: "fallbackOf",
+        confidence: "explicit",
+        viaRunId: event.runId
+      });
+      continue;
+    }
+    if (sameRun && compareEventOrder(failure, event) >= 0) continue;
+    const eventLinks = linkKeys(event);
+    const sharedLink = eventLinks.find((key) => failureLinks.has(key));
+    if (sharedLink !== void 0) {
+      candidates.push({
+        event,
+        basis: sharedLink.split(":")[0] ?? "linkedId",
+        confidence: "explicit"
+      });
+      continue;
+    }
+    const eventAttempt = pickNumber(eventMeta, ["attempt", "retryAttempt", "retryCount"]) ?? eventRun?.attempt;
+    const sameParent = failure.parentId !== void 0 && event.parentId !== void 0 && failure.parentId === event.parentId;
+    const differentParent = failure.parentId !== void 0 && event.parentId !== void 0 && failure.parentId !== event.parentId;
+    const sessionScoped = failureRun !== void 0 && eventRun !== void 0 && sameCorrelationScope(failureRun, eventRun);
+    if (canonicalName(event) === failureName && failureAttempt !== void 0 && eventAttempt !== void 0 && eventAttempt > failureAttempt && !differentParent && (sameParent || sessionScoped || sameRun)) {
+      candidates.push({
+        event,
+        basis: "attempt-progression",
+        confidence: "correlated",
+        ...event.runId !== failure.runId ? { viaRunId: event.runId } : {}
+      });
+    }
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const prev = byId.get(candidate.event.eventId);
+    if (!prev || prev.confidence !== "explicit" && candidate.confidence === "explicit") {
+      byId.set(candidate.event.eventId, candidate);
+    }
+  }
+  return [...byId.values()].sort((a, b) => compareEventOrder(a.event, b.event));
+}
+function classifyFailure(failure, candidates, runs, logicalEvents) {
+  const successful = candidates.filter((c) => isSuccessful(c.event));
+  const unsuccessful = candidates.filter((c) => !isSuccessful(c.event));
+  const retryRunIds = Object.freeze(
+    [...new Set(candidates.map((c) => c.viaRunId).filter((id) => id !== void 0))].sort(
+      (a, b) => a.localeCompare(b)
+    )
+  );
+  if (successful.length > 1) {
+    const distinctRuns = new Set(successful.map((c) => c.event.runId));
+    const distinctParents = new Set(
+      successful.map((c) => c.event.parentId ?? "").filter((id) => id !== "")
+    );
+    if (distinctRuns.size > 1 || distinctParents.size > 1) {
+      return {
+        eventId: failure.eventId,
+        runId: failure.runId,
+        name: failure.name,
+        kind: failure.kind,
+        role: "unknown",
+        confidence: "unknown",
+        basis: Object.freeze(["ambiguous-recovery-candidates"]),
+        recoveryEventIds: Object.freeze(
+          successful.map((c) => c.event.eventId).sort((a, b) => a.localeCompare(b))
+        ),
+        retryRunIds
+      };
+    }
+  }
+  if (successful.length >= 1) {
+    const best = successful[0];
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "recovered",
+      confidence: best.confidence,
+      basis: Object.freeze([best.basis]),
+      recoveryEventIds: Object.freeze(
+        successful.map((c) => c.event.eventId).sort((a, b) => a.localeCompare(b))
+      ),
+      retryRunIds
+    };
+  }
+  if (candidates.length > 0) {
+    const best = candidates[0];
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "transient",
+      confidence: best.confidence,
+      basis: Object.freeze([
+        best.basis,
+        unsuccessful.some((c) => c.event.status === void 0) ? "retry-incomplete" : "retry-without-success"
+      ]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds
+    };
+  }
+  const failureMeta = eventMetadata(failure);
+  const declaredSuccessor = pickString2(failureMeta, [
+    "retriedBy",
+    "nextRetryRunId",
+    "retryRunId"
+  ]);
+  if (declaredSuccessor !== void 0 && !runs.has(declaredSuccessor)) {
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "transient",
+      confidence: "explicit",
+      basis: Object.freeze(["retry-declared", "retry-run-missing"]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds: Object.freeze([declaredSuccessor])
+    };
+  }
+  for (const run of runs.values()) {
+    if (run.retryOf === failure.runId) {
+      return {
+        eventId: failure.eventId,
+        runId: failure.runId,
+        name: failure.name,
+        kind: failure.kind,
+        role: "transient",
+        confidence: "explicit",
+        basis: Object.freeze(["retryOf", "retry-run-missing-or-empty"]),
+        recoveryEventIds: Object.freeze([]),
+        retryRunIds: Object.freeze([run.runId])
+      };
+    }
+  }
+  const failureRun = runs.get(failure.runId);
+  const hasSuccessorDeclared = [...runs.values()].some((run) => run.retryOf === failure.runId);
+  const isFinalInChain = failureRun !== void 0 && !hasSuccessorDeclared && (failureRun.retryOf !== void 0 || failureRun.attempt !== void 0 && failureRun.attempt > 1 || pickNumber(eventMetadata(failure), ["attempt"]) !== void 0);
+  if (isFinalInChain && failureRun?.status === "error" && !logicalEvents.some(
+    (event) => event.runId === failure.runId && event.eventId !== failure.eventId && isSuccessful(event) && canonicalName(event) === canonicalName(failure)
+  )) {
+    return {
+      eventId: failure.eventId,
+      runId: failure.runId,
+      name: failure.name,
+      kind: failure.kind,
+      role: "terminal",
+      confidence: failureRun.retryOf !== void 0 ? "explicit" : "correlated",
+      basis: Object.freeze(["final-retry-chain-member", "enclosing-run-error"]),
+      recoveryEventIds: Object.freeze([]),
+      retryRunIds: Object.freeze(
+        failureRun.retryOf !== void 0 ? [failureRun.retryOf] : []
+      )
+    };
+  }
+  return {
+    eventId: failure.eventId,
+    runId: failure.runId,
+    name: failure.name,
+    kind: failure.kind,
+    role: "unknown",
+    confidence: "unknown",
+    basis: Object.freeze(["no-explicit-or-correlated-recovery"]),
+    recoveryEventIds: Object.freeze([]),
+    retryRunIds: Object.freeze([])
+  };
+}
+function deriveFailureFacts(logicalEvents) {
+  const runs = buildRunContexts(logicalEvents);
+  const failures = logicalEvents.filter((event) => isFailure(event)).sort(compareEventOrder);
+  const failureFacts = failures.map(
+    (failure) => classifyFailure(failure, collectCandidates(failure, logicalEvents, runs), runs, logicalEvents)
+  );
+  const byRole = /* @__PURE__ */ new Map([
+    ["transient", []],
+    ["recovered", []],
+    ["terminal", []],
+    ["unknown", []]
+  ]);
+  for (const fact of failureFacts) {
+    byRole.get(fact.role).push(fact);
+  }
+  for (const [role, list] of byRole) {
+    byRole.set(
+      role,
+      Object.freeze(
+        [...list].sort((a, b) => {
+          const byRun = a.runId.localeCompare(b.runId);
+          if (byRun !== 0) return byRun;
+          return a.eventId.localeCompare(b.eventId);
+        })
+      )
+    );
+  }
+  const failureRoleCounts = {
+    transient: byRole.get("transient").length,
+    recovered: byRole.get("recovered").length,
+    terminal: byRole.get("terminal").length,
+    unknown: byRole.get("unknown").length
+  };
+  return {
+    failureFacts: Object.freeze(failureFacts),
+    failuresByRole: byRole,
+    failureRoleCounts
+  };
+}
+
 // packages/core/src/checks/trace-facts.ts
 function summarizeSemanticParity(events) {
   const projection = projectLogicalEvents(events);
@@ -3013,6 +3372,7 @@ function summarizeSemanticParity(events) {
   const finishedToolNames = Object.freeze(
     finishedTools.map((event) => resolveCanonicalToolName(event)).sort((a, b) => a.localeCompare(b))
   );
+  const derived = deriveFailureFacts(logical);
   return {
     rawEventCount: events.length,
     logicalEventCount: logical.length,
@@ -3023,7 +3383,8 @@ function summarizeSemanticParity(events) {
     parentRemapCount: projection.diagnostics.filter(
       (item) => item.code === "AI_LOGICAL_PARENT_REMAPPED"
     ).length,
-    diagnostics: projection.diagnostics
+    diagnostics: projection.diagnostics,
+    failureRoleCounts: derived.failureRoleCounts
   };
 }
 var TRACE_FACTS_INPUT_NOT_NORMALIZED = formatProgrammaticDiagnostic(
@@ -3086,6 +3447,8 @@ function buildTraceFacts(input) {
   for (const [name, list] of [...toolsByName.entries()]) {
     toolsByName.set(name, Object.freeze([...list]));
   }
+  const derived = deriveFailureFacts(projection.logicalEvents);
+  const summary = summarizeSemanticParity(events);
   return {
     rawEvents: Object.freeze([...events]),
     logicalEvents: projection.logicalEvents,
@@ -3093,7 +3456,12 @@ function buildTraceFacts(input) {
     toolsByName,
     llmEvents: Object.freeze(llmEvents),
     outcomeEvents: Object.freeze(outcomeEvents),
-    summary: summarizeSemanticParity(events)
+    summary: {
+      ...summary,
+      failureRoleCounts: derived.failureRoleCounts
+    },
+    failureFacts: derived.failureFacts,
+    failuresByRole: derived.failuresByRole
   };
 }
 
@@ -3419,7 +3787,7 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
 function semanticEvents(context) {
   return context.logicalEvents ?? context.events;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizedKey(value) {
@@ -3450,7 +3818,7 @@ function pushValueEntries(entries, event, value, path17, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord7(value)) return;
+  if (!isRecord8(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -3698,7 +4066,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord7(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord8(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -3816,14 +4184,14 @@ function runTraceChecks(input, options = {}) {
 }
 
 // packages/core/src/persisted/token-usage.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeFinite(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 function normalizeTokenUsage(value) {
-  if (!isRecord8(value)) return void 0;
+  if (!isRecord9(value)) return void 0;
   const input = nonNegativeFinite(value.input);
   const output = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
@@ -4704,7 +5072,7 @@ function persistedEventsForParsedTrace(parsed) {
     sourceName: "agent-inspect-jsonl-reader"
   });
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString3(value) {
@@ -4719,13 +5087,13 @@ function readStringField(record, keys) {
 }
 function readRecordField(record, key) {
   const value = record[key];
-  return isRecord9(value) ? value : void 0;
+  return isRecord10(value) ? value : void 0;
 }
 function parseJsonDocument(content) {
   return JSON.parse(content);
 }
 function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   const attributes = readRecordField(value, "attributes");
   return readStringField(value, ["trace_id", "traceId"]) !== void 0 && readStringField(value, ["span_id", "spanId"]) !== void 0 && (readStringField(value, ["name"]) !== void 0 || attributes?.["openinference.span.kind"] !== void 0);
 }
@@ -4750,7 +5118,7 @@ function extractOpenInferenceDocument(root) {
       unsupportedFields
     };
   }
-  if (!isRecord9(root)) return void 0;
+  if (!isRecord10(root)) return void 0;
   const rootFormat = root.format;
   const rootCompatibility = root.compatibility;
   const version = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
@@ -4890,7 +5258,7 @@ function summarizeAttributeValue(value) {
   if (Array.isArray(value)) {
     return { type: "array", length: value.length };
   }
-  if (isRecord9(value)) {
+  if (isRecord10(value)) {
     return { type: "object", keyCount: Object.keys(value).length };
   }
   if (value === null) {
@@ -4977,7 +5345,7 @@ function mapOpenInferenceKind(span, attributes, pathPrefix) {
   }
 }
 function mapOpenInferenceStatus(status) {
-  if (!isRecord9(status)) return void 0;
+  if (!isRecord10(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -5077,7 +5445,7 @@ function mapOpenInferenceSpan(span, index, version) {
   warnings.push(...kindWarnings);
   const status = mapOpenInferenceStatus(span.status);
   const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
-  const errorMessage = isRecord9(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord10(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : spanId,
@@ -5223,7 +5591,7 @@ var openInferenceJsonReader = {
   }
 };
 function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     unsupportedFields.push(field);
     warnings.push({
       code: "otlp_attribute_value_invalid",
@@ -5245,15 +5613,15 @@ function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
   if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
     return value.doubleValue;
   }
-  if (isRecord9(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+  if (isRecord10(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
     return value.arrayValue.values.map(
       (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
     );
   }
-  if (isRecord9(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+  if (isRecord10(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
     const out = {};
     for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord9(item) || typeof item.key !== "string") {
+      if (!isRecord10(item) || typeof item.key !== "string") {
         unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
         continue;
       }
@@ -5304,7 +5672,7 @@ function parseOtlpAttributes(value, pathPrefix) {
   }
   for (const [index, item] of value.entries()) {
     const field = `${pathPrefix}[${index}]`;
-    if (!isRecord9(item) || typeof item.key !== "string") {
+    if (!isRecord10(item) || typeof item.key !== "string") {
       unsupportedFields.push(field);
       warnings.push({
         code: "otlp_attribute_invalid",
@@ -5327,16 +5695,16 @@ function parseOtlpAttributes(value, pathPrefix) {
   return { attributes, warnings, unsupportedFields };
 }
 function looksLikeOtlpSpan(value) {
-  return isRecord9(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+  return isRecord10(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
 }
 function extractOtlpDocument(root) {
-  if (!isRecord9(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  if (!isRecord10(root) || !Array.isArray(root.resourceSpans)) return void 0;
   const spans = [];
   const warnings = [];
   const unsupportedFields = [];
   for (const [resourceIndex, resourceSpan] of root.resourceSpans.entries()) {
     const resourcePath = `resourceSpans[${resourceIndex}]`;
-    if (!isRecord9(resourceSpan)) {
+    if (!isRecord10(resourceSpan)) {
       unsupportedFields.push(resourcePath);
       continue;
     }
@@ -5359,7 +5727,7 @@ function extractOtlpDocument(root) {
     }
     for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
       const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord9(scopeSpan)) {
+      if (!isRecord10(scopeSpan)) {
         unsupportedFields.push(scopePath);
         continue;
       }
@@ -5426,7 +5794,7 @@ function extractOtlpDocument(root) {
   };
 }
 function mapOtlpStatus(status) {
-  if (!isRecord9(status)) return void 0;
+  if (!isRecord10(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -5526,7 +5894,7 @@ function mapOtlpEvents(value, pathPrefix) {
   const events = [];
   for (const [index, event] of value.entries()) {
     const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord9(event)) {
+    if (!isRecord10(event)) {
       unsupportedFields.push(eventPath);
       continue;
     }
@@ -5664,7 +6032,7 @@ function mapOtlpSpan(context) {
   warnings.push(...kindWarnings);
   const status = mapOtlpStatus(span.status);
   const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord9(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord10(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : spanId,
@@ -6015,7 +6383,7 @@ function openTrace(input, options = {}) {
 var EXPORT_PAYLOAD_VERSION = "0.1.2";
 
 // packages/core/src/exporters/redact-export.ts
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function deepClone(value) {
@@ -6089,7 +6457,7 @@ function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPrevi
     0
   );
   const err = bounded.error;
-  if (isRecord10(err) && typeof err.message === "string") {
+  if (isRecord11(err) && typeof err.message === "string") {
     bounded.error = {
       ...err,
       message: truncateStringForProfile(
@@ -6814,7 +7182,7 @@ var STRICT_PROFILE_EXTRA_KEYS2 = [
   "retrieval",
   "query"
 ];
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toKey2(key) {
@@ -7194,7 +7562,7 @@ var Redactor2 = class {
       });
       return out;
     }
-    if (isRecord11(value)) {
+    if (isRecord12(value)) {
       if (state.seen.has(value)) return state.seen.get(value);
       const out = {};
       state.seen.set(value, out);
@@ -7613,7 +7981,18 @@ async function callReadOnlyTool(context, name, args = {}) {
         toolNames: [...facts.toolsByName.keys()].sort((a, b) => a.localeCompare(b)),
         llmCount: facts.llmEvents.length,
         outcomeCount: facts.outcomeEvents.length,
-        note: "Bounded TraceFacts summary only; raw events and prompts are not included."
+        failureRoleCounts: facts.summary.failureRoleCounts ?? {
+          transient: 0,
+          recovered: 0,
+          terminal: 0,
+          unknown: 0
+        },
+        failureFactIds: facts.failureFacts.map((fact) => ({
+          eventId: fact.eventId,
+          role: fact.role,
+          confidence: fact.confidence
+        })),
+        note: "Bounded TraceFacts summary only; raw events, prompts, and error bodies are not included. Failure roles are derived classifications over recorded evidence."
       },
       context
     );