@yeaft/webchat-agent 1.0.549 → 1.0.550

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.549"}
+{"version":"1.0.550"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.549",
+  "version": "1.0.550",
   "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

@@ -353,7 +353,9 @@ function buildRequestSnapshot(info = {}) {
     systemPrompt: String(info.systemPrompt || ''),
     messages: Array.isArray(info.messages) ? cloneJsonValue(info.messages) : [],
     requestInputBreakdown: normalizeRequestInputBreakdown(info.requestInputBreakdown),
-    rawRequest: info.rawRequest ?? null,
+    // Own the latest snapshot: adapters/callers may extend their message array
+    // after endTurn. Keeping that live reference would silently skip raw deltas.
+    rawRequest: cloneRawValue(info.rawRequest) ?? null,
   };
 }
 
@@ -501,6 +503,8 @@ function serializableTraceMeta(trace) {
   delete meta._lastSnapshot;
   delete meta._persistedFormat;
   delete meta._persistedRequestDir;
+  delete meta._payloadReleased;
+  delete meta._failedAppend;
   delete meta.baseRequest;
   delete meta.loops;
   delete meta.tools;
@@ -553,6 +557,8 @@ async function countRequestEvents(requestDir) {
   }
   let loopCount = 0;
   let toolCount = 0;
+  const loopIds = new Set();
+  const toolIds = new Set();
   const stream = createReadStream(requestEventsPath(requestDir), { encoding: 'utf8' });
   stream.on('error', () => {});
   try {
@@ -561,8 +567,13 @@ async function countRequestEvents(requestDir) {
       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;
+        if (event?.type === 'loop' && event.record) {
+          const id = event.record.turnRowId || event.record.loopInstanceId || `${event.record.loopNumber || 0}`;
+          if (!loopIds.has(id)) { loopIds.add(id); loopCount += 1; }
+        } else if (event?.type === 'tool' && event.record) {
+          const id = event.record.id || `${event.record.turnRowId || ''}:${event.record.toolCallId || ''}`;
+          if (!toolIds.has(id)) { toolIds.add(id); toolCount += 1; }
+        }
       } catch { /* Ignore one torn final append. */ }
     }
   } catch { /* Missing/unreadable event file counts as empty. */ }
@@ -853,6 +864,28 @@ async function readHeaderDetail(rootDir, header) {
   return sameTraceIdentity(trace, header) ? trace : null;
 }
 
+/** Detail reads combine durable payload with records whose append failed. The
+ * compact live rows must never overwrite full disk rows or hide unwritten data. */
+async function readAvailableTrace(rootDir, trace) {
+  if (!trace?._payloadReleased) return trace;
+  const stored = await readHeaderDetail(rootDir, trace);
+  const loops = new Map((stored?.loops || []).map(loop => [loop.turnRowId || loop.loopInstanceId, loop]));
+  for (const loop of trace.loops || []) {
+    if (Object.hasOwn(loop, 'requestDelta')) loops.set(loop.turnRowId || loop.loopInstanceId, loop);
+  }
+  const tools = new Map((stored?.tools || []).map(tool => [tool.id, tool]));
+  for (const tool of trace.tools || []) {
+    if (Object.hasOwn(tool, 'toolOutput')) tools.set(tool.id, tool);
+  }
+  return {
+    ...trace,
+    baseRequest: stored?.baseRequest || null,
+    loops: [...loops.values()].sort((a, b) => (a.loopNumber || 0) - (b.loopNumber || 0)
+      || String(a.turnRowId || '').localeCompare(String(b.turnRowId || ''))),
+    tools: [...tools.values()],
+  };
+}
+
 async function countDirFiles(rootDir) {
   let files = 0;
   let bytes = 0;
@@ -986,10 +1019,10 @@ export class DebugTrace {
       // it to a transport failure or another uncaptured attempt.
       rawRequest: Object.prototype.hasOwnProperty.call(info, 'rawRequest')
         ? info.rawRequest
-        : (trace.baseRequest?.rawRequest ?? null),
+        : (trace._lastSnapshot?.rawRequest ?? trace.baseRequest?.rawRequest ?? null),
     });
     const previousSnapshot = trace._lastSnapshot || this.#reconstructLastSnapshot(trace);
