@agent-inspect/mcp-server 6.1.0 → 6.4.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import readline from 'readline';
 import path from 'path';
 import { AsyncLocalStorage } from 'async_hooks';
-import 'crypto';
+import crypto from 'crypto';
 import { readdir, stat, readFile } from 'fs/promises';
 import os from 'os';
 import 'nanoid';
@@ -36,6 +36,183 @@ function extractCorrelationMetadata(record) {
   }
   return found ? out : void 0;
 }
+var DEFAULT_REDACT_KEYS = [
+  "authorization",
+  "cookie",
+  "token",
+  "apiKey",
+  "password",
+  "secret",
+  "email"
+];
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function toKey(s) {
+  return s.toLowerCase();
+}
+function stableHash(value) {
+  const h = crypto.createHash("sha256").update(value, "utf8").digest("hex");
+  return h.slice(0, 8);
+}
+function compileRules(rules, extraKeys) {
+  const out = /* @__PURE__ */ new Map();
+  const set = (r) => {
+    const k = toKey(r.key);
+    out.set(k, { ...r, key: k });
+  };
+  for (const k of DEFAULT_REDACT_KEYS) {
+    set({ key: k, strategy: "full" });
+  }
+  for (const k of extraKeys ?? []) {
+    if (typeof k === "string" && k.length > 0) {
+      set({ key: k, strategy: "full" });
+    }
+  }
+  for (const r of rules ?? []) {
+    if (typeof r === "string") {
+      set({ key: r, strategy: "full" });
+      continue;
+    }
+    const key = r.key;
+    if (r.strategy === "full") set({ key, strategy: "full" });
+    if (r.strategy === "hash") set({ key, strategy: "hash" });
+    if (r.strategy === "prefix") {
+      set({ key, strategy: "prefix", keep: typeof r.keep === "number" ? r.keep : 8 });
+    }
+  }
+  return [...out.values()];
+}
+var Redactor = class {
+  #rules;
+  constructor(options) {
+    this.#rules = compileRules(options?.rules, options?.extraKeys);
+  }
+  redactValue(key, value) {
+    const k = toKey(key);
+    const rule = this.#rules.find((r) => r.key === k);
+    if (!rule) {
+      return this.#redactNested(value);
+    }
+    if (rule.strategy === "full") return "[REDACTED]";
+    const asString = typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : void 0;
+    if (rule.strategy === "prefix") {
+      if (asString === void 0) return "[REDACTED]";
+      const keep = Math.max(0, Math.floor(rule.keep));
+      return asString.length <= keep ? `${asString}\u2026` : `${asString.slice(0, keep)}\u2026`;
+    }
+    if (rule.strategy === "hash") {
+      if (asString === void 0) return "[HASH:unknown]";
+      return `[HASH:${stableHash(asString)}]`;
+    }
+    return this.#redactNested(value);
+  }
+  redactRecord(record) {
+    const out = {};
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = this.redactValue(k, v);
+    }
+    return out;
+  }
+  #redactNested(value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => this.#redactNested(v));
+    }
+    if (isRecord(value)) {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = this.redactValue(k, v);
+      }
+      return out;
+    }
+    return value;
+  }
+};
+
+// packages/core/src/redaction-profiles.ts
+var SHARE_PROFILE_EXTRA_KEYS = [
+  "userEmail",
+  "customerEmail",
+  "phone",
+  "phoneNumber",
+  "address",
+  "ip",
+  "ipAddress",
+  "sessionId",
+  "requestId",
+  "correlationId",
+  "decisionId",
+  "groupId",
+  "customerId",
+  "userId",
+  "accountId",
+  "tenantId",
+  "orgId",
+  "organizationId",
+  "traceId",
+  "spanId",
+  "parentSpanId"
+];
+var STRICT_PROFILE_EXTRA_KEYS = [
+  "prompt",
+  "completion",
+  "input",
+  "output",
+  "inputPreview",
+  "outputPreview",
+  "message",
+  "messages",
+  "transcript",
+  "context",
+  "document",
+  "documents",
+  "chunk",
+  "chunks",
+  "retrieval",
+  "query"
+];
+function resolveRedactionProfile(profile = "local") {
+  switch (profile) {
+    case "local":
+      return { profile: "local", extraKeys: [] };
+    case "share":
+      return {
+        profile: "share",
+        extraKeys: SHARE_PROFILE_EXTRA_KEYS,
+        maxMetadataValueLengthCap: 500,
+        maxPreviewLengthCap: 200
+      };
+    case "strict":
+      return {
+        profile: "strict",
+        extraKeys: [...SHARE_PROFILE_EXTRA_KEYS, ...STRICT_PROFILE_EXTRA_KEYS],
+        maxMetadataValueLengthCap: 200,
+        maxPreviewLengthCap: 80
+      };
+    default:
+      return { profile: "local", extraKeys: [] };
+  }
+}
+function isPreviewKey(key) {
+  return key.toLowerCase().includes("preview");
+}
+function applyProfileMetadataCaps(maxMetadataValueLength, maxPreviewLength, resolved) {
+  let meta = maxMetadataValueLength;
+  let preview = maxPreviewLength;
+  if (resolved.maxMetadataValueLengthCap !== void 0) {
+    meta = Math.min(meta, resolved.maxMetadataValueLengthCap);
+  }
+  if (resolved.maxPreviewLengthCap !== void 0) {
+    preview = Math.min(preview, resolved.maxPreviewLengthCap);
+  }
+  return { maxMetadataValueLength: meta, maxPreviewLength: preview };
+}
+function truncateStringForProfile(value, key, maxMetadataValueLength, maxPreviewLength) {
+  const max = isPreviewKey(key) ? maxPreviewLength : maxMetadataValueLength;
+  if (max <= 0) return "\u2026";
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}\u2026`;
+}
 
 // packages/core/src/types.ts
 var STEP_TYPES = [
@@ -47,14 +224,14 @@ var STEP_TYPES = [
   "state",
   "custom"
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isStepType(value) {
   return typeof value === "string" && STEP_TYPES.includes(value);
 }
 function isTraceEvent(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord2(value)) return false;
   if (value.schemaVersion !== "0.1") return false;
   if (typeof value.timestamp !== "number") return false;
   if (typeof value.event !== "string") return false;
@@ -114,7 +291,7 @@ var PERSISTED_EVENT_STATUSES = [
   "error",
   "unknown"
 ];
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isString(value) {
@@ -145,21 +322,21 @@ function isPersistedEventStatus(value) {
   return typeof value === "string" && PERSISTED_EVENT_STATUSES.includes(value);
 }
 function isPersistedEventSource(value) {
-  if (!isRecord2(value)) return false;
+  if (!isRecord3(value)) return false;
   if (!isPersistedEventSourceType(value.type)) return false;
   if (!isOptionalString(value.name)) return false;
   if (!isOptionalString(value.version)) return false;
   return true;
 }
 function isPersistedInspectError(value) {
-  if (!isRecord2(value)) return false;
+  if (!isRecord3(value)) return false;
   if (!isNonEmptyString2(value.message)) return false;
   if (!isOptionalString(value.name)) return false;
   if (!isOptionalString(value.code)) return false;
   return true;
 }
 function isPersistedTokenUsage(value) {
-  if (!isRecord2(value)) return false;
+  if (!isRecord3(value)) return false;
   if (!isOptionalNonNegativeNumber(value.input)) return false;
   if (!isOptionalNonNegativeNumber(value.output)) return false;
   if (!isOptionalNonNegativeNumber(value.total)) return false;
@@ -167,14 +344,14 @@ function isPersistedTokenUsage(value) {
   return true;
 }
 function isPersistedTraceContext(value) {
-  if (!isRecord2(value)) return false;
+  if (!isRecord3(value)) return false;
   if (!isOptionalString(value.traceId)) return false;
   if (!isOptionalString(value.spanId)) return false;
   if (!isOptionalString(value.parentSpanId)) return false;
   return true;
 }
 function isPersistedInspectEvent(value) {
-  if (!isRecord2(value)) return false;
+  if (!isRecord3(value)) return false;
   if (value.schemaVersion !== "0.2" && value.schemaVersion !== "1.0") {
     return false;
   }
@@ -196,7 +373,7 @@ function isPersistedInspectEvent(value) {
   if (value.durationMs !== void 0 && !isNonNegativeNumber(value.durationMs)) {
     return false;
   }
-  if (value.attributes !== void 0 && !isRecord2(value.attributes)) {
+  if (value.attributes !== void 0 && !isRecord3(value.attributes)) {
     return false;
   }
   if (value.error !== void 0 && !isPersistedInspectError(value.error)) {
@@ -548,6 +725,24 @@ function parseDuration(duration) {
     }
   }
 }
+function formatDuration(ms) {
+  if (!Number.isFinite(ms)) {
+    return "0ms";
+  }
+  if (ms < 0) {
+    throw new Error(`formatDuration: ms must be non-negative (got ${ms})`);
+  }
+  if (ms < 1e3) {
+    return `${Math.floor(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  if (ms < 36e5) {
+    return `${(ms / 6e4).toFixed(1)}m`;
+  }
+  return `${(ms / 36e5).toFixed(1)}h`;
+}
 
 // packages/core/src/utils.ts
 var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
@@ -557,6 +752,9 @@ var FALLBACK_TRACE_DIR = path.join(
   "agent-inspect",
   RUNS_DIR_NAME
 );
+function formatDuration2(ms) {
+  return formatDuration(ms);
+}
 function getDefaultTraceDir() {
   const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
   if (typeof envDir === "string" && envDir.trim() !== "") {
@@ -611,11 +809,11 @@ function warn(message, error) {
 }
 
 // packages/core/src/read-trace.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function detectLineFormat(parsed) {
-  if (!isRecord3(parsed)) return "unknown";
+  if (!isRecord4(parsed)) return "unknown";
   if (parsed.schemaVersion === "0.1") return "0.1";
   if (parsed.schemaVersion === "0.2") return "0.2";
   if (parsed.schemaVersion === "1.0") return "1.0";
@@ -687,7 +885,7 @@ function parseTraceJsonl(raw, options = {}) {
 }
 
 // packages/core/src/storage.ts
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -698,7 +896,7 @@ function finiteNumber(value) {
 }
 function optionalErrorInfo(value) {
   if (value === void 0) return true;
-  if (!isRecord4(value)) return false;
+  if (!isRecord5(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;
@@ -706,7 +904,7 @@ function optionalErrorInfo(value) {
   return true;
 }
 function validateEvent(event) {
-  if (!isRecord4(event)) return false;
+  if (!isRecord5(event)) return false;
   if (event.schemaVersion !== "0.1") return false;
   if (!finiteNumber(event.timestamp)) return false;
   if (typeof event.event !== "string") return false;
@@ -715,7 +913,7 @@ function validateEvent(event) {
       if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord5(event.metadata)) {
         return false;
       }
       return true;
@@ -730,7 +928,7 @@ function validateEvent(event) {
       if (event.parentId !== void 0 && typeof event.parentId !== "string") {
         return false;
       }
-      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+      if (event.metadata !== void 0 && !isRecord5(event.metadata)) {
         return false;
       }
       return true;
@@ -952,6 +1150,129 @@ async function extractMetadata(filePath, _quickScan) {
     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"
+  );
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const lastCompleted = completed[completed.length - 1];
+  const runId = started?.runId ?? events.find((e) => typeof e.runId === "string")?.runId ?? "unknown-run";
+  const name = typeof started?.name === "string" && started.name.trim() !== "" ? started.name : void 0;
+  const status = lastCompleted ? lastCompleted.status : started ? "running" : "unknown";
+  const durationMs = lastCompleted && isFiniteNumber(lastCompleted.durationMs) ? lastCompleted.durationMs : void 0;
+  started && isFiniteNumber(started.startTime) ? started.startTime : void 0;
+  const steps = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      steps.set(s.stepId, {
+        type: s.type,
+        name: s.name,
+        status: "running",
+        parentId: s.parentId,
+        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
+      });
+    }
+  }
+  for (const e of events) {
+    if (e.event === "step_completed") {
+      const c = e;
+      const existing = steps.get(c.stepId);
+      if (!existing) continue;
+      existing.status = c.status;
+      existing.durationMs = c.durationMs;
+    }
+  }
+  let totalSteps = 0;
+  let llmSteps = 0;
+  let toolSteps = 0;
+  let logicSteps = 0;
+  let errorSteps = 0;
+  let maxDepth = 0;
+  let longestStep;
+  let totalTokensInput = 0;
+  let totalTokensOutput = 0;
+  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);
+    if (cached !== void 0) return cached;
+    const node = steps.get(stepId);
+    if (!node) return 0;
+    const parent = node.parentId;
+    if (typeof parent !== "string" || parent.trim() === "" || !steps.has(parent)) {
+      depthCache.set(stepId, 0);
+      return 0;
+    }
+    const d = Math.min(1e3, computeDepth(parent) + 1);
+    depthCache.set(stepId, d);
+    return d;
+  };
+  for (const [id, s] of steps.entries()) {
+    totalSteps += 1;
+    if (s.type === "llm") llmSteps += 1;
+    else if (s.type === "tool") toolSteps += 1;
+    else logicSteps += 1;
+    if (s.status === "error") errorSteps += 1;
+    const depth = computeDepth(id);
+    if (depth > maxDepth) maxDepth = depth;
+    if (typeof s.durationMs === "number" && Number.isFinite(s.durationMs)) {
+      if (!longestStep || s.durationMs > longestStep.durationMs) {
+        longestStep = { name: s.name, durationMs: s.durationMs, type: s.type };
+      }
+    }
+    if (s.tokensInput !== void 0 || s.tokensOutput !== void 0 || s.tokensTotal !== void 0 || s.tokensCached !== void 0) {
+      tokenBearingSteps += 1;
+      if (s.tokensInput !== void 0) totalTokensInput += s.tokensInput;
+      if (s.tokensOutput !== void 0) totalTokensOutput += s.tokensOutput;
+      if (s.tokensTotal !== void 0) {
+        totalTokensTotal += s.tokensTotal;
+        stepsWithKnownTotal += 1;
+      } else if (s.tokensInput !== void 0 && s.tokensOutput !== void 0) {
+        totalTokensTotal += s.tokensInput + s.tokensOutput;
+        stepsWithKnownTotal += 1;
+      }
+      if (s.tokensCached !== void 0) {
+        totalTokensCached += s.tokensCached;
+        hasCachedTokens = true;
+      }
+    }
+  }
+  const summary = {
+    runId,
+    name,
+    status,
+    durationMs,
+    totalSteps,
+    llmSteps,
+    toolSteps,
+    logicSteps,
+    errorSteps,
+    maxDepth,
+    ...longestStep ? { longestStep } : {},
+    ...tokenBearingSteps > 0 ? {
+      totalTokens: {
+        input: totalTokensInput,
+        output: totalTokensOutput,
+        ...stepsWithKnownTotal === tokenBearingSteps ? { total: totalTokensTotal } : {},
+        ...hasCachedTokens ? { cached: totalTokensCached } : {}
+      }
+    } : {}
+  };
+  return summary;
+}
 
 // packages/core/src/trace-filter.ts
 function toLower(s) {
@@ -1110,6 +1431,145 @@ function buildRunTimeline(events, options = {}) {
   };
 }
 
+// packages/core/src/what.ts
+function pickCorrelation2(metadata) {
+  if (!metadata) return void 0;
+  const out = {};
+  for (const key of [
+    "correlationId",
+    "requestId",
+    "decisionId",
+    "groupId"
+  ]) {
+    const value = metadata[key];
+    if (typeof value === "string" && value.trim() !== "") {
+      out[key] = value;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function stepMixLine(summary) {
+  const parts = [];
+  if (summary.llmSteps > 0) parts.push(`${summary.llmSteps} LLM`);
+  if (summary.toolSteps > 0) parts.push(`${summary.toolSteps} tool`);
+  if (summary.logicSteps > 0) parts.push(`${summary.logicSteps} logic`);
+  return parts.length > 0 ? parts.join(", ") : "none";
+}
+function outcomeLine(summary) {
+  if (summary.status === "success") {
+    return summary.errorSteps > 0 ? "Completed with step errors recorded." : "Completed successfully.";
+  }
+  if (summary.status === "error") {
+    if (summary.failedStepNames.length > 0) {
+      const names = summary.failedStepNames.slice(0, 3).join(", ");
+      const suffix = summary.failedStepNames.length > 3 ? ` (+${summary.failedStepNames.length - 3} more)` : "";
+      return `Failed at step(s): ${names}${suffix}.`;
+    }
+    if (summary.runErrorMessage) {
+      return `Run failed: ${summary.runErrorMessage}`;
+    }
+    return "Run failed.";
+  }
+  if (summary.status === "running") {
+    return "Run is still in progress (no run_completed).";
+  }
+  return "Outcome unknown \u2014 inspect events may be incomplete.";
+}
+function buildRunWhatSummary(events) {
+  const base = buildRunSummary(events);
+  const started = events.find(
+    (e) => e.event === "run_started"
+  );
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const lastCompleted = completed[completed.length - 1];
+  const failedStepNames = [];
+  const stepNames = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      stepNames.set(s.stepId, s.name);
+    }
+  }
+  for (const e of events) {
+    if (e.event === "step_completed") {
+      const sc = e;
+      if (sc.status === "error") {
+        failedStepNames.push(stepNames.get(sc.stepId) ?? sc.stepId);
+      }
+    }
+  }
+  return {
+    runId: base.runId,
+    name: base.name,
+    status: base.status,
+    durationMs: base.durationMs,
+    totalSteps: base.totalSteps,
+    llmSteps: base.llmSteps,
+    toolSteps: base.toolSteps,
+    logicSteps: base.logicSteps,
+    errorSteps: base.errorSteps,
+    maxDepth: base.maxDepth,
+    longestStep: base.longestStep,
+    totalTokens: base.totalTokens,
+    correlation: pickCorrelation2(started?.metadata),
+    failedStepNames,
+    runErrorMessage: lastCompleted?.error?.message
+  };
+}
+function renderRunWhat(summary, options = {}) {
+  const showCorrelation = options.correlation !== false;
+  const lines = [];
+  const label = summary.name ?? summary.runId;
+  lines.push(`What: ${label}`);
+  const duration = summary.durationMs !== void 0 ? formatDuration2(summary.durationMs) : "\u2014";
+  lines.push(
+    `Status: ${summary.status} \xB7 Duration: ${duration} \xB7 Steps: ${summary.totalSteps} (${stepMixLine(summary)})`
+  );
+  if (summary.totalTokens) {
+    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 = [];
+    if (summary.correlation.correlationId) {
+      parts.push(`correlationId=${summary.correlation.correlationId}`);
+    }
+    if (summary.correlation.requestId) {
+      parts.push(`requestId=${summary.correlation.requestId}`);
+    }
+    if (summary.correlation.decisionId) {
+      parts.push(`decisionId=${summary.correlation.decisionId}`);
+    }
+    if (summary.correlation.groupId) {
+      parts.push(`groupId=${summary.correlation.groupId}`);
+    }
+    if (parts.length > 0) {
+      lines.push(`Correlation: ${parts.join(", ")}`);
+    }
+  }
+  lines.push(`Outcome: ${outcomeLine(summary)}`);
+  if (summary.longestStep && summary.totalSteps > 0) {
+    lines.push(
+      `Slowest: ${summary.longestStep.name} (${formatDuration2(summary.longestStep.durationMs)}, ${summary.longestStep.type})`
+    );
+  }
+  if (summary.maxDepth > 0) {
+    lines.push(`Max depth: ${summary.maxDepth}`);
+  }
+  return lines.join("\n");
+}
+
 // packages/core/src/search.ts
 function parseDurationFilter(expr) {
   const raw = expr.trim();
@@ -1329,6 +1789,39 @@ async function loadTraceMetadataList(_traceDir, fileNames, getPath) {
   return metas;
 }
 
+// packages/core/src/bundle/safety-status.ts
+function aggregateBundleSafeStatus(statuses) {
+  if (statuses.length === 0) return "UNKNOWN";
+  if (statuses.some((status) => status === "UNSAFE")) return "UNSAFE";
+  if (statuses.some((status) => status === "UNKNOWN")) return "UNKNOWN";
+  if (statuses.some((status) => status === "SAFE WITH WARNINGS")) return "SAFE WITH WARNINGS";
+  return "SAFE";
+}
+function toMetadataSafeStatus(status) {
+  if (status === "SAFE WITH WARNINGS") return "SAFE_WITH_WARNINGS";
+  return status;
+}
+
+// packages/core/src/bundle/manifest.ts
+var BUNDLE_NOTE = "Generated locally by AgentInspect. Bundles are derived copies for review \u2014 not compliance or security certification. Review before sharing.";
+function buildBundleMetadata(parts) {
+  const aggregate = aggregateBundleSafeStatus(
+    parts.checks.runs.map((run) => run.status)
+  );
+  return {
+    createdAt: parts.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    agentInspectVersion: parts.agentInspectVersion,
+    redactionProfile: parts.profile,
+    sourceTraceCount: parts.resolve.runIds.length,
+    runIds: [...parts.resolve.runIds],
+    safeStatus: toMetadataSafeStatus(aggregate),
+    files: [...parts.files].sort((a, b) => a.localeCompare(b)),
+    note: BUNDLE_NOTE,
+    ...parts.resolve.sessionId !== void 0 ? { sessionId: parts.resolve.sessionId } : {},
+    ...parts.resolve.since !== void 0 ? { since: parts.resolve.since } : {}
+  };
+}
+
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -1637,14 +2130,14 @@ function runTraceChecks(input, options = {}) {
 }
 
 // packages/core/src/persisted/token-usage.ts
-function isRecord5(value) {
+function isRecord6(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 (!isRecord5(value)) return void 0;
+  if (!isRecord6(value)) return void 0;
   const input = nonNegativeFinite(value.input);
   const output = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
@@ -2402,7 +2895,7 @@ function persistedEventsForParsedTrace(parsed) {
     sourceName: "agent-inspect-jsonl-reader"
   });
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString3(value) {
@@ -2417,13 +2910,13 @@ function readStringField(record, keys) {
 }
 function readRecordField(record, key) {
   const value = record[key];
-  return isRecord6(value) ? value : void 0;
+  return isRecord7(value) ? value : void 0;
 }
 function parseJsonDocument(content) {
   return JSON.parse(content);
 }
 function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord6(value)) return false;
+  if (!isRecord7(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);
 }
@@ -2448,7 +2941,7 @@ function extractOpenInferenceDocument(root) {
       unsupportedFields
     };
   }
-  if (!isRecord6(root)) return void 0;
+  if (!isRecord7(root)) return void 0;
   const rootFormat = root.format;
   const rootCompatibility = root.compatibility;
   const version = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
@@ -2588,7 +3081,7 @@ function summarizeAttributeValue(value) {
   if (Array.isArray(value)) {
     return { type: "array", length: value.length };
   }
-  if (isRecord6(value)) {
+  if (isRecord7(value)) {
     return { type: "object", keyCount: Object.keys(value).length };
   }
   if (value === null) {
@@ -2675,7 +3168,7 @@ function mapOpenInferenceKind(span, attributes, pathPrefix) {
   }
 }
 function mapOpenInferenceStatus(status) {
-  if (!isRecord6(status)) return void 0;
+  if (!isRecord7(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -2775,7 +3268,7 @@ function mapOpenInferenceSpan(span, index, version) {
   warnings.push(...kindWarnings);
   const status = mapOpenInferenceStatus(span.status);
   const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
-  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord7(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,
@@ -2921,7 +3414,7 @@ var openInferenceJsonReader = {
   }
 };
 function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     unsupportedFields.push(field);
     warnings.push({
       code: "otlp_attribute_value_invalid",
@@ -2943,15 +3436,15 @@ function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
   if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
     return value.doubleValue;
   }
-  if (isRecord6(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+  if (isRecord7(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
     return value.arrayValue.values.map(
       (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
     );
   }
-  if (isRecord6(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+  if (isRecord7(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
     const out = {};
     for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord6(item) || typeof item.key !== "string") {
+      if (!isRecord7(item) || typeof item.key !== "string") {
         unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
         continue;
       }
@@ -3002,7 +3495,7 @@ function parseOtlpAttributes(value, pathPrefix) {
   }
   for (const [index, item] of value.entries()) {
     const field = `${pathPrefix}[${index}]`;
-    if (!isRecord6(item) || typeof item.key !== "string") {
+    if (!isRecord7(item) || typeof item.key !== "string") {
       unsupportedFields.push(field);
       warnings.push({
         code: "otlp_attribute_invalid",
@@ -3025,16 +3518,16 @@ function parseOtlpAttributes(value, pathPrefix) {
   return { attributes, warnings, unsupportedFields };
 }
 function looksLikeOtlpSpan(value) {
-  return isRecord6(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+  return isRecord7(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
 }
 function extractOtlpDocument(root) {
-  if (!isRecord6(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  if (!isRecord7(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 (!isRecord6(resourceSpan)) {
+    if (!isRecord7(resourceSpan)) {
       unsupportedFields.push(resourcePath);
       continue;
     }
@@ -3057,7 +3550,7 @@ function extractOtlpDocument(root) {
     }
     for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
       const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord6(scopeSpan)) {
+      if (!isRecord7(scopeSpan)) {
         unsupportedFields.push(scopePath);
         continue;
       }
@@ -3124,7 +3617,7 @@ function extractOtlpDocument(root) {
   };
 }
 function mapOtlpStatus(status) {
-  if (!isRecord6(status)) return void 0;
+  if (!isRecord7(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -3224,7 +3717,7 @@ function mapOtlpEvents(value, pathPrefix) {
   const events = [];
   for (const [index, event] of value.entries()) {
     const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord6(event)) {
+    if (!isRecord7(event)) {
       unsupportedFields.push(eventPath);
       continue;
     }
@@ -3362,7 +3855,7 @@ function mapOtlpSpan(context) {
   warnings.push(...kindWarnings);
   const status = mapOtlpStatus(span.status);
   const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord7(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,
@@ -3735,6 +4228,9 @@ function safeString(value, maxLength) {
 function escapeMarkdown(value) {
   return value.replace(/\|/g, "\\|").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, " ");
 }
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
 function sortKeysDeep(input) {
   if (input === null || typeof input !== "object") return input;
   if (Array.isArray(input)) return input.map(sortKeysDeep);
@@ -3752,14 +4248,15 @@ function stableJson(value, pretty) {
 function compactAttributes3(attrs, options) {
   if (attrs === void 0) return {};
   const maxLen = options?.maxLength ?? 500;
+  const redacted = options?.redacted ?? true;
   const out = {};
   for (const key of Object.keys(attrs).sort()) {
-    if (shouldRedactKey(key)) {
+    if (redacted && shouldRedactKey(key)) {
       out[key] = "[REDACTED]";
       continue;
     }
     const v = attrs[key];
-    out[key] = compactValue(v, maxLen);
+    out[key] = compactValue(v, maxLen, redacted);
   }
   return out;
 }
@@ -3768,15 +4265,15 @@ function compactValue(value, maxLen, redacted) {
     return typeof value === "string" ? safeString(value, maxLen) : value;
   }
   if (Array.isArray(value)) {
-    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen));
+    const arr = value.slice(0, 20).map((x) => compactValue(x, maxLen, redacted));
     if (value.length > 20) arr.push(`\u2026(+${value.length - 20} more)`);
     return arr;
   }
   const o = value;
   const inner = {};
   for (const k of Object.keys(o)) {
-    if (shouldRedactKey(k)) inner[k] = "[REDACTED]";
-    else inner[k] = compactValue(o[k], maxLen);
+    if (redacted && shouldRedactKey(k)) inner[k] = "[REDACTED]";
+    else inner[k] = compactValue(o[k], maxLen, redacted);
   }
   return inner;
 }
@@ -4150,6 +4647,274 @@ function diffRuns(left, right, options) {
   return { summary, differences };
 }
 
+// packages/core/src/exporters/types.ts
+var EXPORT_PAYLOAD_VERSION = "0.1.2";
+
+// packages/core/src/exporters/redact-export.ts
+function isRecord8(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 (isRecord8(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 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;
+  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 = compactAttributes3(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 = [];
@@ -4175,6 +4940,7 @@ function exportMarkdown(tree, options) {
   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)}`);
@@ -4250,7 +5016,9 @@ function exportMarkdown(tree, options) {
     for (const n of flat) {
       if (!n.event.attributes || Object.keys(n.event.attributes).length === 0) continue;
       const compact = compactAttributes3(n.event.attributes, {
-        maxLength: maxLen});
+        maxLength: maxLen,
+        redacted
+      });
       lines.push(`### ${escapeMarkdown(n.event.name)}`);
       lines.push("");
       lines.push("```json");
@@ -4270,6 +5038,295 @@ function exportMarkdown(tree, options) {
     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/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,
+    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)}`);
+    }
+  }
+}
 
 // packages/mcp-server/src/tools.ts
 var READ_ONLY_TOOLS = [
@@ -4343,6 +5400,42 @@ var READ_ONLY_TOOLS = [
       properties: { runId: { type: "string" } },
       required: ["runId"]
     }
+  },
+  {
+    name: "summarize_failed_run",
+    description: "Summarize a failed run with step errors and correlation metadata.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "retrieve_decision_notes",
+    description: "List decision steps and decision metadata for one run.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "find_failed_observation",
+    description: "Find failed observed outcomes in one run.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
+  },
+  {
+    name: "create_share_safe_bundle",
+    description: "Create an in-memory share-safe bundle manifest and redacted exports.",
+    inputSchema: {
+      type: "object",
+      properties: { runId: { type: "string" } },
+      required: ["runId"]
+    }
   }
 ];
 function textResult(payload) {
@@ -4377,6 +5470,19 @@ async function openRunTrace(context, runId) {
 function legacyTraceEvents(events) {
   return persistedInspectEventsToTraceEvents(events);
 }
+function redactionProfileForExport(context) {
+  return context.redactionProfile === "local" ? "share" : context.redactionProfile;
+}
+function decisionNotes(events) {
+  return events.filter(
+    (event) => event.kind === "DECISION" || typeof event.attributes?.decisionId === "string" && event.attributes.decisionId !== ""
+  ).slice(0, 50).map((event) => ({
+    name: event.name,
+    kind: event.kind,
+    status: event.status,
+    decisionId: typeof event.attributes?.decisionId === "string" ? event.attributes.decisionId : void 0
+  }));
+}
 async function callReadOnlyTool(context, name, args = {}) {
   switch (name) {
     case "list_traces": {
@@ -4477,10 +5583,73 @@ async function callReadOnlyTool(context, name, args = {}) {
       const { read } = await openRunTrace(context, runId);
       const run = read.runs.find((item) => item.runId === runId) ?? read.runs[0];
       if (!run) return errorResult2(`Run tree not found: ${runId}`);
+      const profile = redactionProfileForExport(context);
       const markdown = exportMarkdown(run, {
-        redactionProfile: context.redactionProfile === "local" ? "share" : context.redactionProfile
+        redacted: true});
+      return textResult({ runId, profile, markdown: markdown.content });
+    }
+    case "summarize_failed_run": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const traceEvents = legacyTraceEvents(read.events);
+      const summary = buildRunWhatSummary(traceEvents);
+      return textResult({
+        runId,
+        status: summary.status,
+        summary: renderRunWhat(summary),
+        failedStepNames: summary.failedStepNames,
+        correlation: summary.correlation ?? null
+      });
+    }
+    case "retrieve_decision_notes": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const notes = decisionNotes(read.events);
+      return textResult({ runId, decisions: notes, count: notes.length });
+    }
+    case "find_failed_observation": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const outcomes = extractOutcomesFromTraceEvents(legacyTraceEvents(read.events));
+      const failed = outcomes.filter((outcome) => outcome.status === "failed");
+      return textResult({
+        runId,
+        failed,
+        count: failed.length
+      });
+    }
+    case "create_share_safe_bundle": {
+      const runId = String(args.runId ?? "");
+      const { read } = await openRunTrace(context, runId);
+      const run = read.runs.find((item) => item.runId === runId) ?? read.runs[0];
+      if (!run) return errorResult2(`Run tree not found: ${runId}`);
+      const profile = redactionProfileForExport(context);
+      const markdown = exportMarkdown(run, {
+        redacted: true});
+      const tree = exportRunTree(run, {
+        format: "openinference",
+        redacted: true,
+        redactionProfile: profile
+      });
+      const metadata = buildBundleMetadata({
+        agentInspectVersion: "mcp-server",
+        profile,
+        resolve: { runIds: [runId] },
+        checks: {
+          aggregateStatus: "SAFE",
+          runs: [{ runId, status: "SAFE", errors: 0, warnings: 0, findings: 0 }]
+        },
+        files: ["report.md", "tree.json"]
+      });
+      return textResult({
+        runId,
+        profile,
+        metadata,
+        files: {
+          "report.md": markdown.content,
+          "tree.json": tree.content
+        }
       });
-      return textResult({ runId, profile: context.redactionProfile, markdown: markdown.content });
     }
     default:
       return errorResult2(`Unknown tool: ${name}`);