@yeaft/webchat-agent 0.1.420 → 0.1.421

package/connection/message-router.js

@@ -25,6 +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';
 
 export async function handleMessage(msg) {
   switch (msg.type) {
@@ -318,5 +319,10 @@ export async function handleMessage(msg) {
       sendToServer({ type: 'llm_config_updated', ...result });
       break;
     }
+
+    // Unify — independent chat via Engine
+    case 'unify_chat':
+      await handleUnifyChat(msg);
+      break;
   }
 }

package/conversation.js

@@ -6,7 +6,6 @@ import { query } from './sdk/index.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
 import { crewSessions, loadCrewIndex } from './crew.js';
-import { handleUnifyInput } from './unify/web-bridge.js';
 
 // 不支持的斜杠命令（真正需要交互式 CLI 的命令）
 const UNSUPPORTED_SLASH_COMMANDS = ['/help', '/bug', '/login', '/logout', '/terminal-setup', '/vim', '/config'];
@@ -294,8 +293,7 @@ export async function sendConversationList() {
       createdAt: state.createdAt,
       processing: !!state.turnActive,
       userId: state.userId,
-      username: state.username,
-      mode: state.mode || null
+      username: state.username
     };
     list.push(entry);
   }
@@ -356,7 +354,7 @@ export function sendError(conversationId, message) {
 
 // 创建新的 conversation (延迟启动 Claude，等待用户发送第一条消息)
 export async function createConversation(msg) {
-  const { conversationId, workDir, userId, username, disallowedTools, mode } = msg;
+  const { conversationId, workDir, userId, username, disallowedTools } = msg;
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
 
   console.log(`Creating conversation: ${conversationId} in ${effectiveWorkDir} (lazy start)`);
@@ -377,7 +375,6 @@ export async function createConversation(msg) {
     userId,
     username,
     disallowedTools: disallowedTools || null,  // null = 使用全局默认
-    mode: mode || 'claude',  // 'claude' (default) or 'unify'
     usage: {
       inputTokens: 0,
       outputTokens: 0,
@@ -393,8 +390,7 @@ export async function createConversation(msg) {
     workDir: effectiveWorkDir,
     userId,
     username,
-    disallowedTools: disallowedTools || null,
-    mode: mode || 'claude'
+    disallowedTools: disallowedTools || null
   });
 
   // 立即发送 agent 级别的 MCP servers 列表（从 ~/.claude.json 读取的）
@@ -417,11 +413,8 @@ export async function createConversation(msg) {
   sendConversationList();
 
   // ★ Prestart Claude CLI in background to eagerly fetch skills/tools/model
-  // Skip prestart for unify mode — it doesn't use Claude CLI
-  if (mode !== 'unify') {
-    // Fire-and-forget: failure just degrades to lazy-start behavior
-    prestartClaude(conversationId, effectiveWorkDir, null);
-  }
+  // Fire-and-forget: failure just degrades to lazy-start behavior
+  prestartClaude(conversationId, effectiveWorkDir, null);
 }
 
 // Resume 历史 conversation (延迟启动 Claude，等待用户发送第一条消息)
@@ -669,12 +662,6 @@ export async function handleCancelExecution(msg) {
 export async function handleUserInput(msg) {
   const { conversationId, prompt, workDir, claudeSessionId } = msg;
 
-  // ★ Unify mode: route to Unify Engine instead of Claude CLI
-  const state = ctx.conversations.get(conversationId);
-  if (state?.mode === 'unify') {
-    return handleUnifyInput(msg);
-  }
-
   // 解析斜杠命令
   const slashCommand = parseSlashCommand(prompt);
 

package/package.json

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

package/unify/web-bridge.js

@@ -1,204 +1,99 @@
 /**
- * web-bridge.js — Bridge between Yeaft Unify Engine and the Web UI
+ * web-bridge.js — Bridge between web UI and Yeaft Unify Engine.
  *
- * Translates Unify Engine streaming events into the sendOutput wire format
- * that the existing web client already understands. This means the UI needs
- * zero rendering changes — Unify conversations look identical to Claude ones.
+ * Handles `unify_chat` messages from the server, runs queries through
+ * the Engine, and streams `unify_output` events back.
  *
- * Architecture: Agent-side only. UI and Server are transparent relays.
- *
- * Lifecycle per conversation:
- *   1. First user message → lazy-load a Unify Session (loadSession)
- *   2. Each user message → engine.query({ prompt }) → stream events → sendOutput
- *   3. On turn complete → send turn_completed so UI exits processing state
+ * The session is lazily initialized on first use and reused across queries.
+ * Engine internally manages conversation history and persistence.
  */
 
-import ctx from '../context.js';
-import { sendOutput, sendConversationList } from '../conversation.js';
 import { loadSession } from './session.js';
+import { sendToServer } from '../connection/buffer.js';
+import ctx from '../context.js';
+
+/** @type {import('./session.js').Session | null} */
+let session = null;
+
+/** @type {AbortController | null} */
+let currentAbort = null;
 
 /**
- * Handle a user message for a Unify-mode conversation.
+ * Handle a unify_chat message from the web UI.
  *
- * Called from conversation.js handleUserInput() when state.mode === 'unify'.
- * Reuses the same sendOutput() wire format as Claude conversations so the
- * web client renders messages identically.
- *
- * @param {{ conversationId: string, prompt: string }} msg
+ * @param {{ prompt: string, userId?: string, username?: string }} msg
  */
-export async function handleUnifyInput(msg) {
-  const { conversationId, prompt } = msg;
-  const state = ctx.conversations.get(conversationId);
-
-  if (!state) {
-    console.error(`[Unify] No conversation state for ${conversationId}`);
-    return;
-  }
+export async function handleUnifyChat(msg) {
+  const { prompt } = msg;
+  if (!prompt?.trim()) return;
 
-  // ─── Lazy-init Unify Session ──────────────────────────────
-  if (!state._unifySession) {
-    try {
-      console.log(`[Unify] Loading session for ${conversationId}...`);
-      state._unifySession = await loadSession({
+  try {
+    // 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,
       });
-      state._unifyMessages = [];
-      console.log(`[Unify] Session loaded for ${conversationId} (model: ${state._unifySession.config.model})`);
-    } catch (err) {
-      console.error(`[Unify] Failed to load session for ${conversationId}:`, err);
-      sendOutput(conversationId, {
-        type: 'assistant',
-        message: {
-          role: 'assistant',
-          content: [{
-            type: 'text',
-            text: `Unify session initialization failed: ${err.message}`
-          }]
-        }
-      });
-      ctx.sendToServer({
-        type: 'turn_completed',
-        conversationId,
-        workDir: state.workDir
+
+      // Send model info to UI so the badge updates
+      sendToServer({
+        type: 'unify_output',
+        event: { type: 'model_info', model: session.config.model },
       });
-      return;
     }
-  }
-
-  const session = state._unifySession;
 
-  // ─── Send user message to UI ──────────────────────────────
-  sendOutput(conversationId, {
-    type: 'user',
-    message: {
-      role: 'user',
-      content: prompt
+    // Cancel any in-flight query
+    if (currentAbort) {
+      currentAbort.abort();
+      currentAbort = null;
     }
-  });
 
-  // Track messages for multi-turn context
-  state._unifyMessages.push({ role: 'user', content: prompt });
+    currentAbort = new AbortController();
 
-  // ─── Run Engine query and stream back ─────────────────────
-  let fullText = '';
-  let hasError = false;
-
-  try {
-    for await (const event of session.engine.query({
-      prompt,
-      messages: state._unifyMessages.slice(0, -1), // pass history (excluding current prompt which engine adds)
-    })) {
+    // Stream query events → unify_output messages
+    for await (const event of session.engine.query({ prompt, signal: currentAbort.signal })) {
       switch (event.type) {
         case 'text_delta':
-          fullText += event.text;
-          sendOutput(conversationId, {
-            type: 'assistant',
-            message: {
-              role: 'assistant',
-              content: [{
-                type: 'text',
-                text: event.text
-              }]
-            },
-            subtype: 'text_delta'
-          });
-          break;
-
-        case 'tool_call':
-          sendOutput(conversationId, {
-            type: 'assistant',
-            message: {
-              role: 'assistant',
-              content: [{
-                type: 'tool_use',
-                id: event.id,
-                name: event.name,
-                input: event.input
-              }]
-            }
-          });
-          break;
-
-        case 'tool_result':
-          sendOutput(conversationId, {
-            type: 'assistant',
-            message: {
-              role: 'tool',
-              tool_use_id: event.toolCallId,
-              content: typeof event.result === 'string'
-                ? event.result
-                : JSON.stringify(event.result)
-            }
+          sendToServer({
+            type: 'unify_output',
+            event: { type: 'text_delta', text: event.text },
           });
           break;
 
-        case 'usage':
-          // Update conversation usage tracking
-          if (state.usage) {
-            state.usage.inputTokens += event.inputTokens || 0;
-            state.usage.outputTokens += event.outputTokens || 0;
-          }
-          break;
-
         case 'error':
-          hasError = true;
-          sendOutput(conversationId, {
-            type: 'assistant',
-            message: {
-              role: 'assistant',
-              content: [{
-                type: 'text',
-                text: `Error: ${event.error?.message || 'Unknown error'}`
-              }]
-            }
+          sendToServer({
+            type: 'unify_output',
+            event: {
+              type: 'error',
+              message: event.error?.message || 'Unknown error',
+            },
           });
           break;
 
-        case 'stop':
-        case 'turn_start':
-        case 'turn_end':
-        case 'recall':
-        case 'consolidate':
-        case 'fallback':
-        case 'thinking_delta':
-          // These are engine-internal events; no UI action needed
+        // Silently consume other events (tool_call, thinking_delta, usage, etc.)
+        // These can be surfaced later as the Unify UI grows.
+        default:
           break;
       }
     }
-  } catch (err) {
-    hasError = true;
-    console.error(`[Unify] Query error for ${conversationId}:`, err);
-    sendOutput(conversationId, {
-      type: 'assistant',
-      message: {
-        role: 'assistant',
-        content: [{
-          type: 'text',
-          text: `Unify query error: ${err.message}`
-        }]
-      }
+
+    // Signal completion
+    sendToServer({
+      type: 'unify_output',
+      event: { type: 'done' },
     });
-  }
+  } catch (err) {
+    // Don't report abort errors
+    if (err.name === 'AbortError') return;
 
-  // ─── Track assistant response for multi-turn ──────────────
-  if (fullText) {
-    state._unifyMessages.push({ role: 'assistant', content: fullText });
+    console.error('[Unify] query error:', err.message);
+    sendToServer({
+      type: 'unify_output',
+      event: { type: 'error', message: err.message || 'Session error' },
+    });
+  } finally {
+    currentAbort = null;
   }
-
-  // ─── Send result + turn_completed ─────────────────────────
-  // Emit a result message to match Claude's wire format (UI uses this for state management)
-  sendOutput(conversationId, {
-    type: 'result',
-    subtype: hasError ? 'error' : 'success',
-    result_text: fullText
-  });
-
-  ctx.sendToServer({
-    type: 'turn_completed',
-    conversationId,
-    workDir: state.workDir
-  });
-
-  sendConversationList();
 }