@yeaft/webchat-agent 0.1.734 → 0.1.735

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.735",
   "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/web-bridge.js

@@ -53,6 +53,7 @@ import {
 import { createFeatureArc } from './feature-arc.js';
 import { getFeatureStore } from './tools/feature-tools.js';
 import { persistUnifyAttachments, attachmentsForPersistence } from './attachments.js';
+import { parseSeqFromId } from './conversation/persist.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -2594,6 +2595,32 @@ export async function handleUnifyLoadHistory(msg) {
     }
   }
 
+  // Compute the pagination cursor for the bootstrap load so the frontend
+  // knows whether a "Load older messages" hint should be shown and where
+  // to start the next page. The cursor is the seq of the oldest replayed
+  // message; `hasMore` is true iff there's an earlier message in the
+  // group that we did NOT replay.
+  let hasMore = false;
+  let oldestSeq = null;
+  if (groupId && messages.length > 0) {
+    const firstId = messages[0].id;
+    const seq = parseSeqFromId(firstId);
+    // Defend against malformed ids: a NaN cursor would round-trip back as
+    // a poison `beforeSeq` and degrade subsequent paginations to "give me
+    // the newest page again". Surface as null instead.
+    oldestSeq = Number.isFinite(seq) ? seq : null;
+    if (oldestSeq != null) {
+      // Consult the store for whether anything older exists in the same
+      // group. Cheap: a single extra `loadOlderByGroup` with turns=1.
+      try {
+        const probe = session.conversationStore.loadOlderByGroup(groupId, oldestSeq, 1);
+        hasMore = probe.messages.length > 0;
+      } catch (err) {
+        console.error('[Unify] history-load probe failed:', err.message);
+      }
+    }
+  }
+
   sendUnifyEvent({
     type: 'history_loaded',
     count: messages.length,
@@ -2601,6 +2628,71 @@ export async function handleUnifyLoadHistory(msg) {
     totalHot: session.conversationStore.countHot(),
     totalCold: session.conversationStore.countCold(),
     groupId,
+    hasMore,
+    oldestSeq,
+  });
+}
+
+/**
+ * Handle a "load older messages" pagination request. Reads `turns` more
+ * turns of history strictly older than `beforeSeq` for `groupId`, and
+ * emits them in a single `unify_history_chunk` envelope (NOT a
+ * `unify_output` — that pipeline appends, but the frontend needs to
+ * PREPEND these older messages above what it already has).
+ *
+ * Tool replay is NOT included in this PR — same projection as
+ * `handleUnifyLoadHistory` (user / assistant text only). On any internal
+ * failure we still emit an empty chunk so the spinner clears.
+ *
+ * @param {object} msg — { groupId, beforeSeq, turns }
+ */
+export async function handleUnifyLoadMoreHistory(msg) {
+  const groupId = (msg && typeof msg.groupId === 'string' && msg.groupId) || null;
+  const emit = (payload) => sendToServer({
+    type: 'unify_history_chunk',
+    conversationId: unifyConversationId,
+    groupId,
+    ...payload,
+  });
+
+  if (!session || !groupId) {
+    emit({ messages: [], oldestSeq: null, hasMore: false });
+    return;
+  }
+
+  const beforeSeq = (typeof msg.beforeSeq === 'number') ? msg.beforeSeq : null;
+  const turns = (typeof msg.turns === 'number' && msg.turns > 0) ? msg.turns : 20;
+
+  let result;
+  try {
+    result = session.conversationStore.loadOlderByGroup(groupId, beforeSeq, turns);
+  } catch (err) {
+    console.error('[Unify] loadOlderByGroup failed:', err.message);
+    result = { messages: [], oldestSeq: null, hasMore: false };
+  }
+
+  // Wire shape mirrors handleUnifyLoadHistory's projection: only user /
+  // assistant text rows. Tool_use / tool_result replay is out of scope
+  // for this PR (today's bootstrap path drops them too).
+  //
+  // We intentionally do NOT ship `id` or `time` over the wire:
+  // `handleUnifyHistoryChunk` reads only role / content / groupId. The
+  // pagination cursor (`oldestSeq`) is sent once at the envelope level,
+  // so per-row ids are dead weight. `time` would be useful if we render
+  // "5 days ago" stamps on older history rows — when that ships, add it
+  // back here and consume it in conversationHandler.
+  const projected = (result.messages || [])
+    .filter(m => m && (m.role === 'user' || m.role === 'assistant'))
+    .map(m => ({
+      role: m.role,
+      content: m.content,
+      groupId: m.groupId || null,
+    }));
+
+  emit({
+    messages: projected,
+    oldestSeq: result.oldestSeq,
+    hasMore: !!result.hasMore,
   });
 }