@agent-inspect/mcp 6.29.1 → 6.29.2

package/dist/index.cjs

@@ -1,19 +1,6 @@
 '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 nanoid = require('nanoid');
-var chalk = require('chalk');
-
-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 chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var agentInspect = require('agent-inspect');
 
 // packages/mcp/src/summarize.ts
 var DEFAULT_MAX_SUMMARY_LENGTH = 240;
@@ -46,1029 +33,6 @@ function hashServerUrl(url) {
   }
   return hash.toString(16).padStart(8, "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/safety/credential-value-patterns.ts
-var KEY_VALUE_SECRET_PATTERN = /\b(?:api[_-]?key|internal[_-]?token|access[_-]?token|auth[_-]?token|password|secret|token)=([^\s"'\\]{8,})/i;
-var HIGH_CONFIDENCE_CREDENTIAL_PATTERNS = [
-  /^(?:basic|bearer|digest|apikey)\s+[a-z0-9._~+/=-]+$/i,
-  /\bbearer\s+[a-z0-9._~+/=-]{12,}\b/i,
-  /\b[a-z0-9_.-]+=[^;\s]+(?:;\s*[a-z0-9_.-]+=[^;\s]+)+/i,
-  /\beyJ[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\.[a-zA-Z0-9_-]{8,}\b/,
-  /\b(?:sk-(?:proj-)?[a-zA-Z0-9_-]{16,}|sk-ant-[a-zA-Z0-9_-]{16,}|AIza[0-9A-Za-z_-]{20,})\b/,
-  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b/,
-  /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/,
-  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/,
-  KEY_VALUE_SECRET_PATTERN
-];
-function stringContainsHighConfidenceCredential(value) {
-  for (const pattern of HIGH_CONFIDENCE_CREDENTIAL_PATTERNS) {
-    pattern.lastIndex = 0;
-    if (pattern.test(value)) {
-      pattern.lastIndex = 0;
-      return true;
-    }
-  }
-  return false;
-}
-function redactHighConfidenceCredentialsInString(value, replacement = "[REDACTED]") {
-  return stringContainsHighConfidenceCredential(value) ? replacement : 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.ts
-var STEP_TYPES = [
-  "run",
-  "llm",
-  "tool",
-  "decision",
-  "logic",
-  "state",
-  "custom"
-];
-function isStepType(value) {
-  return typeof value === "string" && STEP_TYPES.includes(value);
-}
-
-// 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 createStepId() {
-  return `step_${nanoid.nanoid(10)}`;
-}
-function formatDuration2(ms) {
-  return formatDuration(ms);
-}
-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 isRecord2(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 (!isRecord2(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 (!isRecord2(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 && !isRecord2(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 && !isRecord2(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);
-    }
-    case "outcome_observed": {
-      return nonEmptyString(event.runId) && nonEmptyString(event.outcomeId) && nonEmptyString(event.name) && nonEmptyString(event.expectation) && (event.status === "passed" || event.status === "failed" || event.status === "unknown" || event.status === "skipped") && finiteNumber(event.observedAt);
-    }
-    default:
-      return false;
-  }
-}
-function serializeEvent(event) {
-  try {
-    return JSON.stringify(event);
-  } catch {
-    return "";
-  }
-}
-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 promises.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");
-}
-
-// 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) {
-  let redactEnabled = true;
-  let redactionRules;
-  {
-    redactEnabled = true;
-  }
-  const profile = options?.redactionProfile ?? "local";
-  const resolvedProfile = resolveRedactionProfile(profile);
-  const userMaxMetadata = "undefined" === "number" && Number.isFinite(options.maxMetadataValueLength) && options.maxMetadataValueLength >= 0 ? Math.floor(options.maxMetadataValueLength) : void 0;
-  const userMaxPreview = "undefined" === "number" && Number.isFinite(options.maxPreviewLength) && options.maxPreviewLength >= 0 ? Math.floor(options.maxPreviewLength) : void 0;
-  let maxMetadataValueLength = userMaxMetadata ?? DEFAULT_MAX_METADATA_VALUE_LENGTH;
-  let maxPreviewLength = userMaxPreview ?? DEFAULT_MAX_PREVIEW_LENGTH;
-  if (redactEnabled && profile !== "local") {
-    const capped = applyProfileMetadataCaps(
-      maxMetadataValueLength,
-      maxPreviewLength,
-      resolvedProfile
-    );
-    maxMetadataValueLength = capped.maxMetadataValueLength;
-    maxPreviewLength = capped.maxPreviewLength;
-  }
-  return {
-    redactEnabled,
-    redactionRules,
-    redactionProfile: profile,
-    profileExtraKeys: redactEnabled ? resolvedProfile.extraKeys : [],
-    maxMetadataValueLength,
-    maxPreviewLength,
-    maxEventBytes: "undefined" === "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 prepareTraceEventErrorForDisk(event, opts) {
-  if (event.event !== "run_completed" && event.event !== "step_completed" || !event.error) {
-    return event;
-  }
-  if (!opts.redactEnabled) return event;
-  const redactor = new Redactor({
-    rules: opts.redactionRules,
-    extraKeys: opts.profileExtraKeys
-  });
-  const nextError = { ...event.error };
-  let changed = false;
-  if (typeof nextError.message === "string") {
-    const keyRedacted = redactor.redactValue("message", nextError.message);
-    const message = typeof keyRedacted === "string" ? redactHighConfidenceCredentialsInString(keyRedacted) : "[REDACTED]";
-    if (message !== nextError.message) {
-      nextError.message = message.length > 0 ? message : "Unknown error";
-      changed = true;
-    }
-  }
-  if (typeof nextError.stack === "string") {
-    const scrubbedStack = redactHighConfidenceCredentialsInString(nextError.stack);
-    if (scrubbedStack !== nextError.stack) {
-      nextError.stack = scrubbedStack;
-      changed = true;
-    }
-  }
-  if (!changed) return event;
-  return { ...event, error: nextError };
-}
-function prepareTraceEventForDisk(event, opts) {
-  try {
-    let working = prepareTraceEventErrorForDisk({ ...event }, opts);
-    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;
-  }
-}
-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 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 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 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);
-      }
-    });
-  });
-}
-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 chalk__default.default.green("\u2714");
-  if (status === "error") return chalk__default.default.red("\u2716");
-  return chalk__default.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}${chalk__default.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}${chalk__default.default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
-    }
-    if (!hasDur || dur === void 0) {
-      return `${ind}${chalk__default.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 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 printFailedAt(stepName) {
-  if (isSilentContext()) return;
-  try {
-    safePrint(`Failed at: ${formatTerminalName(stepName)}`);
-  } catch {
-  }
-}
-
-// packages/core/src/step.ts
-function normalizeStepName(name) {
-  if (typeof name !== "string" || name.trim() === "") {
-    return "unnamed-step";
-  }
-  return truncateName(name.trim(), 100);
-}
-async function safeInstrumentation(label, op) {
-  try {
-    await Promise.resolve(op());
-  } catch (e) {
-    warn(`step: ${label}`, e);
-  }
-}
-async function stepImpl(name, fn, options) {
-  if (typeof fn !== "function") {
-    throw new TypeError("step requires `fn` to be a function");
-  }
-  const stepName = normalizeStepName(name);
-  const context = getCurrentContext();
-  if (!context) {
-    warn("step() called outside inspectRun(); executing without instrumentation");
-    return Promise.resolve(fn());
-  }
-  const stepId = createStepId();
-  const renderDepth = getCurrentDepth();
-  const parentId = getParentStepId();
-  const stepType = options?.type ?? "logic";
-  const metadata = options?.metadata;
-  const traceSafety = getTraceSafetyFromContext();
-  const startTime = Date.now();
-  await safeInstrumentation("writeTraceEvent(step_started)", async () => {
-    const started = {
-      schemaVersion: "0.1",
-      event: "step_started",
-      timestamp: startTime,
-      runId: context.runId,
-      stepId,
-      ...typeof parentId === "string" && parentId.trim() !== "" ? { parentId } : {},
-      name: stepName,
-      type: stepType,
-      startTime,
-      ...metadata !== void 0 ? { metadata } : {}
-    };
-    const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(started, traceSafety) : started;
-    await writeTraceEvent(safe, context.traceDir);
-  });
-  await safeInstrumentation("printStepStart", () => {
-    printStepStart(stepName, renderDepth);
-  });
-  let result;
-  try {
-    result = await runWithStepContext(stepId, async () => {
-      return await Promise.resolve(fn());
-    });
-  } catch (userError) {
-    const endTime2 = Date.now();
-    const durationMs2 = endTime2 - startTime;
-    const formatted = formatError(userError);
-    await safeInstrumentation("writeTraceEvent(step_completed error)", async () => {
-      const completed = {
-        schemaVersion: "0.1",
-        event: "step_completed",
-        timestamp: endTime2,
-        runId: context.runId,
-        stepId,
-        status: "error",
-        endTime: endTime2,
-        durationMs: durationMs2,
-        error: formatted
-      };
-      const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
-      await writeTraceEvent(safe, context.traceDir);
-    });
-    await safeInstrumentation("printStepComplete(error)", () => {
-      printStepComplete(stepName, durationMs2, "error", renderDepth);
-    });
-    await safeInstrumentation("printError", () => {
-      printError(formatted, renderDepth);
-    });
-    await safeInstrumentation("printFailedAt", () => {
-      printFailedAt(stepName);
-    });
-    throw userError;
-  }
-  const endTime = Date.now();
-  const durationMs = endTime - startTime;
-  await safeInstrumentation("writeTraceEvent(step_completed success)", async () => {
-    const completed = {
-      schemaVersion: "0.1",
-      event: "step_completed",
-      timestamp: endTime,
-      runId: context.runId,
-      stepId,
-      status: "success",
-      endTime,
-      durationMs
-    };
-    const safe = traceSafety !== void 0 ? prepareTraceEventForDisk(completed, traceSafety) : completed;
-    await writeTraceEvent(safe, context.traceDir);
-  });
-  await safeInstrumentation("printStepComplete(success)", () => {
-    printStepComplete(stepName, durationMs, "success", renderDepth);
-  });
-  return result;
-}
-async function stepLlm(model, fn) {
-  const modelName = typeof model === "string" && model.trim() !== "" ? model.trim() : "unknown-model";
-  return stepImpl(`llm:${modelName}`, fn, {
-    type: "llm",
-    metadata: { model: modelName }
-  });
-}
-async function stepTool(toolName, fn) {
-  const normalized = typeof toolName === "string" && toolName.trim() !== "" ? toolName.trim() : "unknown-tool";
-  return stepImpl(`tool:${normalized}`, fn, {
-    type: "tool",
-    metadata: { toolName: normalized }
-  });
-}
-var step = Object.assign(stepImpl, {
-  llm: stepLlm,
-  tool: stepTool
-});
-
-// packages/mcp/src/wrap.ts
 var toolCallCounter = 0;
 function nextToolCallId(prefix) {
   toolCallCounter += 1;
@@ -1090,7 +54,7 @@ function wrapMcpClient(client, options = {}) {
   const wrapped = { ...client };
   if (typeof client.listTools === "function") {
     const listTools = client.listTools.bind(client);
-    wrapped.listTools = async (params) => step(
+    wrapped.listTools = async (params) => agentInspect.step(
       "mcp:tools/list",
       async () => {
         const result = await listTools(params);
@@ -1106,7 +70,7 @@ function wrapMcpClient(client, options = {}) {
     );
   }
   const callTool = client.callTool.bind(client);
-  wrapped.callTool = async (params) => step(
+  wrapped.callTool = async (params) => agentInspect.step(
     `mcp:${params.name}`,
     async () => callTool(params),
     {