@yeaft/webchat-agent 1.0.232 → 1.0.233

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.232",
+  "version": "1.0.233",
   "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/work-center/debug-projection.js

@@ -1,3 +1,5 @@
+import { createHash } from 'node:crypto';
+
 const MAX_DEBUG_STRING_BYTES = 64 * 1024;
 export const MAX_ACTION_REQUEST_DETAIL_BYTES = 256 * 1024;
 const MAX_ACTION_REQUEST_INPUT_BYTES = MAX_ACTION_REQUEST_DETAIL_BYTES;
@@ -33,6 +35,17 @@ function truncateUtf8(value, maxBytes = MAX_DEBUG_STRING_BYTES) {
   return `${bytes.subarray(0, end).toString('utf8')}${marker}`;
 }
 
+export function boundedDebugIdentity(value, maxBytes) {
+  const text = String(value || '');
+  if (!text || byteLength(text) <= maxBytes) return text;
+  const digest = createHash('sha256').update(text, 'utf8').digest('hex');
+  const suffix = `~${digest}`;
+  const bytes = Buffer.from(text, 'utf8');
+  let end = Math.max(0, maxBytes - byteLength(suffix));
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end -= 1;
+  return `${bytes.subarray(0, end).toString('utf8')}${suffix}`;
+}
+
 function normalizeSensitiveName(name) {
   return String(name || '').toLowerCase().replace(/[^a-z0-9]/g, '');
 }
@@ -260,6 +273,76 @@ function boundedDebugInputBytes(value, maxBytes) {
   return bytes > maxBytes ? maxBytes + 1 : bytes;
 }
 
