@yeaft/webchat-agent 0.1.421 → 0.1.423

package/connection/message-router.js

@@ -25,7 +25,7 @@ import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
 import { getLlmConfig, updateLlmConfig } from '../unify/config-api.js';
-import { handleUnifyChat } from '../unify/web-bridge.js';
+import { handleUnifyChat, handleUnifyModeSwitch, resetUnifySession } from '../unify/web-bridge.js';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -324,5 +324,13 @@ export async function handleMessage(msg) {
     case 'unify_chat':
       await handleUnifyChat(msg);
       break;
+
+    case 'unify_mode_switch':
+      handleUnifyModeSwitch(msg);
+      break;
+
+    case 'unify_reset':
+      await resetUnifySession();
+      break;
   }
 }

package/package.json

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

package/unify/web-bridge.js

@@ -1,11 +1,16 @@
 /**
  * web-bridge.js — Bridge between web UI and Yeaft Unify Engine.
  *
- * Handles `unify_chat` messages from the server, runs queries through
- * the Engine, and streams `unify_output` events back.
+ * Translates Engine events into claude_output-format messages so the
+ * frontend can fully reuse the standard Chat rendering pipeline
+ * (MessageList, AssistantTurn, ToolLine, AskCard, waiting cat, etc.).
  *
- * The session is lazily initialized on first use and reused across queries.
- * Engine internally manages conversation history and persistence.
+ * Architecture:
+ *   1. On first use, loadSession() initialises Engine with skills + MCP enabled.
+ *   2. A virtual conversationId ('unify-<ts>') is assigned per session.
+ *   3. Engine.query() yields events → translated into unify_output messages
+ *      that carry { conversationId, data } in claude_output format.
+ *   4. The frontend's handleUnifyOutput dispatches them through handleClaudeOutput.
  */
 
 import { loadSession } from './session.js';
@@ -18,33 +23,76 @@ let session = null;
 /** @type {AbortController | null} */
 let currentAbort = null;
 
