agent-inspect 1.3.0 → 1.5.0

package/packages/core/dist/chunk-XDBND27A.mjs

@@ -0,0 +1,975 @@
+import { isPersistedInspectEvent, persistedInspectEventsToTraceEvents, extractCorrelationMetadata } from './chunk-QX3ZMPUF.mjs';
+import { nanoid } from './chunk-7TGZLWEE.mjs';
+import { resolveRedactionProfile, applyProfileMetadataCaps } from './chunk-EDTQHZPM.mjs';
+import { Redactor } from './chunk-VU6O5QAH.mjs';
+import { source_default } from './chunk-BT7CATSD.mjs';
+import { mkdir, writeFile, readFile, readdir, stat, appendFile } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// packages/core/src/types.ts
+var STEP_TYPES = [
+  "run",
+  "llm",
+  "tool",
+  "decision",
+  "logic",
+  "state",
+  "custom"
+];
+var STEP_STATUSES = [
+  "running",
+  "success",
+  "error"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStepType(value) {
+  return typeof value === "string" && STEP_TYPES.includes(value);
+}
+function isStepStatus(value) {
+  return typeof value === "string" && STEP_STATUSES.includes(value);
+}
+function isTraceEvent(value) {
+  if (!isRecord(value)) return false;
+  if (value.schemaVersion !== "0.1") return false;
+  if (typeof value.timestamp !== "number") return false;
+  if (typeof value.event !== "string") return false;
+  switch (value.event) {
+    case "run_started": {
+      return typeof value.runId === "string" && typeof value.name === "string" && typeof value.startTime === "number";
+    }
+    case "run_completed": {
+      return typeof value.runId === "string" && (value.status === "success" || value.status === "error") && typeof value.endTime === "number" && typeof value.durationMs === "number";
+    }
+    case "step_started": {
+      return typeof value.runId === "string" && typeof value.stepId === "string" && typeof value.name === "string" && isStepType(value.type) && typeof value.startTime === "number";
+    }
+    case "step_completed": {
+      return typeof value.runId === "string" && typeof value.stepId === "string" && (value.status === "success" || value.status === "error") && typeof value.endTime === "number" && typeof value.durationMs === "number";
+    }
+    default:
+      return false;
+  }
+}
+
+// packages/core/src/utils/duration.ts
+function parseDuration(duration) {
+  const raw = typeof duration === "string" ? duration.trim() : "";
+  const match = raw.match(/^(\d+)(ms|[smhd])$/);
+  if (!match) {
+    throw new Error(
+      `Invalid duration format: ${duration}. Use a positive integer followed by ms, s, m, h, or d (e.g. 500ms, 30s, 5m, 2h, 7d).`
+    );
+  }
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error(
+      `Invalid duration amount: ${duration}. Amount must be a positive integer.`
+    );
+  }
+  switch (unit) {
+    case "ms":
+      return amount;
+    case "s":
+      return amount * 1e3;
+    case "m":
+      return amount * 60 * 1e3;
+    case "h":
+      return amount * 60 * 60 * 1e3;
+    case "d":
+      return amount * 24 * 60 * 60 * 1e3;
+    default: {
+      throw new Error(`Unknown duration unit: ${unit}`);
+    }
+  }
+}
+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`;
+}
+var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
+var RUNS_DIR_NAME = "runs";
+var FALLBACK_TRACE_DIR = path.join(
+  os.tmpdir(),
+  "agent-inspect",
+  RUNS_DIR_NAME
+);
+var MAX_NAME_LENGTH = 100;
+function createRunId() {
+  return `run_${nanoid(10)}`;
+}
+function createStepId() {
+  return `step_${nanoid(10)}`;
+}
+function formatDuration2(ms) {
+  return formatDuration(ms);
+}
+function formatTimestamp(timestamp) {
+  if (!Number.isFinite(timestamp)) {
+    return "Invalid date";
+  }
+  const d = new Date(timestamp);
+  if (Number.isNaN(d.getTime())) {
+    return "Invalid date";
+  }
+  const y = d.getFullYear();
+  const mo = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${day} ${h}:${min}:${s}`;
+}
+function getDefaultTraceDir() {
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  try {
+    const home = os.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+  } catch {
+    return FALLBACK_TRACE_DIR;
+  }
+}
+function getTraceFilePath(runId, traceDir) {
+  const baseDir = traceDir ?? getDefaultTraceDir();
+  let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safeId = path.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path.join(baseDir, `${safeId}.jsonl`);
+}
+async function ensureTraceDir(traceDir) {
+  const primary = path.resolve(traceDir);
+  try {
+    await mkdir(primary, { recursive: true });
+    return primary;
+  } catch {
+    warn(`Failed to create trace directory: ${primary}`);
+    const fallback = path.resolve(FALLBACK_TRACE_DIR);
+    try {
+      await mkdir(fallback, { recursive: true });
+      return fallback;
+    } catch {
+      warn(`Failed to create fallback trace directory: ${fallback}`);
+      return primary;
+    }
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const out = { message: error.message };
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+      out.stack = error.stack;
+    }
+    return out;
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (error === null) {
+    return { message: "Unknown error: null" };
+  }
+  if (error === void 0) {
+    return { message: "Unknown error: undefined" };
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "object") {
+    try {
+      return { message: JSON.stringify(error) };
+    } catch {
+      return { message: "Unknown error" };
+    }
+  }
+  return { message: "Unknown error" };
+}
+function truncateName(name, maxLength = MAX_NAME_LENGTH) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
+  }
+  const trimmed = name.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  const ellipsis = "...";
+  const head = Math.max(0, maxLength - ellipsis.length);
+  return `${trimmed.slice(0, head)}${ellipsis}`;
+}
+function warn(message, error) {
+  const base = `[AgentInspect] ${message}`;
+  if (error === void 0) {
+    console.warn(base);
+    return;
+  }
+  console.warn(`${base}: ${formatError(error).message}`);
+}
+
+// packages/core/src/read-trace.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectLineFormat(parsed) {
+  if (!isRecord2(parsed)) return "unknown";
+  if (parsed.schemaVersion === "0.1") return "0.1";
+  if (parsed.schemaVersion === "0.2") return "0.2";
+  return "unknown";
+}
+function parseTraceJsonl(raw, options = {}) {
+  const validate = options.validate ?? isTraceEvent;
+  const persisted = [];
+  const traceEvents = [];
+  let saw01 = false;
+  let saw02 = false;
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      warn("Skipped invalid JSON line in trace file");
+      continue;
+    }
+    const format2 = detectLineFormat(parsed);
+    if (format2 === "0.1") {
+      saw01 = true;
+      if (validate(parsed)) {
+        traceEvents.push(parsed);
+      } else {
+        warn("Skipped invalid trace event line in trace file");
+      }
+      continue;
+    }
+    if (format2 === "0.2") {
+      saw02 = true;
+      if (isPersistedInspectEvent(parsed)) {
+        persisted.push(parsed);
+      } else {
+        warn("Skipped invalid persisted inspect event line in trace file");
+      }
+      continue;
+    }
+    warn("Skipped trace line with unknown schemaVersion");
+  }
+  if (saw01 && saw02) {
+    warn("Trace file mixes schemaVersion 0.1 and 0.2 lines; normalizing all rows");
+  }
+  const converted = persisted.length > 0 ? persistedInspectEventsToTraceEvents(persisted) : [];
+  const events = [...traceEvents, ...converted];
+  let format = "empty";
+  if (saw01 && saw02) format = "mixed";
+  else if (saw01) format = "0.1";
+  else if (saw02) format = "0.2";
+  return { format, events, persisted };
+}
+function unknownTraceFormatMessage() {
+  return "Unsupported trace format. Expected schemaVersion 0.1 (TraceEvent) or 0.2 (PersistedInspectEvent).";
+}
+
+// packages/core/src/trace-event-safety.ts
+var DEFAULT_MAX_METADATA_VALUE_LENGTH = 2e3;
+var DEFAULT_MAX_PREVIEW_LENGTH = 500;
+var DEFAULT_MAX_EVENT_BYTES = 65536;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPreviewKey(key) {
+  return key.toLowerCase().includes("preview");
+}
+function truncateString(value, maxLen) {
+  if (maxLen <= 0) return "\u2026";
+  if (value.length <= maxLen) return value;
+  return `${value.slice(0, maxLen)}\u2026`;
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function resolveTraceSafetyOptions(options) {
+  const redact = options?.redact;
+  let redactEnabled = true;
+  let redactionRules;
+  if (redact === false) {
+    redactEnabled = false;
+  } else if (redact === true || redact === void 0) {
+    redactEnabled = true;
+  } else if (isRecord3(redact)) {
+    redactEnabled = true;
+    redactionRules = redact.rules;
+  }
+  const profile = options?.redactionProfile ?? "local";
+  const resolvedProfile = resolveRedactionProfile(profile);
+  const userMaxMetadata = typeof options?.maxMetadataValueLength === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : void 0;
+  const userMaxPreview = typeof options?.maxPreviewLength === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : void 0;
+  let maxMetadataValueLength = userMaxMetadata ?? DEFAULT_MAX_METADATA_VALUE_LENGTH;
+  let maxPreviewLength = userMaxPreview ?? DEFAULT_MAX_PREVIEW_LENGTH;
+  if (redactEnabled && profile !== "local") {
+    const capped = applyProfileMetadataCaps(
+      maxMetadataValueLength,
+      maxPreviewLength,
+      resolvedProfile
+    );
+    maxMetadataValueLength = capped.maxMetadataValueLength;
+    maxPreviewLength = capped.maxPreviewLength;
+  }
+  return {
+    redactEnabled,
+    redactionRules,
+    redactionProfile: profile,
+    profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
+    maxMetadataValueLength,
+    maxPreviewLength,
+    maxEventBytes: typeof options?.maxEventBytes === "number" && Number.isFinite(options.maxEventBytes) && options.maxEventBytes > 0 ? Math.floor(options.maxEventBytes) : DEFAULT_MAX_EVENT_BYTES
+  };
+}
+function boundMetadataValue(key, value, opts, seen, depth) {
+  if (depth > 32) return "[MaxDepth]";
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      const max = isPreviewKey(key) ? opts.maxPreviewLength : opts.maxMetadataValueLength;
+      return truncateString(value, max);
+    }
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const maxItems = 50;
+    const out2 = value.slice(0, maxItems).map(
+      (item, index) => boundMetadataValue(String(index), item, opts, seen, depth + 1)
+    );
+    if (value.length > maxItems) {
+      out2.push(`\u2026(+${value.length - maxItems} more)`);
+    }
+    return out2;
+  }
+  const record = value;
+  const out = {};
+  for (const [k, v] of Object.entries(record)) {
+    out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+  }
+  return out;
+}
+function redactMetadata(metadata, opts) {
+  if (!opts.redactEnabled) return { ...metadata };
+  const redactor = new Redactor({
+    rules: opts.redactionRules,
+    extraKeys: opts.profileExtraKeys
+  });
+  return redactor.redactRecord(metadata);
+}
+function prepareMetadataForDisk(metadata, opts) {
+  try {
+    const redacted = redactMetadata(metadata, opts);
+    const seen = /* @__PURE__ */ new WeakSet();
+    const bounded = boundMetadataValue(
+      "metadata",
+      redacted,
+      opts,
+      seen,
+      0
+    );
+    return isRecord3(bounded) ? bounded : {};
+  } catch {
+    return { truncated: true, reason: "metadataPreparationFailed" };
+  }
+}
+function truncateErrorStack(event, maxLen) {
+  if (event.event !== "run_completed" && event.event !== "step_completed") {
+    return event;
+  }
+  if (!event.error?.stack || typeof event.error.stack !== "string") {
+    return event;
+  }
+  return {
+    ...event,
+    error: {
+      ...event.error,
+      stack: truncateString(event.error.stack, maxLen)
+    }
+  };
+}
+function replaceMetadataWithTruncationMarker(event, originalApproxBytes) {
+  const marker = {
+    truncated: true,
+    reason: "maxEventBytes",
+    originalApproxBytes
+  };
+  if (event.event === "run_started") {
+    return { ...event, metadata: marker };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata: marker };
+  }
+  return event;
+}
+function shrinkMetadataLimits(opts, factor) {
+  return {
+    ...opts,
+    maxMetadataValueLength: Math.max(32, Math.floor(opts.maxMetadataValueLength * factor)),
+    maxPreviewLength: Math.max(16, Math.floor(opts.maxPreviewLength * factor))
+  };
+}
+function applyMetadataToEvent(event, metadata) {
+  if (event.event === "run_started") {
+    return { ...event, metadata };
+  }
+  if (event.event === "step_started") {
+    return { ...event, metadata };
+  }
+  return event;
+}
+function eventHasMetadata(event) {
+  return (event.event === "run_started" || event.event === "step_started") && event.metadata !== void 0;
+}
+function getEventMetadata(event) {
+  if (event.event === "run_started" || event.event === "step_started") {
+    return event.metadata;
+  }
+  return void 0;
+}
+function prepareTraceEventForDisk(event, opts) {
+  try {
+    let working = { ...event };
+    const rawMetadata = getEventMetadata(working);
+    if (rawMetadata !== void 0) {
+      const safe = prepareMetadataForDisk(rawMetadata, opts);
+      working = applyMetadataToEvent(working, safe);
+    }
+    let serialized = serializeEvent(working);
+    if (serialized === "") {
+      return working;
+    }
+    let bytes = byteLength(serialized);
+    if (bytes <= opts.maxEventBytes) {
+      return working;
+    }
+    if (rawMetadata !== void 0) {
+      for (const factor of [0.5, 0.25, 0.1]) {
+        const tighter = shrinkMetadataLimits(opts, factor);
+        const shrunk = prepareMetadataForDisk(rawMetadata, tighter);
+        working = applyMetadataToEvent(working, shrunk);
+        serialized = serializeEvent(working);
+        if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+          return working;
+        }
+      }
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+    }
+    working = truncateErrorStack(working, Math.min(opts.maxMetadataValueLength, 500));
+    serialized = serializeEvent(working);
+    if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+      return working;
+    }
+    if (eventHasMetadata(working)) {
+      working = replaceMetadataWithTruncationMarker(working, bytes);
+      serialized = serializeEvent(working);
+      if (serialized !== "" && byteLength(serialized) <= opts.maxEventBytes) {
+        return working;
+      }
+      if (working.event === "run_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      } else if (working.event === "step_started") {
+        const { metadata: _meta, ...rest } = working;
+        working = rest;
+      }
+    }
+    return working;
+  } catch {
+    if (event.event === "run_started" || event.event === "step_started") {
+      return applyMetadataToEvent(event, {
+        truncated: true,
+        reason: "prepareTraceEventFailed"
+      });
+    }
+    return event;
+  }
+}
+
+// packages/core/src/storage.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function optionalErrorInfo(value) {
+  if (value === void 0) return true;
+  if (!isRecord4(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;
+  }
+  return true;
+}
+function validateEvent(event) {
+  if (!isRecord4(event)) return false;
+  if (event.schemaVersion !== "0.1") return false;
+  if (!finiteNumber(event.timestamp)) return false;
+  if (typeof event.event !== "string") return false;
+  switch (event.event) {
+    case "run_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "run_completed": {
+      return nonEmptyString(event.runId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    case "step_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.stepId) || !nonEmptyString(event.name) || !isStepType(event.type) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.parentId !== void 0 && typeof event.parentId !== "string") {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord4(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "step_completed": {
+      return nonEmptyString(event.runId) && nonEmptyString(event.stepId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    default:
+      return false;
+  }
+}
+function serializeEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return "";
+  }
+}
+async function initializeTraceFile(runId, traceDir) {
+  try {
+    const usable = await ensureTraceDir(traceDir);
+    const filePath = getTraceFilePath(runId, usable);
+    await writeFile(filePath, "", "utf-8");
+    return filePath;
+  } catch (e) {
+    warn("Failed to initialize trace file", e);
+  }
+  try {
+    const usable = await ensureTraceDir(FALLBACK_TRACE_DIR);
+    const filePath = getTraceFilePath(runId, usable);
+    await writeFile(filePath, "", "utf-8");
+    return filePath;
+  } catch (e) {
+    warn("Failed to initialize trace file on fallback directory", e);
+    return void 0;
+  }
+}
+function ensureEventWithinBounds(event) {
+  const line = serializeEvent(event);
+  if (line === "") return event;
+  const bytes = Buffer.byteLength(line, "utf8");
+  if (bytes <= DEFAULT_MAX_EVENT_BYTES) return event;
+  return prepareTraceEventForDisk(event, resolveTraceSafetyOptions());
+}
+async function writeTraceEvent(event, traceDir) {
+  const bounded = ensureEventWithinBounds(event);
+  if (!validateEvent(bounded)) {
+    warn("Skipped invalid trace event (validation failed)");
+    return;
+  }
+  const line = serializeEvent(bounded);
+  if (line === "") {
+    warn("Skipped trace event (serialization failed)");
+    return;
+  }
+  const payload = `${line}
+`;
+  const tryAppend = async (dir) => {
+    try {
+      const usable = await ensureTraceDir(dir);
+      const filePath = getTraceFilePath(event.runId, usable);
+      await appendFile(filePath, payload, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (await tryAppend(traceDir)) {
+    return;
+  }
+  warn(`Failed to append trace event for run ${event.runId}`);
+  if (await tryAppend(FALLBACK_TRACE_DIR)) {
+    return;
+  }
+  warn("Failed to append trace event to fallback directory");
+}
+async function readTraceFile(runId, traceDir) {
+  try {
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await readFile(filePath, "utf-8");
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return void 0;
+    }
+    warn("Unexpected error reading trace file", e);
+    return void 0;
+  }
+}
+async function readTraceEvents(runId, traceDir) {
+  try {
+    const raw = await readTraceFile(runId, traceDir);
+    if (raw === void 0) {
+      return [];
+    }
+    return parseTraceJsonl(raw, { validate: validateEvent }).events;
+  } catch (e) {
+    warn("Failed to read trace events", e);
+    return [];
+  }
+}
+async function listTraceFiles(traceDir) {
+  try {
+    const usable = path.resolve(traceDir);
+    const names = await readdir(usable);
+    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
+    const withStat = await Promise.all(
+      jsonl.map(async (name) => {
+        try {
+          const st = await stat(path.join(usable, name));
+          return { name, mtime: st.mtimeMs };
+        } catch {
+          return { name, mtime: 0 };
+        }
+      })
+    );
+    withStat.sort((a, b) => {
+      if (b.mtime !== a.mtime) return b.mtime - a.mtime;
+      return a.name.localeCompare(b.name);
+    });
+    return withStat.map((x) => x.name);
+  } catch {
+    return [];
+  }
+}
+function getRunIdFromTraceFileName(fileName) {
+  try {
+    const base = path.basename(fileName);
+    if (!base.endsWith(".jsonl")) return void 0;
+    const id = base.slice(0, -".jsonl".length);
+    return id === "" ? void 0 : id;
+  } catch {
+    return void 0;
+  }
+}
+var storage = new AsyncLocalStorage();
+function toPublicContext(ctx) {
+  return {
+    runId: ctx.runId,
+    runName: ctx.runName,
+    traceDir: ctx.traceDir,
+    silent: ctx.silent,
+    metadata: ctx.metadata
+  };
+}
+function invoke(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function getCurrentContext() {
+  try {
+    const s = storage.getStore();
+    if (!s) return void 0;
+    return toPublicContext(s);
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentRunId() {
+  try {
+    return storage.getStore()?.runId;
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentCorrelationMetadata() {
+  try {
+    return extractCorrelationMetadata(storage.getStore()?.metadata);
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentRunName() {
+  try {
+    return storage.getStore()?.runName;
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentStepId() {
+  try {
+    return storage.getStore()?.currentStepId;
+  } catch {
+    return void 0;
+  }
+}
+function getParentStepId() {
+  return getCurrentStepId();
+}
+function getCurrentDepth() {
+  try {
+    const d = storage.getStore()?.currentDepth;
+    return typeof d === "number" && Number.isFinite(d) ? d : 0;
+  } catch {
+    return 0;
+  }
+}
+function hasActiveContext() {
+  try {
+    return storage.getStore() !== void 0;
+  } catch {
+    return false;
+  }
+}
+function getTraceDirFromContext() {
+  try {
+    return storage.getStore()?.traceDir;
+  } catch {
+    return void 0;
+  }
+}
+function isSilentContext() {
+  try {
+    const s = storage.getStore();
+    return s ? s.silent : false;
+  } catch {
+    return false;
+  }
+}
+function getTraceSafetyFromContext() {
+  try {
+    return storage.getStore()?.traceSafety;
+  } catch {
+    return void 0;
+  }
+}
+function runWithContext(context, fn, traceSafety = resolveTraceSafetyOptions()) {
+  const runtime = {
+    runId: context.runId,
+    runName: context.runName,
+    traceDir: context.traceDir,
+    silent: context.silent,
+    metadata: context.metadata,
+    traceSafety,
+    currentDepth: 0
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(runtime, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+function runWithStepContext(stepId, fn) {
+  let parent;
+  try {
+    parent = storage.getStore();
+  } catch {
+    parent = void 0;
+  }
+  if (!parent) {
+    return invoke(fn);
+  }
+  const derived = {
+    runId: parent.runId,
+    runName: parent.runName,
+    traceDir: parent.traceDir,
+    silent: parent.silent,
+    metadata: parent.metadata,
+    traceSafety: parent.traceSafety,
+    currentStepId: stepId,
+    currentDepth: parent.currentDepth + 1
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(derived, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+
+// packages/core/src/terminal.ts
+var TERMINAL_INDENT = "  ";
+var MAX_TERMINAL_NAME_LENGTH = 80;
+var MAX_TERMINAL_DEPTH = 10;
+function normalizeDepth(depth) {
+  if (!Number.isFinite(depth) || depth < 0) {
+    return 0;
+  }
+  return Math.min(Math.floor(depth), MAX_TERMINAL_DEPTH);
+}
+function safePrint(line = "") {
+  try {
+    console.log(line);
+  } catch {
+  }
+}
+function getIndent(depth) {
+  return TERMINAL_INDENT.repeat(normalizeDepth(depth));
+}
+function formatTerminalName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
+  }
+  return truncateName(name, MAX_TERMINAL_NAME_LENGTH);
+}
+function getStatusIcon(status) {
+  if (status === "success") return source_default.green("\u2714");
+  if (status === "error") return source_default.red("\u2716");
+  return source_default.yellow("\u23F3");
+}
+function renderStepLine(name, durationMs, status, depth) {
+  try {
+    const nm = formatTerminalName(name);
+    const ind = getIndent(depth ?? 0);
+    if (status === "running" && durationMs === void 0) {
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
+    }
+    const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
+    const dur = hasDur ? formatDuration2(durationMs) : void 0;
+    if (status === "running") {
+      return dur !== void 0 ? `${ind}${source_default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${source_default.yellow("\u23F3")} ${nm}`;
+    }
+    if (!hasDur || dur === void 0) {
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
+    }
+    if (status === "success") {
+      return `${ind}${getStatusIcon("success")} ${nm} (${dur})`;
+    }
+    return `${ind}${getStatusIcon("error")} ${nm} (${dur})`;
+  } catch {
+    return "";
+  }
+}
+function renderErrorLine(error, depth) {
+  try {
+    const msg = typeof error.message === "string" ? error.message : "";
+    const ind = getIndent((depth ?? 0) + 1);
+    return `${ind}Error: ${msg}`;
+  } catch {
+    return "";
+  }
+}
+function renderRunSummary(durationMs, status, traceFilePath) {
+  try {
+    const dur = Number.isFinite(durationMs) ? formatDuration2(durationMs) : formatDuration2(0);
+    const head = status === "error" ? `Failed in ${dur}` : `Completed in ${dur}`;
+    const lines = [head];
+    if (traceFilePath !== void 0 && traceFilePath.trim() !== "") {
+      lines.push(`Trace: ${traceFilePath}`);
+    }
+    return lines;
+  } catch {
+    return [];
+  }
+}
+function printRunStart(runId, name) {
+  if (isSilentContext()) return;
+  try {
+    safePrint("");
+    const header = `${source_default.cyan.bold("\u{1F50D} AgentInspect:")} ${formatTerminalName(name)} ${source_default.dim(`(${runId})`)}`;
+    safePrint(header);
+  } catch {
+  }
+}
+function printStepStart(name, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderStepLine(name, void 0, "running", depth));
+  } catch {
+  }
+}
+function printStepComplete(name, durationMs, status, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderStepLine(name, durationMs, status, depth));
+  } catch {
+  }
+}
+function printError(error, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderErrorLine(error, depth));
+  } catch {
+  }
+}
+function printRunComplete(_name, _runId, durationMs, status, traceFilePath) {
+  if (isSilentContext()) return;
+  try {
+    const lines = renderRunSummary(durationMs, status, traceFilePath);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (i === 0) {
+        const color = status === "error" ? source_default.red : status === "running" ? source_default.yellow : source_default.green;
+        safePrint(color(line));
+      } else {
+        safePrint(source_default.dim(line));
+      }
+    }
+  } catch {
+  }
+}
+function printFailedAt(stepName) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(`Failed at: ${formatTerminalName(stepName)}`);
+  } catch {
+  }
+}
+
+export { DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_METADATA_VALUE_LENGTH, DEFAULT_MAX_PREVIEW_LENGTH, DEFAULT_TRACE_DIR_NAME, FALLBACK_TRACE_DIR, MAX_NAME_LENGTH, MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, RUNS_DIR_NAME, TERMINAL_INDENT, createRunId, createStepId, ensureTraceDir, formatDuration2 as formatDuration, formatError, formatTerminalName, formatTimestamp, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getDefaultTraceDir, getIndent, getParentStepId, getRunIdFromTraceFileName, getTraceDirFromContext, getTraceFilePath, getTraceSafetyFromContext, hasActiveContext, initializeTraceFile, isSilentContext, isStepStatus, isStepType, isTraceEvent, listTraceFiles, parseDuration, parseTraceJsonl, prepareMetadataForDisk, prepareTraceEventForDisk, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, readTraceEvents, readTraceFile, renderErrorLine, renderRunSummary, renderStepLine, resolveTraceSafetyOptions, runWithContext, runWithStepContext, serializeEvent, truncateName, unknownTraceFormatMessage, validateEvent, warn, writeTraceEvent };
+//# sourceMappingURL=chunk-XDBND27A.mjs.map
+//# sourceMappingURL=chunk-XDBND27A.mjs.map