@yeaft/webchat-agent 0.1.975 → 0.1.977

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.975",
+  "version": "0.1.977",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/yeaft/debug-trace.js

@@ -48,6 +48,7 @@ const SCHEMA = `
     tool_name TEXT NOT NULL,
     tool_input TEXT,
     tool_output TEXT,
+    tool_call_id TEXT,
     duration_ms INTEGER,
     is_error INTEGER DEFAULT 0,
     created_at INTEGER NOT NULL,
@@ -101,12 +102,12 @@ function migrateAddColumn(db, table, column, type) {
   }
 }
 
-/** Max tool_output size stored (10KB). Longer outputs are truncated. */
-const MAX_TOOL_OUTPUT = 10240;
+/** Max tool input size stored inline. Tool output is persisted raw. */
+const MAX_TOOL_INPUT = 10240;
 
 /**
  * Max per-loop payload (system prompt, messages JSON, raw request /
- * response, response text) stored per row. Larger than MAX_TOOL_OUTPUT
+ * response, response text) stored per row. Larger than MAX_TOOL_INPUT
  * because real-world LLM exchanges (system prompt + 30K-token message
  * trail + raw response) routinely cross 10KB. 256KB lets us replay the
  * panel verbatim for the most recent traces without bloating the DB.
@@ -207,6 +208,7 @@ export class DebugTrace {
     // snapshot — `messages.find(role==='user')` would return turn 1's
     // text for every subsequent turn, mislabeling every Turn header.
     migrateAddColumn(this.#db, 'trace_turns', 'user_prompt', 'TEXT');
+    migrateAddColumn(this.#db, 'trace_tools', 'tool_call_id', 'TEXT');
     // Indexes on the just-added columns. Must run AFTER the ALTER TABLEs
     // — running them inside SCHEMA's CREATE INDEX IF NOT EXISTS block
     // would fail with "no such column: group_id" on a pre-bugfix DB.
@@ -308,11 +310,12 @@ export class DebugTrace {
   /**
    * Log a tool call within a turn.
    * @param {string} turnId
-   * @param {{ toolName: string, toolInput?: string, toolOutput?: string, durationMs?: number, isError?: boolean }} info
+   * @param {{ toolName: string, toolCallId?: string|null, toolInput?: string, toolOutput?: string, durationMs?: number, isError?: boolean }} info
    * @returns {string} — tool record id
    */
   logTool(turnId, {
     toolName,
+    toolCallId = null,
     toolInput = null,
     toolOutput = null,
     durationMs = null,
@@ -321,12 +324,13 @@ export class DebugTrace {
     const id = randomUUID();
     const now = Date.now();
     this.#prepare('insertTool', `
