agent-inspect 1.9.0 → 2.0.0

package/packages/core/dist/exporters.mjs

@@ -1,6 +1,1116 @@
-export { EXPORT_PAYLOAD_VERSION, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, manualTraceEventsToRunTree, mergeExportDefaults, redactRunTreeForExport, validateExport, validateExportContent } from './chunk-Y56BPA3B.mjs';
+import { buildRunWhatSummary, renderRunWhat, renderTimeline, buildRunTimeline } from './chunk-2ZXEMWGK.mjs';
+import { escapeHtml, flattenTree, safeString, compactAttributes, stableJson, escapeMarkdown, zeroKinds } from './chunk-HY7H3CQM.mjs';
 export { compactAttributes, escapeHtml, escapeMarkdown, flattenTree, safeString, stableJson, summarizeTree } from './chunk-HY7H3CQM.mjs';
-import './chunk-EDTQHZPM.mjs';
-import './chunk-VU6O5QAH.mjs';
+import { resolveRedactionProfile, applyProfileMetadataCaps, truncateStringForProfile } from './chunk-EDTQHZPM.mjs';
+import { Redactor } from './chunk-VU6O5QAH.mjs';
+import './chunk-NQZPZ2FN.mjs';
+import './chunk-IZBJAZGF.mjs';
+import './chunk-7TGZLWEE.mjs';
+import crypto from 'crypto';
+
+// packages/core/src/exporters/types.ts
+var EXPORT_PAYLOAD_VERSION = "0.1.2";
+
+// packages/core/src/exporters/redact-export.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    out[k] = deepClone(v);
+  }
+  return out;
+}
+function boundAttributeValues(record, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+  if (depth > 32) {
+    return { truncated: true, reason: "maxDepth" };
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(record)) {
+    out[key] = boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth);
+  }
+  return out;
+}
+function boundValue(value, key, maxMetadataValueLength, maxPreviewLength, seen, depth) {
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      return truncateStringForProfile(
+        value,
+        key,
+        maxMetadataValueLength,
+        maxPreviewLength
+      );
+    }
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map(
+      (item, index) => boundValue(
+        item,
+        String(index),
+        maxMetadataValueLength,
+        maxPreviewLength,
+        seen,
+        depth + 1
+      )
+    );
+  }
+  return boundAttributeValues(
+    value,
+    maxMetadataValueLength,
+    maxPreviewLength,
+    seen,
+    depth + 1
+  );
+}
+function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPreviewLength) {
+  if (!attrs || Object.keys(attrs).length === 0) {
+    return attrs;
+  }
+  const redacted = redactor.redactRecord(attrs);
+  const seen = /* @__PURE__ */ new WeakSet();
+  const bounded = boundAttributeValues(
+    redacted,
+    maxMetadataValueLength,
+    maxPreviewLength,
+    seen,
+    0
+  );
+  const err = bounded.error;
+  if (isRecord(err) && typeof err.message === "string") {
+    bounded.error = {
+      ...err,
+      message: truncateStringForProfile(
+        err.message,
+        "message",
+        maxMetadataValueLength,
+        maxPreviewLength
+      ),
+      ...typeof err.stack === "string" ? {
+        stack: truncateStringForProfile(
+          err.stack,
+          "stack",
+          maxMetadataValueLength,
+          maxPreviewLength
+        )
+      } : {}
+    };
+  }
+  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 (!isRecord(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") {
+    return deepClone(tree);
+  }
+  const resolved = resolveRedactionProfile(profile);
+  const { maxMetadataValueLength, maxPreviewLength } = applyProfileMetadataCaps(
+    2e3,
+    500,
+    resolved
+  );
+  const redactor = new Redactor({ extraKeys: resolved.extraKeys });
+  const clone = deepClone(tree);
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.event.attributes !== void 0) {
+        node.event.attributes = redactEventAttributes(
+          node.event.attributes,
+          redactor,
+          maxMetadataValueLength,
+          maxPreviewLength
+        );
+      }
+      if (node.children.length > 0) {
+        walk(node.children);
+      }
+    }
+  }
+  walk(clone.children);
+  return clone;
+}
+
+// packages/core/src/exporters/html-exporter.ts
+function renderTreeHtml(nodes, ulClass = "tree") {
+  if (nodes.length === 0) return "";
+  const parts = [`<ul class="${ulClass}">`];
+  for (const n of nodes) {
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    parts.push("<li>");
+    parts.push(
+      `<span class="nm">${escapeHtml(ev.name)}</span> <span class="meta">[${escapeHtml(ev.kind)}] ${escapeHtml(status)} (${escapeHtml(dur)})</span>`
+    );
+    if (n.children.length > 0) {
+      parts.push(renderTreeHtml(n.children, "tree nested"));
+    }
+    parts.push("</li>");
+  }
+  parts.push("</ul>");
+  return parts.join("");
+}
+function exportHtml(tree, options) {
+  const warnings = [];
+  const includeMetadata = options?.includeMetadata ?? true;
+  const includeAttributes = options?.includeAttributes ?? false;
+  const includeErrors = options?.includeErrors ?? true;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const titleName = escapeHtml(tree.name ?? tree.runId);
+  const summaryRows = [];
+  summaryRows.push(
+    `<tr><th scope="row">runId</th><td><code>${escapeHtml(tree.runId)}</code></td></tr>`
+  );
+  if (tree.name !== void 0) {
+    summaryRows.push(`<tr><th scope="row">name</th><td>${escapeHtml(tree.name)}</td></tr>`);
+  }
+  summaryRows.push(
+    `<tr><th scope="row">status</th><td>${escapeHtml(String(tree.status ?? "unknown"))}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">durationMs</th><td>${tree.durationMs !== void 0 ? escapeHtml(String(tree.durationMs)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">startedAt</th><td>${tree.startedAt !== void 0 ? escapeHtml(String(tree.startedAt)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">endedAt</th><td>${tree.endedAt !== void 0 ? escapeHtml(String(tree.endedAt)) : "\u2014"}</td></tr>`
+  );
+  summaryRows.push(
+    `<tr><th scope="row">totalEvents</th><td>${escapeHtml(String(tree.metadata.totalEvents))}</td></tr>`
+  );
+  let confidenceHtml = "";
+  if (includeMetadata) {
+    const cb = tree.metadata.confidenceBreakdown;
+    confidenceHtml += "<h3>Confidence breakdown</h3><table><thead><tr><th>bucket</th><th>count</th></tr></thead><tbody>";
+    for (const k of Object.keys(cb).sort()) {
+      const key = k;
+      confidenceHtml += `<tr><td>${escapeHtml(key)}</td><td>${cb[key]}</td></tr>`;
+    }
+    confidenceHtml += "</tbody></table>";
+    confidenceHtml += "<h3>Kind breakdown</h3><table><thead><tr><th>kind</th><th>count</th></tr></thead><tbody>";
+    for (const k of Object.keys(tree.metadata.kinds).sort()) {
+      const key = k;
+      const c = tree.metadata.kinds[key];
+      if (c > 0) confidenceHtml += `<tr><td>${escapeHtml(key)}</td><td>${c}</td></tr>`;
+    }
+    confidenceHtml += "</tbody></table>";
+  }
+  const flat = flattenTree(tree);
+  const errors = flat.filter((n) => n.event.status === "error");
+  let errorsHtml = "";
+  if (includeErrors && errors.length > 0) {
+    errorsHtml += "<h2>Errors</h2><ul>";
+    for (const n of errors) {
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
+        n.event.attributes.error.message,
+        maxLen
+      ) : "";
+      errorsHtml += `<li><strong>${escapeHtml(n.event.name)}</strong> (${escapeHtml(n.event.eventId)}): ${escapeHtml(msg || "error")}</li>`;
+    }
+    errorsHtml += "</ul>";
+  }
+  let attrsHtml = "";
+  if (includeAttributes) {
+    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, {
+        maxLength: maxLen,
+        redacted
+      });
+      attrsHtml += `<h3>${escapeHtml(n.event.name)}</h3><pre class="json">${escapeHtml(stableJson(compact, true))}</pre>`;
+    }
+    warnings.push(
+      "Attributes may still contain sensitive data; review exports before sharing."
+    );
+  }
+  const css = `
+body{font-family:system-ui,sans-serif;line-height:1.5;margin:1.5rem;max-width:960px;color:#111}
+h1{font-size:1.35rem}
+h2{font-size:1.1rem;margin-top:1.5rem}
+table{border-collapse:collapse;margin:0.75rem 0}
+th,td{border:1px solid #ccc;padding:0.35rem 0.6rem;text-align:left}
+th{background:#f5f5f5}
+pre.json{background:#f8f8f8;padding:0.75rem;overflow:auto;font-size:0.85rem}
+ul.tree{list-style:none;padding-left:1rem}
+ul.tree.nested{padding-left:1.25rem;border-left:1px solid #ddd;margin:0.25rem 0}
+.nm{font-weight:600}
+.meta{color:#555;font-size:0.9rem}
+footer{margin-top:2rem;font-size:0.85rem;color:#555}
+`.trim();
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>${titleName}</title>
+<style>${css}</style>
+</head>
+<body>
+<header><h1>AgentInspect Run: ${titleName}</h1></header>
+<p class="note">Generated locally by AgentInspect.</p>
+${includeMetadata ? `<section class="summary"><h2>Summary</h2><table>${summaryRows.join("")}</table>${confidenceHtml}</section>` : ""}
+<section class="tree"><h2>Execution tree</h2>${tree.children.length > 0 ? renderTreeHtml(tree.children) : "<p>No steps recorded.</p>"}</section>
+${errorsHtml}
+${attrsHtml}
+<footer>Generated locally by AgentInspect. Review for sensitive data before sharing.</footer>
+</body>
+</html>`;
+  return {
+    format: "html",
+    content: html,
+    contentType: "text/html",
+    fileExtension: ".html",
+    warnings
+  };
+}
+
+// packages/core/src/exporters/markdown-exporter.ts
+function renderTreeAscii(nodes, indent = "") {
+  const lines = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    const last = i === nodes.length - 1;
+    const branch = last ? "\u2514\u2500 " : "\u251C\u2500 ";
+    const ev = n.event;
+    const status = ev.status ?? "?";
+    const dur = ev.durationMs !== void 0 && Number.isFinite(ev.durationMs) ? `${ev.durationMs}ms` : "-";
+    lines.push(`${indent}${branch}${escapeMarkdown(ev.name)} [${ev.kind}] ${status} (${dur})`);
+    const nextIndent = indent + (last ? "   " : "\u2502  ");
+    if (n.children.length > 0) {
+      const childStr = renderTreeAscii(n.children, nextIndent);
+      if (childStr.length > 0) lines.push(childStr);
+    }
+  }
+  return lines.join("\n");
+}
+function exportMarkdown(tree, options) {
+  const warnings = [];
+  const includeMetadata = options?.includeMetadata ?? true;
+  const includeAttributes = options?.includeAttributes ?? false;
+  const includeErrors = options?.includeErrors ?? true;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const redacted = options?.redacted ?? true;
+  const titleName = tree.name ?? tree.runId;
+  const lines = [];
+  lines.push(`# AgentInspect Run: ${escapeMarkdown(titleName)}`);
+  lines.push("");
+  lines.push("Generated locally by AgentInspect. Review for sensitive data before sharing.");
+  lines.push("");
+  if (includeMetadata) {
+    lines.push("## Summary");
+    lines.push("");
+    lines.push(`- **runId**: ${escapeMarkdown(tree.runId)}`);
+    if (tree.name !== void 0) lines.push(`- **name**: ${escapeMarkdown(tree.name)}`);
+    lines.push(`- **status**: ${escapeMarkdown(String(tree.status ?? "unknown"))}`);
+    lines.push(
+      `- **durationMs**: ${tree.durationMs !== void 0 ? escapeMarkdown(String(tree.durationMs)) : "-"}`
+    );
+    lines.push(
+      `- **startedAt**: ${tree.startedAt !== void 0 ? escapeMarkdown(String(tree.startedAt)) : "-"}`
+    );
+    lines.push(
+      `- **endedAt**: ${tree.endedAt !== void 0 ? escapeMarkdown(String(tree.endedAt)) : "-"}`
+    );
+    lines.push(`- **totalEvents**: ${tree.metadata.totalEvents}`);
+    lines.push("");
+    lines.push("### Confidence breakdown");
+    lines.push("");
+    lines.push("| bucket | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.confidenceBreakdown).sort()) {
+      const key = k;
+      lines.push(
+        `| ${escapeMarkdown(key)} | ${tree.metadata.confidenceBreakdown[key]} |`
+      );
+    }
+    lines.push("");
+    lines.push("### Kind breakdown");
+    lines.push("");
+    lines.push("| kind | count |");
+    lines.push("| --- | --- |");
+    for (const k of Object.keys(tree.metadata.kinds).sort()) {
+      const key = k;
+      const c = tree.metadata.kinds[key];
+      if (c > 0) lines.push(`| ${escapeMarkdown(key)} | ${c} |`);
+    }
+    lines.push("");
+  }
+  lines.push("## Execution tree");
+  lines.push("");
+  lines.push("```text");
+  lines.push(
+    tree.children.length > 0 ? renderTreeAscii(tree.children) : "(no steps)"
+  );
+  lines.push("```");
+  lines.push("");
+  const flat = flattenTree(tree);
+  const errors = flat.filter((n) => n.event.status === "error");
+  if (includeErrors && errors.length > 0) {
+    lines.push("## Errors");
+    lines.push("");
+    for (const n of errors) {
+      const msg = n.event.attributes && typeof n.event.attributes.error === "object" ? safeString(
+        n.event.attributes.error.message,
+        maxLen
+      ) : "";
+      lines.push(
+        `- **${escapeMarkdown(n.event.name)}** (${escapeMarkdown(n.event.eventId)}): ${escapeMarkdown(msg || "error")}`
+      );
+    }
+    lines.push("");
+  }
+  if (includeAttributes) {
+    lines.push("## Attributes (bounded)");
+    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, {
+        maxLength: maxLen,
+        redacted
+      });
+      lines.push(`### ${escapeMarkdown(n.event.name)}`);
+      lines.push("");
+      lines.push("```json");
+      lines.push(stableJson(compact, true));
+      lines.push("```");
+      lines.push("");
+    }
+    warnings.push(
+      "Attributes may still contain sensitive data; review exports before sharing."
+    );
+  }
+  return {
+    format: "markdown",
+    content: lines.join("\n"),
+    contentType: "text/markdown",
+    fileExtension: ".md",
+    warnings
+  };
+}
+function hexFrom(seed, byteLen) {
+  return crypto.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
+}
+function mapInspectKindToOI(kind, warnings) {
+  switch (kind) {
+    case "LLM":
+      return { openInferenceKind: "LLM" };
+    case "TOOL":
+      return { openInferenceKind: "TOOL" };
+    case "CHAIN":
+      return { openInferenceKind: "CHAIN" };
+    case "RETRIEVER":
+      return { openInferenceKind: "RETRIEVER" };
+    case "AGENT":
+      return { openInferenceKind: "AGENT" };
+    case "DECISION":
+      warnings.push(
+        `Ambiguous kind DECISION mapped to CHAIN for span compatibility (${EXPORT_PAYLOAD_VERSION}).`
+      );
+      return { openInferenceKind: "CHAIN" };
+    case "RESULT":
+      warnings.push(
+        `Ambiguous kind RESULT mapped to UNKNOWN for span compatibility (${EXPORT_PAYLOAD_VERSION}).`
+      );
+      return { openInferenceKind: "UNKNOWN" };
+    case "ERROR":
+      warnings.push(`ERROR kind mapped to CHAIN for span compatibility.`);
+      return { openInferenceKind: "CHAIN" };
+    case "LOG":
+    case "LOGIC":
+    case "RUN":
+      warnings.push(`${kind} mapped to CHAIN for span compatibility.`);
+      return { openInferenceKind: "CHAIN" };
+    default:
+      warnings.push(`Unhandled InspectKind ${kind} mapped to UNKNOWN.`);
+      return { openInferenceKind: "UNKNOWN" };
+  }
+}
+function exportOpenInference(tree, options) {
+  const warnings = [
+    "OpenInference-compatible JSON export is experimental until verified against specific backends.",
+    "This file was generated locally and not sent anywhere."
+  ];
+  const traceId = hexFrom(`trace:${tree.runId}`, 16);
+  const includeAttributes = options?.includeAttributes ?? false;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const pretty = options?.pretty ?? true;
+  const spans = [];
+  for (const n of flattenTree(tree)) {
+    const ev = n.event;
+    const spanId = hexFrom(`${tree.runId}:${ev.eventId}`, 8);
+    const parentSpanHex = ev.parentId ? hexFrom(`${tree.runId}:${ev.parentId}`, 8) : void 0;
+    const startNs = Math.round(ev.timestamp * 1e6);
+    let endNs;
+    if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
+      endNs = startNs + Math.round(ev.durationMs * 1e6);
+    }
+    const { openInferenceKind } = mapInspectKindToOI(ev.kind, warnings);
+    const attrs = {
+      "openinference.span.kind": openInferenceKind,
+      "agent_inspect.kind": ev.kind,
+      "agent_inspect.confidence": ev.confidence,
+      "agent_inspect.source.type": ev.source.type,
+      "agent_inspect.run_id": tree.runId,
+      "agent_inspect.event_id": ev.eventId,
+      "agent_inspect.status": ev.status ?? "unset"
+    };
+    if (ev.durationMs !== void 0) {
+      attrs["agent_inspect.duration_ms"] = ev.durationMs;
+    }
+    const meta = ev.attributes;
+    if (meta?.model !== void 0 && typeof meta.model === "string") {
+      attrs["llm.model_name"] = meta.model;
+    }
+    const tokens = meta?.tokens;
+    if (tokens && typeof tokens === "object" && tokens !== null) {
+      const inp = tokens.input;
+      const outp = tokens.output;
+      if (typeof inp === "number") attrs["llm.token_count.prompt"] = inp;
+      if (typeof outp === "number") attrs["llm.token_count.completion"] = outp;
+    }
+    if (includeAttributes && meta && typeof meta === "object") {
+      for (const [k, v] of Object.entries(meta)) {
+        if (k === "tokens" || k === "model") continue;
+        if (v !== void 0 && v !== null && typeof v !== "object") {
+          attrs[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
+        }
+      }
+    }
+    let status;
+    if (ev.status === "error") {
+      const msg = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error") : "error";
+      status = { code: "ERROR", message: msg.slice(0, maxLen) };
+    } else if (ev.status === "ok") {
+      status = { code: "OK" };
+    } else {
+      status = { code: "UNSET" };
+    }
+    spans.push({
+      trace_id: traceId,
+      span_id: spanId,
+      parent_span_id: parentSpanHex,
+      name: ev.name,
+      start_time_unix_nano: startNs,
+      end_time_unix_nano: endNs,
+      attributes: attrs,
+      status
+    });
+  }
+  const payload = {
+    exporter: "agent-inspect",
+    format: "openinference",
+    compatibility: "openinference-compatible",
+    version: EXPORT_PAYLOAD_VERSION,
+    trace_id: traceId,
+    spans,
+    warnings
+  };
+  return {
+    format: "openinference",
+    content: JSON.stringify(payload, null, pretty ? 2 : void 0),
+    contentType: "application/json",
+    fileExtension: ".openinference.json",
+    warnings
+  };
+}
+function hexFrom2(seed, byteLen) {
+  return crypto.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
+}
+function stringAttr(key, value) {
+  return { key, value: { stringValue: value } };
+}
+function intAttr(key, value) {
+  return { key, value: { intValue: String(value) } };
+}
+function genAiOperationName(kind) {
+  switch (kind) {
+    case "LLM":
+      return "generate_content";
+    case "TOOL":
+      return "execute_tool";
+    case "AGENT":
+      return "invoke_agent";
+    default:
+      return void 0;
+  }
+}
+function exportOtlpJson(tree, options) {
+  const warnings = [
+    "OTLP JSON export uses OTel GenAI-aligned attributes where applicable; experimental until verified against specific collectors.",
+    "Not OTLP gRPC/protobuf \u2014 JSON mapping only. Generated locally; no network upload."
+  ];
+  const traceId = hexFrom2(`trace:${tree.runId}`, 16);
+  const includeAttributes = options?.includeAttributes ?? false;
+  const maxLen = options?.maxAttributeLength ?? 500;
+  const pretty = options?.pretty ?? true;
+  const flat = flattenTree(tree);
+  const spans = [];
+  for (const n of flat) {
+    const ev = n.event;
+    const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
+    const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
+    const startNs = String(Math.round(ev.timestamp * 1e6));
+    let endNs;
+    if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
+      endNs = String(Math.round(ev.timestamp * 1e6 + ev.durationMs * 1e6));
+    }
+    const attrs = [
+      stringAttr("agent_inspect.kind", ev.kind),
+      stringAttr("agent_inspect.confidence", ev.confidence),
+      stringAttr("agent_inspect.source.type", ev.source.type),
+      stringAttr("agent_inspect.run_id", tree.runId),
+      stringAttr("agent_inspect.event_id", ev.eventId),
+      stringAttr("agent_inspect.status", ev.status ?? "unset")
+    ];
+    if (ev.durationMs !== void 0) {
+      attrs.push(intAttr("agent_inspect.duration_ms", ev.durationMs));
+    }
+    const op = genAiOperationName(ev.kind);
+    if (op !== void 0) {
+      attrs.push(stringAttr("gen_ai.operation.name", op));
+    }
+    const meta = ev.attributes;
+    if (meta?.model !== void 0 && typeof meta.model === "string") {
+      attrs.push(stringAttr("gen_ai.request.model", meta.model.slice(0, maxLen)));
+    }
+    const tokens = meta?.tokens;
+    if (tokens && typeof tokens === "object" && tokens !== null) {
+      const inp = tokens.input;
+      const outp = tokens.output;
+      if (typeof inp === "number") attrs.push(intAttr("gen_ai.usage.input_tokens", inp));
+      if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
+    }
+    if (includeAttributes && meta && typeof meta === "object") {
+      for (const [k, v] of Object.entries(meta)) {
+        if (k === "tokens" || k === "model") continue;
+        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+          attrs.push(
+            stringAttr(
+              `agent_inspect.preview.${k}`,
+              typeof v === "string" ? v.slice(0, maxLen) : String(v)
+            )
+          );
+        }
+      }
+    }
+    let statusCode = "STATUS_CODE_UNSET";
+    let statusMessage;
+    if (ev.status === "error") {
+      statusCode = "STATUS_CODE_ERROR";
+      statusMessage = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error").slice(0, maxLen) : "error";
+    } else if (ev.status === "ok") {
+      statusCode = "STATUS_CODE_OK";
+    }
+    const spanJson = {
+      traceId,
+      spanId,
+      name: ev.name,
+      kind: "SPAN_KIND_INTERNAL",
+      startTimeUnixNano: startNs,
+      attributes: attrs,
+      status: {
+        code: statusCode,
+        ...statusMessage !== void 0 ? { message: statusMessage } : {}
+      }
+    };
+    if (parentSpanId !== void 0) {
+      spanJson.parentSpanId = parentSpanId;
+    }
+    if (endNs !== void 0) {
+      spanJson.endTimeUnixNano = endNs;
+    }
+    spans.push(spanJson);
+  }
+  const payload = {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [stringAttr("service.name", "agent-inspect")]
+        },
+        scopeSpans: [
+          {
+            scope: { name: "agent-inspect" },
+            spans
+          }
+        ]
+      }
+    ]
+  };
+  return {
+    format: "otlp-json",
+    content: JSON.stringify(payload, null, pretty ? 2 : void 0),
+    contentType: "application/json",
+    fileExtension: ".otlp.json",
+    warnings
+  };
+}
+
+// packages/core/src/exporters/validation.ts
+var EXPERIMENTAL = "Experimental compatibility export \u2014 verify against your target tooling before relying on it.";
+function validateExportContent(format, content) {
+  const errors = [];
+  const warnings = [EXPERIMENTAL];
+  if (format === "markdown") {
+    if (!content.startsWith("# AgentInspect Run")) {
+      errors.push('Markdown export must start with "# AgentInspect Run"');
+    }
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "html") {
+    const lower = content.toLowerCase();
+    if (!lower.includes("<!doctype html")) {
+      errors.push("HTML export must include <!doctype html>");
+    }
+    if (/<\s*script\b/i.test(content)) {
+      errors.push("HTML export must not contain script tags");
+    }
+    if (/<\s*link\b[^>]*href\s*=/i.test(content)) {
+      warnings.push("HTML export contains link tags \u2014 ensure no external stylesheets.");
+    }
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "openinference") {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      errors.push("OpenInference export is not valid JSON");
+      return { ok: false, format, errors, warnings };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      errors.push("OpenInference export JSON must be an object");
+      return { ok: false, format, errors, warnings };
+    }
+    const o = parsed;
+    if (o.format !== "openinference") {
+      errors.push('OpenInference export must include format: "openinference"');
+    }
+    if (!Array.isArray(o.spans)) {
+      errors.push("OpenInference export must include a spans array");
+    }
+    warnings.push("OpenInference-compatible JSON is not guaranteed for every backend.");
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  if (format === "otlp-json") {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      errors.push("OTLP JSON export is not valid JSON");
+      return { ok: false, format, errors, warnings };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      errors.push("OTLP JSON export must be an object");
+      return { ok: false, format, errors, warnings };
+    }
+    const o = parsed;
+    if (!Array.isArray(o.resourceSpans)) {
+      errors.push("OTLP JSON export must include resourceSpans array");
+    }
+    warnings.push(
+      "OTLP JSON mapping uses OTel GenAI-aligned attributes where applicable; collectors may require transformation."
+    );
+    return { ok: errors.length === 0, format, errors, warnings };
+  }
+  errors.push(`Unsupported export format`);
+  return { ok: false, format, errors, warnings };
+}
+
+// packages/core/src/exporters/manual-trace-adapter.ts
+function stepTypeToInspectKind(t) {
+  switch (t) {
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "run":
+      return "CHAIN";
+    default:
+      return "LOGIC";
+  }
+}
+function mapStepStatus(s) {
+  if (s === void 0) return "running";
+  if (s === "success") return "ok";
+  return "error";
+}
+function manualTraceEventsToRunTree(events) {
+  const started = events.find((e) => e.event === "run_started");
+  if (!started || started.event !== "run_started") {
+    throw new Error("Invalid trace: missing run_started");
+  }
+  const runId = started.runId;
+  const runName = started.name;
+  const completedAll = events.filter((e) => e.event === "run_completed");
+  const lastCompleted = completedAll[completedAll.length - 1];
+  let runStatus;
+  if (lastCompleted === void 0) {
+    runStatus = "running";
+  } else if (lastCompleted.status === "success") {
+    runStatus = "ok";
+  } else {
+    runStatus = "error";
+  }
+  const startedAt = started.startTime;
+  const endedAt = lastCompleted !== void 0 && runStatus !== "running" ? lastCompleted.endTime : void 0;
+  const durationMs = lastCompleted !== void 0 && Number.isFinite(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event !== "step_started") continue;
+    const s = e;
+    steps.set(s.stepId, {
+      id: s.stepId,
+      parentId: s.parentId,
+      name: s.name,
+      type: s.type,
+      startTime: s.startTime,
+      timestamp: s.timestamp,
+      metadata: s.metadata
+    });
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const acc = steps.get(e.stepId);
+    if (!acc) continue;
+    acc.status = e.status;
+    acc.endTime = e.endTime;
+    acc.durationMs = e.durationMs;
+    if (e.error?.message) {
+      acc.error = e.error;
+    }
+  }
+  const inspectNodes = /* @__PURE__ */ new Map();
+  for (const acc of steps.values()) {
+    const kind = stepTypeToInspectKind(acc.type);
+    const status = mapStepStatus(acc.status);
+    const attrs = { ...acc.metadata ?? {} };
+    if (acc.error?.message) {
+      attrs.error = acc.error;
+    }
+    const evt = {
+      eventId: acc.id,
+      runId,
+      parentId: acc.parentId,
+      name: acc.name,
+      kind,
+      timestamp: acc.timestamp,
+      status,
+      durationMs: acc.durationMs,
+      attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+      confidence: "explicit",
+      source: { type: "manual" }
+    };
+    inspectNodes.set(acc.id, { event: evt, children: [], depth: 0 });
+  }
+  const roots = [];
+  const sortByStart = (a, b) => a.event.timestamp - b.event.timestamp;
+  for (const node of inspectNodes.values()) {
+    const pid = node.event.parentId;
+    if (pid !== void 0 && inspectNodes.has(pid)) {
+      inspectNodes.get(pid).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  roots.sort(sortByStart);
+  for (const n of inspectNodes.values()) {
+    n.children.sort(sortByStart);
+  }
+  const assignDepth = (n, depth) => {
+    n.depth = depth;
+    for (const c of n.children) assignDepth(c, depth + 1);
+  };
+  for (const r of roots) assignDepth(r, 0);
+  const confidenceBreakdown = {
+    explicit: 0,
+    correlated: 0,
+    heuristic: 0,
+    unknown: 0
+  };
+  const kinds = zeroKinds();
+  function countWalk(nodes) {
+    for (const n of nodes) {
+      confidenceBreakdown[n.event.confidence] += 1;
+      kinds[n.event.kind] += 1;
+      if (n.children.length > 0) countWalk(n.children);
+    }
+  }
+  countWalk(roots);
+  return {
+    runId,
+    name: runName,
+    status: runStatus,
+    startedAt,
+    endedAt,
+    durationMs,
+    children: roots,
+    metadata: {
+      totalEvents: inspectNodes.size,
+      confidenceBreakdown,
+      kinds
+    }
+  };
+}
+
+// packages/core/src/exporters/index.ts
+function mergeExportDefaults(options) {
+  return {
+    format: options.format,
+    includeMetadata: options.includeMetadata ?? true,
+    includeAttributes: options.includeAttributes ?? false,
+    includeErrors: options.includeErrors ?? true,
+    pretty: options.pretty ?? true,
+    redacted: options.redacted ?? true,
+    maxAttributeLength: options.maxAttributeLength ?? 500,
+    redactionProfile: options.redactionProfile ?? "local"
+  };
+}
+function exportRunTree(tree, options) {
+  const opts = mergeExportDefaults(options);
+  const exportTree = opts.redactionProfile === "local" ? tree : redactRunTreeForExport(tree, { redactionProfile: opts.redactionProfile });
+  switch (opts.format) {
+    case "markdown":
+      return exportMarkdown(exportTree, opts);
+    case "html":
+      return exportHtml(exportTree, opts);
+    case "openinference":
+      return exportOpenInference(exportTree, opts);
+    case "otlp-json":
+      return exportOtlpJson(exportTree, opts);
+    default: {
+      const _x = opts.format;
+      throw new Error(`Unsupported export format: ${String(_x)}`);
+    }
+  }
+}
+function validateExport(result) {
+  const base = validateExportContent(result.format, result.content);
+  return {
+    ok: base.ok,
+    format: base.format,
+    errors: base.errors,
+    warnings: [...result.warnings, ...base.warnings]
+  };
+}
+
+// packages/core/src/report.ts
+function resolveTree(events, profile) {
+  const tree = manualTraceEventsToRunTree(events);
+  return profile === "local" ? tree : redactRunTreeForExport(tree, { redactionProfile: profile });
+}
+function tailMarkdownSection(content, heading) {
+  const marker = `## ${heading}`;
+  const idx = content.indexOf(marker);
+  if (idx < 0) return "";
+  return content.slice(idx).trimEnd();
+}
+function extractHtmlFragment(content, start, end) {
+  const startIdx = content.indexOf(start);
+  if (startIdx < 0) return "";
+  const endIdx = content.indexOf(end, startIdx + start.length);
+  if (endIdx < 0) return content.slice(startIdx);
+  return content.slice(startIdx, endIdx);
+}
+var REPORT_HTML_CSS = `
+body{font-family:system-ui,sans-serif;line-height:1.5;margin:1.5rem;max-width:960px;color:#111}
+h1{font-size:1.35rem}
+h2{font-size:1.1rem;margin-top:1.5rem}
+pre{white-space:pre-wrap;background:#f8f8f8;padding:0.75rem;overflow:auto;font-size:0.9rem}
+ul.tree{list-style:none;padding-left:1rem}
+ul.tree.nested{padding-left:1.25rem;border-left:1px solid #ddd;margin:0.25rem 0}
+.nm{font-weight:600}
+.meta{color:#555;font-size:0.9rem}
+footer{margin-top:2rem;font-size:0.85rem;color:#555}
+`.trim();
+function buildRunReport(events, options) {
+  const profile = options.redactionProfile ?? "local";
+  const safeEvents = redactTraceEventsForReport(events, {
+    redactionProfile: profile
+  });
+  const whatSummary = buildRunWhatSummary(safeEvents);
+  const whatText = renderRunWhat(whatSummary, {
+    correlation: options.correlation !== false
+  });
+  const timelineText = renderTimeline(buildRunTimeline(safeEvents));
+  const tree = resolveTree(safeEvents, profile);
+  const exportOpts = {
+    includeMetadata: false,
+    includeAttributes: options.includeAttributes === true,
+    includeErrors: options.includeErrors !== false,
+    redacted: true,
+    maxAttributeLength: 500
+  };
+  if (options.format === "markdown") {
+    const treeMd = exportMarkdown(tree, exportOpts);
+    const tail = tailMarkdownSection(treeMd.content, "Execution tree");
+    const title2 = escapeMarkdown(whatSummary.name ?? whatSummary.runId);
+    const lines = [
+      `# AgentInspect Report: ${title2}`,
+      "",
+      "Generated locally by AgentInspect. Review for sensitive data before sharing.",
+      "",
+      "## What happened",
+      "",
+      "```text",
+      whatText,
+      "```",
+      "",
+      "## Timeline",
+      "",
+      "```text",
+      timelineText,
+      "```",
+      ""
+    ];
+    if (tail) {
+      lines.push(tail, "");
+    } else {
+      lines.push("## Execution tree", "", "(no steps)", "");
+    }
+    return {
+      format: "markdown",
+      content: lines.join("\n"),
+      contentType: "text/markdown",
+      fileExtension: ".md"
+    };
+  }
+  const treeHtml = exportHtml(tree, exportOpts);
+  const title = escapeHtml(whatSummary.name ?? whatSummary.runId);
+  const treeSection = extractHtmlFragment(
+    treeHtml.content,
+    '<section class="tree">',
+    "</section>"
+  );
+  const errorsSection = treeHtml.content.includes("<h2>Errors</h2>") ? extractHtmlFragment(treeHtml.content, "<h2>Errors</h2>", "<footer>") : "";
+  const attrsSection = treeHtml.content.includes("<h2>Attributes (bounded)</h2>") ? extractHtmlFragment(
+    treeHtml.content,
+    "<h2>Attributes (bounded)</h2>",
+    "<footer>"
+  ) : "";
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>AgentInspect Report: ${title}</title>
+<style>${REPORT_HTML_CSS}</style>
+</head>
+<body>
+<header><h1>AgentInspect Report: ${title}</h1></header>
+<p class="note">Generated locally by AgentInspect. Review for sensitive data before sharing.</p>
+<section class="what"><h2>What happened</h2><pre>${escapeHtml(whatText)}</pre></section>
+<section class="timeline"><h2>Timeline</h2><pre>${escapeHtml(timelineText)}</pre></section>
+${treeSection || '<section class="tree"><h2>Execution tree</h2><p>No steps recorded.</p></section>'}
+${errorsSection}
+${attrsSection}
+<footer>Generated locally by AgentInspect. Review for sensitive data before sharing.</footer>
+</body>
+</html>`;
+  return {
+    format: "html",
+    content: html,
+    contentType: "text/html",
+    fileExtension: ".html"
+  };
+}
+
+export { EXPORT_PAYLOAD_VERSION, buildRunReport, exportHtml, exportMarkdown, exportOpenInference, exportOtlpJson, exportRunTree, manualTraceEventsToRunTree, mergeExportDefaults, redactRunTreeForExport, validateExport, validateExportContent };
 //# sourceMappingURL=exporters.mjs.map
 //# sourceMappingURL=exporters.mjs.map