@yeaft/webchat-agent 1.0.387 → 1.0.388

package/package.json

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

@@ -36,6 +36,10 @@ const TRACE_APPEND_BATCH_MS = 100;
 const EVENT_FLUSH_INTERVAL_MS = 30_000;
 const MAX_SEARCH_PATTERN_CHARS = 300;
 const DEFAULT_TRACE_TEXT_MAX_BYTES = 256 * 1024;
+// A turn detail is returned as one WebSocket message. Keep its UI projection
+// comfortably below the Agent connection's 8 MiB outbound queue ceiling while
+// preserving the canonical file-backed trace without any extra truncation.
+const DEBUG_DETAIL_WIRE_MAX_BYTES = 6 * 1024 * 1024;
 
 function isPlainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value);
@@ -803,6 +807,169 @@ function expandTrace(trace) {
   return { loops, turns: Array.from(turnsById.values()) };
 }
 
+function debugDetailTextSentinel(value, maxBytes, path, originalBytes = jsonByteLength(value)) {
+  const text = value == null ? '' : String(value);
+  const budget = Math.max(2, Math.floor(Number(maxBytes) || 0));
+  if (originalBytes <= budget) return text;
+  const marker = `\n... [wire truncated ${path}; original ${originalBytes} bytes]`;
+  const rawBytes = Math.max(1, Buffer.byteLength(text, 'utf8'));
+  const expansion = Math.max(1, originalBytes / rawBytes);
+  const markerBytes = jsonByteLength(marker) - 2;
+  let previewBytes = Math.max(0, Math.floor((budget - markerBytes - 2) / expansion));
+  let projected = `${truncateUtf8Text(text, previewBytes).value}${marker}`;
+  let projectedBytes = jsonByteLength(projected);
+  if (projectedBytes > budget && previewBytes > 0) {
+    previewBytes = Math.max(0, Math.floor(previewBytes * (budget / projectedBytes)) - 8);
+    projected = `${truncateUtf8Text(text, previewBytes).value}${marker}`;
+    projectedBytes = jsonByteLength(projected);
+  }
+  if (projectedBytes <= budget) return projected;
+  if (jsonByteLength(marker) <= budget) return marker;
+  return '';
+}
+
+function debugDetailJsonSentinel(value, maxBytes, path, originalBytes = jsonByteLength(value)) {
+  if (value == null) return value;
+  const budget = Math.max(0, Math.floor(Number(maxBytes) || 0));
+  if (originalBytes <= budget) return value;
+  const base = {
+    __truncated: true,
+    reason: 'debug_detail_wire_budget',
+    path,
+    originalBytes,
+    maxBytes: budget,
+  };
+  const baseBytes = jsonByteLength(base);
+  if (baseBytes > budget) return budget >= 4 ? null : '';
+  let preview = '';
+  try {
+    const encoded = JSON.stringify(value);
+    preview = debugDetailTextSentinel(
+      encoded,
+      Math.max(2, budget - baseBytes - 16),
+      path,
+      jsonByteLength(encoded),
+    );
+  } catch { /* metadata-only sentinel below */ }
+  const projected = preview ? { ...base, preview } : base;
+  return jsonByteLength(projected) <= budget ? projected : base;
+}
+
+function allocateDebugCandidateBudgets(candidates, totalBytes) {
+  const sorted = [...candidates].sort((a, b) => a.originalBytes - b.originalBytes || a.path.localeCompare(b.path));
+  let remainingBytes = Math.max(0, Math.floor(totalBytes));
+  let remainingCount = sorted.length;
+  for (let index = 0; index < sorted.length; index += 1) {
+    const candidate = sorted[index];
+    const fairShare = remainingCount > 0 ? Math.floor(remainingBytes / remainingCount) : 0;
+    if (candidate.originalBytes <= fairShare) {
+      candidate.budget = candidate.originalBytes;
+      remainingBytes -= candidate.budget;
+      remainingCount -= 1;
+      continue;
+    }
+    for (let tail = index; tail < sorted.length; tail += 1) {
+      const count = sorted.length - tail;
+      const budget = count > 0 ? Math.floor(remainingBytes / count) : 0;
+      sorted[tail].budget = budget;
+      remainingBytes -= budget;
+    }
+    break;
+  }
+}
+
+export function projectDebugDetailForWire(detail, maxBytes = DEBUG_DETAIL_WIRE_MAX_BYTES) {
+  // `fetchTurnDebug()` hands us a freshly expanded response object; mutate that
+  // disposable projection rather than cloning tens or hundreds of cumulative
+  // request snapshots. Canonical file records and the request cache are separate.
+  const wire = detail && typeof detail === 'object'
+    ? detail
+    : { loops: [], turns: [], dreamEvents: [] };
+  const payloadBudget = Math.max(0, maxBytes - 2048);
+  const candidates = [];
+  const addCandidate = (container, field, path) => {
+    if (!container || container[field] == null) return;
+    const value = container[field];
+    candidates.push({
+      container,
+      field,
+      path,
+      value,
+      originalBytes: jsonByteLength(value),
+      budget: 0,
+    });
+    // Measure the non-candidate envelope exactly once without serializing every
+    // cumulative request again after each replacement.
+    container[field] = null;
+  };
+
+  const loopFields = ['rawRequest', 'rawResponse', 'messages', 'requestBase', 'requestDelta', 'toolCalls', 'response', 'systemPrompt'];
+  for (const [loopIndex, loop] of (Array.isArray(wire.loops) ? wire.loops : []).entries()) {
+    if (!loop || typeof loop !== 'object') continue;
+    for (const field of loopFields) addCandidate(loop, field, `loops[${loopIndex}].${field}`);
+  }
+  for (const [turnIndex, turn] of (Array.isArray(wire.turns) ? wire.turns : []).entries()) {
+    if (!turn || typeof turn !== 'object') continue;
+    for (const field of ['userPrompt', 'memoryLoaded', 'memoryAdjust']) {
+      addCandidate(turn, field, `turns[${turnIndex}].${field}`);
+    }
+    for (const [toolIndex, tool] of (Array.isArray(turn.tools) ? turn.tools : []).entries()) {
+      if (!tool || typeof tool !== 'object') continue;
+      addCandidate(tool, 'toolInput', `turns[${turnIndex}].tools[${toolIndex}].toolInput`);
+      addCandidate(tool, 'toolOutput', `turns[${turnIndex}].tools[${toolIndex}].toolOutput`);
+    }
+  }
+  for (const [eventIndex] of (Array.isArray(wire.dreamEvents) ? wire.dreamEvents : []).entries()) {
+    addCandidate(wire.dreamEvents, eventIndex, `dreamEvents[${eventIndex}]`);
+  }
+
+  const skeletonBytes = jsonByteLength(wire);
+  const candidateBytes = candidates.reduce((sum, candidate) => sum + candidate.originalBytes, 0);
+  const originalBytes = skeletonBytes - (4 * candidates.length) + candidateBytes;
+  if (originalBytes <= payloadBudget) {
+    for (const candidate of candidates) candidate.container[candidate.field] = candidate.value;
+    return wire;
+  }
+  if (candidates.length === 0 || skeletonBytes > payloadBudget) {
+    throw new Error(`Debug detail metadata exceeds the ${maxBytes}-byte wire budget`);
+  }
+
+  // Each candidate currently occupies JSON `null` (4 bytes) in the skeleton.
+  // Water-fill the exact value budget: small fields stay complete, while large
+  // cumulative requests and tool outputs receive fair, independently bounded
+  // previews. This is O(total input bytes + candidates log candidates), with
+  // one final whole-envelope serialization rather than one per candidate.
+  const valueBudget = payloadBudget - skeletonBytes + (4 * candidates.length);
+  allocateDebugCandidateBudgets(candidates, valueBudget);
+  let truncatedFields = 0;
+  for (const candidate of candidates) {
+    if (candidate.originalBytes <= candidate.budget) {
+      candidate.container[candidate.field] = candidate.value;
+      continue;
+    }
+    const fieldBudget = candidate.budget;
+    candidate.container[candidate.field] = typeof candidate.value === 'string'
+      ? debugDetailTextSentinel(candidate.value, fieldBudget, candidate.path, candidate.originalBytes)
+      : debugDetailJsonSentinel(candidate.value, fieldBudget, candidate.path, candidate.originalBytes);
+    truncatedFields += 1;
+  }
+
+  wire.projection = {
+    truncated: true,
+    reason: 'debug_detail_wire_budget',
+    maxBytes,
+    truncatedFields,
+  };
+  const projectedBytesBase = jsonByteLength(wire);
+  let projectedBytes = projectedBytesBase + Buffer.byteLength(`,\"projectedBytes\":${projectedBytesBase}`, 'utf8');
+  projectedBytes = projectedBytesBase + Buffer.byteLength(`,\"projectedBytes\":${projectedBytes}`, 'utf8');
+  wire.projection.projectedBytes = projectedBytes;
+  if (projectedBytes > maxBytes) {
+    throw new Error(`Debug detail projection still exceeds the ${maxBytes}-byte wire budget`);
+  }
+  return wire;
+}
+
 function traceToLegacyRows(trace) {
   let snapshot = null;
   let rawRequest = trace?.baseRequest?.rawRequest ?? null;
@@ -1249,7 +1416,7 @@ export class DebugTrace {
     const dreamEvents = this.#readDreamEvents({ sessionId: requestedSessionId, dreamLimit });
     if (!trace) return { loops: [], turns: [], dreamEvents, detailTurnId: requestedTurnId };
     const expanded = expandTrace(trace);
-    return { ...expanded, dreamEvents, detailTurnId: requestedTurnId };
+    return projectDebugDetailForWire({ ...expanded, dreamEvents, detailTurnId: requestedTurnId });
   }
 
   async fetchRecentDebugHistory({ limit = MAX_HISTORY_LIMIT, dreamLimit = 5, sessionId = null, threadId = null, indexOnly = false, detailTurnId = null, search = '' } = {}) {

package/yeaft/web-bridge.js

@@ -6467,11 +6467,13 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
   const search = typeof msg?.search === 'string' ? msg.search.trim() : '';
   const requestId = typeof msg?.requestId === 'string' && msg.requestId ? msg.requestId : null;
   const requestKind = typeof msg?.requestKind === 'string' && msg.requestKind ? msg.requestKind : null;
+  const requestClientId = typeof msg?._requestClientId === 'string' && msg._requestClientId ? msg._requestClientId : null;
   const indexOnly = !!msg?.indexOnly;
   const detailTurnId = typeof msg?.detailTurnId === 'string' && msg.detailTurnId ? msg.detailTurnId : null;
   let loops = [];
   let turns = [];
   let dreamEvents = [];
+  let projection = null;
   let hasMore = false;
   try {
     if (session?.trace && detailTurnId && sessionId && typeof session.trace.fetchTurnDebug === 'function') {
@@ -6479,12 +6481,14 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
       loops = Array.isArray(out?.loops) ? out.loops : [];
       turns = Array.isArray(out?.turns) ? out.turns : [];
       dreamEvents = Array.isArray(out?.dreamEvents) ? out.dreamEvents : [];
+      projection = out?.projection && typeof out.projection === 'object' ? out.projection : null;
       hasMore = false;
     } else if (session?.trace && typeof session.trace.fetchRecentDebugHistory === 'function') {
       const out = await session.trace.fetchRecentDebugHistory({ limit, dreamLimit, sessionId, threadId, indexOnly, detailTurnId, search });
       loops = Array.isArray(out?.loops) ? out.loops : [];
       turns = Array.isArray(out?.turns) ? out.turns : [];
       dreamEvents = Array.isArray(out?.dreamEvents) ? out.dreamEvents : [];
+      projection = out?.projection && typeof out.projection === 'object' ? out.projection : null;
       hasMore = !!out?.hasMore;
     }
   } catch (err) {
@@ -6495,6 +6499,7 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
       dreamEvents: [],
       requestId,
       requestKind,
+      ...(requestClientId ? { _requestClientId: requestClientId } : {}),
       sessionId,
       threadId,
       search,
@@ -6510,8 +6515,10 @@ export async function handleYeaftFetchDebugHistory(msg = {}) {
     loops,
     turns,
     dreamEvents,
+    ...(projection ? { projection } : {}),
     requestId,
     requestKind,
+    ...(requestClientId ? { _requestClientId: requestClientId } : {}),
     sessionId,
     threadId,
     search,