@ynhcj/xiaoyi-channel 0.0.16-beta → 0.0.16-next

package/dist/src/outbound.js

@@ -1,7 +1,9 @@
 import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
-import { getLatestSessionContext } from "./tools/session-manager.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { savePushData } from "./utils/pushdata-manager.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -65,8 +67,8 @@ export const xyOutbound = {
         // If the target doesn't contain "::", try to enhance it with taskId from session context
         if (!trimmedTo.includes("::")) {
             console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
-            // Try to get the latest session context
-            const sessionContext = getLatestSessionContext();
+            // Try to get the current session context
+            const sessionContext = getCurrentSessionContext();
             if (sessionContext && sessionContext.sessionId === trimmedTo) {
                 const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
                 console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
@@ -105,19 +107,63 @@ export const xyOutbound = {
             // The push service will handle it based on config
             actualTo = config.defaultSessionId || "";
         }
+        // 1. 持久化推送消息内容，获取 pushDataId
+        console.log(`[xyOutbound.sendText] Saving push data to local storage...`);
+        let pushDataId;
+        try {
+            pushDataId = await savePushData(text);
+            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId}`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
+            // 如果持久化失败，仍然继续发送（不阻塞主流程）
+            pushDataId = "";
+        }
+        // 2. 读取所有 pushId
+        console.log(`[xyOutbound.sendText] Loading all pushIds...`);
+        let pushIdList = [];
+        try {
+            pushIdList = await getAllPushIds();
+            console.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
+        }
+        catch (error) {
+            console.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
+        }
+        // 3. 如果 pushIdList 为空，回退到原有逻辑（使用 config pushId）
+        if (pushIdList.length === 0) {
+            console.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
+            pushIdList = [config.pushId];
+        }
         // Create push service
         const pushService = new XYPushService(config);
         // Extract title (first 57 chars or first line)
         const title = text.split("\n")[0].slice(0, 57);
         // Truncate push content to max length 1000
         const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
-        // Send push message (content, title, data, sessionId)
-        await pushService.sendPush(pushText, title, undefined, actualTo);
+        // 4. 遍历所有 pushId，依次发送推送通知
+        console.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
+        let successCount = 0;
+        let failureCount = 0;
+        for (const pushId of pushIdList) {
+            try {
+                console.log(`[xyOutbound.sendText] Sending to pushId: ${pushId.substring(0, 20)}...`);
+                // 传入 pushId 和 pushDataId，使用 kind="data" 格式
+                await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId, pushId);
+                successCount++;
+                console.log(`[xyOutbound.sendText] ✅ Sent successfully to pushId: ${pushId.substring(0, 20)}...`);
+            }
+            catch (error) {
+                failureCount++;
+                console.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
+                // 单个 pushId 发送失败不影响其他，继续处理下一个
+            }
+        }
+        console.log(`[xyOutbound.sendText] 📊 Broadcast summary: ${successCount} success, ${failureCount} failures`);
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",
-            messageId: Date.now().toString(),
+            messageId: pushDataId || Date.now().toString(),
             chatId: actualTo,
         };
     },

package/dist/src/parser.d.ts

@@ -43,6 +43,13 @@ export declare function isTasksCancelMessage(method: string): boolean;
  * Looks for push_id in data parts under variables.systemVariables.push_id
  */
 export declare function extractPushId(parts: A2AMessagePart[]): string | null;
+/**
+ * Extract Trigger event data from message parts.
+ * Looks for Trigger events with pushDataId in data parts.
+ */
+export declare function extractTriggerData(parts: A2AMessagePart[]): {
+    pushDataId: string;
+} | null;
 /**
  * Validate A2A request structure.
  */

package/dist/src/parser.js

@@ -72,6 +72,28 @@ export function extractPushId(parts) {
     }
     return null;
 }
+/**
+ * Extract Trigger event data from message parts.
+ * Looks for Trigger events with pushDataId in data parts.
+ */
+export function extractTriggerData(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const events = part.data.events;
+            if (Array.isArray(events)) {
+                for (const event of events) {
+                    if (event.header?.namespace === "Common" && event.header?.name === "Trigger") {
+                        const pushDataId = event.payload?.dataMap?.pushDataId;
+                        if (pushDataId && typeof pushDataId === "string") {
+                            return { pushDataId };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
 /**
  * Validate A2A request structure.
  */

package/dist/src/push.d.ts

@@ -14,8 +14,15 @@ export declare class XYPushService {
     private generateTraceId;
     /**
      * Send a push message to a user session.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
+     * @param pushId - Push ID to use (required)
      */
-    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string): Promise<void>;
+    sendPush(content: string, title: string, data?: Record<string, any>, sessionId?: string, pushDataId?: string, pushId?: string): Promise<void>;
     /**
      * Send a push message with file attachments.
      */

package/dist/src/push.js

@@ -1,7 +1,6 @@
 // Push message service for scheduled tasks
 import fetch from "node-fetch";
 import { randomUUID } from "crypto";
-import { configManager } from "./utils/config-manager.js";
 /**
  * Service for sending push messages to users.
  * Used for outbound messages and scheduled tasks.
@@ -21,27 +20,27 @@ export class XYPushService {
     }
     /**
      * Send a push message to a user session.
+     *
+     * @param content - Push message content
+     * @param title - Push message title
+     * @param data - Optional additional data
+     * @param sessionId - Optional session ID
+     * @param pushDataId - Optional pushDataId for kind="data" format
+     * @param pushId - Push ID to use (required)
      */
-    async sendPush(content, title, data, sessionId) {
+    async sendPush(content, title, data, sessionId, pushDataId, pushId) {
         const pushUrl = this.config.pushUrl || this.DEFAULT_PUSH_URL;
         const traceId = this.generateTraceId();
-        // Get dynamic pushId for the session (falls back to config pushId)
-        const dynamicPushId = configManager.getPushId(sessionId);
-        const pushId = dynamicPushId || this.config.pushId;
+        // Use provided pushId or fall back to config pushId
+        const actualPushId = pushId || this.config.pushId;
         console.log(`[PUSH] 📤 Preparing to send push message`);
         console.log(`[PUSH]   - Title: "${title}"`);
         console.log(`[PUSH]   - Content length: ${content.length} chars`);
         console.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
         console.log(`[PUSH]   - Trace ID: ${traceId}`);
         console.log(`[PUSH]   - Push URL: ${pushUrl}`);
-        if (dynamicPushId) {
-            console.log(`[PUSH]   - Using dynamic pushId (from session): ${pushId.substring(0, 20)}...`);
-            console.log(`[PUSH]   - Full dynamic pushId: ${pushId}`);
-        }
-        else {
-            console.log(`[PUSH]   - Using config pushId (fallback): ${pushId.substring(0, 20)}...`);
-            console.log(`[PUSH]   - Full config pushId: ${pushId}`);
-        }
+        console.log(`[PUSH]   - Using pushId: ${actualPushId.substring(0, 20)}...`);
+        console.log(`[PUSH]   - Full pushId: ${actualPushId}`);
         console.log(`[PUSH]   - API ID: ${this.config.apiId}`);
         console.log(`[PUSH]   - UID: ${this.config.uid}`);
         try {
@@ -51,18 +50,27 @@ export class XYPushService {
                 result: {
                     id: randomUUID(),
                     apiId: this.config.apiId,
-                    pushId: pushId, // Use dynamic pushId
+                    pushId: actualPushId,
                     pushText: title,
                     kind: "task",
                     artifacts: [
                         {
                             artifactId: randomUUID(),
-                            parts: [
-                                {
-                                    kind: "text",
-                                    text: content,
-                                },
-                            ],
+                            parts: pushDataId
+                                ? [
+                                    {
+                                        kind: "data",
+                                        data: {
+                                            pushDataId: pushDataId,
+                                        },
+                                    },
+                                ]
+                                : [
+                                    {
+                                        kind: "text",
+                                        text: content,
+                                    },
+                                ],
                         },
                     ],
                 },
@@ -114,14 +122,14 @@ export class XYPushService {
             console.log(`[PUSH] ✅ Push message sent successfully`);
             console.log(`[PUSH]   - Title: "${title}"`);
             console.log(`[PUSH]   - Trace ID: ${traceId}`);
-            console.log(`[PUSH]   - Used pushId: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Used pushId: ${actualPushId.substring(0, 20)}...`);
             console.log(`[PUSH]   - Response:`, result);
         }
         catch (error) {
             console.log(`[PUSH] ❌ Failed to send push message`);
             console.log(`[PUSH]   - Trace ID: ${traceId}`);
             console.log(`[PUSH]   - Target URL: ${pushUrl}`);
-            console.log(`[PUSH]   - Push ID: ${pushId.substring(0, 20)}...`);
+            console.log(`[PUSH]   - Push ID: ${actualPushId.substring(0, 20)}...`);
             if (error instanceof Error) {
                 console.log(`[PUSH]   - Error name: ${error.name}`);
                 console.log(`[PUSH]   - Error message: ${error.message}`);

package/dist/src/reply-dispatcher.d.ts

@@ -6,6 +6,7 @@ export interface CreateXYReplyDispatcherParams {
     taskId: string;
     messageId: string;
     accountId: string;
+    isSteerFollower?: boolean;
 }
 /**
  * Create a reply dispatcher for XY channel messages.

package/dist/src/reply-dispatcher.js

@@ -2,47 +2,58 @@ import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 import { getXYRuntime } from "./runtime.js";
 import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 /**
  * Create a reply dispatcher for XY channel messages.
  * Follows feishu pattern with status updates and streaming support.
  * Runtime is expected to be validated before calling this function.
  */
 export function createXYReplyDispatcher(params) {
-    const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
+    const { cfg, runtime, sessionId, taskId, messageId, accountId, isSteerFollower } = params;
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
-    log(`[DISPATCHER-CREATE] ******* Creating dispatcher for session=${sessionId}, taskId=${taskId}, messageId=${messageId} *******`);
-    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
-    log(`[DISPATCHER-CREATE] ======== Creating reply dispatcher ========`);
-    log(`[DISPATCHER-CREATE] sessionId: ${sessionId}, taskId: ${taskId}, messageId: ${messageId}`);
-    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
-    // Get runtime (already validated in monitor.ts, but get reference for use)
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
+    log(`[DISPATCHER-CREATE]   - sessionId: ${sessionId}`);
+    log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
+    log(`[DISPATCHER-CREATE]   - messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE]   - isSteerFollower: ${isSteerFollower ?? false}`);
+    // 初始taskId和messageId（作为fallback）
+    const initialTaskId = taskId;
+    const initialMessageId = messageId;
+    /**
+     * 🔑 核心改造：动态获取当前活跃的taskId和messageId
+     * 每次需要taskId时，都从TaskManager获取最新值
+     */
+    const getActiveTaskId = () => {
+        return getCurrentTaskId(sessionId) ?? initialTaskId;
+    };
+    const getActiveMessageId = () => {
+        return getCurrentMessageId(sessionId) ?? initialMessageId;
+    };
     const core = getXYRuntime();
-    // Resolve configuration
     const config = resolveXYConfig(cfg);
-    // Create reply prefix context (for model selection, etc.)
     const prefixContext = createReplyPrefixContext({ cfg, agentId: accountId });
-    // Status update interval (every 60 seconds)
     let statusUpdateInterval = null;
-    // Track if we've sent any response
     let hasSentResponse = false;
-    // Track if we've sent the final empty message
     let finalSent = false;
-    // Accumulate all text from deliver calls
     let accumulatedText = "";
     /**
      * Start the status update interval
-     * Call this immediately after creating the dispatcher
      */
     const startStatusInterval = () => {
-        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}, taskId=${taskId}`);
+        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}`);
         statusUpdateInterval = setInterval(() => {
-            log(`[STATUS INTERVAL] Triggering status update for session ${sessionId}, taskId=${taskId}`);
+            // 🔑 使用动态taskId
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[STATUS INTERVAL] Triggering status update`);
+            log(`[STATUS INTERVAL]   - sessionId: ${sessionId}`);
+            log(`[STATUS INTERVAL]   - currentTaskId: ${currentTaskId}`);
             void sendStatusUpdate({
                 config,
                 sessionId,
-                taskId,
-                messageId,
+                taskId: currentTaskId, // 🔑 动态taskId
+                messageId: currentMessageId, // 🔑 动态messageId
                 text: "任务正在处理中，请稍后~",
                 state: "working",
             }).catch((err) => {
@@ -50,15 +61,11 @@ export function createXYReplyDispatcher(params) {
             });
         }, 30000); // 30 seconds
     };
