@yeaft/webchat-agent 0.1.896 → 0.1.897

package/claude.js

@@ -4,15 +4,18 @@ import { query, Stream } from './sdk/index.js';
 import ctx from './context.js';
 import { sendConversationList, sendOutput, sendError, handleAskUserQuestion } from './conversation.js';
 import { startSubagentWatcher, stopSubagentWatcher, cleanupSubagentWatchers } from './subagent.js';
+import { SYNTHETIC_TOOL_NAMES } from './synthetic-tools.js';
 
 /**
  * Detect whether a user message is a Claude Code compact summary.
- * These appear after context compaction and should not be displayed in the UI.
+ * These appear after context compaction and should not be displayed as a
+ * normal user bubble — they're surfaced as a synthetic __CompactSummary
+ * tool action instead.
  *
  * @param {string} text — user message content
  * @returns {boolean}
  */
-function isCompactSummary(text) {
+export function isCompactSummary(text) {
   if (!text || text.length < 200) return false;
   // Claude Code compact summary always starts with this exact text
   if (text.includes('This session is being continued from a previous conversation')) return true;
@@ -23,6 +26,105 @@ function isCompactSummary(text) {
   return false;
 }
 
+/**
+ * Parse a Claude Code background-task notification.
+ * Claude CLI injects these as fake user messages after an Agent/Task tool
+ * finishes, e.g.:
+ *
+ *   <task-notification>
+ *     <task-id>...</task-id>
+ *     <tool-use-id>...</tool-use-id>
+ *     <output-file>...</output-file>
+ *     <status>completed</status>
+ *     <summary>...one-liner...</summary>
+ *     <result>...full text...</result>
+ *   </task-notification>
+ *
+ * We surface them as a synthetic __SubagentResult tool action so the UI
+ * doesn't render them as a giant user bubble.
+ *
+ * Returns null on degenerate input (no closing tag, every interesting field
+ * empty) so the caller falls through and the malformed text is at least
+ * visible somewhere debuggable rather than emitting a content-less ToolLine.
+ *
+ * @param {string} text
+ * @returns {{ taskId: string, toolUseId: string, outputFile: string, status: string, summary: string, result: string } | null}
+ */
+export function parseTaskNotification(text) {
+  if (typeof text !== 'string') return null;
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith('<task-notification>')) return null;
+  // Greedy match — picks the LAST closing tag, so nested
+  // <task-notification> mentions inside <result> survive intact.
+  const pick = (tag) => {
+    const m = text.match(new RegExp(`<${tag}>([\\s\\S]*)<\\/${tag}>`));
+    return m ? m[1].trim() : '';
+  };
+  const parsed = {
+    taskId: pick('task-id'),
+    toolUseId: pick('tool-use-id'),
+    outputFile: pick('output-file'),
+    status: pick('status'),
+    summary: pick('summary'),
+    result: pick('result'),
+  };
+  // Degenerate notification (truncated stream, no closing tag, etc.) —
+  // every field that would carry meaning is empty. Decline to rewrite.
+  if (!parsed.status && !parsed.summary && !parsed.result) return null;
+  return parsed;
+}
+
+/**
+ * Extract a plain-text view of a Claude SDK message's content.
+ * The SDK is inconsistent about where the content lives and whether it's a
+ * string or an array of {type, text} blocks; this helper papers over all
+ * four observed shapes so callers can work with a single string.
+ *
+ * @param {object} message
+ * @returns {string}
+ */
+export function extractUserText(message) {
+  if (!message) return '';
+  const candidates = [message.content, message.message?.content];
+  for (const c of candidates) {
+    if (typeof c === 'string') return c;
+    if (Array.isArray(c)) {
+      return c
+        .map(b => (b && typeof b === 'object' && typeof b.text === 'string') ? b.text : '')
+        .join('');
+    }
+  }
+  return '';
+}
+
+/**
+ * Build a synthetic assistant.tool_use wire message that reuses the existing
+ * tool-action persistence and rendering pipeline (`agent-output.js` stores
+ * tool_use blocks as DB rows with message_type='tool_use'; the web ToolLine
+ * component renders them with collapse/expand).
+ *
+ * The `synthetic-` id prefix is intentional — any log scraper or debugger
+ * can tell synthetic blocks apart from real tool_use blocks (real
+ * Anthropic IDs look like `toolu_01ABC...`).
+ *
+ * @param {string} name  — synthetic tool name (one of SYNTHETIC_TOOL_NAMES)
+ * @param {object} input — toolInput payload
+ * @returns {object} a Claude SDK assistant-shaped message
+ */
+export function buildSyntheticToolUseMessage(name, input) {
+  return {
+    type: 'assistant',
+    message: {
+      content: [{
+        type: 'tool_use',
+        id: `synthetic-${name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        name,
+        input,
+      }],
+    },
+  };
+}
+
 /**
  * Determine maxContextTokens and autoCompactThreshold from model name.
  * Returns defaults suitable for the model's context window size.
@@ -393,6 +495,9 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
         if (message.subtype === 'compact_boundary') {
           state._compacting = false;
           state._compactSummaryPending = true;
+          // Reset content-fallback de-dup so the second compaction in a
+          // long-running session still broadcasts "completed".
+          state._compactCompleteSent = false;
           console.log(`[${conversationId}] Compact completed (boundary)`);
           ctx.sendToServer({
             type: 'compact_status',
@@ -415,6 +520,7 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
         if (message.subtype === 'compact_complete' || message.subtype === 'compact_end') {
           state._compacting = false;
           state._compactSummaryPending = true;
+          state._compactCompleteSent = false;
           console.log(`[${conversationId}] Compact completed`);
           ctx.sendToServer({
             type: 'compact_status',
@@ -443,25 +549,52 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
         continue;
       }
 
-      // 过滤 compact summary 消息（compact_boundary 之后的 user 消息）
-      if (message.type === 'user' && state._compactSummaryPending) {
-        console.log(`[${conversationId}] Filtering compact summary message (pending flag)`);
-        continue;
-      }
-      // compact 后的 <local-command-stdout>Compacted </local-command-stdout> 标记 summary 结束
-      if (state._compactSummaryPending && message.type !== 'user') {
-        state._compactSummaryPending = false;
-      }
-
-      // 兜底过滤: Claude Code 的 compact summary 有时不触发 compact_boundary,
-      // 直接以 user 消息形式出现。通过内容特征检测过滤。
+      // Recognise the two classes of "fake user messages" Claude Code injects
+      // back into the main conversation, and re-emit them as synthetic
+      // assistant.tool_use blocks so they reuse the standard ToolLine
+      // collapse/expand pipeline instead of showing as giant user bubbles.
+      //
+      //   1. <task-notification>...</task-notification> — emitted when a
+      //      background Task (Agent tool) finishes. Surfaced as
+      //      __SubagentResult.
+      //   2. Compact summaries — emitted after context compaction. Surfaced
+      //      as __CompactSummary. Two detection paths: the compact_boundary
+      //      flag (set by the system message handler above) and a content
+      //      fallback for sessions where Claude Code skips the boundary.
       if (message.type === 'user') {
-        const userText = typeof message.content === 'string'
-          ? message.content
-          : (Array.isArray(message.content) ? message.content.map(b => b.text || '').join('') : '');
+        const userText = extractUserText(message);
+
+        // 1. <task-notification> from a completed background Agent/Task.
+        const parsedTask = parseTaskNotification(userText);
+        if (parsedTask) {
+          console.log(`[${conversationId}] Rewriting <task-notification> as __SubagentResult tool action (task=${parsedTask.taskId})`);
+          sendOutput(conversationId, buildSyntheticToolUseMessage(SYNTHETIC_TOOL_NAMES.SUBAGENT_RESULT, parsedTask));
+          continue;
+        }
+
+        // 2a. Compact summary tagged by an earlier compact_boundary system
+        // event AND matching the compact-summary content shape. Both signals
+        // required — the boundary flag alone is not enough to safely
+        // re-classify a user message, because the SDK can interleave other
+        // user-shaped messages (tool_result, slash-command metadata, even a
+        // genuine user keystroke caught mid-turn) right after the boundary.
+        // Without the content sniff we'd silently stuff that text into the
+        // synthetic summary field and lose it.
+        if (state._compactSummaryPending) {
+          if (userText && isCompactSummary(userText)) {
+            console.log(`[${conversationId}] Rewriting compact summary (pending flag + content) as __CompactSummary tool action`);
+            state._compactSummaryPending = false;
+            sendOutput(conversationId, buildSyntheticToolUseMessage(SYNTHETIC_TOOL_NAMES.COMPACT_SUMMARY, { summary: userText }));
+            continue;
+          }
+          // Pending flag set but the user message doesn't look like a compact
+          // summary — clear the flag (we missed the window) and fall through.
+          state._compactSummaryPending = false;
+        }
+
+        // 2b. Compact summary content fallback (no boundary event was emitted).
         if (userText && isCompactSummary(userText)) {
-          console.log(`[${conversationId}] Filtering compact summary message (content match)`);
-          // 补发 compact 完成通知（如果之前没发过）
+          console.log(`[${conversationId}] Rewriting compact summary (content match) as __CompactSummary tool action`);
           if (!state._compactCompleteSent) {
             state._compactCompleteSent = true;
             ctx.sendToServer({
@@ -471,9 +604,18 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
               message: 'Context compacted successfully'
             });
           }
+          sendOutput(conversationId, buildSyntheticToolUseMessage(SYNTHETIC_TOOL_NAMES.COMPACT_SUMMARY, { summary: userText }));
           continue;
         }
       }
+      // The compact-summary-pending flag was previously cleared by the first
+      // non-user message after the boundary. Now we clear it the moment we
+      // consume the user message above, so anything else that arrives is
+      // treated normally. Keep this defensive clear in case the SDK emits a
+      // non-user message before the summary user message lands.
+      if (state._compactSummaryPending && message.type !== 'user') {
+        state._compactSummaryPending = false;
+      }
 
       // 捕获 result 消息中的 usage 信息
       if (message.type === 'result') {

package/package.json

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

package/synthetic-tools.js

@@ -0,0 +1,41 @@
+/**
+ * Synthetic tool names — single source of truth for Claude Chat's
+ * "fake user message" rewrites.
+ *
+ * Claude CLI injects two classes of system-generated user messages back into
+ * the main conversation:
+ *
+ *   1. <task-notification>...</task-notification> — emitted when a background
+ *      Agent/Task tool finishes. Rewritten by `agent/claude.js` into a
+ *      synthetic assistant.tool_use block with `name = SUBAGENT_RESULT`.
+ *
+ *   2. Compact summaries ("This session is being continued from a previous
+ *      conversation...") — emitted after context compaction. Rewritten with
+ *      `name = COMPACT_SUMMARY`.
+ *
+ * These names are persisted verbatim into SQLite's `messages.tool_name`
+ * column (see `server/handlers/agent-output.js` tool_use branch) and
+ * matched verbatim by `web/components/ToolLine.js` to pick the icon and
+ * one-line label. They are de-facto schema — renaming requires a DB
+ * migration for old rows, so don't rename without one.
+ *
+ * The `__` prefix is reserved for synthetic / project-internal tool names.
+ * Real Claude SDK tools and MCP tools must not use this prefix; if a future
+ * tool registry ever needs to enforce this, do it there. Today the
+ * convention is documented + relied upon by name collision being absent in
+ * practice.
+ */
+
+export const SYNTHETIC_TOOL_NAMES = Object.freeze({
+  SUBAGENT_RESULT: '__SubagentResult',
+  COMPACT_SUMMARY: '__CompactSummary',
+});
+
+export const SYNTHETIC_TOOL_PREFIX = '__';
+
+/** True when `name` is one of the project's synthetic tool sentinels. */
+export function isSyntheticToolName(name) {
+  if (typeof name !== 'string') return false;
+  return name === SYNTHETIC_TOOL_NAMES.SUBAGENT_RESULT
+      || name === SYNTHETIC_TOOL_NAMES.COMPACT_SUMMARY;
+}