agent-inspect 1.8.0 → 2.0.0

package/packages/core/dist/{chunk-6QSLZCBJ.mjs → chunk-A4V2H3YU.mjs}

@@ -1,156 +1,12 @@
 import { source_default } from './chunk-BT7CATSD.mjs';
-import { resolveTraceSafetyOptions, preparePersistedInspectEventForWrite } from './chunk-57S5D6HR.mjs';
-import { extractCorrelationMetadata } from './chunk-S4YWKV4G.mjs';
-import { truncateName, formatDuration, createRunId, getDefaultTraceDir, createStepId } from './chunk-VTIB5MDK.mjs';
+import { resolveTraceSafetyOptions, preparePersistedInspectEventForWrite, initializeTraceFile, writeTraceEvent, prepareTraceEventForDisk } from './chunk-4JVGFNQH.mjs';
+import { extractCorrelationMetadata, buildRunStartedMetadata } from './chunk-S4YWKV4G.mjs';
+import { truncateName, formatDuration, getDefaultTraceDir, createRunId, formatError, getTraceFilePath, createStepId, warn } from './chunk-NQZPZ2FN.mjs';
 import { AsyncLocalStorage } from 'async_hooks';
+import { readdir, stat } from 'fs/promises';
+import path from 'path';
 
-var storage = new AsyncLocalStorage();
-function toPublicContext(ctx) {
-  return {
-    runId: ctx.runId,
-    runName: ctx.runName,
-    traceDir: ctx.traceDir,
-    silent: ctx.silent,
-    metadata: ctx.metadata
-  };
-}
 function invoke(fn) {
-  return new Promise((resolve, reject) => {
-    try {
-      Promise.resolve(fn()).then(resolve, reject);
-    } catch (e) {
-      reject(e);
-    }
-  });
-}
-function getCurrentContext() {
-  try {
-    const s = storage.getStore();
-    if (!s) return void 0;
-    return toPublicContext(s);
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentRunId() {
-  try {
-    return storage.getStore()?.runId;
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentCorrelationMetadata() {
-  try {
-    return extractCorrelationMetadata(storage.getStore()?.metadata);
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentRunName() {
-  try {
-    return storage.getStore()?.runName;
-  } catch {
-    return void 0;
-  }
-}
-function getCurrentStepId() {
-  try {
-    return storage.getStore()?.currentStepId;
-  } catch {
-    return void 0;
-  }
-}
-function getParentStepId() {
-  return getCurrentStepId();
-}
-function getCurrentDepth() {
-  try {
-    const d = storage.getStore()?.currentDepth;
-    return typeof d === "number" && Number.isFinite(d) ? d : 0;
-  } catch {
-    return 0;
-  }
-}
-function hasActiveContext() {
-  try {
-    return storage.getStore() !== void 0;
-  } catch {
-    return false;
-  }
-}
-function getTraceDirFromContext() {
-  try {
-    return storage.getStore()?.traceDir;
-  } catch {
-    return void 0;
-  }
-}
-function isSilentContext() {
-  try {
-    const s = storage.getStore();
-    return s ? s.silent : false;
-  } catch {
-    return false;
-  }
-}
-function getTraceSafetyFromContext() {
-  try {
-    return storage.getStore()?.traceSafety;
-  } catch {
-    return void 0;
-  }
-}
-function runWithContext(context, fn, traceSafety = resolveTraceSafetyOptions()) {
-  const runtime = {
-    runId: context.runId,
-    runName: context.runName,
-    traceDir: context.traceDir,
-    silent: context.silent,
-    metadata: context.metadata,
-    traceSafety,
-    currentDepth: 0
-  };
-  return new Promise((resolve, reject) => {
-    storage.run(runtime, () => {
-      try {
-        Promise.resolve(fn()).then(resolve, reject);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}
-function runWithStepContext(stepId, fn) {
-  let parent;
-  try {
-    parent = storage.getStore();
-  } catch {
-    parent = void 0;
-  }
-  if (!parent) {
-    return invoke(fn);
-  }
-  const derived = {
-    runId: parent.runId,
-    runName: parent.runName,
-    traceDir: parent.traceDir,
-    silent: parent.silent,
-    metadata: parent.metadata,
-    traceSafety: parent.traceSafety,
-    currentStepId: stepId,
-    currentDepth: parent.currentDepth + 1
-  };
-  return new Promise((resolve, reject) => {
-    storage.run(derived, () => {
-      try {
-        Promise.resolve(fn()).then(resolve, reject);
-      } catch (e) {
-        reject(e);
-      }
-    });
-  });
-}
-function invoke2(fn) {
   return new Promise((resolve, reject) => {
     try {
       Promise.resolve(fn()).then(resolve, reject);
@@ -207,7 +63,7 @@ function createInspectorRuntime(options = {}) {
     runtimeId,
     enabled,
     runWithContext(context, fn) {
-      if (!enabled) return invoke2(fn);
+      if (!enabled) return invoke(fn);
       const store = {
         runtimeId,
         runId: context.runId,
@@ -220,14 +76,14 @@ function createInspectorRuntime(options = {}) {
       };
       return new Promise((resolve, reject) => {
         storage2.run(store, () => {
-          invoke2(fn).then(resolve, reject);
+          invoke(fn).then(resolve, reject);
         });
       });
     },
     runWithStepContext(stepId, fn) {
-      if (!enabled) return invoke2(fn);
+      if (!enabled) return invoke(fn);
       const parent = currentStore();
-      if (!parent) return invoke2(fn);
+      if (!parent) return invoke(fn);
       const store = {
         runtimeId,
         runId: parent.runId,
@@ -241,7 +97,7 @@ function createInspectorRuntime(options = {}) {
       };
       return new Promise((resolve, reject) => {
         storage2.run(store, () => {
-          invoke2(fn).then(resolve, reject);
+          invoke(fn).then(resolve, reject);
         });
       });
     },
@@ -311,6 +167,7 @@ function createInspectorRuntime(options = {}) {
 }
 
 // packages/core/src/inspector.ts
+var INSPECTOR_PERSISTED_SCHEMA_VERSION = "1.0";
 function normalizeName(name, fallback) {
   if (typeof name !== "string" || name.trim() === "") return fallback;
   return truncateName(name.trim(), 100);
@@ -427,7 +284,7 @@ function createInspector(options = {}) {
       },
       async () => {
         await write({
-          schemaVersion: "0.2",
+          schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
           eventId: `${runId}_started`,
           runId,
           kind: "RUN",
@@ -446,7 +303,7 @@ function createInspector(options = {}) {
           const result = await Promise.resolve(fn());
           const endedAt = nowIso();
           await write({
-            schemaVersion: "0.2",
+            schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
             eventId: `${runId}_completed`,
             runId,
             kind: "RUN",
@@ -464,7 +321,7 @@ function createInspector(options = {}) {
         } catch (error) {
           const endedAt = nowIso();
           await write({
-            schemaVersion: "0.2",
+            schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
             eventId: `${runId}_completed`,
             runId,
             kind: "RUN",
@@ -504,7 +361,7 @@ function createInspector(options = {}) {
       ...stepOptions.metadata !== void 0 ? { metadata: stepOptions.metadata } : {}
     };
     await write({
-      schemaVersion: "0.2",
+      schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
       eventId: `${stepId}_started`,
       runId: context.runId,
       ...parentId !== void 0 ? { parentId } : {},
@@ -522,7 +379,7 @@ function createInspector(options = {}) {
         const result = await Promise.resolve(fn());
         const endedAt = nowIso();
         await write({
-          schemaVersion: "0.2",
+          schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
           eventId: `${stepId}_completed`,
           runId: context.runId,
           kind: stepTypeToKind(stepType),
@@ -544,7 +401,7 @@ function createInspector(options = {}) {
       } catch (error) {
         const endedAt = nowIso();
         await write({
-          schemaVersion: "0.2",
+          schemaVersion: INSPECTOR_PERSISTED_SCHEMA_VERSION,
           eventId: `${stepId}_completed`,
           runId: context.runId,
           kind: stepTypeToKind(stepType),
@@ -608,6 +465,152 @@ function createInspector(options = {}) {
   };
   return inspector;
 }
+var storage = new AsyncLocalStorage();
+function toPublicContext(ctx) {
+  return {
+    runId: ctx.runId,
+    runName: ctx.runName,
+    traceDir: ctx.traceDir,
+    silent: ctx.silent,
+    metadata: ctx.metadata
+  };
+}
+function invoke2(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 invoke2(fn);
+  }
+  const derived = {
+    runId: parent.runId,
+    runName: parent.runName,
+    traceDir: parent.traceDir,
+    silent: parent.silent,
+    metadata: parent.metadata,
+    traceSafety: parent.traceSafety,
+    currentStepId: stepId,
+    currentDepth: parent.currentDepth + 1
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(derived, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
 
 // packages/core/src/terminal.ts
 var TERMINAL_INDENT = "  ";
@@ -737,7 +740,170 @@ function printFailedAt(stepName) {
   } catch {
   }
 }
+function resolveTraceDir(options = {}) {
+  if (typeof options.dir === "string" && options.dir.trim() !== "") {
+    return options.dir.trim();
+  }
+  const envDir = process.env.AGENT_INSPECT_TRACE_DIR;
+  if (typeof envDir === "string" && envDir.trim() !== "") {
+    return envDir.trim();
+  }
+  return getDefaultTraceDir();
+}
+var TraceDirectory = class {
+  #dir;
+  constructor(options = {}) {
+    this.#dir = resolveTraceDir(options);
+  }
+  getPath(filename) {
+    return filename ? path.join(this.#dir, filename) : this.#dir;
+  }
+  async list() {
+    try {
+      const files = await readdir(this.#dir);
+      return files.filter((f) => f.endsWith(".jsonl"));
+    } catch (e) {
+      if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+        return [];
+      }
+      throw e;
+    }
+  }
+  async getFileStats(filename) {
+    return await stat(this.getPath(filename));
+  }
+};
+
+// packages/core/src/inspect-run.ts
+function normalizeRunName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed-run";
+  }
+  return truncateName(name.trim(), 100);
+}
+async function safeInstrumentation(label, op) {
+  try {
+    await Promise.resolve(op());
+  } catch (e) {
+    warn(`inspectRun: ${label}`, e);
+  }
+}
+async function inspectRun(name, fn, options) {
+  if (typeof fn !== "function") {
+    throw new TypeError("inspectRun requires `fn` to be a function");
+  }
+  if (options?.enabled === false) {
+    return Promise.resolve(fn());
+  }
+  const runName = normalizeRunName(name);
+  const runId = createRunId();
+  const traceDir = resolveTraceDir({ dir: options?.traceDir });
+  const traceSafety = resolveTraceSafetyOptions(options);
+  const runMetadata = buildRunStartedMetadata(options);
+  const context = {
+    runId,
+    runName,
+    traceDir,
+    silent: options?.silent ?? false,
+    metadata: runMetadata
+  };
+  return runWithContext(context, async () => {
+    const startTime = Date.now();
+    let traceFilePath;
+    await safeInstrumentation("initializeTraceFile", async () => {
+      traceFilePath = await initializeTraceFile(runId, traceDir);
+    });
+    await safeInstrumentation("writeTraceEvent(run_started)", async () => {
+      const started = {
+        schemaVersion: "0.1",
+        event: "run_started",
+        timestamp: startTime,
+        runId,
+        name: runName,
+        startTime,
+        ...runMetadata !== void 0 ? { metadata: runMetadata } : {}
+      };
+      await writeTraceEvent(
+        prepareTraceEventForDisk(started, traceSafety),
+        traceDir
+      );
+    });
+    await safeInstrumentation("printRunStart", () => {
+      printRunStart(runId, runName);
+    });
+    let result;
+    try {
+      result = await Promise.resolve(fn());
+    } catch (userError) {
+      const endTime2 = Date.now();
+      const durationMs3 = endTime2 - startTime;
+      const formatted = formatError(userError);
+      const printPath2 = traceFilePath ?? getTraceFilePath(runId, traceDir);
+      await safeInstrumentation("writeTraceEvent(run_completed error)", async () => {
+        const completed = {
+          schemaVersion: "0.1",
+          event: "run_completed",
+          timestamp: endTime2,
+          runId,
+          status: "error",
+          endTime: endTime2,
+          durationMs: durationMs3,
+          error: formatted
+        };
+        await writeTraceEvent(
+          prepareTraceEventForDisk(completed, traceSafety),
+          traceDir
+        );
+      });
+      await safeInstrumentation("printRunComplete(error)", () => {
+        printRunComplete(runName, runId, durationMs3, "error", printPath2);
+      });
+      throw userError;
+    }
+    const endTime = Date.now();
+    const durationMs2 = endTime - startTime;
+    const printPath = traceFilePath ?? getTraceFilePath(runId, traceDir);
+    await safeInstrumentation("writeTraceEvent(run_completed success)", async () => {
+      const completed = {
+        schemaVersion: "0.1",
+        event: "run_completed",
+        timestamp: endTime,
+        runId,
+        status: "success",
+        endTime,
+        durationMs: durationMs2
+      };
+      await writeTraceEvent(
+        prepareTraceEventForDisk(completed, traceSafety),
+        traceDir
+      );
+    });
+    await safeInstrumentation("printRunComplete(success)", () => {
+      printRunComplete(runName, runId, durationMs2, "success", printPath);
+    });
+    return result;
+  }, traceSafety);
+}
+
+// packages/core/src/maybe-inspect-run.ts
+var ENABLED_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on", "enabled"]);
+function isAgentInspectEnabled(value) {
+  if (value === void 0) return false;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "") return false;
+  return ENABLED_ENV_VALUES.has(normalized);
+}
+async function maybeInspectRun(name, fn, options) {
+  if (typeof fn !== "function") {
+    throw new TypeError("maybeInspectRun requires `fn` to be a function");
+  }
+  const enabled = options?.enabled !== void 0 ? options.enabled : isAgentInspectEnabled(process.env.AGENT_INSPECT);
+  if (!enabled) {
+    return Promise.resolve(fn());
+  }
+  return inspectRun(name, fn, options);
+}
 
-export { MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, TERMINAL_INDENT, createInspector, createInspectorRuntime, formatTerminalName, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getIndent, getParentStepId, getTraceDirFromContext, getTraceSafetyFromContext, hasActiveContext, isSilentContext, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, runWithContext, runWithStepContext };
-//# sourceMappingURL=chunk-6QSLZCBJ.mjs.map
-//# sourceMappingURL=chunk-6QSLZCBJ.mjs.map
+export { MAX_TERMINAL_DEPTH, MAX_TERMINAL_NAME_LENGTH, TERMINAL_INDENT, TraceDirectory, createInspector, createInspectorRuntime, formatTerminalName, getCurrentContext, getCurrentCorrelationMetadata, getCurrentDepth, getCurrentRunId, getCurrentRunName, getCurrentStepId, getIndent, getParentStepId, getTraceDirFromContext, getTraceSafetyFromContext, hasActiveContext, inspectRun, isAgentInspectEnabled, isSilentContext, maybeInspectRun, printError, printFailedAt, printRunComplete, printRunStart, printStepComplete, printStepStart, renderErrorLine, renderRunSummary, renderStepLine, resolveTraceDir, runWithContext, runWithStepContext };
+//# sourceMappingURL=chunk-A4V2H3YU.mjs.map
+//# sourceMappingURL=chunk-A4V2H3YU.mjs.map