agent-inspect 1.4.0 → 1.6.0

package/packages/core/dist/advanced.cjs

@@ -0,0 +1,2258 @@
+'use strict';
+
+var async_hooks = require('async_hooks');
+var crypto = require('crypto');
+var promises = require('fs/promises');
+var path = require('path');
+var os = require('os');
+var process2 = require('process');
+var tty = require('tty');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var tty__default = /*#__PURE__*/_interopDefault(tty);
+
+// packages/core/src/context.ts
+
+// packages/core/src/correlation-metadata.ts
+var TRACE_CORRELATION_KEYS = [
+  "correlationId",
+  "requestId",
+  "decisionId",
+  "groupId"
+];
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function extractCorrelationMetadata(record) {
+  if (!record) {
+    return void 0;
+  }
+  const out = {};
+  let found = false;
+  for (const key of TRACE_CORRELATION_KEYS) {
+    const value = record[key];
+    if (isNonEmptyString(value)) {
+      out[key] = value;
+      found = true;
+    }
+  }
+  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__default.default.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 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 };
+}
+
+// packages/core/src/types/persisted-inspect-event.ts
+var INSPECT_KINDS = [
+  "RUN",
+  "AGENT",
+  "LLM",
+  "TOOL",
+  "CHAIN",
+  "RETRIEVER",
+  "DECISION",
+  "RESULT",
+  "ERROR",
+  "LOGIC",
+  "LOG"
+];
+var ATTRIBUTION_CONFIDENCES = [
+  "explicit",
+  "correlated",
+  "heuristic",
+  "unknown"
+];
+var PERSISTED_EVENT_SOURCE_TYPES = [
+  "manual",
+  "json-log",
+  "log4js",
+  "adapter",
+  "ai-sdk",
+  "otel"
+];
+var PERSISTED_EVENT_STATUSES = [
+  "running",
+  "ok",
+  "error",
+  "unknown"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isOptionalString(value) {
+  return value === void 0 || isString(value);
+}
+function isNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isOptionalNonNegativeNumber(value) {
+  return value === void 0 || isNonNegativeNumber(value);
+}
+function isInspectKind(value) {
+  return typeof value === "string" && INSPECT_KINDS.includes(value);
+}
+function isAttributionConfidence(value) {
+  return typeof value === "string" && ATTRIBUTION_CONFIDENCES.includes(value);
+}
+function isPersistedEventSourceType(value) {
+  return typeof value === "string" && PERSISTED_EVENT_SOURCE_TYPES.includes(value);
+}
+function isPersistedEventStatus(value) {
+  return typeof value === "string" && PERSISTED_EVENT_STATUSES.includes(value);
+}
+function isPersistedEventSource(value) {
+  if (!isRecord2(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 (!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 (!isOptionalNonNegativeNumber(value.input)) return false;
+  if (!isOptionalNonNegativeNumber(value.output)) return false;
+  if (!isOptionalNonNegativeNumber(value.total)) return false;
+  if (!isOptionalNonNegativeNumber(value.cached)) return false;
+  return true;
+}
+function isPersistedTraceContext(value) {
+  if (!isRecord2(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 (value.schemaVersion !== "0.2") return false;
+  if (!isNonEmptyString2(value.eventId)) return false;
+  if (!isNonEmptyString2(value.runId)) return false;
+  if (!isInspectKind(value.kind)) return false;
+  if (!isNonEmptyString2(value.name)) return false;
+  if (!isNonEmptyString2(value.timestamp)) return false;
+  if (!isAttributionConfidence(value.confidence)) return false;
+  if (!isPersistedEventSource(value.source)) return false;
+  if (value.parentId !== void 0 && !isNonEmptyString2(value.parentId)) {
+    return false;
+  }
+  if (value.status !== void 0 && !isPersistedEventStatus(value.status)) {
+    return false;
+  }
+  if (!isOptionalString(value.startedAt)) return false;
+  if (!isOptionalString(value.endedAt)) return false;
+  if (value.durationMs !== void 0 && !isNonNegativeNumber(value.durationMs)) {
+    return false;
+  }
+  if (value.attributes !== void 0 && !isRecord2(value.attributes)) {
+    return false;
+  }
+  if (value.error !== void 0 && !isPersistedInspectError(value.error)) {
+    return false;
+  }
+  if (value.tokenUsage !== void 0 && !isPersistedTokenUsage(value.tokenUsage)) {
+    return false;
+  }
+  if (value.trace !== void 0 && !isPersistedTraceContext(value.trace)) {
+    return false;
+  }
+  return true;
+}
+
+// node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/.pnpm/nanoid@5.1.11/node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (bytes < 0 || bytes > 1024) throw new RangeError("Wrong ID size");
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.webcrypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// packages/core/src/utils/duration.ts
+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";
+var RUNS_DIR_NAME = "runs";
+var FALLBACK_TRACE_DIR = path__default.default.join(
+  os__default.default.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__default.default.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path__default.default.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__default.default.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path__default.default.join(baseDir, `${safeId}.jsonl`);
+}
+async function ensureTraceDir(traceDir) {
+  const primary = path__default.default.resolve(traceDir);
+  try {
+    await promises.mkdir(primary, { recursive: true });
+    return primary;
+  } catch {
+    warn(`Failed to create trace directory: ${primary}`);
+    const fallback = path__default.default.resolve(FALLBACK_TRACE_DIR);
+    try {
+      await promises.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/storage.ts
+function serializeEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return "";
+  }
+}
+
+// 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 (typeof value === "bigint") {
+    return `${value.toString()}n`;
+  }
+  if (typeof value === "function") {
+    return "[Function]";
+  }
+  if (typeof value === "symbol") {
+    return "[Symbol]";
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
+  }
+  if (value === void 0) {
+    return null;
+  }
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "string") {
+      const max = 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 = {};
+  try {
+    for (const [k, v] of Object.entries(record)) {
+      out[k] = boundMetadataValue(k, v, opts, seen, depth + 1);
+    }
+  } catch {
+    return { truncated: true, reason: "metadataEnumerationFailed" };
+  }
+  return out;
+}
+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 preBounded = boundMetadataValue(
+      "metadata",
+      metadata,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const redacted = redactMetadata(
+      isRecord3(preBounded) ? preBounded : {},
+      opts
+    );
+    const bounded = boundMetadataValue(
+      "metadata",
+      redacted,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      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;
+  }
+}
+function safeGet(record, key) {
+  try {
+    return record[key];
+  } catch {
+    return void 0;
+  }
+}
+function optionalBoundedString(value, _key, opts) {
+  if (typeof value !== "string") return void 0;
+  return truncateString(value, opts.maxMetadataValueLength);
+}
+function requiredBoundedString(value, key, opts) {
+  const out = optionalBoundedString(value, key, opts);
+  return out && out.length > 0 ? out : void 0;
+}
+function preparePersistedSummaryForDisk(key, value, opts) {
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const redacted = opts.redactEnabled ? redactor.redactValue(key, value) : value;
+    return boundMetadataValue(key, redacted, opts, /* @__PURE__ */ new WeakSet(), 0);
+  } catch {
+    return { truncated: true, reason: "summaryPreparationFailed" };
+  }
+}
+function preparePersistedErrorForDisk(value, opts) {
+  if (!isRecord3(value)) return void 0;
+  try {
+    const redactor = new Redactor({
+      rules: opts.redactionRules,
+      extraKeys: opts.profileExtraKeys
+    });
+    const rawMessage = safeGet(value, "message");
+    const redactedMessage = opts.redactEnabled ? redactor.redactValue("message", rawMessage) : rawMessage;
+    const boundedMessage = boundMetadataValue(
+      "message",
+      redactedMessage,
+      opts,
+      /* @__PURE__ */ new WeakSet(),
+      0
+    );
+    const message = typeof boundedMessage === "string" && boundedMessage.length > 0 ? boundedMessage : "Unknown error";
+    const out = { message };
+    const name = optionalBoundedString(safeGet(value, "name"), "name", opts);
+    const code = optionalBoundedString(safeGet(value, "code"), "code", opts);
+    if (name !== void 0) out.name = name;
+    if (code !== void 0) out.code = code;
+    return out;
+  } catch {
+    return { message: "Error preparation failed" };
+  }
+}
+function prepareTokenUsage(value) {
+  if (!isRecord3(value)) return void 0;
+  const out = {};
+  for (const key of ["input", "output", "total", "cached"]) {
+    const item = safeGet(value, key);
+    if (typeof item === "number" && Number.isFinite(item) && item >= 0) {
+      out[key] = item;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function prepareTraceContext(value, opts) {
+  if (!isRecord3(value)) return void 0;
+  const out = {};
+  const traceId = optionalBoundedString(safeGet(value, "traceId"), "traceId", opts);
+  const spanId = optionalBoundedString(safeGet(value, "spanId"), "spanId", opts);
+  const parentSpanId = optionalBoundedString(
+    safeGet(value, "parentSpanId"),
+    "parentSpanId",
+    opts
+  );
+  if (traceId !== void 0) out.traceId = traceId;
+  if (spanId !== void 0) out.spanId = spanId;
+  if (parentSpanId !== void 0) out.parentSpanId = parentSpanId;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function serializedPersistedEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return void 0;
+  }
+}
+function persistedEventByteLength(event) {
+  const serialized = serializedPersistedEvent(event);
+  return serialized === void 0 ? void 0 : byteLength(serialized);
+}
+function minimalPersistedEvent(event, opts, originalApproxBytes) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 128),
+    runId: truncateString(event.runId, 128),
+    kind: event.kind,
+    name: truncateString(event.name, 128),
+    ...event.status !== void 0 ? { status: event.status } : {},
+    timestamp: truncateString(event.timestamp, 128),
+    confidence: event.confidence,
+    source: {
+      type: event.source.type,
+      ...event.source.name !== void 0 ? { name: truncateString(event.source.name, 128) } : {},
+      ...event.source.version !== void 0 ? { version: truncateString(event.source.version, 128) } : {}
+    },
+    attributes: {
+      truncated: true,
+      reason: "maxEventBytes",
+      originalApproxBytes,
+      maxEventBytes: opts.maxEventBytes
+    }
+  };
+}
+function tinyPersistedEvent(event) {
+  return {
+    schemaVersion: "0.2",
+    eventId: truncateString(event.eventId, 32),
+    runId: truncateString(event.runId, 32),
+    kind: event.kind,
+    name: truncateString(event.name, 32),
+    timestamp: truncateString(event.timestamp, 32),
+    confidence: event.confidence,
+    source: { type: event.source.type },
+    attributes: { truncated: true, reason: "maxEventBytes" }
+  };
+}
+function enforcePersistedEventSize(event, opts) {
+  const bytes = persistedEventByteLength(event);
+  if (bytes === void 0) return void 0;
+  if (bytes <= opts.maxEventBytes) return event;
+  const minimal = minimalPersistedEvent(event, opts, bytes);
+  const minimalBytes = persistedEventByteLength(minimal);
+  if (minimalBytes !== void 0 && minimalBytes <= opts.maxEventBytes) {
+    return minimal;
+  }
+  const tiny = tinyPersistedEvent(event);
+  return isPersistedInspectEvent(tiny) ? tiny : void 0;
+}
+function preparePersistedInspectEventForWrite(value, opts = resolveTraceSafetyOptions()) {
+  try {
+    if (!isRecord3(value)) return void 0;
+    const source = safeGet(value, "source");
+    if (!isRecord3(source)) return void 0;
+    const candidate = {
+      schemaVersion: safeGet(value, "schemaVersion"),
+      eventId: requiredBoundedString(safeGet(value, "eventId"), "eventId", opts) ?? "",
+      runId: requiredBoundedString(safeGet(value, "runId"), "runId", opts) ?? "",
+      kind: safeGet(value, "kind"),
+      name: requiredBoundedString(safeGet(value, "name"), "name", opts) ?? "",
+      timestamp: requiredBoundedString(safeGet(value, "timestamp"), "timestamp", opts) ?? "",
+      confidence: safeGet(value, "confidence"),
+      source: {
+        type: safeGet(source, "type")
+      }
+    };
+    const parentId = requiredBoundedString(safeGet(value, "parentId"), "parentId", opts);
+    const status = safeGet(value, "status");
+    const startedAt = optionalBoundedString(safeGet(value, "startedAt"), "startedAt", opts);
+    const endedAt = optionalBoundedString(safeGet(value, "endedAt"), "endedAt", opts);
+    const durationMs2 = safeGet(value, "durationMs");
+    const sourceName = optionalBoundedString(safeGet(source, "name"), "name", opts);
+    const sourceVersion = optionalBoundedString(safeGet(source, "version"), "version", opts);
+    if (parentId !== void 0) candidate.parentId = parentId;
+    if (status === "running" || status === "ok" || status === "error" || status === "unknown") {
+      candidate.status = status;
+    }
+    if (startedAt !== void 0) candidate.startedAt = startedAt;
+    if (endedAt !== void 0) candidate.endedAt = endedAt;
+    if (typeof durationMs2 === "number" && Number.isFinite(durationMs2) && durationMs2 >= 0) {
+      candidate.durationMs = durationMs2;
+    }
+    if (sourceName !== void 0) candidate.source.name = sourceName;
+    if (sourceVersion !== void 0) candidate.source.version = sourceVersion;
+    const attributes = safeGet(value, "attributes");
+    if (isRecord3(attributes)) {
+      candidate.attributes = prepareMetadataForDisk(attributes, opts);
+    }
+    if (safeGet(value, "inputSummary") !== void 0) {
+      candidate.inputSummary = preparePersistedSummaryForDisk(
+        "input",
+        safeGet(value, "inputSummary"),
+        opts
+      );
+    }
+    if (safeGet(value, "outputSummary") !== void 0) {
+      candidate.outputSummary = preparePersistedSummaryForDisk(
+        "output",
+        safeGet(value, "outputSummary"),
+        opts
+      );
+    }
+    const error = preparePersistedErrorForDisk(safeGet(value, "error"), opts);
+    if (error !== void 0) candidate.error = error;
+    const tokenUsage = prepareTokenUsage(safeGet(value, "tokenUsage"));
+    if (tokenUsage !== void 0) candidate.tokenUsage = tokenUsage;
+    const trace = prepareTraceContext(safeGet(value, "trace"), opts);
+    if (trace !== void 0) candidate.trace = trace;
+    if (!isPersistedInspectEvent(candidate)) return void 0;
+    return enforcePersistedEventSize(candidate, opts);
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/src/context.ts
+var storage = new async_hooks.AsyncLocalStorage();
+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);
+      }
+    });
+  });
+}
+function invoke2(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+function normalizeError(error) {
+  if (error instanceof Error && error.message.trim() !== "") {
+    return error.message;
+  }
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
+  }
+  return "Unknown inspector runtime error";
+}
+var runtimeSequence = 0;
+function createRuntimeId() {
+  runtimeSequence += 1;
+  return `runtime_${runtimeSequence.toString(36)}`;
+}
+function publicContext(store) {
+  return {
+    runtimeId: store.runtimeId,
+    runId: store.runId,
+    runName: store.runName,
+    traceDir: store.traceDir,
+    silent: store.silent,
+    metadata: store.metadata
+  };
+}
+function createInspectorRuntime(options = {}) {
+  const storage2 = new async_hooks.AsyncLocalStorage();
+  const enabled = options.enabled ?? true;
+  const runtimeId = createRuntimeId();
+  const traceSafety = options.traceSafety ?? resolveTraceSafetyOptions();
+  let closed = false;
+  let instrumentationErrors = 0;
+  let lastInstrumentationError;
+  function recordInstrumentationError(error) {
+    instrumentationErrors += 1;
+    lastInstrumentationError = normalizeError(error);
+  }
+  function currentStore() {
+    try {
+      return storage2.getStore();
+    } catch (error) {
+      recordInstrumentationError(error);
+      return void 0;
+    }
+  }
+  const runtime = {
+    runtimeId,
+    enabled,
+    runWithContext(context, fn) {
+      if (!enabled) return invoke2(fn);
+      const store = {
+        runtimeId,
+        runId: context.runId,
+        runName: context.runName,
+        traceDir: context.traceDir,
+        silent: context.silent,
+        metadata: context.metadata,
+        traceSafety,
+        currentDepth: 0
+      };
+      return new Promise((resolve, reject) => {
+        storage2.run(store, () => {
+          invoke2(fn).then(resolve, reject);
+        });
+      });
+    },
+    runWithStepContext(stepId, fn) {
+      if (!enabled) return invoke2(fn);
+      const parent = currentStore();
+      if (!parent) return invoke2(fn);
+      const store = {
+        runtimeId,
+        runId: parent.runId,
+        runName: parent.runName,
+        traceDir: parent.traceDir,
+        silent: parent.silent,
+        metadata: parent.metadata,
+        traceSafety: parent.traceSafety,
+        currentStepId: stepId,
+        currentDepth: parent.currentDepth + 1
+      };
+      return new Promise((resolve, reject) => {
+        storage2.run(store, () => {
+          invoke2(fn).then(resolve, reject);
+        });
+      });
+    },
+    getCurrentContext() {
+      const store = currentStore();
+      return store ? publicContext(store) : void 0;
+    },
+    getCurrentCorrelationMetadata() {
+      return extractCorrelationMetadata(currentStore()?.metadata);
+    },
+    getCurrentStepId() {
+      return currentStore()?.currentStepId;
+    },
+    getCurrentDepth() {
+      const depth = currentStore()?.currentDepth;
+      return typeof depth === "number" && Number.isFinite(depth) ? depth : 0;
+    },
+    getTraceSafety() {
+      return traceSafety;
+    },
+    async write(event) {
+      if (!enabled || closed || !options.writer) return;
+      try {
+        const safe = preparePersistedInspectEventForWrite(event, traceSafety);
+        if (safe === void 0) {
+          recordInstrumentationError("Invalid persisted inspect event");
+          return;
+        }
+        await options.writer.write(safe);
+      } catch (error) {
+        recordInstrumentationError(error);
+      }
+    },
+    async flush() {
+      if (!options.writer) return;
+      try {
+        await options.writer.flush?.();
+      } catch (error) {
+        recordInstrumentationError(error);
+      }
+    },
+    async close() {
+      if (closed) return;
+      try {
+        await options.writer?.close?.();
+      } catch (error) {
+        recordInstrumentationError(error);
+      } finally {
+        closed = true;
+      }
+    },
+    getDiagnostics() {
+      const diagnostics = {
+        instrumentationErrors
+      };
+      if (lastInstrumentationError !== void 0) {
+        diagnostics.lastInstrumentationError = lastInstrumentationError;
+      }
+      const writerStats = options.writer?.getStats?.();
+      if (writerStats !== void 0) {
+        diagnostics.writerStats = writerStats;
+      }
+      return diagnostics;
+    }
+  };
+  return runtime;
+}
+
+// packages/core/src/inspector.ts
+function normalizeName(name, fallback) {
+  if (typeof name !== "string" || name.trim() === "") return fallback;
+  return truncateName(name.trim(), 100);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function durationMs(startedAt, endedAt) {
+  return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
+}
+function mergeMetadata(base, override) {
+  if (base === void 0 && override === void 0) return void 0;
+  return {
+    ...base ?? {},
+    ...override ?? {}
+  };
+}
+function toPersistedError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message
+    };
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  return { message: "Unknown error" };
+}
+function summarizeValue(value) {
+  if (value === null) return { type: "null" };
+  if (Array.isArray(value)) return { type: "array", length: value.length };
+  if (typeof value === "string") return { type: "string", length: value.length };
+  if (typeof value === "number") {
+    return { type: "number", finite: Number.isFinite(value) };
+  }
+  if (typeof value === "bigint") return { type: "bigint" };
+  if (typeof value === "boolean") return { type: "boolean" };
+  if (typeof value === "undefined") return { type: "undefined" };
+  if (typeof value === "symbol") return { type: "symbol" };
+  if (typeof value === "function") {
+    return { type: "function", name: value.name || void 0 };
+  }
+  if (typeof value === "object") {
+    const record = value;
+    let keyCount;
+    try {
+      keyCount = Object.keys(record).length;
+    } catch {
+      keyCount = void 0;
+    }
+    return {
+      type: "object",
+      constructorName: value?.constructor?.name,
+      ...keyCount !== void 0 ? { keyCount } : {}
+    };
+  }
+  return { type: typeof value };
+}
+function summarizeCapturedError(error) {
+  if (error instanceof Error) {
+    return { type: "error", name: error.name };
+  }
+  return summarizeValue(error);
+}
+function stepTypeToKind(type) {
+  switch (type) {
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "decision":
+      return "DECISION";
+    case "run":
+      return "RUN";
+    default:
+      return "LOGIC";
+  }
+}
+function createInspector(options = {}) {
+  const traceSafety = options.traceSafety ?? resolveTraceSafetyOptions({
+    redactionProfile: options.redactionProfile
+  });
+  const runtime = createInspectorRuntime({
+    enabled: options.enabled,
+    writer: options.writer,
+    traceSafety
+  });
+  async function write(event) {
+    const safe = preparePersistedInspectEventForWrite(event, traceSafety);
+    if (safe !== void 0) {
+      await runtime.write(safe);
+    }
+  }
+  async function run(name, fn, runOptions = {}) {
+    if (typeof fn !== "function") {
+      throw new TypeError("inspector.run requires `fn` to be a function");
+    }
+    if (options.enabled === false) {
+      return Promise.resolve(fn());
+    }
+    const runName = normalizeName(name, "unnamed-run");
+    const runId = runOptions.runId ?? createRunId();
+    const traceDir = runOptions.traceDir ?? options.traceDir ?? getDefaultTraceDir();
+    const metadata = mergeMetadata(options.metadata, runOptions.metadata);
+    const startedAt = nowIso();
+    return runtime.runWithContext(
+      {
+        runId,
+        runName,
+        traceDir,
+        silent: runOptions.silent ?? options.silent ?? true,
+        metadata
+      },
+      async () => {
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${runId}_started`,
+          runId,
+          kind: "RUN",
+          name: runName,
+          status: "running",
+          timestamp: startedAt,
+          startedAt,
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "run_started",
+            ...metadata !== void 0 ? { metadata } : {}
+          }
+        });
+        try {
+          const result = await Promise.resolve(fn());
+          const endedAt = nowIso();
+          await write({
+            schemaVersion: "0.2",
+            eventId: `${runId}_completed`,
+            runId,
+            kind: "RUN",
+            name: runName,
+            status: "ok",
+            timestamp: endedAt,
+            endedAt,
+            durationMs: durationMs(startedAt, endedAt),
+            confidence: "explicit",
+            source: { type: "manual", name: "createInspector" },
+            attributes: { legacyEvent: "run_completed" },
+            ...options.capture?.onSuccess === "metadata-only" ? { outputSummary: summarizeValue(result) } : {}
+          });
+          return result;
+        } catch (error) {
+          const endedAt = nowIso();
+          await write({
+            schemaVersion: "0.2",
+            eventId: `${runId}_completed`,
+            runId,
+            kind: "RUN",
+            name: runName,
+            status: "error",
+            timestamp: endedAt,
+            endedAt,
+            durationMs: durationMs(startedAt, endedAt),
+            confidence: "explicit",
+            source: { type: "manual", name: "createInspector" },
+            attributes: { legacyEvent: "run_completed" },
+            ...options.capture?.onError === "metadata-only" ? { outputSummary: summarizeCapturedError(error) } : {},
+            error: toPersistedError(error)
+          });
+          throw error;
+        }
+      }
+    );
+  }
+  async function step(name, fn, stepOptions = {}) {
+    if (typeof fn !== "function") {
+      throw new TypeError("inspector.step requires `fn` to be a function");
+    }
+    if (options.enabled === false || !runtime.getCurrentContext()) {
+      return Promise.resolve(fn());
+    }
+    const context = runtime.getCurrentContext();
+    const stepName = normalizeName(name, "unnamed-step");
+    const stepId = createStepId();
+    const parentId = runtime.getCurrentStepId();
+    const stepType = stepOptions.type ?? "logic";
+    const startedAt = nowIso();
+    const attributes = {
+      legacyEvent: "step_started",
+      stepId,
+      stepType,
+      ...stepOptions.metadata !== void 0 ? { metadata: stepOptions.metadata } : {}
+    };
+    await write({
+      schemaVersion: "0.2",
+      eventId: `${stepId}_started`,
+      runId: context.runId,
+      ...parentId !== void 0 ? { parentId } : {},
+      kind: stepTypeToKind(stepType),
+      name: stepName,
+      status: "running",
+      timestamp: startedAt,
+      startedAt,
+      confidence: "explicit",
+      source: { type: "manual", name: "createInspector" },
+      attributes
+    });
+    return runtime.runWithStepContext(stepId, async () => {
+      try {
+        const result = await Promise.resolve(fn());
+        const endedAt = nowIso();
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${stepId}_completed`,
+          runId: context.runId,
+          kind: stepTypeToKind(stepType),
+          name: stepName,
+          status: "ok",
+          timestamp: endedAt,
+          endedAt,
+          durationMs: durationMs(startedAt, endedAt),
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "step_completed",
+            stepId,
+            stepType
+          },
+          ...options.capture?.onSuccess === "metadata-only" ? { outputSummary: summarizeValue(result) } : {}
+        });
+        return result;
+      } catch (error) {
+        const endedAt = nowIso();
+        await write({
+          schemaVersion: "0.2",
+          eventId: `${stepId}_completed`,
+          runId: context.runId,
+          kind: stepTypeToKind(stepType),
+          name: stepName,
+          status: "error",
+          timestamp: endedAt,
+          endedAt,
+          durationMs: durationMs(startedAt, endedAt),
+          confidence: "explicit",
+          source: { type: "manual", name: "createInspector" },
+          attributes: {
+            legacyEvent: "step_completed",
+            stepId,
+            stepType
+          },
+          ...options.capture?.onError === "metadata-only" ? { outputSummary: summarizeCapturedError(error) } : {},
+          error: toPersistedError(error)
+        });
+        throw error;
+      }
+    });
+  }
+  const inspector = {
+    runtime,
+    run,
+    step,
+    tool(name, fn, toolOptions) {
+      const toolName = normalizeName(name, "unknown-tool");
+      return step(`tool:${toolName}`, fn, {
+        ...toolOptions,
+        type: "tool",
+        metadata: {
+          ...toolOptions?.metadata ?? {},
+          toolName
+        }
+      });
+    },
+    llm(name, fn, llmOptions) {
+      const model = normalizeName(name, "unknown-model");
+      return step(`llm:${model}`, fn, {
+        ...llmOptions,
+        type: "llm",
+        metadata: {
+          ...llmOptions?.metadata ?? {},
+          model
+        }
+      });
+    },
+    observe(name, fn, observeOptions) {
+      return async (...args) => step(name, () => Promise.resolve(fn(...args)), observeOptions);
+    },
+    getDiagnostics() {
+      return runtime.getDiagnostics();
+    },
+    flush() {
+      return runtime.flush();
+    },
+    close() {
+      return runtime.close();
+    }
+  };
+  return inspector;
+}
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2__default.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2__default.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2__default.default.platform === "win32") {
+    const osRelease = os__default.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty__default.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty__default.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// 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, durationMs2, status, depth) {
+  try {
+    const nm = formatTerminalName(name);
+    const ind = getIndent(depth ?? 0);
+    if (status === "running" && durationMs2 === void 0) {
+      return `${ind}${source_default.yellow("\u23F3")} ${nm}`;
+    }
+    const hasDur = durationMs2 !== void 0 && Number.isFinite(durationMs2);
+    const dur = hasDur ? formatDuration2(durationMs2) : void 0;
+    if (status === "running") {
+      return dur !== void 0 ? `${ind}${source_default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${source_default.yellow("\u23F3")} ${nm}`;
+    }
+    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(durationMs2, status, traceFilePath) {
+  try {
+    const dur = Number.isFinite(durationMs2) ? formatDuration2(durationMs2) : formatDuration2(0);
+    const head = status === "error" ? `Failed in ${dur}` : `Completed in ${dur}`;
+    const lines = [head];
+    if (traceFilePath !== void 0 && traceFilePath.trim() !== "") {
+      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, durationMs2, status, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderStepLine(name, durationMs2, status, depth));
+  } catch {
+  }
+}
+function printError(error, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderErrorLine(error, depth));
+  } catch {
+  }
+}
+function printRunComplete(_name, _runId, durationMs2, status, traceFilePath) {
+  if (isSilentContext()) return;
+  try {
+    const lines = renderRunSummary(durationMs2, 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 {
+  }
+}
+
+exports.DEFAULT_MAX_EVENT_BYTES = DEFAULT_MAX_EVENT_BYTES;
+exports.DEFAULT_MAX_METADATA_VALUE_LENGTH = DEFAULT_MAX_METADATA_VALUE_LENGTH;
+exports.DEFAULT_MAX_PREVIEW_LENGTH = DEFAULT_MAX_PREVIEW_LENGTH;
+exports.DEFAULT_TRACE_DIR_NAME = DEFAULT_TRACE_DIR_NAME;
+exports.FALLBACK_TRACE_DIR = FALLBACK_TRACE_DIR;
+exports.MAX_NAME_LENGTH = MAX_NAME_LENGTH;
+exports.MAX_TERMINAL_DEPTH = MAX_TERMINAL_DEPTH;
+exports.MAX_TERMINAL_NAME_LENGTH = MAX_TERMINAL_NAME_LENGTH;
+exports.RUNS_DIR_NAME = RUNS_DIR_NAME;
+exports.TERMINAL_INDENT = TERMINAL_INDENT;
+exports.createInspector = createInspector;
+exports.createInspectorRuntime = createInspectorRuntime;
+exports.createRunId = createRunId;
+exports.createStepId = createStepId;
+exports.ensureTraceDir = ensureTraceDir;
+exports.formatDuration = formatDuration2;
+exports.formatError = formatError;
+exports.formatTerminalName = formatTerminalName;
+exports.formatTimestamp = formatTimestamp;
+exports.getCurrentContext = getCurrentContext;
+exports.getCurrentCorrelationMetadata = getCurrentCorrelationMetadata;
+exports.getCurrentDepth = getCurrentDepth;
+exports.getCurrentRunId = getCurrentRunId;
+exports.getCurrentRunName = getCurrentRunName;
+exports.getCurrentStepId = getCurrentStepId;
+exports.getDefaultTraceDir = getDefaultTraceDir;
+exports.getIndent = getIndent;
+exports.getParentStepId = getParentStepId;
+exports.getTraceDirFromContext = getTraceDirFromContext;
+exports.getTraceFilePath = getTraceFilePath;
+exports.getTraceSafetyFromContext = getTraceSafetyFromContext;
+exports.hasActiveContext = hasActiveContext;
+exports.isSilentContext = isSilentContext;
+exports.prepareMetadataForDisk = prepareMetadataForDisk;
+exports.prepareTraceEventForDisk = prepareTraceEventForDisk;
+exports.printError = printError;
+exports.printFailedAt = printFailedAt;
+exports.printRunComplete = printRunComplete;
+exports.printRunStart = printRunStart;
+exports.printStepComplete = printStepComplete;
+exports.printStepStart = printStepStart;
+exports.renderErrorLine = renderErrorLine;
+exports.renderRunSummary = renderRunSummary;
+exports.renderStepLine = renderStepLine;
+exports.resolveRedactionProfile = resolveRedactionProfile;
+exports.resolveTraceSafetyOptions = resolveTraceSafetyOptions;
+exports.runWithContext = runWithContext;
+exports.runWithStepContext = runWithStepContext;
+exports.truncateName = truncateName;
+exports.warn = warn;
+//# sourceMappingURL=advanced.cjs.map
+//# sourceMappingURL=advanced.cjs.map