agent-inspect 6.31.12 → 6.31.13

package/packages/cli/dist/index.cjs

@@ -3411,12 +3411,14 @@ function topKinds(run) {
 function countErrorNodes(nodes) {
   return nodes.filter((entry) => entry.node.event.status === "error").length;
 }
+function isExecutionStepKind(kind) {
+  return kind !== "RUN" && kind !== "OUTCOME";
+}
 function slowestNode(nodes) {
   return nodes.filter(
     (entry) => entry.node.event.durationMs !== void 0 && // The RUN boundary spans the whole run, so its duration always dominates
-    // and shadows every real step. Rank actual work nodes only, matching the
-    // stats slowest-step ranking, which never counts the run envelope.
-    entry.node.event.kind !== "RUN"
+    // and shadows every real step. OUTCOME is a linked result, not execution.
+    isExecutionStepKind(entry.node.event.kind)
   ).sort((a, b) => {
     const delta = (b.node.event.durationMs ?? 0) - (a.node.event.durationMs ?? 0);
     return delta !== 0 ? delta : a.index - b.index;
@@ -3469,6 +3471,12 @@ function buildFacts(run, redactor, events) {
     const scoped = events.filter((event) => event.runId === run.runId);
     const { logicalEvents: logical } = projectLogicalEvents(scoped);
     const logicalSteps = logical.filter((event) => event.kind !== "RUN");
+    const executionSteps = logical.filter((event) => isExecutionStepKind(event.kind));
+    const executionByKind = {
+      LLM: executionSteps.filter((event) => event.kind === "LLM").length,
+      TOOL: executionSteps.filter((event) => event.kind === "TOOL").length,
+      LOGIC: executionSteps.filter((event) => event.kind === "LOGIC").length
+    };
     facts.push(
       fact("run.rawEventCount", "Raw persisted event count", scoped.length, redactor),
       fact(
@@ -3482,9 +3490,21 @@ function buildFacts(run, redactor, events) {
         "Logical lifecycle event count (including RUN)",
         logical.length,
         redactor
+      ),
+      fact(
+        "run.executionStepCount",
+        "Execution step count (excludes RUN and OUTCOME)",
+        executionSteps.length,
+        redactor
+      ),
+      fact(
+        "run.executionStepKinds",
+        "Execution step kind counts",
+        executionByKind,
+        redactor
       )
     );
-    const slowestLogical = [...logicalSteps].filter((event) => typeof event.durationMs === "number").sort((a, b) => {
+    const slowestLogical = [...executionSteps].filter((event) => typeof event.durationMs === "number").sort((a, b) => {
       const delta = (b.durationMs ?? 0) - (a.durationMs ?? 0);
       return delta !== 0 ? delta : a.eventId.localeCompare(b.eventId);
     })[0];
@@ -12739,6 +12759,57 @@ function linkNodesVisibilityFirst(nodes) {
     }
   };
 }
+function resolveRunTiming(sorted, status) {
+  let startedAtMs;
+  let endedAtMs;
+  let explicitDurationMs;
+  for (const event of sorted) {
+    if (event.kind !== "RUN") continue;
+    const attrs = event.attributes ?? {};
+    if (typeof attrs.startedAtMs === "number" && Number.isFinite(attrs.startedAtMs)) {
+      startedAtMs = startedAtMs === void 0 ? attrs.startedAtMs : Math.min(startedAtMs, attrs.startedAtMs);
+    }
+    if (typeof attrs.endedAtMs === "number" && Number.isFinite(attrs.endedAtMs)) {
+      endedAtMs = endedAtMs === void 0 ? attrs.endedAtMs : Math.max(endedAtMs, attrs.endedAtMs);
+    }
+    if ((event.status === "ok" || event.status === "error") && typeof event.durationMs === "number" && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+      explicitDurationMs = event.durationMs;
+      if (endedAtMs === void 0 && startedAtMs !== void 0) {
+        endedAtMs = startedAtMs + event.durationMs;
+      } else if (endedAtMs === void 0 && Number.isFinite(event.timestamp)) {
+        endedAtMs = event.timestamp + event.durationMs;
+        if (startedAtMs === void 0) {
+          startedAtMs = event.timestamp;
+        }
+      }
+    }
+    if (startedAtMs === void 0 && event.status === "running" && Number.isFinite(event.timestamp)) {
+      startedAtMs = event.timestamp;
+    }
+  }
+  if (startedAtMs !== void 0 && endedAtMs !== void 0 && Number.isFinite(startedAtMs) && Number.isFinite(endedAtMs) && endedAtMs >= startedAtMs && status !== "running") {
+    return {
+      startedAt: startedAtMs,
+      endedAt: endedAtMs,
+      durationMs: endedAtMs - startedAtMs
+    };
+  }
+  if (startedAtMs !== void 0 && explicitDurationMs !== void 0 && status !== "running") {
+    return {
+      startedAt: startedAtMs,
+      endedAt: startedAtMs + explicitDurationMs,
+      durationMs: explicitDurationMs
+    };
+  }
+  const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
+  const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
+  const durationMs2 = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
+  return {
+    startedAt,
+    endedAt: status === "running" ? void 0 : endedAt,
+    durationMs: durationMs2
+  };
+}
 var TreeBuilder;
 var init_tree_builder = __esm({
   "packages/core/src/logs/tree-builder.ts"() {
@@ -12771,18 +12842,16 @@ var init_tree_builder = __esm({
             inc(confidenceBreakdown, e.confidence);
             kinds[e.kind] = (kinds[e.kind] ?? 0) + 1;
           }
-          const startedAt = sorted.length > 0 ? sorted[0].timestamp : void 0;
-          const endedAt = sorted.length > 0 ? sorted[sorted.length - 1].timestamp : void 0;
-          const status = computeRunStatus(sorted);
-          const durationMs2 = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
           const name = sorted.find((e) => e.kind === "RUN")?.name;
+          const status = computeRunStatus(sorted);
+          const timing = resolveRunTiming(sorted, status);
           out.push({
             runId,
             name,
             status,
-            startedAt,
-            endedAt: status === "running" ? void 0 : endedAt,
-            durationMs: durationMs2,
+            startedAt: timing.startedAt,
+            endedAt: timing.endedAt,
+            durationMs: timing.durationMs,
             children: roots,
             metadata: {
               totalEvents: sorted.length,
@@ -16760,7 +16829,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.31.12";
+var version = "6.31.13";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -19554,7 +19623,14 @@ function exportOtlpJson(tree, options) {
 
 // packages/core/src/exporters/validation.ts
 var EXPERIMENTAL = "Experimental compatibility export \u2014 verify against your target tooling before relying on it.";
+var UINT64_MAX = 18446744073709551615n;
+var INT64_MIN = -9223372036854775808n;
+var INT64_MAX = 9223372036854775807n;
+var MAX_ANYVALUE_DEPTH = 8;
+var MAX_ANYVALUE_ELEMENTS = 256;
+var MAX_DIAGNOSTIC_ERRORS = 64;
 function pushPath(errors, path44, message) {
+  if (errors.length >= MAX_DIAGNOSTIC_ERRORS) return;
   errors.push(`${path44}: ${message}`);
 }
 function isRecord16(value) {
@@ -19563,7 +19639,59 @@ function isRecord16(value) {
 function isHexId(value, byteLen) {
   return typeof value === "string" && new RegExp(`^[0-9a-fA-F]{${byteLen * 2}}$`).test(value);
 }
-function validateAnyValue(errors, path44, value) {
+function parseDecimalIntegerString(value) {
+  if (typeof value !== "string" || !/^-?\d+$/.test(value)) {
+    return { ok: false, reason: "must be a decimal integer string" };
+  }
+  try {
+    return { ok: true, n: BigInt(value) };
+  } catch {
+    return { ok: false, reason: "out of integer range" };
+  }
+}
+function validateUint64String(errors, path44, value, label) {
+  const parsed = parseDecimalIntegerString(value);
+  if (!parsed.ok) {
+    pushPath(errors, path44, `${label} ${parsed.reason}`);
+    return;
+  }
+  if (parsed.n < 0n || parsed.n > UINT64_MAX) {
+    pushPath(
+      errors,
+      path44,
+      `${label} must be an unsigned 64-bit integer (0..${UINT64_MAX.toString()})`
+    );
+  }
+}
+function validateInt64String(errors, path44, value) {
+  const parsed = parseDecimalIntegerString(value);
+  if (!parsed.ok) {
+    pushPath(errors, path44, parsed.reason);
+    return;
+  }
+  if (parsed.n < INT64_MIN || parsed.n > INT64_MAX) {
+    pushPath(
+      errors,
+      path44,
+      `must be a signed 64-bit integer (${INT64_MIN.toString()}..${INT64_MAX.toString()})`
+    );
+  }
+}
+function validateAnyValue(errors, path44, value, depth = 0, counters = { elements: 0 }) {
+  if (errors.length >= MAX_DIAGNOSTIC_ERRORS) return;
+  if (depth > MAX_ANYVALUE_DEPTH) {
+    pushPath(errors, path44, `AnyValue nesting exceeds depth ${MAX_ANYVALUE_DEPTH}`);
+    return;
+  }
+  counters.elements += 1;
+  if (counters.elements > MAX_ANYVALUE_ELEMENTS) {
+    pushPath(
+      errors,
+      path44,
+      `AnyValue element count exceeds ${MAX_ANYVALUE_ELEMENTS}`
+    );
+    return;
+  }
   if (!isRecord16(value)) {
     pushPath(errors, path44, "must be an AnyValue object");
     return;
@@ -19583,13 +19711,99 @@ function validateAnyValue(errors, path44, value) {
       path44,
       `AnyValue must set exactly one variant (found ${variants.length}: ${variants.join(",")})`
     );
+    return;
   }
-  if (value.intValue !== void 0) {
-    if (typeof value.intValue !== "string" || !/^-?\d+$/.test(value.intValue)) {
-      pushPath(errors, `${path44}.intValue`, "must be a decimal integer string");
+  const arm = variants[0];
+  switch (arm) {
+    case "stringValue":
+      if (typeof value.stringValue !== "string") {
+        pushPath(errors, `${path44}.stringValue`, "must be a string");
+      }
+      break;
+    case "boolValue":
+      if (typeof value.boolValue !== "boolean") {
+        pushPath(errors, `${path44}.boolValue`, "must be a boolean");
+      }
+      break;
+    case "intValue":
+      validateInt64String(errors, `${path44}.intValue`, value.intValue);
+      break;
+    case "doubleValue":
+      if (typeof value.doubleValue !== "number" || !Number.isFinite(value.doubleValue)) {
+        pushPath(errors, `${path44}.doubleValue`, "must be a finite number");
+      }
+      break;
+    case "bytesValue":
+      if (typeof value.bytesValue !== "string") {
+        pushPath(errors, `${path44}.bytesValue`, "must be a base64 string");
+      }
+      break;
+    case "arrayValue": {
+      if (!isRecord16(value.arrayValue)) {
+        pushPath(errors, `${path44}.arrayValue`, "must be an object");
+        break;
+      }
+      const values = value.arrayValue.values;
+      if (values === void 0) break;
+      if (!Array.isArray(values)) {
+        pushPath(errors, `${path44}.arrayValue.values`, "must be an array");
+        break;
+      }
+      values.forEach((item, i) => {
+        validateAnyValue(
+          errors,
+          `${path44}.arrayValue.values[${i}]`,
+          item,
+          depth + 1,
+          counters
+        );
+      });
+      break;
+    }
+    case "kvlistValue": {
+      if (!isRecord16(value.kvlistValue)) {
+        pushPath(errors, `${path44}.kvlistValue`, "must be an object");
+        break;
+      }
+      const values = value.kvlistValue.values;
+      if (values === void 0) break;
+      if (!Array.isArray(values)) {
+        pushPath(errors, `${path44}.kvlistValue.values`, "must be an array");
+        break;
+      }
+      values.forEach((item, i) => {
+        const itemPath = `${path44}.kvlistValue.values[${i}]`;
+        if (!isRecord16(item)) {
+          pushPath(errors, itemPath, "must be a KeyValue object");
+          return;
+        }
+        if (typeof item.key !== "string") {
+          pushPath(errors, `${itemPath}.key`, "must be a string");
+        }
+        validateAnyValue(errors, `${itemPath}.value`, item.value, depth + 1, counters);
+      });
+      break;
     }
   }
 }
+function validateKeyValueList(errors, path44, attrs) {
+  if (attrs === void 0) return;
+  if (!Array.isArray(attrs)) {
+    pushPath(errors, path44, "must be an array");
+    return;
+  }
+  attrs.forEach((attr, ai) => {
+    const attrPath = `${path44}[${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);
+  });
+}
 function validateOtlpJson(content) {
   const errors = [];
   const warnings = [
@@ -19618,6 +19832,13 @@ function validateOtlpJson(content) {
       pushPath(errors, rsPath, "must be an object");
       return;
     }
+    if (isRecord16(resourceSpan.resource)) {
+      validateKeyValueList(
+        errors,
+        `${rsPath}.resource.attributes`,
+        resourceSpan.resource.attributes
+      );
+    }
     if (!Array.isArray(resourceSpan.scopeSpans)) {
       pushPath(errors, `${rsPath}.scopeSpans`, "must be an array");
       return;
@@ -19628,6 +19849,13 @@ function validateOtlpJson(content) {
         pushPath(errors, ssPath, "must be an object");
         return;
       }
+      if (isRecord16(scopeSpan.scope)) {
+        validateKeyValueList(
+          errors,
+          `${ssPath}.scope.attributes`,
+          scopeSpan.scope.attributes
+        );
+      }
       if (!Array.isArray(scopeSpan.spans)) {
         pushPath(errors, `${ssPath}.spans`, "must be an array");
         return;
@@ -19662,44 +19890,58 @@ function validateOtlpJson(content) {
         if (typeof span.name !== "string") {
           pushPath(errors, `${spanPath}.name`, "must be a string");
         }
-        if (typeof span.startTimeUnixNano !== "string" || !/^\d+$/.test(span.startTimeUnixNano)) {
-          pushPath(
-            errors,
-            `${spanPath}.startTimeUnixNano`,
-            "must be a decimal-string 64-bit integer"
-          );
-        }
-        if (span.endTimeUnixNano !== void 0 && (typeof span.endTimeUnixNano !== "string" || !/^\d+$/.test(span.endTimeUnixNano))) {
-          pushPath(
+        validateUint64String(
+          errors,
+          `${spanPath}.startTimeUnixNano`,
+          span.startTimeUnixNano,
+          "startTimeUnixNano"
+        );
+        if (span.endTimeUnixNano !== void 0) {
+          validateUint64String(
             errors,
             `${spanPath}.endTimeUnixNano`,
-            "must be a decimal-string 64-bit integer when present"
+            span.endTimeUnixNano,
+            "endTimeUnixNano"
           );
         }
-        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(
+        if (typeof span.startTimeUnixNano === "string" && typeof span.endTimeUnixNano === "string") {
+          const start = parseDecimalIntegerString(span.startTimeUnixNano);
+          const end = parseDecimalIntegerString(span.endTimeUnixNano);
+          if (start.ok && end.ok && end.n < start.n) {
+            pushPath(
+              errors,
+              `${spanPath}.endTimeUnixNano`,
+              "must be >= startTimeUnixNano"
+            );
+          }
+        }
+        validateKeyValueList(errors, `${spanPath}.attributes`, span.attributes);
+        if (Array.isArray(span.events)) {
+          span.events.forEach((event, ei) => {
+            const eventPath = `${spanPath}.events[${ei}]`;
+            if (!isRecord16(event)) {
+              pushPath(errors, eventPath, "must be an object");
+              return;
+            }
+            if (event.timeUnixNano !== void 0) {
+              validateUint64String(
                 errors,
-                `${spanPath}.endTimeUnixNano`,
-                "must be >= startTimeUnixNano"
+                `${eventPath}.timeUnixNano`,
+                event.timeUnixNano,
+                "timeUnixNano"
               );
             }
-          } catch {
-            pushPath(errors, `${spanPath}.endTimeUnixNano`, "out of integer range");
-          }
+            validateKeyValueList(errors, `${eventPath}.attributes`, event.attributes);
+          });
         }
-        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");
+        if (Array.isArray(span.links)) {
+          span.links.forEach((link, li) => {
+            const linkPath = `${spanPath}.links[${li}]`;
+            if (!isRecord16(link)) {
+              pushPath(errors, linkPath, "must be an object");
               return;
             }
-            if (typeof attr.key !== "string") {
-              pushPath(errors, `${attrPath}.key`, "must be a string");
-            }
-            validateAnyValue(errors, `${attrPath}.value`, attr.value);
+            validateKeyValueList(errors, `${linkPath}.attributes`, link.attributes);
           });
         }
         if (typeof span.kind === "number") {