@yeaft/webchat-agent 0.1.569 → 0.1.572

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 } from '../unify/config-api.js';
-import { handleUnifyChat, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyGroupChat, handleUnifyModeSwitch, handleUnifyModelSwitch, resetUnifySession, handleUnifyLoadHistory, handleUnifyMergeThread, handleUnifyForkThread, handleUnifyAbortThread, handleUnifyAbortAll, handleUnifyVpSubscribe, handleUnifyVpCreate, handleUnifyVpUpdate, handleUnifyVpDelete, handleUnifyVpRead, handleUnifyTaskMessage, handleUnifyUserMemoryWrite, handleUnifyUserMemoryRemove, handleUnifyMemoryScopeList, handleUnifyListGroups, handleUnifyCreateGroup, handleUnifyRenameGroup, handleUnifyArchiveGroup, handleUnifyAddMember, handleUnifyRemoveMember, handleUnifySetDefaultVp, handleUnifyDreamTrigger } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -440,6 +440,11 @@ export async function handleMessage(msg) {
     case 'unify_user_memory_remove':
       handleUnifyUserMemoryRemove(msg);
       break;
+    // task-fix: list MemoryStore entries (scope-tree folder view) for the
+    // Unify "User Memory" page. Replies with `memory_scope_snapshot`.
+    case 'unify_memory_scope_list':
+      handleUnifyMemoryScopeList(msg);
+      break;
 
     // task-334m: Group CRUD + D1 seed wiring (§Δ10 334m + R6 §Δ31.2).
     // All handlers reply via `group_crud_result`; mutating ops additionally

package/package.json

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

package/unify/conversation/persist.js

@@ -71,11 +71,24 @@ function serializeMessage(msg) {
   fm.push(`tokens_est: ${tokensEst}`);
 
   // Tool calls as YAML array (simplified)
+  // task-fix: persist `input` as base64-encoded JSON so multi-line tool
+  // arguments round-trip safely (YAML string escaping is brittle for
+  // JSON blobs with newlines / quotes). Paired with the parser below.
   if (msg.toolCalls && msg.toolCalls.length > 0) {
     fm.push(`toolCalls:`);
     for (const tc of msg.toolCalls) {
       fm.push(`  - id: ${tc.id}`);
       fm.push(`    name: ${tc.name}`);
+      if (tc.input !== undefined) {
+        try {
+          const b64 = Buffer.from(JSON.stringify(tc.input)).toString('base64');
+          fm.push(`    inputB64: ${b64}`);
+        } catch {
+          // best-effort: if input isn't JSON-serializable, skip it;
+          // restoring a tool_call without input is still better than
+          // dropping the whole record.
+        }
+      }
     }
   }
 
@@ -138,13 +151,21 @@ export function parseMessage(raw) {
       for (const entry of entries) {
         const tc = {};
         for (const line of entry.split('\n')) {
-          const trimmed = line.trim();
+          // task-fix: the split regex only strips `\n  - ` between
+          // entries, leaving a leading `- ` on the first line of the
+          // first entry. Strip it here so `- id: xxx` parses as `id`.
+          const trimmed = line.trim().replace(/^-\s+/, '');
           const ci = trimmed.indexOf(':');
           if (ci === -1) continue;
           const k = trimmed.slice(0, ci).trim();
           const v = trimmed.slice(ci + 1).trim();
           if (k === 'id') tc.id = v;
           if (k === 'name') tc.name = v;
+          if (k === 'inputB64') {
+            try {
+              tc.input = JSON.parse(Buffer.from(v, 'base64').toString('utf8'));
+            } catch { /* best-effort: leave input undefined */ }
+          }
         }
         if (tc.id && tc.name) toolCalls.push(tc);
       }

package/unify/stop-hooks.js

@@ -65,19 +65,53 @@ export async function runStopHooks(context) {
   }
 
   // 1. Persist latest messages
+  //
+  // task-fix: we must persist the complete new turn — including the
+  // assistant's `toolCalls` and each paired `role:'tool'` result —
+  // otherwise restoring history on session reload drops the pairing
+  // and causes "No tool output found for function call" 400s on the
+  // next chat-completions request. We walk back from the end of
+  // `messages` to find the first `role:'user'` that marks the start
+  // of the current turn, then persist everything from there forward.
   try {
     if (conversationStore && messages.length > 0) {
-      const recentMessages = messages.slice(-2); // last user + assistant pair
+      // Find the start of the latest turn — the last `role:'user'`
+      // message in the array. Everything from that index onward is
+      // new this turn (user + assistant[+toolCalls] + tool results).
+      let turnStart = messages.length - 1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i] && messages[i].role === 'user') {
+          turnStart = i;
+          break;
+        }
+      }
+      const recentMessages = messages.slice(turnStart);
       for (const msg of recentMessages) {
-        if (msg.role && msg.content) {
-          conversationStore.append({
-            role: msg.role,
-            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-            mode,
-            model: persistModel,
-          });
-          result.messagesPersisted++;
+        if (!msg || !msg.role) continue;
+        // Allow empty assistant content when toolCalls are present;
+        // tool messages have content by construction.
+        const hasContent =
+          (typeof msg.content === 'string' && msg.content.length > 0) ||
+          (msg.content && typeof msg.content !== 'string') ||
+          (Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0) ||
+          msg.role === 'tool';
+        if (!hasContent) continue;
+
+        const record = {
+          role: msg.role,
+          content: typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content ?? ''),
+          mode,
+          model: persistModel,
+        };
+        if (msg.toolCallId) record.toolCallId = msg.toolCallId;
+        if (Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0) {
+          record.toolCalls = msg.toolCalls;
         }
+        if (msg.isError) record.isError = true;
+        conversationStore.append(record);
+        result.messagesPersisted++;
       }
     }
   } catch (err) {

package/unify/vp/vp-bridge.js

@@ -147,6 +147,16 @@ function _fanout(evt) {
 function ensureLoader(registry = defaultRegistry) {
   if (_loaderStarted) return { loader: _loader, fresh: false };
   _loaderStarted = true;
+  // For NON-default registries (unit tests seeding VPs manually) we MUST NOT
+  // start VpLoader — its .start() scans DEFAULT_VP_LIB_DIR and push-imports
+  // every on-disk VP into the test registry, overwriting/augmenting the
+  // fixture. Tests don't need hot-reload anyway; `_broadcastChangeForTest`
+  // drives the diff path directly.
+  if (registry !== defaultRegistry) {
+    _loader = null;
+    captureState(registry);
+    return { loader: null, fresh: true };
+  }
   try {
     _loader = new VpLoader({
       registry,

package/unify/web-bridge.js

@@ -86,6 +86,39 @@ function getThreadMessages(threadId) {
   return arr;
 }
 
+/**
+ * Restore per-thread message history from persisted conversation store.
+ *
+ * task-fix: accept `role:'tool'` messages AND preserve `toolCalls` /
+ * `toolCallId` fields. Without this, chat-completions serialization
+ * emits `tool_calls` without paired `role:'tool'` results, causing
+ * "No tool output found for function call" 400s after the first tool
+ * use across any restart / session-ready / model-switch event.
+ *
+ * @param {Array<object>} recent — output of conversationStore.loadRecent()
+ */
+function restoreThreadHistoryFromRecent(recent) {
+  messagesByThread.clear();
+  for (const m of recent) {
+    // Keep user, assistant, AND tool messages. Tool messages are required
+    // for the chat-completions `tool_call_id` pairing.
+    if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') continue;
+    const tid = m.threadId || MAIN_THREAD_ID;
+    const bucket = getThreadMessages(tid);
+    const entry = { role: m.role, content: m.content };
+    if (m.toolCallId) entry.toolCallId = m.toolCallId;
+    if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
+      entry.toolCalls = m.toolCalls.map(tc => ({
+        id: tc.id,
+        name: tc.name,
+        input: tc.input,
+      }));
+    }
+    if (m.isError) entry.isError = true;
+    bucket.push(entry);
+  }
+}
+
 /** Whether we've already sent a permission warning to the UI */
 let _permissionDiagnosticSent = false;
 
@@ -257,6 +290,41 @@ export function handleUnifyUserMemoryRemove(msg) {
   _handleUnifyUserMemoryRemove(msg, sendUnifyEvent);
 }
 
+/**
+ * task-fix: list MemoryStore entries as a scope-tree for the
+ * UserMemoryPage "folder view". Entries come from MemoryStore.listEntries()
+ * and are grouped client-side by their `scope` (a `/`-separated path like
+ * `work/claude-web-chat/auth`).
+ *
+ * Request shape:  { type: 'unify_memory_scope_list', requestId? }
+ * Reply shape:    { type: 'memory_scope_snapshot',
+ *                   entries: Array<{name,scope,kind,tags,importance,
+ *                                    frequency,created_at,updated_at,
+ *                                    content}>,
+ *                   requestId? }
+ */
+export function handleUnifyMemoryScopeList(msg) {
+  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
+  try {
+    const store = session && session.memoryStore;
+    const entries = store && typeof store.listEntries === 'function'
+      ? store.listEntries()
+      : [];
+    sendUnifyEvent({
+      type: 'memory_scope_snapshot',
+      entries,
+      ...(requestId ? { requestId } : {}),
+    });
+  } catch (err) {
+    sendUnifyEvent({
+      type: 'memory_scope_snapshot',
+      entries: [],
+      error: String(err && err.message || err),
+      ...(requestId ? { requestId } : {}),
+    });
+  }
+}
+
 export function handleUnifyVpRead(msg) {
   const requestId = msg && msg.requestId;
   const vpId = msg && msg.vpId;
@@ -754,7 +822,7 @@ function forwardPipelineEvent(ev, ctx) {
  *
  * @param {object} event — engine event (text_delta / tool_call / …)
  * @param {string} threadId — owning thread id (from envelope)
- * @param {{assistantTextParts:string[], resetQueryTimer:Function}} hctx
+ * @param {{assistantTextParts:string[], toolCallsAccum:Array, toolResultsAccum:Array, resetQueryTimer:Function}} hctx
  */
 function handleEngineEvent(event, threadId, hctx) {
   hctx.resetQueryTimer();
@@ -790,6 +858,16 @@ function handleEngineEvent(event, threadId, hctx) {
       break;
 
     case 'tool_call':
+      // Capture tool_call for the assistant message's toolCalls array so the
+      // next turn's history correctly pairs `tool_calls` with `role:'tool'`
+      // results (fixes "No tool output found for function call" 400s).
+      if (hctx.toolCallsAccum) {
+        hctx.toolCallsAccum.push({
+          id: event.id,
+          name: event.name,
+          input: event.input,
+        });
+      }
       // Finish any in-progress text streaming so UI shows typing dots
       sendUnifyOutput({
         type: 'assistant',
@@ -820,6 +898,17 @@ function handleEngineEvent(event, threadId, hctx) {
       break;
 
     case 'tool_end':
+      // Capture tool result for the next-turn history so the paired
+      // `role:'tool'` message is included when we hand `messages` back to
+      // engine.query() (chat-completions requires tool_call_id pairing).
+      if (hctx.toolResultsAccum) {
+        hctx.toolResultsAccum.push({
+          role: 'tool',
+          toolCallId: event.id,
+          content: typeof event.output === 'string' ? event.output : JSON.stringify(event.output ?? ''),
+          isError: !!event.isError,
+        });
+      }
       sendUnifyOutput({
         type: 'user',
         tool_use_result: [{
@@ -1113,14 +1202,9 @@ export async function handleUnifyChat(msg) {
 
       // Restore per-thread history from persisted conversation store.
       // task-320: bucket by threadId so each thread keeps its own context.
-      messagesByThread.clear();
-      const recent = session.conversationStore.loadRecent(50);
-      for (const m of recent) {
-        if (m.role !== 'user' && m.role !== 'assistant') continue;
-        const tid = m.threadId || MAIN_THREAD_ID;
-        const bucket = getThreadMessages(tid);
-        bucket.push({ role: m.role, content: m.content });
-      }
+      // task-fix: use restoreThreadHistoryFromRecent() so tool messages
+      // and toolCalls/toolCallId survive the restore.
+      restoreThreadHistoryFromRecent(session.conversationStore.loadRecent(50));
 
       // Notify UI: session is ready with model info + conversationId
       sendUnifyEvent({
@@ -1176,6 +1260,11 @@ export async function handleUnifyChat(msg) {
     try {
     // ─── Collect assistant response for conversation history ──
     let assistantTextParts = [];
+    // task-fix: preserve toolCalls + tool_result pairings across turns so
+    // the next engine.query({messages}) handoff stays valid for OpenAI
+    // chat-completions (avoids "No tool output found for function call").
+    const toolCallsAccum = [];
+    const toolResultsAccum = [];
 
     // task-310: route via Dispatcher pipeline (queue → router → registry →
     // EngineInstance). The input is enqueued first so the UI observes the
@@ -1203,6 +1292,8 @@ export async function handleUnifyChat(msg) {
     const pipelineCtx = {
       onEngineEvent: (event, threadId) => handleEngineEvent(event, threadId, {
         assistantTextParts,
+        toolCallsAccum,
+        toolResultsAccum,
         resetQueryTimer,
       }),
       onError: (err) => { throw err; },
@@ -1226,13 +1317,38 @@ export async function handleUnifyChat(msg) {
 
     // ─── Query complete — accumulate messages for context continuity ──
     // task-320: per-thread history (no cross-thread contamination).
+    // task-fix: when the turn made tool calls, the assistant message MUST
+    // carry `toolCalls` AND each paired `role:'tool'` result must be
+    // appended — otherwise the next turn's chat-completions serializer
+    // emits `tool_calls` without matching `tool` messages → proxy 400
+    // "No tool output found for function call call_xxx".
     const historyThread = resolvedThreadId || MAIN_THREAD_ID;
     const threadMessages = getThreadMessages(historyThread);
     threadMessages.push({ role: 'user', content: cleanedPrompt });
 
     const fullText = assistantTextParts.join('');
-    if (fullText) {
-      threadMessages.push({ role: 'assistant', content: fullText });
+    if (fullText || toolCallsAccum.length > 0) {
+      const assistantMsg = { role: 'assistant', content: fullText };
+      if (toolCallsAccum.length > 0) {
+        assistantMsg.toolCalls = toolCallsAccum.map(tc => ({
+          id: tc.id,
+          name: tc.name,
+          input: tc.input,
+        }));
+      }
+      threadMessages.push(assistantMsg);
+
+      // Append paired tool results, in order. Chat-completions requires
+      // one `role:'tool'` message per `tool_call_id` right after the
+      // assistant message that emitted them.
+      for (const tr of toolResultsAccum) {
+        threadMessages.push({
+          role: 'tool',
+          toolCallId: tr.toolCallId,
+          content: tr.content,
+          isError: tr.isError,
+        });
+      }
     }
 
     // ─── Signal turn end to UI ──
@@ -1627,14 +1743,9 @@ export async function handleUnifyLoadHistory(msg) {
 
     // Restore per-thread history from persisted conversation store.
     // task-320: bucket by threadId so each thread keeps its own context.
-    messagesByThread.clear();
-    const recent = session.conversationStore.loadRecent(50);
-    for (const m of recent) {
-      if (m.role !== 'user' && m.role !== 'assistant') continue;
-      const tid = m.threadId || MAIN_THREAD_ID;
-      const bucket = getThreadMessages(tid);
-      bucket.push({ role: m.role, content: m.content });
-    }
+    // task-fix: use restoreThreadHistoryFromRecent() so tool messages
+    // and toolCalls/toolCallId survive the restore.
+    restoreThreadHistoryFromRecent(session.conversationStore.loadRecent(50));
   }
 
   // task-322: replay `session_ready` + `thread_list_updated` UNCONDITIONALLY
@@ -1739,12 +1850,9 @@ export async function resetUnifySession() {
     unifyConversationId = `unify-${Date.now()}`;
 
     // Restore per-thread history for LLM context (task-320).
-    const recent = session.conversationStore.loadRecent(50);
-    for (const m of recent) {
-      if (m.role !== 'user' && m.role !== 'assistant') continue;
-      const tid = m.threadId || MAIN_THREAD_ID;
-      getThreadMessages(tid).push({ role: m.role, content: m.content });
-    }
+    // task-fix: use restoreThreadHistoryFromRecent() so tool messages
+    // and toolCalls/toolCallId survive the restore.
+    restoreThreadHistoryFromRecent(session.conversationStore.loadRecent(50));
 
     sendUnifyEvent({
       type: 'session_ready',