agent-inspect 1.5.0 → 1.7.0

package/packages/cli/dist/index.mjs

@@ -3,7 +3,7 @@ import { realpathSync, createReadStream } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { Command, Option } from 'commander';
-import { unlink, stat, mkdir, writeFile, appendFile, readdir, readFile, open } from 'fs/promises';
+import { unlink, stat, mkdir, writeFile, appendFile, readdir, readFile, access, open } from 'fs/promises';
 import crypto, { webcrypto } from 'crypto';
 import os from 'os';
 import { AsyncLocalStorage } from 'async_hooks';
@@ -11,6 +11,9 @@ import { createInterface } from 'readline';
 import process2, { stdin, stdout } from 'process';
 import tty from 'tty';
 
+// package.json
+var version = "1.7.0";
+
 // packages/core/src/types.ts
 var STEP_TYPES = [
   "run",
@@ -133,6 +136,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) {
@@ -178,8 +182,405 @@ function isPersistedInspectEvent(value) {
   return true;
 }
 
-// packages/core/src/persisted/to-trace-event.ts
+// packages/core/src/correlation-metadata.ts
+var TRACE_CORRELATION_KEYS = [
+  "correlationId",
+  "requestId",
+  "decisionId",
+  "groupId"
+];
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function extractCorrelationMetadata(record) {
+  if (!record) {
+    return void 0;
+  }
+  const out = {};
+  let found = false;
+  for (const key of TRACE_CORRELATION_KEYS) {
+    const value = record[key];
+    if (isNonEmptyString2(value)) {
+      out[key] = value;
+      found = true;
+    }
+  }
+  return found ? out : 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 input3 = nonNegativeFinite(value.input);
+  const output2 = nonNegativeFinite(value.output);
+  const suppliedTotal = nonNegativeFinite(value.total);
+  const cached = nonNegativeFinite(value.cached);
+  const derivedTotal = input3 !== void 0 && output2 !== void 0 && Number.isFinite(input3 + output2) ? input3 + output2 : void 0;
+  const total = suppliedTotal ?? derivedTotal;
+  if (input3 === void 0 && output2 === void 0 && total === void 0 && cached === void 0) {
+    return void 0;
+  }
+  return {
+    ...input3 !== void 0 ? { input: input3 } : {},
+    ...output2 !== void 0 ? { output: output2 } : {},
+    ...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, "_");
+}
+function nodeIdForEvent(event) {
+  switch (event.event) {
+    case "run_started":
+    case "run_completed":
+      return event.runId;
+    case "step_started":
+    case "step_completed":
+      return event.stepId;
+    default:
+      return "unknown";
+  }
+}
+function createPersistedEventId(event, eventIndex) {
+  const runId = sanitizeIdPart(event.runId);
+  const ev = sanitizeIdPart(event.event);
+  const node = sanitizeIdPart(nodeIdForEvent(event));
+  return `manual:${runId}:${ev}:${node}:${eventIndex}`;
+}
+function toIsoTimestamp(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) {
+    return { iso: (/* @__PURE__ */ new Date(0)).toISOString(), invalidTimestamp: true };
+  }
+  return { iso: new Date(ms).toISOString(), invalidTimestamp: false };
+}
+function buildSource(options) {
+  return {
+    type: "manual",
+    name: options?.sourceName ?? "trace-event",
+    version: options?.sourceVersion ?? "0.1"
+  };
+}
+function mapStepTypeToInspectKind(type) {
+  switch (type) {
+    case "run":
+      return "RUN";
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "logic":
+    case "state":
+    case "custom":
+      return "LOGIC";
+    default:
+      return "LOGIC";
+  }
+}
+function mapRunOrStepStatus(status) {
+  return status === "success" ? "ok" : "error";
+}
+function mapErrorInfo(error) {
+  if (!error?.message) {
+    return {};
+  }
+  const out = {
+    persisted: {
+      message: error.message,
+      name: "Error"
+    }
+  };
+  if (typeof error.stack === "string" && error.stack.length > 0) {
+    out.errorStack = error.stack;
+  }
+  return out;
+}
+function mapTokenUsageFromMetadata(metadata) {
+  return normalizeTokenUsage(metadata?.tokens);
+}
+function compactAttributes(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function traceEventToPersistedInspectEvent(event, options) {
+  const eventIndex = options?.eventIndex ?? 0;
+  const eventId = createPersistedEventId(event, eventIndex);
+  const source = buildSource(options);
+  const tsMain = toIsoTimestamp(event.timestamp);
+  switch (event.event) {
+    case "run_started": {
+      const tsStart = toIsoTimestamp(event.startTime);
+      const correlation = extractCorrelationMetadata(event.metadata);
+      const attributes = compactAttributes({
+        legacyEvent: "run_started",
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        correlationId: correlation?.correlationId,
+        requestId: correlation?.requestId,
+        decisionId: correlation?.decisionId,
+        groupId: correlation?.groupId,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+    }
+    case "run_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "run_completed",
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "RUN",
+        name: "run",
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
+    }
+    case "step_started": {
+      const tsStart = toIsoTimestamp(event.startTime);
+      const tokenUsage = mapTokenUsageFromMetadata(event.metadata);
+      const attributes = compactAttributes({
+        legacyEvent: "step_started",
+        stepId: event.stepId,
+        stepType: event.type,
+        metadata: event.metadata !== void 0 ? { ...event.metadata } : void 0,
+        invalidTimestamp: tsMain.invalidTimestamp || tsStart.invalidTimestamp ? true : void 0
+      });
+      const out = {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: mapStepTypeToInspectKind(event.type),
+        name: event.name,
+        status: "running",
+        timestamp: tsMain.iso,
+        startedAt: tsStart.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+      if (event.parentId !== void 0) {
+        out.parentId = event.parentId;
+      }
+      if (tokenUsage !== void 0) {
+        out.tokenUsage = tokenUsage;
+      }
+      return out;
+    }
+    case "step_completed": {
+      const tsEnd = toIsoTimestamp(event.endTime);
+      const { persisted: error, errorStack } = mapErrorInfo(event.error);
+      const attributes = compactAttributes({
+        legacyEvent: "step_completed",
+        stepId: event.stepId,
+        errorStack,
+        invalidTimestamp: tsMain.invalidTimestamp || tsEnd.invalidTimestamp ? true : void 0
+      });
+      return {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "LOGIC",
+        name: event.stepId,
+        status: mapRunOrStepStatus(event.status),
+        timestamp: tsMain.iso,
+        endedAt: tsEnd.iso,
+        durationMs: event.durationMs,
+        confidence: "explicit",
+        source,
+        attributes,
+        error
+      };
+    }
+    default: {
+      const _exhaustive = event;
+      throw new Error(`Unsupported trace event: ${_exhaustive.event}`);
+    }
+  }
+}
+function traceEventsToPersistedInspectEvents(events, options) {
+  return events.map(
+    (event, index) => traceEventToPersistedInspectEvent(event, { ...options, eventIndex: index })
+  );
+}
+
+// packages/core/src/persisted/to-inspect-event.ts
+function compactAttributes2(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function parseIsoToMs(iso) {
+  const parsed = Date.parse(iso);
+  if (!Number.isFinite(parsed)) {
+    return { ms: 0, invalidTimestamp: true };
+  }
+  return { ms: parsed, invalidTimestamp: false };
+}
+function mapPersistedSourceToInspect(event) {
+  const attrs = event.attributes ?? {};
+  const sourceName = event.source.name;
+  if (sourceName === "pino") {
+    return {
+      type: "pino",
+      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+    };
+  }
+  if (sourceName === "winston") {
+    return {
+      type: "winston",
+      file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+      line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+    };
+  }
+  const mapType = (t) => {
+    switch (t) {
+      case "manual":
+        return "manual";
+      case "json-log":
+        return "json-log";
+      case "log4js":
+        return "log4js";
+      case "adapter":
+      case "ai-sdk":
+      case "otel":
+        return "adapter";
+      default:
+        return "json-log";
+    }
+  };
+  return {
+    type: mapType(event.source.type),
+    file: typeof attrs.sourceFile === "string" ? attrs.sourceFile : void 0,
+    line: typeof attrs.sourceLine === "number" ? attrs.sourceLine : void 0
+  };
+}
+function buildInspectAttributes(event) {
+  const attrs = event.attributes !== void 0 ? { ...event.attributes } : {};
+  if (event.inputSummary !== void 0) {
+    attrs.inputSummary = event.inputSummary;
+  }
+  if (event.outputSummary !== void 0) {
+    attrs.outputSummary = event.outputSummary;
+  }
+  if (event.error) {
+    if (event.error.name !== void 0) {
+      attrs.errorName = event.error.name;
+    }
+    attrs.errorMessage = event.error.message;
+    if (event.error.code !== void 0) {
+      attrs.errorCode = event.error.code;
+    }
+  }
+  if (event.tokenUsage) {
+    attrs.tokens = { ...event.tokenUsage };
+  }
+  if (event.source.type === "ai-sdk" || event.source.type === "otel") {
+    attrs.originalSourceType = event.source.type;
+  }
+  if (event.source.name !== void 0) {
+    attrs.sourceName = event.source.name;
+  }
+  if (event.source.version !== void 0) {
+    attrs.sourceVersion = event.source.version;
+  }
+  return attrs;
+}
+function persistedInspectEventToInspectEvent(event) {
+  if (!isPersistedInspectEvent(event)) {
+    throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
+  }
+  const ts = parseIsoToMs(event.timestamp);
+  const attrs = buildInspectAttributes(event);
+  if (ts.invalidTimestamp) {
+    attrs.invalidTimestamp = true;
+  }
+  let status;
+  if (event.status === "running" || event.status === "ok" || event.status === "error") {
+    status = event.status;
+  } else if (event.status === "unknown") {
+    attrs.persistedStatus = "unknown";
+  }
+  const out = {
+    eventId: event.eventId,
+    runId: event.runId,
+    name: event.name,
+    kind: event.kind,
+    timestamp: ts.ms,
+    confidence: event.confidence,
+    source: mapPersistedSourceToInspect(event),
+    attributes: compactAttributes2(attrs)
+  };
+  if (event.parentId !== void 0) {
+    out.parentId = event.parentId;
+  }
+  if (status !== void 0) {
+    out.status = status;
+  }
+  if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0) {
+    out.durationMs = event.durationMs;
+  }
+  return out;
+}
+function persistedInspectEventsToInspectEvents(events, options) {
+  const skipInvalid = options?.skipInvalid === true;
+  const out = [];
+  for (const event of events) {
+    if (!isPersistedInspectEvent(event)) {
+      if (skipInvalid) {
+        continue;
+      }
+      throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
+    }
+    out.push(persistedInspectEventToInspectEvent(event));
+  }
+  return out;
+}
+
+// packages/core/src/persisted/to-trace-event.ts
+function parseIsoToMs2(iso) {
   const parsed = Date.parse(iso);
   return Number.isFinite(parsed) ? parsed : 0;
 }
@@ -221,10 +622,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;
   }
@@ -238,7 +639,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;
@@ -277,9 +680,9 @@ function resolveStepType(event) {
   return mapInspectKindToStepType(event.kind);
 }
 function resolveTimes(event) {
-  const timestamp = parseIsoToMs(event.timestamp);
-  const startTime = event.startedAt !== void 0 ? parseIsoToMs(event.startedAt) : timestamp;
-  let endTime = event.endedAt !== void 0 ? parseIsoToMs(event.endedAt) : timestamp;
+  const timestamp = parseIsoToMs2(event.timestamp);
+  const startTime = event.startedAt !== void 0 ? parseIsoToMs2(event.startedAt) : timestamp;
+  let endTime = event.endedAt !== void 0 ? parseIsoToMs2(event.endedAt) : timestamp;
   if (event.durationMs !== void 0 && Number.isFinite(event.durationMs) && event.durationMs >= 0 && event.endedAt === void 0) {
     endTime = startTime + event.durationMs;
   }
@@ -311,7 +714,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;
 }
@@ -345,7 +748,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;
 }
@@ -376,7 +779,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);
   }