-    if (!trace.baseRequest) {
+    if (!previousSnapshot) {
       trace.baseRequest = {
         systemPrompt: snapshot.systemPrompt,
         messages: Array.isArray(snapshot.messages) ? cloneJsonValue(snapshot.messages) : [],
@@ -1065,7 +1098,7 @@ export class DebugTrace {
     };
     trace.tools.push(tool);
     trace.updatedAt = tool.createdAt;
-    this.#appendTraceRecord(trace, 'tool', tool, { writeMeta: false });
+    this.#appendTraceRecord(trace, 'tool', tool, { writeMeta: trace.active === false });
     return id;
   }
 
@@ -1142,6 +1175,7 @@ export class DebugTrace {
       item?.sessionId === requestedSessionId
       && (item.requestId === requestedTurnId || item.traceId === requestedTurnId)
     )) || null;
+    if (trace) trace = await readAvailableTrace(this.#rootDir, trace);
     if (!trace) {
       const locator = await readJson(turnLocatorPath(this.#rootDir, requestedSessionId, requestedTurnId));
       if (locator?.requestKey && locator.sessionId === requestedSessionId && locator.requestId === requestedTurnId) {
@@ -1218,8 +1252,8 @@ export class DebugTrace {
     await this.#drainWrites();
     const tools = [];
     for (const { trace: header } of this.#traceSummaries().slice().reverse()) {
-      const trace = this.#requestCache.get(header.requestKey)
-        || await readHeaderDetail(this.#rootDir, header);
+      const live = this.#requestCache.get(header.requestKey);
+      const trace = live ? await readAvailableTrace(this.#rootDir, live) : await readHeaderDetail(this.#rootDir, header);
       if (!trace) continue;
       for (const tool of Array.isArray(trace.tools) ? trace.tools : []) {
         const row = traceToolToLegacy(trace, tool);
@@ -1240,8 +1274,8 @@ export class DebugTrace {
     if (!needle) return [];
     const results = [];
     for (const { trace: header } of this.#traceSummaries().slice().reverse()) {
-      const trace = this.#requestCache.get(header.requestKey)
-        || await readHeaderDetail(this.#rootDir, header);
+      const live = this.#requestCache.get(header.requestKey);
+      const trace = live ? await readAvailableTrace(this.#rootDir, live) : await readHeaderDetail(this.#rootDir, header);
       if (!trace || !JSON.stringify(trace).toLowerCase().includes(needle)) continue;
       results.push(...traceToLegacyRows(trace));
       if (results.length >= 50) break;
@@ -1319,6 +1353,23 @@ export class DebugTrace {
   async close() {
     this.#acceptingWrites = false;
     await this.#drainWrites();
+    // One final bounded retry, also for a failure with no later loop/finalize.
+    // Persistent disk errors retain diagnostics rather than silently evicting.
+    for (const trace of this.#requestCache.values()) {
+      const failed = trace._failedAppend;
+      if (!failed) continue;
+      delete trace._failedAppend;
+      for (const entry of failed.records) {
+        this.#pendingWrites.push({ trace, ...entry, initialize: true,
+          writeMeta: failed.writeMeta, evictAfterWrite: failed.evictAfterWrite });
+      }
+    }
+    await this.#drainWrites();
+    if ([...this.#requestCache.values()].some(trace => trace._failedAppend)) return;
+    this.#requestCache.clear();
+    this.#turnIndex.clear();
+    this.#retentionIndex.clear();
+    this.#reconciledRetentionSessions.clear();
   }
 
   /**
@@ -1410,6 +1461,12 @@ export class DebugTrace {
         .find(item => traceMatchesIdentity(item, sessionId, turnId)) || null;
     }
     if (!trace) return false;
+    // Legacy traces must keep their source payload until format migration has
+    // durably copied it. Event traces already own their history on disk.
+    if (trace._persistedFormat === 'events') {
+      trace._lastSnapshot = this.#reconstructLastSnapshot(trace);
+      this.#releasePersistedPayload(trace, [...trace.loops, ...trace.tools]);
+    }
     this.#requestCache.set(trace.requestKey, trace);
     return true;
   }
@@ -1477,6 +1534,25 @@ export class DebugTrace {
     return tracePathFor(this.#rootDir, trace.sessionId || null, trace.requestKey);
   }
 
+  /** Release only exact records known to be durable; newer replacements and
+   * in-flight records keep their payload. Lightweight rows preserve identity,
+   * counts and usage without keeping tool output/response/request bodies. */
+  #releasePersistedPayload(trace, records) {
+    const persisted = new Set(records);
+    trace.loops = (trace.loops || []).map(loop => {
+      if (!persisted.has(loop)) return loop;
+      const { response, toolCalls, rawRequest, rawResponse, requestDelta, ...meta } = loop;
+      return meta;
+    });
+    trace.tools = (trace.tools || []).map(tool => {
+      if (!persisted.has(tool)) return tool;
+      const { toolInput, toolOutput, ...meta } = tool;
+      return meta;
+    });
+    trace.baseRequest = null;
+    trace._payloadReleased = true;
+  }
+
   #appendTraceRecord(trace, type, record, { writeMeta = false, evictAfterWrite = false } = {}) {
     if (!this.#acceptingWrites || !trace?.requestKey || !record) return;
     this.#requestCache.set(trace.requestKey, trace);
@@ -1485,7 +1561,9 @@ export class DebugTrace {
     this.#pendingWrites.push({
       trace,
       type,
-      record: cloneJsonValue(record),
+      // Records are private immutable snapshots, already detached from caller
+      // input by endTurn/logTool. Do not serialize+parse a second full copy.
+      record,
       initialize,
       writeMeta: !!writeMeta,
       evictAfterWrite: !!evictAfterWrite,
@@ -1528,17 +1606,29 @@ export class DebugTrace {
       for (const entry of entries) {
         if (!this.#requestCache.has(entry.trace.requestKey)) continue;
         const requestDir = requestDirFor(this.#rootDir, entry.trace.sessionId || null, entry.trace.requestKey);
-        const batch = batches.get(requestDir) || { trace: entry.trace, initialize: false, writeMeta: false, evictAfterWrite: false, lines: [] };
+        const batch = batches.get(requestDir) || { trace: entry.trace, initialize: false, writeMeta: false, evictAfterWrite: false, records: [] };
         batch.trace = entry.trace;
         batch.initialize ||= entry.initialize;
         batch.writeMeta ||= entry.writeMeta;
         batch.evictAfterWrite ||= entry.evictAfterWrite;
-        batch.lines.push(`${JSON.stringify({ type: entry.type, record: entry.record })}\n`);
+        batch.records.push({ type: entry.type, record: entry.record });
         batches.set(requestDir, batch);
       }
       for (const [requestDir, batch] of batches) {
-        const { trace, initialize, writeMeta, evictAfterWrite } = batch;
-        const lines = [...batch.lines];
+        const { trace } = batch;
+        // A failed append may contain the base/delta for every later loop.
+        // Retry it before new records (including finalize); do not run a timer
+        // retry loop on a full disk. Record identity makes partial replay safe.
+        if (trace._failedAppend) {
+          const failed = trace._failedAppend;
+          batch.records.unshift(...failed.records);
+          batch.initialize = true; // recheck metadata and repair any partial tail
+          batch.writeMeta ||= failed.writeMeta;
+          batch.evictAfterWrite ||= failed.evictAfterWrite;
+        }
+        const { initialize, writeMeta, evictAfterWrite } = batch;
+        const records = [...batch.records];
+        const durableRecords = batch.records.map(entry => entry.record);
         const legacyRequestDir = trace._persistedFormat === 'legacy'
           ? trace._persistedRequestDir || null
           : null;
@@ -1548,14 +1638,16 @@ export class DebugTrace {
             const meta = serializableTraceMeta(trace);
             if (legacyRequestDir) {
               meta.legacyBaseRequest = cloneJsonValue(trace.baseRequest);
-              const legacyLines = [];
+              const legacyRecords = [];
               for (const loop of Array.isArray(trace.loops) ? trace.loops : []) {
-                legacyLines.push(`${JSON.stringify({ type: 'loop', record: loop })}\n`);
+                legacyRecords.push({ type: 'loop', record: loop });
+                durableRecords.push(loop);
               }
               for (const tool of Array.isArray(trace.tools) ? trace.tools : []) {
-                legacyLines.push(`${JSON.stringify({ type: 'tool', record: tool })}\n`);
+                legacyRecords.push({ type: 'tool', record: tool });
+                durableRecords.push(tool);
               }
-              lines.unshift(...legacyLines);
+              records.unshift(...legacyRecords);
             }
             await atomicWriteText(metaPath, JSON.stringify(meta));
             await atomicWriteText(
@@ -1566,18 +1658,29 @@ export class DebugTrace {
           await ensureDir(requestDir);
           const eventPath = requestEventsPath(requestDir);
           if (initialize) await prepareJsonlAppend(eventPath);
-          await fsp.appendFile(eventPath, lines.join(''), 'utf8');
+          // Serialize/write one record at a time, not all batch strings plus a
+          // second joined string. Raw diagnostics remain lossless on disk.
+          const handle = await fsp.open(eventPath, 'a');
+          try {
+            for (const record of records) await handle.writeFile(`${JSON.stringify(record)}\n`, 'utf8');
+          } finally { await handle.close(); }
           if (writeMeta) {
             const meta = serializableTraceMeta(trace);
             await atomicWriteText(metaPath, JSON.stringify(meta));
             this.#diskHeaders.set(trace.requestKey, meta);
           }
+          delete trace._failedAppend;
+          this.#releasePersistedPayload(trace, durableRecords);
           trace._persistedFormat = 'events';
           trace._persistedRequestDir = requestDir;
           if (legacyRequestDir && legacyRequestDir !== requestDir) {
             await removeRequestDirIfIdentityMatches(legacyRequestDir, trace);
           }
           if (evictAfterWrite) {
+            // Retention must not keep a second strong reference to finalized
+            // _lastSnapshot after the primary cache has evicted the request.
+            const retained = this.#retentionIndex.get(trace.sessionId || '')?.get(trace.requestKey);
+            if (retained) retained.trace = serializableTraceMeta(trace);
             this.#requestCache.delete(trace.requestKey);
             this.#initializedRequestKeys.delete(trace.requestKey);
             for (const [turnId, ctx] of this.#turnIndex) {
@@ -1585,6 +1688,9 @@ export class DebugTrace {
             }
           }
         } catch (err) {
+          // Keep immutable entries until a later append/close can durably retry
+          // them. In particular, finalize must not evict a failed base/delta.
+          trace._failedAppend = { records: batch.records, writeMeta, evictAfterWrite };
           console.warn('[Yeaft] debug trace append failed:', err?.message || err);
         }
       }

package/yeaft/engine.js

@@ -336,9 +336,10 @@ function sleepWithAbort(ms, signal) {
  *   - `toolCalls` on assistant turns (the LLM's function_call requests)
  *   - `toolCallId` + `isError` on tool turns (the paired tool_result)
  *
- * Content is kept intact for the live protocol. The file-backed debug trace
- * applies its own configured byte budget at persistence time so the model
- * request path never pays an extra copy just for diagnostics.
+ * Content is kept intact for the live protocol. Raw provider exchanges belong
+ * to the loop-level file-backed trace, never to its message snapshots: copying
+ * historical rawRequest values here multiplies retained request bodies on every
+ * tool loop. Do not even traverse diagnostic fields on incoming messages.
  *
  * Pure function — no side effects on the input message.
  *
@@ -348,7 +349,6 @@ function sleepWithAbort(ms, signal) {
 export function mapDebugMessage(m) {
   const out = { role: m.role };
   out.content = m.content;
-  if (m.rawRequest != null) out.rawRequest = m.rawRequest;
   if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
     out.toolCalls = m.toolCalls.map(tc => ({
       id: tc.id,
@@ -3741,7 +3741,10 @@ export class Engine {
       // yielding any post-stream diagnostics. A consumer may stop iterating at
       // any yield; persistence therefore cannot wait for turn_end or even the
       // debug `loop` event below.
-      const assistantMsg = { role: 'assistant', content: responseText, responseKind: 'progress', ...(rawRequest ? { rawRequest } : {}) };
+      // The complete exchange is already owned by the per-loop debug trace.
+      // Keeping it on model history retains every previous request and makes
+      // subsequent debug snapshots grow with cumulative request bodies.
+      const assistantMsg = { role: 'assistant', content: responseText, responseKind: 'progress' };
       if (toolCalls.length > 0) {
         assistantMsg.toolCalls = toolCalls.map(tc => ({
           id: tc.id,