@yeaft/webchat-agent 1.0.208 → 1.0.210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.208",
+  "version": "1.0.210",
   "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/conversation/persist.js

@@ -1577,40 +1577,72 @@ export class ConversationStore {
     const limit = Math.min(50, Math.max(1, Number.isFinite(opts.limit) ? Math.floor(opts.limit) : 20));
     const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
     const results = [];
-    const seen = new Set();
     let hasMore = false;
 
-    for (const message of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
-      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) continue;
-      if (message.role !== 'user' && message.role !== 'assistant') continue;
-      if (!message.id || seen.has(message.id)) continue;
-      seen.add(message.id);
-
-      const text = this.#visibleSearchText(message.content);
+    for (const entry of this.#iterateVisibleResponseEntries(sessionId, { beforeSeq })) {
+      const text = entry.textParts.join(' ');
       const matchIndex = text.toLocaleLowerCase().indexOf(needle);
       if (matchIndex < 0) continue;
       if (results.length >= limit) {
         hasMore = true;
         break;
       }
-
-      const seq = parseSeqFromId(message.id);
-      if (!Number.isFinite(seq)) continue;
       results.push({
-        messageId: message.id,
-        turnId: message.turnId || message.threadId || message.id,
-        seq,
-        role: message.role,
-        speakerVpId: message.speakerVpId || null,
-        timestamp: message.ts || message.time || null,
+        ...this.#projectVisibleResponseEntry(entry),
         snippet: this.#searchSnippet(text, matchIndex, needle.length),
       });
     }
 
+    const lastResult = results[results.length - 1] || null;
+    return {
+      results: results.map(({ _beforeSeq, ...result }) => result),
+      hasMore,
+      nextBeforeSeq: hasMore && lastResult ? lastResult._beforeSeq : null,
+    };
+  }
+
+  /**
+   * Load a lightweight outline page for one Session. Only user and assistant
+   * text metadata is projected; tool payloads, attachments and full message
+   * bodies never leave the Agent through this API.
+   *
+   * @param {string} sessionId
+   * @param {{ limit?: number, beforeSeq?: number|null, includeTotal?: boolean }} [opts]
+   * @returns {{ results: object[], hasMore: boolean, nextBeforeSeq: number|null, totalCount: number|null }}
+   */
+  loadVisibleOutlineBySession(sessionId, opts = {}) {
+    if (!sessionId) return { results: [], hasMore: false, nextBeforeSeq: null, totalCount: 0 };
+
+    const limit = Math.min(100, Math.max(1, Number.isFinite(opts.limit) ? Math.floor(opts.limit) : 50));
+    const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
+    const newestFirst = [];
+    let hasMore = false;
+
+    for (const entry of this.#iterateVisibleResponseEntries(sessionId, { beforeSeq })) {
+      if (newestFirst.length >= limit) {
+        hasMore = true;
+        break;
+      }
+      const projected = this.#projectVisibleResponseEntry(entry);
+      newestFirst.push({
+        ...projected,
+        snippet: this.#outlineSnippet(entry.textParts.join(' ')),
+      });
+    }
+
+    let totalCount = null;
+    if (opts.includeTotal !== false) {
+      totalCount = 0;
+      for (const _entry of this.#iterateVisibleResponseEntries(sessionId)) totalCount += 1;
+    }
+
+    const oldestEntry = newestFirst[newestFirst.length - 1] || null;
+    const results = newestFirst.reverse().map(({ _beforeSeq, ...entry }) => entry);
     return {
       results,
       hasMore,
-      nextBeforeSeq: hasMore && results.length > 0 ? results[results.length - 1].seq : null,
+      nextBeforeSeq: hasMore && oldestEntry ? oldestEntry._beforeSeq : null,
+      totalCount,
     };
   }
 
@@ -2381,6 +2413,75 @@ export class ConversationStore {
     };
   }
 