@@ -418,7 +821,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);
   }
@@ -530,7 +933,15 @@ var TreeBuilder = class {
     return out;
   }
 };
-function isRecord3(v) {
+
+// packages/core/src/persisted/tree-bridge.ts
+function persistedInspectEventsToRunTrees(events, options) {
+  const inspectEvents = persistedInspectEventsToInspectEvents(events, {
+    skipInvalid: options?.skipInvalid
+  });
+  return new TreeBuilder().build(inspectEvents);
+}
+function isRecord4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isNonEmptyStringArray(v) {
@@ -542,7 +953,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() === "") {
@@ -561,7 +972,7 @@ function validateRedact(redact) {
   }
 }
 function validateMappings(mappings) {
-  if (!isRecord3(mappings)) {
+  if (!isRecord4(mappings)) {
     throw new Error("Invalid config: mappings must be an object");
   }
 }
@@ -611,7 +1022,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;
@@ -648,7 +1059,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 {
@@ -673,7 +1084,7 @@ var JsonLogParser = class {
         });
         continue;
       }
-      if (!isRecord4(parsed)) {
+      if (!isRecord5(parsed)) {
         warnings.push({
           code: "MALFORMED_JSON",
           message: "JSON log line must be an object",
@@ -704,7 +1115,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) {
@@ -780,7 +1191,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",
@@ -858,7 +1269,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) {
@@ -931,7 +1342,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);
@@ -1688,66 +2099,78 @@ 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 };
 }
 
 // packages/core/src/storage.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -1758,7 +2181,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;
@@ -1766,7 +2189,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;
@@ -1775,7 +2198,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;
@@ -1790,7 +2213,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;
@@ -1848,27 +2271,15 @@ async function writeTraceEvent(event, traceDir) {
   }
   warn("Failed to append trace event to fallback directory");
 }
-async function readTraceFile(runId, traceDir) {
+async function readTraceEventsFromFile(filePath) {
   try {
-    const filePath = getTraceFilePath(runId, traceDir);
-    return await readFile(filePath, "utf-8");
+    const raw = await readFile(filePath, "utf-8");
+    return parseTraceJsonl(raw, { validate: validateEvent }).events;
   } catch (e) {
     if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
-      return void 0;
-    }
-    warn("Unexpected error reading trace file", e);
-    return void 0;
-  }
-}
-async function readTraceEvents(runId, traceDir) {
-  try {
-    const raw = await readTraceFile(runId, traceDir);
-    if (raw === void 0) {
       return [];
     }
-    return parseTraceJsonl(raw, { validate: validateEvent }).events;
-  } catch (e) {
-    warn("Failed to read trace events", e);
+    warn("Failed to read trace events from file", e);
     return [];
   }
 }
@@ -1877,7 +2288,7 @@ async function readTraceEvents(runId, traceDir) {
 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) {
@@ -1897,21 +2308,10 @@ function resolveTraceSafetyOptions(options) {
   {
     redactEnabled = true;
   }
-  const profile = options?.redactionProfile ?? "local";
+  const profile = "local";
   const resolvedProfile = resolveRedactionProfile(profile);
-  const userMaxMetadata = "undefined" === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : void 0;
-  const userMaxPreview = "undefined" === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : void 0;
-  let maxMetadataValueLength = userMaxMetadata ?? DEFAULT_MAX_METADATA_VALUE_LENGTH;
-  let maxPreviewLength = userMaxPreview ?? DEFAULT_MAX_PREVIEW_LENGTH;
-  if (redactEnabled && profile !== "local") {
-    const capped = applyProfileMetadataCaps(
-      maxMetadataValueLength,
-      maxPreviewLength,
-      resolvedProfile
-    );
-    maxMetadataValueLength = capped.maxMetadataValueLength;
-    maxPreviewLength = capped.maxPreviewLength;
-  }
+  let maxMetadataValueLength = DEFAULT_MAX_METADATA_VALUE_LENGTH;
+  let maxPreviewLength = DEFAULT_MAX_PREVIEW_LENGTH;
   return {
     redactEnabled,
     redactionRules,
@@ -1919,11 +2319,26 @@ function resolveTraceSafetyOptions(options) {
     profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
     maxMetadataValueLength,
     maxPreviewLength,
-    maxEventBytes: "undefined" === "number" && Number.isFinite(options.maxEventBytes) && options.maxEventBytes > 0 ? Math.floor(options.maxEventBytes) : DEFAULT_MAX_EVENT_BYTES
+    maxEventBytes: DEFAULT_MAX_EVENT_BYTES
   };
 }
 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;
@@ -1945,8 +2360,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;
 }
@@ -1960,16 +2379,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" };
   }
@@ -2219,12 +2647,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 stat(filePath);
@@ -2233,8 +2659,7 @@ async function extractMetadata(filePath, _quickScan) {
     runIdFromFile = runIdFromFile.slice(0, -".jsonl".length);
   }
   const raw = await 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;
@@ -2244,16 +2669,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;
     }