-      INSERT INTO trace_tools (id, turn_id, tool_name, tool_input, tool_output, duration_ms, is_error, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO trace_tools (id, turn_id, tool_name, tool_input, tool_output, tool_call_id, duration_ms, is_error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
       id, turnId, toolName,
-      truncate(toolInput, MAX_TOOL_OUTPUT),
-      truncate(toolOutput, MAX_TOOL_OUTPUT),
+      truncate(toolInput, MAX_TOOL_INPUT),
+      toolOutput == null ? null : String(toolOutput),
+      toolCallId,
       durationMs, isError ? 1 : 0, now,
     );
     return id;
@@ -518,8 +522,10 @@ export class DebugTrace {
       if (!t) continue;
       t.tools.push({
         loopNumber: owner.turn_number || 0,
-        callId: tool.id,
+        callId: tool.tool_call_id || tool.id,
+        traceToolId: tool.id,
         name: tool.tool_name,
+        toolOutput: tool.tool_output == null ? null : String(tool.tool_output),
         durationMs: tool.duration_ms || 0,
         isError: !!tool.is_error,
       });

package/yeaft/engine.js

@@ -43,7 +43,7 @@ import { countTurns } from './turn-utils.js';
 import { attachRouterPlan, extractPriorPlan, stripMetaForWire } from './router/continuity.js';
 import { resolveThinking } from './router/thinking.js';
 import { approxTokens } from './memory/budget.js';
-import { COLLAB_TOOL_POLICY, truncateToolResultIfNeeded } from './tools/registry.js';
+import { COLLAB_TOOL_POLICY, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
 import {
   TOOL_BATCH_SIZE,
@@ -2489,13 +2489,7 @@ export class Engine {
               // is exercised by tests and a few standalone tools. Aligning
               // both paths keeps `ctx.cwd` semantics consistent.
               const rawOutput = await tool.execute(tc.input, toolCtx);
-              // Legacy #tools branch must apply the same per-tool cap as
-              // ToolRegistry.execute. Otherwise a deployment using the legacy
-              // registration path bypasses the defense entirely.
-              output = truncateToolResultIfNeeded(rawOutput, {
-                toolName: tc.name,
-                language: this.#config?.language,
-              });
+              output = normalizeToolOutput(rawOutput);
             }
             yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: false, threadId: this.currentThreadId };
           } catch (err) {
@@ -2508,9 +2502,8 @@ export class Engine {
         const toolDurationMs = Date.now() - toolStartTime;
 
         // feat-6af5f9f1 PR B: emit a structured `tool_exec` event for the
-        // debug panel. Args/output are already in `conversationMessages`
-        // and will be visible in the next loop's snapshot, so we don't
-        // duplicate them here — only the per-tool timing + status.
+        // debug panel. Keep raw output here; the model-facing tool
+        // message below is deliberately truncated for context budget.
         yield {
           type: 'tool_exec',
           turnId: queryTurnId,
@@ -2520,6 +2513,7 @@ export class Engine {
           name: tc.name,
           durationMs: toolDurationMs,
           isError,
+          toolOutput: output,
         };
 
         // 2026-05-13: feed the per-tool counters. Stays best-effort — a
@@ -2539,17 +2533,25 @@ export class Engine {
         // Log tool to debug trace
         this.#trace.logTool(turnId, {
           toolName: tc.name,
+          toolCallId: tc.id,
           toolInput: JSON.stringify(tc.input),
           toolOutput: output,
           durationMs: toolDurationMs,
           isError,
+          toolOutput: output,
         });
 
-        // Append tool result to conversation
+        // Append only the bounded copy to the model message history. Raw
+        // `output` is still used for debug traces, UI events, exec-log, and
+        // persistence so large tool results are not lost outside context.
+        const contextOutput = truncateToolResultIfNeeded(output, {
+          toolName: tc.name,
+          language: this.#config?.language,
+        });
         conversationMessages.push({
           role: 'tool',
           toolCallId: tc.id,
-          content: output,
+          content: contextOutput,
           isError,
         });
 

package/yeaft/history-compact.js

@@ -54,12 +54,28 @@
 
 import { estimateTokens } from './conversation/persist.js';
 import { pairSanitize } from './pair-sanitize.js';
+import { truncateToolResultIfNeeded } from './tools/registry.js';
 import {
   countTurns as countTurnsImpl,
   indexOfNthTurnFromEnd,
   sliceLastNTurns,
 } from './turn-utils.js';
 
+
+function truncateToolResultsForModel(messages, opts = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) return [];
+  return messages.map((m) => {
+    if (!m || m.role !== 'tool' || typeof m.content !== 'string') return { ...m };
+    return {
+      ...m,
+      content: truncateToolResultIfNeeded(m.content, {
+        toolName: m.name || m.toolName || 'tool_result',
+        language: opts.language,
+      }),
+    };
+  });
+}
+
 /**
  * Re-export `countTurns` so existing callers / tests that import it
  * from this module continue to work. Implementation now lives in
@@ -706,7 +722,7 @@ export async function compactHistory(messages, options) {
  * between trim (per-call) and compact (global) explicit.
  *
  * @param {Array<object>} snapshot
- * @param {{ messageTokenBudget?: number, recentTurnCap?: number, keepToolTurns?: number }} [opts]
+ * @param {{ messageTokenBudget?: number, recentTurnCap?: number, keepToolTurns?: number, language?: string }} [opts]
  * @returns {Array<object>}
  */
 export function trimSnapshotForBudget(snapshot, opts = {}) {
@@ -738,6 +754,11 @@ export function trimSnapshotForBudget(snapshot, opts = {}) {
     keepToolTurns: opts.keepToolTurns,
   });
 
-  // Stage 4: pair-sanitize to drop orphan tool_use/tool_result.
+  // Stage 4: bound the raw tool result copy that is fed back into the model.
+  // The in-memory/persisted transcript keeps the full content; this transform
+  // only affects the per-query snapshot passed to engine.query().
+  trimmed = truncateToolResultsForModel(trimmed, { language: opts.language });
+
+  // Stage 5: pair-sanitize to drop orphan tool_use/tool_result.
   return pairSanitize(trimmed);
 }

package/yeaft/tools/registry.js

@@ -33,19 +33,17 @@ export const SUB_AGENT_TOOL_NAMES = Object.freeze([
 export const FORWARD_TOOL_NAMES = Object.freeze(['RouteForward']);
 
 /**
- * Per-tool-result hard cap.
+ * Per-tool-result model-context cap.
  *
  * A single tool can return megabytes (a grep over a large repo, a large file
  * read, a paginated web fetch). If we forward that verbatim into the next LLM
- * request, persistence, or UI event, it bloats context and makes every replay
- * expensive. Keep the hard boundary small and deterministic: one tool result
+ * request, it bloats context and makes every replay expensive. Keep the
+ * boundary small and deterministic for LLM message history: one tool result
  * gets at most 1 KiB before a visible truncation marker is appended.
  *
- * The truncation lands HERE (not in engine.js when pushing tool results
- * into messages) so the UI's `tool_end` event, the exec log, AND the
- * model all see the same truncated content. Truncating later would mean
- * the user sees the full 2 MB output but the model gets a stub —
- * confusing.
+ * Do NOT apply this at tool execution time. Debug events, exec logs, and
+ * persisted transcripts need the raw result. The engine/history replay path
+ * applies this only when building messages for the model.
  */
 export const TOOL_RESULT_MAX_BYTES = 1024;
 
@@ -170,7 +168,7 @@ export class ToolExecutionTimeoutError extends Error {
  * @param {{ toolName: string, language?: string }} opts
  * @returns {string}
  */
-export function truncateToolResultIfNeeded(output, { toolName, language } = {}) {
+export function normalizeToolOutput(output) {
   let text;
   if (typeof output === 'string') {
     text = output;
@@ -182,6 +180,11 @@ export function truncateToolResultIfNeeded(output, { toolName, language } = {})
       text = String(output);
     }
   }
+  return text;
+}
+
+export function truncateToolResultIfNeeded(output, { toolName, language } = {}) {
+  const text = normalizeToolOutput(output);
   const originalBytes = Buffer.byteLength(text, 'utf8');
   if (originalBytes <= TOOL_RESULT_MAX_BYTES) return text;
 
@@ -195,8 +198,8 @@ export function truncateToolResultIfNeeded(output, { toolName, language } = {})
   }
   const head = chunks.join('');
   const marker = normalizeLanguage(language) === 'zh'
-    ? `\n\n[已截断：${toolName} 返回 ${formatSize(originalBytes)}，上限为 ${formatSize(TOOL_RESULT_MAX_BYTES)}；原因：单个 tool result 超过 1KB，模型和持久化展示不会看到剩余内容]`
-    : `\n\n[truncated: ${toolName} returned ${formatSize(originalBytes)}, capped at ${formatSize(TOOL_RESULT_MAX_BYTES)}; reason: single tool result exceeded 1KB, the model and persisted display will not see the rest]`;
+    ? `\n\n[已截断：${toolName} 返回 ${formatSize(originalBytes)}，上限为 ${formatSize(TOOL_RESULT_MAX_BYTES)}；原因：单个 tool result 超过 1KB，模型消息历史不会看到剩余内容]`
+    : `\n\n[truncated: ${toolName} returned ${formatSize(originalBytes)}, capped at ${formatSize(TOOL_RESULT_MAX_BYTES)}; reason: single tool result exceeded 1KB, the model message history will not see the rest]`;
   return head + marker;
 }
 
@@ -372,9 +375,9 @@ export class ToolRegistry {
   /**
    * Execute a tool by name.
    *
-   * The result is passed through {@link truncateToolResultIfNeeded} so that
-   * a single tool result never injects more than 1KB before the visible
-   * truncation marker.
+   * Returns the raw tool result as text. Do not truncate here: debug display,
+   * exec logs, and persistence must retain the full result. The engine/history
+   * replay path truncates only the copy inserted into model message history.
    *
    * @param {string} name
    * @param {object} input
@@ -398,10 +401,7 @@ export class ToolRegistry {
       ? await runWithTimeout(tool.execute(input, ctx), rawTimeout, name)
       : await tool.execute(input, ctx);
 
-    return truncateToolResultIfNeeded(output, {
-      toolName: name,
-      language: ctx.config?.language,
-    });
+    return normalizeToolOutput(output);
   }
 
   /** Number of registered tools. */

package/yeaft/web-bridge.js

@@ -2276,6 +2276,7 @@ function handleEngineEvent(event, hctx) {
         name: event.name,
         durationMs: event.durationMs,
         isError: event.isError,
+        toolOutput: event.toolOutput,
       }, envelope);
       break;
 
@@ -3035,6 +3036,7 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
       // array). See `trimSnapshotForBudget` doc-block for policy.
       const trimmedMessages = trimSnapshotForBudget(baseSnapshot, {
         messageTokenBudget: session?.config?.messageTokenBudget,
+        language: session?.config?.language,
       });
       for await (const event of vpEngine.query({
         prompt,