@kafca/agentdock 0.1.28 → 0.1.30

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-store.js

@@ -41,6 +41,8 @@ class LocalCoreAcpStore {
         role TEXT NOT NULL,
         content TEXT NOT NULL,
         tool_call_json TEXT,
+        bridge_kind TEXT,
+        bridge_status TEXT,
         timestamp TEXT NOT NULL,
         kind TEXT NOT NULL,
         seq INTEGER NOT NULL,
@@ -222,6 +224,8 @@ class LocalCoreAcpStore {
       CREATE INDEX IF NOT EXISTS idx_audit_events_type_created ON audit_events (type, created_at DESC);
     `);
         this.ensureColumn('messages', 'tool_call_json', 'TEXT');
+        this.ensureColumn('messages', 'bridge_kind', 'TEXT');
+        this.ensureColumn('messages', 'bridge_status', 'TEXT');
         this.ensureColumn('scheduled_jobs', 'execution_mode', "TEXT NOT NULL DEFAULT 'same-thread'");
         this.ensureColumn('threads', 'agent_mode', "TEXT NOT NULL DEFAULT 'default'");
     }
@@ -284,7 +288,7 @@ class LocalCoreAcpStore {
             throw new Error(`Thread not found: ${threadId}`);
         }
         const messages = this.db.prepare(`
-      SELECT id, thread_id, role, content, tool_call_json, timestamp, kind, seq
+      SELECT id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq
       FROM messages
       WHERE thread_id = ?
       ORDER BY seq ASC
@@ -305,6 +309,8 @@ class LocalCoreAcpStore {
                 role: message.role,
                 content: message.content,
                 toolCall: parseJson(message.tool_call_json || 'null', null) || undefined,
+                bridgeKind: normalizeBridgeKind(message.bridge_kind),
+                bridgeStatus: normalizeBridgeStatus(message.bridge_status),
                 timestamp: message.timestamp,
                 kind: message.kind,
             })),
