agent-inspect 1.5.0 → 1.7.0

package/packages/core/dist/index.cjs

@@ -148,6 +148,7 @@ function isPersistedTokenUsage(value) {
   if (!isOptionalNonNegativeNumber(value.input)) return false;
   if (!isOptionalNonNegativeNumber(value.output)) return false;
   if (!isOptionalNonNegativeNumber(value.total)) return false;
+  if (!isOptionalNonNegativeNumber(value.cached)) return false;
   return true;
 }
 function isPersistedTraceContext(value) {
@@ -238,6 +239,32 @@ function buildRunStartedMetadata(options) {
   return Object.keys(merged).length > 0 ? merged : void 0;
 }
 
+// packages/core/src/persisted/token-usage.ts
+function isRecord3(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 (!isRecord3(value)) return void 0;
+  const input = nonNegativeFinite(value.input);
+  const output = nonNegativeFinite(value.output);
+  const suppliedTotal = nonNegativeFinite(value.total);
+  const cached = nonNegativeFinite(value.cached);
+  const derivedTotal = input !== void 0 && output !== void 0 && Number.isFinite(input + output) ? input + output : void 0;
+  const total = suppliedTotal ?? derivedTotal;
+  if (input === void 0 && output === void 0 && total === void 0 && cached === void 0) {
+    return void 0;
+  }
+  return {
+    ...input !== void 0 ? { input } : {},
+    ...output !== void 0 ? { output } : {},
+    ...total !== void 0 ? { total } : {},
+    ...cached !== void 0 ? { cached } : {}
+  };
+}
+
 // packages/core/src/persisted/from-trace-event.ts
 function sanitizeIdPart(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -310,22 +337,7 @@ function mapErrorInfo(error) {
   return out;
 }
 function mapTokenUsageFromMetadata(metadata) {
-  const tokens = metadata?.tokens;
-  if (!tokens || typeof tokens !== "object") {
-    return void 0;
-  }
-  const input = typeof tokens.input === "number" && Number.isFinite(tokens.input) && tokens.input >= 0 ? tokens.input : void 0;
-  const output = typeof tokens.output === "number" && Number.isFinite(tokens.output) && tokens.output >= 0 ? tokens.output : void 0;
-  if (input === void 0 && output === void 0) {
-    return void 0;
-  }
-  const usage = {};
-  if (input !== void 0) usage.input = input;
-  if (output !== void 0) usage.output = output;
-  if (input !== void 0 && output !== void 0) {
-    usage.total = input + output;
-  }
-  return usage;
+  return normalizeTokenUsage(metadata?.tokens);
 }
 function compactAttributes(entries) {
   const out = {};
@@ -529,23 +541,7 @@ function mapInspectSourceToPersisted(source, options) {
   }
 }
 function mapTokenUsageFromAttributes(attributes) {
-  const tokens = attributes?.tokens;
-  if (!tokens || typeof tokens !== "object" || Array.isArray(tokens)) {
-    return void 0;
-  }
-  const rec = tokens;
-  const input = typeof rec.input === "number" && Number.isFinite(rec.input) && rec.input >= 0 ? rec.input : void 0;
-  const output = typeof rec.output === "number" && Number.isFinite(rec.output) && rec.output >= 0 ? rec.output : void 0;
-  if (input === void 0 && output === void 0) {
-    return void 0;
-  }
-  const usage = {};
-  if (input !== void 0) usage.input = input;
-  if (output !== void 0) usage.output = output;
-  if (input !== void 0 && output !== void 0) {
-    usage.total = input + output;
-  }
-  return usage;
+  return normalizeTokenUsage(attributes?.tokens);
 }
 function mapErrorFromAttributes(event) {
   if (event.status !== "error" || !event.attributes) {
@@ -802,10 +798,10 @@ function mapPersistedStatusToRunStatus(status) {
       return void 0;
   }
 }
-function mapPersistedError(error) {
+function mapPersistedError(error, attributes) {
   if (!error?.message) return void 0;
   const out = { message: error.message };
-  const stack = typeof error.name === "string" && error.name.length > 0 ? error.name : void 0;
+  const stack = typeof attributes?.errorStack === "string" && attributes.errorStack.length > 0 ? attributes.errorStack : void 0;
   if (stack) {
     out.stack = stack;
   }
@@ -819,7 +815,9 @@ function mapTokenUsageToMetadata(tokenUsage, attributes) {
   if (tokenUsage) {
     metadata.tokens = {
       ...tokenUsage.input !== void 0 ? { input: tokenUsage.input } : {},
-      ...tokenUsage.output !== void 0 ? { output: tokenUsage.output } : {}
+      ...tokenUsage.output !== void 0 ? { output: tokenUsage.output } : {},
+      ...tokenUsage.total !== void 0 ? { total: tokenUsage.total } : {},
+      ...tokenUsage.cached !== void 0 ? { cached: tokenUsage.cached } : {}
     };
   }
   return Object.keys(metadata).length > 0 ? metadata : void 0;
@@ -892,7 +890,7 @@ function fromLegacyRunCompleted(event) {
     endTime,
     durationMs: event.durationMs ?? Math.max(0, endTime - timestamp)
   };
-  const error = mapPersistedError(event.error);
+  const error = mapPersistedError(event.error, event.attributes);
   if (error) out.error = error;
   return out;
 }
@@ -926,7 +924,7 @@ function fromLegacyStepCompleted(event) {
     endTime,
     durationMs: event.durationMs ?? Math.max(0, endTime - timestamp)
   };
-  const error = mapPersistedError(event.error);
+  const error = mapPersistedError(event.error, event.attributes);
   if (error) out.error = error;
   return out;
 }
@@ -957,7 +955,7 @@ function fromNativeRun(event) {
       endTime,
       durationMs: event.durationMs ?? Math.max(0, endTime - startTime)
     };
-    const error = mapPersistedError(event.error);
+    const error = mapPersistedError(event.error, event.attributes);
     if (error) completed.error = error;
     out.push(completed);
   }
@@ -999,7 +997,7 @@ function fromNativeStep(event) {
       endTime,
       durationMs: event.durationMs ?? Math.max(0, endTime - startTime)
     };
-    const error = mapPersistedError(event.error);
+    const error = mapPersistedError(event.error, event.attributes);
     if (error) completed.error = error;
     out.push(completed);
   }
@@ -1092,7 +1090,7 @@ var TreeBuilder = class {
       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 durationMs = startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt && status !== "running" ? endedAt - startedAt : void 0;
+      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;
       out.push({
         runId,
@@ -1100,7 +1098,7 @@ var TreeBuilder = class {
         status,
         startedAt,
         endedAt: status === "running" ? void 0 : endedAt,
-        durationMs,
+        durationMs: durationMs2,
         children: roots,
         metadata: {
           totalEvents: sorted.length,
@@ -1125,7 +1123,7 @@ function traceEventsToPersistedRunTrees(events) {
   const persisted = traceEventsToPersistedInspectEvents(events);
   return persistedInspectEventsToRunTrees(persisted);
 }
-function isRecord3(v) {
+function isRecord4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isNonEmptyStringArray(v) {
@@ -1137,7 +1135,7 @@ function validateRedact(redact) {
   }
   for (const r of redact) {
     if (typeof r === "string") continue;
-    if (!isRecord3(r)) {
+    if (!isRecord4(r)) {
       throw new Error("Invalid config: redact entries must be strings or objects");
     }
     if (typeof r.key !== "string" || r.key.trim() === "") {
@@ -1156,7 +1154,7 @@ function validateRedact(redact) {
   }
 }
 function validateMappings(mappings) {
-  if (!isRecord3(mappings)) {
+  if (!isRecord4(mappings)) {
     throw new Error("Invalid config: mappings must be an object");
   }
 }
@@ -1206,7 +1204,7 @@ async function loadLogIngestConfig(configPath) {
     const msg = e instanceof Error ? e.message : String(e);
     throw new Error(`Invalid JSON in config file: ${configPath} (${msg})`);
   }
-  if (!isRecord3(parsed)) {
+  if (!isRecord4(parsed)) {
     throw new Error("Invalid config: expected a JSON object at top-level");
   }
   const user = parsed;
@@ -1243,7 +1241,7 @@ async function loadLogIngestConfig(configPath) {
   }
   return mergeLogIngestConfig(DEFAULT_LOG_INGEST_CONFIG, user);
 }
-function isRecord4(v) {
+function isRecord5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var JsonLogParser = class {
@@ -1268,7 +1266,7 @@ var JsonLogParser = class {
         });
         continue;
       }
-      if (!isRecord4(parsed)) {
+      if (!isRecord5(parsed)) {
         warnings.push({
           code: "MALFORMED_JSON",
           message: "JSON log line must be an object",
@@ -1299,7 +1297,7 @@ var JsonLogParser = class {
     return this.parseLines(lines, filePath);
   }
 };
-function isRecord5(v) {
+function isRecord6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function findLastJsonObjectSubstring(line) {
@@ -1375,7 +1373,7 @@ var Log4jsParser = class {
         });
         continue;
       }
-      if (!isRecord5(parsed)) {
+      if (!isRecord6(parsed)) {
         warnings.push({
           code: "UNSUPPORTED_LOG4JS_PAYLOAD",
           message: "Embedded JSON payload must be an object",
@@ -1453,7 +1451,7 @@ var DEFAULT_REDACT_KEYS = [
   "secret",
   "email"
 ];
-function isRecord6(v) {
+function isRecord7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function toKey(s) {
@@ -1526,7 +1524,7 @@ var Redactor = class {
     if (Array.isArray(value)) {
       return value.map((v) => this.#redactNested(v));
     }
-    if (isRecord6(value)) {
+    if (isRecord7(value)) {
       const out = {};
       for (const [k, v] of Object.entries(value)) {
         out[k] = this.redactValue(k, v);
@@ -1654,13 +1652,13 @@ var EventNormalizer = class {
     const timestampMissing = parsedTs === void 0;
     const parentIdKey = cfg.parentIdKey;
     const parentId = parentIdKey ? safeString(raw[parentIdKey]) : void 0;
-    let durationMs;
+    let durationMs2;
     const durationKey = cfg.durationKey;
     if (durationKey) {
       const v = raw[durationKey];
-      if (isFiniteNumber(v)) durationMs = v;
+      if (isFiniteNumber(v)) durationMs2 = v;
     } else if (isFiniteNumber(raw.durationMs)) {
-      durationMs = raw.durationMs;
+      durationMs2 = raw.durationMs;
     }
     let status;
     const statusKey = cfg.statusKey;
@@ -1707,7 +1705,7 @@ var EventNormalizer = class {
       kind,
       timestamp,
       ...status ? { status } : {},
-      ...durationMs !== void 0 ? { durationMs } : {},
+      ...durationMs2 !== void 0 ? { durationMs: durationMs2 } : {},
       ...Object.keys(attributes).length > 0 ? { attributes } : {},
       confidence,
       source: {
@@ -2286,69 +2284,81 @@ function truncateStringForProfile(value, key, maxMetadataValueLength, maxPreview
 }
 
 // packages/core/src/read-trace.ts
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function detectLineFormat(parsed) {
-  if (!isRecord7(parsed)) return "unknown";
+  if (!isRecord8(parsed)) return "unknown";
   if (parsed.schemaVersion === "0.1") return "0.1";
   if (parsed.schemaVersion === "0.2") return "0.2";
   return "unknown";
 }
 function parseTraceJsonl(raw, options = {}) {
   const validate = options.validate ?? isTraceEvent;
+  const emitWarning = (message) => {
+    if (options.warnings !== false) warn(message);
+  };
   const persisted = [];
   const traceEvents = [];
+  const rows = [];
+  let sourceEventCount = 0;
   let saw01 = false;
   let saw02 = false;
+  let lineNumber = 0;
   for (const line of raw.split(/\r?\n/)) {
+    lineNumber += 1;
     const trimmed = line.trim();
     if (trimmed === "") continue;
     let parsed;
     try {
       parsed = JSON.parse(trimmed);
     } catch {
-      warn("Skipped invalid JSON line in trace file");
+      emitWarning("Skipped invalid JSON line in trace file");
       continue;
     }
     const format2 = detectLineFormat(parsed);
     if (format2 === "0.1") {
       saw01 = true;
       if (validate(parsed)) {
+        sourceEventCount += 1;
         traceEvents.push(parsed);
+        rows.push({ format: "0.1", event: parsed, sourceLine: lineNumber });
       } else {
-        warn("Skipped invalid trace event line in trace file");
+        emitWarning("Skipped invalid trace event line in trace file");
       }
       continue;
     }
     if (format2 === "0.2") {
       saw02 = true;
       if (isPersistedInspectEvent(parsed)) {
+        sourceEventCount += 1;
         persisted.push(parsed);
+        rows.push({ format: "0.2", event: parsed, sourceLine: lineNumber });
+        traceEvents.push(...persistedInspectEventToTraceEvents(parsed));
       } else {
-        warn("Skipped invalid persisted inspect event line in trace file");
+        emitWarning("Skipped invalid persisted inspect event line in trace file");
       }
       continue;
     }
-    warn("Skipped trace line with unknown schemaVersion");
+    emitWarning("Skipped trace line with unknown schemaVersion");
   }
   if (saw01 && saw02) {
-    warn("Trace file mixes schemaVersion 0.1 and 0.2 lines; normalizing all rows");
+    emitWarning(
+      "Trace file mixes schemaVersion 0.1 and 0.2 lines; normalizing all rows"
+    );
   }
-  const converted = persisted.length > 0 ? persistedInspectEventsToTraceEvents(persisted) : [];
-  const events = [...traceEvents, ...converted];
   let format = "empty";
   if (saw01 && saw02) format = "mixed";
   else if (saw01) format = "0.1";
   else if (saw02) format = "0.2";
-  return { format, events, persisted };
+  return { format, sourceEventCount, events: traceEvents, persisted, rows };
 }
 function unknownTraceFormatMessage() {
   return "Unsupported trace format. Expected schemaVersion 0.1 (TraceEvent) or 0.2 (PersistedInspectEvent).";
 }
 
 // packages/core/src/storage.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -2359,7 +2369,7 @@ function finiteNumber(value) {
 }
 function optionalErrorInfo(value) {
   if (value === void 0) return true;
-  if (!isRecord8(value)) return false;
+  if (!isRecord9(value)) return false;
   if (typeof value.message !== "string") return false;
   if ("stack" in value && value.stack !== void 0) {
     if (typeof value.stack !== "string") return false;
@@ -2367,7 +2377,7 @@ function optionalErrorInfo(value) {
   return true;
 }
 function validateEvent(event) {
-  if (!isRecord8(event)) return false;
+  if (!isRecord9(event)) return false;
   if (event.schemaVersion !== "0.1") return false;
   if (!finiteNumber(event.timestamp)) return false;
   if (typeof event.event !== "string") return false;
@@ -2376,7 +2386,7 @@ function validateEvent(event) {
       if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord8(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord9(event.metadata)) {
         return false;
       }
       return true;
@@ -2391,7 +2401,7 @@ function validateEvent(event) {
       if (event.parentId !== void 0 && typeof event.parentId !== "string") {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord8(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord9(event.metadata)) {
         return false;
       }
       return true;
@@ -2482,16 +2492,25 @@ async function readTraceFile(runId, traceDir) {
 }
 async function readTraceEvents(runId, traceDir) {
   try {
-    const raw = await readTraceFile(runId, traceDir);
-    if (raw === void 0) {
-      return [];
-    }
-    return parseTraceJsonl(raw, { validate: validateEvent }).events;
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await readTraceEventsFromFile(filePath);
   } catch (e) {
     warn("Failed to read trace events", e);
     return [];
   }
 }
+async function readTraceEventsFromFile(filePath) {
+  try {
+    const raw = await promises.readFile(filePath, "utf-8");
+    return parseTraceJsonl(raw, { validate: validateEvent }).events;
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return [];
+    }
+    warn("Failed to read trace events from file", e);
+    return [];
+  }
+}
 async function listTraceFiles(traceDir) {
   try {
     const usable = path__default.default.resolve(traceDir);
@@ -2531,7 +2550,7 @@ function getRunIdFromTraceFileName(fileName) {
 var DEFAULT_MAX_METADATA_VALUE_LENGTH = 2e3;
 var DEFAULT_MAX_PREVIEW_LENGTH = 500;
 var DEFAULT_MAX_EVENT_BYTES = 65536;
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPreviewKey2(key) {
@@ -2553,7 +2572,7 @@ function resolveTraceSafetyOptions(options) {
     redactEnabled = false;
   } else if (redact === true || redact === void 0) {
     redactEnabled = true;
-  } else if (isRecord9(redact)) {
+  } else if (isRecord10(redact)) {
     redactEnabled = true;
     redactionRules = redact.rules;
   }
@@ -2584,6 +2603,21 @@ function resolveTraceSafetyOptions(options) {
 }
 function boundMetadataValue(key, value, opts, seen, depth) {
   if (depth > 32) return "[MaxDepth]";
+  if (typeof value === "bigint") {
+    return `${value.toString()}n`;
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (typeof value === "symbol") {
+    return "[Symbol]";
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === void 0) {
+    return null;
+  }
   if (value === null || typeof value !== "object") {
     if (typeof value === "string") {
       const max = isPreviewKey2(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
@@ -2605,8 +2639,12 @@ function boundMetadataValue(key, value, opts, seen, depth) {
   }
   const record = value;
   const out = {};
-  for (const [k, v] of Object.entries(record)) {
-    out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+  try {
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+    }
+  } catch {
+    return { truncated: true, reason: "metadataEnumerationFailed" };
   }
   return out;
 }
@@ -2620,16 +2658,25 @@ function redactMetadata(metadata, opts) {
 }
 function prepareMetadataForDisk(metadata, opts) {
   try {
-    const redacted = redactMetadata(metadata, opts);
-    const seen = /* @__PURE__ */ new WeakSet();
+    const preBounded = boundMetadataValue(
+      "metadata",
+      metadata,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const redacted = redactMetadata(
+      isRecord10(preBounded) ? preBounded : {},
+      opts
+    );
     const bounded = boundMetadataValue(
       "metadata",
       redacted,
       opts,
-      seen,
+      /* @__PURE__ */ new WeakSet(),
       0
     );
-    return isRecord9(bounded) ? bounded : {};
+    return isRecord10(bounded) ? bounded : {};
   } catch {
     return { truncated: true, reason: "metadataPreparationFailed" };
   }
@@ -2750,6 +2797,210 @@ function prepareTraceEventForDisk(event, opts) {
     return event;
   }
 }
+function safeGet(record, key) {
+  try {
+    return record[key];
+  } catch {
+    return void 0;
+  }
+}
+function optionalBoundedString(value, _key, opts) {
+  if (typeof value !== "string") return void 0;
+  return truncateString(value, opts.maxMetadataValueLength);
+}
+function requiredBoundedString(value, key, opts) {
+  const out = optionalBoundedString(value, key, opts);
+  return out && out.length > 0 ? out : void 0;
+}
+function preparePersistedSummaryForDisk(key, value, opts) {
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const redacted = opts.redactEnabled ? redactor.redactValue(key, value) : value;
+    return boundMetadataValue(key, redacted, opts, /* @__PURE__ */ new WeakSet(), 0);
+  } catch {
+    return { truncated: true, reason: "summaryPreparationFailed" };
+  }
+}
+function preparePersistedErrorForDisk(value, opts) {
+  if (!isRecord10(value)) return void 0;
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const rawMessage = safeGet(value, "message");
+    const redactedMessage = opts.redactEnabled ? redactor.redactValue("message", rawMessage) : rawMessage;
+    const boundedMessage = boundMetadataValue(
+      "message",
+      redactedMessage,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const message = typeof boundedMessage === "string" && boundedMessage.length > 0 ? boundedMessage : "Unknown error";
+    const out = { message };
+    const name = optionalBoundedString(safeGet(value, "name"), "name", opts);
+    const code = optionalBoundedString(safeGet(value, "code"), "code", opts);
+    if (name !== void 0) out.name = name;
+    if (code !== void 0) out.code = code;
+    return out;
+  } catch {
+    return { message: "Error preparation failed" };
+  }
+}
+function prepareTokenUsage(value) {
+  if (!isRecord10(value)) return void 0;
+  const out = {};
+  for (const key of ["input", "output", "total", "cached"]) {
+    const item = safeGet(value, key);
+    if (typeof item === "number" && Number.isFinite(item) && item >= 0) {
+      out[key] = item;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function prepareTraceContext(value, opts) {
+  if (!isRecord10(value)) return void 0;
+  const out = {};
+  const traceId = optionalBoundedString(safeGet(value, "traceId"), "traceId", opts);
+  const spanId = optionalBoundedString(safeGet(value, "spanId"), "spanId", opts);
+  const parentSpanId = optionalBoundedString(
+    safeGet(value, "parentSpanId"),
+    "parentSpanId",
+    opts
+  );
+  if (traceId !== void 0) out.traceId = traceId;
+  if (spanId !== void 0) out.spanId = spanId;
+  if (parentSpanId !== void 0) out.parentSpanId = parentSpanId;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function serializedPersistedEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return void 0;
+  }
+}
+function persistedEventByteLength(event) {
+  const serialized = serializedPersistedEvent(event);
+  return serialized === void 0 ? void 0 : byteLength(serialized);
+}
+function minimalPersistedEvent(event, opts, originalApproxBytes) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 128),
+    runId: truncateString(event.runId, 128),
+    kind: event.kind,
+    name: truncateString(event.name, 128),
+    ...event.status !== void 0 ? { status: event.status } : {},
+    timestamp: truncateString(event.timestamp, 128),
+    confidence: event.confidence,
+    source: {
+      type: event.source.type,
+      ...event.source.name !== void 0 ? { name: truncateString(event.source.name, 128) } : {},
+      ...event.source.version !== void 0 ? { version: truncateString(event.source.version, 128) } : {}
+    },
+    attributes: {
+      truncated: true,
+      reason: "maxEventBytes",
+      originalApproxBytes,
+      maxEventBytes: opts.maxEventBytes
+    }
+  };
+}
+function tinyPersistedEvent(event) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 32),
+    runId: truncateString(event.runId, 32),
+    kind: event.kind,
+    name: truncateString(event.name, 32),
+    timestamp: truncateString(event.timestamp, 32),
+    confidence: event.confidence,
+    source: { type: event.source.type },
+    attributes: { truncated: true, reason: "maxEventBytes" }
+  };
+}
+function enforcePersistedEventSize(event, opts) {
+  const bytes = persistedEventByteLength(event);
+  if (bytes === void 0) return void 0;
+  if (bytes <= opts.maxEventBytes) return event;
+  const minimal = minimalPersistedEvent(event, opts, bytes);
+  const minimalBytes = persistedEventByteLength(minimal);
+  if (minimalBytes !== void 0 && minimalBytes <= opts.maxEventBytes) {
+    return minimal;
+  }
+  const tiny = tinyPersistedEvent(event);
+  return isPersistedInspectEvent(tiny) ? tiny : void 0;
+}
+function preparePersistedInspectEventForWrite(value, opts = resolveTraceSafetyOptions()) {
+  try {
+    if (!isRecord10(value)) return void 0;
+    const source = safeGet(value, "source");
+    if (!isRecord10(source)) return void 0;
+    const candidate = {
+      schemaVersion: safeGet(value, "schemaVersion"),
+      eventId: requiredBoundedString(safeGet(value, "eventId"), "eventId", opts) ?? "",
+      runId: requiredBoundedString(safeGet(value, "runId"), "runId", opts) ?? "",
+      kind: safeGet(value, "kind"),
+      name: requiredBoundedString(safeGet(value, "name"), "name", opts) ?? "",
+      timestamp: requiredBoundedString(safeGet(value, "timestamp"), "timestamp", opts) ?? "",
+      confidence: safeGet(value, "confidence"),
+      source: {
+        type: safeGet(source, "type")
+      }
+    };
+    const parentId = requiredBoundedString(safeGet(value, "parentId"), "parentId", opts);
+    const status = safeGet(value, "status");
+    const startedAt = optionalBoundedString(safeGet(value, "startedAt"), "startedAt", opts);
+    const endedAt = optionalBoundedString(safeGet(value, "endedAt"), "endedAt", opts);
+    const durationMs2 = safeGet(value, "durationMs");
+    const sourceName = optionalBoundedString(safeGet(source, "name"), "name", opts);
+    const sourceVersion = optionalBoundedString(safeGet(source, "version"), "version", opts);
+    if (parentId !== void 0) candidate.parentId = parentId;
+    if (status === "running" || status === "ok" || status === "error" || status === "unknown") {
+      candidate.status = status;
+    }
+    if (startedAt !== void 0) candidate.startedAt = startedAt;
+    if (endedAt !== void 0) candidate.endedAt = endedAt;
+    if (typeof durationMs2 === "number" && Number.isFinite(durationMs2) && durationMs2 >= 0) {
+      candidate.durationMs = durationMs2;
+    }
+    if (sourceName !== void 0) candidate.source.name = sourceName;
+    if (sourceVersion !== void 0) candidate.source.version = sourceVersion;
+    const attributes = safeGet(value, "attributes");
+    if (isRecord10(attributes)) {
+      candidate.attributes = prepareMetadataForDisk(attributes, opts);
+    }
+    if (safeGet(value, "inputSummary") !== void 0) {
+      candidate.inputSummary = preparePersistedSummaryForDisk(
+        "input",
+        safeGet(value, "inputSummary"),
+        opts
+      );
+    }
+    if (safeGet(value, "outputSummary") !== void 0) {
+      candidate.outputSummary = preparePersistedSummaryForDisk(
+        "output",
+        safeGet(value, "outputSummary"),
+        opts
+      );
+    }
+    const error = preparePersistedErrorForDisk(safeGet(value, "error"), opts);
+    if (error !== void 0) candidate.error = error;
+    const tokenUsage = prepareTokenUsage(safeGet(value, "tokenUsage"));
+    if (tokenUsage !== void 0) candidate.tokenUsage = tokenUsage;
+    const trace = prepareTraceContext(safeGet(value, "trace"), opts);
+    if (trace !== void 0) candidate.trace = trace;
+    if (!isPersistedInspectEvent(candidate)) return void 0;
+    return enforcePersistedEventSize(candidate, opts);
+  } catch {
+    return void 0;
+  }
+}
 
 // packages/core/src/context.ts
 var storage = new async_hooks.AsyncLocalStorage();
@@ -2934,12 +3185,10 @@ var TraceDirectory = class {
 function isFiniteNumber2(v) {
   return typeof v === "number" && Number.isFinite(v);
 }
-function safeParseJson(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return void 0;
-  }
+function parseIsoToMs3(value) {
+  if (value === void 0) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
 }
 async function extractMetadata(filePath, _quickScan) {
   const stats = await promises.stat(filePath);
@@ -2948,8 +3197,7 @@ async function extractMetadata(filePath, _quickScan) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
   const raw = await promises.readFile(filePath, "utf-8");
-  const lines = raw.split(/\r?\n/);
-  let eventCount = 0;
+  const parsedTrace = parseTraceJsonl(raw, { warnings: false });
   let runId;
   let name;
   let startedAt;
@@ -2959,16 +3207,32 @@ async function extractMetadata(filePath, _quickScan) {
   let hasRunCompleted = false;
   let runCompletedStatus;
   let anyStepError = false;
-  let anyKnownEvent = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === "") continue;
-    const parsed = safeParseJson(trimmed);
-    if (!parsed) continue;
-    if (!isTraceEvent(parsed)) continue;
-    const e = parsed;
-    anyKnownEvent = true;
-    eventCount += 1;
+  const anyKnownEvent = parsedTrace.sourceEventCount > 0;
+  let persistedStatus;
+  const persistedRun = parsedTrace.persisted.find(
+    (event) => event.kind === "RUN"
+  );
+  if (persistedRun) {
+    runId = persistedRun.runId;
+    if (persistedRun.name.trim() !== "") {
+      name = persistedRun.name;
+    }
+    startedAt = parseIsoToMs3(persistedRun.startedAt) ?? parseIsoToMs3(persistedRun.timestamp);
+    endedAt = parseIsoToMs3(persistedRun.endedAt);
+    if (isFiniteNumber2(persistedRun.durationMs)) {
+      explicitDurationMs = persistedRun.durationMs;
+      if (endedAt === void 0 && startedAt !== void 0) {
+        endedAt = startedAt + persistedRun.durationMs;
+      }
+    }
+    if (persistedRun.status === "ok") persistedStatus = "success";
+    else if (persistedRun.status === "error") persistedStatus = "error";
+    else if (persistedRun.status === "running") persistedStatus = "running";
+    else if (persistedRun.status === "unknown") persistedStatus = "unknown";
+  } else {
+    runId = parsedTrace.persisted[0]?.runId;
+  }
+  for (const e of parsedTrace.events) {
     if (runId === void 0 && typeof e.runId === "string") {
       runId = e.runId;
     }
@@ -3005,6 +3269,8 @@ async function extractMetadata(filePath, _quickScan) {
     status = runCompletedStatus;
   } else if (anyStepError) {
     status = "error";
+  } else if (persistedStatus !== void 0) {
+    status = persistedStatus;
   } else if (hasRunStarted && !hasRunCompleted) {
     status = "running";
   } else if (anyKnownEvent) {
@@ -3012,20 +3278,23 @@ async function extractMetadata(filePath, _quickScan) {
   } else {
     status = "unknown";
   }
-  const durationMs = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
+  const durationMs2 = explicitDurationMs ?? (startedAt !== void 0 && endedAt !== void 0 && Number.isFinite(startedAt) && Number.isFinite(endedAt) && endedAt >= startedAt ? endedAt - startedAt : void 0);
   return {
     runId: resolvedRunId,
     name,
     status,
     startedAt,
     endedAt,
-    durationMs,
-    eventCount,
+    durationMs: durationMs2,
+    eventCount: parsedTrace.sourceEventCount,
     filePath,
     fileSize: stats.size,
     createdAt: stats.birthtime
   };
 }
+function isNonNegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 function buildRunSummary(events) {
   const started = events.find(
     (e) => e.event === "run_started"
@@ -3037,7 +3306,7 @@ function buildRunSummary(events) {
   const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
   const name = typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0;
   const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
-  const durationMs = lastCompleted && isFiniteNumber2(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const durationMs2 = lastCompleted && isFiniteNumber2(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
   started && isFiniteNumber2(started.startTime) ? started.startTime : void 0;
   const steps = /* @__PURE__ */ new Map();
   for (const e of events) {
@@ -3048,8 +3317,10 @@ function buildRunSummary(events) {
         name: s.name,
         status: "running",
         parentId: s.parentId,
-        tokensInput: typeof s.metadata?.tokens?.input === "number" ? s.metadata.tokens.input : void 0,
-        tokensOutput: typeof s.metadata?.tokens?.output === "number" ? s.metadata.tokens.output : void 0
+        tokensInput: isNonNegativeFiniteNumber(s.metadata?.tokens?.input) ? s.metadata.tokens.input : void 0,
+        tokensOutput: isNonNegativeFiniteNumber(s.metadata?.tokens?.output) ? s.metadata.tokens.output : void 0,
+        tokensTotal: isNonNegativeFiniteNumber(s.metadata?.tokens?.total) ? s.metadata.tokens.total : void 0,
+        tokensCached: isNonNegativeFiniteNumber(s.metadata?.tokens?.cached) ? s.metadata.tokens.cached : void 0
       });
     }
   }
@@ -3071,7 +3342,11 @@ function buildRunSummary(events) {
   let longestStep;
   let totalTokensInput = 0;
   let totalTokensOutput = 0;
-  let hasAnyTokens = false;
+  let totalTokensTotal = 0;
+  let totalTokensCached = 0;
+  let tokenBearingSteps = 0;
+  let stepsWithKnownTotal = 0;
+  let hasCachedTokens = false;
   const depthCache = /* @__PURE__ */ new Map();
   const computeDepth = (stepId) => {
     const cached = depthCache.get(stepId);
@@ -3100,17 +3375,28 @@ function buildRunSummary(events) {
         longestStep = { name: s.name, durationMs: s.durationMs, type: s.type };
       }
     }
-    if (typeof s.tokensInput === "number" || typeof s.tokensOutput === "number") {
-      hasAnyTokens = true;
-      if (typeof s.tokensInput === "number") totalTokensInput += s.tokensInput;
-      if (typeof s.tokensOutput === "number") totalTokensOutput += s.tokensOutput;
+    if (s.tokensInput !== void 0 || s.tokensOutput !== void 0 || s.tokensTotal !== void 0 || s.tokensCached !== void 0) {
+      tokenBearingSteps += 1;
+      if (s.tokensInput !== void 0) totalTokensInput += s.tokensInput;
+      if (s.tokensOutput !== void 0) totalTokensOutput += s.tokensOutput;
+      if (s.tokensTotal !== void 0) {
+        totalTokensTotal += s.tokensTotal;
+        stepsWithKnownTotal += 1;
+      } else if (s.tokensInput !== void 0 && s.tokensOutput !== void 0) {
+        totalTokensTotal += s.tokensInput + s.tokensOutput;
+        stepsWithKnownTotal += 1;
+      }
+      if (s.tokensCached !== void 0) {
+        totalTokensCached += s.tokensCached;
+        hasCachedTokens = true;
+      }
     }
   }
   const summary = {
     runId,
     name,
     status,
-    durationMs,
+    durationMs: durationMs2,
     totalSteps,
     llmSteps,
     toolSteps,
@@ -3118,7 +3404,14 @@ function buildRunSummary(events) {
     errorSteps,
     maxDepth,
     ...longestStep ? { longestStep } : {},
-    ...hasAnyTokens ? { totalTokens: { input: totalTokensInput, output: totalTokensOutput } } : {}
+    ...tokenBearingSteps > 0 ? {
+      totalTokens: {
+        input: totalTokensInput,
+        output: totalTokensOutput,
+        ...stepsWithKnownTotal === tokenBearingSteps ? { total: totalTokensTotal } : {},
+        ...hasCachedTokens ? { cached: totalTokensCached } : {}
+      }
+    } : {}
   };
   return summary;
 }
@@ -3423,9 +3716,17 @@ function renderRunWhat(summary, options = {}) {
     `Status: ${summary.status} \xB7 Duration: ${duration} \xB7 Steps: ${summary.totalSteps} (${stepMixLine(summary)})`
   );
   if (summary.totalTokens) {
-    lines.push(
-      `Tokens: ${summary.totalTokens.input} in / ${summary.totalTokens.output} out`
-    );
+    const tokenParts = [
+      `${summary.totalTokens.input} in`,
+      `${summary.totalTokens.output} out`
+    ];
+    if (summary.totalTokens.total !== void 0) {
+      tokenParts.push(`${summary.totalTokens.total} total`);
+    }
+    if (summary.totalTokens.cached !== void 0) {
+      tokenParts.push(`${summary.totalTokens.cached} cached`);
+    }
+    lines.push(`Tokens: ${tokenParts.join(" / ")}`);
   }
   if (showCorrelation && summary.correlation) {
     const parts = [];
@@ -3881,7 +4182,7 @@ function manualTraceEventsToRunTree(events) {
   }
   const startedAt = started.startTime;
   const endedAt = lastCompleted !== void 0 && runStatus !== "running" ? lastCompleted.endTime : void 0;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const durationMs2 = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
   const steps = /* @__PURE__ */ new Map();
   for (const e of events) {
     if (e.event !== "step_started") continue;
@@ -3970,7 +4271,7 @@ function manualTraceEventsToRunTree(events) {
     status: runStatus,
     startedAt,
     endedAt,
-    durationMs,
+    durationMs: durationMs2,
     children: roots,
     metadata: {
       totalEvents: inspectNodes.size,
@@ -3981,7 +4282,7 @@ function manualTraceEventsToRunTree(events) {
 }
 
 // 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) {
@@ -4055,7 +4356,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(
@@ -4076,6 +4377,89 @@ function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPrevi
   }
   return bounded;
 }
+function redactErrorInfo(error, redactor, maxMetadataValueLength, maxPreviewLength) {
+  if (error === void 0) return void 0;
+  const record = redactEventAttributes(
+    { error },
+    redactor,
+    maxMetadataValueLength,
+    maxPreviewLength
+  );
+  const redacted = record?.error;
+  if (!isRecord11(redacted) || typeof redacted.message !== "string") {
+    return void 0;
+  }
+  return {
+    message: redacted.message,
+    ...typeof redacted.stack === "string" ? { stack: redacted.stack } : {}
+  };
+}
+function redactTraceEventsForReport(events, options) {
+  const profile = options?.redactionProfile ?? "local";
+  if (profile === "local") {
+    return deepClone(events);
+  }
+  const resolved = resolveRedactionProfile(profile);
+  const { maxMetadataValueLength, maxPreviewLength } = applyProfileMetadataCaps(
+    2e3,
+    500,
+    resolved
+  );
+  const redactor = new Redactor({ extraKeys: resolved.extraKeys });
+  return events.map((event) => {
+    switch (event.event) {
+      case "run_started":
+        return {
+          ...event,
+          name: truncateStringForProfile(
+            event.name,
+            "name",
+            maxMetadataValueLength,
+            maxPreviewLength
+          ),
+          ...event.metadata !== void 0 ? {
+            metadata: redactEventAttributes(
+              event.metadata,
+              redactor,
+              maxMetadataValueLength,
+              maxPreviewLength
+            )
+          } : {}
+        };
+      case "step_started":
+        return {
+          ...event,
+          name: truncateStringForProfile(
+            event.name,
+            "name",
+            maxMetadataValueLength,
+            maxPreviewLength
+          ),
+          ...event.metadata !== void 0 ? {
+            metadata: redactEventAttributes(
+              event.metadata,
+              redactor,
+              maxMetadataValueLength,
+              maxPreviewLength
+            )
+          } : {}
+        };
+      case "run_completed":
+      case "step_completed":
+        return {
+          ...event,
+          ...event.error !== void 0 ? {
+            error: redactErrorInfo(
+              event.error,
+              redactor,
+              maxMetadataValueLength,
+              maxPreviewLength
+            )
+          } : {}
+        };
+    }
+  });
+}
 function redactRunTreeForExport(tree, options) {
   const profile = options?.redactionProfile ?? "local";
   if (profile === "local") {
@@ -4139,12 +4523,15 @@ footer{margin-top:2rem;font-size:0.85rem;color:#555}
 `.trim();
 function buildRunReport(events, options) {
   const profile = options.redactionProfile ?? "local";
-  const whatSummary = buildRunWhatSummary(events);
+  const safeEvents = redactTraceEventsForReport(events, {
+    redactionProfile: profile
+  });
+  const whatSummary = buildRunWhatSummary(safeEvents);
   const whatText = renderRunWhat(whatSummary, {
     correlation: options.correlation !== false
   });
-  const timelineText = renderTimeline(buildRunTimeline(events));
-  const tree = resolveTree(events, profile);
+  const timelineText = renderTimeline(buildRunTimeline(safeEvents));
+  const tree = resolveTree(safeEvents, profile);
   const exportOpts = {
     includeMetadata: false,
     includeAttributes: options.includeAttributes === true,
@@ -4225,6 +4612,8 @@ ${attrsSection}
     fileExtension: ".html"
   };
 }
+
+// packages/core/src/stats.ts
 function percentile(sorted, p) {
   if (sorted.length === 0) return void 0;
   const idx = Math.min(
@@ -4235,19 +4624,10 @@ function percentile(sorted, p) {
 }
 async function readRunStartedMetadata(filePath) {
   try {
-    const raw = await promises.readFile(filePath, "utf-8");
-    for (const line of raw.split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (trimmed === "") continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      if (!isTraceEvent(parsed)) continue;
-      if (parsed.event !== "run_started") continue;
-      const rs = parsed;
+    const events = await readTraceEventsFromFile(filePath);
+    for (const event of events) {
+      if (event.event !== "run_started") continue;
+      const rs = event;
       if (rs.metadata && typeof rs.metadata === "object") {
         return rs.metadata;
       }
@@ -4306,7 +4686,7 @@ async function buildTraceStats(metas, options) {
       });
     }
     try {
-      const events = await readTraceEvents(m.runId, options.traceDir);
+      const events = await readTraceEventsFromFile(m.filePath);
       if (events.length === 0) continue;
       const summary = buildRunSummary(events);
       totalSteps += summary.totalSteps;
@@ -4494,7 +4874,7 @@ async function searchTraces(metas, options) {
     if (options.status && m.status !== options.status) continue;
     let events = [];
     try {
-      events = await readTraceEvents(m.runId, options.traceDir);
+      events = await readTraceEventsFromFile(m.filePath);
     } catch {
       continue;
     }
@@ -4630,7 +5010,7 @@ var KNOWN_EVENTS = /* @__PURE__ */ new Set([
   "step_started",
   "step_completed"
 ]);
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function safeParse(line) {
@@ -4652,7 +5032,7 @@ async function isAgentInspectTrace(filePath) {
       if (trimmed === "") continue;
       const parsed = safeParse(trimmed);
       if (!parsed) continue;
-      if (!isRecord11(parsed)) continue;
+      if (!isRecord12(parsed)) continue;
       checked += 1;
       if (isTraceEvent(parsed)) return true;
       const ev = parsed.event;
@@ -4667,64 +5047,2417 @@ async function isAgentInspectTrace(filePath) {
     return false;
   }
 }
-
-// packages/core/src/diff/comparable.ts
-function extractOutputPreview(meta) {
-  if (meta === void 0) return void 0;
-  if ("outputPreview" in meta) return meta.outputPreview;
-  if ("resultPreview" in meta) return meta.resultPreview;
-  return void 0;
-}
-function mapStepStatus2(s) {
-  if (s === void 0) return "running";
-  return s;
+function invoke2(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
 }
-function manualTraceEventsToComparableRun(events) {
-  const started = events.find((e) => e.event === "run_started");
-  if (!started || started.event !== "run_started") {
-    throw new Error("Invalid trace: missing run_started");
+function normalizeError(error) {
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
   }
-  const rs = started;
-  const runId = rs.runId;
-  const completedAll = events.filter((e) => e.event === "run_completed");
-  const lastCompleted = completedAll[completedAll.length - 1];
-  let runStatus;
-  if (lastCompleted === void 0) runStatus = "running";
-  else runStatus = lastCompleted.status;
-  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
-  const steps = /* @__PURE__ */ new Map();
-  let order = 0;
-  for (const e of events) {
-    if (e.event !== "step_started") continue;
-    const s = e;
-    const meta = s.metadata ? { ...s.metadata } : void 0;
-    steps.set(s.stepId, {
-      id: s.stepId,
-      parentId: s.parentId,
-      name: s.name,
-      type: s.type,
-      order: order++,
-      timestamp: s.timestamp,
-      metadata: meta
-    });
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
   }
-  for (const e of events) {
-    if (e.event !== "step_completed") continue;
-    const acc = steps.get(e.stepId);
-    if (!acc) continue;
-    acc.status = e.status;
-    acc.durationMs = e.durationMs;
-    if (e.error?.message) acc.errorMsg = e.error.message;
-    const extra = e;
-    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
-      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
+  return "Unknown inspector runtime error";
+}
+var runtimeSequence = 0;
+function createRuntimeId() {
+  runtimeSequence += 1;
+  return `runtime_${runtimeSequence.toString(36)}`;
+}
+function publicContext(store) {
+  return {
+    runtimeId: store.runtimeId,
+    runId: store.runId,
+    runName: store.runName,
+    traceDir: store.traceDir,
+    silent: store.silent,
+    metadata: store.metadata
+  };
+}
+function createInspectorRuntime(options = {}) {
+  const storage2 = new async_hooks.AsyncLocalStorage();
+  const enabled = options.enabled ?? true;
+  const runtimeId = createRuntimeId();
+  const traceSafety = options.traceSafety ?? resolveTraceSafetyOptions();
+  let closed = false;
+  let instrumentationErrors = 0;
+  let lastInstrumentationError;
+  function recordInstrumentationError(error) {
+    instrumentationErrors += 1;
+    lastInstrumentationError = normalizeError(error);
+  }
+  function currentStore() {
+    try {
+      return storage2.getStore();
+    } catch (error) {
+      recordInstrumentationError(error);
+      return void 0;
     }
   }
-  const nodes = /* @__PURE__ */ new Map();
-  for (const acc of steps.values()) {
-    let meta = acc.metadata ? { ...acc.metadata } : void 0;
-    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
-      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
+  const runtime = {
+    runtimeId,
+    enabled,
+    runWithContext(context, fn) {
+      if (!enabled) return invoke2(fn);
+      const store = {
+        runtimeId,
+        runId: context.runId,
+        runName: context.runName,
+        traceDir: context.traceDir,
+        silent: context.silent,
+        metadata: context.metadata,
+        traceSafety,
+        currentDepth: 0
+      };
+      return new Promise((resolve, reject) => {
+        storage2.run(store, () => {
+          invoke2(fn).then(resolve, reject);
+        });
+      });
+    },
+    runWithStepContext(stepId, fn) {
+      if (!enabled) return invoke2(fn);
+      const parent = currentStore();
+      if (!parent) return invoke2(fn);
+      const store = {
+        runtimeId,
+        runId: parent.runId,
+        runName: parent.runName,
+        traceDir: parent.traceDir,
+        silent: parent.silent,
+        metadata: parent.metadata,
+        traceSafety: parent.traceSafety,
+        currentStepId: stepId,
+        currentDepth: parent.currentDepth + 1
+      };
+      return new Promise((resolve, reject) => {
+        storage2.run(store, () => {
+          invoke2(fn).then(resolve, reject);
+        });
+      });
+    },
+    getCurrentContext() {
+      const store = currentStore();
+      return store ? publicContext(store) : void 0;
+    },
+    getCurrentCorrelationMetadata() {
+      return extractCorrelationMetadata(currentStore()?.metadata);
+    },
+    getCurrentStepId() {
+      return currentStore()?.currentStepId;
+    },
+    getCurrentDepth() {
+      const depth = currentStore()?.currentDepth;
+      return typeof depth === "number" && Number.isFinite(depth) ? depth : 0;
+    },
+    getTraceSafety() {
+      return traceSafety;
+    },
+    async write(event) {
+      if (!enabled || closed || !options.writer) return;
+      try {
+        const safe = preparePersistedInspectEventForWrite(event, traceSafety);
+        if (safe === void 0) {
+          recordInstrumentationError("Invalid persisted inspect event");
+          return;
+        }
+        await options.writer.write(safe);
+      } catch (error) {
+        recordInstrumentationError(error);
+      }
+    },
+    async flush() {
+      if (!options.writer) return;
+      try {
+        await options.writer.flush?.();
+      } catch (error) {
+        recordInstrumentationError(error);
+      }
+    },
+    async close() {
+      if (closed) return;
+      try {
+        await options.writer?.close?.();
+      } catch (error) {
+        recordInstrumentationError(error);
+      } finally {
+        closed = true;
+      }
+    },
+    getDiagnostics() {
+      const diagnostics = {
+        instrumentationErrors
+      };
+      if (lastInstrumentationError !== void 0) {
+        diagnostics.lastInstrumentationError = lastInstrumentationError;
+      }
+      const writerStats = options.writer?.getStats?.();
+      if (writerStats !== void 0) {
+        diagnostics.writerStats = writerStats;
+      }
+      return diagnostics;
+    }
+  };
+  return runtime;
+}
+
+// packages/core/src/inspector.ts
+function normalizeName(name, fallback) {
+  if (typeof name !== "string" || name.trim() === "") return fallback;
+  return truncateName(name.trim(), 100);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function durationMs(startedAt, endedAt) {
+  return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
+}
+function mergeMetadata(base, override) {
+  if (base === void 0 && override === void 0) return void 0;
+  return {
+    ...base ?? {},
+    ...override ?? {}
+  };
+}
+function toPersistedError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  return { message: "Unknown error" };
+}
+function summarizeValue(value) {
+  if (value === null) return { type: "null" };
+  if (Array.isArray(value)) return { type: "array", length: value.length };
+  if (typeof value === "string") return { type: "string", length: value.length };
+  if (typeof value === "number") {
+    return { type: "number", finite: Number.isFinite(value) };
+  }
+  if (typeof value === "bigint") return { type: "bigint" };
+  if (typeof value === "boolean") return { type: "boolean" };
+  if (typeof value === "undefined") return { type: "undefined" };
+  if (typeof value === "symbol") return { type: "symbol" };
+  if (typeof value === "function") {
+    return { type: "function", name: value.name || void 0 };
+  }
+  if (typeof value === "object") {
+    const record = value;
+    let keyCount;
+    try {
+      keyCount = Object.keys(record).length;
+    } catch {
+      keyCount = void 0;
+    }
+    return {
+      type: "object",
+      constructorName: value?.constructor?.name,
+      ...keyCount !== void 0 ? { keyCount } : {}
+    };
+  }
+  return { type: typeof value };
+}
+function summarizeCapturedError(error) {
+  if (error instanceof Error) {
+    return { type: "error", name: error.name };
+  }
+  return summarizeValue(error);
+}
+function stepTypeToKind(type) {
+  switch (type) {
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "run":
+      return "RUN";
+    default:
+      return "LOGIC";
+  }
+}
+function createInspector(options = {}) {
+  const traceSafety = options.traceSafety ?? resolveTraceSafetyOptions({
+    redactionProfile: options.redactionProfile
+  });
+  const runtime = createInspectorRuntime({
+    enabled: options.enabled,
+    writer: options.writer,
+    traceSafety
+  });
+  async function write(event) {
+    const safe = preparePersistedInspectEventForWrite(event, traceSafety);
+    if (safe !== void 0) {
+      await runtime.write(safe);
+    }
+  }
+  async function run(name, fn, runOptions = {}) {
+    if (typeof fn !== "function") {
+      throw new TypeError("inspector.run requires `fn` to be a function");
+    }
+    if (options.enabled === false) {
+      return Promise.resolve(fn());
+    }
+    const runName = normalizeName(name, "unnamed-run");
+    const runId = runOptions.runId ?? createRunId();
+    const traceDir = runOptions.traceDir ?? options.traceDir ?? getDefaultTraceDir();
+    const metadata = mergeMetadata(options.metadata, runOptions.metadata);
+    const startedAt = nowIso();
+    return runtime.runWithContext(
+      {
+        runId,
+        runName,
+        traceDir,
+        silent: runOptions.silent ?? options.silent ?? true,
+        metadata
+      },
+      async () => {
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${runId}_started`,
+          runId,
+          kind: "RUN",
+          name: runName,
+          status: "running",
+          timestamp: startedAt,
+          startedAt,
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "run_started",
+            ...metadata !== void 0 ? { metadata } : {}
+          }
+        });
+        try {
+          const result = await Promise.resolve(fn());
+          const endedAt = nowIso();
+          await write({
+            schemaVersion: "0.2",
+            eventId: `${runId}_completed`,
+            runId,
+            kind: "RUN",
+            name: runName,
+            status: "ok",
+            timestamp: endedAt,
+            endedAt,
+            durationMs: durationMs(startedAt, endedAt),
+            confidence: "explicit",
+            source: { type: "manual", name: "createInspector" },
+            attributes: { legacyEvent: "run_completed" },
+            ...options.capture?.onSuccess === "metadata-only" ? { outputSummary: summarizeValue(result) } : {}
+          });
+          return result;
+        } catch (error) {
+          const endedAt = nowIso();
+          await write({
+            schemaVersion: "0.2",
+            eventId: `${runId}_completed`,
+            runId,
+            kind: "RUN",
+            name: runName,
+            status: "error",
+            timestamp: endedAt,
+            endedAt,
+            durationMs: durationMs(startedAt, endedAt),
+            confidence: "explicit",
+            source: { type: "manual", name: "createInspector" },
+            attributes: { legacyEvent: "run_completed" },
+            ...options.capture?.onError === "metadata-only" ? { outputSummary: summarizeCapturedError(error) } : {},
+            error: toPersistedError(error)
+          });
+          throw error;
+        }
+      }
+    );
+  }
+  async function step2(name, fn, stepOptions = {}) {
+    if (typeof fn !== "function") {
+      throw new TypeError("inspector.step requires `fn` to be a function");
+    }
+    if (options.enabled === false || !runtime.getCurrentContext()) {
+      return Promise.resolve(fn());
+    }
+    const context = runtime.getCurrentContext();
+    const stepName = normalizeName(name, "unnamed-step");
+    const stepId = createStepId();
+    const parentId = runtime.getCurrentStepId();
+    const stepType = stepOptions.type ?? "logic";
+    const startedAt = nowIso();
+    const attributes = {
+      legacyEvent: "step_started",
+      stepId,
+      stepType,
+      ...stepOptions.metadata !== void 0 ? { metadata: stepOptions.metadata } : {}
+    };
+    await write({
+      schemaVersion: "0.2",
+      eventId: `${stepId}_started`,
+      runId: context.runId,
+      ...parentId !== void 0 ? { parentId } : {},
+      kind: stepTypeToKind(stepType),
+      name: stepName,
+      status: "running",
+      timestamp: startedAt,
+      startedAt,
+      confidence: "explicit",
+      source: { type: "manual", name: "createInspector" },
+      attributes
+    });
+    return runtime.runWithStepContext(stepId, async () => {
+      try {
+        const result = await Promise.resolve(fn());
+        const endedAt = nowIso();
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${stepId}_completed`,
+          runId: context.runId,
+          kind: stepTypeToKind(stepType),
+          name: stepName,
+          status: "ok",
+          timestamp: endedAt,
+          endedAt,
+          durationMs: durationMs(startedAt, endedAt),
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "step_completed",
+            stepId,
+            stepType
+          },
+          ...options.capture?.onSuccess === "metadata-only" ? { outputSummary: summarizeValue(result) } : {}
+        });
+        return result;
+      } catch (error) {
+        const endedAt = nowIso();
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${stepId}_completed`,
+          runId: context.runId,
+          kind: stepTypeToKind(stepType),
+          name: stepName,
+          status: "error",
+          timestamp: endedAt,
+          endedAt,
+          durationMs: durationMs(startedAt, endedAt),
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "step_completed",
+            stepId,
+            stepType
+          },
+          ...options.capture?.onError === "metadata-only" ? { outputSummary: summarizeCapturedError(error) } : {},
+          error: toPersistedError(error)
+        });
+        throw error;
+      }
+    });
+  }
+  const inspector = {
+    runtime,
+    run,
+    step: step2,
+    tool(name, fn, toolOptions) {
+      const toolName = normalizeName(name, "unknown-tool");
+      return step2(`tool:${toolName}`, fn, {
+        ...toolOptions,
+        type: "tool",
+        metadata: {
+          ...toolOptions?.metadata ?? {},
+          toolName
+        }
+      });
+    },
+    llm(name, fn, llmOptions) {
+      const model = normalizeName(name, "unknown-model");
+      return step2(`llm:${model}`, fn, {
+        ...llmOptions,
+        type: "llm",
+        metadata: {
+          ...llmOptions?.metadata ?? {},
+          model
+        }
+      });
+    },
+    observe(name, fn, observeOptions) {
+      return async (...args) => step2(name, () => Promise.resolve(fn(...args)), observeOptions);
+    },
+    getDiagnostics() {
+      return runtime.getDiagnostics();
+    },
+    flush() {
+      return runtime.flush();
+    },
+    close() {
+      return runtime.close();
+    }
+  };
+  return inspector;
+}
+var DEFAULT_TRACE_SAFETY = resolveTraceSafetyOptions();
+function createInitialStats() {
+  return {
+    writtenEvents: 0,
+    droppedEvents: 0,
+    flushCount: 0
+  };
+}
+function markFlush(stats) {
+  stats.flushCount += 1;
+  stats.lastFlushAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneStats(stats) {
+  return { ...stats };
+}
+function normalizeError2(error) {
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
+  }
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
+  }
+  return "Unknown trace writer error";
+}
+function recordDropped(stats, error) {
+  stats.droppedEvents += 1;
+  stats.lastError = normalizeError2(error);
+}
+function prepareWriterEvent(event) {
+  return preparePersistedInspectEventForWrite(event, DEFAULT_TRACE_SAFETY);
+}
+function resolveFilePath(event, options) {
+  if (options.filePath && options.filePath.trim() !== "") {
+    return path__default.default.resolve(options.filePath);
+  }
+  return getTraceFilePath(event.runId, options.dir);
+}
+function serializeEvent2(event) {
+  return `${JSON.stringify(event)}
+`;
+}
+async function appendEventLine(event, options) {
+  const filePath = resolveFilePath(event, options);
+  await promises.mkdir(path__default.default.dirname(filePath), { recursive: true });
+  await promises.appendFile(filePath, serializeEvent2(event), "utf-8");
+}
+async function appendEventBatch(events, options) {
+  const byPath = /* @__PURE__ */ new Map();
+  let dropped = 0;
+  let lastError;
+  for (const event of events) {
+    try {
+      const filePath = resolveFilePath(event, options);
+      const line = serializeEvent2(event);
+      const lines = byPath.get(filePath);
+      if (lines) {
+        lines.push(line);
+      } else {
+        byPath.set(filePath, [line]);
+      }
+    } catch (error) {
+      dropped += 1;
+      lastError = normalizeError2(error);
+    }
+  }
+  let written = 0;
+  for (const [filePath, lines] of byPath) {
+    try {
+      await promises.mkdir(path__default.default.dirname(filePath), { recursive: true });
+      await promises.appendFile(filePath, lines.join(""), "utf-8");
+      written += lines.length;
+    } catch (error) {
+      dropped += lines.length;
+      lastError = normalizeError2(error);
+    }
+  }
+  return lastError ? { written, dropped, lastError } : { written, dropped };
+}
+function memoryWriter() {
+  const events = [];
+  const stats = createInitialStats();
+  return {
+    async write(event) {
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      events.push(safe);
+      stats.writtenEvents += 1;
+    },
+    async flush() {
+      markFlush(stats);
+    },
+    async close() {
+    },
+    getStats() {
+      return cloneStats(stats);
+    },
+    getEvents() {
+      return events.map((event) => structuredClone(event));
+    },
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+function nullWriter() {
+  const stats = createInitialStats();
+  return {
+    async write() {
+      stats.writtenEvents += 1;
+    },
+    async flush() {
+      markFlush(stats);
+    },
+    async close() {
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function fileWriter(options = {}) {
+  const stats = createInitialStats();
+  let closed = false;
+  let queue = Promise.resolve();
+  const enqueue = (event) => {
+    const operation = queue.then(async () => {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      try {
+        await appendEventLine(event, options);
+        stats.writtenEvents += 1;
+      } catch (error) {
+        recordDropped(stats, error);
+      }
+    });
+    queue = operation.catch(() => {
+    });
+    return operation.catch(() => {
+    });
+  };
+  return {
+    write(event) {
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return Promise.resolve();
+      }
+      return enqueue(safe);
+    },
+    async flush() {
+      await queue;
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await queue;
+      closed = true;
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function positiveInteger(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  return Math.floor(value);
+}
+function nonNegativeInteger(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value < 0) return fallback;
+  return Math.floor(value);
+}
+function bufferedFileWriter(options = {}) {
+  const stats = createInitialStats();
+  const maxQueueSize = positiveInteger(options.maxQueueSize, 1e3);
+  const flushIntervalMs = nonNegativeInteger(options.flushIntervalMs, 250);
+  const maxBatchSize = positiveInteger(options.maxBatchSize, 100);
+  const overflow = options.overflow ?? "drop-oldest";
+  const pending = [];
+  let closed = false;
+  let timer;
+  let chain = Promise.resolve();
+  const clearTimer = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const scheduleFlush = () => {
+    if (closed || timer !== void 0 || pending.length === 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      void drain(false);
+    }, flushIntervalMs);
+    if (timer && typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") {
+      timer.unref();
+    }
+  };
+  const drainBatch = async (drainAll) => {
+    clearTimer();
+    do {
+      const batch = pending.splice(0, maxBatchSize);
+      if (batch.length === 0) break;
+      const result = await appendEventBatch(batch, options);
+      stats.writtenEvents += result.written;
+      stats.droppedEvents += result.dropped;
+      if (result.lastError) {
+        stats.lastError = result.lastError;
+      }
+    } while (drainAll && pending.length > 0);
+    if (pending.length > 0) scheduleFlush();
+  };
+  const drain = (drainAll) => {
+    const operation = chain.then(() => drainBatch(drainAll));
+    chain = operation.catch(() => {
+    });
+    return operation.catch(() => {
+    });
+  };
+  return {
+    async write(event) {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      if (pending.length >= maxQueueSize) {
+        if (overflow === "drop-newest") {
+          recordDropped(stats, "Trace writer queue overflow");
+          return;
+        }
+        pending.shift();
+        recordDropped(stats, "Trace writer queue overflow");
+      }
+      try {
+        pending.push(safe);
+      } catch (error) {
+        recordDropped(stats, error);
+        return;
+      }
+      scheduleFlush();
+    },
+    async flush() {
+      await drain(true);
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await drain(true);
+      closed = true;
+      clearTimer();
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+function compositeWriter(writersOrOptions) {
+  const stats = createInitialStats();
+  const writers = Array.isArray(writersOrOptions) ? [...writersOrOptions] : [...writersOrOptions.writers];
+  let closed = false;
+  const recordChildFailure = (error) => {
+    stats.droppedEvents += 1;
+    stats.lastError = normalizeError2(error);
+  };
+  return {
+    async write(event) {
+      if (closed) {
+        recordDropped(stats, "Trace writer is closed");
+        return;
+      }
+      const safe = prepareWriterEvent(event);
+      if (safe === void 0) {
+        recordDropped(stats, "Invalid persisted inspect event");
+        return;
+      }
+      const childResults = await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.write(structuredClone(safe));
+            return true;
+          } catch (error) {
+            recordChildFailure(error);
+            return false;
+          }
+        })
+      );
+      if (childResults.some(Boolean)) {
+        stats.writtenEvents += 1;
+      } else {
+        recordDropped(stats, "No composite trace writer accepted the event");
+      }
+    },
+    async flush() {
+      await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.flush?.();
+          } catch (error) {
+            stats.lastError = normalizeError2(error);
+          }
+        })
+      );
+      markFlush(stats);
+    },
+    async close() {
+      if (closed) return;
+      await Promise.all(
+        writers.map(async (writer) => {
+          try {
+            await writer.close?.();
+          } catch (error) {
+            stats.lastError = normalizeError2(error);
+          }
+        })
+      );
+      closed = true;
+    },
+    getStats() {
+      return cloneStats(stats);
+    }
+  };
+}
+var DEFAULT_MAX_TRACE_INPUT_BYTES = 10 * 1024 * 1024;
+var MIN_DETECTION_CONFIDENCE = 0.5;
+var AMBIGUOUS_CONFIDENCE_DELTA = 0.05;
+var resolvedInputCache = /* @__PURE__ */ new WeakMap();
+var OPENINFERENCE_READER_FORMAT = "openinference-json";
+var OTLP_READER_FORMAT = "otlp-json";
+var OPENINFERENCE_SPAN_KEYS = /* @__PURE__ */ new Set([
+  "trace_id",
+  "traceId",
+  "span_id",
+  "spanId",
+  "parent_span_id",
+  "parentSpanId",
+  "name",
+  "start_time_unix_nano",
+  "startTimeUnixNano",
+  "end_time_unix_nano",
+  "endTimeUnixNano",
+  "start_time",
+  "startTime",
+  "end_time",
+  "endTime",
+  "attributes",
+  "status",
+  "kind",
+  "span_kind",
+  "spanKind"
+]);
+var OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS = [
+  "input.value",
+  "output.value",
+  "input.mime_type",
+  "output.mime_type",
+  "llm.input_messages",
+  "llm.output_messages",
+  "llm.prompts",
+  "llm.completions",
+  "retrieval.documents",
+  "reranker.input_documents",
+  "reranker.output_documents",
+  "document.content",
+  "gen_ai.prompt",
+  "gen_ai.completion",
+  "gen_ai.input.messages",
+  "gen_ai.output.messages"
+];
+var OTLP_SPAN_KEYS = /* @__PURE__ */ new Set([
+  "traceId",
+  "spanId",
+  "parentSpanId",
+  "name",
+  "kind",
+  "startTimeUnixNano",
+  "endTimeUnixNano",
+  "attributes",
+  "events",
+  "status",
+  "droppedAttributesCount",
+  "droppedEventsCount",
+  "droppedLinksCount",
+  "links",
+  "flags"
+]);
+var TraceReadError = class extends Error {
+  code;
+  warnings;
+  constructor(code, message, warnings = []) {
+    super(message);
+    this.name = "TraceReadError";
+    this.code = code;
+    this.warnings = warnings;
+  }
+};
+function normalizeCandidate(reader, candidate) {
+  const confidence = Number.isFinite(candidate.confidence) ? Math.max(0, Math.min(1, candidate.confidence)) : 0;
+  return {
+    ...candidate,
+    format: candidate.format || reader.format,
+    confidence,
+    readerName: candidate.readerName ?? reader.name
+  };
+}
+function sortCandidates(candidates) {
+  return [...candidates].sort((a, b) => {
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    return a.format.localeCompare(b.format);
+  });
+}
+function collectWarnings(candidates) {
+  return candidates.flatMap((candidate) => candidate.warnings ?? []);
+}
+function dedupeWarnings(warnings) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const warning of warnings) {
+    const key = [
+      warning.code,
+      warning.message,
+      warning.severity ?? "",
+      warning.sourceFile ?? "",
+      warning.line ?? "",
+      warning.field ?? ""
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(warning);
+  }
+  return out;
+}
+function attachSingleSourceFile(warnings, resolved) {
+  if (resolved.sourceFiles.length !== 1) return [...warnings];
+  const [sourceFile] = resolved.sourceFiles;
+  return warnings.map((warning) => ({
+    ...warning,
+    sourceFile: warning.sourceFile ?? sourceFile
+  }));
+}
+function findReaderByFormat(format, readers) {
+  return readers.find((reader) => reader.format === format);
+}
+async function jsonlFilesInDirectory(dirPath) {
+  const entries = await promises.readdir(dirPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path__default.default.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+}
+async function resolveInput(input) {
+  const cached = resolvedInputCache.get(input);
+  if (cached) return cached;
+  const promise = resolveInputUncached(input);
+  resolvedInputCache.set(input, promise);
+  return promise;
+}
+function assertInputWithinBounds(content, sourceFile) {
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes <= DEFAULT_MAX_TRACE_INPUT_BYTES) return;
+  throw new TraceReadError("unsupported_format", "Trace input exceeds the local reader size limit.", [
+    {
+      code: "input_too_large",
+      message: `Trace input is ${bytes} bytes; max is ${DEFAULT_MAX_TRACE_INPUT_BYTES} bytes.`,
+      severity: "error",
+      ...sourceFile !== void 0 ? { sourceFile } : {}
+    }
+  ]);
+}
+async function resolveInputUncached(input) {
+  if (input.type === "string") {
+    assertInputWithinBounds(input.content);
+    return { content: input.content, sourceFiles: [] };
+  }
+  if (input.type === "buffer") {
+    const content = input.content.toString("utf-8");
+    assertInputWithinBounds(content);
+    return { content, sourceFiles: [] };
+  }
+  if (input.type === "file") {
+    const content = await promises.readFile(input.path, "utf-8");
+    assertInputWithinBounds(content, input.path);
+    return { content, sourceFiles: [input.path] };
+  }
+  if (input.type === "directory") {
+    const files = await jsonlFilesInDirectory(input.path);
+    const parts = await Promise.all(
+      files.map(async (file) => (await promises.readFile(file, "utf-8")).trimEnd())
+    );
+    const content = parts.filter((part) => part.trim() !== "").join("\n");
+    assertInputWithinBounds(content, input.path);
+    return {
+      content,
+      sourceFiles: files
+    };
+  }
+  return void 0;
+}
+function detectJsonlFormat(content) {
+  let saw01 = false;
+  let saw02 = false;
+  let validRows = 0;
+  let invalidJsonRows = 0;
+  let unknownSchemaRows = 0;
+  let firstInvalidJsonLine;
+  let firstUnknownSchemaLine;
+  let lineNumber = 0;
+  for (const line of content.split(/\r?\n/)) {
+    lineNumber += 1;
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      invalidJsonRows += 1;
+      firstInvalidJsonLine ??= lineNumber;
+      continue;
+    }
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && "schemaVersion" in parsed) {
+      const version = parsed.schemaVersion;
+      if (version === "0.1") {
+        saw01 = true;
+        validRows += 1;
+        continue;
+      }
+      if (version === "0.2") {
+        saw02 = true;
+        validRows += 1;
+        continue;
+      }
+    }
+    unknownSchemaRows += 1;
+    firstUnknownSchemaLine ??= lineNumber;
+  }
+  const warnings = [];
+  if (invalidJsonRows > 0) {
+    warnings.push({
+      code: "invalid_jsonl_rows",
+      message: `Skipped ${invalidJsonRows} invalid JSONL row(s) during format detection.`,
+      severity: "warning",
+      ...firstInvalidJsonLine !== void 0 ? { line: firstInvalidJsonLine } : {}
+    });
+  }
+  if (unknownSchemaRows > 0) {
+    warnings.push({
+      code: "unknown_schema_rows",
+      message: `Skipped ${unknownSchemaRows} row(s) with unknown schemaVersion during format detection.`,
+      severity: "warning",
+      ...firstUnknownSchemaLine !== void 0 ? { line: firstUnknownSchemaLine } : {}
+    });
+  }
+  let format = "empty";
+  if (saw01 && saw02) format = "mixed";
+  else if (saw01) format = "0.1";
+  else if (saw02) format = "0.2";
+  return { format, validRows, warnings };
+}
+function agentInspectFormatLabel(format) {
+  switch (format) {
+    case "0.1":
+      return "agent-inspect-v0.1-jsonl";
+    case "0.2":
+      return "agent-inspect-v0.2-jsonl";
+    case "mixed":
+      return "agent-inspect-mixed-jsonl";
+    default:
+      return "agent-inspect-jsonl";
+  }
+}
+function persistedEventsForParsedTrace(parsed) {
+  if (parsed.format === "0.2" && parsed.persisted.length > 0) {
+    return [...parsed.persisted];
+  }
+  if (parsed.format === "mixed" && parsed.rows.length > 0) {
+    return parsed.rows.map((row, index) => {
+      if (row.format === "0.2") return row.event;
+      return traceEventToPersistedInspectEvent(row.event, {
+        eventIndex: index,
+        sourceName: "agent-inspect-jsonl-reader"
+      });
+    });
+  }
+  return traceEventsToPersistedInspectEvents(parsed.events, {
+    sourceName: "agent-inspect-jsonl-reader"
+  });
+}
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString3(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function readStringField(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (isNonEmptyString3(value)) return value;
+  }
+  return void 0;
+}
+function readRecordField(record, key) {
+  const value = record[key];
+  return isRecord13(value) ? value : void 0;
+}
+function parseJsonDocument(content) {
+  return JSON.parse(content);
+}
+function looksLikeOpenInferenceSpan(value) {
+  if (!isRecord13(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);
+}
+function extractOpenInferenceDocument(root) {
+  const warnings = [];
+  const unsupportedFields = [];
+  if (Array.isArray(root)) {
+    const spans = root.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.length) {
+      warnings.push({
+        code: "openinference_skipped_items",
+        message: "Skipped non-span item(s) in OpenInference span array.",
+        severity: "warning"
+      });
+    }
+    return {
+      spans,
+      confidence: 0.82,
+      description: "OpenInference span array",
+      warnings,
+      unsupportedFields
+    };
+  }
+  if (!isRecord13(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;
+  if (Array.isArray(root.spans)) {
+    const spans = root.spans.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0 && (rootFormat === "openinference" || rootCompatibility === "openinference-compatible")) {
+      warnings.push({
+        code: "openinference_no_valid_spans",
+        message: "OpenInference document did not contain any valid spans.",
+        severity: "error"
+      });
+      return {
+        spans,
+        confidence: 0.7,
+        description: "Malformed OpenInference document",
+        version,
+        warnings,
+        unsupportedFields
+      };
+    }
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.spans.length) {
+      warnings.push({
+        code: "openinference_skipped_spans",
+        message: "Skipped invalid OpenInference span item(s).",
+        severity: "warning"
+      });
+    }
+    return {
+      spans,
+      confidence: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? 0.9 : 0.84,
+      description: rootFormat === "openinference" || rootCompatibility === "openinference-compatible" ? "OpenInference document" : "OpenInference spans document",
+      version,
+      warnings,
+      unsupportedFields
+    };
+  }
+  if (Array.isArray(root.data)) {
+    const spans = root.data.filter(looksLikeOpenInferenceSpan);
+    if (spans.length === 0) return void 0;
+    if (spans.length !== root.data.length) {
+      warnings.push({
+        code: "openinference_skipped_data_items",
+        message: "Skipped non-span item(s) in OpenInference data array.",
+        severity: "warning"
+      });
+    }
+    return {
+      spans,
+      confidence: 0.8,
+      description: "OpenInference data document",
+      version,
+      warnings,
+      unsupportedFields
+    };
+  }
+  if (looksLikeOpenInferenceSpan(root)) {
+    return {
+      spans: [root],
+      confidence: 0.76,
+      description: "OpenInference single span",
+      version,
+      warnings,
+      unsupportedFields
+    };
+  }
+  if (rootFormat === "openinference" || rootCompatibility === "openinference-compatible") {
+    warnings.push({
+      code: "openinference_missing_spans",
+      message: "OpenInference document is missing a spans array.",
+      severity: "error"
+    });
+    return {
+      spans: [],
+      confidence: 0.7,
+      description: "Malformed OpenInference document",
+      version,
+      warnings,
+      unsupportedFields
+    };
+  }
+  return void 0;
+}
+function parseUnixNanoToIso(value) {
+  if (typeof value === "bigint" && value >= 0n) {
+    return new Date(Number(value / 1000000n)).toISOString();
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return new Date(Math.floor(value / 1e6)).toISOString();
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return new Date(Number(BigInt(value) / 1000000n)).toISOString();
+  }
+  return void 0;
+}
+function parseIsoTime(value) {
+  if (!isNonEmptyString3(value)) return void 0;
+  const ms = Date.parse(value);
+  if (!Number.isFinite(ms)) return void 0;
+  return new Date(ms).toISOString();
+}
+function readOpenInferenceTimestamp(span, nanoKeys, isoKeys) {
+  for (const key of nanoKeys) {
+    const iso = parseUnixNanoToIso(span[key]);
+    if (iso !== void 0) return iso;
+  }
+  for (const key of isoKeys) {
+    const iso = parseIsoTime(span[key]);
+    if (iso !== void 0) return iso;
+  }
+  return void 0;
+}
+function durationBetweenIso(startedAt, endedAt) {
+  if (startedAt === void 0 || endedAt === void 0) return void 0;
+  const startMs = Date.parse(startedAt);
+  const endMs = Date.parse(endedAt);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) {
+    return void 0;
+  }
+  return endMs - startMs;
+}
+function isSensitiveOpenInferenceAttribute(key) {
+  return OPENINFERENCE_SENSITIVE_ATTRIBUTE_KEYS.some(
+    (sensitiveKey) => key === sensitiveKey || key.startsWith(`${sensitiveKey}.`) || key.endsWith(".message.content") || key.endsWith(".document.content")
+  );
+}
+function summarizeAttributeValue(value) {
+  if (typeof value === "string") {
+    return { type: "string", length: value.length };
+  }
+  if (typeof value === "number") {
+    return { type: "number", finite: Number.isFinite(value) };
+  }
+  if (typeof value === "boolean") {
+    return { type: "boolean" };
+  }
+  if (Array.isArray(value)) {
+    return { type: "array", length: value.length };
+  }
+  if (isRecord13(value)) {
+    return { type: "object", keyCount: Object.keys(value).length };
+  }
+  if (value === null) {
+    return { type: "null" };
+  }
+  return { type: typeof value };
+}
+function sanitizeOpenInferenceAttributes(attributes, pathPrefix) {
+  const out = {};
+  const warnings = [];
+  const unsupportedFields = [];
+  const summarizedKeys = [];
+  for (const [key, value] of Object.entries(attributes)) {
+    if (isSensitiveOpenInferenceAttribute(key)) {
+      summarizedKeys.push(key);
+      out[`${key}.summary`] = summarizeAttributeValue(value);
+      unsupportedFields.push(`${pathPrefix}.attributes.${key}`);
+      continue;
+    }
+    out[key] = value;
+  }
+  if (summarizedKeys.length > 0) {
+    out["openinference.summarized_attributes"] = summarizedKeys;
+    warnings.push({
+      code: "openinference_sensitive_attribute_summarized",
+      message: "OpenInference prompt/output/document attribute(s) were summarized instead of copied verbatim.",
+      severity: "warning"
+    });
+  }
+  return { attributes: out, warnings, unsupportedFields };
+}
+function mapOpenInferenceKind(span, attributes, pathPrefix) {
+  const warnings = [];
+  const agentInspectKind = attributes["agent_inspect.kind"];
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG") {
+    return { kind: agentInspectKind, warnings };
+  }
+  const rawKind = readStringField(span, ["kind", "span_kind", "spanKind"]) ?? (typeof attributes["openinference.span.kind"] === "string" ? attributes["openinference.span.kind"] : void 0);
+  const normalized = rawKind?.toUpperCase();
+  switch (normalized) {
+    case "LLM":
+      return { kind: "LLM", warnings };
+    case "TOOL":
+      return { kind: "TOOL", warnings };
+    case "CHAIN":
+      return { kind: "CHAIN", warnings };
+    case "RETRIEVER":
+      return { kind: "RETRIEVER", warnings };
+    case "AGENT":
+      return { kind: "AGENT", warnings };
+    case "EMBEDDING":
+      warnings.push({
+        code: "openinference_kind_semantic_loss",
+        message: "OpenInference EMBEDDING span kind mapped to AgentInspect LLM.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LLM", warnings };
+    case "RERANKER":
+      warnings.push({
+        code: "openinference_kind_semantic_loss",
+        message: "OpenInference RERANKER span kind mapped to AgentInspect RETRIEVER.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "RETRIEVER", warnings };
+    case "UNKNOWN":
+    case void 0:
+      warnings.push({
+        code: "openinference_kind_unknown",
+        message: "OpenInference span kind was missing or unknown; mapped to AgentInspect LOGIC.",
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LOGIC", warnings };
+    default:
+      warnings.push({
+        code: "openinference_kind_unsupported",
+        message: `Unsupported OpenInference span kind "${rawKind}" mapped to AgentInspect LOGIC.`,
+        severity: "warning",
+        field: `${pathPrefix}.attributes.openinference.span.kind`
+      });
+      return { kind: "LOGIC", warnings };
+  }
+}
+function mapOpenInferenceStatus(status) {
+  if (!isRecord13(status)) return void 0;
+  const rawCode = status.code;
+  if (typeof rawCode !== "string") return void 0;
+  switch (rawCode.toUpperCase()) {
+    case "OK":
+      return "ok";
+    case "ERROR":
+      return "error";
+    case "UNSET":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function readOpenInferenceTokenUsage(attributes) {
+  const prompt = attributes["llm.token_count.prompt"];
+  const completion = attributes["llm.token_count.completion"];
+  const total = attributes["llm.token_count.total"];
+  const cached = attributes["llm.token_count.prompt_details.cache_read"];
+  const usage = {};
+  if (typeof prompt === "number" && Number.isFinite(prompt) && prompt >= 0) {
+    usage.input = prompt;
+  }
+  if (typeof completion === "number" && Number.isFinite(completion) && completion >= 0) {
+    usage.output = completion;
+  }
+  if (typeof total === "number" && Number.isFinite(total) && total >= 0) {
+    usage.total = total;
+  }
+  if (typeof cached === "number" && Number.isFinite(cached) && cached >= 0) {
+    usage.cached = cached;
+  }
+  if (usage.total === void 0 && usage.input !== void 0 && usage.output !== void 0) {
+    usage.total = usage.input + usage.output;
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
+}
+function readOpenInferenceConfidence(attributes) {
+  const confidence = attributes["agent_inspect.confidence"];
+  if (confidence === "explicit" || confidence === "correlated" || confidence === "heuristic" || confidence === "unknown") {
+    return confidence;
+  }
+  return "correlated";
+}
+function mapOpenInferenceSpan(span, index, version) {
+  const pathPrefix = `spans[${index}]`;
+  const warnings = [];
+  const unsupportedFields = [];
+  const rawAttributes = readRecordField(span, "attributes") ?? {};
+  const sanitized = sanitizeOpenInferenceAttributes(rawAttributes, pathPrefix);
+  warnings.push(...sanitized.warnings);
+  unsupportedFields.push(...sanitized.unsupportedFields);
+  const attributes = { ...sanitized.attributes };
+  for (const [key, value] of Object.entries(span)) {
+    if (OPENINFERENCE_SPAN_KEYS.has(key)) continue;
+    unsupportedFields.push(`${pathPrefix}.${key}`);
+    if (value === null || typeof value !== "object") {
+      attributes[`openinference.${key}`] = value;
+    } else {
+      attributes[`openinference.${key}.summary`] = summarizeAttributeValue(value);
+      warnings.push({
+        code: "openinference_unsupported_field_summarized",
+        message: `Unsupported OpenInference span field "${key}" was summarized.`,
+        severity: "warning",
+        field: `${pathPrefix}.${key}`
+      });
+    }
+  }
+  const traceId = readStringField(span, ["trace_id", "traceId"]) ?? `trace-${index}`;
+  const spanId = readStringField(span, ["span_id", "spanId"]) ?? `span-${index}`;
+  const parentSpanId = readStringField(span, ["parent_span_id", "parentSpanId"]);
+  const name = readStringField(span, ["name"]) ?? spanId;
+  const startedAt = readOpenInferenceTimestamp(
+    span,
+    ["start_time_unix_nano", "startTimeUnixNano"],
+    ["start_time", "startTime"]
+  );
+  const endedAt = readOpenInferenceTimestamp(
+    span,
+    ["end_time_unix_nano", "endTimeUnixNano"],
+    ["end_time", "endTime"]
+  );
+  const timestamp = startedAt ?? "1970-01-01T00:00:00.000Z";
+  if (startedAt === void 0) {
+    warnings.push({
+      code: "openinference_missing_start_time",
+      message: "OpenInference span is missing a valid start time; using Unix epoch.",
+      severity: "warning",
+      field: `${pathPrefix}.start_time_unix_nano`
+    });
+    unsupportedFields.push(`${pathPrefix}.start_time_unix_nano`);
+  }
+  const { kind, warnings: kindWarnings } = mapOpenInferenceKind(
+    span,
+    rawAttributes,
+    pathPrefix
+  );
+  warnings.push(...kindWarnings);
+  const status = mapOpenInferenceStatus(span.status);
+  const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
+  const errorMessage = isRecord13(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,
+    runId: typeof rawAttributes["agent_inspect.run_id"] === "string" ? rawAttributes["agent_inspect.run_id"] : traceId,
+    kind,
+    name,
+    timestamp,
+    confidence: readOpenInferenceConfidence(rawAttributes),
+    source: {
+      type: "otel",
+      name: "openinference",
+      ...version !== void 0 ? { version } : {}
+    },
+    attributes,
+    trace: {
+      traceId,
+      spanId,
+      ...parentSpanId !== void 0 ? { parentSpanId } : {}
+    }
+  };
+  if (status !== void 0) {
+    event.status = status;
+  }
+  if (startedAt !== void 0) {
+    event.startedAt = startedAt;
+  }
+  if (endedAt !== void 0) {
+    event.endedAt = endedAt;
+  }
+  const durationMs2 = durationBetweenIso(startedAt, endedAt);
+  if (durationMs2 !== void 0) {
+    event.durationMs = durationMs2;
+  }
+  if (tokenUsage !== void 0) {
+    event.tokenUsage = tokenUsage;
+  }
+  if (status === "error") {
+    event.error = {
+      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OpenInference span error"
+    };
+  }
+  return {
+    event,
+    warnings,
+    unsupportedFields,
+    spanId,
+    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  };
+}
+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])
+  );
+  for (const span of mapped) {
+    if (span.parentSpanId === void 0) continue;
+    span.event.parentId = spanIdToEventId.get(span.parentSpanId) ?? span.parentSpanId;
+  }
+  return {
+    events: mapped.map((span) => span.event),
+    warnings: mapped.flatMap((span) => span.warnings),
+    unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
+  };
+}
+var openInferenceJsonReader = {
+  format: OPENINFERENCE_READER_FORMAT,
+  name: "OpenInference JSON",
+  async detect(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) return void 0;
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      return void 0;
+    }
+    const document = extractOpenInferenceDocument(parsed);
+    if (!document) return void 0;
+    return {
+      format: OPENINFERENCE_READER_FORMAT,
+      confidence: document.confidence,
+      readerName: "OpenInference JSON",
+      description: document.description,
+      warnings: attachSingleSourceFile(document.warnings, resolved)
+    };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "OpenInference JSON reader requires file, string, or buffer input."
+      );
+    }
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      throw new TraceReadError("unsupported_format", "OpenInference JSON input is not valid JSON.", [
+        {
+          code: "openinference_invalid_json",
+          message: "OpenInference JSON reader could not parse the input as JSON.",
+          severity: "error"
+        }
+      ]);
+    }
+    const document = extractOpenInferenceDocument(parsed);
+    if (!document || document.spans.length === 0) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "No valid OpenInference spans found.",
+        attachSingleSourceFile(
+          document?.warnings ?? [
+            {
+              code: "openinference_no_valid_spans",
+              message: "OpenInference JSON input did not contain valid spans.",
+              severity: "error"
+            }
+          ],
+          resolved
+        )
+      );
+    }
+    const mapped = mapOpenInferenceEvents(document);
+    const warnings = attachSingleSourceFile(
+      [...document.warnings, ...mapped.warnings],
+      resolved
+    );
+    const unsupportedFields = [
+      ...document.unsupportedFields,
+      ...mapped.unsupportedFields
+    ].sort((a, b) => a.localeCompare(b));
+    return {
+      format: OPENINFERENCE_READER_FORMAT,
+      events: mapped.events,
+      runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
+      warnings,
+      unsupportedFields,
+      sourceFiles: resolved.sourceFiles
+    };
+  }
+};
+function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
+  if (!isRecord13(value)) {
+    unsupportedFields.push(field);
+    warnings.push({
+      code: "otlp_attribute_value_invalid",
+      message: "OTLP attribute value was not an AnyValue object.",
+      severity: "warning",
+      field
+    });
+    return void 0;
+  }
+  if (typeof value.stringValue === "string") return value.stringValue;
+  if (typeof value.boolValue === "boolean") return value.boolValue;
+  if (typeof value.intValue === "number" && Number.isFinite(value.intValue)) {
+    return value.intValue;
+  }
+  if (typeof value.intValue === "string" && value.intValue.trim() !== "") {
+    const n = Number(value.intValue);
+    if (Number.isFinite(n)) return n;
+  }
+  if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
+    return value.doubleValue;
+  }
+  if (isRecord13(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+    return value.arrayValue.values.map(
+      (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
+    );
+  }
+  if (isRecord13(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+    const out = {};
+    for (const [index, item] of value.kvlistValue.values.entries()) {
+      if (!isRecord13(item) || typeof item.key !== "string") {
+        unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
+        continue;
+      }
+      out[item.key] = parseOtlpAnyValue(
+        item.value,
+        `${field}.kvlistValue.values[${index}].value`,
+        warnings,
+        unsupportedFields
+      );
+    }
+    return out;
+  }
+  if (typeof value.bytesValue === "string") {
+    unsupportedFields.push(field);
+    warnings.push({
+      code: "otlp_bytes_value_summarized",
+      message: "OTLP bytesValue attribute was summarized instead of decoded.",
+      severity: "warning",
+      field
+    });
+    return { type: "bytes", length: value.bytesValue.length };
+  }
+  unsupportedFields.push(field);
+  warnings.push({
+    code: "otlp_attribute_value_unsupported",
+    message: "OTLP attribute value used an unsupported AnyValue shape.",
+    severity: "warning",
+    field
+  });
+  return void 0;
+}
+function parseOtlpAttributes(value, pathPrefix) {
+  const attributes = {};
+  const warnings = [];
+  const unsupportedFields = [];
+  if (value === void 0) {
+    return { attributes, warnings, unsupportedFields };
+  }
+  if (!Array.isArray(value)) {
+    unsupportedFields.push(pathPrefix);
+    warnings.push({
+      code: "otlp_attributes_invalid",
+      message: "OTLP attributes field was not an array.",
+      severity: "warning",
+      field: pathPrefix
+    });
+    return { attributes, warnings, unsupportedFields };
+  }
+  for (const [index, item] of value.entries()) {
+    const field = `${pathPrefix}[${index}]`;
+    if (!isRecord13(item) || typeof item.key !== "string") {
+      unsupportedFields.push(field);
+      warnings.push({
+        code: "otlp_attribute_invalid",
+        message: "Skipped OTLP attribute without a string key.",
+        severity: "warning",
+        field
+      });
+      continue;
+    }
+    const parsed = parseOtlpAnyValue(
+      item.value,
+      `${field}.value`,
+      warnings,
+      unsupportedFields
+    );
+    if (parsed !== void 0) {
+      attributes[item.key] = parsed;
+    }
+  }
+  return { attributes, warnings, unsupportedFields };
+}
+function looksLikeOtlpSpan(value) {
+  return isRecord13(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+}
+function extractOtlpDocument(root) {
+  if (!isRecord13(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 (!isRecord13(resourceSpan)) {
+      unsupportedFields.push(resourcePath);
+      continue;
+    }
+    const resource = readRecordField(resourceSpan, "resource");
+    const resourceParsed = parseOtlpAttributes(
+      resource?.attributes,
+      `${resourcePath}.resource.attributes`
+    );
+    warnings.push(...resourceParsed.warnings);
+    unsupportedFields.push(...resourceParsed.unsupportedFields);
+    if (!Array.isArray(resourceSpan.scopeSpans)) {
+      unsupportedFields.push(`${resourcePath}.scopeSpans`);
+      warnings.push({
+        code: "otlp_scope_spans_missing",
+        message: "OTLP resourceSpans entry did not contain a scopeSpans array.",
+        severity: "warning",
+        field: `${resourcePath}.scopeSpans`
+      });
+      continue;
+    }
+    for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
+      const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
+      if (!isRecord13(scopeSpan)) {
+        unsupportedFields.push(scopePath);
+        continue;
+      }
+      const scope = readRecordField(scopeSpan, "scope");
+      const scopeParsed = parseOtlpAttributes(
+        scope?.attributes,
+        `${scopePath}.scope.attributes`
+      );
+      warnings.push(...scopeParsed.warnings);
+      unsupportedFields.push(...scopeParsed.unsupportedFields);
+      if (!Array.isArray(scopeSpan.spans)) {
+        unsupportedFields.push(`${scopePath}.spans`);
+        warnings.push({
+          code: "otlp_spans_missing",
+          message: "OTLP scopeSpans entry did not contain a spans array.",
+          severity: "warning",
+          field: `${scopePath}.spans`
+        });
+        continue;
+      }
+      for (const [spanIndex, span] of scopeSpan.spans.entries()) {
+        const spanPath = `${scopePath}.spans[${spanIndex}]`;
+        if (!looksLikeOtlpSpan(span)) {
+          unsupportedFields.push(spanPath);
+          warnings.push({
+            code: "otlp_invalid_span",
+            message: "Skipped OTLP span without required traceId, spanId, or name.",
+            severity: "warning",
+            field: spanPath
+          });
+          continue;
+        }
+        spans.push({
+          span,
+          resourceAttributes: resourceParsed.attributes,
+          scopeAttributes: scopeParsed.attributes,
+          scopeName: readStringField(scope ?? {}, ["name"]),
+          scopeVersion: readStringField(scope ?? {}, ["version"]),
+          pathPrefix: spanPath
+        });
+      }
+    }
+  }
+  if (spans.length === 0) {
+    warnings.push({
+      code: "otlp_no_valid_spans",
+      message: "OTLP JSON payload did not contain any valid spans.",
+      severity: "error"
+    });
+    return {
+      spans,
+      confidence: 0.7,
+      description: "Malformed OTLP JSON trace payload",
+      warnings,
+      unsupportedFields
+    };
+  }
+  return {
+    spans,
+    confidence: 0.93,
+    description: "OTLP JSON trace payload",
+    warnings,
+    unsupportedFields
+  };
+}
+function mapOtlpStatus(status) {
+  if (!isRecord13(status)) return void 0;
+  const rawCode = status.code;
+  if (typeof rawCode !== "string") return void 0;
+  switch (rawCode.toUpperCase()) {
+    case "STATUS_CODE_OK":
+    case "OK":
+      return "ok";
+    case "STATUS_CODE_ERROR":
+    case "ERROR":
+      return "error";
+    case "STATUS_CODE_UNSET":
+    case "UNSET":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function readOtlpKind(attributes, pathPrefix) {
+  const warnings = [];
+  const agentInspectKind = attributes["agent_inspect.kind"];
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG") {
+    return { kind: agentInspectKind, warnings };
+  }
+  const operation = attributes["gen_ai.operation.name"];
+  if (typeof operation === "string") {
+    switch (operation) {
+      case "generate_content":
+      case "chat":
+        return { kind: "LLM", warnings };
+      case "execute_tool":
+        return { kind: "TOOL", warnings };
+      case "invoke_agent":
+        return { kind: "AGENT", warnings };
+      default:
+        warnings.push({
+          code: "otlp_gen_ai_operation_semantic_loss",
+          message: `OTLP GenAI operation "${operation}" mapped to AgentInspect LOGIC.`,
+          severity: "warning",
+          field: `${pathPrefix}.attributes.gen_ai.operation.name`
+        });
+        return { kind: "LOGIC", warnings };
+    }
+  }
+  warnings.push({
+    code: "otlp_kind_unknown",
+    message: "OTLP span had no AgentInspect kind or GenAI operation; mapped to LOGIC.",
+    severity: "warning",
+    field: `${pathPrefix}.attributes`
+  });
+  return { kind: "LOGIC", warnings };
+}
+function readOtlpTokenUsage(attributes) {
+  const input = attributes["gen_ai.usage.input_tokens"];
+  const output = attributes["gen_ai.usage.output_tokens"];
+  const usage = {};
+  if (typeof input === "number" && Number.isFinite(input) && input >= 0) {
+    usage.input = input;
+  }
+  if (typeof output === "number" && Number.isFinite(output) && output >= 0) {
+    usage.output = output;
+  }
+  if (usage.input !== void 0 && usage.output !== void 0) {
+    usage.total = usage.input + usage.output;
+  }
+  return Object.keys(usage).length > 0 ? usage : void 0;
+}
+function readOtlpConfidence(attributes) {
+  return readOpenInferenceConfidence(attributes);
+}
+function sanitizeOtlpAttributes(attributes, pathPrefix) {
+  const ownerPath = pathPrefix.endsWith(".attributes") ? pathPrefix.slice(0, -".attributes".length) : pathPrefix;
+  const sanitized = sanitizeOpenInferenceAttributes(attributes, ownerPath);
+  return {
+    ...sanitized,
+    warnings: sanitized.warnings.map(
+      (warning) => warning.code === "openinference_sensitive_attribute_summarized" ? {
+        ...warning,
+        code: "otlp_sensitive_attribute_summarized",
+        message: "OTLP prompt/output/document attribute(s) were summarized instead of copied verbatim."
+      } : warning
+    )
+  };
+}
+function mapOtlpEvents(value, pathPrefix) {
+  const warnings = [];
+  const unsupportedFields = [];
+  if (value === void 0) return { warnings, unsupportedFields };
+  if (!Array.isArray(value)) {
+    unsupportedFields.push(pathPrefix);
+    warnings.push({
+      code: "otlp_events_invalid",
+      message: "OTLP events field was not an array.",
+      severity: "warning",
+      field: pathPrefix
+    });
+    return { warnings, unsupportedFields };
+  }
+  const events = [];
+  for (const [index, event] of value.entries()) {
+    const eventPath = `${pathPrefix}[${index}]`;
+    if (!isRecord13(event)) {
+      unsupportedFields.push(eventPath);
+      continue;
+    }
+    const parsedAttributes = parseOtlpAttributes(
+      event.attributes,
+      `${eventPath}.attributes`
+    );
+    warnings.push(...parsedAttributes.warnings);
+    unsupportedFields.push(...parsedAttributes.unsupportedFields);
+    const sanitized = sanitizeOtlpAttributes(
+      parsedAttributes.attributes,
+      `${eventPath}.attributes`
+    );
+    warnings.push(...sanitized.warnings);
+    unsupportedFields.push(...sanitized.unsupportedFields);
+    const out = {};
+    const name = readStringField(event, ["name"]);
+    if (name !== void 0) {
+      out.name = name;
+    }
+    const timestamp = parseUnixNanoToIso(event.timeUnixNano);
+    if (timestamp !== void 0) {
+      out.timestamp = timestamp;
+    } else if (event.timeUnixNano !== void 0) {
+      unsupportedFields.push(`${eventPath}.timeUnixNano`);
+      warnings.push({
+        code: "otlp_event_timestamp_invalid",
+        message: "OTLP event timeUnixNano could not be parsed.",
+        severity: "warning",
+        field: `${eventPath}.timeUnixNano`
+      });
+    }
+    if (Object.keys(sanitized.attributes).length > 0) {
+      out.attributes = sanitized.attributes;
+    }
+    events.push(out);
+  }
+  return {
+    events: events.length > 0 ? events : void 0,
+    warnings,
+    unsupportedFields
+  };
+}
+function mapOtlpSpan(context) {
+  const { span, pathPrefix } = context;
+  const warnings = [];
+  const unsupportedFields = [];
+  const parsedSpanAttributes = parseOtlpAttributes(
+    span.attributes,
+    `${pathPrefix}.attributes`
+  );
+  warnings.push(...parsedSpanAttributes.warnings);
+  unsupportedFields.push(...parsedSpanAttributes.unsupportedFields);
+  const sanitizedSpanAttributes = sanitizeOtlpAttributes(
+    parsedSpanAttributes.attributes,
+    `${pathPrefix}.attributes`
+  );
+  warnings.push(...sanitizedSpanAttributes.warnings);
+  unsupportedFields.push(...sanitizedSpanAttributes.unsupportedFields);
+  const attributes = {
+    ...sanitizedSpanAttributes.attributes
+  };
+  for (const [key, value] of Object.entries(context.resourceAttributes)) {
+    attributes[`resource.${key}`] = value;
+  }
+  for (const [key, value] of Object.entries(context.scopeAttributes)) {
+    attributes[`scope.${key}`] = value;
+  }
+  if (context.scopeName !== void 0) {
+    attributes["scope.name"] = context.scopeName;
+  }
+  if (context.scopeVersion !== void 0) {
+    attributes["scope.version"] = context.scopeVersion;
+  }
+  for (const [key, value] of Object.entries(span)) {
+    if (OTLP_SPAN_KEYS.has(key)) continue;
+    unsupportedFields.push(`${pathPrefix}.${key}`);
+    if (value === null || typeof value !== "object") {
+      attributes[`otlp.${key}`] = value;
+    } else {
+      attributes[`otlp.${key}.summary`] = summarizeAttributeValue(value);
+      warnings.push({
+        code: "otlp_unsupported_field_summarized",
+        message: `Unsupported OTLP span field "${key}" was summarized.`,
+        severity: "warning",
+        field: `${pathPrefix}.${key}`
+      });
+    }
+  }
+  for (const key of [
+    "droppedAttributesCount",
+    "droppedEventsCount",
+    "droppedLinksCount",
+    "links"
+  ]) {
+    if (span[key] !== void 0) {
+      unsupportedFields.push(`${pathPrefix}.${key}`);
+      warnings.push({
+        code: "otlp_span_field_not_mapped",
+        message: `OTLP span field "${key}" is not represented in AgentInspect events.`,
+        severity: "warning",
+        field: `${pathPrefix}.${key}`
+      });
+    }
+  }
+  const events = mapOtlpEvents(span.events, `${pathPrefix}.events`);
+  warnings.push(...events.warnings);
+  unsupportedFields.push(...events.unsupportedFields);
+  if (events.events !== void 0) {
+    attributes["otlp.events"] = events.events;
+  }
+  const traceId = readStringField(span, ["traceId"]) ?? "trace-unknown";
+  const spanId = readStringField(span, ["spanId"]) ?? "span-unknown";
+  const parentSpanId = readStringField(span, ["parentSpanId"]);
+  const startedAt = readOpenInferenceTimestamp(
+    span,
+    ["startTimeUnixNano"],
+    []
+  );
+  const endedAt = readOpenInferenceTimestamp(span, ["endTimeUnixNano"], []);
+  const timestamp = startedAt ?? "1970-01-01T00:00:00.000Z";
+  if (startedAt === void 0) {
+    unsupportedFields.push(`${pathPrefix}.startTimeUnixNano`);
+    warnings.push({
+      code: "otlp_missing_start_time",
+      message: "OTLP span is missing a valid startTimeUnixNano; using Unix epoch.",
+      severity: "warning",
+      field: `${pathPrefix}.startTimeUnixNano`
+    });
+  }
+  const { kind, warnings: kindWarnings } = readOtlpKind(
+    parsedSpanAttributes.attributes,
+    pathPrefix
+  );
+  warnings.push(...kindWarnings);
+  const status = mapOtlpStatus(span.status);
+  const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
+  const errorMessage = isRecord13(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,
+    runId: typeof parsedSpanAttributes.attributes["agent_inspect.run_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.run_id"] : traceId,
+    kind,
+    name: readStringField(span, ["name"]) ?? spanId,
+    timestamp,
+    confidence: readOtlpConfidence(parsedSpanAttributes.attributes),
+    source: {
+      type: "otel",
+      name: context.scopeName ?? (typeof context.resourceAttributes["service.name"] === "string" ? context.resourceAttributes["service.name"] : "otlp-json"),
+      ...context.scopeVersion !== void 0 ? { version: context.scopeVersion } : {}
+    },
+    attributes,
+    trace: {
+      traceId,
+      spanId,
+      ...parentSpanId !== void 0 ? { parentSpanId } : {}
+    }
+  };
+  if (status !== void 0) {
+    event.status = status;
+  }
+  if (startedAt !== void 0) {
+    event.startedAt = startedAt;
+  }
+  if (endedAt !== void 0) {
+    event.endedAt = endedAt;
+  }
+  const durationMs2 = durationBetweenIso(startedAt, endedAt);
+  if (durationMs2 !== void 0) {
+    event.durationMs = durationMs2;
+  }
+  if (tokenUsage !== void 0) {
+    event.tokenUsage = tokenUsage;
+  }
+  if (status === "error") {
+    event.error = {
+      message: errorMessage !== void 0 && errorMessage.trim() !== "" ? errorMessage : "OTLP span error"
+    };
+  }
+  return {
+    event,
+    warnings,
+    unsupportedFields,
+    spanId,
+    ...parentSpanId !== void 0 ? { parentSpanId } : {}
+  };
+}
+function mapOtlpEventsToPersisted(document) {
+  const mapped = document.spans.map((span) => mapOtlpSpan(span));
+  const spanIdToEventId = new Map(
+    mapped.map((span) => [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;
+  }
+  return {
+    events: mapped.map((span) => span.event),
+    warnings: mapped.flatMap((span) => span.warnings),
+    unsupportedFields: mapped.flatMap((span) => span.unsupportedFields)
+  };
+}
+var otlpJsonReader = {
+  format: OTLP_READER_FORMAT,
+  name: "OTLP JSON",
+  async detect(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) return void 0;
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      return void 0;
+    }
+    const document = extractOtlpDocument(parsed);
+    if (!document) return void 0;
+    return {
+      format: OTLP_READER_FORMAT,
+      confidence: document.confidence,
+      readerName: "OTLP JSON",
+      description: document.description,
+      warnings: attachSingleSourceFile(document.warnings, resolved)
+    };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "OTLP JSON reader requires file, string, or buffer input."
+      );
+    }
+    let parsed;
+    try {
+      parsed = parseJsonDocument(resolved.content);
+    } catch {
+      throw new TraceReadError("unsupported_format", "OTLP JSON input is not valid JSON.", [
+        {
+          code: "otlp_invalid_json",
+          message: "OTLP JSON reader could not parse the input as JSON.",
+          severity: "error"
+        }
+      ]);
+    }
+    const document = extractOtlpDocument(parsed);
+    if (!document || document.spans.length === 0) {
+      throw new TraceReadError(
+        "unsupported_format",
+        "No valid OTLP spans found.",
+        attachSingleSourceFile(
+          document?.warnings ?? [
+            {
+              code: "otlp_no_valid_spans",
+              message: "OTLP JSON input did not contain valid spans.",
+              severity: "error"
+            }
+          ],
+          resolved
+        )
+      );
+    }
+    const mapped = mapOtlpEventsToPersisted(document);
+    const warnings = attachSingleSourceFile(
+      [...document.warnings, ...mapped.warnings],
+      resolved
+    );
+    const unsupportedFields = [
+      ...document.unsupportedFields,
+      ...mapped.unsupportedFields
+    ].sort((a, b) => a.localeCompare(b));
+    return {
+      format: OTLP_READER_FORMAT,
+      events: mapped.events,
+      runs: persistedInspectEventsToRunTrees(mapped.events, { skipInvalid: true }),
+      warnings,
+      unsupportedFields,
+      sourceFiles: resolved.sourceFiles
+    };
+  }
+};
+var agentInspectJsonlReader = {
+  format: "agent-inspect-jsonl",
+  name: "AgentInspect JSONL",
+  async detect(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) return void 0;
+    const detected = detectJsonlFormat(resolved.content);
+    if (detected.validRows === 0 || detected.format === "empty") {
+      return void 0;
+    }
+    return {
+      format: "agent-inspect-jsonl",
+      confidence: 0.95,
+      readerName: "AgentInspect JSONL",
+      description: agentInspectFormatLabel(detected.format),
+      warnings: attachSingleSourceFile(detected.warnings, resolved)
+    };
+  },
+  async read(input) {
+    const resolved = await resolveInput(input);
+    if (!resolved) {
+      throw new Error("AgentInspect JSONL reader requires file, directory, string, or buffer input.");
+    }
+    const parsed = parseTraceJsonl(resolved.content, { warnings: false });
+    if (parsed.sourceEventCount === 0) {
+      throw new Error("No valid AgentInspect JSONL events found.");
+    }
+    const events = persistedEventsForParsedTrace(parsed);
+    return {
+      format: agentInspectFormatLabel(parsed.format),
+      events,
+      runs: persistedInspectEventsToRunTrees(events, { skipInvalid: true }),
+      warnings: parsed.format === "mixed" ? attachSingleSourceFile(
+        [
+          {
+            code: "mixed_agent_inspect_jsonl",
+            message: "Trace input mixes schemaVersion 0.1 and 0.2 rows; events were normalized for reading.",
+            severity: "warning"
+          }
+        ],
+        resolved
+      ) : [],
+      unsupportedFields: [],
+      sourceFiles: resolved.sourceFiles
+    };
+  }
+};
+var DEFAULT_TRACE_READERS = [
+  agentInspectJsonlReader,
+  openInferenceJsonReader,
+  otlpJsonReader
+];
+async function detectTraceFormat(input, options = {}) {
+  const readers = options.readers ?? DEFAULT_TRACE_READERS;
+  if (options.format !== void 0) {
+    const reader = findReaderByFormat(options.format, readers);
+    if (!reader) {
+      return {
+        status: "unsupported",
+        candidates: [],
+        warnings: [
+          {
+            code: "unsupported_format",
+            message: `No trace reader is registered for format "${options.format}".`,
+            severity: "error"
+          }
+        ]
+      };
+    }
+    return {
+      status: "detected",
+      format: reader.format,
+      candidates: [
+        {
+          format: reader.format,
+          confidence: 1,
+          readerName: reader.name,
+          description: "Explicit format override"
+        }
+      ],
+      warnings: []
+    };
+  }
+  const candidates = [];
+  const warnings = [];
+  for (const reader of readers) {
+    try {
+      const candidate = await reader.detect(input);
+      if (candidate !== void 0) {
+        candidates.push(normalizeCandidate(reader, candidate));
+      }
+    } catch (error) {
+      if (error instanceof TraceReadError) {
+        warnings.push(...error.warnings);
+        continue;
+      }
+      warnings.push({
+        code: "reader_detect_failed",
+        message: error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed during detection.`,
+        severity: "warning"
+      });
+    }
+  }
+  const sorted = sortCandidates(
+    candidates.filter((candidate) => candidate.confidence >= MIN_DETECTION_CONFIDENCE)
+  );
+  const candidateWarnings = collectWarnings(sorted);
+  const lowConfidenceWarnings = candidates.length > sorted.length ? [
+    {
+      code: "low_confidence_candidates",
+      message: `Ignored ${candidates.length - sorted.length} low-confidence format candidate(s).`,
+      severity: "info"
+    }
+  ] : [];
+  const allWarnings = dedupeWarnings([
+    ...warnings,
+    ...candidateWarnings,
+    ...lowConfidenceWarnings
+  ]);
+  if (sorted.length === 0) {
+    return {
+      status: "unsupported",
+      candidates: [],
+      warnings: allWarnings
+    };
+  }
+  const [best, second] = sorted;
+  if (second !== void 0 && best.confidence - second.confidence <= AMBIGUOUS_CONFIDENCE_DELTA) {
+    return {
+      status: "ambiguous",
+      candidates: sorted,
+      warnings: [
+        ...allWarnings,
+        {
+          code: "ambiguous_format_candidates",
+          message: `Top trace format candidates are within ${AMBIGUOUS_CONFIDENCE_DELTA} confidence.`,
+          severity: "warning"
+        }
+      ]
+    };
+  }
+  return {
+    status: "detected",
+    format: best.format,
+    candidates: sorted,
+    warnings: allWarnings
+  };
+}
+async function readTrace(input, options = {}) {
+  const readers = options.readers ?? DEFAULT_TRACE_READERS;
+  const detection = await detectTraceFormat(input, options);
+  if (detection.status === "unsupported" || detection.format === void 0) {
+    throw new TraceReadError(
+      "unsupported_format",
+      "No trace reader could detect the input format.",
+      detection.warnings
+    );
+  }
+  if (detection.status === "ambiguous") {
+    throw new TraceReadError(
+      "ambiguous_format",
+      "Multiple trace readers matched the input with equal confidence.",
+      detection.warnings
+    );
+  }
+  const reader = findReaderByFormat(detection.format, readers);
+  if (!reader) {
+    throw new TraceReadError(
+      "unsupported_format",
+      `No trace reader is registered for format "${detection.format}".`,
+      detection.warnings
+    );
+  }
+  try {
+    const result = await reader.read(input, { format: detection.format });
+    return {
+      ...result,
+      format: result.format || detection.format,
+      warnings: [...detection.warnings, ...result.warnings]
+    };
+  } catch (error) {
+    if (error instanceof TraceReadError) {
+      throw new TraceReadError(
+        error.code,
+        error.message,
+        dedupeWarnings([...detection.warnings, ...error.warnings])
+      );
+    }
+    throw new TraceReadError(
+      "reader_failed",
+      error instanceof Error && error.message.trim() !== "" ? error.message : `Trace reader "${reader.format}" failed.`,
+      detection.warnings
+    );
+  }
+}
+function openTrace(input, options = {}) {
+  return readTrace(input, options);
+}
+
+// packages/core/src/diff/comparable.ts
+function extractOutputPreview(meta) {
+  if (meta === void 0) return void 0;
+  if ("outputPreview" in meta) return meta.outputPreview;
+  if ("resultPreview" in meta) return meta.resultPreview;
+  return void 0;
+}
+function mapStepStatus2(s) {
+  if (s === void 0) return "running";
+  return s;
+}
+function manualTraceEventsToComparableRun(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
+  }
+  const rs = started;
+  const runId = rs.runId;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) runStatus = "running";
+  else runStatus = lastCompleted.status;
+  const durationMs2 = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  let order = 0;
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    const meta = s.metadata ? { ...s.metadata } : void 0;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      order: order++,
+      timestamp: s.timestamp,
+      metadata: meta
+    });
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) acc.errorMsg = e.error.message;
+    const extra = e;
+    if (extra.metadata !== void 0 && typeof extra.metadata === "object") {
+      acc.metadata = { ...acc.metadata ?? {}, ...extra.metadata };
+    }
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    let meta = acc.metadata ? { ...acc.metadata } : void 0;
+    if (acc.parentId !== void 0 && !steps.has(acc.parentId)) {
+      meta = { ...meta ?? {}, agent_inspect_diff_parent_missing: true };
     }
     const outputPreview = extractOutputPreview(meta);
     const sc = {
@@ -4762,7 +7495,7 @@ function manualTraceEventsToComparableRun(events) {
     runId,
     name: rs.name,
     status: runStatus,
-    durationMs,
+    durationMs: durationMs2,
     steps: roots
   };
 }
@@ -4807,13 +7540,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path5 = buildPath(segments);
+  const path7 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path5,
+      path: path7,
       left: L.name,
       right: R.name
     });
@@ -4823,7 +7556,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path5,
+      path: path7,
       left: L.type,
       right: R.type
     });
@@ -4833,7 +7566,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path5,
+      path: path7,
       left: L.status,
       right: R.status
     });
@@ -4845,7 +7578,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path5,
+      path: path7,
       left: le || void 0,
       right: re || void 0
     });
@@ -4863,7 +7596,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path5,
+        path: path7,
         left: ld,
         right: rd
       });
@@ -4876,7 +7609,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path5,
+      path: path7,
       left: L.metadata,
       right: R.metadata
     });
@@ -4888,7 +7621,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path5,
+      path: path7,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -5538,11 +8271,11 @@ createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // packages/core/src/diff/renderer.ts
-function formatPath(path5) {
-  if (path5 === void 0 || path5.path.length === 0) {
+function formatPath(path7) {
+  if (path7 === void 0 || path7.path.length === 0) {
     return "(run)";
   }
-  return path5.path.map((s) => s.name).join(" > ");
+  return path7.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -5657,15 +8390,15 @@ function getStatusIcon(status) {
   if (status === "error") return source_default.red("\u2716");
   return source_default.yellow("\u23F3");
 }
-function renderStepLine(name, durationMs, status, depth) {
+function renderStepLine(name, durationMs2, status, depth) {
   try {
     const nm = formatTerminalName(name);
     const ind = getIndent(depth ?? 0);
-    if (status === "running" && durationMs === void 0) {
+    if (status === "running" && durationMs2 === void 0) {
       return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
-    const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
-    const dur = hasDur ? formatDuration2(durationMs) : void 0;
+    const hasDur = durationMs2 !== void 0 && Number.isFinite(durationMs2);
+    const dur = hasDur ? formatDuration2(durationMs2) : void 0;
     if (status === "running") {
       return dur !== void 0 ? `${ind}${source_default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${source_default.yellow("\u23F3")} ${nm}`;
     }
@@ -5689,9 +8422,9 @@ function renderErrorLine(error, depth) {
     return "";
   }
 }
-function renderRunSummary(durationMs, status, traceFilePath) {
+function renderRunSummary(durationMs2, status, traceFilePath) {
   try {
-    const dur = Number.isFinite(durationMs) ? formatDuration2(durationMs) : formatDuration2(0);
+    const dur = Number.isFinite(durationMs2) ? formatDuration2(durationMs2) : formatDuration2(0);
     const head = status === "error" ? `Failed in ${dur}` : `Completed in ${dur}`;
     const lines = [head];
     if (traceFilePath !== void 0 && traceFilePath.trim() !== "") {
@@ -5718,10 +8451,10 @@ function printStepStart(name, depth = 0) {
   } catch {
   }
 }
-function printStepComplete(name, durationMs, status, depth = 0) {
+function printStepComplete(name, durationMs2, status, depth = 0) {
   if (isSilentContext()) return;
   try {
-    safePrint(renderStepLine(name, durationMs, status, depth));
+    safePrint(renderStepLine(name, durationMs2, status, depth));
   } catch {
   }
 }
@@ -5732,10 +8465,10 @@ function printError(error, depth = 0) {
   } catch {
   }
 }
-function printRunComplete(_name, _runId, durationMs, status, traceFilePath) {
+function printRunComplete(_name, _runId, durationMs2, status, traceFilePath) {
   if (isSilentContext()) return;
   try {
-    const lines = renderRunSummary(durationMs, status, traceFilePath);
+    const lines = renderRunSummary(durationMs2, status, traceFilePath);
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (i === 0) {
@@ -5818,7 +8551,7 @@ async function inspectRun(name, fn, options) {
       result = await Promise.resolve(fn());
     } catch (userError) {
       const endTime2 = Date.now();
-      const durationMs2 = endTime2 - startTime;
+      const durationMs3 = endTime2 - startTime;
       const formatted = formatError(userError);
       const printPath2 = traceFilePath ?? getTraceFilePath(runId, traceDir);
       await safeInstrumentation("writeTraceEvent(run_completed error)", async () => {
@@ -5829,7 +8562,7 @@ async function inspectRun(name, fn, options) {
           runId,
           status: "error",
           endTime: endTime2,
-          durationMs: durationMs2,
+          durationMs: durationMs3,
           error: formatted
         };
         await writeTraceEvent(
@@ -5838,12 +8571,12 @@ async function inspectRun(name, fn, options) {
         );
       });
       await safeInstrumentation("printRunComplete(error)", () => {
-        printRunComplete(runName, runId, durationMs2, "error", printPath2);
+        printRunComplete(runName, runId, durationMs3, "error", printPath2);
       });
       throw userError;
     }
     const endTime = Date.now();
-    const durationMs = endTime - startTime;
+    const durationMs2 = endTime - startTime;
     const printPath = traceFilePath ?? getTraceFilePath(runId, traceDir);
     await safeInstrumentation("writeTraceEvent(run_completed success)", async () => {
       const completed = {
@@ -5853,7 +8586,7 @@ async function inspectRun(name, fn, options) {
         runId,
         status: "success",
         endTime,
-        durationMs
+        durationMs: durationMs2
       };
       await writeTraceEvent(
         prepareTraceEventForDisk(completed, traceSafety),
@@ -5861,7 +8594,7 @@ async function inspectRun(name, fn, options) {
       );
     });
     await safeInstrumentation("printRunComplete(success)", () => {
-      printRunComplete(runName, runId, durationMs, "success", printPath);
+      printRunComplete(runName, runId, durationMs2, "success", printPath);
     });
     return result;
   }, traceSafety);
@@ -5943,7 +8676,7 @@ async function stepImpl(name, fn, options) {
     });
   } catch (userError) {
     const endTime2 = Date.now();
-    const durationMs2 = endTime2 - startTime;
+    const durationMs3 = endTime2 - startTime;
     const formatted = formatError(userError);
     await safeInstrumentation2("writeTraceEvent(step_completed error)", async () => {
       const completed = {
@@ -5954,14 +8687,14 @@ async function stepImpl(name, fn, options) {
         stepId,
         status: "error",
         endTime: endTime2,
-        durationMs: durationMs2,
+        durationMs: durationMs3,
         error: formatted
       };
       const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
       await writeTraceEvent(safe, context.traceDir);
     });
     await safeInstrumentation2("printStepComplete(error)", () => {
-      printStepComplete(stepName, durationMs2, "error", renderDepth);
+      printStepComplete(stepName, durationMs3, "error", renderDepth);
     });
     await safeInstrumentation2("printError", () => {
       printError(formatted, renderDepth);
@@ -5972,7 +8705,7 @@ async function stepImpl(name, fn, options) {
     throw userError;
   }
   const endTime = Date.now();
-  const durationMs = endTime - startTime;
+  const durationMs2 = endTime - startTime;
   await safeInstrumentation2("writeTraceEvent(step_completed success)", async () => {
     const completed = {
       schemaVersion: "0.1",
@@ -5982,13 +8715,13 @@ async function stepImpl(name, fn, options) {
       stepId,
       status: "success",
       endTime,
-      durationMs
+      durationMs: durationMs2
     };
     const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
     await writeTraceEvent(safe, context.traceDir);
   });
   await safeInstrumentation2("printStepComplete(success)", () => {
-    printStepComplete(stepName, durationMs, "success", renderDepth);
+    printStepComplete(stepName, durationMs2, "success", renderDepth);
   });
   return result;
 }
@@ -6463,6 +9196,7 @@ exports.DEFAULT_MAX_METADATA_VALUE_LENGTH = DEFAULT_MAX_METADATA_VALUE_LENGTH;
 exports.DEFAULT_MAX_PREVIEW_LENGTH = DEFAULT_MAX_PREVIEW_LENGTH;
 exports.DEFAULT_REDACT_KEYS = DEFAULT_REDACT_KEYS;
 exports.DEFAULT_TRACE_DIR_NAME = DEFAULT_TRACE_DIR_NAME;
+exports.DEFAULT_TRACE_READERS = DEFAULT_TRACE_READERS;
 exports.EXPORT_PAYLOAD_VERSION = EXPORT_PAYLOAD_VERSION;
 exports.EventNormalizer = EventNormalizer;
 exports.FALLBACK_TRACE_DIR = FALLBACK_TRACE_DIR;
@@ -6476,15 +9210,22 @@ exports.RUNS_DIR_NAME = RUNS_DIR_NAME;
 exports.Redactor = Redactor;
 exports.TERMINAL_INDENT = TERMINAL_INDENT;
 exports.TraceDirectory = TraceDirectory;
+exports.TraceReadError = TraceReadError;
 exports.TreeBuilder = TreeBuilder;
+exports.agentInspectJsonlReader = agentInspectJsonlReader;
+exports.bufferedFileWriter = bufferedFileWriter;
 exports.buildRunReport = buildRunReport;
 exports.buildRunSummary = buildRunSummary;
 exports.buildRunTimeline = buildRunTimeline;
 exports.buildRunWhatSummary = buildRunWhatSummary;
 exports.buildTraceStats = buildTraceStats;
 exports.compactAttributes = compactAttributes4;
+exports.compositeWriter = compositeWriter;
+exports.createInspector = createInspector;
+exports.createInspectorRuntime = createInspectorRuntime;
 exports.createRunId = createRunId;
 exports.createStepId = createStepId;
+exports.detectTraceFormat = detectTraceFormat;
 exports.diffRuns = diffRuns;
 exports.diffTraceEvents = diffTraceEvents;
 exports.ensureTraceDir = ensureTraceDir;
@@ -6496,6 +9237,7 @@ exports.exportOpenInference = exportOpenInference;
 exports.exportOtlpJson = exportOtlpJson;
 exports.exportRunTree = exportRunTree;
 exports.extractMetadata = extractMetadata;
+exports.fileWriter = fileWriter;
 exports.filterTraces = filterTraces;
 exports.flattenTree = flattenTree;
 exports.formatDuration = formatDuration2;
@@ -6534,9 +9276,12 @@ exports.manualTraceEventsToComparableRun = manualTraceEventsToComparableRun;
 exports.manualTraceEventsToRunTree = manualTraceEventsToRunTree;
 exports.matchMapping = matchMapping;
 exports.maybeInspectRun = maybeInspectRun;
+exports.memoryWriter = memoryWriter;
 exports.mergeExportDefaults = mergeExportDefaults;
 exports.mergeLogIngestConfig = mergeLogIngestConfig;
+exports.nullWriter = nullWriter;
 exports.observe = observe;
+exports.openTrace = openTrace;
 exports.parseDuration = parseDuration;
 exports.parseDurationFilter = parseDurationFilter;
 exports.parseLogLine = parseLogLine;
@@ -6555,6 +9300,7 @@ exports.printRunComplete = printRunComplete;
 exports.printRunStart = printRunStart;
 exports.printStepComplete = printStepComplete;
 exports.printStepStart = printStepStart;
+exports.readTrace = readTrace;
 exports.readTraceEvents = readTraceEvents;
 exports.readTraceFile = readTraceFile;
 exports.redactRunTreeForExport = redactRunTreeForExport;