@@ -2290,6 +2731,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) {
@@ -2305,12 +2748,15 @@ async function extractMetadata(filePath, _quickScan) {
     startedAt,
     endedAt,
     durationMs,
-    eventCount,
+    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"
@@ -2333,8 +2779,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
       });
     }
   }
@@ -2356,7 +2804,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);
@@ -2385,10 +2837,21 @@ 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 = {
@@ -2403,7 +2866,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;
 }
@@ -2708,9 +3178,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 = [];
@@ -2790,7 +3268,7 @@ function stableJson(value, pretty) {
   const sorted = sortKeysDeep(value);
   return pretty === true ? JSON.stringify(sorted, null, 2) : JSON.stringify(sorted);
 }
-function compactAttributes(attrs, options) {
+function compactAttributes3(attrs, options) {
   if (attrs === void 0) return {};
   const maxLen = options?.maxLength ?? 500;
   const redacted = options?.redacted ?? true;
@@ -2935,7 +3413,7 @@ function exportHtml(tree, options) {
     attrsHtml += "<h2>Attributes (bounded)</h2>";
     for (const n of flat) {
       if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
-      const compact = compactAttributes(n.event.attributes, {
+      const compact = compactAttributes3(n.event.attributes, {
         maxLength: maxLen,
         redacted
       });
@@ -3086,7 +3564,7 @@ function exportMarkdown(tree, options) {
     lines.push("");
     for (const n of flat) {
       if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
-      const compact = compactAttributes(n.event.attributes, {
+      const compact = compactAttributes3(n.event.attributes, {
         maxLength: maxLen,
         redacted
       });
@@ -3249,7 +3727,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) {
@@ -3323,7 +3801,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(
@@ -3344,6 +3822,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") {
@@ -3407,12 +3968,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,
@@ -3493,6 +4057,8 @@ ${attrsSection}
     fileExtension: ".html"
   };
 }
+
+// packages/core/src/stats.ts
 function percentile(sorted, p) {
   if (sorted.length === 0) return void 0;
   const idx = Math.min(
@@ -3503,19 +4069,10 @@ function percentile(sorted, p) {
 }
 async function readRunStartedMetadata(filePath) {
   try {
-    const raw = await 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;
       }
@@ -3574,7 +4131,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;
@@ -3762,7 +4319,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;
     }
@@ -3898,7 +4455,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) {
@@ -3920,7 +4477,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;
@@ -3935,9 +4492,1572 @@ async function isAgentInspectTrace(filePath) {
     return false;
   }
 }
-
-// packages/core/src/diff/comparable.ts
-function extractOutputPreview(meta) {
+resolveTraceSafetyOptions();
+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 readdir(dirPath, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => path.join(dirPath, entry.name)).sort((a, b) => a.localeCompare(b));
+}
+async function resolveInput(input3) {
+  const cached = resolvedInputCache.get(input3);
+  if (cached) return cached;
+  const promise = resolveInputUncached(input3);
+  resolvedInputCache.set(input3, 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(input3) {
+  if (input3.type === "string") {
+    assertInputWithinBounds(input3.content);
+    return { content: input3.content, sourceFiles: [] };
+  }
+  if (input3.type === "buffer") {
+    const content = input3.content.toString("utf-8");
+    assertInputWithinBounds(content);
+    return { content, sourceFiles: [] };
+  }
+  if (input3.type === "file") {
+    const content = await readFile(input3.path, "utf-8");
+    assertInputWithinBounds(content, input3.path);
+    return { content, sourceFiles: [input3.path] };
+  }
+  if (input3.type === "directory") {
+    const files = await jsonlFilesInDirectory(input3.path);
+    const parts = await Promise.all(
+      files.map(async (file) => (await readFile(file, "utf-8")).trimEnd())
+    );
+    const content = parts.filter((part) => part.trim() !== "").join("\n");
+    assertInputWithinBounds(content, input3.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 version2 = parsed.schemaVersion;
+      if (version2 === "0.1") {
+        saw01 = true;
+        validRows += 1;
+        continue;
+      }
+      if (version2 === "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 version2 = 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: version2,
+        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: version2,
+      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: version2,
+      warnings,
+      unsupportedFields
+    };
+  }
+  if (looksLikeOpenInferenceSpan(root)) {
+    return {
+      spans: [root],
+      confidence: 0.76,
+      description: "OpenInference single span",
+      version: version2,
+      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: version2,
+      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, version2) {
+  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",
+      ...version2 !== void 0 ? { version: version2 } : {}
+    },
+    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 durationMs = durationBetweenIso(startedAt, endedAt);
+  if (durationMs !== void 0) {
+    event.durationMs = durationMs;
+  }
+  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(input3) {
+    const resolved = await resolveInput(input3);
+    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(input3) {
+    const resolved = await resolveInput(input3);
+    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 input3 = attributes["gen_ai.usage.input_tokens"];
+  const output2 = attributes["gen_ai.usage.output_tokens"];
+  const usage = {};
+  if (typeof input3 === "number" && Number.isFinite(input3) && input3 >= 0) {
+    usage.input = input3;
+  }
+  if (typeof output2 === "number" && Number.isFinite(output2) && output2 >= 0) {
+    usage.output = output2;
+  }
+  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 durationMs = durationBetweenIso(startedAt, endedAt);
+  if (durationMs !== void 0) {
+    event.durationMs = durationMs;
+  }
+  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(input3) {
+    const resolved = await resolveInput(input3);
+    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(input3) {
+    const resolved = await resolveInput(input3);
+    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(input3) {
+    const resolved = await resolveInput(input3);
+    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(input3) {
+    const resolved = await resolveInput(input3);
+    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(input3, 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(input3);
+      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(input3, options = {}) {
+  const readers = options.readers ?? DEFAULT_TRACE_READERS;
+  const detection = await detectTraceFormat(input3, 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(input3, { 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(input3, options = {}) {
+  return readTrace(input3, 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;
@@ -4075,13 +6195,13 @@ function pairSteps(left, right) {
   return pairs;
 }
 function compareLeafSteps(L, R, segments, opts, out) {
-  const path8 = buildPath(segments);
+  const path10 = buildPath(segments);
   if (L.name !== R.name) {
     out.push({
       kind: "structure",
       severity: "warning",
       message: "Step name differs",
-      path: path8,
+      path: path10,
       left: L.name,
       right: R.name
     });
@@ -4091,7 +6211,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-type",
       severity: "warning",
       message: "Step type differs",
-      path: path8,
+      path: path10,
       left: L.type,
       right: R.type
     });
@@ -4101,7 +6221,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "step-status",
       severity: "warning",
       message: "Step status differs",
-      path: path8,
+      path: path10,
       left: L.status,
       right: R.status
     });
@@ -4113,7 +6233,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "error",
       severity: "error",
       message: "Step error message differs",
-      path: path8,
+      path: path10,
       left: le || void 0,
       right: re || void 0
     });
@@ -4131,7 +6251,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
         kind: "duration",
         severity: "info",
         message: "Step duration differs",
-        path: path8,
+        path: path10,
         left: ld,
         right: rd
       });
@@ -4144,7 +6264,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "metadata",
       severity: "info",
       message: "Step metadata differs",
-      path: path8,
+      path: path10,
       left: L.metadata,
       right: R.metadata
     });
@@ -4156,7 +6276,7 @@ function compareLeafSteps(L, R, segments, opts, out) {
       kind: "output",
       severity: "info",
       message: "Output preview differs",
-      path: path8,
+      path: path10,
       left: L.outputPreview,
       right: R.outputPreview
     });
@@ -4594,10 +6714,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+        return version2 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -4806,11 +6926,11 @@ createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // packages/core/src/diff/renderer.ts
-function formatPath(path8) {
-  if (path8 === void 0 || path8.path.length === 0) {
+function formatPath(path10) {
+  if (path10 === void 0 || path10.path.length === 0) {
     return "(run)";
   }
-  return path8.path.map((s) => s.name).join(" > ");
+  return path10.path.map((s) => s.name).join(" > ");
 }
 function formatValue(v, verbose) {
   if (v === void 0) return "(undefined)";
@@ -5717,18 +7837,38 @@ async function clean(options = {}) {
     process.exitCode = 1;
   }
 }
-
-// packages/cli/src/read-run.ts
-async function readRunTraceEvents(runId, traceDir) {
-  const raw = await readTraceFile(runId, traceDir);
-  if (raw === void 0) {
-    return void 0;
+function mapReaderFormat(format) {
+  switch (format) {
+    case "agent-inspect-v0.1-jsonl":
+      return "0.1";
+    case "agent-inspect-v0.2-jsonl":
+      return "0.2";
+    case "agent-inspect-mixed-jsonl":
+      return "mixed";
+    default:
+      return "empty";
   }
-  const parsed = parseTraceJsonl(raw);
-  if (parsed.format === "empty") {
-    return { events: [], format: "empty" };
+}
+function isMissingFileError(error) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+async function readRunTraceEvents(runId, traceDir) {
+  const filePath = getTraceFilePath(runId, traceDir);
+  try {
+    await access(filePath);
+    const result = await openTrace(
+      { type: "file", path: filePath },
+      { format: "agent-inspect-jsonl" }
+    );
+    const events = persistedInspectEventsToTraceEvents(result.events);
+    return {
+      events,
+      format: events.length > 0 ? mapReaderFormat(result.format) : "empty"
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) return void 0;
+    throw error;
   }
-  return { events: parsed.events, format: parsed.format };
 }
 
 // packages/cli/src/view.ts
@@ -6799,6 +8939,149 @@ async function reportCommand(runId, options = {}) {
     console.log(result.content);
   }
 }
+async function readStdin(stdin) {
+  stdin.setEncoding("utf8");
+  let content = "";
+  for await (const chunk of stdin) {
+    content += typeof chunk === "string" ? chunk : String(chunk);
+  }
+  return content;
+}
+async function inputFromPathOrStdin(input3, stdin) {
+  if (input3 === void 0 || input3 === "-") {
+    return { type: "string", content: await readStdin(stdin) };
+  }
+  const stats = await stat(input3);
+  if (stats.isDirectory()) return { type: "directory", path: input3 };
+  return { type: "file", path: input3 };
+}
+function printWarnings(result) {
+  if (result.warnings.length === 0 && result.unsupportedFields.length === 0) {
+    return;
+  }
+  console.log("");
+  console.log("Diagnostics");
+  for (const warning of result.warnings) {
+    const where = [
+      warning.sourceFile,
+      warning.line !== void 0 ? `line ${warning.line}` : void 0,
+      warning.field
+    ].filter((value) => value !== void 0).join(" ");
+    console.log(
+      `- ${warning.code}: ${warning.message}${where !== "" ? ` (${where})` : ""}`
+    );
+  }
+  for (const field of result.unsupportedFields) {
+    console.log(`- unsupported: ${field}`);
+  }
+}
+function printNode(node, depth) {
+  const ev = node.event;
+  const status = ev.status !== void 0 ? ` ${ev.status}` : "";
+  const duration = ev.durationMs !== void 0 ? ` ${formatDuration2(ev.durationMs)}` : "";
+  console.log(`${getIndent(depth)}${ev.kind.toLowerCase()}: ${ev.name}${status}${duration}`);
+  for (const child of node.children) {
+    printNode(child, depth + 1);
+  }
+}
+function printRun(result, run) {
+  console.log(`Format: ${result.format}`);
+  console.log(`Run: ${run.runId}`);
+  if (run.name !== void 0) console.log(`Name: ${run.name}`);
+  if (run.status !== void 0) console.log(`Status: ${run.status}`);
+  if (run.startedAt !== void 0) {
+    console.log(`Started: ${formatTimestamp(run.startedAt)}`);
+  }
+  if (run.durationMs !== void 0) {
+    console.log(`Duration: ${formatDuration2(run.durationMs)}`);
+  }
+  console.log(`Events: ${run.metadata.totalEvents}`);
+  for (const node of run.children) {
+    printNode(node, 0);
+  }
+}
+function selectRun(result, runId) {
+  if (runId !== void 0) {
+    return result.runs.find((run) => run.runId === runId);
+  }
+  return result.runs.length === 1 ? result.runs[0] : void 0;
+}
+function printMultipleRuns(result) {
+  console.error(
+    `Trace contains ${result.runs.length} runs. Re-run with --run <run-id>.`
+  );
+  for (const run of result.runs) {
+    const bits = [
+      run.runId,
+      run.name !== void 0 ? `name=${run.name}` : void 0,
+      run.status !== void 0 ? `status=${run.status}` : void 0,
+      `events=${run.metadata.totalEvents}`
+    ].filter((value) => value !== void 0);
+    console.error(`- ${bits.join(" ")}`);
+  }
+}
+function writeJson(output2) {
+  console.log(JSON.stringify(output2, null, 2));
+}
+async function openCommand(input3, options = {}, stdin = process.stdin) {
+  try {
+    const traceInput = await inputFromPathOrStdin(input3, stdin);
+    const result = await openTrace(traceInput, {
+      ...options.format !== void 0 ? { format: options.format } : {}
+    });
+    const selected = selectRun(result, options.run);
+    if (selected === void 0) {
+      process.exitCode = 1;
+      const message = options.run !== void 0 ? `Run not found: ${options.run}` : `Trace contains ${result.runs.length} runs. Specify --run <run-id>.`;
+      if (options.json) {
+        writeJson({
+          format: result.format,
+          sourceFiles: result.sourceFiles,
+          warnings: result.warnings,
+          unsupportedFields: result.unsupportedFields,
+          runs: result.runs,
+          error: { message }
+        });
+      } else if (options.run !== void 0) {
+        console.error(message);
+      } else {
+        printMultipleRuns(result);
+      }
+      return;
+    }
+    if (options.json) {
+      writeJson({
+        format: result.format,
+        sourceFiles: result.sourceFiles,
+        warnings: result.warnings,
+        unsupportedFields: result.unsupportedFields,
+        selectedRunId: selected.runId,
+        runs: [selected]
+      });
+      return;
+    }
+    printRun(result, selected);
+    if (options.diagnostics) {
+      printWarnings(result);
+    }
+  } catch (error) {
+    process.exitCode = 1;
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof TraceReadError ? error.code : void 0;
+    const warnings = error instanceof TraceReadError ? error.warnings : [];
+    if (options.json) {
+      writeJson({
+        warnings,
+        error: { ...code !== void 0 ? { code } : {}, message }
+      });
+      return;
+    }
+    console.error(message);
+    if (options.diagnostics) {
+      printWarnings({ warnings, unsupportedFields: [] });
+    }
+  }
+}
 
 // packages/cli/src/index.ts
 function runCommand(action) {
@@ -6809,7 +9092,7 @@ function runCommand(action) {
   });
 }
 function createCliProgram() {
-  const program = new Command("agent-inspect").description("Local-first execution-tree debugger for AI agents").version("1.0.0");
+  const program = new Command("agent-inspect").description("Local-first execution-tree debugger for AI agents").version(version);
   program.command("list").description("List recent AgentInspect runs").option("--dir <path>", "trace directory").option("--limit <number>", "max runs to show (default 20, max 100)").addOption(
     new Option("--status <status>", "filter by run status").choices([
       "running",
@@ -6892,6 +9175,15 @@ function createCliProgram() {
   ).action((runId, opts) => {
     runCommand(() => exportCommand(runId, opts));
   });
+  program.command("open").description("Open any supported local trace through the reader pipeline").argument("[input]", "trace file, directory, or - for stdin").addOption(
+    new Option("--format <format>", "trace input format").choices([
+      "agent-inspect-jsonl",
+      "openinference-json",
+      "otlp-json"
+    ])
+  ).option("--json", "print result as JSON").option("--diagnostics", "print reader warnings and unsupported fields").option("--run <run-id>", "select a run when the trace contains multiple runs").action((input3, opts) => {
+    runCommand(() => openCommand(input3, opts));
+  });
   program.command("diff").description("Compare two local AgentInspect JSONL traces (read-only)").argument("<left-run-id>", "first run id").argument("<right-run-id>", "second run id").option("--dir <path>", "trace directory").option("--json", "print diff result as JSON").option("--ignore-duration", "omit duration comparisons").option(
     "--duration-threshold <duration>",
     "ignore duration deltas at or below this (e.g. 500ms, 2s, 1m)"
@@ -6947,7 +9239,7 @@ function createCliProgram() {
   ).option("-o, --output <path>", "write report to file (creates parent dirs)").option("--json", "emit JSON wrapper (includes content when writing to stdout)").option("--include-attributes", "include bounded step attributes in tree section").option("--no-errors", "omit error details from tree section").option("--no-correlation", "omit correlation metadata from what section").addOption(
     new Option(
       "--redaction-profile <profile>",
-      "redaction profile for tree section: local, share, strict (default: local)"
+      "redaction profile for entire report: local, share, strict (default: local)"
     ).choices(["local", "share", "strict"])
   ).action((runId, opts) => {
     runCommand(() => reportCommand(runId, opts));