@yeaft/webchat-agent 1.0.44 → 1.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "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/tools/registry.js

@@ -12,24 +12,16 @@
 import { formatSize } from '../archive/tool-results.js';
 
 /**
- * Collaboration tools are mutually exclusive per Yeaft group shape:
- * single-VP groups use sub-agents; multi-VP groups use VP-to-VP forwarding.
- * Keep the policy names close to the tool registry so LLM exposure and
- * execution gating use the same source of truth.
+ * Collaboration tools are gated only where the session shape makes a tool
+ * invalid. Single-VP sessions cannot forward to peers because no peers exist.
+ * Multi-VP sessions keep the full tool surface, including background tasks and
+ * sub-agents, and additionally expose VP-to-VP forwarding.
  */
 export const COLLAB_TOOL_POLICY = Object.freeze({
   SINGLE_VP: 'single-vp',
   MULTI_VP: 'multi-vp',
 });
 
-export const SUB_AGENT_TOOL_NAMES = Object.freeze([
-  'SpawnAgent',
-  'PromptAgent',
-  'WaitAgent',
-  'CloseAgent',
-  'ListAgents',
-]);
-
 export const FORWARD_TOOL_NAMES = Object.freeze(['RouteForward']);
 
 /**
@@ -261,8 +253,7 @@ export function normalizeCollabToolPolicy(policy) {
 export function isToolHiddenByCollabPolicy(toolName, policy) {
   const normalized = normalizeCollabToolPolicy(policy);
   if (!normalized) return false;
-  if (normalized === COLLAB_TOOL_POLICY.SINGLE_VP) return FORWARD_TOOL_NAMES.includes(toolName);
-  return SUB_AGENT_TOOL_NAMES.includes(toolName);
+  return normalized === COLLAB_TOOL_POLICY.SINGLE_VP && FORWARD_TOOL_NAMES.includes(toolName);
 }
 
 export class ToolRegistry {
@@ -350,8 +341,9 @@ export class ToolRegistry {
 
   /**
    * Get tool definitions for the LLM adapter.
-   * Returns all registered tools unless a collaboration policy hides one of
-   * the mutually-exclusive orchestration tool families.
+   * Returns all registered tools unless the current session shape makes a
+   * specific collaboration tool invalid, such as RouteForward in single-VP
+   * sessions.
    * @param {string} [language='en']
    * @param {{ collabToolPolicy?: string }} [opts]
    * @returns {{ name: string, description: string, parameters: object }[]}

package/yeaft/web-bridge.js

@@ -164,6 +164,41 @@ async function sendDreamSnapshotForSession(sessionId, extra = {}) {
   return snapshot;
 }
 
+function scheduleYeaftLoadHistoryMetadataReplay(sessionId) {
+  const replaySession = session;
+  const replayConversationId = yeaftConversationId;
+  setTimeout(() => {
+    try {
+      if (!replaySession) return;
+      refreshLiveSessionConfig();
+      hydrateYeaftStatusFromSession(replaySession, { reason: 'history_load', emitEvent: true });
+      sendSessionEvent({
+        type: 'session_ready',
+        conversationId: replayConversationId,
+        model: replaySession.config.primaryModel || replaySession.config.model,
+        modelEffort: replaySession.config.modelEffort || null,
+        availableModels: replaySession.config.availableModels || [],
+        skills: replaySession.status.skills,
+        mcpServers: replaySession.status.mcpServers,
+        tools: replaySession.status.tools,
+        yeaftDir: ctx.CONFIG?.yeaftDir || null,
+        tasks: replaySession.taskManager ? replaySession.taskManager.listActiveTasks() : [],
+      });
+      sendSessionSnapshotBroadcast();
+      if (sessionId && session === replaySession) {
+        sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
+      }
+      try {
+        getVpStatusBroker().broadcastSnapshot();
+      } catch (err) {
+        console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
+      }
+    } catch (err) {
+      console.warn('[Yeaft] load-history metadata replay failed:', err?.message || err);
+    }
+  }, 0);
+}
+
 
 /**
  * Single in-flight AbortController for legacy 1:1 chat. A new 1:1 user message
@@ -4819,6 +4854,7 @@ export function handleYeaftModelSwitch(msg) {
  */
 export async function handleYeaftLoadHistory(msg) {
   const sessionId = (msg && typeof msg.sessionId === 'string' && msg.sessionId) || null;
+  const metadataOnly = msg && Number.isFinite(msg.limit) && msg.limit <= 0;
   // `lim` is now expressed in TURNS, not raw messages. `loadRecent` and
   // `loadRecentBySession` use turn-based slicing so the cut never lands
   // mid-tool-arc. Pass `undefined` to use the persistence-layer default
@@ -4828,6 +4864,7 @@ export async function handleYeaftLoadHistory(msg) {
   let historyAlreadyReplayed = false;
 
   const replayHistoryFromStore = () => {
+    if (metadataOnly) return;
     // Delta path: caller knows the latest seq (or message id) it has cached
     // and wants only the messages that arrived after that cursor. Returns
     // mode:'delta' so the frontend can append+dedupe instead of replacing
@@ -4959,7 +4996,7 @@ export async function handleYeaftLoadHistory(msg) {
         afterSeq,
       });
       sendSessionEvent({ type: 'history_loaded', mode: 'delta', count: projectedMessages.length, sessionId, latestSeq: delta.latestSeq, afterSeq });
-    } else {
+    } else if (!metadataOnly) {
       emitVisibleHistoryReplay({ store: coldStore, sessionId, limit, mode: 'recent' });
     }
     historyAlreadyReplayed = true;
@@ -4972,9 +5009,6 @@ export async function handleYeaftLoadHistory(msg) {
     });
     installYeaftRuntimeBridge(session);
 
