npm - @yeaft/webchat-agent - Versions diffs - 1.0.197 → 1.0.199 - Mend

@yeaft/webchat-agent 1.0.197 → 1.0.199

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +83 -83
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/conversation/persist.js +180 -36
package/yeaft/engine.js +3 -1
package/yeaft/tools/types.js +1 -1
package/yeaft/web-bridge.js +469 -189

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=aa7816be"></script>
+  <script type="module" src="app.bundle.js?v=b986f0f0"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.197",
+  "version": "1.0.199",
   "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 CHANGED Viewed

@@ -57,6 +57,10 @@ let DEFAULT_RECENT_TURNS = 20;
 const RECENT_SESSION_SCAN_BASE_CAP = 64;
 const RECENT_SESSION_SCAN_PER_TURN_CAP = 4;
 const RECENT_SESSION_SCAN_MAX_CAP = 256;
+// A normal Engine loop executes at most 30 tools, but parallel VPs can append
+// many rows between a call and its result. One extra normal delta page keeps the
+// scan bounded while leaving enough room to close a legitimate interleaved arc.
+const DELTA_TOOL_PAIR_EXTENSION_CAP = 500;
 const SEGMENT_INDEX_FILE = 'index.json';
@@ -235,6 +239,90 @@ function recentSessionScanCap(turnsLimit) {
   return Math.min(RECENT_SESSION_SCAN_MAX_CAP, RECENT_SESSION_SCAN_BASE_CAP + turns * RECENT_SESSION_SCAN_PER_TURN_CAP);
 }
