@tonyclaw/llm-inspector 1.17.1 → 1.18.0

package/.output/server/_ssr/{router-DG_jmXCF.mjs → router-711KpGkz.mjs}

@@ -1,14 +1,15 @@
 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, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync, copyFileSync, unlinkSync } from "node:fs";
 import { mkdir, appendFile, readFile, open, readdir, stat, unlink, writeFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import path, { join, isAbsolute, dirname } from "node:path";
 import { C as Conf } from "../_libs/conf.mjs";
 import { randomUUID } from "crypto";
-import { exec } from "node:child_process";
+import { exec, fork } from "node:child_process";
 import { promisify } from "node:util";
+import { Worker } from "node:worker_threads";
 import { M as McpServer, W as WebStandardStreamableHTTPServerTransport } from "../_libs/modelcontextprotocol__server.mjs";
 import { homedir } from "node:os";
 import { d as object, _ as _enum, b as string, a as array, u as union, n as number, c as boolean, r as record, g as discriminatedUnion, l as literal, h as _null, k as lazy, e as unknown } from "../_libs/zod.mjs";
@@ -70,7 +71,7 @@ function RootDocument({ children }) {
     ] })
   ] });
 }
-const $$splitComponentImporter = () => import("./index-nUG0H1oS.mjs").then((n) => n.t);
+const $$splitComponentImporter = () => import("./index-C7I_Qgt0.mjs").then((n) => n.t);
 const Route$j = createFileRoute("/")({
   component: lazyRouteComponent($$splitComponentImporter, "component")
 });
@@ -750,20 +751,24 @@ const LooseRequestSchema = object({
   model: string().optional(),
   metadata: object({ user_id: string().optional() }).passthrough().optional()
 });
