@yeaft/webchat-agent 1.0.50 → 1.0.51

package/history.js

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync, fstatSync } from 'fs';
 import { join } from 'path';
 import ctx from './context.js';
+import { normalizeClaudeMessage } from './sdk/message-normalize.js';
 import { getProvider, DEFAULT_PROVIDER } from './providers/index.js';
 
 // Claude 项目目录
@@ -227,7 +228,7 @@ function readTailMessages(filePath, limit) {
         const line = lines[i];
         if (!line || !line.trim()) continue;
         try {
-          const data = JSON.parse(line);
+          const data = normalizeClaudeMessage(JSON.parse(line));
           if (data.type === 'user' || data.type === 'assistant') {
             collected.push(data);
             if (collected.length >= limit) break;
@@ -241,7 +242,7 @@ function readTailMessages(filePath, limit) {
       const headLine = carry.toString('utf-8').trim();
       if (headLine) {
         try {
-          const data = JSON.parse(headLine);
+          const data = normalizeClaudeMessage(JSON.parse(headLine));
           if (data.type === 'user' || data.type === 'assistant') {
             collected.push(data);
           }
@@ -287,7 +288,7 @@ export function loadSessionHistory(workDir, claudeSessionId, limit = 500) {
 
     for (const line of lines) {
       try {
-        const data = JSON.parse(line);
+        const data = normalizeClaudeMessage(JSON.parse(line));
         if (data.type === 'user' || data.type === 'assistant') {
           messages.push(data);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.50",
+  "version": "1.0.51",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/sdk/message-normalize.js

@@ -0,0 +1,129 @@
+const TOOL_LIKE_BLOCK_TYPES = new Set([
+  'tool_use',
+  'tool_call',
+  'function_call',
+  'server_tool_use',
+  'call',
+]);
+
+/**
+ * Claude Code stream-json has changed its tool-call block spelling more than
+ * once. Normalize every known tool-like assistant content block to the
+ * Anthropic-compatible `tool_use` shape used by the rest of the app.
+ *
+ * @param {unknown} block
+ * @returns {unknown}
+ */
+export function normalizeAssistantContentBlock(block) {
+  if (!block || typeof block !== 'object') return block;
+  if (block.type === 'tool_use') return block;
+  if (!TOOL_LIKE_BLOCK_TYPES.has(block.type)) return block;
+
+  const input = normalizeToolInput(block);
+  const name = block.name
+    || block.tool_name
+    || block.toolName
+    || block.function?.name
+    || block.action?.name
+    || input?.name
+    || 'tool';
+  const id = block.id
+    || block.tool_use_id
+    || block.toolUseId
+    || block.tool_call_id
+    || block.toolCallId
+    || block.call_id
+    || block.callId
+    || stableFallbackToolId(name, block);
+
+  return {
+    type: 'tool_use',
+    id,
+    name,
+    input,
+  };
+}
+
+/**
+ * @param {unknown} content
+ * @returns {unknown}
+ */
+export function normalizeAssistantContent(content) {
+  if (!Array.isArray(content)) return content;
+  return content.map(normalizeAssistantContentBlock);
+}
+
+/**
+ * @param {unknown} message
+ * @returns {unknown}
+ */
+export function normalizeClaudeMessage(message) {
+  if (!message || typeof message !== 'object') return message;
+  if (message.type !== 'assistant' || !message.message) return message;
+  const content = message.message.content;
+  const normalized = normalizeAssistantContent(content);
+  if (normalized === content) return message;
+  return {
+    ...message,
+    message: {
+      ...message.message,
+      content: normalized,
+    },
+  };
+}
+
+/**
+ * Stream events should only emit text deltas from actual text blocks. Newer
+ * Claude Code builds may emit text-looking deltas while a tool-call block is
+ * being assembled (`call`, transient id, JSON argument text). Those bytes are
+ * transport detail, not assistant prose; the final complete assistant message
+ * carries the real tool_use block.
+ *
+ * @param {string|undefined|null} blockType
+ * @returns {boolean}
+ */
+export function shouldForwardTextDeltaForBlockType(blockType) {
+  if (!blockType) return true; // Back-compat for older CLIs without start events.
+  return blockType === 'text';
+}
+
+function stableFallbackToolId(name, block) {
+  const raw = stableStringify(block);
+  let hash = 2166136261;
+  for (let i = 0; i < raw.length; i++) {
+    hash ^= raw.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `${name}-${hash.toString(36)}`;
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function normalizeToolInput(block) {
+  const raw = block.input
+    ?? block.arguments
+    ?? block.args
+    ?? block.parameters
+    ?? block.function?.arguments
+    ?? block.action?.arguments
+    ?? {};
+
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (!trimmed) return {};
+    try {
+      const parsed = JSON.parse(trimmed);
+      return parsed && typeof parsed === 'object' ? parsed : { value: parsed };
+    } catch {
+      return { arguments: raw };
+    }
+  }
+  if (raw && typeof raw === 'object') return raw;
+  return {};
+}

package/sdk/query.js

@@ -7,6 +7,7 @@ import { spawn } from 'child_process';
 import { createInterface } from 'readline';
 import { Stream } from './stream.js';
 import { AbortError } from './types.js';
+import { normalizeClaudeMessage, shouldForwardTextDeltaForBlockType } from './message-normalize.js';
 import { getCleanEnv, logDebug, streamToStdin, resolveClaudeCommand } from './utils.js';
 
 
@@ -82,6 +83,7 @@ export class Query {
     // Track whether we've forwarded text deltas for the current assistant turn.
     // When true, the next complete `assistant` message's text blocks are redundant.
     let hasStreamedTextDeltas = false;
+    const streamBlockTypes = new Map();
 
     try {
       for await (const line of rl) {
@@ -114,36 +116,52 @@ export class Query {
               const event = message.event;
               if (!event) continue;
 
-              // content_block_delta with text_delta → convert to assistant message for streaming
+              if (event.type === 'content_block_start') {
+                streamBlockTypes.set(event.index, event.content_block?.type || null);
+                continue;
+              }
+              if (event.type === 'content_block_stop') {
+                streamBlockTypes.delete(event.index);
+                continue;
+              }
+              // content_block_delta with text_delta → convert to assistant message for streaming,
+              // but only while the active block is actually text. Some Claude Code builds
+              // expose tool-call assembly as text-looking deltas; forwarding those leaks
+              // raw `call`, transient ids, and JSON arguments into the chat transcript.
               if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && event.delta.text) {
-                hasStreamedTextDeltas = true;
-                this.inputStream.enqueue({
-                  type: 'assistant',
-                  message: {
-                    role: 'assistant',
-                    content: [{ type: 'text', text: event.delta.text }]
-                  }
-                });
+                const blockType = streamBlockTypes.get(event.index);
+                if (shouldForwardTextDeltaForBlockType(blockType)) {
+                  hasStreamedTextDeltas = true;
+                  this.inputStream.enqueue({
+                    type: 'assistant',
+                    message: {
+                      role: 'assistant',
+                      content: [{ type: 'text', text: event.delta.text }]
+                    }
+                  });
+                }
               }
-              // All other stream events (message_start, content_block_start,
-              // input_json_delta, content_block_stop, message_stop) are ignored.
-              // tool_use is handled via the complete assistant message.
+              // All other stream events (message_start, input_json_delta,
+              // message_stop) are ignored. Tool use is handled via the complete
+              // assistant message after block normalization below.
               continue;
             }
 
+            const normalizedMessage = normalizeClaudeMessage(message);
+
             // Deduplicate: when a complete assistant message arrives after we've
             // already streamed text deltas, strip the text blocks (already sent).
             // Keep tool_use blocks which are NOT sent incrementally.
-            if (message.type === 'assistant' && hasStreamedTextDeltas) {
+            if (normalizedMessage.type === 'assistant' && hasStreamedTextDeltas) {
               hasStreamedTextDeltas = false; // Reset for next assistant turn
 
-              const content = message.message?.content;
+              const content = normalizedMessage.message?.content;
               if (Array.isArray(content)) {
                 const nonTextBlocks = content.filter(b => b.type !== 'text');
                 if (nonTextBlocks.length > 0) {
                   // Forward only tool_use blocks (text already sent via deltas)
-                  message.message.content = nonTextBlocks;
-                  this.inputStream.enqueue(message);
+                  normalizedMessage.message.content = nonTextBlocks;
+                  this.inputStream.enqueue(normalizedMessage);
                 } else {
                   // Pure text message fully streamed — send finish-streaming signal
                   // so frontend clears isStreaming and typing dots can reappear
@@ -165,11 +183,12 @@ export class Query {
 
             // Reset delta tracking on non-assistant messages
             // (e.g., user, result, system — a new turn boundary)
-            if (message.type !== 'assistant') {
+            if (normalizedMessage.type !== 'assistant') {
               hasStreamedTextDeltas = false;
+              streamBlockTypes.clear();
             }
 
-            this.inputStream.enqueue(message);
+            this.inputStream.enqueue(normalizedMessage);
           } catch (e) {
             logDebug(`Non-JSON line: ${line.substring(0, 100)}`);
           }