agent-inspect 6.31.7 → 6.31.9

package/packages/cli/dist/index.cjs

@@ -1252,11 +1252,23 @@ var init_trace_event_safety = __esm({
     init_persisted_inspect_event();
   }
 });
+function getSharedContextStorage() {
+  const host = globalThis;
+  const existing = host[GLOBAL_CONTEXT_ALS_KEY];
+  if (existing instanceof async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const created = new async_hooks.AsyncLocalStorage();
+  host[GLOBAL_CONTEXT_ALS_KEY] = created;
+  return created;
+}
+var GLOBAL_CONTEXT_ALS_KEY;
 var init_context = __esm({
   "packages/core/src/context.ts"() {
     init_correlation_metadata();
     init_trace_event_safety();
-    new async_hooks.AsyncLocalStorage();
+    GLOBAL_CONTEXT_ALS_KEY = "agent-inspect:execution-context-als:v1";
+    getSharedContextStorage();
   }
 });
 var init_inspector_runtime = __esm({
@@ -6524,6 +6536,45 @@ function createToolOrderingRule(options) {
     requireEndpoints: false
   });
 }
+function createToolFailureRule(options) {
+  return {
+    id: "tool.failures",
+    category: "tool",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const tools = finishedEvents(context, "TOOL");
+      const failures = tools.filter((event) => event.status === "error");
+      const retries = tools.map((event) => ({ event, count: retryCount(event) })).filter((item) => item.count !== void 0);
+      const findings = [];
+      if (options.maxFailures !== void 0 && failures.length > options.maxFailures) {
+        findings.push(
+          failFinding(
+            "tool.failures",
+            `Tool failure count ${failures.length} exceeded ${options.maxFailures}.`,
+            failures.map((event) => eventEvidence(event)),
+            { maxFailures: options.maxFailures },
+            failures.length
+          )
+        );
+      }
+      if (options.maxRetries !== void 0) {
+        const excessiveRetries = retries.filter((item) => item.count > options.maxRetries);
+        if (excessiveRetries.length > 0) {
+          findings.push(
+            failFinding(
+              "tool.failures",
+              `Tool retry count exceeded ${options.maxRetries}.`,
+              excessiveRetries.map((item) => eventEvidence(item.event, "attributes.retryCount")),
+              { maxRetries: options.maxRetries },
+              excessiveRetries.map((item) => ({ tool: toolName(item.event), retries: item.count }))
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
 function createLlmUsageRule(options) {
   return {
     id: "llm.usage",
@@ -12618,14 +12669,20 @@ var init_to_inspect_event = __esm({
 });
 
 // packages/core/src/persisted/tree-bridge.ts
+function logicalToPersisted(event) {
+  const { sourceEventIds: _sourceEventIds, projection: _projection, ...rest } = event;
+  return rest;
+}
 function persistedInspectEventsToRunTrees(events, options) {
-  const inspectEvents = persistedInspectEventsToInspectEvents(events, {
+  const sourceEvents = options?.coalesceLifecycle === true ? projectLogicalEvents(events).logicalEvents.map(logicalToPersisted) : events;
+  const inspectEvents = persistedInspectEventsToInspectEvents(sourceEvents, {
     skipInvalid: options?.skipInvalid
   });
   return new TreeBuilder().build(inspectEvents);
 }
 var init_tree_bridge = __esm({
   "packages/core/src/persisted/tree-bridge.ts"() {
+    init_logical_events();
     init_tree_builder();
     init_from_trace_event();
     init_to_inspect_event();
@@ -13246,7 +13303,7 @@ function mapOpenInferenceSpan(span, index, version2) {
   const errorMessage = isRecord11(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,
+    eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : `${traceId}:${spanId}`,
     runId: typeof rawAttributes["agent_inspect.run_id"] === "string" ? rawAttributes["agent_inspect.run_id"] : traceId,
     kind,
     name,
@@ -13297,12 +13354,16 @@ function mapOpenInferenceEvents(document) {
   const mapped = document.spans.map(
     (span, index) => mapOpenInferenceSpan(span, index, document.version)
   );
-  const spanIdToEventId = new Map(
-    mapped.map((span) => [span.spanId, span.event.eventId])
+  const spanKeyToEventId = new Map(
+    mapped.map((span) => {
+      const traceId = typeof span.event.trace?.traceId === "string" ? span.event.trace.traceId : "";
+      return [`${traceId}:${span.spanId}`, span.event.eventId];
+    })
   );
   for (const span of mapped) {
     if (span.parentSpanId === void 0) continue;
-    span.event.parentId = spanIdToEventId.get(span.parentSpanId) ?? span.parentSpanId;
+    const traceId = typeof span.event.trace?.traceId === "string" ? span.event.trace.traceId : "";
+    span.event.parentId = spanKeyToEventId.get(`${traceId}:${span.parentSpanId}`) ?? span.parentSpanId;
   }
   return {
     events: mapped.map((span) => span.event),
@@ -13773,7 +13834,7 @@ function mapOtlpSpan(context) {
   const errorMessage = isRecord11(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,
+    eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : `${traceId}:${spanId}`,
     runId: typeof parsedSpanAttributes.attributes["agent_inspect.run_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.run_id"] : traceId,
     kind,
     name: readStringField(span, ["name"]) ?? spanId,
@@ -13822,12 +13883,16 @@ function mapOtlpSpan(context) {
 }
 function mapOtlpEventsToPersisted(document) {
   const mapped = document.spans.map((span) => mapOtlpSpan(span));
-  const spanIdToEventId = new Map(
-    mapped.map((span) => [span.spanId, span.event.eventId])
+  const spanKeyToEventId = new Map(
+    mapped.map((span) => {
+      const traceId = typeof span.event.trace?.traceId === "string" ? span.event.trace.traceId : "";
+      return [`${traceId}:${span.spanId}`, span.event.eventId];
+    })
   );
   for (const span of mapped) {
     if (span.parentSpanId === void 0) continue;
-    span.event.parentId = spanIdToEventId.get(span.parentSpanId) ?? span.parentSpanId;
+    const traceId = typeof span.event.trace?.traceId === "string" ? span.event.trace.traceId : "";
+    span.event.parentId = spanKeyToEventId.get(`${traceId}:${span.parentSpanId}`) ?? span.parentSpanId;
   }
   return {
     events: mapped.map((span) => span.event),
@@ -14283,18 +14348,36 @@ var init_readers = __esm({
 function diagnostic5(code, message, severity = "error", caseId) {
   return { code, message, severity, ...caseId !== void 0 ? { caseId } : {} };
 }
-function buildCaseRules(suiteCase, config) {
+function buildCaseAssertions(suiteCase, config) {
   const rules = [];
   const select = new Set(config.checks?.select ?? []);
-  if (select.has("run.status")) {
+  const configDiagnostics = [];
+  const evalConfig = config.eval;
+  const declaredSelect = [...select];
+  for (const id of declaredSelect) {
+    if (!KNOWN_SUITE_SELECT_IDS.has(id)) {
+      configDiagnostics.push(
+        diagnostic5(
+          "AI_SUITE_UNKNOWN_SELECTOR",
+          `Unknown or unsupported suite check selector "${id}".`,
+          "error",
+          suiteCase.id
+        )
+      );
+    }
+  }
+  if (select.has("run.status") || evalConfig?.requireSuccess === true) {
     rules.push(createRunStatusRule());
+    select.add("run.status");
   }
   const requiredTools = [
     ...config.checks?.tool?.required ?? [],
+    ...evalConfig?.requiredTools ?? [],
     ...suiteCase.requireTools ?? []
   ];
   const forbiddenTools = [
     ...config.checks?.tool?.forbidden ?? [],
+    ...evalConfig?.forbiddenTools ?? [],
     ...suiteCase.forbidTools ?? []
   ];
   if (requiredTools.length > 0 || forbiddenTools.length > 0) {
@@ -14306,20 +14389,51 @@ function buildCaseRules(suiteCase, config) {
     );
     select.add("tool.usage");
   }
-  const maxDurationMs = suiteCase.maxDurationMs ?? config.checks?.run?.maxDurationMs ?? config.eval?.maxDurationMs;
+  const maxDurationMs = suiteCase.maxDurationMs ?? config.checks?.run?.maxDurationMs ?? evalConfig?.maxDurationMs;
   if (maxDurationMs !== void 0) {
     rules.push(createRunDurationRule({ maxDurationMs }));
     select.add("run.duration");
   }
-  const llm = config.checks?.llm;
-  if (llm?.allowedModels !== void 0 || llm?.maxTotalTokens !== void 0) {
-    rules.push(createLlmUsageRule(llm));
+  const maxDepth = config.checks?.run?.maxDepth ?? evalConfig?.maxDepth;
+  if (maxDepth !== void 0) {
+    rules.push(createRunDepthRule({ maxDepth }));
+    select.add("run.depth");
+  }
+  if (evalConfig?.maxRetries !== void 0) {
+    rules.push(createToolFailureRule({ maxRetries: evalConfig.maxRetries }));
+    select.add("tool.failures");
+  }
+  const allowedModels = config.checks?.llm?.allowedModels;
+  const maxTotalTokens = config.checks?.llm?.maxTotalTokens ?? evalConfig?.maxTotalTokens;
+  if (allowedModels !== void 0 || maxTotalTokens !== void 0) {
+    rules.push(
+      createLlmUsageRule({
+        ...allowedModels !== void 0 ? { allowedModels } : {},
+        ...maxTotalTokens !== void 0 ? { maxTotalTokens } : {}
+      })
+    );
     select.add("llm.usage");
   }
   if (select.has("outcome.status")) {
     rules.push(createObservedOutcomeRule({ failOn: ["failed"] }));
   }
-  return { rules, select: [...select] };
+  const observationCount = suiteCase.expectedObservations?.length ?? 0;
+  if (rules.length === 0 && observationCount === 0 && configDiagnostics.length === 0) {
+    configDiagnostics.push(
+      diagnostic5(
+        "AI_SUITE_NO_ASSERTIONS",
+        `Suite case "${suiteCase.id}" declares no effective checks, eval controls, or expected observations.`,
+        "error",
+        suiteCase.id
+      )
+    );
+  }
+  return {
+    rules,
+    select: [...select],
+    observationCount,
+    configDiagnostics
+  };
 }
 function outcomesFromRead(read) {
   const persistedOutcomes = extractOutcomesFromPersistedEvents(
@@ -14400,8 +14514,20 @@ async function runSuiteCase(suiteCase, config, options) {
       ]
     };
   }
-  const { rules, select } = buildCaseRules(suiteCase, config);
-  const checkResult = rules.length > 0 ? runTraceChecks({ read }, { rules, select }) : {
+  const compiled = buildCaseAssertions(suiteCase, config);
+  if (compiled.configDiagnostics.length > 0) {
+    return {
+      id: suiteCase.id,
+      status: "error",
+      tracePath: resolved.tracePath,
+      ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
+      checkOk: false,
+      ...config.eval?.requireSuccess === true ? { evalOk: false } : {},
+      message: compiled.configDiagnostics.map((item) => item.message).join("; "),
+      diagnostics: compiled.configDiagnostics
+    };
+  }
+  const checkResult = compiled.rules.length > 0 ? runTraceChecks({ read }, { rules: compiled.rules, select: compiled.select }) : {
     ok: true,
     status: "pass",
     format: read.format,
@@ -14429,6 +14555,9 @@ async function runSuiteCase(suiteCase, config, options) {
   ];
   const checkOk = checkResult.ok;
   const observationsOk = observationResult.ok;
+  const evalOk = config.eval?.requireSuccess === true ? checkResult.findings.every(
+    (finding) => finding.ruleId !== "run.status" || finding.status !== "fail"
+  ) && checkResult.diagnostics.every((item) => item.severity !== "error") : void 0;
   const ok = checkOk && observationsOk;
   const status = ok ? "pass" : checkResult.status === "error" ? "error" : "fail";
   return {
@@ -14437,6 +14566,7 @@ async function runSuiteCase(suiteCase, config, options) {
     tracePath: resolved.tracePath,
     ...resolved.runId !== void 0 ? { runId: resolved.runId } : {},
     checkOk,
+    ...evalOk !== void 0 ? { evalOk } : {},
     observationsOk,
     diagnostics,
     ...ok ? {} : {
@@ -14481,6 +14611,7 @@ async function runSuite(options = {}) {
     diagnostics
   };
 }
+var KNOWN_SUITE_SELECT_IDS;
 var init_run = __esm({
   "packages/core/src/suite/run.ts"() {
     init_checks2();
@@ -14488,6 +14619,15 @@ var init_run = __esm({
     init_readers();
     init_load2();
     init_resolve2();
+    KNOWN_SUITE_SELECT_IDS = /* @__PURE__ */ new Set([
+      "run.status",
+      "run.duration",
+      "run.depth",
+      "outcome.status",
+      "tool.usage",
+      "tool.failures",
+      "llm.usage"
+    ]);
   }
 });
 
@@ -16235,7 +16375,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.31.7";
+var version = "6.31.9";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -18770,11 +18910,13 @@ function exportOpenInference(tree, options) {
       endNs = startNs + unixNano(ev.durationMs);
     }
     const { openInferenceKind } = mapInspectKindToOI(ev.kind, warnings);
+    const meta2 = ev.attributes;
+    const originalSource = typeof meta2?.originalSourceType === "string" && meta2.originalSourceType.trim() !== "" ? meta2.originalSourceType.trim() : ev.source.type;
     const attrs = {
       "openinference.span.kind": openInferenceKind,
       "agent_inspect.kind": ev.kind,
       "agent_inspect.confidence": ev.confidence,
-      "agent_inspect.source.type": ev.source.type,
+      "agent_inspect.source.type": originalSource,
       "agent_inspect.run_id": tree.runId,
       "agent_inspect.event_id": ev.eventId,
       "agent_inspect.status": ev.status ?? "unset"
@@ -18782,9 +18924,9 @@ function exportOpenInference(tree, options) {
     if (ev.durationMs !== void 0) {
       attrs["agent_inspect.duration_ms"] = ev.durationMs;
     }
-    const meta2 = ev.attributes;
-    if (meta2?.model !== void 0 && typeof meta2.model === "string") {
-      attrs["llm.model_name"] = meta2.model;
+    const requestModel = (typeof meta2?.model === "string" && meta2.model.trim() !== "" ? meta2.model : void 0) ?? (typeof meta2?.modelId === "string" && meta2.modelId.trim() !== "" ? meta2.modelId : void 0);
+    if (requestModel !== void 0) {
+      attrs["llm.model_name"] = requestModel;
     }
     const tokens = meta2?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
@@ -18794,8 +18936,9 @@ function exportOpenInference(tree, options) {
       if (typeof outp === "number") attrs["llm.token_count.completion"] = outp;
     }
     if (includeAttributes && meta2 && typeof meta2 === "object") {
+      const skipKeys = /* @__PURE__ */ new Set(["tokens", "model", "modelId", "originalSourceType"]);
       for (const [k, v] of Object.entries(meta2)) {
-        if (k === "tokens" || k === "model") continue;
+        if (skipKeys.has(k)) continue;
         if (v !== void 0 && v !== null && typeof v !== "object") {
           attrs[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
         }
@@ -18916,24 +19059,33 @@ function exportOtlpJson(tree, options) {
     const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
     const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
     const { startNs, endNs } = resolveSpanTimes(ev);
+    const meta2 = ev.attributes;
+    const originalSource = typeof meta2?.originalSourceType === "string" && meta2.originalSourceType.trim() !== "" ? meta2.originalSourceType.trim() : ev.source.type;
     const attrs = [
       stringAttr2("agent_inspect.kind", ev.kind),
       stringAttr2("agent_inspect.confidence", ev.confidence),
-      stringAttr2("agent_inspect.source.type", ev.source.type),
+      stringAttr2("agent_inspect.source.type", originalSource),
       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));
+      attrs.push(numberAttr("agent_inspect.duration_ms", ev.durationMs));
     }
     const op = genAiOperationName(ev.kind);
     if (op !== void 0) {
       attrs.push(stringAttr2("gen_ai.operation.name", op));
     }
-    const meta2 = ev.attributes;
-    if (meta2?.model !== void 0 && typeof meta2.model === "string") {
-      attrs.push(stringAttr2("gen_ai.request.model", meta2.model.slice(0, maxLen)));
+    const requestModel = (typeof meta2?.model === "string" && meta2.model.trim() !== "" ? meta2.model : void 0) ?? (typeof meta2?.modelId === "string" && meta2.modelId.trim() !== "" ? meta2.modelId : void 0);
+    if (requestModel !== void 0) {
+      attrs.push(stringAttr2("gen_ai.request.model", requestModel.slice(0, maxLen)));
+    }
+    const responseModel = typeof meta2?.responseModelId === "string" && meta2.responseModelId.trim() !== "" ? meta2.responseModelId : typeof meta2?.responseModel === "string" && meta2.responseModel.trim() !== "" ? meta2.responseModel : void 0;
+    if (responseModel !== void 0) {
+      attrs.push(stringAttr2("gen_ai.response.model", responseModel.slice(0, maxLen)));
+    }
+    if (typeof meta2?.provider === "string" && meta2.provider.trim() !== "") {
+      attrs.push(stringAttr2("gen_ai.provider.name", meta2.provider.slice(0, maxLen)));
     }
     const tokens = meta2?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
@@ -18943,8 +19095,17 @@ function exportOtlpJson(tree, options) {
       if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
     }
     if (includeAttributes && meta2 && typeof meta2 === "object") {
+      const skipKeys = /* @__PURE__ */ new Set([
+        "tokens",
+        "model",
+        "modelId",
+        "responseModel",
+        "responseModelId",
+        "provider",
+        "originalSourceType"
+      ]);
       for (const [k, v] of Object.entries(meta2)) {
-        if (k === "tokens" || k === "model") continue;
+        if (skipKeys.has(k)) continue;
         if (typeof v === "string") {
           attrs.push(stringAttr2(`agent_inspect.preview.${k}`, v.slice(0, maxLen)));
         } else if (typeof v === "number" && Number.isFinite(v)) {
@@ -19014,12 +19175,42 @@ function pushPath(errors, path44, message) {
 function isRecord16(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isHexId(value, byteLen) {
+  return typeof value === "string" && new RegExp(`^[0-9a-fA-F]{${byteLen * 2}}$`).test(value);
+}
+function validateAnyValue(errors, path44, value) {
+  if (!isRecord16(value)) {
+    pushPath(errors, path44, "must be an AnyValue object");
+    return;
+  }
+  const variants = [
+    "stringValue",
+    "boolValue",
+    "intValue",
+    "doubleValue",
+    "bytesValue",
+    "arrayValue",
+    "kvlistValue"
+  ].filter((key) => value[key] !== void 0);
+  if (variants.length !== 1) {
+    pushPath(
+      errors,
+      path44,
+      `AnyValue must set exactly one variant (found ${variants.length}: ${variants.join(",")})`
+    );
+  }
+  if (value.intValue !== void 0) {
+    if (typeof value.intValue !== "string" || !/^-?\d+$/.test(value.intValue)) {
+      pushPath(errors, `${path44}.intValue`, "must be a decimal integer string");
+    }
+  }
+}
 function validateOtlpJson(content) {
   const errors = [];
   const warnings = [
     EXPERIMENTAL,
     "OTLP JSON mapping uses OTel GenAI-aligned attributes where applicable; collectors may require transformation.",
-    "protocol-valid \u2260 profile-complete \u2260 fixture-complete \u2014 nested path diagnostics report protocol shape only."
+    "producer-profile checks IDs, timing, and AnyValue shape; historical string enums are reader-compat warnings only."
   ];
   let parsed;
   try {
@@ -19062,11 +19253,26 @@ function validateOtlpJson(content) {
           pushPath(errors, spanPath, "must be an object");
           return;
         }
-        if (typeof span.traceId !== "string" || span.traceId.length === 0) {
-          pushPath(errors, `${spanPath}.traceId`, "must be a non-empty string");
+        if (!isHexId(span.traceId, 16)) {
+          pushPath(
+            errors,
+            `${spanPath}.traceId`,
+            "must be a 32-char hex trace id (16 bytes)"
+          );
+        }
+        if (!isHexId(span.spanId, 8)) {
+          pushPath(
+            errors,
+            `${spanPath}.spanId`,
+            "must be a 16-char hex span id (8 bytes)"
+          );
         }
-        if (typeof span.spanId !== "string" || span.spanId.length === 0) {
-          pushPath(errors, `${spanPath}.spanId`, "must be a non-empty string");
+        if (span.parentSpanId !== void 0 && !isHexId(span.parentSpanId, 8)) {
+          pushPath(
+            errors,
+            `${spanPath}.parentSpanId`,
+            "must be a 16-char hex span id when present"
+          );
         }
         if (typeof span.name !== "string") {
           pushPath(errors, `${spanPath}.name`, "must be a string");
@@ -19085,13 +19291,39 @@ function validateOtlpJson(content) {
             "must be a decimal-string 64-bit integer when present"
           );
         }
+        if (typeof span.startTimeUnixNano === "string" && /^\d+$/.test(span.startTimeUnixNano) && typeof span.endTimeUnixNano === "string" && /^\d+$/.test(span.endTimeUnixNano)) {
+          try {
+            if (BigInt(span.endTimeUnixNano) < BigInt(span.startTimeUnixNano)) {
+              pushPath(
+                errors,
+                `${spanPath}.endTimeUnixNano`,
+                "must be >= startTimeUnixNano"
+              );
+            }
+          } catch {
+            pushPath(errors, `${spanPath}.endTimeUnixNano`, "out of integer range");
+          }
+        }
+        if (Array.isArray(span.attributes)) {
+          span.attributes.forEach((attr, ai) => {
+            const attrPath = `${spanPath}.attributes[${ai}]`;
+            if (!isRecord16(attr)) {
+              pushPath(errors, attrPath, "must be an object");
+              return;
+            }
+            if (typeof attr.key !== "string") {
+              pushPath(errors, `${attrPath}.key`, "must be a string");
+            }
+            validateAnyValue(errors, `${attrPath}.value`, attr.value);
+          });
+        }
         if (typeof span.kind === "number") {
           if (!Number.isInteger(span.kind)) {
             pushPath(errors, `${spanPath}.kind`, "must be an integer SpanKind enum");
           }
         } else if (typeof span.kind === "string") {
           warnings.push(
-            `${spanPath}.kind: string SpanKind enum is legacy; prefer numeric (INTERNAL=1)`
+            `${spanPath}.kind: string SpanKind is historical reader-compat only; producer wire format uses numeric enums`
           );
         } else if (span.kind !== void 0) {
           pushPath(
@@ -19122,7 +19354,7 @@ function validateOtlpJson(content) {
               );
             } else {
               warnings.push(
-                `${spanPath}.status.code: string StatusCode is legacy; prefer numeric 0/1/2`
+                `${spanPath}.status.code: string StatusCode is historical reader-compat only; producer wire format uses numeric 0/1/2`
               );
             }
           } else {
@@ -19603,7 +19835,9 @@ Trace directory: ${traceDir}`);
   }
   let tree;
   try {
-    const trees = persistedInspectEventsToRunTrees(events);
+    const trees = persistedInspectEventsToRunTrees(events, {
+      coalesceLifecycle: true
+    });
     tree = trees.find((candidate) => candidate.runId === id) ?? trees[0];
     if (tree === void 0) {
       throw new Error("No run tree could be built from persisted events");
@@ -28899,13 +29133,15 @@ import { generateText, stepCountIs, tool } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 import { agentInspect } from "@agent-inspect/ai-sdk";
 import { z } from "zod";
-import { readdirSync, readFileSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 
-const TRACE_DIR = ".agent-inspect";
+const SESSION = randomUUID().slice(0, 8);
+const TRACE_DIR = path.join(".agent-inspect", \`demo-\${SESSION}\`);
 const ANSWER = "You have 2 orders";
-const CORRECT_RUN = "ai-sdk-demo-correct";
-const WRONG_RUN = "ai-sdk-demo-wrong";
+const CORRECT_RUN = \`ai-sdk-demo-correct-\${SESSION}\`;
+const WRONG_RUN = \`ai-sdk-demo-wrong-\${SESSION}\`;
 
 const usage = {
   inputTokens: { total: 4, noCache: 4, cacheRead: 0, cacheWrite: 0 },
@@ -28945,7 +29181,7 @@ async function runPath(runName, toolName) {
                   type: "tool-call",
                   toolCallId: \`call-\${toolName}\`,
                   toolName,
-                  input: { userId: "u1" },
+                  input: JSON.stringify({ userId: "u1" }),
                 },
               ],
               finishReason: { unified: "tool-calls", raw: "tool-calls" },
@@ -28997,15 +29233,39 @@ function selectRunIdByName(runName) {
   return matches[0];
 }
 
+function assertToolExecuted(runId, requiredTool) {
+  const text = readFileSync(path.join(TRACE_DIR, \`\${runId}.jsonl\`), "utf8");
+  const toolHits = text
+    .split("\\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line))
+    .filter(
+      (ev) =>
+        (ev.kind === "TOOL" || ev.attributes?.stepType === "tool") &&
+        (ev.name === requiredTool || ev.attributes?.toolName === requiredTool),
+    );
+  if (toolHits.length === 0) {
+    throw new Error(\`expected TOOL events for \${requiredTool} in \${runId}\`);
+  }
+}
+
 async function main() {
-  await runPath(CORRECT_RUN, "lookup_orders");
-  await runPath(WRONG_RUN, "delete_orders");
-  const correctId = selectRunIdByName(CORRECT_RUN);
-  const wrongId = selectRunIdByName(WRONG_RUN);
-  console.log("Trace written to .agent-inspect/");
-  console.log(\`Correct path runId: \${correctId}\`);
-  console.log(\`Wrong path runId:   \${wrongId}\`);
-  console.log(\`Next: npx agent-inspect check \${correctId} --required-tool lookup_orders\`);
+  mkdirSync(TRACE_DIR, { recursive: true });
+  try {
+    await runPath(CORRECT_RUN, "lookup_orders");
+    await runPath(WRONG_RUN, "delete_orders");
+    const correctId = selectRunIdByName(CORRECT_RUN);
+    const wrongId = selectRunIdByName(WRONG_RUN);
+    assertToolExecuted(correctId, "lookup_orders");
+    assertToolExecuted(wrongId, "delete_orders");
+    console.log(\`Trace written to \${TRACE_DIR}/\`);
+    console.log(\`Correct path runId: \${correctId}\`);
+    console.log(\`Wrong path runId:   \${wrongId}\`);
+    console.log(\`Next: npx agent-inspect check \${correctId} --dir \${TRACE_DIR} --required-tool lookup_orders\`);
+  } catch (error) {
+    rmSync(TRACE_DIR, { recursive: true, force: true });
+    throw error;
+  }
 }
 
 main().catch((error) => {