-    /**
-     * Stop the status update interval
-     */
     const stopStatusInterval = () => {
         if (statusUpdateInterval) {
-            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}, taskId=${taskId}`);
+            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}`);
             clearInterval(statusUpdateInterval);
             statusUpdateInterval = null;
-            log(`[STATUS INTERVAL] Stopped interval for session ${sessionId}, taskId=${taskId}`);
         }
     };
     const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
@@ -66,33 +73,28 @@ export function createXYReplyDispatcher(params) {
         responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
         onReplyStart: () => {
-            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${taskId}`);
-            // Status update interval is now managed externally
+            const currentTaskId = getActiveTaskId();
+            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
         },
         deliver: async (payload, info) => {
             const text = payload.text ?? "";
-            // 🔍 Debug logging
-            log(`[DELIVER] sessionId=${sessionId}, info.kind=${info?.kind}, text.length=${text.length}, text="${text.slice(0, 200)}"`);
-            log(`[DELIVER] payload keys: ${Object.keys(payload).join(", ")}`);
-            if (payload.mediaUrls) {
-                log(`[DELIVER] mediaUrls: ${payload.mediaUrls.length} files`);
-            }
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[DELIVER] sessionId=${sessionId}, taskId=${currentTaskId}, info.kind=${info?.kind}, text.length=${text.length}`);
             try {
-                // Skip empty messages
                 if (!text.trim()) {
                     log(`[DELIVER SKIP] Empty text, skipping`);
                     return;
                 }
-                // Accumulate text instead of sending immediately
                 accumulatedText += text;
                 hasSentResponse = true;
                 log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
-                // Also stream text as reasoningText for real-time display
+                // 🔑 使用动态taskId发送reasoningText更新
                 await sendReasoningTextUpdate({
                     config,
                     sessionId,
-                    taskId,
-                    messageId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
                     text,
                 });
                 log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
@@ -103,16 +105,21 @@ export function createXYReplyDispatcher(params) {
         },
         onError: async (err, info) => {
             runtime.error?.(`xy: ${info.kind} reply failed: ${String(err)}`);
-            // Stop status updates
             stopStatusInterval();
-            // Send error status if we haven't sent any response yet
+            // 🔑 steer follower不发送错误状态（让主dispatcher处理）
+            if (isSteerFollower) {
+                log(`[ON_ERROR] Steer follower - skipping error response`);
+                return;
+            }
             if (!hasSentResponse) {
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
                 try {
                     await sendStatusUpdate({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: "处理失败，请稍后重试",
                         state: "failed",
                     });
@@ -123,46 +130,61 @@ export function createXYReplyDispatcher(params) {
             }
         },
         onIdle: async () => {
-            log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Send accumulated text with append=false and final=true
+            const currentTaskId = getActiveTaskId();
+            const currentMessageId = getActiveMessageId();
+            log(`[ON_IDLE] Reply idle`);
+            log(`[ON_IDLE]   - sessionId: ${sessionId}`);
+            log(`[ON_IDLE]   - taskId: ${currentTaskId}`);
+            log(`[ON_IDLE]   - isSteerFollower: ${isSteerFollower}`);
+            log(`[ON_IDLE]   - hasSentResponse: ${hasSentResponse}`);
+            log(`[ON_IDLE]   - finalSent: ${finalSent}`);
+            // 🔑 核心改动：steer follower不发送final响应
+            if (isSteerFollower) {
+                log(`[ON_IDLE] Steer follower - skipping final response`);
+                log(`[ON_IDLE]   - Message queued successfully, waiting for primary dispatcher`);
+                stopStatusInterval();
+                return; // ← 直接返回，不发送任何东西！
+            }
+            // 正常模式（或steer的第一条消息）
             if (hasSentResponse && !finalSent) {
                 log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
-                    // Send status update before final message
+                    // 🔑 使用动态taskId发送完成状态
                     await sendStatusUpdate({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: "任务处理已完成~",
                         state: "completed",
                     });
                     log(`[ON_IDLE] ✅ Sent completion status update`);
+                    // 🔑 使用动态taskId发送最终响应
                     await sendA2AResponse({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: accumulatedText,
                         append: false,
                         final: true,
                     });
                     finalSent = true;
-                    log(`[ON_IDLE] Sent accumulated text`);
+                    log(`[ON_IDLE] ✅ Sent final response with taskId=${currentTaskId}`);
                 }
                 catch (err) {
-                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
+                    error(`[ON_IDLE] Failed to send final response:`, err);
                 }
             }
             else {
+                // 正常失败场景（非steer follower）
                 log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-                // Task was interrupted - send failure status and error response
                 try {
                     await sendStatusUpdate({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: "任务处理中断了~",
                         state: "failed",
                     });
@@ -170,8 +192,8 @@ export function createXYReplyDispatcher(params) {
                     await sendA2AResponse({
                         config,
                         sessionId,
-                        taskId,
-                        messageId,
+                        taskId: currentTaskId,
+                        messageId: currentMessageId,
                         text: "任务执行异常，请重试~",
                         append: false,
                         final: true,
@@ -180,14 +202,14 @@ export function createXYReplyDispatcher(params) {
                     log(`[ON_IDLE] ✅ Sent error response`);
                 }
                 catch (err) {
-                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                    error(`[ON_IDLE] Failed to send error response:`, err);
                 }
             }
-            // Stop status updates
             stopStatusInterval();
         },
         onCleanup: () => {
-            log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+            const currentTaskId = getActiveTaskId();
+            log(`[ON_CLEANUP] Reply cleanup, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
         },
     });
     return {
@@ -195,17 +217,22 @@ export function createXYReplyDispatcher(params) {
         replyOptions: {
             ...replyOptions,
             onModelSelected: prefixContext.onModelSelected,
-            // 🔧 Tool execution start callback
             onToolStart: async ({ name, phase }) => {
-                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                // 🔑 steer follower不发送tool状态（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                log(`[TOOL START] Tool: ${name}, phase: ${phase}, taskId: ${currentTaskId}`);
                 if (phase === "start") {
                     const toolName = name || "unknown";
                     try {
                         await sendStatusUpdate({
                             config,
                             sessionId,
-                            taskId,
-                            messageId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
                             text: `正在使用工具: ${toolName}...`,
                             state: "working",
                         });
@@ -216,25 +243,24 @@ export function createXYReplyDispatcher(params) {
                     }
                 }
             },
-            // 🔧 Tool execution result callback
             onToolResult: async (payload) => {
+                // 🔑 steer follower不发送tool结果（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
                 const text = payload.text ?? "";
                 const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
-                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
-                log(`[TOOL RESULT]   - text.length=${text.length}`);
-                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
-                log(`[TOOL RESULT]   - isError=${payload.isError}`);
-                if (text.length > 0) {
-                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
-                }
+                log(`[TOOL RESULT] Tool result, taskId: ${currentTaskId}, text.length: ${text.length}`);
                 try {
                     if (text.length > 0 || hasMedia) {
                         const resultText = text.length > 0 ? text : "工具执行完成";
                         await sendStatusUpdate({
                             config,
                             sessionId,
-                            taskId,
-                            messageId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
                             text: resultText,
                             state: "working",
                         });
@@ -245,54 +271,43 @@ export function createXYReplyDispatcher(params) {
                     error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
                 }
             },
-            // 🧠 Reasoning/thinking process streaming callback
             onReasoningStream: async (payload) => {
-                const text = payload.text ?? "";
-                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
-                log(`[REASONING STREAM]   - text.length=${text.length}`);
-                if (text.length > 0) {
-                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                // 🔑 steer follower不发送reasoning stream
+                if (isSteerFollower) {
+                    return;
                 }
-                // try {
-                //   if (text.length > 0) {
-                //     await sendReasoningTextUpdate({
-                //       config,
-                //       sessionId,
-                //       taskId,
-                //       messageId,
-                //       text,
-                //     });
-                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
-                //   }
-                // } catch (err) {
-                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
-                // }
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] Reasoning chunk received, text.length: ${text.length}`);
+                // Reasoning stream 目前被注释掉
+                // 如果需要可以启用
             },
-            // 📝 Partial reply streaming callback (real-time preview)
             onPartialReply: async (payload) => {
+                // 🔑 steer follower不发送partial reply（让主dispatcher处理）
+                if (isSteerFollower) {
+                    return;
+                }
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
                 const text = payload.text ?? "";
-                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
-                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
                 try {
                     if (text.length > 0) {
                         await sendReasoningTextUpdate({
                             config,
                             sessionId,
-                            taskId,
-                            messageId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
                             text,
                             append: false,
                         });
-                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
                     }
                 }
                 catch (err) {
-                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply:`, err);
                 }
             },
         },
         markDispatchIdle,
-        startStatusInterval, // Expose this to be called immediately
-        stopStatusInterval, // Expose this for manual control if needed
+        startStatusInterval,
+        stopStatusInterval,
     };
 }