@yeaft/webchat-agent 1.0.208 → 1.0.209

package/package.json

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

@@ -6537,18 +6537,50 @@ export async function handleYeaftLoadHistory(msg) {
 }
 
 /**
- * Handle a "load older messages" pagination request. Reads `turns` more
- * turns of history strictly older than `beforeSeq` for `sessionId`, and
- * emits them in a single `yeaft_history_chunk` envelope (NOT a
- * `yeaft_output` — that pipeline appends, but the frontend needs to
- * PREPEND these older messages above what it already has).
+ * Load one lightweight Conversation Outline page. The response contains only
+ * visible user/assistant metadata and bounded snippets; full message bodies and
+ * tool payloads stay on the Agent. `beforeSeq` is an exclusive older-page
+ * cursor, and `includeTotal` avoids recounting after the first page.
  *
- * Tool replay is NOT included in this PR — same projection as
- * `handleYeaftLoadHistory` (user / assistant text only). On any internal
- * failure we still emit an empty chunk so the spinner clears.
- *
- * @param {object} msg — { sessionId, beforeSeq, turns }
+ * @param {object} msg — { sessionId, beforeSeq, limit, includeTotal }
  */
+export async function handleYeaftLoadHistoryOutline(msg) {
+  const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
+  const requestId = typeof msg?.requestId === 'string' ? msg.requestId : null;
+  const beforeSeq = Number.isFinite(msg?.beforeSeq) ? msg.beforeSeq : null;
+  const limit = Math.min(100, Math.max(1, Number.isFinite(msg?.limit) ? Math.floor(msg.limit) : 50));
+  const response = {
+    type: 'yeaft_history_outline',
+    requestId,
+    sessionId: sessionId || null,
+    results: [],
+    hasMore: false,
+    nextBeforeSeq: null,
+    totalCount: null,
+    _requestClientId: msg?._requestClientId || null,
+  };
+
+  if (!sessionId) {
+    sendToServer({ ...response, error: 'invalid_session' });
+    return;
+  }
+
+  try {
+    const defaultYeaftDir = ctx.CONFIG?.yeaftDir || DEFAULT_YEAFT_DIR;
+    const storeDir = resolveSessionYeaftDir(defaultYeaftDir, sessionId);
+    const store = new ConversationStore(storeDir);
+    const result = store.loadVisibleOutlineBySession(sessionId, {
+      limit,
+      beforeSeq,
+      includeTotal: msg?.includeTotal !== false,
+    });
+    sendToServer({ ...response, ...result });
+  } catch (err) {
+    console.error('[Yeaft] Session history outline failed:', err?.message || err);
+    sendToServer({ ...response, error: 'outline_failed' });
+  }
+}
+
 export async function handleYeaftSearchHistory(msg) {
   const sessionId = typeof msg?.sessionId === 'string' ? msg.sessionId.trim() : '';
   const query = typeof msg?.query === 'string' ? msg.query.trim().slice(0, 500) : '';