agent-inspect 6.19.0 → 6.20.0

package/packages/core/dist/exporters.cjs

@@ -1455,9 +1455,63 @@ function formatTimestamp(timestamp) {
 function isFiniteNumber(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
+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"
@@ -1511,27 +1565,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) {