@yeaft/webchat-agent 1.0.376 → 1.0.377

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.376"}
+{"version":"1.0.377"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.376",
+  "version": "1.0.377",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/debug-trace.js

@@ -10,9 +10,10 @@
  * best-effort: failures are logged and never allowed to stop the agent.
  */
 
-import { promises as fsp } from 'fs';
+import { createReadStream, promises as fsp } from 'fs';
 import { basename, dirname, extname, join } from 'path';
 import { createHash, randomUUID } from 'crypto';
+import { createInterface } from 'readline';
 import { truncateUtf8Text } from './perf-trace.js';
 
 const TRACE_VERSION = 3;
@@ -619,6 +620,7 @@ function serializableTraceMeta(trace) {
   const meta = {
     ...trace,
     loopCount: loops.length,
+    toolCount: tools.length,
     ...usage,
     loopModels: [...new Set(loops.map(loop => loop?.model).filter(Boolean))],
     stopReasons: [...new Set(loops.map(loop => loop?.stopReason).filter(Boolean))],
@@ -668,6 +670,33 @@ async function readJsonLines(filePath) {
   return records;
 }
 
+async function countRequestEvents(requestDir) {
+  const meta = await readJson(requestMetaPath(requestDir));
+  if (!meta?.requestId) {
+    const legacy = await readJson(requestFilePath(requestDir));
+    return {
+      loopCount: Array.isArray(legacy?.loops) ? legacy.loops.length : 0,
+      toolCount: Array.isArray(legacy?.tools) ? legacy.tools.length : 0,
+    };
+  }
+  let loopCount = 0;
+  let toolCount = 0;
+  const stream = createReadStream(requestEventsPath(requestDir), { encoding: 'utf8' });
+  stream.on('error', () => {});
+  try {
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line);
+        if (event?.type === 'loop' && event.record) loopCount += 1;
+        else if (event?.type === 'tool' && event.record) toolCount += 1;
+      } catch { /* Ignore one torn final append. */ }
+    }
+  } catch { /* Missing/unreadable event file counts as empty. */ }
+  return { loopCount, toolCount };
+}
+
 async function readRequestDir(requestDir) {
   const meta = await readJson(requestMetaPath(requestDir));
   if (!meta?.requestId) {
@@ -894,19 +923,15 @@ async function removeRequestDirIfIdentityMatches(requestDir, expected) {
 
 async function readTraceHeaders(rootDir, sessionId) {
   const traces = [];
-  const requestDirs = sessionId == null
-    ? await (async () => {
-      const dirs = [];
-      for (const entry of await readdirSafe(sessionRequestsDir(rootDir, null))) {
-        if (entry.isDirectory()) dirs.push(join(sessionRequestsDir(rootDir, null), entry.name));
-      }
-      return dirs;
-    })()
-    : await collectRequestDirs(rootDir, sessionId);
+  const requestDirs = await collectRequestDirs(rootDir, sessionId);
   for (const requestDir of requestDirs) {
     const meta = await readJson(requestMetaPath(requestDir));
-    const trace = meta?.requestId ? meta : await readJson(requestFilePath(requestDir));
-    if (!trace?.requestId || !trace?.requestKey || trace.sessionId !== sessionId) continue;
+    const stored = meta?.requestId ? meta : await readJson(requestFilePath(requestDir));
+    if (!stored?.requestId || !stored?.requestKey) continue;
+    if (sessionId != null && stored.sessionId !== sessionId) continue;
+    const trace = meta?.requestId ? { ...meta } : serializableTraceMeta(stored);
+    trace._persistedFormat = meta?.requestId ? 'events' : 'legacy';
+    trace._persistedRequestDir = requestDir;
     traces.push({
       trace,
       file: requestFilePath(requestDir),
@@ -917,6 +942,13 @@ async function readTraceHeaders(rootDir, sessionId) {
   return traces.sort((a, b) => ((a.openedAt || 0) - (b.openedAt || 0)) || String(a.trace.requestKey).localeCompare(String(b.trace.requestKey)));
 }
 
+async function readHeaderDetail(rootDir, header) {
+  const requestDir = header?._persistedRequestDir
+    || requestDirFor(rootDir, header?.sessionId || null, header?.requestKey);
+  const trace = await readRequestDir(requestDir);
+  return sameTraceIdentity(trace, header) ? trace : null;
+}
+
 async function countDirFiles(rootDir) {
   let files = 0;
   let bytes = 0;
@@ -947,6 +979,8 @@ export class DebugTrace {
   #initializedRequestKeys = new Set();
   /** @type {Set<string>} */
   #reconciledRetentionSessions = new Set();
+  /** @type {Map<string, object>} Lightweight persisted metadata by request key. */
+  #diskHeaders = new Map();
   /** @type {Map<string, Map<string, { trace: object, requestDirs: Set<string>, openedAt: number }>>} */
   #retentionIndex = new Map();
   /** @type {NodeJS.Timeout|null} */
@@ -971,9 +1005,9 @@ export class DebugTrace {
   /** @type {NodeJS.Timeout|null} */
   #eventFlushTimer = null;
   /**
-   * One-time hydrate guard. Reads/maintenance load every on-disk trace into
-   * #requestCache exactly once; afterwards every query is served from memory
-   * with zero disk reads. The write path never hydrates — it only appends.
+   * One-time metadata hydrate guard. Reads/maintenance keep only bounded
+   * request headers resident. Full loop/tool payloads are loaded for one
+   * selected request at a time and are never installed in #requestCache.
    * @type {boolean}
    */
   #hydrated = false;
@@ -1270,16 +1304,20 @@ export class DebugTrace {
     await this.#ensureHydrated();
     await this.#drainWrites();
     const tools = [];
-    for (const { trace } of this.#traceSummaries()) {
+    for (const { trace: header } of this.#traceSummaries().slice().reverse()) {
+      const trace = this.#requestCache.get(header.requestKey)
+        || await readHeaderDetail(this.#rootDir, header);
+      if (!trace) continue;
       for (const tool of Array.isArray(trace.tools) ? trace.tools : []) {
         const row = traceToolToLegacy(trace, tool);
         if (name && row.tool_name !== name) continue;
         if (since && row.created_at < since) continue;
         tools.push(row);
       }
+      tools.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
+      if (tools.length > 100) tools.length = 100;
     }
-    tools.sort((a, b) => (b.created_at || 0) - (a.created_at || 0));
-    return tools.slice(0, 100);
+    return tools;
   }
 
   async search(keyword) {
@@ -1287,19 +1325,42 @@ export class DebugTrace {
     await this.#drainWrites();
     const needle = String(keyword || '').toLowerCase();
     if (!needle) return [];
-    return this.#traceSummaries()
-      .filter(({ trace }) => JSON.stringify(trace).toLowerCase().includes(needle))
-      .slice(-50)
-      .reverse()
-      .flatMap(({ trace }) => traceToLegacyRows(trace));
+    const results = [];
+    for (const { trace: header } of this.#traceSummaries().slice().reverse()) {
+      const trace = this.#requestCache.get(header.requestKey)
+        || await readHeaderDetail(this.#rootDir, header);
+      if (!trace || !JSON.stringify(trace).toLowerCase().includes(needle)) continue;
+      results.push(...traceToLegacyRows(trace));
+      if (results.length >= 50) break;
+    }
+    return results.slice(0, 50);
   }
 
   async stats() {
     await this.#ensureHydrated();
     await this.#drainWrites();
     const traces = this.#traceSummaries().map(({ trace }) => trace);
-    const turnCount = traces.reduce((n, trace) => n + (Array.isArray(trace.loops) ? trace.loops.length : 0), 0);
-    const toolCount = traces.reduce((n, trace) => n + (Array.isArray(trace.tools) ? trace.tools.length : 0), 0);
+    let turnCount = 0;
+    let toolCount = 0;
+    for (const header of traces) {
+      const live = this.#requestCache.get(header.requestKey);
+      if (live) {
+        turnCount += Array.isArray(live.loops) ? live.loops.length : Number(live.loopCount || 0);
+        toolCount += Array.isArray(live.tools) ? live.tools.length : Number(live.toolCount || 0);
+        continue;
+      }
+      if (Number.isFinite(Number(header.loopCount)) && Number.isFinite(Number(header.toolCount))) {
+        turnCount += Number(header.loopCount);
+        toolCount += Number(header.toolCount);
+        continue;
+      }
+      const counts = await countRequestEvents(
+        header._persistedRequestDir
+          || requestDirFor(this.#rootDir, header.sessionId || null, header.requestKey),
+      );
+      turnCount += counts.loopCount;
+      toolCount += counts.toolCount;
+    }
     const eventCount = this.#events.length;
     const { bytes } = await countDirFiles(this.#rootDir);
     return { turnCount, toolCount, eventCount, dbSizeBytes: bytes, fileSizeBytes: bytes, requestCount: traces.length };
@@ -1331,6 +1392,7 @@ export class DebugTrace {
     await ensureDir(this.#rootDir);
     this.#turnIndex.clear();
     this.#requestCache.clear();
+    this.#diskHeaders.clear();
     this.#initializedRequestKeys.clear();
     this.#reconciledRetentionSessions.clear();
     this.#retentionIndex.clear();
@@ -1429,11 +1491,10 @@ export class DebugTrace {
   }
 
   #traceSummaries(sessionId = null) {
-    // Cache-only: #ensureHydrated() has already merged every on-disk trace
-    // into #requestCache exactly once, so we never touch disk here. This is
-    // what turns the old O(N^2) per-query rescan into an in-memory filter.
+    const merged = new Map(this.#diskHeaders);
+    for (const trace of this.#requestCache.values()) merged.set(trace.requestKey, trace);
     const out = [];
-    for (const trace of this.#requestCache.values()) {
+    for (const trace of merged.values()) {
       if (sessionId && trace.sessionId !== sessionId) continue;
       if (!trace?.requestId || !trace?.requestKey) continue;
       out.push({
@@ -1446,34 +1507,24 @@ export class DebugTrace {
   }
 
   /**
-   * Load every on-disk trace into #requestCache exactly once. Live entries
-   * (created by this process) always win over their disk copy — a flush may
-   * be mid-flight, and the in-memory trace is the newer truth. Idempotent and
-   * concurrency-safe: overlapping callers await the same promise.
-   *
-   * Footprint trade-off (deliberate): this pins every session's full trace
-   * payload (systemPrompt + cumulative messages + rawRequest, each already
-   * byte-bounded) in #requestCache for the instance's lifetime — O(retention ×
-   * total sessions) memory instead of the old O(N²) per-query CPU rescan that
-   * stalled the event loop. Retention (10/session) and the byte caps keep it
-   * bounded, and the web path uses a single module-level instance. Follow-up if
-   * footprint ever bites: hydrate per queried sessionId, or keep only a
-   * lightweight summary resident and lazy-load full payloads on detailTurnId.
+   * Load lightweight persisted metadata once. Active requests stay in
+   * #requestCache; completed payloads remain on disk and are lazy-loaded only
+   * for detail/search/tool queries. This prevents retained debug history from
+   * expanding into a process-lifetime multi-gigabyte object graph.
    */
   async #ensureHydrated() {
     if (this.#hydrated) return;
     if (this.#hydratePromise) return this.#hydratePromise;
     this.#hydratePromise = (async () => {
-      const [summaries, storedEvents] = await Promise.all([
-        readTraceSummaries(this.#rootDir),
+      const [headers, storedEvents] = await Promise.all([
+        readTraceHeaders(this.#rootDir, null),
         readJson(join(this.#rootDir, 'events.json')),
       ]);
-      for (const { trace } of summaries) {
-        if (!trace?.requestKey) continue;
-        // Never clobber a live in-memory trace with its older disk snapshot.
-        if (!this.#requestCache.has(trace.requestKey)) {
-          this.#requestCache.set(trace.requestKey, trace);
-        }
+      for (const { trace } of headers) {
+        if (!trace?.requestKey || this.#requestCache.has(trace.requestKey)) continue;
+        this.#diskHeaders.set(trace.requestKey, trace.active
+          ? { ...trace, active: false, interrupted: true }
+          : trace);
       }
       if (Array.isArray(storedEvents)) this.#mergeStoredEvents(storedEvents);
       this.#hydrated = true;
@@ -1592,13 +1643,23 @@ export class DebugTrace {
           const eventPath = requestEventsPath(requestDir);
           if (initialize) await prepareJsonlAppend(eventPath);
           await fsp.appendFile(eventPath, lines.join(''), 'utf8');
-          if (writeMeta) await atomicWriteText(metaPath, JSON.stringify(serializableTraceMeta(trace)));
+          if (writeMeta) {
+            const meta = serializableTraceMeta(trace);
+            await atomicWriteText(metaPath, JSON.stringify(meta));
+            this.#diskHeaders.set(trace.requestKey, meta);
+          }
           trace._persistedFormat = 'events';
           trace._persistedRequestDir = requestDir;
           if (legacyRequestDir && legacyRequestDir !== requestDir) {
             await removeRequestDirIfIdentityMatches(legacyRequestDir, trace);
           }
-          if (evictAfterWrite) this.#requestCache.delete(trace.requestKey);
+          if (evictAfterWrite) {
+            this.#requestCache.delete(trace.requestKey);
+            this.#initializedRequestKeys.delete(trace.requestKey);
+            for (const [turnId, ctx] of this.#turnIndex) {
+              if (ctx.requestKey === trace.requestKey) this.#turnIndex.delete(turnId);
+            }
+          }
         } catch (err) {
           console.warn('[Yeaft] debug trace append failed:', err?.message || err);
         }
@@ -1694,6 +1755,7 @@ export class DebugTrace {
 
   async #pruneAll(keep) {
     const sessions = new Set();
+    for (const trace of this.#diskHeaders.values()) sessions.add(trace.sessionId || null);
     for (const trace of this.#requestCache.values()) sessions.add(trace.sessionId || null);
     for (const sessionId of sessions) await this.#pruneSession(sessionId, keep);
   }
@@ -1743,6 +1805,7 @@ export class DebugTrace {
     const stale = pruneCandidates.slice(0, Math.max(0, traces.length - protectedItems.length - keep));
     for (const item of stale) {
       this.#requestCache.delete(item.trace.requestKey);
+      this.#diskHeaders.delete(item.trace.requestKey);
       this.#initializedRequestKeys.delete(item.trace.requestKey);
       index.delete(item.trace.requestKey);
       for (const requestDir of item.requestDirs) {

package/yeaft/web-bridge.js

@@ -954,7 +954,12 @@ function registerRoutePromise(msgId, promise) {
     routePromisesByMsgId.set(msgId, set);
   }
   set.add(promise);
-  promise.finally(() => set.delete(promise)).catch(() => {});
+  promise.finally(() => {
+    set.delete(promise);
+    if (set.size === 0 && routePromisesByMsgId.get(msgId) === set) {
+      routePromisesByMsgId.delete(msgId);
+    }
+  }).catch(() => {});
 }
 
 
@@ -1859,7 +1864,12 @@ function getOrCreateVpEngine(sessionId, vpId, threadId = 'main') {
  */
 function getOrCreateSessionContext(sessionId, sessionHandle) {
   let entry = sessionContexts.get(sessionId);
-  if (entry && entry.coord && entry.router) return entry;
+  if (entry && entry.coord && entry.router) {
+    if (sessionHandle && sessionHandle !== entry.sessionHandle) {
+      try { sessionHandle.close?.(); } catch { /* best-effort unused handle cleanup */ }
+    }
+    return entry;
+  }
   // Either no entry, or a partial entry seeded by `getOrCreateSessionHistory`
   // (no coord/router yet). Build the coord/router and merge into the
   // existing record so the per-group history reference and hydration
@@ -7820,6 +7830,20 @@ export const __testHooks = {
   async loadProjectRuntime(workDir) {
     return loadProjectRuntime(workDir);
   },
+  registerRoutePromiseForTest(msgId, promise) {
+    registerRoutePromise(msgId, promise);
+  },
+  routePromiseEntryCountForTest() {
+    return routePromisesByMsgId.size;
+  },
+  getOrCreateSessionContextForTest(sessionId, sessionHandle) {
+    return getOrCreateSessionContext(sessionId, sessionHandle);
+  },
+  clearSessionContextForTest(sessionId) {
+    const entry = sessionContexts.get(sessionId);
+    try { entry?.sessionHandle?.close?.(); } catch { /* best-effort test cleanup */ }
+    sessionContexts.delete(sessionId);
+  },
   seedSessionContext(sessionId, meta) {
     const group = {
       getMeta() { return structuredClone(meta); },