@@ -319,7 +325,7 @@ class LocalCoreAcpStore {
     deleteThread(threadId) {
         this.db.prepare('DELETE FROM threads WHERE id = ?').run(threadId);
     }
-    appendMessage(threadId, role, content, kind, toolCall) {
+    appendMessage(threadId, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
         const timestamp = new Date().toISOString();
         const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
         const nextSeq = Number(nextSequenceRow?.next_seq || 0);
@@ -328,9 +334,9 @@ class LocalCoreAcpStore {
         this.db.exec('BEGIN IMMEDIATE');
         try {
             this.db.prepare(`
-        INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
+        INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
             this.db.prepare(`
         UPDATE threads
         SET updated_at = ?, history_count = history_count + 1, excerpt = ?
@@ -344,7 +350,7 @@ class LocalCoreAcpStore {
         }
         return { id, timestamp };
     }
-    upsertMessage(threadId, id, role, content, kind, toolCall) {
+    upsertMessage(threadId, id, role, content, kind, toolCall, bridgeKind, bridgeStatus) {
         const timestamp = new Date().toISOString();
         const excerpt = (0, workspace_thread_mappers_js_1.normalizeMessageContent)(content);
         const existing = this.db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(id, threadId);
@@ -353,17 +359,17 @@ class LocalCoreAcpStore {
             if (existing) {
                 this.db.prepare(`
           UPDATE messages
-          SET content = ?, tool_call_json = ?, timestamp = ?, kind = ?
+          SET content = ?, tool_call_json = ?, bridge_kind = ?, bridge_status = ?, timestamp = ?, kind = ?
           WHERE id = ? AND thread_id = ?
-        `).run(content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, id, threadId);
+        `).run(content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, id, threadId);
             }
             else {
                 const nextSequenceRow = this.db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS next_seq FROM messages WHERE thread_id = ?').get(threadId);
                 const nextSeq = Number(nextSequenceRow?.next_seq || 0);
                 this.db.prepare(`
-          INSERT INTO messages (id, thread_id, role, content, tool_call_json, timestamp, kind, seq)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, timestamp, kind, nextSeq);
+          INSERT INTO messages (id, thread_id, role, content, tool_call_json, bridge_kind, bridge_status, timestamp, kind, seq)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, threadId, role, content, toolCall ? JSON.stringify(toolCall) : null, bridgeKind || null, bridgeStatus || null, timestamp, kind, nextSeq);
                 this.db.prepare(`
           UPDATE threads
           SET history_count = history_count + 1
@@ -830,6 +836,9 @@ class LocalCoreAcpStore {
         return row ? this.toScheduledJob(row) : undefined;
     }
     createScheduledJob(input) {
+        if (!input.platform || !input.route) {
+            throw new Error('Scheduled job creation requires a resolved platform and route.');
+        }
         let id = (0, job_id_js_1.createScheduledJobId)();
         for (let attempt = 0; attempt < 5 && this.getScheduledJob(id); attempt += 1) {
             id = (0, job_id_js_1.createScheduledJobId)();
@@ -1301,6 +1310,22 @@ function parseJson(value, fallback) {
         return fallback;
     }
 }
+function normalizeBridgeKind(value) {
+    switch (value) {
+        case 'assistant':
+        case 'thought':
+        case 'plan':
+        case 'tool':
+        case 'status':
+        case 'permission':
+            return value;
+        default:
+            return undefined;
+    }
+}
+function normalizeBridgeStatus(value) {
+    return value === 'awaiting_input' ? value : undefined;
+}
 function defaultPermissions() {
     return {
         'workspace.read': 'allow',

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-transport.js

@@ -35,9 +35,11 @@ class LocalCoreAcpTransport {
             loadReplayMode: false,
             pendingPermissionByRun: new Map(),
             schedulerJobCreatedByRun: new Map(),
+            pendingRawAssistantProgressChunks: [],
             closed: false,
             closeReason: null,
             promptPromise: null,
+            launchPermissionMode: '',
         };
         child.stdout.setEncoding('utf8');
         child.stdout.on('data', (chunk) => this.handleStdout(session, chunk));

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js

@@ -11,6 +11,11 @@ class LocalCoreAcpTurnCoordinator {
     constructor(options) {
         this.options = options;
     }
+    closePendingThoughtSegment(session) {
+        const currentTurn = session.currentTurn;
+        if (currentTurn)
+            (0, local_core_acp_progress_js_1.closeThoughtSegment)(currentTurn);
+    }
     flushPendingToolCall(session) {
         const currentTurn = session.currentTurn;
         const currentRunId = session.currentRunId;
@@ -97,6 +102,7 @@ class LocalCoreAcpTurnCoordinator {
         }
         const options = (0, local_core_acp_permission_lifecycle_js_1.parsePermissionOptions)(payload.params?.options);
         const toolTitle = (0, workspace_acp_permissions_js_1.formatToolCallContent)(payload.params?.toolCall);
+        this.closePendingThoughtSegment(session);
         if ((this.options.getThreadAgentMode?.(session.threadId) || local_core_slash_commands_js_1.DEFAULT_AGENT_MODE) === 'bypassPermissions') {
             const selected = options.find((option) => option.normalizedAction === 'allow all')
                 || options.find((option) => option.normalizedAction === 'allow')
@@ -160,17 +166,26 @@ class LocalCoreAcpTurnCoordinator {
         });
         this.options.updateRunStatus(currentRunId, session.threadId, 'awaiting_input');
         const permissionPrompt = (0, local_core_acp_permission_lifecycle_js_1.createPermissionPrompt)(toolTitle);
-        this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress');
+        this.options.appendMessage(session.threadId, 'assistant', permissionPrompt, 'progress', undefined, 'permission', 'awaiting_input');
         this.options.emitBridge({
             type: 'buttons',
             sessionKey: session.bridgeSessionKey,
             replyCtx: currentRunId,
+            bridgeKind: 'permission',
+            bridgeStatus: 'awaiting_input',
             content: permissionPrompt,
             buttonRows,
         });
     }
     handleAgentNotification(session, payload) {
-        if (session.loadReplayMode || payload.method !== 'session/update') {
+        if (session.loadReplayMode) {
+            return;
+        }
+        if (payload.method === '_claude/sdkMessage') {
+            this.handleClaudeSdkMessage(session, payload.params?.message);
+            return;
+        }
+        if (payload.method !== 'session/update') {
             return;
         }
         const update = payload.params?.update;
@@ -181,10 +196,25 @@ class LocalCoreAcpTurnCoordinator {
         }
         switch (String(update.sessionUpdate || '')) {
             case 'agent_message_chunk': {
+                this.closePendingThoughtSegment(session);
                 this.flushPendingToolCall(session);
                 if (update.content?.type !== 'text') {
                     return;
                 }
+                if (isToolScopedAssistantUpdate(update) || consumeRawAssistantProgressChunk(session, String(update.content.text || ''))) {
+                    const content = String(update.content.text || '').trim();
+                    if (content) {
+                        this.options.appendMessage(session.threadId, 'assistant', content, 'progress', undefined, 'tool');
+                        this.options.emitBridge({
+                            type: 'reply',
+                            sessionKey: session.bridgeSessionKey,
+                            replyCtx: currentRunId,
+                            bridgeKind: 'tool',
+                            content,
+                        });
+                    }
+                    return;
+                }
                 const projection = (0, local_core_acp_progress_js_1.applyAssistantMessageChunk)(currentTurn, String(update.content.text || ''));
                 if (!projection) {
                     return;
@@ -194,12 +224,12 @@ class LocalCoreAcpTurnCoordinator {
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
                     previewHandle: projection.previewHandle,
+                    bridgeKind: projection.bridgeKind,
                     content: projection.content,
                 });
                 return;
             }
             case 'agent_thought_chunk': {
-                this.flushPendingToolCall(session);
                 if (update.content?.type !== 'text') {
                     return;
                 }
@@ -208,23 +238,31 @@ class LocalCoreAcpTurnCoordinator {
                     return;
                 }
                 if (this.options.upsertMessage) {
-                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress');
+                    this.options.upsertMessage(session.threadId, projection.messageId, 'assistant', projection.content, 'progress', undefined, projection.bridgeKind);
                 }
                 this.options.emitBridge({
                     type: projection.bridgeType,
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
                     previewHandle: projection.previewHandle,
+                    bridgeKind: projection.bridgeKind,
                     content: projection.content,
                 });
                 return;
             }
             case 'tool_call': {
+                this.closePendingThoughtSegment(session);
                 const toolCall = (0, local_core_acp_progress_js_1.registerPendingToolCall)({ currentTurn, runId: currentRunId, update });
+                (0, local_core_acp_progress_js_1.recordToolObservation)(currentTurn, {
+                    name: toolCall.title,
+                    title: toolCall.title,
+                    input: toolCall.input,
+                });
                 (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, toolCall);
                 return;
             }
             case 'tool_call_update': {
+                this.closePendingThoughtSegment(session);
                 const title = String(update.title || 'Tool update').trim();
                 const status = String(update.status || '').trim();
                 const content = (0, local_core_acp_progress_js_1.extractToolUpdateContent)(update.content);
@@ -276,11 +314,19 @@ class LocalCoreAcpTurnCoordinator {
                     detail: displayTitle,
                     content,
                 });
+                (0, local_core_acp_progress_js_1.recordToolObservation)(currentTurn, {
+                    name: toolName || displayTitle || title,
+                    title: displayTitle || title,
+                    status,
+                    input: updateInput === undefined ? toolCall?.input : updateInput,
+                    outputText: content,
+                });
                 this.emitProgress(session, currentRunId, (0, local_core_acp_progress_js_1.formatToolProgressMessage)({ toolName, title: displayTitle, status, content }), messageId, toolCallPayload);
                 (0, local_core_acp_progress_js_1.syncLegacyPendingToolCall)(currentTurn, (0, local_core_acp_progress_js_1.resolveFallbackToolCall)(currentTurn));
                 return;
             }
             case 'plan': {
+                this.closePendingThoughtSegment(session);
                 this.flushPendingToolCall(session);
                 const entries = Array.isArray(update.entries) ? update.entries : [];
                 if (entries.length === 0) {
@@ -290,11 +336,12 @@ class LocalCoreAcpTurnCoordinator {
                 if (!content) {
                     return;
                 }
-                this.options.appendMessage(session.threadId, 'assistant', content, 'progress');
+                this.options.appendMessage(session.threadId, 'assistant', content, 'progress', undefined, 'plan');
                 this.options.emitBridge({
                     type: 'reply',
                     sessionKey: session.bridgeSessionKey,
                     replyCtx: currentRunId,
+                    bridgeKind: 'plan',
                     content,
                 });
                 return;
@@ -303,24 +350,60 @@ class LocalCoreAcpTurnCoordinator {
                 return;
         }
     }
+    handleClaudeSdkMessage(session, message) {
+        if (!session.currentTurn || message?.type !== 'system' || message?.subtype !== 'local_command_output') {
+            return;
+        }
+        const content = typeof message.content === 'string' ? message.content : '';
+        if (!content) {
+            return;
+        }
+        session.pendingRawAssistantProgressChunks = [
+            ...(session.pendingRawAssistantProgressChunks || []),
+            content,
+        ];
+    }
     emitProgress(session, currentRunId, content, messageId, toolCall) {
         if (messageId && this.options.upsertMessage) {
-            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall);
+            this.options.upsertMessage(session.threadId, messageId, 'assistant', content, 'progress', toolCall, toolCall ? 'tool' : undefined);
         }
         else {
-            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall);
+            this.options.appendMessage(session.threadId, 'assistant', content, 'progress', toolCall, toolCall ? 'tool' : undefined);
         }
         this.options.emitBridge({
             type: 'reply',
             sessionKey: session.bridgeSessionKey,
             replyCtx: currentRunId,
             messageId,
+            bridgeKind: toolCall ? 'tool' : undefined,
             content,
             toolCall,
         });
     }
 }
 exports.LocalCoreAcpTurnCoordinator = LocalCoreAcpTurnCoordinator;
+function isToolScopedAssistantUpdate(update) {
+    const meta = update._meta;
+    if (!meta || typeof meta !== 'object') {
+        return false;
+    }
+    const claudeCode = meta.claudeCode;
+    if (!claudeCode || typeof claudeCode !== 'object') {
+        return false;
+    }
+    const parentToolUseId = claudeCode.parentToolUseId;
+    return typeof parentToolUseId === 'string' && parentToolUseId.trim().length > 0;
+}
+function consumeRawAssistantProgressChunk(session, text) {
+    const pending = session.pendingRawAssistantProgressChunks || [];
+    const index = pending.findIndex((candidate) => candidate === text);
+    if (index < 0) {
+        return false;
+    }
+    pending.splice(index, 1);
+    session.pendingRawAssistantProgressChunks = pending;
+    return true;
+}
 function createToolCallPayload(input) {
     const status = input.status.trim() || 'running';
     return {

package/dist-electron/services/local-ai-core/src/channel/lark/runtime-state.js

@@ -31,31 +31,25 @@ function createLarkTurnState(sessionKey, sourceMessageId) {
     return turn;
 }
 function foldToolResultForLark(content) {
-    const normalized = String(content || '').trim();
-    if (!normalized.startsWith('🔧 '))
-        return normalized;
-    const parts = normalized.split(' - ');
-    if (parts.length <= 2)
-        return normalized;
-    return parts.slice(0, 2).join(' - ');
+    return String(content || '').trim();
 }
 function summarizeToolCallForLark(event, content) {
     const toolCall = event.toolCall;
     if (toolCall) {
         const name = String(toolCall.name || '').trim() || summarizeToolContentForLark(content);
         const input = formatToolInputForLark(toolCall.input);
-        return [name.startsWith('🔧 ') ? name : `🔧 ${name}`, input ? `参数：${input}` : '']
+        return [`🔧 ${name}`, input ? `参数：${input}` : '']
             .filter(Boolean)
             .join('\n\n');
     }
     return summarizeToolContentForLark(content);
 }
-function isPendingToolProgressForLark(content) {
-    const normalized = foldToolResultForLark(content).toLowerCase();
-    return normalized.startsWith('🔧 ') && normalized.includes(' - pending');
+function isPendingToolProgressForLark(event) {
+    return event.toolCall?.status.trim().toLowerCase() === 'pending';
 }
 function consumeLarkBridgeEvent(turn, event, options) {
     const content = foldToolResultForLark(String(event.content || '').trim());
+    const bridgeKind = resolveBridgeEventKind(event);
     if (event.type === 'typing_start') {
         turn.messageId = undefined;
         turn.finalMessageId = undefined;
@@ -80,10 +74,10 @@ function consumeLarkBridgeEvent(turn, event, options) {
         return;
     }
     if (event.type === 'preview_start' || event.type === 'update_message') {
-        if (content.startsWith('💭 ')) {
+        if (bridgeKind === 'thought') {
             turn.pendingThoughtKey = event.previewHandle || 'thinking-preview';
             turn.pendingThoughtText = content;
-            pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+            pushUniqueLarkTurnLine(turn.thinkingSteps, content);
             return;
         }
         turn.previewText = content;
@@ -106,17 +100,17 @@ function consumeLarkBridgeEvent(turn, event, options) {
     if (!content) {
         return;
     }
-    if (content.startsWith('💭 ')) {
+    if (bridgeKind === 'thought' || bridgeKind === 'plan') {
         turn.pendingThoughtKey = progressKey('thinking', event);
         turn.pendingThoughtText = content;
-        pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+        pushUniqueLarkTurnLine(turn.thinkingSteps, content);
         return;
     }
-    if (content.startsWith('🔧 ')) {
+    if (bridgeKind === 'tool') {
         pushUniqueLarkTurnLine(turn.toolCalls, content.slice(3).trim());
         return;
     }
-    if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+    if (bridgeKind === 'status') {
         pushUniqueLarkTurnLine(turn.statusLines, content.slice(3).trim());
         return;
     }
@@ -125,12 +119,13 @@ function consumeLarkBridgeEvent(turn, event, options) {
 }
 function renderLarkBridgeEventMessage(turn, event) {
     const content = foldToolResultForLark(String(event.content || '').trim());
+    const bridgeKind = resolveBridgeEventKind(event);
     if (event.type === 'preview_start' || event.type === 'update_message') {
-        if (content.startsWith('💭 ')) {
+        if (bridgeKind === 'thought') {
             return { key: 'noop', text: '', buttonRows: [], isFinal: false };
         }
-        if (content.startsWith('🔧 ')) {
-            if (isPendingToolProgressForLark(content)) {
+        if (bridgeKind === 'tool') {
+            if (isPendingToolProgressForLark(event)) {
                 return { key: 'noop', text: '', buttonRows: [], isFinal: false };
             }
             return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
@@ -138,19 +133,19 @@ function renderLarkBridgeEventMessage(turn, event) {
         return { key: 'noop', text: '', buttonRows: [], isFinal: false };
     }
     if (event.type === 'status') {
-        return renderProgressMessage(progressKey('status', event), content.startsWith('⏳ ') ? content : `⏳ ${content}`);
+        return renderProgressMessage(progressKey('status', event), `⏳ ${content}`);
     }
     if (event.type === 'reply') {
-        if (content.startsWith('💭 ')) {
-            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
+        if (bridgeKind === 'thought' || bridgeKind === 'plan') {
+            return renderProgressMessage(progressKey(bridgeKind, event), renderProcessText(bridgeKind, content));
         }
-        if (content.startsWith('🔧 ')) {
-            if (isPendingToolProgressForLark(content)) {
+        if (bridgeKind === 'tool') {
+            if (isPendingToolProgressForLark(event)) {
                 return { key: 'noop', text: '', buttonRows: [], isFinal: false };
             }
             return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
         }
-        if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+        if (bridgeKind === 'status') {
             return renderProgressMessage(progressKey('status', event), content);
         }
         return {
@@ -186,14 +181,14 @@ function takePendingLarkThoughtRender(turn) {
     }
     turn.thoughtSegmentSequence += 1;
     const baseKey = turn.pendingThoughtKey || 'thinking-preview';
-    const rendered = renderProgressMessage(`thinking:${baseKey}:${turn.thoughtSegmentSequence}`, text);
+    const rendered = renderProgressMessage(`thinking:${baseKey}:${turn.thoughtSegmentSequence}`, renderProcessText('thought', text));
     turn.pendingThoughtKey = undefined;
     turn.pendingThoughtText = undefined;
     return rendered;
 }
 function getLarkRenderedMessageId(turn, rendered) {
     if (rendered.isFinal) {
-        return turn.finalMessageId || turn.replyMessageId;
+        return undefined;
     }
     return turn.progressMessageIds[rendered.key];
 }
@@ -229,21 +224,21 @@ function progressKey(prefix, event) {
     return `${prefix}:${content.slice(0, 120)}`;
 }
 function isThoughtBridgeEvent(event) {
-    if (event.type !== 'preview_start' && event.type !== 'update_message' && event.type !== 'reply') {
-        return false;
+    const kind = resolveBridgeEventKind(event);
+    return kind === 'thought' || kind === 'plan';
+}
+function resolveBridgeEventKind(event) {
+    if (event.bridgeKind) {
+        return event.bridgeKind;
     }
-    return String(event.content || '').trim().startsWith('💭 ');
+    return event.type === 'status' ? 'status' : 'assistant';
+}
+function renderProcessText(kind, content) {
+    const text = content.trim();
+    return kind === 'plan' ? `计划\n${text}` : text;
 }
 function summarizeToolContentForLark(content) {
-    const normalized = String(content || '').trim();
-    if (!normalized.startsWith('🔧 ')) {
-        return normalized;
-    }
-    const withoutOutput = normalized.split(' - ')[0]?.trim() || normalized;
-    return withoutOutput
-        .replace(/\s+-\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
-        .replace(/:\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
-        .trim();
+    return String(content || '').trim();
 }
 function formatToolInputForLark(input) {
     if (input == null) {

package/dist-electron/services/local-ai-core/src/channel/weixin/local-core-weixin-gateway.js

@@ -130,16 +130,16 @@ function truncateTextByUtf8Bytes(text, maxBytes) {
     }
     return `${result.trim()}${suffix}`;
 }
-function stripToolResultForWeixin(content) {
-    const normalized = String(content || '').trim();
-    if (!normalized.startsWith('🔧 '))
-        return normalized;
-    const parts = normalized.split(' - ');
-    if (parts[0] === '🔧 Tool update' && parts[1] === 'completed')
+function renderBridgeContentForWeixin(event) {
+    const toolCall = event.toolCall;
+    if (!toolCall) {
+        return String(event.content || '').trim();
+    }
+    const name = String(toolCall.name || '').trim() || 'Tool update';
+    const status = String(toolCall.status || '').trim();
+    if (name === 'Tool update' && status === 'completed')
         return '';
-    if (parts.length <= 2)
-        return normalized;
-    return parts.slice(0, 2).join(' - ');
+    return [name, status].filter(Boolean).join(' - ');
 }
 // ==================== Gateway Class ====================
 class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
@@ -1058,6 +1058,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             previewText: '',
             finalText: '',
             thinkingSteps: [],
+            pendingThoughtText: undefined,
             statusLines: [],
             buttonRows: [],
             lastSentAt: 0,
@@ -1070,12 +1071,14 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         return this.outboundTurns.get(sessionKey) || this.createTurnState(sessionKey);
     }
     consumeBridgeEvent(turn, event) {
-        const content = stripToolResultForWeixin(String(event.content || '').trim());
+        const content = renderBridgeContentForWeixin(event);
+        const bridgeKind = this.resolveBridgeEventKind(event);
         if (event.type === 'typing_start') {
             turn.processing = true;
             turn.previewText = '';
             turn.finalText = '';
             turn.thinkingSteps = [];
+            turn.pendingThoughtText = undefined;
             turn.statusLines = [];
             turn.buttonRows = [];
             return;
@@ -1085,9 +1088,16 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return;
         }
         if (event.type === 'preview_start' || event.type === 'update_message') {
+            if (bridgeKind === 'thought') {
+                turn.pendingThoughtText = content;
+                return;
+            }
             turn.previewText = content;
             return;
         }
+        if (bridgeKind !== 'thought') {
+            this.flushPendingThought(turn);
+        }
         if (event.type === 'status') {
             if (content) {
                 this.pushUnique(turn.statusLines, content);
@@ -1110,8 +1120,12 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         if (!content)
             return;
-        if (content.startsWith('💭 ')) {
-            this.pushUnique(turn.thinkingSteps, content.slice(3).trim());
+        if (bridgeKind === 'thought' || bridgeKind === 'plan') {
+            this.pushUnique(turn.thinkingSteps, content);
+            return;
+        }
+        if (bridgeKind === 'tool' || bridgeKind === 'status') {
+            this.pushUnique(turn.statusLines, content);
             return;
         }
         turn.finalText = content;
@@ -1120,7 +1134,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     renderTurnText(turn) {
         const sections = [];
         if (turn.thinkingSteps.length > 0) {
-            sections.push(`**思考过程**\n${turn.thinkingSteps.map((step) => `• ${step.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
+            sections.push(`**中间过程**\n${turn.thinkingSteps.map((step) => `• ${step.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
         }
         if (turn.finalText) {
             sections.push(turn.finalText);
@@ -1128,7 +1142,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         else if (turn.previewText) {
             sections.push(turn.previewText);
         }
-        else if (turn.processing && turn.statusLines.length > 0) {
+        else if (turn.statusLines.length > 0) {
             sections.push(`**处理中**\n${turn.statusLines.slice(-3).map((l) => `• ${l.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
         }
         else if (turn.processing) {
@@ -1139,21 +1153,32 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         }
         return sections.join('\n\n').trim();
     }
+    flushPendingThought(turn) {
+        const text = String(turn.pendingThoughtText || '').trim();
+        if (!text)
+            return;
+        this.pushUnique(turn.thinkingSteps, text);
+        turn.pendingThoughtText = undefined;
+    }
     isTerminalBridgeMessage(event, rendered) {
         if (event.type === 'buttons')
             return true;
         if (event.type !== 'reply')
             return false;
-        const eventContent = String(event.content || '').trim();
-        if (eventContent.startsWith('🔧 ') || eventContent.startsWith('💭 '))
+        const bridgeKind = this.resolveBridgeEventKind(event);
+        if (bridgeKind === 'tool' || bridgeKind === 'thought' || bridgeKind === 'plan' || bridgeKind === 'status')
             return false;
         const normalized = rendered.trim();
         if (!normalized)
             return false;
-        if (normalized.startsWith('🔧 ') || normalized.startsWith('💭 '))
-            return false;
         return true;
     }
+    resolveBridgeEventKind(event) {
+        if (event.bridgeKind) {
+            return event.bridgeKind;
+        }
+        return event.type === 'status' ? 'status' : 'assistant';
+    }
     // ==================== Private: Helpers ====================
     pushUnique(target, value) {
         const normalized = value.trim();