+/** Virtual conversationId for the Unify session */
+let unifyConversationId = null;
+
+/** Current query mode: 'chat' or 'work' */
+let currentMode = 'chat';
+
+/**
+ * Send a unify_output message carrying claude_output-format data.
+ * The server forwards this as-is to the web client.
+ * The frontend's handleUnifyOutput will dispatch via handleClaudeOutput.
+ */
+function sendUnifyOutput(data) {
+  sendToServer({
+    type: 'unify_output',
+    conversationId: unifyConversationId,
+    data,
+  });
+}
+
+/**
+ * Send a unify_output event (non-claude_output metadata).
+ */
+function sendUnifyEvent(event) {
+  sendToServer({
+    type: 'unify_output',
+    conversationId: unifyConversationId,
+    event,
+  });
+}
+
 /**
  * Handle a unify_chat message from the web UI.
  *
- * @param {{ prompt: string, userId?: string, username?: string }} msg
+ * @param {{ prompt: string, mode?: string, userId?: string, username?: string }} msg
  */
 export async function handleUnifyChat(msg) {
-  const { prompt } = msg;
+  const { prompt, mode } = msg;
   if (!prompt?.trim()) return;
 
+  // Update mode if provided
+  if (mode === 'chat' || mode === 'work') {
+    currentMode = mode;
+  }
+
   try {
-    // Lazy-init session (reuse across queries — Engine manages history)
+    // ─── Lazy-init session (reuse across queries — Engine manages history) ──
     if (!session) {
       const yeaftDir = ctx.CONFIG?.yeaftDir;
       session = await loadSession({
         ...(yeaftDir && { dir: yeaftDir }),
-        skipMCP: true,
-        skipSkills: true,
+        // Enable all features — no lazy shortcuts
+        skipMCP: false,
+        skipSkills: false,
       });
 
-      // Send model info to UI so the badge updates
-      sendToServer({
-        type: 'unify_output',
-        event: { type: 'model_info', model: session.config.model },
+      // Create a stable conversationId for the Unify session
+      unifyConversationId = `unify-${Date.now()}`;
+
+      // Notify UI: session is ready with model info + conversationId
+      sendUnifyEvent({
+        type: 'session_ready',
+        conversationId: unifyConversationId,
+        model: session.config.model,
+        skills: session.status.skills,
+        mcpServers: session.status.mcpServers,
+        tools: session.status.tools,
       });
     }
 
-    // Cancel any in-flight query
+    // ─── Cancel any in-flight query ──
     if (currentAbort) {
       currentAbort.abort();
       currentAbort = null;
@@ -52,48 +100,197 @@ export async function handleUnifyChat(msg) {
 
     currentAbort = new AbortController();
 
-    // Stream query events → unify_output messages
-    for await (const event of session.engine.query({ prompt, signal: currentAbort.signal })) {
+    // ─── Stream Engine events → claude_output format ──
+    for await (const event of session.engine.query({
+      prompt,
+      mode: currentMode,
+      signal: currentAbort.signal,
+    })) {
       switch (event.type) {
+        // ── Text streaming ──
         case 'text_delta':
-          sendToServer({
-            type: 'unify_output',
-            event: { type: 'text_delta', text: event.text },
+          sendUnifyOutput({
+            type: 'assistant',
+            message: {
+              content: [{ type: 'text', text: event.text }],
+            },
+          });
+          break;
+
+        // ── Thinking streaming (extended thinking) ──
+        case 'thinking_delta':
+          // Currently not rendered in UI, but forward for future use
+          sendUnifyEvent({ type: 'thinking_delta', text: event.text });
+          break;
+
+        // ── Tool call announced by LLM ──
+        case 'tool_call':
+          // Finish any in-progress text streaming so UI shows typing dots
+          sendUnifyOutput({
+            type: 'assistant',
+            message: { content: [] },
           });
+          // Send tool_use block
+          sendUnifyOutput({
+            type: 'assistant',
+            message: {
+              content: [{
+                type: 'tool_use',
+                id: event.id,
+                name: event.name,
+                input: event.input,
+              }],
+            },
+          });
+          break;
+
+        // ── Tool execution started ──
+        case 'tool_start':
+          // Tool is running — the UI already shows it from tool_use block above
+          break;
+
+        // ── Tool execution completed ──
+        case 'tool_end':
+          // Send tool_result as a user message (matches Claude CLI format)
+          sendUnifyOutput({
+            type: 'user',
+            tool_use_result: [{
+              type: 'tool_result',
+              tool_use_id: event.id,
+              content: event.output || '',
+              is_error: event.isError || false,
+            }],
+          });
+          break;
+
+        // ── Turn boundaries ──
+        case 'turn_start':
+          // No UI action needed
+          break;
+
+        case 'turn_end':
+          // Don't send result/done here — wait for the outermost loop to finish
           break;
 
+        // ── Token usage ──
+        case 'usage':
+          sendUnifyEvent({
+            type: 'context_usage',
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+          });
+          break;
+
+        // ── Stop reason from LLM ──
+        case 'stop':
+          // Intermediate signal — final done is sent after the loop
+          break;
+
+        // ── Memory recall ──
+        case 'recall':
+          sendUnifyEvent({
+            type: 'recall',
+            entryCount: event.entryCount,
+            cached: event.cached,
+          });
+          break;
+
+        // ── Context consolidation ──
+        case 'consolidate':
+          sendUnifyEvent({
+            type: 'consolidate',
+            archivedCount: event.archivedCount,
+            extractedCount: event.extractedCount,
+          });
+          break;
+
+        // ── Model fallback ──
+        case 'fallback':
+          sendUnifyEvent({
+            type: 'fallback',
+            from: event.from,
+            to: event.to,
+            reason: event.reason,
+          });
+          break;
+
+        // ── Errors ──
         case 'error':
-          sendToServer({
-            type: 'unify_output',
-            event: {
-              type: 'error',
-              message: event.error?.message || 'Unknown error',
+          sendUnifyOutput({
+            type: 'assistant',
+            message: {
+              content: [{
+                type: 'text',
+                text: `⚠️ Error: ${event.error?.message || 'Unknown error'}`,
+              }],
             },
           });
           break;
 
-        // Silently consume other events (tool_call, thinking_delta, usage, etc.)
-        // These can be surfaced later as the Unify UI grows.
         default:
+          // Silently consume unknown events
           break;
       }
     }
 
-    // Signal completion
-    sendToServer({
-      type: 'unify_output',
-      event: { type: 'done' },
+    // ─── Query complete — signal turn end ──
+    // Finish any streaming text
+    sendUnifyOutput({
+      type: 'assistant',
+      message: { content: [] },
+    });
+    // Send result to clear processing state
+    sendUnifyOutput({
+      type: 'result',
+      result_text: '',
     });
+
   } catch (err) {
     // Don't report abort errors
     if (err.name === 'AbortError') return;
 
     console.error('[Unify] query error:', err.message);
-    sendToServer({
-      type: 'unify_output',
-      event: { type: 'error', message: err.message || 'Session error' },
+    sendUnifyOutput({
+      type: 'assistant',
+      message: {
+        content: [{
+          type: 'text',
+          text: `⚠️ Session error: ${err.message}`,
+        }],
+      },
+    });
+    // Still send result to clear processing state
+    sendUnifyOutput({
+      type: 'result',
+      result_text: '',
     });
   } finally {
     currentAbort = null;
   }
 }
+
+/**
+ * Handle mode switch from the web UI.
+ * @param {{ mode: 'chat' | 'work' }} msg
+ */
+export function handleUnifyModeSwitch(msg) {
+  if (msg.mode === 'chat' || msg.mode === 'work') {
+    currentMode = msg.mode;
+  }
+}
+
+/**
+ * Reset Unify session (for clear messages).
+ */
+export async function resetUnifySession() {
+  if (currentAbort) {
+    currentAbort.abort();
+    currentAbort = null;
+  }
+  if (session) {
+    await session.shutdown();
+    session = null;
+  }
+  unifyConversationId = null;
+  currentMode = 'chat';
+}