+function extractSessionIdFromHeaders(headers) {
+  return headers.get("x-llm-inspector-session-id") ?? headers.get("x-session-affinity");
+}
 function extractRequestMetadata(body, headers) {
-  if (body === null) return { model: null, sessionId: null };
+  const headerSessionId = extractSessionIdFromHeaders(headers);
+  if (body === null) return { model: null, sessionId: headerSessionId };
   try {
     const json = JSON.parse(body);
     const loose = LooseRequestSchema.safeParse(json);
     if (loose.success) {
       return {
         model: loose.data.model ?? null,
-        sessionId: loose.data.metadata?.user_id ?? headers.get("x-session-affinity") ?? null
+        sessionId: loose.data.metadata?.user_id ?? headerSessionId
       };
     }
   } catch {
   }
-  return { model: null, sessionId: null };
+  return { model: null, sessionId: headerSessionId };
 }
 const StreamingChunkSchema = object({
   index: number(),
@@ -833,6 +838,199 @@ function readChunks(path2) {
     return null;
   }
 }
+const PROVIDER_TEST_SESSION_ID = "provider-test";
+function getRuntimeMode() {
+  if (process.env["FINALIZER_USE_WORKER"] === "0") return "in-process";
+  const mode = process.env["FINALIZER_RUNTIME"];
+  if (mode === "worker") return "worker-thread";
+  if (mode === "inline") return "in-process";
+  return "child-process";
+}
+const sessions = /* @__PURE__ */ new Map();
+const knownLogSessions = /* @__PURE__ */ new Map();
+const completedLogIds = /* @__PURE__ */ new Set();
+const failedLogIds = /* @__PURE__ */ new Set();
+function normalizeExplicitSessionId(sessionId) {
+  if (sessionId === null || sessionId === void 0) return null;
+  const trimmed = sessionId.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function buildClientSessionId(clientInfo) {
+  const projectFolder = normalizeExplicitSessionId(clientInfo.projectFolder);
+  if (clientInfo.pid !== null) {
+    return {
+      id: projectFolder !== null ? `process:${clientInfo.pid}:${projectFolder}` : `process:${clientInfo.pid}`,
+      source: "client-process"
+    };
+  }
+  if (clientInfo.port !== null) {
+    return {
+      id: `connection:${clientInfo.port}`,
+      source: "client-connection"
+    };
+  }
+  return { id: null, source: null };
+}
+function resolveSessionIdentity(input) {
+  if (input.isTest === true) {
+    return { id: PROVIDER_TEST_SESSION_ID, source: "provider-test" };
+  }
+  const explicit = normalizeExplicitSessionId(input.explicitSessionId);
+  if (explicit !== null) {
+    return { id: explicit, source: "explicit" };
+  }
+  if (input.clientInfo !== void 0) {
+    return buildClientSessionId(input.clientInfo);
+  }
+  return { id: null, source: null };
+}
+function getLogSessionIdentity(log) {
+  return resolveSessionIdentity({
+    explicitSessionId: log.sessionId,
+    clientInfo: {
+      port: log.clientPort ?? null,
+      pid: log.clientPid ?? null,
+      cwd: log.clientCwd ?? null,
+      projectFolder: log.clientProjectFolder ?? null
+    },
+    isTest: log.isTest
+  });
+}
+function getLogSessionId(log) {
+  return getLogSessionIdentity(log).id;
+}
+function getTimestamp(log) {
+  return log.timestamp.length > 0 ? log.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+}
+function createSessionRecord(id, source, log) {
+  const timestamp = getTimestamp(log);
+  return {
+    id,
+    source,
+    runtimeMode: getRuntimeMode(),
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    requestCount: 0,
+    activeRequests: 0,
+    completedRequests: 0,
+    failedRequests: 0,
+    queuedTasks: 0,
+    runningTasks: 0,
+    lastTaskError: null,
+    lastLogId: null,
+    lastModel: null,
+    clientPid: log.clientPid ?? null,
+    clientProjectFolder: log.clientProjectFolder ?? null
+  };
+}
+function upsertSession(log, sourceOverride) {
+  const identity = getLogSessionIdentity(log);
+  if (identity.id === null) return null;
+  const source = sourceOverride ?? identity.source;
+  if (source === null) return null;
+  const existing = sessions.get(identity.id);
+  const session = existing ?? createSessionRecord(identity.id, source, log);
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  session.lastLogId = log.id;
+  session.lastModel = log.model ?? session.lastModel;
+  session.clientPid = log.clientPid ?? session.clientPid;
+  session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+  sessions.set(identity.id, session);
+  return session;
+}
+function rememberLogSession(log) {
+  const sessionId = getLogSessionId(log);
+  if (sessionId === null) return false;
+  const knownSessionId = knownLogSessions.get(log.id);
+  if (knownSessionId === sessionId) return false;
+  knownLogSessions.set(log.id, sessionId);
+  return true;
+}
+function isFailedLog(log) {
+  const hasError = log.error !== null && log.error !== void 0 && log.error.length > 0;
+  const hasErrorStatus = log.responseStatus !== null && log.responseStatus >= 400;
+  return hasError || hasErrorStatus;
+}
+function markSessionStarted(log, sourceOverride) {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+  const isNewLog = rememberLogSession(log);
+  if (isNewLog) {
+    session.requestCount += 1;
+  }
+  session.activeRequests += 1;
+}
+function markSessionFinished(log, sourceOverride) {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+  if (session.activeRequests > 0) {
+    session.activeRequests -= 1;
+  }
+  if (completedLogIds.has(log.id) === false) {
+    completedLogIds.add(log.id);
+    session.completedRequests += 1;
+  }
+  if (isFailedLog(log) && failedLogIds.has(log.id) === false) {
+    failedLogIds.add(log.id);
+    session.failedRequests += 1;
+  }
+}
+function markSessionTaskQueued(sessionId) {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === void 0) return;
+  session.queuedTasks += 1;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function markSessionTaskStarted(sessionId) {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === void 0) return;
+  if (session.queuedTasks > 0) {
+    session.queuedTasks -= 1;
+  }
+  session.runningTasks += 1;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function markSessionTaskFinished(sessionId, error) {
+  if (sessionId === null) return;
+  const session = sessions.get(sessionId);
+  if (session === void 0) return;
+  if (session.runningTasks > 0) {
+    session.runningTasks -= 1;
+  }
+  session.lastTaskError = error;
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+}
+function observeSessionLog(log, sourceOverride) {
+  const session = upsertSession(log, sourceOverride);
+  if (session === null) return;
+  const isNewLog = rememberLogSession(log);
+  if (isNewLog) {
+    session.requestCount += 1;
+  }
+  if (log.responseStatus !== null || log.responseText !== null) {
+    markSessionFinished(log, sourceOverride);
+  }
+}
+function clearSessionRegistry() {
+  sessions.clear();
+  knownLogSessions.clear();
+  completedLogIds.clear();
+  failedLogIds.clear();
+}
+function rebuildSessionRegistry(logs) {
+  clearSessionRegistry();
+  for (const log of logs) {
+    observeSessionLog(log);
+  }
+}
+function getSessionIds() {
+  return [...sessions.values()].map((session) => session.id);
+}
+function getSessionSnapshots() {
+  return [...sessions.values()].map((session) => ({ ...session }));
+}
 const MAX_MEMORY_CACHE = 100;
 const memoryCache = /* @__PURE__ */ new Map();
 function evictOldestIfNeeded() {
@@ -842,11 +1040,17 @@ function evictOldestIfNeeded() {
     memoryCache.delete(oldestKey);
   }
 }
+function normalizeLogSession(log) {
+  const sessionId = getLogSessionId(log);
+  if (sessionId === log.sessionId) return log;
+  return { ...log, sessionId };
+}
 function addToCache(log) {
-  if (memoryCache.has(log.id)) {
-    memoryCache.delete(log.id);
+  const cachedLog = normalizeLogSession(log);
+  if (memoryCache.has(cachedLog.id)) {
+    memoryCache.delete(cachedLog.id);
   }
-  memoryCache.set(log.id, log);
+  memoryCache.set(cachedLog.id, cachedLog);
   evictOldestIfNeeded();
 }
 function removeFromCache(id) {
@@ -867,12 +1071,18 @@ async function addTestLogEntry(entry) {
       entry.streamingChunks.truncated
     );
   }
+  const session = resolveSessionIdentity({
+    explicitSessionId: entry.sessionId,
+    isTest: entry.isTest
+  });
   const log = {
     id,
     ...entry,
+    sessionId: session.id,
     streamingChunksPath
   };
   addToCache(log);
+  observeSessionLog(log, session.source);
   emitLogUpdate(log);
   return log;
 }
@@ -880,13 +1090,17 @@ async function createLog(method, path2, requestBody, headers, clientInfo, rawHea
   const userAgent = headers.get("user-agent");
   const origin = headers.get("origin");
   const id = preAcquiredId ?? await getNextLogId();
+  const session = resolveSessionIdentity({
+    explicitSessionId: sessionId,
+    clientInfo
+  });
   const log = {
     id,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     method,
     path: path2,
     model,
-    sessionId,
+    sessionId: session.id,
     rawRequestBody: requestBody,
     responseStatus: null,
     responseText: null,
@@ -913,9 +1127,15 @@ async function createLog(method, path2, requestBody, headers, clientInfo, rawHea
   appendLogEntry(log);
   await addToIndex(id, logFile, -1, -1);
   addToCache(log);
+  markSessionStarted(log, session.source);
   emitLogUpdate(log);
   return log;
 }
+function finalizeLogUpdate(log) {
+  addToCache(log);
+  markSessionFinished(log);
+  emitLogUpdate(log);
+}
 async function getLogById(id) {
   const cached = memoryCache.get(id);
   if (cached !== void 0) {
@@ -940,7 +1160,12 @@ async function getLogById(id) {
         if (line === "") return null;
         const parsed = JSON.parse(line);
         const result = CapturedLogSchema.safeParse(parsed);
-        if (result.success) return result.data;
+        if (result.success) {
+          const log = normalizeLogSession(result.data);
+          addToCache(log);
+          observeSessionLog(log);
+          return log;
+        }
       } finally {
         await fh.close();
       }
@@ -958,9 +1183,11 @@ async function getLogById(id) {
           if (desc !== void 0 && typeof desc.value === "number" && desc.value === id) {
             const result = CapturedLogSchema.safeParse(parsed);
             if (result.success) {
-              lastMatch = result.data;
+              lastMatch = normalizeLogSession(result.data);
               if (result.data.responseStatus !== null) {
-                return result.data;
+                addToCache(lastMatch);
+                observeSessionLog(lastMatch);
+                return lastMatch;
               }
             }
           }
@@ -968,7 +1195,11 @@ async function getLogById(id) {
       } catch {
       }
     }
-    if (lastMatch !== null) return lastMatch;
+    if (lastMatch !== null) {
+      addToCache(lastMatch);
+      observeSessionLog(lastMatch);
+      return lastMatch;
+    }
   } catch (err) {
     logger.error("[store] Failed to read log from disk:", String(err));
   }
@@ -976,17 +1207,13 @@ async function getLogById(id) {
 }
 function getFilteredLogs(sessionId, model) {
   return [...memoryCache.values()].filter((l) => {
-    if (sessionId !== void 0 && l.sessionId !== sessionId) return false;
+    if (sessionId !== void 0 && getLogSessionId(l) !== sessionId) return false;
     if (model !== void 0 && l.model !== model) return false;
     return true;
   });
 }
 function getSessions() {
-  const set = /* @__PURE__ */ new Set();
-  for (const l of memoryCache.values()) {
-    if (l.sessionId !== null && l.sessionId !== "") set.add(l.sessionId);
-  }
-  return [...set];
+  return getSessionIds();
 }
 function getModels() {
   const set = /* @__PURE__ */ new Set();
@@ -998,6 +1225,7 @@ function getModels() {
 function clearAllLogs() {
   const count = memoryCache.size;
   memoryCache.clear();
+  clearSessionRegistry();
   return { cleared: count };
 }
 function clearLogsByIds(ids) {
@@ -1008,6 +1236,7 @@ function clearLogsByIds(ids) {
   for (const id of unique) {
     removeFromCache(id);
   }
+  rebuildSessionRegistry(memoryCache.values());
   return { cleared: unique.size };
 }
 const sseHandlers = /* @__PURE__ */ new Set();
@@ -2368,6 +2597,350 @@ function stripOpenAIOrphanToolMessages(rawBody) {
   parsed.messages = kept;
   return { body: JSON.stringify(parsed), removed: indices.length, orphanIds };
 }
+const IDLE_TIMEOUT_MS = Number(process.env["SESSION_PROCESS_IDLE_MS"]) || 5 * 60 * 1e3;
+const MAX_RESTARTS = 3;
+const _processes = /* @__PURE__ */ new Map();
+class SessionProcess {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+  }
+  child = null;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 0;
+  idleTimer = null;
+  restartCount = 0;
+  destroyed = false;
+  /** Number of outstanding jobs sent to this process. */
+  get pendingCount() {
+    return this.pending.size;
+  }
+  ensureRunning() {
+    if (this.child !== null && this.child.connected) return this.child;
+    const entryPath = new URL("./sessionWorkerEntry.ts", import.meta.url).pathname;
+    const resolvedPath = process.platform === "win32" && entryPath.startsWith("/") ? entryPath.slice(1) : entryPath;
+    this.child = fork(resolvedPath, [], {
+      stdio: ["pipe", "pipe", "pipe", "ipc"]
+    });
+    this.restartCount += 1;
+    this.child.on("message", (msg) => {
+      const pending = this.pending.get(msg.id);
+      if (pending !== void 0) {
+        this.pending.delete(msg.id);
+        pending.resolve(msg.result);
+      }
+      this.resetIdleTimer();
+    });
+    this.child.on("error", (err) => {
+      logger.error(`[sessionProcess] Session ${this.sessionId} process error:`, err.message);
+    });
+    this.child.on("exit", (code, signal) => {
+      const wasConnected = this.child !== null;
+      this.child = null;
+      if (this.destroyed) return;
+      for (const [, pending] of this.pending) {
+        pending.reject(
+          new Error(
+            `Session process exited with code ${code ?? signal}, session=${this.sessionId}`
+          )
+        );
+      }
+      this.pending.clear();
+      if (wasConnected && this.restartCount <= MAX_RESTARTS) {
+        logger.warn(
+          `[sessionProcess] Session ${this.sessionId} worker exited (code=${code ?? signal}), restart ${this.restartCount}/${MAX_RESTARTS}`
+        );
+      }
+    });
+    this.resetIdleTimer();
+    return this.child;
+  }
+  enqueue(job) {
+    return new Promise((resolve, reject) => {
+      const child = this.ensureRunning();
+      const id = String(++this.nextId);
+      this.pending.set(id, { resolve, reject });
+      child.send({ id, job });
+    });
+  }
+  resetIdleTimer() {
+    if (this.idleTimer !== null) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      if (this.pending.size === 0) {
+        this.destroy();
+      }
+    }, IDLE_TIMEOUT_MS);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.idleTimer !== null) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.child !== null) {
+      this.child.kill();
+      this.child = null;
+    }
+    _processes.delete(this.sessionId);
+  }
+}
+function getSessionProcess(sessionId) {
+  const existing = _processes.get(sessionId);
+  if (existing !== void 0) return existing;
+  const sp = new SessionProcess(sessionId);
+  _processes.set(sessionId, sp);
+  return sp;
+}
+function buildFileLogEntry(log, upstreamUrl) {
+  return {
+    timestamp: log.timestamp,
+    id: log.id,
+    method: log.method,
+    path: log.path,
+    model: log.model,
+    sessionId: log.sessionId,
+    rawRequestBody: log.rawRequestBody,
+    responseStatus: log.responseStatus,
+    responseText: log.responseText,
+    inputTokens: log.inputTokens,
+    outputTokens: log.outputTokens,
+    cacheCreationInputTokens: log.cacheCreationInputTokens,
+    cacheReadInputTokens: log.cacheReadInputTokens,
+    elapsedMs: log.elapsedMs,
+    streaming: log.streaming,
+    userAgent: log.userAgent,
+    origin: log.origin,
+    upstreamUrl,
+    clientPort: log.clientPort,
+    clientPid: log.clientPid,
+    clientCwd: log.clientCwd,
+    clientProjectFolder: log.clientProjectFolder,
+    streamingChunks: log.streamingChunks,
+    streamingChunksPath: log.streamingChunksPath,
+    error: log.error
+  };
+}
+function cloneLog(log) {
+  return { ...log };
+}
+function errorMessage$2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function persistStreamingChunks(log) {
+  if (log.streamingChunks !== void 0 && log.streamingChunks.chunks.length > 0) {
+    const chunkPath = writeChunks(
+      log.id,
+      log.streamingChunks.chunks,
+      log.streamingChunks.truncated
+    );
+    log.streamingChunksPath = chunkPath;
+  }
+}
+function finalizeWithError(job, log, fallbackStatus, fallbackResponseText, err) {
+  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 };
+}
+function finalizeNonStreaming(job, log) {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null) {
+    return finalizeWithError(job, log, job.responseStatus, job.responseBody, "Unsupported format");
+  }
+  try {
+    const tokens = formatHandler.extractTokens(job.responseBody);
+    log.elapsedMs = job.elapsedMs;
+    log.responseStatus = job.responseStatus;
+    log.responseText = job.responseBody;
+    log.inputTokens = tokens.inputTokens;
+    log.outputTokens = tokens.outputTokens;
+    log.cacheCreationInputTokens = tokens.cacheCreationInputTokens;
+    log.cacheReadInputTokens = tokens.cacheReadInputTokens;
+    return { log, upstreamUrl: job.upstreamUrl, error: null };
+  } catch (err) {
+    return finalizeWithError(job, log, job.responseStatus, job.responseBody, err);
+  }
+}
+function finalizeStreaming(job, log) {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null) {
+    return finalizeWithError(job, log, job.responseStatus, job.rawStream, "Unsupported format");
+  }
+  try {
+    log.elapsedMs = job.elapsedMs;
+    log.responseStatus = job.responseStatus;
+    log.responseText = formatHandler.extractStream(
+      job.rawStream,
+      log,
+      log.model ?? void 0,
+      true
+    );
+    persistStreamingChunks(log);
+    return { log, upstreamUrl: job.upstreamUrl, error: null };
+  } catch (err) {
+    return finalizeWithError(job, log, job.responseStatus, job.rawStream, err);
+  }
+}
+function finalizeStreamAbort(job, log) {
+  const formatHandler = formatForPath(log.path);
+  if (formatHandler === null && job.hasChunks) {
+    return finalizeWithError(job, log, 499, "Client aborted", "Unsupported format");
+  }
+  try {
+    log.elapsedMs = job.elapsedMs;
+    if (job.hasChunks && formatHandler !== null) {
+      log.responseText = formatHandler.extractStream(
+        job.rawStream,
+        log,
+        log.model ?? void 0,
+        true
+      );
+      persistStreamingChunks(log);
+    } else {
+      log.responseText = "Client aborted";
+    }
+    return { log, upstreamUrl: job.upstreamUrl, error: "Client aborted" };
+  } catch (err) {
+    return finalizeWithError(job, log, 499, "Client aborted", err);
+  }
+}
+function buildFinalizeLogResult(job) {
+  const log = cloneLog(job.log);
+  switch (job.type) {
+    case "non-streaming":
+      return finalizeNonStreaming(job, log);
+    case "streaming":
+      return finalizeStreaming(job, log);
+    case "stream-abort":
+      return finalizeStreamAbort(job, log);
+  }
+}
+function commitFinalizeLogResult(result) {
+  appendLogEntry({ ...buildFileLogEntry(result.log, result.upstreamUrl), error: result.error });
+  finalizeLogUpdate(result.log);
+}
+const RUNTIME = (() => {
+  if (process.env["FINALIZER_USE_WORKER"] === "0") return "inline";
+  const mode = process.env["FINALIZER_RUNTIME"];
+  if (mode === "worker") return "worker";
+  if (mode === "inline") return "inline";
+  return "process";
+})();
+function executeBuildInSessionProcess(job) {
+  const sessionId = job.log.sessionId ?? "__unassigned__";
+  return getSessionProcess(sessionId).enqueue(job).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(
+      `[logFinalizer] Session process failed for log #${job.log.id}, falling back to in-process: ${message}`
+    );
+    return buildFinalizeLogResult(job);
+  });
+}
+function resolveBuildPromise(job) {
+  switch (RUNTIME) {
+    case "process":
+      return executeBuildInSessionProcess(job);
+    case "worker":
+      return executeBuildInWorker(job);
+    case "inline":
+      return Promise.resolve(buildFinalizeLogResult(job));
+  }
+}
+const WORKER_COUNT = Math.max(1, Number(process.env["FINALIZER_WORKER_COUNT"]) || 4);
+let _workers = null;
+const _pending = /* @__PURE__ */ new Map();
+let _nextWorker = 0;
+let _jobSeq = 0;
+function getWorkers() {
+  if (_workers !== null) return _workers;
+  _workers = [];
+  for (let i = 0; i < WORKER_COUNT; i++) {
+    const w = new Worker(new URL("./logFinalizer.worker.ts", import.meta.url));
+    w.on("message", (msg) => {
+      const resolve = _pending.get(msg.id);
+      if (resolve !== void 0) {
+        _pending.delete(msg.id);
+        resolve(msg.result);
+      }
+    });
+    w.on("error", (err) => {
+      logger.error(
+        "[logFinalizer] Worker error:",
+        err instanceof Error ? err.message : String(err)
+      );
+    });
+    _workers.push(w);
+  }
+  return _workers;
+}
+function executeBuildInWorker(job) {
+  return new Promise((resolve) => {
+    const list = getWorkers();
+    const idx = _nextWorker % list.length;
+    _nextWorker++;
+    const w = list[idx];
+    if (w === void 0) return;
+    const id = String(++_jobSeq);
+    _pending.set(id, resolve);
+    w.postMessage({ id, job });
+  });
+}
+function executeFinalizeLogJob(job) {
+  return resolveBuildPromise(job).then((result) => {
+    commitFinalizeLogResult(result);
+    if (result.error !== null && result.error !== "Client aborted") {
+      return Promise.reject(new Error(result.error));
+    }
+    return void 0;
+  });
+}
+const UNASSIGNED_SESSION_QUEUE = "__unassigned__";
+const queues = /* @__PURE__ */ new Map();
+function queueKeyForSession(sessionId) {
+  return sessionId ?? UNASSIGNED_SESSION_QUEUE;
+}
+function errorMessage$1(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function runSessionTask(sessionId, taskName, task) {
+  markSessionTaskStarted(sessionId);
+  try {
+    const result = await task();
+    markSessionTaskFinished(sessionId, null);
+    return result;
+  } catch (err) {
+    const message = errorMessage$1(err);
+    logger.error(`[sessionRuntime] ${taskName} failed for session ${sessionId ?? "unassigned"}`);
+    markSessionTaskFinished(sessionId, message);
+    return Promise.reject(err);
+  }
+}
+function enqueueSessionTask(sessionId, taskName, task) {
+  const queueKey = queueKeyForSession(sessionId);
+  const previous = queues.get(queueKey) ?? Promise.resolve();
+  markSessionTaskQueued(sessionId);
+  const current = previous.catch(() => void 0).then(() => runSessionTask(sessionId, taskName, task));
+  const settled = current.then(
+    () => void 0,
+    () => void 0
+  );
+  queues.set(queueKey, settled);
+  void settled.then(() => {
+    if (queues.get(queueKey) === settled) {
+      queues.delete(queueKey);
+    }
+  });
+  return current;
+}
+function enqueueFinalizeLogJob(job) {
+  return enqueueSessionTask(
+    getLogSessionId(job.log),
+    "finalize-log",
+    () => executeFinalizeLogJob(job)
+  );
+}
 function describeApiRoute(apiPath) {
   const endpointPath = apiPath.split("?")[0] ?? "";
   const isChatCompletions = endpointPath === PATH_CHAT_COMPLETIONS || endpointPath === PATH_V1_CHAT_COMPLETIONS;
@@ -2430,33 +3003,6 @@ function buildProxyHeaders(originalHeaders) {
   }
   return { headers, rawHeaders };
 }
-function buildFileLogEntry(log, upstreamUrl) {
-  return {
-    timestamp: log.timestamp,
-    id: log.id,
-    method: log.method,
-    path: log.path,
-    model: log.model,
-    sessionId: log.sessionId,
-    rawRequestBody: log.rawRequestBody,
-    responseStatus: log.responseStatus,
-    responseText: log.responseText,
-    inputTokens: log.inputTokens,
-    outputTokens: log.outputTokens,
-    elapsedMs: log.elapsedMs,
-    streaming: log.streaming,
-    userAgent: log.userAgent,
-    origin: log.origin,
-    upstreamUrl,
-    clientPort: log.clientPort,
-    clientPid: log.clientPid,
-    clientCwd: log.clientCwd,
-    clientProjectFolder: log.clientProjectFolder,
-    streamingChunks: log.streamingChunks,
-    streamingChunksPath: log.streamingChunksPath,
-    error: log.error
-  };
-}
 function parseRequestPath(req, url) {
   const route = describeApiRoute(getProxyApiPath(url));
   const isPost = req.method === "POST";
@@ -2469,17 +3015,27 @@ function parseRequestPath(req, url) {
     normalizedPath: route.normalizedPath
   };
 }
-function handleNonStreamingResponse(upstreamRes, responseBody, startTime, formatHandler, upstreamUrl, log) {
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function scheduleLogFinalization(job) {
+  void enqueueFinalizeLogJob(job).catch((err) => {
+    logger.error(
+      `[handler] Session finalization task failed for log #${job.log.id}:`,
+      errorMessage(err)
+    );
+  });
+}
+function handleNonStreamingResponse(upstreamRes, responseBody, startTime, upstreamUrl, log) {
   const elapsedMs = Date.now() - startTime;
-  const tokens = formatHandler.extractTokens(responseBody);
-  log.elapsedMs = elapsedMs;
-  log.responseStatus = upstreamRes.status;
-  log.responseText = responseBody;
-  log.inputTokens = tokens.inputTokens;
-  log.outputTokens = tokens.outputTokens;
-  log.cacheCreationInputTokens = tokens.cacheCreationInputTokens;
-  log.cacheReadInputTokens = tokens.cacheReadInputTokens;
-  appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: null });
+  scheduleLogFinalization({
+    type: "non-streaming",
+    log,
+    upstreamUrl,
+    elapsedMs,
+    responseStatus: upstreamRes.status,
+    responseBody
+  });
   const responseHeaders = new Headers(upstreamRes.headers);
   responseHeaders.delete(HEADER_CONTENT_ENCODING);
   responseHeaders.delete(HEADER_CONTENT_LENGTH);
@@ -2488,7 +3044,7 @@ function handleNonStreamingResponse(upstreamRes, responseBody, startTime, format
     headers: responseHeaders
   });
 }