+const MAX_ACTION_REQUEST_SUMMARY_ID_BYTES = 256;
+const MAX_ACTION_REQUEST_SUMMARY_NAME_BYTES = 512;
+const MAX_ACTION_REQUEST_SUMMARY_MODEL_BYTES = 1_024;
+const MAX_ACTION_REQUEST_SUMMARY_STOP_REASON_BYTES = 256;
+
+function summaryString(value, maxBytes, fallback = null) {
+  if (typeof value !== 'string' || !value) return fallback;
+  return truncateUtf8(value, maxBytes);
+}
+
+function summaryUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  return {
+    inputTokens: Math.max(0, Number(usage.inputTokens) || 0),
+    outputTokens: Math.max(0, Number(usage.outputTokens) || 0),
+    cacheReadTokens: Math.max(0, Number(usage.cacheReadTokens) || 0),
+    cacheWriteTokens: Math.max(0, Number(usage.cacheWriteTokens) || 0),
+    totalInputTokens: Math.max(0, Number(usage.totalInputTokens) || 0),
+    totalTokens: Math.max(0, Number(usage.totalTokens) || 0),
+  };
+}
+
+function minimalActionRequestLoopSummary(loop) {
+  return {
+    loopInstanceId: null,
+    loopNumber: Number(loop?.loopNumber) || 0,
+    model: null,
+    response: '',
+    usage: null,
+    latencyMs: 0,
+    ttfbMs: null,
+    stopReason: null,
+    at: 0,
+    toolCalls: [],
+    detailTruncated: true,
+  };
+}
+
+function actionRequestLoopSummary(loop) {
+  const toolCalls = Array.isArray(loop?.toolCalls) ? loop.toolCalls : [];
+  return {
+    loopInstanceId: boundedDebugIdentity(loop?.loopInstanceId, MAX_ACTION_REQUEST_SUMMARY_ID_BYTES) || null,
+    loopNumber: Number(loop?.loopNumber) || 0,
+    model: summaryString(loop?.model, MAX_ACTION_REQUEST_SUMMARY_MODEL_BYTES),
+    response: typeof loop?.response === 'string' ? truncateUtf8(loop.response, 8 * 1024) : '',
+    usage: summaryUsage(loop?.usage),
+    latencyMs: Math.max(0, Number(loop?.latencyMs) || 0),
+    ttfbMs: loop?.ttfbMs == null ? null : Math.max(0, Number(loop.ttfbMs) || 0),
+    stopReason: summaryString(loop?.stopReason, MAX_ACTION_REQUEST_SUMMARY_STOP_REASON_BYTES),
+    at: Math.max(0, Number(loop?.at) || 0),
+    toolCalls: toolCalls.slice(0, MAX_DEBUG_ARRAY_ITEMS).map(call => ({
+      id: boundedDebugIdentity(call?.id, MAX_ACTION_REQUEST_SUMMARY_ID_BYTES) || null,
+      name: summaryString(call?.name, MAX_ACTION_REQUEST_SUMMARY_NAME_BYTES, '?'),
+      input: null,
+    })),
+    detailTruncated: true,
+  };
+}
+
+function actionRequestToolSummary(tool) {
+  return {
+    loopNumber: Number(tool?.loopNumber) || 0,
+    callId: boundedDebugIdentity(tool?.callId, MAX_ACTION_REQUEST_SUMMARY_ID_BYTES) || null,
+    name: summaryString(tool?.name, MAX_ACTION_REQUEST_SUMMARY_NAME_BYTES, '?'),
+    durationMs: Math.max(0, Number(tool?.durationMs) || 0),
+    isError: tool?.isError === true,
+    toolOutput: null,
+  };
+}
+
 export function limitActionRequestDebugInput(loopValues, toolValues) {
   const sourceLoops = Array.isArray(loopValues) ? loopValues : [];
   const sourceTools = Array.isArray(toolValues) ? toolValues : [];
@@ -277,11 +360,25 @@ export function limitActionRequestDebugInput(loopValues, toolValues) {
   let remainingBytes = MAX_ACTION_REQUEST_INPUT_BYTES;
   const loops = [];
   const tools = [];
+  let summarizedLoopCount = 0;
   for (let index = candidates.length - 1; index >= 0; index -= 1) {
-    const loop = candidates[index];
-    const loopTools = toolsByLoop.get(Number(loop?.loopNumber) || 0) || [];
-    const inputBytes = boundedDebugInputBytes({ loop, tools: loopTools }, remainingBytes);
-    if (inputBytes > remainingBytes) continue;
+    const sourceLoop = candidates[index];
+    const sourceLoopTools = toolsByLoop.get(Number(sourceLoop?.loopNumber) || 0) || [];
+    let loop = sourceLoop;
+    let loopTools = sourceLoopTools;
+    let inputBytes = boundedDebugInputBytes({ loop, tools: loopTools }, remainingBytes);
+    if (inputBytes > remainingBytes) {
+      loop = actionRequestLoopSummary(sourceLoop);
+      loopTools = sourceLoopTools.map(actionRequestToolSummary);
+      inputBytes = boundedDebugInputBytes({ loop, tools: loopTools }, remainingBytes);
+      if (inputBytes > remainingBytes && loops.length === 0) {
+        loop = minimalActionRequestLoopSummary(sourceLoop);
+        loopTools = [];
+        inputBytes = boundedDebugInputBytes({ loop, tools: loopTools }, remainingBytes);
+      }
+      if (inputBytes > remainingBytes) continue;
+      summarizedLoopCount += 1;
+    }
     loops.unshift(loop);
     tools.unshift(...loopTools);
     remainingBytes -= inputBytes;
@@ -290,6 +387,7 @@ export function limitActionRequestDebugInput(loopValues, toolValues) {
     loops,
     tools,
     omittedLoopCount: sourceLoops.length - loops.length,
+    summarizedLoopCount,
   };
 }
 
@@ -482,12 +580,25 @@ export function sanitizeDebugValue(value, parent = null, key = '', seen = new We
   }
 }
 
+function finalizeActionRequestDetail(detail) {
+  if (!detail?.request) return detail;
+  const loops = Array.isArray(detail.request.loops) ? detail.request.loops : [];
+  detail.request.summarizedLoopCount = loops.filter(loop => loop?.detailTruncated === true).length;
+  detail.request.omittedLoopCount = Math.max(0, Number(detail.request.omittedLoopCount) || 0);
+  detail.request.truncated = detail.request.truncated === true
+    || detail.request.summarizedLoopCount > 0
+    || detail.request.omittedLoopCount > 0;
+  return detail;
+}
+
 export function enforceActionRequestDetailBudget(detail, omittedLoopCount = 0) {
   if (omittedLoopCount > 0 && detail?.request) {
     detail.request.truncated = true;
     detail.request.omittedLoopCount = omittedLoopCount;
   }
-  if (!detail?.request || jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) return detail;
+  if (!detail?.request || jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) {
+    return finalizeActionRequestDetail(detail);
+  }
   detail.request.truncated = true;
   const loops = Array.isArray(detail.request.loops) ? detail.request.loops : [];
   const stages = [
@@ -504,17 +615,26 @@ export function enforceActionRequestDetailBudget(detail, omittedLoopCount = 0) {
     loop => { loop.response = ''; },
   ];
   for (const stage of stages) {
-    for (const loop of loops) stage(loop);
-    if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) return detail;
+    for (const loop of loops) {
+      stage(loop);
+      loop.detailTruncated = true;
+    }
+    if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) {
+      return finalizeActionRequestDetail(detail);
+    }
   }
   while (loops.length > 1 && jsonByteLength(detail) > MAX_ACTION_REQUEST_DETAIL_BYTES) {
     loops.shift();
     detail.request.omittedLoopCount = (detail.request.omittedLoopCount || 0) + 1;
   }
-  if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) return detail;
+  if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) {
+    return finalizeActionRequestDetail(detail);
+  }
   detail.request.omittedLoopCount = (detail.request.omittedLoopCount || 0) + loops.length;
   detail.request.loops = [];