+  *#iterateVisibleResponseEntries(sessionId, opts = {}) {
+    const beforeSeq = Number.isFinite(opts.beforeSeq) ? opts.beforeSeq : Infinity;
+    const seen = new Set();
+    let current = null;
+
+    const visibleRow = (message) => {
+      if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) return null;
+      if (message.role !== 'user' && message.role !== 'assistant') return null;
+      if (!message.id || seen.has(message.id)) return null;
+      seen.add(message.id);
+      const seq = parseSeqFromId(message.id);
+      if (!Number.isFinite(seq)) return null;
+      const text = this.#visibleSearchText(message.content);
+      const speakerVpId = message.speakerVpId || null;
+      return {
+        message,
+        seq,
+        text,
+        speakerVpId,
+        groupKey: message.role === 'assistant'
+          ? `assistant:${message.turnId || message.id}:${speakerVpId || ''}`
+          : `user:${message.id}`,
+      };
+    };
+    const startEntry = (row) => ({
+      groupKey: row.groupKey,
+      role: row.message.role,
+      turnId: row.message.turnId || row.message.threadId || row.message.id,
+      speakerVpId: row.speakerVpId,
+      oldestSeq: row.seq,
+      anchor: row,
+      anchorHasText: !!row.text,
+      textParts: row.text ? [row.text] : [],
+    });
+    const mergeRow = (entry, row) => {
+      entry.oldestSeq = Math.min(entry.oldestSeq, row.seq);
+      if (row.text) entry.textParts.unshift(row.text);
+      if (!entry.anchorHasText && row.text) {
+        entry.anchor = row;
+        entry.anchorHasText = true;
+      }
+    };
+
+    for (const message of this.#iterateSessionRows(sessionId, { beforeSeq, desc: true })) {
+      const row = visibleRow(message);
+      if (!row) continue;
+      if (current && current.groupKey === row.groupKey) {
+        mergeRow(current, row);
+        continue;
+      }
+      if (current) yield current;
+      current = startEntry(row);
+    }
+    if (current) yield current;
+  }
+
+  #projectVisibleResponseEntry(entry) {
+    return {
+      messageId: entry.anchor.message.id,
+      ...(entry.anchor.message.clientMessageId ? { clientMessageId: entry.anchor.message.clientMessageId } : {}),
+      turnId: entry.turnId,
+      seq: entry.anchor.seq,
+      role: entry.role,
+      speakerVpId: entry.speakerVpId,
+      timestamp: entry.anchor.message.ts || entry.anchor.message.time || null,
+      _beforeSeq: entry.oldestSeq,
+    };
+  }
+
   #visibleSearchText(content) {
     if (typeof content === 'string') return content.replace(/\s+/g, ' ').trim();
     if (!Array.isArray(content)) return '';
@@ -2399,6 +2500,11 @@ export class ConversationStore {
     return `${start > 0 ? '…' : ''}${text.slice(start, end)}${end < text.length ? '…' : ''}`;
   }
 
+  #outlineSnippet(text) {
+    const limit = 180;
+    return text.length > limit ? `${text.slice(0, limit).trimEnd()}…` : text;
+  }
+
   #readSegmentRows(conversationDir, opts = {}) {
     return this.#segmentStoreForConversationDir(conversationDir).readAll(opts);
   }

package/yeaft/engine.js

