@tonyclaw/agent-inspector 2.0.17 → 2.0.19

package/.output/server/_ssr/{router-BJob8RN3.mjs → router-SbCnbDc2.mjs}

@@ -1,8 +1,9 @@
 import { c as createRouter, a as createRootRoute, b as createFileRoute, l as lazyRouteComponent, O as Outlet, H as HeadContent, S as Scripts } from "../_libs/tanstack__react-router.mjs";
 import { j as jsxRuntimeExports } from "../_libs/react.mjs";
 import { S as SWRConfig } from "../_libs/swr.mjs";
-import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync } from "node:fs";
-import fs, { mkdir, appendFile, readFile, open, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, readdirSync, statSync, createReadStream, cpSync, rmSync } from "node:fs";
+import fs, { mkdir, appendFile, readFile, writeFile, readdir, open, stat, unlink } from "node:fs/promises";
+import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
 import path, { join, isAbsolute, dirname } from "node:path";
 import { execFile, exec, spawn } from "node:child_process";
@@ -11,6 +12,7 @@ import { C as Conf } from "../_libs/conf.mjs";
 import { randomUUID } from "crypto";
 import { promisify } from "node:util";
 import { Worker } from "node:worker_threads";
+import { randomUUID as randomUUID$1 } from "node:crypto";
 import { M as McpServer, W as WebStandardStreamableHTTPServerTransport } from "../_libs/modelcontextprotocol__server.mjs";
 import { homedir } from "node:os";
 import { d as object, b as string, a as array, _ as _enum, u as union, n as number, c as boolean, e as unknown, l as literal, r as record, g as discriminatedUnion, h as _null, k as lazy } from "../_libs/zod.mjs";
@@ -31,7 +33,6 @@ import "../_libs/isbot.mjs";
 import "../_libs/use-sync-external-store.mjs";
 import "../_libs/dequal.mjs";
 import "node:process";
-import "node:crypto";
 import "node:assert";
 import "../_libs/dot-prop.mjs";
 import "../_libs/env-paths.mjs";
@@ -49,7 +50,7 @@ import "../_libs/mimic-function.mjs";
 import "../_libs/semver.mjs";
 import "../_libs/uint8array-extras.mjs";
 const faviconSvg = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2064%2064'%20role='img'%20aria-label='Agent%20Inspector'%3e%3crect%20width='64'%20height='64'%20rx='14'%20fill='%23111827'%20/%3e%3cg%20fill='none'%20stroke='%23f59e0b'%20stroke-width='4.2'%20stroke-linecap='round'%20stroke-linejoin='round'%3e%3cpath%20fill='%23f59e0b'%20d='M15%2036c0-11%207-18%2017-18s17%207%2017%2018c0%208-7%2013-17%2013s-17-5-17-13z'%20/%3e%3cpath%20d='M16%2031c-6-5-12-3-12%204%200%205%206%206%2011%202'%20/%3e%3cpath%20d='M48%2031c6-5%2012-3%2012%204%200%205-6%206-11%202'%20/%3e%3cpath%20d='M27%2019l-3-7'%20/%3e%3cpath%20d='M37%2019l3-7'%20/%3e%3cpath%20d='M19%2045l-6%209'%20/%3e%3cpath%20d='M27%2048l-3%209'%20/%3e%3cpath%20d='M37%2048l3%209'%20/%3e%3cpath%20d='M45%2045l6%209'%20/%3e%3c/g%3e%3cpath%20d='M14%2047l9-8%208%209c-5%203.5-12%203-17-1z'%20fill='%232f6b3f'%20opacity='.95'%20/%3e%3cpath%20d='M18%2046l5-5%205%206c-3%201.6-7%201.4-10-1z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M23%2041v10'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='1.6'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='31'%20cy='48'%20r='1.8'%20fill='%23c2412d'%20/%3e%3cpath%20d='M24%2044l13-11%2014%2013c-8%205.8-18%205.3-27-2z'%20fill='%232f6b3f'%20opacity='.97'%20/%3e%3cpath%20d='M30%2043l7-7%209%209c-5%202.7-11%202.5-16-2z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M37%2036v14'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='2'%20stroke-linecap='round'%20/%3e%3cpath%20d='M30%2043c5-2%2011-1.5%2016%202'%20fill='none'%20stroke='%239fca78'%20stroke-width='1.8'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='51'%20cy='46'%20r='2'%20fill='%23c2412d'%20/%3e%3cpath%20d='M40%2050l8-8%207%208c-4.2%203.2-10%203-15%200z'%20fill='%232f6b3f'%20opacity='.95'%20/%3e%3cpath%20d='M43%2049l5-5%204.5%205.5c-3%201.5-6%201.2-9.5-.5z'%20fill='%236fb36f'%20opacity='.95'%20/%3e%3cpath%20d='M48%2044v9'%20fill='none'%20stroke='%23d6b45f'%20stroke-width='1.5'%20stroke-linecap='round'%20/%3e%3ccircle%20cx='55'%20cy='50'%20r='1.7'%20fill='%23c2412d'%20/%3e%3ccircle%20cx='24'%20cy='11'%20r='3.2'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='40'%20cy='11'%20r='3.2'%20fill='%23f59e0b'%20/%3e%3ccircle%20cx='25'%20cy='34'%20r='2.1'%20fill='%23111827'%20/%3e%3ccircle%20cx='39'%20cy='34'%20r='2.1'%20fill='%23111827'%20/%3e%3c/svg%3e";