-  if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) return detail;
+  if (jsonByteLength(detail) <= MAX_ACTION_REQUEST_DETAIL_BYTES) {
+    return finalizeActionRequestDetail(detail);
+  }
   const request = detail.request;
   const metadata = value => truncateUtf8(value, 4 * 1024);
   return {
@@ -536,6 +656,7 @@ export function enforceActionRequestDetailBudget(detail, omittedLoopCount = 0) {
       loops: [],
       truncated: true,
       omittedLoopCount: detail.request.omittedLoopCount,
+      summarizedLoopCount: 0,
     },
   };
 }

package/yeaft/work-center/projection.js

@@ -1,5 +1,6 @@
 import { reconstructDebugRawRequest } from '../debug-trace.js';
 import {
+  boundedDebugIdentity,
   enforceActionRequestDetailBudget,
   limitActionRequestDebugInput,
   sanitizeDebugValue,
@@ -13,6 +14,11 @@ const MAX_ACTION_MESSAGE_CHARS = 16_000;
 const MAX_ACTION_DIAGNOSTIC_CHARS = 8_000;
 const MAX_ACTION_MESSAGES = 20;
 const MAX_ACTION_REQUEST_TOOL_CALLS = 128;
+const MAX_ACTION_REQUEST_ID_BYTES = 256;
+const MAX_ACTION_REQUEST_NAME_BYTES = 512;
+const MAX_ACTION_REQUEST_MODEL_BYTES = 1_024;
+const MAX_ACTION_REQUEST_STOP_REASON_BYTES = 256;
+const MAX_ACTION_REQUEST_METADATA_BYTES = 4 * 1_024;
 const MAX_HISTORICAL_BRIEF_CHARS = 256;
 const MAX_CURRENT_BRIEF_BYTES = 8 * 1024;
 export const MAX_WORK_ITEM_BROWSER_DTO_BYTES = 512 * 1024;
@@ -29,6 +35,10 @@ function truncateUtf8(value, maxBytes) {
   return bytes.subarray(0, end).toString('utf8');
 }
 
+function exceedsUtf8Bytes(value, maxBytes) {
+  return Buffer.byteLength(String(value || ''), 'utf8') > maxBytes;
+}
+
 function currentAction(detail) {
   if (!detail?.currentActionId || !Array.isArray(detail.actions)) return null;
   return detail.actions.find(action => action.id === detail.currentActionId) || null;
@@ -1041,47 +1051,71 @@ export function projectActionRequestDetail(action, run, history, runs = [run]) {
     `${count(tool.loopNumber)}:${tool.callId}`,
     tool,
   ]));