+function askUserToolIdentity(row, toolCallId) {
+  if (!row || typeof toolCallId !== 'string' || !toolCallId) return null;
+  return [
+    row.sessionId || '',
+    row.speakerVpId || '',
+    row.turnId || '',
+    row.threadId || 'main',
+    toolCallId,
+  ].join('\u0000');
+}
+function parseAskUserResult(toolCall, toolResult) {
+  if (!toolCall || toolCall.name !== 'AskUser' || typeof toolCall.id !== 'string' || !toolCall.id
+      || !toolResult || toolResult.isError) return null;
+  let payload = toolResult.content;
+  if (typeof payload === 'string') {
+    try { payload = JSON.parse(payload); } catch { return null; }
+  }
+  if (!payload || typeof payload !== 'object') return null;
+  const question = typeof toolCall.input?.question === 'string'
+    ? toolCall.input.question
+    : (typeof payload.question === 'string' ? payload.question : '');
+  const options = Array.isArray(toolCall.input?.options)
+    ? toolCall.input.options.filter(option => typeof option === 'string')
+    : [];
+  if (payload.timedOut === true) {
+    return {
+      toolCallId: toolCall.id,
+      status: 'expired',
+      question,
+      options,
+    };
+  }
+  if (!payload.answers || typeof payload.answers !== 'object' || Array.isArray(payload.answers)) return null;
+  return {
+    toolCallId: toolCall.id,
+    status: 'answered',
+    question,
+    options,
+    answers: payload.answers,
+  };
+}
+export function projectVisibleSessionMessages(messages) {
+  const rows = Array.isArray(messages) ? messages : [];
+  const toolResults = new Map();
+  for (const row of rows) {
+    if (row?.role !== 'tool') continue;
+    const identity = askUserToolIdentity(row, row.toolCallId);
+    if (identity) toolResults.set(identity, row);
+  }
+  const visible = [];
+  for (const row of rows) {
+    if (!row || (row.role !== 'user' && row.role !== 'assistant')) continue;
+    if (row.role !== 'assistant' || !Array.isArray(row.toolCalls) || row.toolCalls.length === 0) {
+      if (row.role === 'assistant' && !row.content && !row.attachments && !row.images
+          && !row.toolSummaryCount && !row.askUserResults) continue;
+      visible.push(row);
+      continue;
+    }
+    const askUserResults = [];
+    let omittedToolCount = 0;
+    for (const toolCall of row.toolCalls) {
+      const identity = askUserToolIdentity(row, toolCall?.id);
+      const result = parseAskUserResult(toolCall, identity ? toolResults.get(identity) : null);
+      if (result) askUserResults.push(result);
+      else omittedToolCount += 1;
+    }
+    const { toolCalls, ...rest } = row;
+    const projected = {
+      ...rest,
+      ...(omittedToolCount > 0 ? { toolSummaryCount: omittedToolCount } : {}),
+      ...(askUserResults.length > 0 ? { askUserResults } : {}),
+    };
+    if (!projected.content && !projected.attachments && !projected.images
+        && !projected.toolSummaryCount && !projected.askUserResults) continue;
+    visible.push(projected);
+  }
+  return visible;
+}
 // ─── Frontmatter helpers ─────────────────────────────────────
 /**
@@ -1346,14 +1434,15 @@ export class ConversationStore {
     const cutoff = Number.isFinite(beforeSeq) ? beforeSeq : Infinity;
     const page = this.#loadRecentSessionWindow(sessionId, turnsLimit, {
       beforeSeq: cutoff,
-      roles: new Set(['user', 'assistant']),
-      stripAssistantToolCalls: true,
+      roles: null,
+      stripAssistantToolCalls: false,
     });
-    if (page.messages.length === 0) return { messages: [], oldestSeq: null, hasMore: page.truncated };
+    const messages = projectVisibleSessionMessages(page.messages);
+    if (messages.length === 0) return { messages: [], oldestSeq: null, hasMore: page.truncated };
-    const oldestSeq = page.messages.length ? parseSeqFromId(page.messages[0].id) : null;
+    const oldestSeq = messages.length ? parseSeqFromId(messages[0].id) : null;
     return {
-      messages: page.messages,
+      messages,
       oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
       hasMore: page.truncated,
     };
@@ -1368,8 +1457,8 @@ export class ConversationStore {
    * cursor. When no visible rows changed after `afterSeq`, keep the cursor at
    * least at `afterSeq` so an empty delta still completes the in-flight sync
    * without downgrading the client to a cursor-less loaded state. Hidden rows
-   * are also allowed to advance this cursor because they were scanned and
-   * intentionally omitted from UI replay.
+   * advance the cursor only at pair-safe boundaries; a cursor must never cross
+   * an assistant tool call before all of that call's result rows are included.
    *
    * @param {string} sessionId
    * @param {number|null} afterSeq — exclusive lower bound
@@ -1382,19 +1471,81 @@ export class ConversationStore {
     const cutoff = Number.isFinite(afterSeq) && afterSeq >= 0 ? afterSeq : null;
     if (cutoff === null) return { messages: [], latestSeq: null };
     const after = [];
-    let newestScannedSeq = cutoff;
+    const pendingToolResultIds = new Set();
+    const completedBeforeCursor = new Set();
+    const boundaryAssistants = [];
+    let boundaryLookbackRows = 0;
+    for (const previous of this.#iterateSessionRows(sessionId, { beforeSeq: cutoff + 1, desc: true })) {
+      if (!previous || previous.sessionId !== sessionId) continue;
+      boundaryLookbackRows += 1;
+      if (boundaryLookbackRows > DELTA_TOOL_PAIR_EXTENSION_CAP) break;
+      if (isHiddenConversationRow(previous)) continue;
+      if (previous.role === 'tool' && typeof previous.toolCallId === 'string') {
+        completedBeforeCursor.add(previous.toolCallId);
+        continue;
+      }
+      if (previous.role === 'assistant' && Array.isArray(previous.toolCalls) && previous.toolCalls.length > 0) {
+        const pendingIds = previous.toolCalls
+          .map(toolCall => toolCall?.id)
+          .filter(toolCallId => typeof toolCallId === 'string'
+            && toolCallId
+            && !completedBeforeCursor.has(toolCallId));
+        if (pendingIds.length > 0) boundaryAssistants.push({ message: previous, pendingIds });
+        continue;
+      }
+      if (previous.role === 'user') break;
+    }
+    boundaryAssistants.sort((a, b) => compareMessagesBySeq(a.message, b.message));
+    for (const boundary of boundaryAssistants) {
+      after.push(boundary.message);
+      for (const toolCallId of boundary.pendingIds) pendingToolResultIds.add(toolCallId);
+    }
+    const earliestBoundarySeq = boundaryAssistants.length > 0
+      ? parseSeqFromId(boundaryAssistants[0].message.id)
+      : null;
+    let safeCursorSeq = Number.isFinite(earliestBoundarySeq)
+      ? Math.max(0, earliestBoundarySeq - 1)
+      : cutoff;
+    let visibleRows = after.length;
+    let extensionRows = 0;
     for (const m of this.#iterateSessionRows(sessionId, { afterSeq: cutoff, desc: false })) {
       if (!m || m.sessionId !== sessionId) continue;
       const seq = parseSeqFromId(m.id);
-      if (Number.isFinite(seq) && seq > newestScannedSeq) newestScannedSeq = seq;
-      if (isHiddenConversationRow(m)) continue;
-      after.push(m);
-      if (after.length >= limit) break;
-    }
-    const sliced = pairSanitize(after.slice(0, limit));
-    const lastSeq = sliced.length ? parseSeqFromId(sliced[sliced.length - 1].id) : null;
-    const latestSeq = Number.isFinite(lastSeq) ? Math.max(lastSeq, newestScannedSeq) : newestScannedSeq;
-    return { messages: sliced, latestSeq };
+      const hidden = isHiddenConversationRow(m);
+      if (!hidden) {
+        // Keep every outstanding call open across interleaved VP rows. Session
+        // persistence is globally sequenced, so a sibling VP may append visible
+        // messages between an assistant call and that call's result.
+        after.push(m);
+        visibleRows += 1;
+        if (m.role === 'assistant' && Array.isArray(m.toolCalls)) {
+          for (const toolCall of m.toolCalls) {
+            if (typeof toolCall?.id === 'string' && toolCall.id) pendingToolResultIds.add(toolCall.id);
+          }
+        } else if (m.role === 'tool' && typeof m.toolCallId === 'string') {
+          pendingToolResultIds.delete(m.toolCallId);
+        }
+      }
+      if (pendingToolResultIds.size === 0 && Number.isFinite(seq)) safeCursorSeq = seq;
+      if (visibleRows < limit) continue;
+      if (pendingToolResultIds.size === 0) break;
+      extensionRows += 1;
+      if (extensionRows >= DELTA_TOOL_PAIR_EXTENSION_CAP) break;
+    }
+    // If the extension cap stopped inside a malformed arc, return only the
+    // prefix covered by the safe cursor. Returning later rows with an earlier
+    // cursor would make the next delta repeat visible messages unnecessarily.
+    const pairSafeRows = pendingToolResultIds.size === 0
+      ? after
+      : after.filter(message => {
+          const seq = parseSeqFromId(message?.id);
+          return Number.isFinite(seq) && seq <= safeCursorSeq;
+        });
+    const sliced = pairSanitize(pairSafeRows);
+    // Never advance past a row the sanitizer had to drop. A malformed or
+    // over-cap tool arc must be retried from its assistant call rather than
+    // turning the following result into a permanent orphan on the next page.
+    return { messages: projectVisibleSessionMessages(sliced), latestSeq: safeCursorSeq };
   }
   /**
@@ -1480,31 +1631,33 @@ export class ConversationStore {
     const beforeTurns = Math.min(10, Math.max(1, Number.isFinite(opts.beforeTurns) ? Math.floor(opts.beforeTurns) : 3));
     const afterTurns = Math.min(10, Math.max(1, Number.isFinite(opts.afterTurns) ? Math.floor(opts.afterTurns) : 3));
-    const before = this.loadVisibleBySession(sessionId, anchorSeq + 1, beforeTurns + 1);
-    const messages = before.messages.slice();
+    const beforeRaw = this.#loadRecentSessionWindow(sessionId, beforeTurns + 1, {
+      beforeSeq: anchorSeq + 1,
+      roles: null,
+      stripAssistantToolCalls: false,
+    });
+    const messages = beforeRaw.messages.slice();
     const seen = new Set(messages.map(message => message?.id).filter(Boolean));
     let followingUserTurns = 0;
     for (const message of this.#iterateSessionRows(sessionId, { afterSeq: anchorSeq, desc: false })) {
       if (!message || message.sessionId !== sessionId || isHiddenConversationRow(message)) continue;
-      if (message.role !== 'user' && message.role !== 'assistant') continue;
       if (message.role === 'user') {
         followingUserTurns += 1;
         if (followingUserTurns > afterTurns) break;
       }
       if (message.id && seen.has(message.id)) continue;
-      const projected = this.#projectVisibleMessage(message);
-      if (!projected) continue;
-      if (projected.id) seen.add(projected.id);
-      messages.push(projected);
+      if (message.id) seen.add(message.id);
+      messages.push(message);
     }
     messages.sort(compareMessagesBySeq);
-    const oldestSeq = messages.length > 0 ? parseSeqFromId(messages[0].id) : null;
+    const visibleMessages = projectVisibleSessionMessages(messages);
+    const oldestSeq = visibleMessages.length > 0 ? parseSeqFromId(visibleMessages[0].id) : null;
     return {
-      messages,
+      messages: visibleMessages,
       oldestSeq: Number.isFinite(oldestSeq) ? oldestSeq : null,
-      hasMoreBefore: before.hasMore,
+      hasMoreBefore: beforeRaw.truncated,
     };
   }
@@ -2246,15 +2399,6 @@ export class ConversationStore {
     return `${start > 0 ? '…' : ''}${text.slice(start, end)}${end < text.length ? '…' : ''}`;
   }
-  #projectVisibleMessage(message) {
-    if (!message || (message.role !== 'user' && message.role !== 'assistant')) return null;
-    if (message.role !== 'assistant' || !Array.isArray(message.toolCalls) || message.toolCalls.length === 0) {
-      return message;
-    }
-    const { toolCalls, ...rest } = message;
-    return { ...rest, toolSummaryCount: toolCalls.length };
-  }
   #readSegmentRows(conversationDir, opts = {}) {
     return this.#segmentStoreForConversationDir(conversationDir).readAll(opts);
   }

package/yeaft/engine.js CHANGED Viewed

@@ -1242,7 +1242,9 @@ export class Engine {
       // Null in non-VP / test contexts — tools tolerate missing slots.
       getCurrentTodos: vpCtx?.getCurrentTodos || null,
       setCurrentTodos: vpCtx?.setCurrentTodos || null,
-      askUser: vpCtx?.askUser || null,
+      askUser: typeof vpCtx?.askUser === 'function'
+        ? input => vpCtx.askUser(input, typeof vpCtx?.currentToolCall === 'function' ? vpCtx.currentToolCall() : null)
+        : null,
       // task-707: tool-callable end-turn signal. The engine threads this
       // setter when constructing toolCtx so a tool (e.g. route_forward)
       // can mark "after this batch, end the turn — do NOT call adapter

package/yeaft/tools/types.js CHANGED Viewed

@@ -32,7 +32,7 @@
  * @property {number} [contextWindow] — current model's context window in
  *   tokens (used by ToolRegistry.execute to cap a single tool result at a
  *   fraction of the window so one runaway grep can't blow the wire).
- * @property {(input: {question:string, options?:string[]}) => Promise<object>} [askUser]
+ * @property {(input: {question:string, options?:string[]}, toolCall?: {id?:string, name?:string}|null) => Promise<object>} [askUser]
  *   — host-provided interactive prompt. Resolves only after the user answers.
  * @property {(reason?: string|object) => void} [requestEndTurn]
  *   — tool-callable signal that the current engine turn should end after