-    refreshLiveSessionConfig();
-    hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
-
     // Per-group history hydrates lazily via getOrCreateSessionHistory.
     // When the load-history call carries a sessionId, force-refresh THAT
     // group's tape so the next user message sees on-disk state. When
@@ -4984,8 +5018,6 @@ export async function handleYeaftLoadHistory(msg) {
   } else {
     replayHistoryFromStore();
     historyAlreadyReplayed = true;
-    refreshLiveSessionConfig();
-    hydrateYeaftStatusFromSession(session, { reason: 'history_load', emitEvent: true });
   }
 
   if (sessionId) {
@@ -4995,31 +5027,11 @@ export async function handleYeaftLoadHistory(msg) {
     setGroupHistory(sessionId, hydrateGroupHistory(sessionId));
   }
 
-  // Always replay session_ready so refresh / reconnect rebuilds UI state.
-  sendSessionEvent({
-    type: 'session_ready',
-    conversationId: yeaftConversationId,
-    model: session.config.primaryModel || session.config.model,
-    modelEffort: session.config.modelEffort || null,
-    availableModels: session.config.availableModels || [],
-    skills: session.status.skills,
-    mcpServers: session.status.mcpServers,
-    tools: session.status.tools,
-    yeaftDir: ctx.CONFIG?.yeaftDir || null,
-    tasks: session.taskManager ? session.taskManager.listActiveTasks() : [],
-  });
-  sendSessionSnapshotBroadcast();
-  if (sessionId) {
-    await sendDreamSnapshotForSession(sessionId, { trigger: 'load_history' }).catch(() => null);
-  }
-  // vp-status: replay the authoritative table on reconnect so a refreshed
-  // frontend doesn't have to wait for the next transition to learn each
-  // VP's current state.
-  try {
-    getVpStatusBroker().broadcastSnapshot();
-  } catch (err) {
-    console.warn('[Yeaft] vp-status snapshot broadcast (replay) failed:', err?.message || err);
-  }
+  // Always replay session_ready so refresh / reconnect rebuilds UI state, but
+  // never make the history response wait for bulky metadata snapshots. The
+  // first visible chunk has already been sent above; defer metadata to the next
+  // tick so the browser can paint messages before VP/session/dream snapshots.
+  scheduleYeaftLoadHistoryMetadataReplay(sessionId);
 
   if (historyAlreadyReplayed) return;