-const appCss = "/assets/index-D_nZj9Vt.css";
+const appCss = "/assets/index-BfBgrkgU.css";
 const Route$s = createRootRoute({
   head: () => ({
     meta: [
@@ -92,7 +93,7 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter$1 = () => import("./index-T7JG28t6.mjs");
+const $$splitComponentImporter$1 = () => import("./index-ejrSItfz.mjs");
 const Route$r = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter$1, "component")
 });
@@ -135,7 +136,7 @@ function decodeSessionIdFromPath(encoded) {
 function getSessionPath(sessionId) {
   return `/session/${encodeSessionIdForPath(sessionId)}`;
 }
-const $$splitComponentImporter = () => import("../_sessionId-BEuJJhqT.mjs");
+const $$splitComponentImporter = () => import("../_sessionId-F8lm6PIb.mjs");
 const Route$q = createFileRoute("/session/$sessionId")({
   component: lazyRouteComponent($$splitComponentImporter, "component"),
   parseParams: (params) => ({
@@ -146,16 +147,19 @@ const Route$q = createFileRoute("/session/$sessionId")({
   })
 });
 const CURRENT_DATA_DIR_NAME = ".agent-inspector";
-const LEGACY_DATA_DIR_NAME = ".llm-inspector";
+const LEGACY_DATA_DIR_NAMES = [".llm-inspector", ".llm-agent"];
 function getDataDir() {
-  return resolveDataDir(existsSync);
+  migrateLegacyDataDirs();
+  return resolveDataDir();
 }
 function hasDataDirState(pathExists, dir) {
   return pathExists(join(dir, "providers.json")) || pathExists(join(dir, "config.json")) || pathExists(join(dir, "logs")) || pathExists(join(dir, "chunks"));
 }
-function resolveDataDir(pathExists, env = process.env, platform = process.platform) {
-  const isWindows = platform === "win32";
-  const base = isWindows ? env["USERPROFILE"] ?? env["APPDATA"] ?? "C:\\" : env["HOME"] ?? "/tmp";
+function defaultBaseDir(env = process.env, platform = process.platform) {
+  return platform === "win32" ? env["USERPROFILE"] ?? env["APPDATA"] ?? "C:\\" : env["HOME"] ?? "/tmp";
+}
+function resolveDataDir(_pathExists, env = process.env, platform = process.platform) {
+  const base = defaultBaseDir(env, platform);
   const dirEnv = env["AGENT_INSPECTOR_DATA_DIR"];
   if (dirEnv !== void 0 && dirEnv !== "") {
     return isAbsolute(dirEnv) ? dirEnv : join(base, dirEnv);
@@ -164,14 +168,31 @@ function resolveDataDir(pathExists, env = process.env, platform = process.platfo
   if (legacyDirEnv !== void 0 && legacyDirEnv !== "") {
     return isAbsolute(legacyDirEnv) ? legacyDirEnv : join(base, legacyDirEnv);
   }
-  const currentDir = join(base, CURRENT_DATA_DIR_NAME);
-  const legacyDir = join(base, LEGACY_DATA_DIR_NAME);
-  return !hasDataDirState(pathExists, currentDir) && hasDataDirState(pathExists, legacyDir) ? legacyDir : currentDir;
+  return join(base, CURRENT_DATA_DIR_NAME);
 }
 function hasExplicitDataDir() {
   return process.env["AGENT_INSPECTOR_DATA_DIR"] !== void 0 && process.env["AGENT_INSPECTOR_DATA_DIR"] !== "" || process.env["AGENT_INSPECTOR_CONFIG_DIR"] !== void 0 && process.env["AGENT_INSPECTOR_CONFIG_DIR"] !== "";
 }
+function migrateLegacyDataDirs() {
+  if (hasExplicitDataDir()) return;
+  const base = defaultBaseDir();
+  const currentDir = join(base, CURRENT_DATA_DIR_NAME);
+  if (hasDataDirState(existsSync, currentDir)) return;
+  for (const legacyName of LEGACY_DATA_DIR_NAMES) {
+    const legacyDir = join(base, legacyName);
+    if (!existsSync(legacyDir)) continue;
+    try {
+      cpSync(legacyDir, currentDir, { recursive: true, force: true });
+      rmSync(legacyDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
 const RETENTION_DAYS = Number(process.env["LOG_RETENTION_DAYS"] ?? "7");
+function writeStderrFallback(message, error) {
+  process.stderr.write(`${message} ${String(error)}
+`);
+}
 function resolveLogDir() {
   const logDirEnv = process.env["LOG_DIR"];
   if (logDirEnv !== void 0 && logDirEnv !== "") {
@@ -212,7 +233,7 @@ async function initLogger() {
       }
     }
   } catch (err) {
-    console.error("[logger] Failed to initialize log directory:", err);
+    writeStderrFallback("[logger] Failed to initialize log directory:", err);
   }
 }
 let loggerInitialized = false;
@@ -229,7 +250,7 @@ async function writeAppLog(message) {
     await appendFile(logPath, `[${timestamp}] ${message}
 `, "utf-8");
   } catch (err) {
-    console.error(`[logger] Failed to write to ${logPath}:`, err);
+    writeStderrFallback(`[logger] Failed to write to ${logPath}:`, err);
   }
 }
 const logger = {
@@ -253,12 +274,27 @@ const logger = {
 const MAX_BUFFER_SIZE = 1e3;
 let writeBuffer = [];
 let writeQueue = Promise.resolve();
+let logWriteLock = Promise.resolve();
+async function runWithLogWriteLock(fn) {
+  const previousLock = logWriteLock;
+  let releaseLock2 = () => {
+  };
+  logWriteLock = new Promise((resolve) => {
+    releaseLock2 = resolve;
+  });
+  await previousLock;
+  try {
+    return await fn();
+  } finally {
+    releaseLock2();
+  }
+}
 function drainBuffer() {
   const toWrite = writeBuffer.join("");
   writeBuffer = [];
   return toWrite;
 }
-async function flushWriteBuffer() {
+async function flushWriteBufferUnlocked() {
   let toWrite;
   {
     toWrite = drainBuffer();
@@ -270,24 +306,31 @@ async function flushWriteBuffer() {
     await appendFile(filePath, toWrite, "utf-8");
   } catch (err) {
     writeBuffer.unshift(toWrite);
-    console.error("[logger] Failed to flush write buffer, re-queued:", err);
+    writeStderrFallback("[logger] Failed to flush write buffer, re-queued:", err);
   }
 }
 function appendLogEntry(entry) {
   const line = JSON.stringify(entry) + "\n";
   writeBuffer.push(line);
   if (writeBuffer.length >= MAX_BUFFER_SIZE) {
-    writeQueue = writeQueue.then(() => flushWriteBuffer());
+    writeQueue = writeQueue.then(() => runWithLogWriteLock(flushWriteBufferUnlocked));
   } else if (writeBuffer.length === 1) {
-    writeQueue = writeQueue.then(() => flushWriteBuffer());
+    writeQueue = writeQueue.then(() => runWithLogWriteLock(flushWriteBufferUnlocked));
   }
 }
 async function flushLogBuffer() {
   await writeQueue;
   if (writeBuffer.length > 0) {
-    await flushWriteBuffer();
+    await runWithLogWriteLock(flushWriteBufferUnlocked);
   }
 }
+async function runWithFlushedLogWriteLock(fn) {
+  await flushLogBuffer();
+  return await runWithLogWriteLock(async () => {
+    await flushWriteBufferUnlocked();
+    return await fn();
+  });
+}
 process.on("exit", () => {
   if (writeBuffer.length > 0) {
     const toWrite = drainBuffer();
@@ -304,127 +347,6 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
     void flushLogBuffer().then(() => process.exit(0));
   });
 }
-const INDEX_VERSION = 1;
-const INDEX_FILE = "logs.idx";
-function getIndexPath() {
-  return join(resolveLogDir(), INDEX_FILE);
-}
-let cachedIndex = null;
-function createEmptyIndex() {
-  return {
-    version: INDEX_VERSION,
-    entries: {},
-    maxId: 0
-  };
-}
-function isLogIndex(obj) {
-  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
-  const versionDesc = Object.getOwnPropertyDescriptor(obj, "version");
-  const entriesDesc = Object.getOwnPropertyDescriptor(obj, "entries");
-  const maxIdDesc = Object.getOwnPropertyDescriptor(obj, "maxId");
-  return versionDesc !== void 0 && typeof versionDesc.value === "number" && entriesDesc !== void 0 && typeof entriesDesc.value === "object" && entriesDesc.value !== null && maxIdDesc !== void 0 && typeof maxIdDesc.value === "number";
-}
-async function loadIndex() {
-  if (cachedIndex !== null) return cachedIndex;
-  const indexPath = getIndexPath();
-  if (!existsSync(indexPath)) {
-    cachedIndex = createEmptyIndex();
-    return cachedIndex;
-  }
-  try {
-    const content = await readFile(indexPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (isLogIndex(parsed)) {
-      cachedIndex = parsed;
-    } else {
-      cachedIndex = createEmptyIndex();
-    }
-    return cachedIndex;
-  } catch (err) {
-    logger.error("[logIndex] Failed to load index:", String(err));
-    cachedIndex = createEmptyIndex();
-    return cachedIndex;
-  }
-}
-async function saveIndex(index) {
-  const indexPath = getIndexPath();
-  const dir = dirname(indexPath);
-  try {
-    await mkdir(dir, { recursive: true });
-  } catch {
-  }
-  try {
-    await writeFile(indexPath, JSON.stringify(index), "utf-8");
-  } catch (err) {
-    logger.error("[logIndex] Failed to save index:", String(err));
-  }
-}
-async function addToIndex(id, file, byteOffset, byteLength) {
-  const index = await loadIndex();
-  index.entries[id] = { id, file, byteOffset, byteLength };
-  if (id > index.maxId) {
-    index.maxId = id;
-  }
-  scheduleIndexFlush();
-}
-let indexFlushScheduled = false;
-async function flushIndexAsync() {
-  indexFlushScheduled = false;
-  const index = await loadIndex();
-  await saveIndex(index);
-}
-function scheduleIndexFlush() {
-  if (indexFlushScheduled) return;
-  indexFlushScheduled = true;
-  setTimeout(() => {
-    void flushIndexAsync();
-  }, 1e3);
-}
-async function findInIndex(id) {
-  const index = await loadIndex();
-  return index.entries[id] ?? null;
-}
-let idGenerationPromise = null;
-let releaseLock = null;
-async function acquireLock() {
-  if (releaseLock === null) {
-    idGenerationPromise = new Promise((resolve) => {
-      releaseLock = resolve;
-    });
-  } else {
-    await idGenerationPromise;
-    idGenerationPromise = new Promise((resolve) => {
-      releaseLock = resolve;
-    });
-  }
-}
-function releaseLockFn() {
-  if (releaseLock) {
-    const resolve = releaseLock;
-    releaseLock = null;
-    idGenerationPromise = null;
-    resolve();
-  }
-}
-async function getNextLogId() {
-  await acquireLock();
-  try {
-    const index = await loadIndex();
-    const nextId = index.maxId + 1;
-    index.maxId = nextId;
-    cachedIndex = index;
-    return nextId;
-  } finally {
-    releaseLockFn();
-  }
-}
-function getCurrentLogFile() {
-  const now = /* @__PURE__ */ new Date();
-  const yyyy = now.getUTCFullYear();
-  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(now.getUTCDate()).padStart(2, "0");
-  return `${yyyy}-${mm}-${dd}.jsonl`;
-}
 const JsonValueSchema = lazy(
   () => union([
     string(),
@@ -438,14 +360,6 @@ const JsonValueSchema = lazy(
 function trustAsJsonValue(value) {
   return value;
 }
-function isPlainRecord(val) {
-  return typeof val === "object" && val !== null && !Array.isArray(val);
-}
-function safeGetOwnProperty(obj, key) {
-  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return void 0;
-  const desc = Object.getOwnPropertyDescriptor(obj, key);
-  return desc?.value;
-}
 const CacheControl = object({
   type: string(),
   ttl: string().optional(),
@@ -807,6 +721,7 @@ const CapturedLogSchema = object({
   headers: record(string(), string()).optional(),
   apiFormat: _enum(["anthropic", "openai", "unknown"]).default("unknown"),
   isTest: boolean().optional().default(false),
+  replayOfLogId: number().nullable().optional(),
   providerName: string().nullable().optional(),
   clientPort: number().nullable().optional(),
   clientPid: number().nullable().optional(),
@@ -897,7 +812,7 @@ function writeChunks(logId, chunks, truncated) {
   try {
     renameSync(tempPath, targetPath);
   } catch (err) {
-    console.warn("[chunkStorage] Rename failed, falling back to copy+delete:", err);
+    logger.warn("[chunkStorage] Rename failed, falling back to copy+delete:", String(err));
     try {
       copyFileSync(tempPath, targetPath);
       unlinkSync(tempPath);
@@ -921,6 +836,193 @@ function readChunks(path2) {
     return null;
   }
 }
+const INDEX_VERSION = 1;
+const INDEX_FILE = "logs.idx";
+function getIndexPath() {
+  return join(resolveLogDir(), INDEX_FILE);
+}
+let cachedIndex = null;
+function createEmptyIndex() {
+  return {
+    version: INDEX_VERSION,
+    entries: {},
+    maxId: 0
+  };
+}
+function isLogIndex(obj) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
+  const versionDesc = Object.getOwnPropertyDescriptor(obj, "version");
+  const entriesDesc = Object.getOwnPropertyDescriptor(obj, "entries");
+  const maxIdDesc = Object.getOwnPropertyDescriptor(obj, "maxId");
+  return versionDesc !== void 0 && typeof versionDesc.value === "number" && entriesDesc !== void 0 && typeof entriesDesc.value === "object" && entriesDesc.value !== null && maxIdDesc !== void 0 && typeof maxIdDesc.value === "number";
+}
+async function loadIndex() {
+  if (cachedIndex !== null) return cachedIndex;
+  const indexPath = getIndexPath();
+  if (!existsSync(indexPath)) {
+    cachedIndex = createEmptyIndex();
+    return cachedIndex;
+  }
+  try {
+    const content = await readFile(indexPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (isLogIndex(parsed)) {
+      cachedIndex = parsed;
+    } else {
+      cachedIndex = createEmptyIndex();
+    }
+    return cachedIndex;
+  } catch (err) {
+    logger.error("[logIndex] Failed to load index:", String(err));
+    cachedIndex = createEmptyIndex();
+    return cachedIndex;
+  }
+}
+async function saveIndex(index) {
+  const indexPath = getIndexPath();
+  const dir = dirname(indexPath);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch {
+  }
+  try {
+    await writeFile(indexPath, JSON.stringify(index), "utf-8");
+  } catch (err) {
+    logger.error("[logIndex] Failed to save index:", String(err));
+  }
+}
+async function addToIndex(id, file, byteOffset, byteLength) {
+  const index = await loadIndex();
+  index.entries[id] = { id, file, byteOffset, byteLength };
+  if (id > index.maxId) {
+    index.maxId = id;
+  }
+  scheduleIndexFlush();
+}
+let indexFlushScheduled = false;
+let indexFlushTimeout = null;
+async function flushIndexAsync() {
+  indexFlushScheduled = false;
+  indexFlushTimeout = null;
+  const index = await loadIndex();
+  await saveIndex(index);
+}
+function scheduleIndexFlush() {
+  if (indexFlushScheduled) return;
+  indexFlushScheduled = true;
+  indexFlushTimeout = setTimeout(() => {
+    void flushIndexAsync();
+  }, 1e3);
+}
+async function flushIndex() {
+  if (indexFlushTimeout !== null) {
+    clearTimeout(indexFlushTimeout);
+    indexFlushTimeout = null;
+  }
+  indexFlushScheduled = false;
+  const index = await loadIndex();
+  await saveIndex(index);
+}
+async function findInIndex(id) {
+  const index = await loadIndex();
+  return index.entries[id] ?? null;
+}
+async function indexFile(filePath, file) {
+  const entries = {};
+  let maxId = 0;
+  let byteOffset = 0;
+  const fileStream = createInterface({
+    input: createReadStream(filePath),
+    crlfDelay: Infinity
+  });
+  for await (const line of fileStream) {
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (line.trim() !== "") {
+      try {
+        const entry = JSON.parse(line);
+        if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+          const idDesc = Object.getOwnPropertyDescriptor(entry, "id");
+          if (idDesc !== void 0 && typeof idDesc.value === "number") {
+            const entryId = idDesc.value;
+            maxId = Math.max(maxId, entryId);
+            entries[entryId] = {
+              id: entryId,
+              file,
+              byteOffset,
+              byteLength: lineBytes
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    byteOffset += lineBytes;
+  }
+  return { entries, maxId };
+}
+async function rebuildIndex() {
+  const logDir = resolveLogDir();
+  const newIndex = createEmptyIndex();
+  if (!existsSync(logDir)) {
+    cachedIndex = newIndex;
+    await saveIndex(newIndex);
+    return newIndex;
+  }
+  const files = (await readdir(logDir)).filter((f) => f.endsWith(".jsonl")).sort();
+  const CONCURRENCY = 4;
+  for (let i = 0; i < files.length; i += CONCURRENCY) {
+    const batch = files.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(batch.map((file) => indexFile(join(logDir, file), file)));
+    for (const result of results) {
+      Object.assign(newIndex.entries, result.entries);
+      newIndex.maxId = Math.max(newIndex.maxId, result.maxId);
+    }
+  }
+  cachedIndex = newIndex;
+  await saveIndex(newIndex);
+  return newIndex;
+}
+let idGenerationPromise = null;
+let releaseLock = null;
+async function acquireLock() {
+  if (releaseLock === null) {
+    idGenerationPromise = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+  } else {
+    await idGenerationPromise;
+    idGenerationPromise = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+  }
+}
+function releaseLockFn() {
+  if (releaseLock) {
+    const resolve = releaseLock;
+    releaseLock = null;
+    idGenerationPromise = null;
+    resolve();
+  }
+}
+async function getNextLogId() {
+  await acquireLock();
+  try {
+    const index = await loadIndex();
+    const nextId = index.maxId + 1;
+    index.maxId = nextId;
+    cachedIndex = index;
+    return nextId;
+  } finally {
+    releaseLockFn();
+  }
+}
+function getCurrentLogFile() {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}.jsonl`;
+}
 const IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1e3;
 const MAX_RESTARTS = 3;
 const _processes = /* @__PURE__ */ new Map();
@@ -1259,9 +1361,11 @@ async function addTestLogEntry(entry) {
     sessionId: session.id,
     streamingChunksPath
   };
-  const logFile = getCurrentLogFile();
-  appendLogEntry(log);
-  await addToIndex(id, logFile, -1, -1);
+  await runWithLogWriteLock(async () => {
+    const logFile = getCurrentLogFile();
+    appendLogEntry(log);
+    await addToIndex(id, logFile, -1, -1);
+  });
   addToCache(log);
   observeSessionLog(log, session.source);
   emitLogUpdate(log);
@@ -1304,9 +1408,11 @@ async function createLog(method, path2, requestBody, headers, clientInfo, rawHea
     clientProjectFolder: clientInfo?.projectFolder ?? null,
     streamingChunksPath: null
   };
-  const logFile = getCurrentLogFile();
-  appendLogEntry(log);
-  await addToIndex(id, logFile, -1, -1);
+  await runWithLogWriteLock(async () => {
+    const logFile = getCurrentLogFile();
+    appendLogEntry(log);
+    await addToIndex(id, logFile, -1, -1);
+  });
   addToCache(log);
   markSessionStarted(log, session.source);
   emitLogUpdate(log);
@@ -1388,11 +1494,81 @@ async function getLogById(id) {
 }
 function getFilteredLogs(sessionId, model) {
   return [...memoryCache.values()].filter((l) => {
-    if (sessionId !== void 0 && getLogSessionId(l) !== sessionId) return false;
-    if (model !== void 0 && l.model !== model) return false;
-    return true;
+    return matchesLogFilters(l, sessionId, model);
   });
 }
+function matchesLogFilters(log, sessionId, model) {
+  if (sessionId !== void 0 && getLogSessionId(log) !== sessionId) return false;
+  if (model !== void 0 && log.model !== model) return false;
+  return true;
+}
+function requestedWindowFitsMemory(filteredMemoryCount, offset, limit) {
+  return offset + limit <= filteredMemoryCount;
+}
+function paginateLogs(logs, offset, limit) {
+  return logs.slice(offset, offset + limit);
+}
+async function readPersistedLogsById() {
+  const byId = /* @__PURE__ */ new Map();
+  const logDir = resolveLogDir();
+  if (!existsSync(logDir)) return byId;
+  try {
+    const entries = await readdir(logDir);
+    const files = entries.filter((file) => file.endsWith(".jsonl")).sort();
+    for (const file of files) {
+      await readPersistedLogFile(join(logDir, file), byId);
+    }
+  } catch (err) {
+    logger.error("[store] Failed to list persisted logs:", String(err));
+  }
+  for (const log of memoryCache.values()) {
+    byId.set(log.id, log);
+  }
+  return byId;
+}
+async function readPersistedLogFile(filePath, byId) {
+  if (!existsSync(filePath)) return;
+  try {
+    const fileStream = createInterface({
+      input: createReadStream(filePath),
+      crlfDelay: Infinity
+    });
+    for await (const line of fileStream) {
+      if (line.trim() === "") continue;
+      try {
+        const parsed = JSON.parse(line);
+        const result = CapturedLogSchema.safeParse(parsed);
+        if (result.success) {
+          const log = normalizeLogSession(result.data);
+          byId.set(log.id, log);
+          observeSessionLog(log);
+        }
+      } catch {
+      }
+    }
+  } catch (err) {
+    logger.error("[store] Failed to read persisted log file:", filePath, String(err));
+  }
+}
+async function listLogsPage(options) {
+  const memoryLogs = getFilteredLogs(options.sessionId, options.model);
+  if (requestedWindowFitsMemory(memoryLogs.length, options.offset, options.limit)) {
+    return {
+      logs: paginateLogs(memoryLogs, options.offset, options.limit),
+      total: memoryLogs.length,
+      offset: options.offset,
+      limit: options.limit
+    };
+  }
+  const persistedById = await readPersistedLogsById();
+  const persistedLogs = [...persistedById.values()].filter((log) => matchesLogFilters(log, options.sessionId, options.model)).sort((left, right) => left.id - right.id);
+  return {
+    logs: paginateLogs(persistedLogs, options.offset, options.limit),
+    total: persistedLogs.length,
+    offset: options.offset,
+    limit: options.limit
+  };
+}
 function getSessions() {
   return getSessionIds();
 }
@@ -1403,12 +1579,216 @@ function getModels() {
   }
   return [...set];
 }
+function getReplayLogsForSource(sourceLogId) {
+  return [...memoryCache.values()].filter((log) => log.replayOfLogId === sourceLogId);
+}
+function collectDirectoryStats(dir, shouldCount) {
+  if (!existsSync(dir)) return { fileCount: 0, bytes: 0 };
+  let fileCount = 0;
+  let bytes = 0;
+  const visit = (currentDir, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = readdirSync(currentDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path2 = join(currentDir, entry);
+      try {
+        const stats = statSync(path2);
+        if (stats.isDirectory()) {
+          visit(path2, depth + 1);
+        } else if (shouldCount(entry)) {
+          fileCount += 1;
+          bytes += stats.size;
+        }
+      } catch {
+      }
+    }
+  };
+  visit(dir, 0);
+  return { fileCount, bytes };
+}
+function getLogStorageStats() {
+  const logDir = resolveLogDir();
+  const chunkDir = getChunksDir();
+  const logStats = collectDirectoryStats(logDir, (fileName) => fileName.endsWith(".jsonl"));
+  const chunkStats = collectDirectoryStats(chunkDir, (fileName) => fileName.endsWith(".json"));
+  return {
+    memoryCount: memoryCache.size,
+    logDir,
+    logFileCount: logStats.fileCount,
+    logBytes: logStats.bytes,
+    chunkDir,
+    chunkFileCount: chunkStats.fileCount,
+    chunkBytes: chunkStats.bytes
+  };
+}
 function clearAllLogs() {
   const count = memoryCache.size;
   memoryCache.clear();
   clearSessionRegistry();
   return { cleared: count };
 }
+async function deleteMatchingFiles(dir, shouldDelete) {
+  if (!existsSync(dir)) return 0;
+  let deleted = 0;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch (err) {
+    logger.warn("[store] Failed to list log storage directory:", String(err));
+    return deleted;
+  }
+  for (const entry of entries) {
+    if (!shouldDelete(entry)) continue;
+    try {
+      await unlink(join(dir, entry));
+      deleted += 1;
+    } catch (err) {
+      logger.warn("[store] Failed to delete log storage file:", entry, String(err));
+    }
+  }
+  return deleted;
+}
+async function clearPersistedLogStorage() {
+  return await runWithFlushedLogWriteLock(async () => {
+    await flushIndex();
+    const result = clearAllLogs();
+    const [logFilesDeleted, chunkFilesDeleted] = await Promise.all([
+      deleteMatchingFiles(
+        resolveLogDir(),
+        (fileName) => fileName.endsWith(".jsonl") || fileName === "logs.idx"
+      ),
+      deleteMatchingFiles(
+        getChunksDir(),
+        (fileName) => fileName.endsWith(".json") || fileName.startsWith(".") && fileName.endsWith(".tmp")
+      )
+    ]);
+    await rebuildIndex();
+    return {
+      cleared: result.cleared,
+      logFilesDeleted,
+      chunkFilesDeleted
+    };
+  });
+}
+function readLogIdFromLine(line) {
+  if (line.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    const idDesc = Object.getOwnPropertyDescriptor(parsed, "id");
+    if (idDesc === void 0 || typeof idDesc.value !== "number") return null;
+    return idDesc.value;
+  } catch {
+    return null;
+  }
+}
+async function rewriteLogFileWithoutIds(filePath, ids) {
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    logger.warn("[store] Failed to read log file for deletion:", filePath, String(err));
+    return { rewritten: false, removedIds: /* @__PURE__ */ new Set() };
+  }
+  const lines = content.split("\n");
+  const keptLines = [];
+  const removedIds = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (line === "") continue;
+    const id = readLogIdFromLine(line);
+    if (id !== null && ids.has(id)) {
+      removedIds.add(id);
+    } else {
+      keptLines.push(line);
+    }
+  }
+  if (removedIds.size === 0) return { rewritten: false, removedIds };
+  try {
+    if (keptLines.length === 0) {
+      await unlink(filePath);
+    } else {
+      await writeFile(filePath, `${keptLines.join("\n")}
+`, "utf-8");
+    }
+  } catch (err) {
+    logger.warn("[store] Failed to rewrite log file after deletion:", filePath, String(err));
+    return { rewritten: false, removedIds: /* @__PURE__ */ new Set() };
+  }
+  return { rewritten: true, removedIds };
+}
+async function rewriteLogFilesWithoutIds(ids) {
+  const logDir = resolveLogDir();
+  if (!existsSync(logDir)) return { logFilesRewritten: 0, removedIds: /* @__PURE__ */ new Set() };
+  let entries;
+  try {
+    entries = await readdir(logDir);
+  } catch (err) {
+    logger.warn("[store] Failed to list log directory for deletion:", String(err));
+    return { logFilesRewritten: 0, removedIds: /* @__PURE__ */ new Set() };
+  }
+  let logFilesRewritten = 0;
+  const removedIds = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.endsWith(".jsonl")) continue;
+    const result = await rewriteLogFileWithoutIds(join(logDir, entry), ids);
+    if (result.rewritten) logFilesRewritten += 1;
+    for (const removedId of result.removedIds) {
+      removedIds.add(removedId);
+    }
+  }
+  return { logFilesRewritten, removedIds };
+}
+async function deleteChunkFilesByIds(ids) {
+  const chunkDir = getChunksDir();
+  if (!existsSync(chunkDir)) return 0;
+  let deleted = 0;
+  for (const id of ids) {
+    const candidates2 = [`${String(id)}.json`, `.${String(id)}.tmp`];
+    for (const candidate of candidates2) {
+      try {
+        await unlink(join(chunkDir, candidate));
+        deleted += 1;
+      } catch {
+      }
+    }
+  }
+  return deleted;
+}
+async function clearPersistedLogsByIds(ids) {
+  const uniqueIds = new Set(ids);
+  if (uniqueIds.size === 0) {
+    return { cleared: 0, logFilesRewritten: 0, chunkFilesDeleted: 0 };
+  }
+  return await runWithFlushedLogWriteLock(async () => {
+    await flushIndex();
+    const memoryRemovedIds = /* @__PURE__ */ new Set();
+    for (const id of uniqueIds) {
+      if (memoryCache.has(id)) memoryRemovedIds.add(id);
+    }
+    const result = clearLogsByIds([...uniqueIds]);
+    const [rewriteResult, chunkFilesDeleted] = await Promise.all([
+      rewriteLogFilesWithoutIds(uniqueIds),
+      deleteChunkFilesByIds(uniqueIds)
+    ]);
+    await rebuildIndex();
+    const clearedIds = new Set(rewriteResult.removedIds);
+    if (result.cleared > 0) {
+      for (const id of memoryRemovedIds) {
+        clearedIds.add(id);
+      }
+    }
+    return {
+      cleared: clearedIds.size,
+      logFilesRewritten: rewriteResult.logFilesRewritten,
+      chunkFilesDeleted
+    };
+  });
+}
 function clearLogsByIds(ids) {
   const unique2 = /* @__PURE__ */ new Set();
   for (const id of ids) {
@@ -2047,6 +2427,10 @@ const alibabaProvider = {
   }
 };
 registry.register(alibabaProvider);
+function maskApiKey(apiKey) {
+  if (apiKey.length <= 8) return "••••••••";
+  return apiKey.slice(0, 4) + "••••••••" + apiKey.slice(-4);
+}
 const ProviderModelMetadataSchema = object({
   model: string().min(1),
   contextWindow: number().int().positive().optional(),
@@ -2613,6 +2997,15 @@ function getProvider(id) {
   const providers = getProviders();
   return providers.find((p) => p.id === id);
 }
+function redactProvider(provider) {
+  return {
+    ...provider,
+    apiKey: maskApiKey(provider.apiKey)
+  };
+}
+function redactProviders(providers) {
+  return providers.map(redactProvider);
+}
 function normalizeApiKey(apiKey) {
   return apiKey.replace(/^Bearer\s+/i, "").trim();
 }
@@ -2779,10 +3172,6 @@ function importProviders(json) {
   }
   return { imported, errors };
 }
-function maskApiKey(apiKey) {
-  if (apiKey.length <= 8) return "••••••••";
-  return apiKey.slice(0, 4) + "••••••••" + apiKey.slice(-4);
-}
 function getModelUsageName(model, providerName) {
   if (providerName !== void 0 && providerName !== "" && providerName.toLowerCase().includes("minimax")) {
     return model.replace(/ /g, "-");
@@ -2824,6 +3213,10 @@ const execFileAsync = promisify(execFile);
 const cache = /* @__PURE__ */ new Map();
 const CACHE_TTL_MS = 5 * 60 * 1e3;
 const MAX_CACHE_SIZE = 200;
+const RemotePortSchema = number().int().min(1).max(65535);
+const SocketSchema = object({
+  remotePort: RemotePortSchema.nullish()
+}).passthrough();
 const inflight = /* @__PURE__ */ new Map();
 function evictCacheIfNeeded() {
   while (cache.size > MAX_CACHE_SIZE) {
@@ -2845,10 +3238,13 @@ function setCache(port, info) {
   evictCacheIfNeeded();
 }
 function extractRemotePort(request) {
-  const socket = request.socket;
-  const remotePort = socket?.remotePort;
-  if (remotePort !== void 0 && remotePort !== null) return remotePort;
-  return null;
+  const descriptor = Object.getOwnPropertyDescriptor(request, "socket");
+  if (descriptor === void 0 || descriptor.get !== void 0) return null;
+  const parsed = SocketSchema.safeParse(descriptor.value);
+  if (!parsed.success) return null;
+  const remotePort = parsed.data.remotePort;
+  if (remotePort === void 0 || remotePort === null) return null;
+  return remotePort;
 }
 async function lookupClientInfo(port) {
   const platform = process.platform;
@@ -3123,6 +3519,14 @@ function toPersistedConfig(value) {
     timeDisplayFormat: value.timeDisplayFormat
   };
 }
+function isPlainRecord(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function safeGetOwnProperty(obj, key) {
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) return void 0;
+  const desc = Object.getOwnPropertyDescriptor(obj, key);
+  return desc?.value;
+}
 const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
 function isClaudeCodeBillingHeaderBlock(text) {
   const trimmed = text.trimStart();
@@ -3288,14 +3692,14 @@ function persistStreamingChunks(log) {
     log.streamingChunksPath = chunkPath;
   }
 }
-function finalizeWithError(job, log, fallbackStatus, fallbackResponseText, err) {
+function finalizeWithError(job, log, fallbackStatus, fallbackResponseText, err, cleanupRawStreamPath = null) {
   const message = errorMessage$2(err);
   logger.error(`[logFinalizer] Failed to finalize log #${log.id}:`, message);
   log.responseStatus = log.responseStatus ?? fallbackStatus;
   log.responseText = log.responseText ?? fallbackResponseText;
   log.elapsedMs = job.elapsedMs;
   log.error = message;
-  return { log, upstreamUrl: job.upstreamUrl, error: message };
+  return { log, upstreamUrl: job.upstreamUrl, error: message, cleanupRawStreamPath };
 }
 function finalizeNonStreaming(job, log) {
   const formatHandler = formatForPath(log.path);
@@ -3316,36 +3720,90 @@ function finalizeNonStreaming(job, log) {
     return finalizeWithError(job, log, job.responseStatus, job.responseBody, err);
   }
 }
+function cleanupPathForRawStream(rawStream) {
+  if (typeof rawStream === "string") return null;
+  switch (rawStream.type) {
+    case "memory":
+      return null;
+    case "file":
+      return rawStream.path;
+  }
+}
+function readRawStream(rawStream) {
+  if (typeof rawStream === "string") {
+    return { rawStreamText: rawStream, cleanupRawStreamPath: null };
+  }
+  switch (rawStream.type) {
+    case "memory":
+      return { rawStreamText: rawStream.rawStream, cleanupRawStreamPath: null };
+    case "file":
+      return {
+        rawStreamText: readFileSync(rawStream.path, "utf-8"),
+        cleanupRawStreamPath: rawStream.path
+      };
+  }
+}
 function finalizeStreaming(job, log) {
   const formatHandler = formatForPath(log.path);
   if (formatHandler === null) {
-    return finalizeWithError(job, log, job.responseStatus, job.rawStream, "Unsupported format");
+    return finalizeWithError(
+      job,
+      log,
+      job.responseStatus,
+      "Streaming response unavailable",
+      "Unsupported format",
+      cleanupPathForRawStream(job.rawStream)
+    );
   }
+  let rawStreamText = "";
+  let cleanupRawStreamPath = null;
   try {
+    const raw = readRawStream(job.rawStream);
+    rawStreamText = raw.rawStreamText;
+    cleanupRawStreamPath = raw.cleanupRawStreamPath;
     log.elapsedMs = job.elapsedMs;
     log.responseStatus = job.responseStatus;
     log.responseText = formatHandler.extractStream(
-      job.rawStream,
+      rawStreamText,
       log,
       log.model ?? void 0,
       job.collectStreamingChunks
     );
     persistStreamingChunks(log);
-    return { log, upstreamUrl: job.upstreamUrl, error: null };
+    return { log, upstreamUrl: job.upstreamUrl, error: null, cleanupRawStreamPath };
   } catch (err) {
-    return finalizeWithError(job, log, job.responseStatus, job.rawStream, err);
+    return finalizeWithError(
+      job,
+      log,
+      job.responseStatus,
+      rawStreamText === "" ? "Streaming response unavailable" : rawStreamText,
+      err,
+      cleanupRawStreamPath ?? cleanupPathForRawStream(job.rawStream)
+    );
   }
 }
 function finalizeStreamAbort(job, log) {
   const formatHandler = formatForPath(log.path);
   if (formatHandler === null && job.hasChunks) {
-    return finalizeWithError(job, log, 499, "Client aborted", "Unsupported format");
+    return finalizeWithError(
+      job,
+      log,
+      499,
+      "Client aborted",
+      "Unsupported format",
+      cleanupPathForRawStream(job.rawStream)
+    );
   }
+  let rawStreamText = "";
+  let cleanupRawStreamPath = null;
   try {
     log.elapsedMs = job.elapsedMs;
     if (job.hasChunks && formatHandler !== null) {
+      const raw = readRawStream(job.rawStream);
+      rawStreamText = raw.rawStreamText;
+      cleanupRawStreamPath = raw.cleanupRawStreamPath;
       log.responseText = formatHandler.extractStream(
-        job.rawStream,
+        rawStreamText,
         log,
         log.model ?? void 0,
         job.collectStreamingChunks
@@ -3354,9 +3812,16 @@ function finalizeStreamAbort(job, log) {
     } else {
       log.responseText = "Client aborted";
     }
-    return { log, upstreamUrl: job.upstreamUrl, error: "Client aborted" };
+    return { log, upstreamUrl: job.upstreamUrl, error: "Client aborted", cleanupRawStreamPath };
   } catch (err) {
-    return finalizeWithError(job, log, 499, "Client aborted", err);
+    return finalizeWithError(
+      job,
+      log,
+      499,
+      rawStreamText === "" ? "Client aborted" : rawStreamText,
+      err,
+      cleanupRawStreamPath ?? cleanupPathForRawStream(job.rawStream)
+    );
   }
 }
 function buildFinalizeLogResult(job) {
@@ -3373,6 +3838,17 @@ function buildFinalizeLogResult(job) {
 function commitFinalizeLogResult(result) {
   appendLogEntry({ ...buildFileLogEntry(result.log, result.upstreamUrl), error: result.error });
   finalizeLogUpdate(result.log);
+  if (result.cleanupRawStreamPath !== void 0 && result.cleanupRawStreamPath !== null) {
+    try {
+      rmSync(result.cleanupRawStreamPath, { force: true });
+    } catch (err) {
+      logger.warn(
+        "[logFinalizer] Failed to remove raw stream temp file:",
+        result.cleanupRawStreamPath,
+        errorMessage$2(err)
+      );
+    }
+  }
 }
 const RUNTIME = (() => {
   if (process.env["FINALIZER_USE_WORKER"] === "0") return "inline";
@@ -3495,6 +3971,63 @@ function enqueueFinalizeLogJob(job) {
     () => executeFinalizeLogJob(job)
   );
 }
+const DEFAULT_MEMORY_LIMIT_BYTES = 1024 * 1024;
+function resolveMemoryLimitBytes() {
+  const raw = process.env["AGENT_INSPECTOR_STREAM_MEMORY_LIMIT_BYTES"];
+  if (raw === void 0 || raw === "") return DEFAULT_MEMORY_LIMIT_BYTES;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) return DEFAULT_MEMORY_LIMIT_BYTES;
+  return parsed;
+}
+function getRawStreamDir() {
+  return join(getDataDir(), "raw-streams");
+}
+function createRawStreamPath() {
+  return join(getRawStreamDir(), `${Date.now()}-${randomUUID$1()}.stream.tmp`);
+}
+class RawStreamCapture {
+  memoryLimitBytes;
+  chunks = [];
+  byteLength = 0;
+  filePath = null;
+  sawChunk = false;
+  constructor(memoryLimitBytes = resolveMemoryLimitBytes()) {
+    this.memoryLimitBytes = memoryLimitBytes;
+  }
+  get hasChunks() {
+    return this.sawChunk;
+  }
+  async append(text) {
+    if (text === "") return;
+    this.sawChunk = true;
+    const nextBytes = Buffer.byteLength(text, "utf-8");
+    if (this.filePath === null && this.byteLength + nextBytes <= this.memoryLimitBytes) {
+      this.chunks.push(text);
+      this.byteLength += nextBytes;
+      return;
+    }
+    if (this.filePath === null) {
+      await this.spillToFile();
+    }
+    if (this.filePath !== null) {
+      await appendFile(this.filePath, text, "utf-8");
+      this.byteLength += nextBytes;
+    }
+  }
+  snapshot() {
+    if (this.filePath !== null) {
+      return { type: "file", path: this.filePath };
+    }
+    return { type: "memory", rawStream: this.chunks.join("") };
+  }
+  async spillToFile() {
+    const path2 = createRawStreamPath();
+    await mkdir(getRawStreamDir(), { recursive: true });
+    await writeFile(path2, this.chunks.join(""), "utf-8");
+    this.filePath = path2;
+    this.chunks = [];
+  }
+}
 function describeApiRoute(apiPath) {
   const endpointPath = apiPath.split("?")[0] ?? "";
   const isChatCompletions = endpointPath === PATH_CHAT_COMPLETIONS || endpointPath === PATH_V1_CHAT_COMPLETIONS;
@@ -3603,25 +4136,47 @@ function handleNonStreamingResponse(upstreamRes, responseBody, startTime, upstre
 function handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log, collectStreamingChunks) {
   log.streaming = true;
   log.responseStatus = upstreamRes.status;
-  const chunks = [];
+  const capture = new RawStreamCapture();
   const decoder = new TextDecoder();
+  let finalizationScheduled = false;
+  const scheduleStreamingFinalization = (type) => {
+    if (finalizationScheduled) return;
+    finalizationScheduled = true;
+    const elapsedMs = Date.now() - startTime;
+    const rawStream = capture.snapshot();
+    switch (type) {
+      case "streaming":
+        scheduleLogFinalization({
+          type: "streaming",
+          log,
+          upstreamUrl,
+          elapsedMs,
+          responseStatus: upstreamRes.status,
+          rawStream,
+          collectStreamingChunks
+        });
+        return;
+      case "stream-abort":
+        scheduleLogFinalization({
+          type: "stream-abort",
+          log,
+          upstreamUrl,
+          elapsedMs,
+          rawStream,
+          hasChunks: capture.hasChunks,
+          collectStreamingChunks
+        });
+        return;
+    }
+  };
   const transform = new TransformStream({
-    transform(chunk, controller) {
+    async transform(chunk, controller) {
       controller.enqueue(chunk);
-      chunks.push(decoder.decode(chunk, { stream: true }));
+      await capture.append(decoder.decode(chunk, { stream: true }));
     },
-    flush() {
-      const full = chunks.join("");
-      const elapsedMs = Date.now() - startTime;
-      scheduleLogFinalization({
-        type: "streaming",
-        log,
-        upstreamUrl,
-        elapsedMs,
-        responseStatus: upstreamRes.status,
-        rawStream: full,
-        collectStreamingChunks
-      });
+    async flush() {
+      await capture.append(decoder.decode());
+      scheduleStreamingFinalization("streaming");
     }
   });
   if (upstreamRes.body === null) {
@@ -3631,18 +4186,7 @@ function handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log,
   req.signal?.addEventListener("abort", () => {
     if (log.responseText === null) {
       logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
-      const elapsedMs = Date.now() - startTime;
-      const full = chunks.join("");
-      const hasChunks = chunks.length > 0;
-      scheduleLogFinalization({
-        type: "stream-abort",
-        log,
-        upstreamUrl,
-        elapsedMs,
-        rawStream: full,
-        hasChunks,
-        collectStreamingChunks
-      });
+      scheduleStreamingFinalization("stream-abort");
     }
   });
   const responseHeaders = new Headers(upstreamRes.headers);
@@ -3797,8 +4341,11 @@ const ProviderInputSchema = object({
 const Route$n = createFileRoute("/api/providers")({
   server: {
     handlers: {
-      GET: () => {
-        return Response.json(getProviders());
+      GET: ({ request }) => {
+        const url = new URL(request.url);
+        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
+        const providers = getProviders();
+        return Response.json(includeSecrets ? providers : redactProviders(providers));
       },
       POST: async ({ request }) => {
         const parsed = ProviderInputSchema.safeParse(await request.json());
@@ -4073,13 +4620,18 @@ async function listModelsImpl(callApi2) {
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);
   return textJson(await res.json());
 }
-async function listProvidersImpl(callApi2) {
-  const res = await callApi2("/api/providers");
+function includeSecretsQuery(includeSecrets) {
+  return includeSecrets === true ? "?includeSecrets=1" : "";
+}
+async function listProvidersImpl(callApi2, args = {}) {
+  const res = await callApi2(`/api/providers${includeSecretsQuery(args.includeSecrets)}`);
   if (!res.ok) return toolError(`GET /api/providers returned ${res.status}`);
   return textJson(await res.json());
 }
-async function getProviderImpl(callApi2, id) {
-  const res = await callApi2(`/api/providers/${encodeURIComponent(id)}`);
+async function getProviderImpl(callApi2, id, args = {}) {
+  const res = await callApi2(
+    `/api/providers/${encodeURIComponent(id)}${includeSecretsQuery(args.includeSecrets)}`
+  );
   if (!res.ok) return toolError(`GET /api/providers/${id} returned ${res.status}`);
   return textJson(await res.json());
 }
@@ -4302,21 +4854,24 @@ function registerTools(server) {
     "inspector_list_providers",
     {
       title: "List configured LLM providers",
-      description: "Returns the full ProviderConfig array, including apiKey in PLAINTEXT. MCP is localhost-only — any process that can call /api/mcp can also read <dataDir>/providers.json directly, so the apiKey is not redacted. Do not expose this MCP server to non-trusted local processes.",
-      inputSchema: object({})
+      description: "Returns the configured ProviderConfig array with apiKey redacted by default. Set includeSecrets=true only when the user explicitly needs plaintext local provider keys; this exposes secrets from <dataDir>/providers.json.",
+      inputSchema: object({
+        includeSecrets: boolean().optional().describe("Return plaintext provider API keys. Exposes local secrets when true.")
+      })
     },
-    () => safeCall(() => listProvidersImpl(callApi))
+    (args) => safeCall(() => listProvidersImpl(callApi, args))
   );
   server.registerTool(
     "inspector_get_provider",
     {
       title: "Get a single provider by id",
-      description: "Returns the full ProviderConfig for the given id, including apiKey in PLAINTEXT (same posture as inspector_list_providers).",
+      description: "Returns one ProviderConfig with apiKey redacted by default. Set includeSecrets=true only when the user explicitly needs the plaintext local provider key.",
       inputSchema: object({
-        id: string().describe("The provider id.")
+        id: string().describe("The provider id."),
+        includeSecrets: boolean().optional().describe("Return the plaintext provider API key. Exposes a local secret when true.")
       })
     },
-    ({ id }) => safeCall(() => getProviderImpl(callApi, id))
+    ({ id, includeSecrets }) => safeCall(() => getProviderImpl(callApi, id, { includeSecrets }))
   );
   server.registerTool(
     "inspector_replay_log",
@@ -4452,23 +5007,40 @@ const Route$l = createFileRoute("/api/mcp")({
 const DeleteBodySchema = object({
   ids: array(number().int().positive()).optional()
 }).optional();
+function parseNonNegativeInt(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 0) return fallback;
+  return parsed;
+}
+function parsePositiveInt(value, fallback) {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}
 const Route$k = createFileRoute("/api/logs")({
   server: {
     handlers: {
-      GET: ({ request }) => {
+      GET: async ({ request }) => {
         const url = new URL(request.url);
+        if (url.searchParams.get("stats") === "1") {
+          return Response.json(getLogStorageStats());
+        }
+        const replayOf = url.searchParams.get("replayOf");
+        if (replayOf !== null) {
+          const id = Number(replayOf);
+          if (!Number.isInteger(id) || id <= 0) {
+            return Response.json({ error: "Invalid replayOf log ID" }, { status: 400 });
+          }
+          const logs = getReplayLogsForSource(id);
+          return Response.json({ logs, total: logs.length, offset: 0, limit: logs.length });
+        }
         const sessionId = url.searchParams.get("sessionId") ?? void 0;
         const model = url.searchParams.get("model") ?? void 0;
-        const offset = Number(url.searchParams.get("offset") ?? 0);
-        const limit = Number(url.searchParams.get("limit") ?? 50);
-        const allLogs = getFilteredLogs(sessionId, model);
-        const paginatedLogs = allLogs.slice(offset, offset + limit);
-        return Response.json({
-          logs: paginatedLogs,
-          total: allLogs.length,
-          offset,
-          limit
-        });
+        const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
+        const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
+        return Response.json(await listLogsPage({ sessionId, model, offset, limit }));
       },
       DELETE: async ({ request }) => {
         let body = void 0;
@@ -4489,11 +5061,21 @@ const Route$k = createFileRoute("/api/logs")({
           return Response.json({ error: "Invalid JSON body" }, { status: 400 });
         }
         if (body?.ids !== void 0 && body.ids.length > 0) {
-          const result2 = clearLogsByIds(body.ids);
-          return Response.json({ success: true, cleared: result2.cleared });
+          const result2 = await clearPersistedLogsByIds(body.ids);
+          return Response.json({
+            success: true,
+            cleared: result2.cleared,
+            logFilesRewritten: result2.logFilesRewritten,
+            chunkFilesDeleted: result2.chunkFilesDeleted
+          });
         }
-        const result = clearAllLogs();
-        return Response.json({ success: true, cleared: result.cleared });
+        const result = await clearPersistedLogStorage();
+        return Response.json({
+          success: true,
+          cleared: result.cleared,
+          logFilesDeleted: result.logFilesDeleted,
+          chunkFilesDeleted: result.chunkFilesDeleted
+        });
       }
     }
   }
@@ -5015,13 +5597,15 @@ const ProviderUpdateSchema = object({
 const Route$e = createFileRoute("/api/providers/$providerId")({
   server: {
     handlers: {
-      GET: ({ params }) => {
+      GET: ({ params, request }) => {
+        const url = new URL(request.url);
+        const includeSecrets = url.searchParams.get("includeSecrets") === "1";
         const providers = getProviders();
         const provider = providers.find((p) => p.id === params.providerId);
         if (!provider) {
           return Response.json({ error: "Provider not found" }, { status: 404 });
         }
-        return Response.json(provider);
+        return Response.json(includeSecrets ? provider : redactProvider(provider));
       },
       PUT: async ({ params, request }) => {
         const parsed = ProviderUpdateSchema.safeParse(await request.json());
@@ -5044,6 +5628,7 @@ const Route$e = createFileRoute("/api/providers/$providerId")({
     }
   }
 });
+const INITIAL_STREAM_LOG_LIMIT = 500;
 const Route$d = createFileRoute("/api/logs/stream")({
   server: {
     handlers: {
@@ -5085,9 +5670,15 @@ const Route$d = createFileRoute("/api/logs/stream")({
         }, 3e4);
         request.signal.addEventListener("abort", cleanup, { once: true });
         const stream = new ReadableStream({
-          start(controller) {
+          async start(controller) {
             controllerRef = controller;
-            const logs = getFilteredLogs(sessionId, model);
+            const result = await listLogsPage({
+              sessionId,
+              model,
+              offset: 0,
+              limit: INITIAL_STREAM_LOG_LIMIT
+            });
+            const logs = result.logs;
             const initData = `data: ${JSON.stringify({ type: "init", logs })}
 
 `;
@@ -6501,6 +7092,37 @@ const Route$5 = createFileRoute("/api/logs/$id/replay")({
           const mockLog = { ...log };
           const responseText = formatHandler.extractStream(fullResponse, mockLog, model, false);
           const tokens = formatHandler.extractTokens(responseText);
+          const savedReplayLog = await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: log.method,
+            path: log.path,
+            model,
+            sessionId: log.sessionId,
+            rawRequestBody: modifiedBody,
+            responseStatus: upstreamRes.status,
+            responseText,
+            inputTokens: tokens.inputTokens ?? null,
+            outputTokens: tokens.outputTokens ?? null,
+            cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
+            cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
+            elapsedMs,
+            streaming: true,
+            userAgent: log.userAgent,
+            origin: log.origin,
+            rawHeaders: log.rawHeaders,
+            headers: log.headers,
+            apiFormat: log.apiFormat,
+            isTest: true,
+            replayOfLogId: log.id,
+            providerName: log.providerName,
+            clientPort: log.clientPort,
+            clientPid: log.clientPid,
+            clientCwd: log.clientCwd,
+            clientProjectFolder: log.clientProjectFolder,
+            streamingChunks: void 0,
+            streamingChunksPath: null,
+            error: null
+          });
           return Response.json({
             success: true,
             responseStatus: upstreamRes.status,
@@ -6508,11 +7130,43 @@ const Route$5 = createFileRoute("/api/logs/$id/replay")({
             inputTokens: tokens.inputTokens ?? void 0,
             outputTokens: tokens.outputTokens ?? void 0,
             elapsedMs,
-            streaming: true
+            streaming: true,
+            replayLogId: savedReplayLog.id
           });
         } else {
           const responseText = await upstreamRes.text();
           const tokens = formatHandler.extractTokens(responseText);
+          const savedReplayLog = await addTestLogEntry({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            method: log.method,
+            path: log.path,
+            model,
+            sessionId: log.sessionId,
+            rawRequestBody: modifiedBody,
+            responseStatus: upstreamRes.status,
+            responseText,
+            inputTokens: tokens.inputTokens ?? null,
+            outputTokens: tokens.outputTokens ?? null,
+            cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
+            cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
+            elapsedMs,
+            streaming: false,
+            userAgent: log.userAgent,
+            origin: log.origin,
+            rawHeaders: log.rawHeaders,
+            headers: log.headers,
+            apiFormat: log.apiFormat,
+            isTest: true,
+            replayOfLogId: log.id,
+            providerName: log.providerName,
+            clientPort: log.clientPort,
+            clientPid: log.clientPid,
+            clientCwd: log.clientCwd,
+            clientProjectFolder: log.clientProjectFolder,
+            streamingChunks: void 0,
+            streamingChunksPath: null,
+            error: null
+          });
           return Response.json({
             success: true,
             responseStatus: upstreamRes.status,
@@ -6520,7 +7174,8 @@ const Route$5 = createFileRoute("/api/logs/$id/replay")({
             inputTokens: tokens.inputTokens ?? void 0,
             outputTokens: tokens.outputTokens ?? void 0,
             elapsedMs,
-            streaming: false
+            streaming: false,
+            replayLogId: savedReplayLog.id
           });
         }
       }
@@ -7204,8 +7859,9 @@ export {
   ProviderTestResultsSchema as j,
   createFailedProviderTestResults as k,
   resolveProviderContextWindow as l,
-  isPlainRecord as m,
-  router as n,
+  maskApiKey as m,
+  isPlainRecord as n,
+  router as o,
   parseOpenAIResponse as p,
   requestFormatForPath as r,
   safeGetOwnProperty as s