-function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log) {
+function handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log) {
   log.streaming = true;
   log.responseStatus = upstreamRes.status;
   const chunks = [];
@@ -2500,18 +3056,15 @@ function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, ups
     },
     flush() {
       const full = chunks.join("");
-      log.elapsedMs = Date.now() - startTime;
-      log.responseText = formatHandler.extractStream(full, log, log.model ?? void 0, true);
-      if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
-        const chunkPath = writeChunks(
-          log.id,
-          log.streamingChunks.chunks,
-          log.streamingChunks.truncated
-        );
-        log.streamingChunksPath = chunkPath;
-      }
-      appendLogEntry(buildFileLogEntry(log, upstreamUrl));
-      emitLogUpdate(log);
+      const elapsedMs = Date.now() - startTime;
+      scheduleLogFinalization({
+        type: "streaming",
+        log,
+        upstreamUrl,
+        elapsedMs,
+        responseStatus: upstreamRes.status,
+        rawStream: full
+      });
     }
   });
   if (upstreamRes.body === null) {
@@ -2521,23 +3074,17 @@ function handleStreamingResponse(upstreamRes, req, startTime, formatHandler, ups
   req.signal?.addEventListener("abort", () => {
     if (log.responseText === null) {
       logger.info(`[handler] Streaming client aborted: ${log.method} ${log.path}`);
-      log.elapsedMs = Date.now() - startTime;
-      if (chunks.length > 0) {
-        const full = chunks.join("");
-        log.responseText = formatHandler.extractStream(full, log, log.model ?? void 0, true);
-        if (log.streamingChunks && log.streamingChunks.chunks.length > 0) {
-          const chunkPath = writeChunks(
-            log.id,
-            log.streamingChunks.chunks,
-            log.streamingChunks.truncated
-          );
-          log.streamingChunksPath = chunkPath;
-        }
-      } else {
-        log.responseText = "Client aborted";
-      }
-      appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
-      emitLogUpdate(log);
+      const elapsedMs = Date.now() - startTime;
+      const full = chunks.join("");
+      const hasChunks = chunks.length > 0;
+      scheduleLogFinalization({
+        type: "stream-abort",
+        log,
+        upstreamUrl,
+        elapsedMs,
+        rawStream: full,
+        hasChunks
+      });
     }
   });
   const responseHeaders = new Headers(upstreamRes.headers);
@@ -2625,27 +3172,22 @@ async function handleProxy(req) {
       log.responseStatus = 499;
       log.responseText = "Client aborted";
       appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: "Client aborted" });
+      finalizeLogUpdate(log);
       return new Response("Client aborted", { status: 499 });
     }
     logger.error(`[handler] Proxy error: ${req.method} ${parsed.apiPath}`, String(err));
     log.responseStatus = STATUS_BAD_GATEWAY;
     log.responseText = String(err);
     appendLogEntry({ ...buildFileLogEntry(log, upstreamUrl), error: String(err) });