@@ -46,7 +46,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, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
+import { COLLAB_TOOL_POLICY, isToolErrorOutput, normalizeToolOutput, truncateToolResultIfNeeded } from './tools/registry.js';
 import { extractDisplayImages, stripDisplayImageData } from './image-assets.js';
 import { acknowledgePendingNotifications, formatNotificationsForPrompt, peekPendingNotifications } from './sub-agent/notifications.js';
 import {
@@ -3344,6 +3344,7 @@ export class Engine {
         let output;
         let displayImages = [];
         let isError = false;
+        let toolErrorOutput = null;
         currentToolCallForAsyncTask = {
           id: tc.id,
           name: tc.name,
@@ -3363,9 +3364,11 @@ export class Engine {
           try {
             yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input, threadId: this.currentThreadId };
             if (this.#toolRegistry) {
+              toolErrorOutput = this.#toolRegistry.get(tc.name)?.errorOutput || null;
               output = await this.#toolRegistry.execute(tc.name, tc.input, toolCtx);
             } else {
               const tool = this.#tools.get(tc.name);
+              toolErrorOutput = tool.errorOutput || null;
               // Pass the full toolCtx (cwd, workDir, signal, …) — not just
               // `{ signal }`. Legacy registerTool() callers historically got
               // a 1-field ctx, but that means tools like bash/file-read run
@@ -3380,7 +3383,8 @@ export class Engine {
             if (displayImages.length > 0) {
               output = stripDisplayImageData(output, displayImages);
             }
-            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError: false, threadId: this.currentThreadId };
+            isError = toolErrorOutput === 'json-error-envelope' && isToolErrorOutput(output);
+            yield { type: 'tool_end', id: tc.id, name: tc.name, output, displayImages, isError, threadId: this.currentThreadId };
             if (displayImages.some(image => image.deliveryQueued === true)) hasDisplayImageAnchor = true;
           } catch (err) {
             output = `Error: ${err.message}`;

package/yeaft/tools/bash.js

@@ -210,6 +210,7 @@ Guidelines:
     },
     required: ['command'],
   },
+  errorOutput: null,
   isConcurrencySafe: () => false,
   isReadOnly: () => false,
   isDestructive: (input) => {
@@ -223,7 +224,7 @@ Guidelines:
   },
   async execute(input, ctx) {
     const { command, cwd: inputCwd, timeout_ms, background = false, taskTitle } = input;
-    if (!command) return JSON.stringify({ error: 'command is required' });
+    if (!command) throw new Error('command is required');
 
     // Resolve working directory
     const cwd = inputCwd
@@ -231,7 +232,7 @@ Guidelines:
       : (ctx?.cwd || process.cwd());
 
     if (!existsSync(cwd)) {
-      return JSON.stringify({ error: `Working directory does not exist: ${cwd}` });
+      throw new Error(`Working directory does not exist: ${cwd}`);
     }
 
     // Clamp timeout
@@ -240,7 +241,7 @@ Guidelines:
 
     if (background) {
       if (!ctx?.taskManager) {
-        return JSON.stringify({ error: 'background tasks are unavailable in this runtime' });
+        throw new Error('background tasks are unavailable in this runtime');
       }
       try {
         const task = ctx.taskManager.startShellTask({
@@ -263,7 +264,7 @@ Guidelines:
         try { ctx.registerAsyncTask?.(task.id, currentToolCall || {}); } catch { /* never block tool return on coord errors */ }
         return `Started background task ${task.id}.\nStatus: ${task.status}\nLog: ${task.log?.path || ''}\nUse ListTasks, ReadTaskLog, or CancelTask to inspect or control it.`;
       } catch (err) {
-        return JSON.stringify({ error: err?.message || String(err) });
+        throw new Error(err?.message || String(err));
       }
     }
 
@@ -287,7 +288,7 @@ Guidelines:
       }
       return output || '(no output)';
     } catch (err) {
-      return JSON.stringify({ error: err.message });
+      throw new Error(err.message);
     }
   },
 });

package/yeaft/tools/file-read.js

@@ -34,6 +34,50 @@ const MAX_FILE_SIZE = 10 * 1024 * 1024;
  *  round-trip this tool's prompt guidance promises to avoid). */
 const DEFAULT_LIMIT = 3000;
 
+/** Keep raw output close to the model-facing 32 KiB budget while leaving
+ * room for line metadata and the Registry's localized truncation marker. */
+const DEFAULT_OUTPUT_BYTES = 30 * 1024;
+
+function takeUtf8(text, maxBytes) {
+  const chars = [];
+  let bytes = 0;
+  for (const char of text) {
+    const size = Buffer.byteLength(char, 'utf8');
+    if (bytes + size > maxBytes) break;
+    chars.push(char);
+    bytes += size;
+  }
+  return { text: chars.join(''), charCount: chars.length, bytes };
+}
+
+function formatLinesWithinBudget(allLines, startLine, endLine, startColumn = 0, maxBytes = DEFAULT_OUTPUT_BYTES) {
+  const parts = [];
+  let usedBytes = 0;
+  let nextLine = startLine;
+  let nextColumn = startColumn;
+  for (let i = startLine; i < endLine; i += 1) {
+    const prefix = parts.length > 0 ? '\n' : '';
+    const lineChars = Array.from(allLines[i]);
+    const column = i === startLine ? Math.min(startColumn, lineChars.length) : 0;
+    const linePrefix = `${i + 1}\t${column > 0 ? `[column ${column}] ` : ''}`;
+    const formatted = linePrefix + lineChars.slice(column).join('');
+    const remaining = maxBytes - usedBytes - Buffer.byteLength(prefix, 'utf8');
+    if (remaining <= 0) break;
+    const bounded = takeUtf8(formatted, remaining);
+    if (!bounded.text) break;
+    parts.push(prefix + bounded.text);
+    usedBytes += Buffer.byteLength(prefix, 'utf8') + bounded.bytes;
+    if (bounded.text !== formatted) {
+      nextLine = i;
+      nextColumn = column + Math.max(0, bounded.charCount - Array.from(linePrefix).length);
+      break;
+    }
+    nextLine = i + 1;
+    nextColumn = 0;
+  }
+  return { text: parts.join(''), nextLine, nextColumn };
+}
+
 export default defineTool({
   name: 'FileRead',
   description: {
@@ -70,14 +114,21 @@ Guidelines:
         },
       },
       offset: {
-        type: 'number',
+        type: 'integer',
+        minimum: 0,
         description: {
           en: 'Line number to start reading from (0-based, default: 0)',
           zh: '起始行号（从 0 开始计数，默认 0）',
         },
       },
+      column_offset: {
+        type: 'integer',
+        minimum: 0,
+        description: { en: 'Unicode character offset within the first requested line (0-based, default: 0)', zh: '首个待读行内的 Unicode 字符偏移量（从 0 开始，默认 0）' },
+      },
       limit: {
-        type: 'number',
+        type: 'integer',
+        minimum: 1,
         description: {
           en: `Maximum number of lines to read (default: ${DEFAULT_LIMIT})`,
           zh: `最多读取行数（默认 ${DEFAULT_LIMIT} 行）`,
@@ -89,8 +140,17 @@ Guidelines:
   isConcurrencySafe: () => true,
   isReadOnly: () => true,
   async execute(input, ctx) {
-    const { file_path, offset = 0, limit = DEFAULT_LIMIT } = input;
+    const { file_path, offset = 0, column_offset = 0, limit = DEFAULT_LIMIT } = input;
     if (!file_path) return JSON.stringify({ error: 'file_path is required' });
+    if (!Number.isInteger(offset) || offset < 0) {
+      return JSON.stringify({ error: 'offset must be a non-negative integer' });
+    }
+    if (!Number.isInteger(column_offset) || column_offset < 0) {
+      return JSON.stringify({ error: 'column_offset must be a non-negative integer' });
+    }
+    if (!Number.isInteger(limit) || limit < 1) {
+      return JSON.stringify({ error: 'limit must be a positive integer' });
+    }
 
     const cwd = ctx?.cwd || process.cwd();
     const absPath = resolve(cwd, file_path);
@@ -126,20 +186,28 @@ Guidelines:
       const allLines = content.split('\n');
       const totalLines = allLines.length;
 
+      if (offset > totalLines) {
+        return JSON.stringify({ error: `offset ${offset} exceeds file length (${totalLines} lines)` });
+      }
+      if (offset === totalLines) {
+        return `[Offset ${offset} is at end of file (${totalLines} lines total).]`;
+      }
+
       // Apply offset and limit
-      const startLine = Math.max(0, Math.min(offset, totalLines));
+      const startLine = offset;
       const endLine = Math.min(startLine + limit, totalLines);
-      const lines = allLines.slice(startLine, endLine);
-
-      // Format with line numbers (1-based like cat -n)
-      const numbered = lines.map((line, i) => {
-        const lineNum = startLine + i + 1;
-        return `${lineNum}\t${line}`;
-      }).join('\n');
-
-      // Add metadata if partial
-      if (startLine > 0 || endLine < totalLines) {
-        return `${numbered}\n\n[Showing lines ${startLine + 1}-${endLine} of ${totalLines} total]`;
+      const startColumn = column_offset;
+      const { text: numbered, nextLine, nextColumn } = formatLinesWithinBudget(allLines, startLine, endLine, startColumn);
+
+      const hasMoreContent = nextColumn > 0 || nextLine < totalLines;
+      if (startLine > 0 || startColumn > 0 || hasMoreContent) {
+        const continuation = hasMoreContent
+          ? nextColumn > 0
+            ? ` Continue with offset=${nextLine}, column_offset=${nextColumn}.`
+            : ` Continue with offset=${nextLine}.`
+          : '';
+        const shownEnd = nextColumn > 0 ? nextLine + 1 : nextLine;
+        return `${numbered}\n\n[Showing lines ${startLine + 1}-${shownEnd} of ${totalLines} total.${continuation}]`;
       }
 
       return numbered;

package/yeaft/tools/glob.js

@@ -10,6 +10,13 @@ import { readdir, stat } from 'fs/promises';
 import { existsSync } from 'fs';
 import { resolve, join, relative } from 'path';
 
+const STAT_CONCURRENCY = 32;
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', '__pycache__', '.next', '.nuxt',
+  'dist', 'build', '.cache', '.venv', 'venv', '.tox',
+  'vendor', 'target', '.gradle', '.idea', '.vscode',
+]);
+
 /**
  * Simple glob pattern matcher (supports * and **).
  * @param {string} pattern
@@ -44,19 +51,13 @@ async function* walkDir(dir, baseDir, maxDepth = 10, depth = 0) {
     return;
   }
 
-  // Skip common large/irrelevant directories
-  const SKIP = new Set([
-    'node_modules', '.git', '__pycache__', '.next', '.nuxt',
-    'dist', 'build', '.cache', '.venv', 'venv', '.tox',
-    'vendor', 'target', '.gradle', '.idea', '.vscode',
-  ]);
-
   for (const entry of entries) {
     const fullPath = join(dir, entry.name);
     const relPath = relative(baseDir, fullPath);
 
     if (entry.isDirectory()) {
-      if (SKIP.has(entry.name)) continue;
+      const normalized = relPath.replace(/\\/g, '/');
+      if (SKIP_DIRS.has(entry.name) || normalized === '.yeaft/worktrees' || normalized.startsWith('.yeaft/worktrees/')) continue;
       yield { path: relPath, isDir: true };
       yield* walkDir(fullPath, baseDir, maxDepth, depth + 1);
     } else {
@@ -106,7 +107,8 @@ Guidelines:
         },
       },
       limit: {
-        type: 'number',
+        type: 'integer',
+        minimum: 1,
         description: {
           en: 'Maximum number of results (default: 500)',
           zh: '最多返回结果数（默认 500）',
@@ -120,6 +122,9 @@ Guidelines:
   async execute(input, ctx) {
     const { pattern, path: searchPath, limit = 500 } = input;
     if (!pattern) return JSON.stringify({ error: 'pattern is required' });
+    if (!Number.isInteger(limit) || limit < 1) {
+      return JSON.stringify({ error: 'limit must be a positive integer' });
+    }
 
     const cwd = ctx?.cwd || process.cwd();
     const baseDir = searchPath ? resolve(cwd, searchPath) : cwd;
@@ -129,29 +134,25 @@ Guidelines:
     }
 
     try {
-      const matches = [];
-
+      const paths = [];
       for await (const entry of walkDir(baseDir, baseDir)) {
-        if (matches.length >= limit * 2) break; // over-fetch for sorting
+        if (!entry.isDir && matchGlob(pattern, entry.path)) paths.push(entry.path);
+      }
 
-        if (!entry.isDir && matchGlob(pattern, entry.path)) {
-          // Get mtime for sorting
+      // Exact newest-first semantics require every matching mtime. Batch the
+      // metadata reads instead of serializing one syscall per path.
+      const matches = [];
+      for (let i = 0; i < paths.length; i += STAT_CONCURRENCY) {
+        matches.push(...await Promise.all(paths.slice(i, i + STAT_CONCURRENCY).map(async (path) => {
           try {
-            const fileStat = await stat(join(baseDir, entry.path));
-            matches.push({
-              path: entry.path,
-              mtime: fileStat.mtimeMs,
-            });
+            const fileStat = await stat(join(baseDir, path));
+            return { path, mtime: fileStat.mtimeMs };
           } catch {
-            matches.push({ path: entry.path, mtime: 0 });
+            return { path, mtime: 0 };
           }
-        }
+        })));
       }
-
-      // Sort by mtime (newest first)
       matches.sort((a, b) => b.mtime - a.mtime);
-
-      // Trim to limit
       const trimmed = matches.slice(0, limit);
 
       return trimmed.map(m => m.path).join('\n') || '(no matches)';