@agent-inspect/mcp 2.4.0

package/dist/index.mjs

@@ -0,0 +1,1056 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import crypto from 'crypto';
+import { appendFile, mkdir } from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { nanoid } from 'nanoid';
+import chalk from 'chalk';
+
+// packages/mcp/src/summarize.ts
+var DEFAULT_MAX_SUMMARY_LENGTH = 240;
+function summarizeMcpValue(value, maxLength = DEFAULT_MAX_SUMMARY_LENGTH) {
+  let text;
+  try {
+    if (typeof value === "string") {
+      text = value;
+    } else {
+      text = JSON.stringify(value);
+    }
+  } catch {
+    text = String(value);
+  }
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function hashServerUrl(url) {
+  let hash = 0;
+  for (let i = 0; i < url.length; i += 1) {
+    hash = hash * 31 + url.charCodeAt(i) >>> 0;
+  }
+  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.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.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.join(
+  os.tmpdir(),
+  "agent-inspect",
+  RUNS_DIR_NAME
+);
+var MAX_NAME_LENGTH = 100;
+function createStepId() {
+  return `step_${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.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+  } catch {
+    return FALLBACK_TRACE_DIR;
+  }
+}
+function getTraceFilePath(runId, traceDir) {
+  const baseDir = traceDir ?? getDefaultTraceDir();
+  let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safeId = path.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path.join(baseDir, `${safeId}.jsonl`);
+}
+async function ensureTraceDir(traceDir) {
+  const primary = path.resolve(traceDir);
+  try {
+    await mkdir(primary, { recursive: true });
+    return primary;
+  } catch {
+    warn(`Failed to create trace directory: ${primary}`);
+    const fallback = path.resolve(FALLBACK_TRACE_DIR);
+    try {
+      await mkdir(fallback, { recursive: true });
+      return fallback;
+    } catch {
+      warn(`Failed to create fallback trace directory: ${fallback}`);
+      return primary;
+    }
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const out = { message: error.message };
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+      out.stack = error.stack;
+    }
+    return out;
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (error === null) {
+    return { message: "Unknown error: null" };
+  }
+  if (error === void 0) {
+    return { message: "Unknown error: undefined" };
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "object") {
+    try {
+      return { message: JSON.stringify(error) };
+    } catch {
+      return { message: "Unknown error" };
+    }
+  }
+  return { message: "Unknown error" };
+}
+function truncateName(name, maxLength = MAX_NAME_LENGTH) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
+  }
+  const trimmed = name.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  const ellipsis = "...";
+  const head = Math.max(0, maxLength - ellipsis.length);
+  return `${trimmed.slice(0, head)}${ellipsis}`;
+}
+function warn(message, error) {
+  const base = `[AgentInspect] ${message}`;
+  if (error === void 0) {
+    console.warn(base);
+    return;
+  }
+  console.warn(`${base}: ${formatError(error).message}`);
+}
+
+// packages/core/src/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);
+    }
+    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 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 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;
+  }
+}
+var storage = new AsyncLocalStorage();
+function toPublicContext(ctx) {
+  return {
+    runId: ctx.runId,
+    runName: ctx.runName,
+    traceDir: ctx.traceDir,
+    silent: ctx.silent,
+    metadata: ctx.metadata
+  };
+}
+function invoke(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function getCurrentContext() {
+  try {
+    const s = storage.getStore();
+    if (!s) return void 0;
+    return toPublicContext(s);
+  } catch {
+    return void 0;
+  }
+}
+function 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.green("\u2714");
+  if (status === "error") return chalk.red("\u2716");
+  return chalk.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.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.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk.yellow("\u23F3")} ${nm}`;
+    }
+    if (!hasDur || dur === void 0) {
+      return `${ind}${chalk.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;
+  const base = prefix?.trim() || "mcp";
+  return `${base}-${toolCallCounter}`;
+}
+function baseMetadata(options, overrides = {}) {
+  const metadata = {
+    source: { type: "mcp-client" },
+    ...options.serverName ? { mcpServerName: options.serverName } : {},
+    ...options.serverUrl ? { mcpServerUrlHash: hashServerUrl(options.serverUrl) } : {},
+    ...options.sessionId ? { sessionId: options.sessionId } : {},
+    ...overrides
+  };
+  return { ...options.metadata ?? {}, ...metadata };
+}
+function wrapMcpClient(client, options = {}) {
+  const maxSummaryLength = options.maxSummaryLength ?? 240;
+  const wrapped = { ...client };
+  if (typeof client.listTools === "function") {
+    const listTools = client.listTools.bind(client);
+    wrapped.listTools = async (params) => step(
+      "mcp:tools/list",
+      async () => {
+        const result = await listTools(params);
+        return result;
+      },
+      {
+        type: "tool",
+        metadata: baseMetadata(options, {
+          toolName: "tools/list",
+          toolCallId: nextToolCallId(options.toolCallIdPrefix)
+        })
+      }
+    );
+  }
+  const callTool = client.callTool.bind(client);
+  wrapped.callTool = async (params) => step(
+    `mcp:${params.name}`,
+    async () => callTool(params),
+    {
+      type: "tool",
+      metadata: baseMetadata(options, {
+        toolName: params.name,
+        toolCallId: nextToolCallId(options.toolCallIdPrefix),
+        argumentSummary: summarizeMcpValue(
+          params.arguments ?? {},
+          maxSummaryLength
+        )
+      })
+    }
+  );
+  return wrapped;
+}
+function resetMcpToolCallIdsForTests() {
+  toolCallCounter = 0;
+}
+
+export { hashServerUrl, resetMcpToolCallIdsForTests, summarizeMcpValue, wrapMcpClient };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map