@yeaft/webchat-agent 0.1.436 → 0.1.438

package/connection/index.js

@@ -56,7 +56,9 @@ export function connect() {
 
     const msg = await parseMessage(data);
     if (msg) {
-      handleMessage(msg);
+      handleMessage(msg).catch(err => {
+        console.error('[WS] handleMessage error:', err.message || err);
+      });
     }
   });
 

package/connection/message-router.js

@@ -332,5 +332,12 @@ export async function handleMessage(msg) {
     case 'unify_reset':
       await resetUnifySession();
       break;
+
+    // Expert roles definition (for ExpertPanel detail view)
+    case 'get_expert_roles': {
+      const { getExpertRolesDefinition } = await import('../expert-roles.js');
+      sendToServer({ type: 'expert_roles_list', roles: getExpertRolesDefinition() });
+      break;
+    }
   }
 }

package/conversation.js

@@ -719,7 +719,10 @@ export async function handleUserInput(msg) {
 
   // ★ Expert Panel: construct expert message if selections provided
   const expertSelections = msg.expertSelections;
-  if (expertSelections?.length > 0) {
+  if (msg.expertMessage) {
+    // Custom expert role: frontend already built the full prompt
+    effectivePrompt = msg.expertMessage;
+  } else if (expertSelections?.length > 0) {
     const { buildExpertMessage } = await import('./expert-roles.js');
     const expertResult = buildExpertMessage(expertSelections, effectivePrompt, msg.language || 'zh-CN');
     effectivePrompt = expertResult.effectivePrompt;

package/expert-roles.js

@@ -877,4 +877,40 @@ export function buildExpertMessage(selections, userText, language = 'zh-CN') {
   return buildMultiExpertMessage(selections, userText, isZh);
 }
 
+/**
+ * Return the full EXPERT_ROLES definition (including prompt content)
+ * for the web debug/admin panel.
+ *
+ * Format per role:
+ * {
+ *   name, messagePrefix, messagePrefixEn,
+ *   actions: { [actionId]: { name, nameEn, messageTemplate, messageTemplateEn, defaultMessage, defaultMessageEn } }
+ * }
+ *
+ * @returns {Object.<string, object>}
+ */
+export function getExpertRolesDefinition() {
+  const result = {};
+  for (const [roleId, roleDef] of Object.entries(EXPERT_ROLES)) {
+    const actions = {};
+    for (const [actionId, actionDef] of Object.entries(roleDef.actions)) {
+      actions[actionId] = {
+        name: actionDef.name,
+        nameEn: actionDef.nameEn,
+        messageTemplate: actionDef.messageTemplate,
+        messageTemplateEn: actionDef.messageTemplateEn,
+        defaultMessage: actionDef.defaultMessage,
+        defaultMessageEn: actionDef.defaultMessageEn,
+      };
+    }
+    result[roleId] = {
+      name: roleDef.name,
+      messagePrefix: roleDef.messagePrefix,
+      messagePrefixEn: roleDef.messagePrefixEn,
+      actions,
+    };
+  }
+  return result;
+}
+
 export { EXPERT_ROLES };

package/package.json

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

package/unify/web-bridge.js

@@ -23,6 +23,9 @@ let session = null;
 /** @type {AbortController | null} */
 let currentAbort = null;
 
+/** Query timeout in ms — abort if LLM doesn't respond within this window */
+const QUERY_TIMEOUT_MS = 120_000;
+
 /** Virtual conversationId for the Unify session */
 let unifyConversationId = null;
 
@@ -100,12 +103,29 @@ export async function handleUnifyChat(msg) {
 
     currentAbort = new AbortController();
 
+    // ─── Timeout guard: abort query if LLM hangs beyond threshold ──
+    // Resets on every event — fires only after prolonged silence.
+    let queryTimer = null;
+    const resetQueryTimer = () => {
+      if (queryTimer) clearTimeout(queryTimer);
+      queryTimer = setTimeout(() => {
+        if (currentAbort) {
+          console.error(`[Unify] query timeout after ${QUERY_TIMEOUT_MS / 1000}s of silence — aborting`);
+          currentAbort.abort();
+        }
+      }, QUERY_TIMEOUT_MS);
+    };
+    resetQueryTimer();
+
+    try {
     // ─── Stream Engine events → claude_output format ──
     for await (const event of session.engine.query({
       prompt,
       mode: currentMode,
       signal: currentAbort.signal,
     })) {
+      // Reset timeout on every event — activity means the query is alive
+      resetQueryTimer();
       switch (event.type) {
         // ── Text streaming ──
         case 'text_delta':
@@ -261,9 +281,29 @@ export async function handleUnifyChat(msg) {
       result_text: '',
     });
 
+    } finally {
+      // Always clear the timeout guard
+      if (queryTimer) clearTimeout(queryTimer);
+    }
+
   } catch (err) {
-    // Don't report abort errors
-    if (err.name === 'AbortError') return;
+    // Don't report abort errors — but still send result to unblock frontend
+    if (err.name === 'AbortError') {
+      sendUnifyOutput({
+        type: 'assistant',
+        message: {
+          content: [{
+            type: 'text',
+            text: '⚠️ Query timed out — no response from LLM. Please try again.',
+          }],
+        },
+      });
+      sendUnifyOutput({
+        type: 'result',
+        result_text: '',
+      });
+      return;
+    }
 
     console.error('[Unify] query error:', err.message);
     sendUnifyOutput({