agent-inspect 6.31.11 → 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];
@@ -11918,25 +11938,45 @@ function asStringArray(value, label) {
 function asPositiveNumber(value, label) {
   if (value === void 0) return void 0;
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative number.`);
+    throw new Error(`${label} must be a non-negative finite number.`);
   }
   return value;
 }
-function asExpectConfig(value, label) {
+function asBoolean(value, label) {
   if (value === void 0) return void 0;
+  if (typeof value !== "boolean") {
+    throw new Error(`${label} must be a boolean (not a string or other type).`);
+  }
+  return value;
+}
+function assertObject(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${label} must be an object.`);
   }
-  const raw = value;
+  return value;
+}
+function assertKnownKeys(raw, allowed, label) {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(raw)) {
+    if (!allowedSet.has(key)) {
+      throw new Error(`${label} has unknown key "${key}".`);
+    }
+  }
+}
+function asExpectConfig(value, label) {
+  if (value === void 0) return void 0;
+  const raw = assertObject(value, label);
+  assertKnownKeys(raw, EXPECT_KEYS, label);
   const checkStatus = raw.checkStatus;
   if (checkStatus !== "pass" && checkStatus !== "fail" && checkStatus !== "error") {
     throw new Error(`${label}.checkStatus must be "pass", "fail", or "error".`);
   }
   const findingRuleIds = asStringArray(raw.findingRuleIds, `${label}.findingRuleIds`);
   const minAssertions = asPositiveNumber(raw.minAssertions, `${label}.minAssertions`);
-  const rejectUnexpectedFindings = raw.rejectUnexpectedFindings === void 0 ? void 0 : typeof raw.rejectUnexpectedFindings === "boolean" ? raw.rejectUnexpectedFindings : (() => {
-    throw new Error(`${label}.rejectUnexpectedFindings must be a boolean.`);
-  })();
+  const rejectUnexpectedFindings = asBoolean(
+    raw.rejectUnexpectedFindings,
+    `${label}.rejectUnexpectedFindings`
+  );
   return {
     checkStatus,
     ...findingRuleIds !== void 0 ? { findingRuleIds } : {},
@@ -11944,6 +11984,56 @@ function asExpectConfig(value, label) {
     ...minAssertions !== void 0 ? { minAssertions } : {}
   };
 }
+function asChecksConfig(value, label) {
+  const raw = assertObject(value, label);
+  assertKnownKeys(raw, CHECKS_KEYS, label);
+  const checks2 = {};
+  const select = asStringArray(raw.select, `${label}.select`);
+  if (select !== void 0) checks2.select = select;
+  if (raw.run !== void 0) {
+    const run = assertObject(raw.run, `${label}.run`);
+    assertKnownKeys(run, CHECKS_RUN_KEYS, `${label}.run`);
+    checks2.run = {
+      ...asPositiveNumber(run.maxDurationMs, `${label}.run.maxDurationMs`) !== void 0 ? { maxDurationMs: asPositiveNumber(run.maxDurationMs, `${label}.run.maxDurationMs`) } : {},
+      ...asPositiveNumber(run.maxDepth, `${label}.run.maxDepth`) !== void 0 ? { maxDepth: asPositiveNumber(run.maxDepth, `${label}.run.maxDepth`) } : {}
+    };
+  }
+  if (raw.tool !== void 0) {
+    const tool = assertObject(raw.tool, `${label}.tool`);
+    assertKnownKeys(tool, CHECKS_TOOL_KEYS, `${label}.tool`);
+    checks2.tool = {
+      ...asStringArray(tool.required, `${label}.tool.required`) !== void 0 ? { required: asStringArray(tool.required, `${label}.tool.required`) } : {},
+      ...asStringArray(tool.forbidden, `${label}.tool.forbidden`) !== void 0 ? { forbidden: asStringArray(tool.forbidden, `${label}.tool.forbidden`) } : {}
+    };
+  }
+  if (raw.llm !== void 0) {
+    const llm = assertObject(raw.llm, `${label}.llm`);
+    assertKnownKeys(llm, CHECKS_LLM_KEYS, `${label}.llm`);
+    checks2.llm = {
+      ...asStringArray(llm.allowedModels, `${label}.llm.allowedModels`) !== void 0 ? { allowedModels: asStringArray(llm.allowedModels, `${label}.llm.allowedModels`) } : {},
+      ...asPositiveNumber(llm.maxTotalTokens, `${label}.llm.maxTotalTokens`) !== void 0 ? {
+        maxTotalTokens: asPositiveNumber(
+          llm.maxTotalTokens,
+          `${label}.llm.maxTotalTokens`
+        )
+      } : {}
+    };
+  }
+  return checks2;
+}
+function asEvalConfig(value, label) {
+  const raw = assertObject(value, label);
+  assertKnownKeys(raw, EVAL_KEYS, label);
+  return {
+    ...asBoolean(raw.requireSuccess, `${label}.requireSuccess`) !== void 0 ? { requireSuccess: asBoolean(raw.requireSuccess, `${label}.requireSuccess`) } : {},
+    ...asStringArray(raw.requiredTools, `${label}.requiredTools`) !== void 0 ? { requiredTools: asStringArray(raw.requiredTools, `${label}.requiredTools`) } : {},
+    ...asStringArray(raw.forbiddenTools, `${label}.forbiddenTools`) !== void 0 ? { forbiddenTools: asStringArray(raw.forbiddenTools, `${label}.forbiddenTools`) } : {},
+    ...asPositiveNumber(raw.maxDurationMs, `${label}.maxDurationMs`) !== void 0 ? { maxDurationMs: asPositiveNumber(raw.maxDurationMs, `${label}.maxDurationMs`) } : {},
+    ...asPositiveNumber(raw.maxDepth, `${label}.maxDepth`) !== void 0 ? { maxDepth: asPositiveNumber(raw.maxDepth, `${label}.maxDepth`) } : {},
+    ...asPositiveNumber(raw.maxRetries, `${label}.maxRetries`) !== void 0 ? { maxRetries: asPositiveNumber(raw.maxRetries, `${label}.maxRetries`) } : {},
+    ...asPositiveNumber(raw.maxTotalTokens, `${label}.maxTotalTokens`) !== void 0 ? { maxTotalTokens: asPositiveNumber(raw.maxTotalTokens, `${label}.maxTotalTokens`) } : {}
+  };
+}
 function validateCaseConfig(value, index) {
   const diagnostics = [];
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -11954,6 +12044,7 @@ function validateCaseConfig(value, index) {
   }
   const raw = value;
   try {
+    assertKnownKeys(raw, CASE_KEYS, `cases[${index}]`);
     const id = asString(raw.id, `cases[${index}].id`);
     if (id === void 0) {
       diagnostics.push(
@@ -12002,6 +12093,7 @@ function normalizeSuiteConfig(value) {
     throw new Error("Suite config must export an object.");
   }
   const raw = value;
+  assertKnownKeys(raw, ROOT_KEYS, "suite config");
   const name = asString(raw.name, "name");
   const traces = asString(raw.traces, "traces");
   if (name === void 0) throw new Error("name is required.");
@@ -12030,25 +12122,15 @@ function normalizeSuiteConfig(value) {
   }
   const config = { name, traces, cases };
   if (raw.checks !== void 0) {
-    if (typeof raw.checks !== "object" || Array.isArray(raw.checks)) {
-      throw new Error("checks must be an object.");
-    }
-    config.checks = raw.checks;
+    config.checks = asChecksConfig(raw.checks, "checks");
   }
   if (raw.eval !== void 0) {
-    if (typeof raw.eval !== "object" || Array.isArray(raw.eval)) {
-      throw new Error("eval must be an object.");
-    }
-    config.eval = raw.eval;
+    config.eval = asEvalConfig(raw.eval, "eval");
   }
   if (raw.artifacts !== void 0) {
-    if (typeof raw.artifacts !== "object" || Array.isArray(raw.artifacts)) {
-      throw new Error("artifacts must be an object.");
-    }
-    const outputDir = asString(
-      raw.artifacts.outputDir,
-      "artifacts.outputDir"
-    );
+    const artifacts = assertObject(raw.artifacts, "artifacts");
+    assertKnownKeys(artifacts, ["outputDir"], "artifacts");
+    const outputDir = asString(artifacts.outputDir, "artifacts.outputDir");
     config.artifacts = outputDir !== void 0 ? { outputDir } : {};
   }
   if (raw.baseline !== void 0) {
@@ -12091,8 +12173,50 @@ async function validateSuiteConfig(config, options) {
   }
   return { ok: diagnostics.every((item) => item.severity !== "error"), diagnostics };
 }
+var CASE_KEYS, EXPECT_KEYS, CHECKS_KEYS, CHECKS_RUN_KEYS, CHECKS_TOOL_KEYS, CHECKS_LLM_KEYS, EVAL_KEYS, ROOT_KEYS;
 var init_validate2 = __esm({
   "packages/core/src/suite/validate.ts"() {
+    CASE_KEYS = [
+      "id",
+      "trace",
+      "runId",
+      "input",
+      "requireTools",
+      "forbidTools",
+      "maxDurationMs",
+      "expectedObservations",
+      "expect"
+    ];
+    EXPECT_KEYS = [
+      "checkStatus",
+      "findingRuleIds",
+      "rejectUnexpectedFindings",
+      "minAssertions"
+    ];
+    CHECKS_KEYS = ["select", "run", "tool", "llm"];
+    CHECKS_RUN_KEYS = ["maxDurationMs", "maxDepth"];
+    CHECKS_TOOL_KEYS = ["required", "forbidden"];
+    CHECKS_LLM_KEYS = ["allowedModels", "maxTotalTokens"];
+    EVAL_KEYS = [
+      "requireSuccess",
+      "requiredTools",
+      "forbiddenTools",
+      "maxDurationMs",
+      "maxDepth",
+      "maxRetries",
+      "maxTotalTokens"
+    ];
+    ROOT_KEYS = [
+      "name",
+      "traces",
+      "cases",
+      "checks",
+      "eval",
+      "redactionProfile",
+      "artifacts",
+      "baseline",
+      "candidate"
+    ];
   }
 });
 function diagnostic4(code, message) {
@@ -12635,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"() {
@@ -12667,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,
@@ -16656,7 +16829,7 @@ var init_src = __esm({
 });
 
 // package.json
-var version = "6.31.11";
+var version = "6.31.13";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -19450,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) {
@@ -19459,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;
@@ -19479,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 = [
@@ -19514,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;
@@ -19524,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;
@@ -19558,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") {
@@ -24209,7 +24555,7 @@ function asStringArray2(value) {
   }
   return value;
 }
-var CHECKS_KEYS = /* @__PURE__ */ new Set(["select", "run", "tool", "llm", "structure", "safety"]);
+var CHECKS_KEYS2 = /* @__PURE__ */ new Set(["select", "run", "tool", "llm", "structure", "safety"]);
 var ROOT_CONFIG_KEYS = /* @__PURE__ */ new Set(["checks", "contract"]);
 var CONTRACT_KEYS = /* @__PURE__ */ new Set([
   "run",
@@ -25270,7 +25616,7 @@ function parseCheckConfig(value) {
   const out = {};
   if ("checks" in root) {
     const checksRecord = requireObject(root.checks, "checks");
-    rejectUnknownKeys(checksRecord, CHECKS_KEYS, "checks");
+    rejectUnknownKeys(checksRecord, CHECKS_KEYS2, "checks");
     const checks2 = {};
     if (checksRecord.select !== void 0) {
       checks2.select = requireStringArray(checksRecord.select, "checks.select");