+    finalizeLogUpdate(log);
     return new Response(`Proxy error: ${err}`, { status: STATUS_BAD_GATEWAY });
   }
   const isStream = upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ?? false;
   if (!isStream) {
     const responseBody = await upstreamRes.text();
-    return handleNonStreamingResponse(
-      upstreamRes,
-      responseBody,
-      startTime,
-      formatHandler,
-      upstreamUrl,
-      log
-    );
+    return handleNonStreamingResponse(upstreamRes, responseBody, startTime, upstreamUrl, log);
   }
-  return handleStreamingResponse(upstreamRes, req, startTime, formatHandler, upstreamUrl, log);
+  return handleStreamingResponse(upstreamRes, req, startTime, upstreamUrl, log);
 }
 const Route$i = createFileRoute("/proxy/$")({
   server: {
@@ -2662,7 +3204,14 @@ const Route$i = createFileRoute("/proxy/$")({
 const Route$h = createFileRoute("/api/sessions")({
   server: {
     handlers: {
-      GET: () => Response.json(getSessions())
+      GET: ({ request }) => {
+        const url = new URL(request.url);
+        const details = url.searchParams.get("details");
+        if (details === "true" || details === "1") {
+          return Response.json(getSessionSnapshots());
+        }
+        return Response.json(getSessions());
+      }
     }
   }
 });
@@ -3832,7 +4381,7 @@ const Route$6 = createFileRoute("/api/logs/stream")({
         let cleanedUp = false;
         const unsubscribe = onLogUpdate((log) => {
           if (controllerRef === null) return;
-          if (sessionId !== void 0 && log.sessionId !== sessionId) return;
+          if (sessionId !== void 0 && getLogSessionId(log) !== sessionId) return;
           if (model !== void 0 && log.model !== model) return;
           try {
             const data = `data: ${JSON.stringify({ type: "update", log })}