-  const loops = limited.loops.map(loop => ({
-    id: loop.loopInstanceId || `${turn.turnId}:${loop.loopNumber}`,
-    loopNumber: count(loop.loopNumber),
-    model: loop.model || run.modelSnapshot?.id || null,
-    systemPrompt: sanitizeDebugValue(typeof loop.systemPrompt === 'string' ? loop.systemPrompt : ''),
-    messages: sanitizeDebugValue(Array.isArray(loop.messages) ? loop.messages : []),
-    response: sanitizeDebugValue(typeof loop.response === 'string' ? loop.response : ''),
-    usage: projectDebugUsage(loop.usage),
-    latencyMs: count(loop.latencyMs),
-    ttfbMs: loop.ttfbMs == null ? null : count(loop.ttfbMs),
-    stopReason: loop.stopReason || null,
-    at: count(loop.at),
-    tools: (Array.isArray(loop.toolCalls) ? loop.toolCalls : [])
-      .slice(0, MAX_ACTION_REQUEST_TOOL_CALLS)
-      .map(call => {
-        const result = toolsByCall.get(`${count(loop.loopNumber)}:${call.id}`);
-        return {
-          id: call.id || null,
-          name: call.name || result?.name || '?',
-          input: sanitizeDebugValue(call.input),
-          output: sanitizeDebugValue(result?.toolOutput ?? null),
-          durationMs: count(result?.durationMs),
-          isError: result?.isError === true,
-        };
-      }),
-    rawRequest: sanitizeDebugValue(reconstructDebugRawRequest(
-      loop.rawRequestBase ?? loop.requestBase?.rawRequest ?? null,
-      loop.requestDelta || null,
-    )),
-    rawResponse: sanitizeDebugValue(loop.rawResponse ?? null),
-  }));
+  const requestModel = run.modelSnapshot?.id || limited.loops[0]?.model || null;
+  const metadataTruncated = exceedsUtf8Bytes(action.id, MAX_ACTION_REQUEST_METADATA_BYTES)
+    || exceedsUtf8Bytes(turn.turnId, MAX_ACTION_REQUEST_METADATA_BYTES)
+    || exceedsUtf8Bytes(run.id, MAX_ACTION_REQUEST_METADATA_BYTES)
+    || exceedsUtf8Bytes(run.status || 'running', MAX_ACTION_REQUEST_METADATA_BYTES)
+    || exceedsUtf8Bytes(requestModel, MAX_ACTION_REQUEST_MODEL_BYTES)
+    || exceedsUtf8Bytes(run.vpSnapshot?.id, MAX_ACTION_REQUEST_METADATA_BYTES)
+    || exceedsUtf8Bytes(run.vpSnapshot?.name || run.vpSnapshot?.id, MAX_ACTION_REQUEST_METADATA_BYTES);
+  const loops = limited.loops.map(loop => {
+    const sourceId = loop.loopInstanceId || `${turn.turnId}:${loop.loopNumber}`;
+    const sourceModel = loop.model || run.modelSnapshot?.id || '';
+    const sourceCalls = Array.isArray(loop.toolCalls) ? loop.toolCalls : [];
+    let detailTruncated = loop.detailTruncated === true
+      || exceedsUtf8Bytes(sourceId, MAX_ACTION_REQUEST_ID_BYTES)
+      || exceedsUtf8Bytes(sourceModel, MAX_ACTION_REQUEST_MODEL_BYTES)
+      || exceedsUtf8Bytes(loop.stopReason, MAX_ACTION_REQUEST_STOP_REASON_BYTES)
+      || sourceCalls.length > MAX_ACTION_REQUEST_TOOL_CALLS;
+    const projectedTools = sourceCalls.slice(0, MAX_ACTION_REQUEST_TOOL_CALLS).map((call, index) => {
+      const result = toolsByCall.get(`${count(loop.loopNumber)}:${call.id}`);
+      const sourceCallId = call.id || `${sourceId}:tool:${index}`;
+      const sourceName = call.name || result?.name || '?';
+      if (exceedsUtf8Bytes(sourceCallId, MAX_ACTION_REQUEST_ID_BYTES)
+        || exceedsUtf8Bytes(sourceName, MAX_ACTION_REQUEST_NAME_BYTES)) {
+        detailTruncated = true;
+      }
+      return {
+        id: boundedDebugIdentity(sourceCallId, MAX_ACTION_REQUEST_ID_BYTES),
+        name: truncateUtf8(sourceName, MAX_ACTION_REQUEST_NAME_BYTES) || '?',
+        input: sanitizeDebugValue(call.input),
+        output: sanitizeDebugValue(result?.toolOutput ?? null),
+        durationMs: count(result?.durationMs),
+        isError: result?.isError === true,
+      };
+    });
+    return {
+      id: boundedDebugIdentity(sourceId, MAX_ACTION_REQUEST_ID_BYTES) || null,
+      loopNumber: count(loop.loopNumber),
+      model: truncateUtf8(sourceModel, MAX_ACTION_REQUEST_MODEL_BYTES) || null,
+      systemPrompt: sanitizeDebugValue(typeof loop.systemPrompt === 'string' ? loop.systemPrompt : ''),
+      messages: sanitizeDebugValue(Array.isArray(loop.messages) ? loop.messages : []),
+      response: sanitizeDebugValue(typeof loop.response === 'string' ? loop.response : ''),
+      usage: projectDebugUsage(loop.usage),
+      latencyMs: count(loop.latencyMs),
+      ttfbMs: loop.ttfbMs == null ? null : count(loop.ttfbMs),
+      stopReason: truncateUtf8(loop.stopReason, MAX_ACTION_REQUEST_STOP_REASON_BYTES) || null,
+      at: count(loop.at),
+      detailTruncated,
+      tools: projectedTools,
+      rawRequest: sanitizeDebugValue(reconstructDebugRawRequest(
+        loop.rawRequestBase ?? loop.requestBase?.rawRequest ?? null,
+        loop.requestDelta || null,
+      )),
+      rawResponse: sanitizeDebugValue(loop.rawResponse ?? null),
+    };
+  });
   return enforceActionRequestDetailBudget({
-    actionId: action.id,
+    actionId: boundedDebugIdentity(action.id, MAX_ACTION_REQUEST_METADATA_BYTES),
     request: {
-      id: turn.turnId,
-      runId: run.id,
-      status: run.status || 'running',
-      model: run.modelSnapshot?.id || loops[0]?.model || null,
+      id: boundedDebugIdentity(turn.turnId, MAX_ACTION_REQUEST_METADATA_BYTES),
+      runId: boundedDebugIdentity(run.id, MAX_ACTION_REQUEST_METADATA_BYTES),
+      status: truncateUtf8(run.status || 'running', MAX_ACTION_REQUEST_METADATA_BYTES),
+      model: truncateUtf8(requestModel, MAX_ACTION_REQUEST_MODEL_BYTES) || null,
       vp: run.vpSnapshot ? {
-        id: run.vpSnapshot.id || null,
-        name: run.vpSnapshot.name || run.vpSnapshot.id || null,
+        id: boundedDebugIdentity(run.vpSnapshot.id, MAX_ACTION_REQUEST_METADATA_BYTES) || null,
+        name: truncateUtf8(run.vpSnapshot.name || run.vpSnapshot.id, MAX_ACTION_REQUEST_METADATA_BYTES) || null,
       } : null,
       openedAt: count(turn.openedAt || run.startedAt),
       closedAt: count(turn.closedAt || run.endedAt),
@@ -1089,6 +1123,9 @@ export function projectActionRequestDetail(action, run, history, runs = [run]) {
       totalMs: count(turn.totalMs),
       totalTokens: count(turn.totalTokens),
       loops,
+      truncated: metadataTruncated || limited.omittedLoopCount > 0 || limited.summarizedLoopCount > 0,
+      omittedLoopCount: limited.omittedLoopCount,
+      summarizedLoopCount: limited.summarizedLoopCount,
     },
   }, limited.omittedLoopCount);
 }