@yeaft/webchat-agent 0.1.734 → 0.1.738

package/connection/message-router.js

@@ -36,7 +36,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig, getUnifySettings, updateUnifySettings, getSearchSettings, updateSearchSettings, fetchTavilyUsage } from '../unify/config-api.js';
-import { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyFetchSummaryHistory, handleUnifyFeatureCrud, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, broadcastLanguageChange } from '../unify/web-bridge.js';
+import { handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyLoadMoreHistory, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyAbortTurn, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyFetchSummaryHistory, handleUnifyFeatureCrud, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyUpdateGroup, handleUnifyArchiveGroup, handleUnifyDeleteGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger, broadcastLanguageChange } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -403,6 +403,10 @@ export async function handleMessage(msg) {
       await handleUnifyLoadHistory(msg);
       break;
 
+    case 'unify_load_more_history':
+      await handleUnifyLoadMoreHistory(msg);
+      break;
+
     case 'unify_mode_switch':
       handleUnifyModeSwitch(msg);
       break;

package/package.json

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

package/unify/conversation/persist.js

@@ -55,6 +55,20 @@ export function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 
+/**
+ * Parse the global monotonic sequence number out of a message id of the
+ * form `m####`. Returns NaN for malformed ids. Used by the pagination
+ * cursor (`loadOlderByGroup`) to compare ids numerically without having
+ * to trust file-system sort order.
+ *
+ * @param {string} id
+ * @returns {number}
+ */
+export function parseSeqFromId(id) {
+  const m = String(id || '').match(/^m(\d+)$/);
+  return m ? parseInt(m[1], 10) : NaN;
+}
+
 // ─── Frontmatter helpers ─────────────────────────────────────
 
 /**
@@ -527,6 +541,66 @@ export class ConversationStore {
     return this.loadRecentByGroup(groupId, Infinity);
   }
 
+  /**
+   * Pagination-cursor read: load the page of `turnsLimit` TURNS that ends
+   * just before `beforeSeq` (exclusive) for the given `groupId`. Used by
+   * the Unify "Load older messages" UI to walk backwards through history
+   * one click at a time.
+   *
+   * Crucially, this scans BOTH hot (`messages/`) and cold (`cold/`) dirs
+   * — `#getNextSeq` is global across both, and `moveToCold` is a `rename`
+   * that never reseqs, so cold ids are strictly < hot ids and a flat
+   * `[...cold, ...hot]` concat is already chronological. Crossing the
+   * hot→cold boundary is therefore transparent to the caller.
+   *
+   * `hasMore` is computed in TURNS (not raw message count). It's true iff
+   * the slice we returned still leaves an earlier turn boundary unread in
+   * the filtered prefix — i.e. there's at least one more page to fetch.
+   *
+   * `pairSanitize` runs as a defensive secondary pass. Turn-boundary cuts
+   * are already pair-safe, but historical / hand-edited stores may
+   * contain orphan tool_use/tool_result pairs.
+   *
+   * @param {string} groupId — required; null/empty returns empty result
+   * @param {number|null} beforeSeq — exclusive upper bound on message
+   *   sequence id. Special cases:
+   *   - `null` / `undefined` / non-finite (e.g. `Infinity`, `NaN`) → start
+   *     from the newest (no upper bound).
+   *   - `0` is a VALID finite cutoff that excludes everything (since seqs
+   *     start at 1). Distinct from `null`. A caller writing
+   *     `loadOlderByGroup(g, store.firstSeq || 0, ...)` will silently get
+   *     an empty page — pass `null` if you mean "from newest".
+   * @param {number} [turnsLimit=DEFAULT_RECENT_TURNS] — max turns per page
+   * @returns {{ messages: object[], oldestSeq: number|null, hasMore: boolean }}
+   */
+  loadOlderByGroup(groupId, beforeSeq, turnsLimit = DEFAULT_RECENT_TURNS) {
+    if (!groupId) return { messages: [], oldestSeq: null, hasMore: false };
+    const hot = this.#loadFromDir(this.#msgDir, Infinity);
+    const cold = this.#loadFromDir(this.#coldDir, Infinity);
+    // Cold ids strictly < hot ids by construction → chronological concat.
+    const all = [...cold, ...hot];
+    const cutoff = Number.isFinite(beforeSeq) ? beforeSeq : Infinity;
+    const prefix = all.filter(m => m && m.groupId === groupId
+      && parseSeqFromId(m.id) < cutoff);
+    if (prefix.length === 0) return { messages: [], oldestSeq: null, hasMore: false };
+    const sliced = pairSanitize(sliceLastNTurns(prefix, turnsLimit));
+    // Turn-based hasMore: there's an EARLIER turn boundary we didn't keep.
+    // Compare seqs (not object identity) — pairSanitize / sliceLastNTurns
+    // return references today, but a future normalization pass that clones
+    // rows would silently flip identity-compare to always-true.
+    const oldestSlicedSeq = sliced.length ? parseSeqFromId(sliced[0].id) : NaN;
+    const oldestPrefixSeq = parseSeqFromId(prefix[0].id);
+    const hasMore = sliced.length > 0
+      && Number.isFinite(oldestSlicedSeq)
+      && Number.isFinite(oldestPrefixSeq)
+      && oldestSlicedSeq > oldestPrefixSeq;
+    // Defend the cursor at the source: a malformed id surfaces as NaN here
+    // and a NaN cursor would round-trip back as a poison `beforeSeq` that
+    // degrades to "give me the newest page again".
+    const oldestSeq = Number.isFinite(oldestSlicedSeq) ? oldestSlicedSeq : null;
+    return { messages: sliced, oldestSeq, hasMore };
+  }
+
   /**
    * Count hot messages.
    *

package/unify/tools/registry.js

@@ -41,6 +41,50 @@ import { DEFAULT_CONTEXT_WINDOW } from '../models.js';
 const TOOL_RESULT_CAP_RATIO = 0.10;
 const TOOL_RESULT_MIN_CAP = 8 * 1024;
 
+/**
+ * Per-tool execution timeout (ms).
+ *
+ * Without a timeout, a tool whose `execute()` ignores `signal` (or hangs on
+ * a network call that doesn't honor AbortSignal) blocks the engine
+ * generator's `await this.#toolRegistry.execute(...)` forever. The for-await
+ * in the bridge driver never advances → no further events emitted → no
+ * `turn_end` → typing dots hang → user sees the conversation "halt" with
+ * no terminal event. The bridge's 120s watchdog calls `vpAbort.abort()`
+ * but a tool that ignores signal also ignores the abort, so the abort
+ * does nothing.
+ *
+ * Fix: race the tool's promise against a timer. On timeout we throw a
+ * loud error — the engine's existing catch (engine.js: tool-execute path)
+ * emits `tool_end{isError:true}` and the loop continues normally. Loud
+ * failure beats silent stall.
+ *
+ * 90s is comfortably above the typical tool budget (most tools complete
+ * in <1s; bash and web-fetch can run tens of seconds; web-search is
+ * usually <10s) but well below the 120s bridge-level watchdog so the
+ * tool-level signal fires first and surfaces a useful per-tool diagnosis
+ * rather than an opaque "VP stalled" log.
+ *
+ * Override per-tool by setting `tool.timeoutMs` on the ToolDef. Set to
+ * 0 (or a negative number) to disable the timeout for that tool — only
+ * use this for legitimately long-running internal tools.
+ */
+export const DEFAULT_TOOL_TIMEOUT_MS = 90_000;
+
+/**
+ * Error thrown when a tool's execute() exceeds its timeout. Carries the
+ * tool name + budget so the engine's catch path (and the resulting
+ * `tool_end{isError:true}` event) can surface a precise diagnostic to
+ * the user instead of a generic stall.
+ */
+export class ToolExecutionTimeoutError extends Error {
+  constructor(toolName, timeoutMs) {
+    super(`Tool "${toolName}" did not complete within ${timeoutMs}ms`);
+    this.name = 'ToolExecutionTimeoutError';
+    this.toolName = toolName;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
 /**
  * Truncate a tool result if it exceeds the per-result cap. Non-string
  * outputs are JSON-stringified first (matching what engine.js eventually
@@ -76,6 +120,35 @@ export function truncateToolResultIfNeeded(output, { contextWindow, toolName })
   return head + marker;
 }
 
+/**
+ * Race a promise against a timer. If the promise resolves first, return its
+ * value. If the timer wins, throw {@link ToolExecutionTimeoutError}. The
+ * underlying tool promise is intentionally NOT cancelled — JS has no
+ * cooperative promise cancellation, so a tool that ignores `signal` will
+ * keep running in the background; we just stop waiting on it. The engine
+ * sees a clean error and the user sees `tool_end{isError:true}` instead
+ * of an indefinite hang.
+ *
+ * Internal helper — not exported. The default and overrides are managed
+ * via {@link DEFAULT_TOOL_TIMEOUT_MS} and `tool.timeoutMs`.
+ *
+ * @param {Promise<unknown>} promise
+ * @param {number} timeoutMs
+ * @param {string} toolName
+ * @returns {Promise<unknown>}
+ */
+function runWithTimeout(promise, timeoutMs, toolName) {
+  let timer = null;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new ToolExecutionTimeoutError(toolName, timeoutMs));
+    }, timeoutMs);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+
 export class ToolRegistry {
   /** @type {Map<string, import('./types.js').ToolDef>} */
   #tools = new Map();
@@ -174,7 +247,20 @@ export class ToolRegistry {
   async execute(name, input, ctx = {}) {
     const tool = this.#tools.get(name);
     if (!tool) throw new Error(`Unknown tool: ${name}`);
-    const output = await tool.execute(input, ctx);
+
+    // Per-tool timeout. A tool that ignores `signal` and never resolves
+    // would otherwise hang the engine's `await this.#toolRegistry.execute(...)`
+    // indefinitely — see DEFAULT_TOOL_TIMEOUT_MS docblock for the
+    // motivating "silent turn stall" failure. The race throws a typed
+    // error on timeout; the engine's existing catch turns it into
+    // `tool_end{isError:true}` and the loop continues.
+    const rawTimeout = Number.isFinite(tool.timeoutMs) ? tool.timeoutMs : DEFAULT_TOOL_TIMEOUT_MS;
+    const useTimeout = rawTimeout > 0;
+
+    const output = useTimeout
+      ? await runWithTimeout(tool.execute(input, ctx), rawTimeout, name)
+      : await tool.execute(input, ctx);
+
     return truncateToolResultIfNeeded(output, {
       contextWindow: ctx.contextWindow,
       toolName: name,

package/unify/tools/types.js

@@ -68,6 +68,7 @@
  *   isConcurrencySafe?: (input?: object) => boolean,
  *   isReadOnly?: (input?: object) => boolean,
  *   isDestructive?: (input?: object) => boolean,
+ *   timeoutMs?: number,
  * }} def
  * @returns {ToolDef}
  */
@@ -79,11 +80,12 @@ export function defineTool({
   isConcurrencySafe = () => false,
   isReadOnly = () => false,
   isDestructive = () => false,
+  timeoutMs,
 }) {
   if (!name) throw new Error('Tool must have a name');
   if (!execute) throw new Error(`Tool "${name}" must have an execute function`);
 
-  return {
+  const def = {
     name,
     description: description || `Tool: ${name}`,
     parameters: parameters || { type: 'object', properties: {} },
@@ -92,4 +94,11 @@ export function defineTool({
     isReadOnly,
     isDestructive,
   };
+  // Only attach `timeoutMs` when the tool author opts in. Leaving it
+  // unset means ToolRegistry.execute uses DEFAULT_TOOL_TIMEOUT_MS — set
+  // to <= 0 to disable the per-tool timeout entirely.
+  if (Number.isFinite(timeoutMs)) {
+    def.timeoutMs = timeoutMs;
+  }
+  return def;
 }