@ynhcj/xiaoyi-channel 0.0.24-beta → 0.0.26-beta

package/dist/src/bot.js

@@ -6,6 +6,7 @@ import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
 import { registerSession, unregisterSession } from "./tools/session-manager.js";
 import { configManager } from "./utils/config-manager.js";
+import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -56,6 +57,22 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
+        // 🔑 检测steer模式和是否是第二条消息
+        const isSteerMode = cfg.messages?.queue?.mode === "steer";
+        const isSecondMessage = isSteerMode && hasActiveTask(parsed.sessionId);
+        if (isSecondMessage) {
+            log(`[BOT] 🔄 STEER MODE - Second message detected (will be follower)`);
+            log(`[BOT]   - Session: ${parsed.sessionId}`);
+            log(`[BOT]   - New taskId: ${parsed.taskId} (will replace current)`);
+        }
+        // 🔑 注册taskId（第二条消息会覆盖第一条的taskId）
+        const { isUpdate, refCount } = registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId, { incrementRef: true } // 增加引用计数
+        );
+        // 🔑 如果是第一条消息，锁定taskId防止被过早清理
+        if (!isUpdate) {
+            lockTaskId(parsed.sessionId);
+            log(`[BOT] 🔒 Locked taskId for first message`);
+        }
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
@@ -83,11 +100,12 @@ export async function handleXYMessage(params) {
             },
         });
         log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
-        // Register session context for tools
+        // 🔑 注册session（带引用计数）
         log(`[BOT] 📝 About to register session for tools...`);
         log(`[BOT]   - sessionKey: ${route.sessionKey}`);
         log(`[BOT]   - sessionId: ${parsed.sessionId}`);
         log(`[BOT]   - taskId: ${parsed.taskId}`);
+        log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
         registerSession(route.sessionKey, {
             config,
             sessionId: parsed.sessionId,
@@ -96,14 +114,14 @@ export async function handleXYMessage(params) {
             agentId: route.accountId,
         });
         log(`[BOT] ✅ Session registered for tools`);
-        // Send initial status update immediately after parsing message
+        // 🔑 发送初始状态更新（第二条消息也要发，用新taskId）
         log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
         void sendStatusUpdate({
             config,
             sessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            text: "任务正在处理中，请稍后~",
+            text: isSecondMessage ? "新消息已接收，正在处理..." : "任务正在处理中，请稍后~",
             state: "working",
         }).catch((err) => {
             error(`Failed to send initial status update:`, err);
@@ -155,32 +173,30 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // Send initial status update immediately after parsing message
-        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
-        void sendStatusUpdate({
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            text: "任务正在处理中，请稍后~",
-            state: "working",
-        }).catch((err) => {
-            error(`Failed to send initial status update:`, err);
-        });
-        // Create reply dispatcher (following feishu pattern)
-        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
+        // 🔑 创建dispatcher（dispatcher会自动使用动态taskId）
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
+        log(`[BOT-DISPATCHER]   - session: ${parsed.sessionId}`);
+        log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
+        log(`[BOT-DISPATCHER]   - isSecondMessage: ${isSecondMessage}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
             sessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            accountId: route.accountId, // ✅ Use route.accountId
+            accountId: route.accountId,
+            isSteerFollower: isSecondMessage, // 🔑 标记第二条消息
         });
         log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
-        // Start status update interval (will send updates every 60 seconds)
-        // Interval will be automatically stopped when onIdle/onCleanup is triggered
-        startStatusInterval();
+        // 🔑 只有第一条消息启动状态定时器
+        // 第二条消息会很快返回，不需要定时器
+        if (!isSecondMessage) {
+            startStatusInterval();
+            log(`[BOT-DISPATCHER] ✅ Status interval started for first message`);
+        }
+        else {
+            log(`[BOT-DISPATCHER] ⏭️  Skipped status interval for steer follower`);
+        }
         log(`xy: dispatching to agent (session=${parsed.sessionId})`);
         // Dispatch to OpenClaw core using correct API (following feishu pattern)
         log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
@@ -188,11 +204,18 @@ export async function handleXYMessage(params) {
             dispatcher,
             onSettled: () => {
                 log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                log(`[BOT]   - About to unregister session...`);
+                log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
                 markDispatchIdle();
-                // Unregister session context when done
+                // 🔑 减少引用计数
+                decrementTaskIdRef(parsed.sessionId);
+                // 🔑 如果是第一条消息完成，解锁
+                if (!isSecondMessage) {
+                    unlockTaskId(parsed.sessionId);
+                    log(`[BOT] 🔓 Unlocked taskId (first message completed)`);
+                }
+                // 减少session引用计数
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Session unregistered in onSettled`);
+                log(`[BOT] ✅ Cleanup completed`);
             },
             run: () => core.channel.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
@@ -209,25 +232,28 @@ export async function handleXYMessage(params) {
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
         log(`[BOT] ❌ Error occurred, attempting cleanup...`);
-        // Try to unregister session on error (if route was established)
+        // 🔑 错误时也要清理taskId和session
         try {
-            const core = getXYRuntime();
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
-                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
+                log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
+                // 清理 taskId
+                decrementTaskIdRef(sessionId);
+                unlockTaskId(sessionId);
+                // 清理 session
+                const core = getXYRuntime();
                 const route = core.channel.routing.resolveAgentRoute({
                     cfg,
                     channel: "xiaoyi-channel",
                     accountId,
                     peer: {
                         kind: "direct",
-                        id: sessionId, // ✅ Use sessionId for cleanup consistency
+                        id: sessionId,
                     },
                 });
-                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Session unregistered after error`);
+                log(`[BOT] ✅ Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {

package/dist/src/monitor.js

@@ -1,6 +1,8 @@
 import { resolveXYConfig } from "./config.js";
 import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
+import { parseA2AMessage } from "./parser.js";
+import { hasActiveTask } from "./task-manager.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -94,11 +96,39 @@ export async function monitorXYProvider(opts = {}) {
                     log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
                 }
             };
-            void enqueue(sessionId, task).catch((err) => {
-                // Error already logged in task, this is for queue failures
-                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
-                activeMessages.delete(messageKey);
-            });
+            // 🔑 核心改造：检测steer模式
+            // 需要提前解析消息以获取sessionId
+            try {
+                const parsed = parseA2AMessage(message);
+                const steerMode = cfg.messages?.queue?.mode === "steer";
+                const hasActiveRun = hasActiveTask(parsed.sessionId);
+                if (steerMode && hasActiveRun) {
+                    // Steer模式且有活跃任务：不入队列，直接并发执行
+                    log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
+                    log(`[MONITOR-HANDLER]   - sessionId: ${parsed.sessionId}`);
+                    log(`[MONITOR-HANDLER]   - Bypassing queue to allow message insertion`);
+                    void task().catch((err) => {
+                        error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+                else {
+                    // 正常模式：入队列串行执行
+                    log(`[MONITOR-HANDLER] 📋 NORMAL MODE: Enqueuing for messageKey=${messageKey}`);
+                    void enqueue(sessionId, task).catch((err) => {
+                        error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                        activeMessages.delete(messageKey);
+                    });
+                }
+            }
+            catch (parseErr) {
+                // 解析失败，回退到正常队列模式
+                error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
+                void enqueue(sessionId, task).catch((err) => {
+                    error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                    activeMessages.delete(messageKey);
+                });
+            }
         };
         const connectedHandler = (serverId) => {
             if (!loggedServers.has(serverId)) {

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,45 @@ 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}`);
+                log(`[PARTIAL REPLY] Partial reply chunk received, taskId: ${currentTaskId}`);
                 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)`);
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update`);
                     }
                 }
                 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,
     };
 }

package/dist/src/task-manager.d.ts

@@ -0,0 +1,55 @@
+interface TaskIdBinding {
+    sessionId: string;
+    currentTaskId: string;
+    currentMessageId: string;
+    refCount: number;
+    updatedAt: number;
+    locked: boolean;
+}
+/**
+ * 注册或更新session的活跃taskId
+ * 返回是否是更新（用于判断是否是第二条消息）
+ */
+export declare function registerTaskId(sessionId: string, taskId: string, messageId: string, options?: {
+    incrementRef?: boolean;
+}): {
+    isUpdate: boolean;
+    refCount: number;
+};
+/**
+ * 增加引用计数（消息开始处理时调用）
+ */
+export declare function incrementTaskIdRef(sessionId: string): void;
+/**
+ * 减少引用计数，当refCount=0时才真正清理
+ */
+export declare function decrementTaskIdRef(sessionId: string): void;
+/**
+ * 锁定taskId，防止被清理（第一个消息使用）
+ */
+export declare function lockTaskId(sessionId: string): void;
+/**
+ * 解锁taskId（第一个消息完成时使用）
+ */
+export declare function unlockTaskId(sessionId: string): void;
+/**
+ * 获取session的当前活跃taskId
+ */
+export declare function getCurrentTaskId(sessionId: string): string | null;
+/**
+ * 获取session的当前活跃messageId
+ */
+export declare function getCurrentMessageId(sessionId: string): string | null;
+/**
+ * 检查session是否有活跃的taskId
+ */
+export declare function hasActiveTask(sessionId: string): boolean;
+/**
+ * 获取完整的binding信息（用于调试）
+ */
+export declare function getTaskIdBinding(sessionId: string): TaskIdBinding | null;
+/**
+ * 强制清理（错误恢复用）
+ */
+export declare function forceCleanTaskId(sessionId: string): void;
+export {};

package/dist/src/task-manager.js

@@ -0,0 +1,136 @@
+// TaskId Manager - 管理session级别的活跃taskId
+// 支持动态切换taskId，用于steer模式下的消息插队
+import { logger } from "./utils/logger.js";
+/**
+ * Session到活跃TaskId的映射
+ * Key: sessionId (注意：这里用sessionId，不是sessionKey)
+ * Value: TaskIdBinding
+ */
+const activeTaskIds = new Map();
+/**
+ * 注册或更新session的活跃taskId
+ * 返回是否是更新（用于判断是否是第二条消息）
+ */
+export function registerTaskId(sessionId, taskId, messageId, options) {
+    logger.log(`[TASK_MANAGER] 📝 Registering/Updating taskId for session: ${sessionId}`);
+    logger.log(`[TASK_MANAGER]   - New taskId: ${taskId}`);
+    logger.log(`[TASK_MANAGER]   - New messageId: ${messageId}`);
+    logger.log(`[TASK_MANAGER]   - incrementRef: ${options?.incrementRef ?? false}`);
+    const existing = activeTaskIds.get(sessionId);
+    if (existing) {
+        logger.log(`[TASK_MANAGER]   - Previous taskId: ${existing.currentTaskId}`);
+        logger.log(`[TASK_MANAGER]   - Previous refCount: ${existing.refCount}`);
+        logger.log(`[TASK_MANAGER]   - 🔄 Switching taskId (steer mode detected)`);
+        // 更新taskId，但保持引用计数
+        existing.currentTaskId = taskId;
+        existing.currentMessageId = messageId;
+        existing.updatedAt = Date.now();
+        if (options?.incrementRef) {
+            existing.refCount++;
+            logger.log(`[TASK_MANAGER]   - Incremented refCount: ${existing.refCount}`);
+        }
+        logger.log(`[TASK_MANAGER]   - ✅ TaskId updated, refCount=${existing.refCount}`);
+        return { isUpdate: true, refCount: existing.refCount };
+    }
+    else {
+        // 新注册
+        const binding = {
+            sessionId,
+            currentTaskId: taskId,
+            currentMessageId: messageId,
+            refCount: 1,
+            updatedAt: Date.now(),
+            locked: false,
+        };
+        activeTaskIds.set(sessionId, binding);
+        logger.log(`[TASK_MANAGER]   - ✅ TaskId registered (new), refCount=1`);
+        return { isUpdate: false, refCount: 1 };
+    }
+}
+/**
+ * 增加引用计数（消息开始处理时调用）
+ */
+export function incrementTaskIdRef(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.refCount++;
+        logger.log(`[TASK_MANAGER] ➕ Incremented refCount for ${sessionId}: ${binding.refCount}`);
+    }
+}
+/**
+ * 减少引用计数，当refCount=0时才真正清理
+ */
+export function decrementTaskIdRef(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (!binding) {
+        logger.log(`[TASK_MANAGER] ⚠️  No binding found for ${sessionId}`);
+        return;
+    }
+    binding.refCount--;
+    logger.log(`[TASK_MANAGER] ➖ Decremented refCount for ${sessionId}: ${binding.refCount}`);
+    if (binding.refCount <= 0 && !binding.locked) {
+        logger.log(`[TASK_MANAGER] 🗑️  RefCount=0 and unlocked, clearing taskId`);
+        activeTaskIds.delete(sessionId);
+    }
+    else {
+        logger.log(`[TASK_MANAGER]   - Keeping binding (refCount=${binding.refCount}, locked=${binding.locked})`);
+    }
+}
+/**
+ * 锁定taskId，防止被清理（第一个消息使用）
+ */
+export function lockTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.locked = true;
+        logger.log(`[TASK_MANAGER] 🔒 Locked taskId for ${sessionId}`);
+    }
+}
+/**
+ * 解锁taskId（第一个消息完成时使用）
+ */
+export function unlockTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.locked = false;
+        logger.log(`[TASK_MANAGER] 🔓 Unlocked taskId for ${sessionId}`);
+        // 解锁后，如果refCount=0，立即清理
+        if (binding.refCount <= 0) {
+            logger.log(`[TASK_MANAGER] 🗑️  Unlocked and refCount=0, clearing taskId`);
+            activeTaskIds.delete(sessionId);
+        }
+    }
+}
+/**
+ * 获取session的当前活跃taskId
+ */
+export function getCurrentTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    return binding?.currentTaskId ?? null;
+}
+/**
+ * 获取session的当前活跃messageId
+ */
+export function getCurrentMessageId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    return binding?.currentMessageId ?? null;
+}
+/**
+ * 检查session是否有活跃的taskId
+ */
+export function hasActiveTask(sessionId) {
+    return activeTaskIds.has(sessionId);
+}
+/**
+ * 获取完整的binding信息（用于调试）
+ */
+export function getTaskIdBinding(sessionId) {
+    return activeTaskIds.get(sessionId) ?? null;
+}
+/**
+ * 强制清理（错误恢复用）
+ */
+export function forceCleanTaskId(sessionId) {
+    logger.log(`[TASK_MANAGER] ⚠️  Force clearing taskId for ${sessionId}`);
+    activeTaskIds.delete(sessionId);
+}

package/dist/src/tools/session-manager.js

@@ -1,6 +1,6 @@
 import { logger } from "../utils/logger.js";
 import { configManager } from "../utils/config-manager.js";
-// Map of sessionKey -> SessionContext
+// Map of sessionKey -> SessionContextWithRef
 const activeSessions = new Map();
 /**
  * Register a session context for tool access.
@@ -13,7 +13,22 @@ export function registerSession(sessionKey, context) {
     logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
     logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
     logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
-    activeSessions.set(sessionKey, context);
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        // 更新上下文，增加引用计数
+        existing.taskId = context.taskId;
+        existing.messageId = context.messageId;
+        existing.refCount++;
+        logger.log(`[SESSION_MANAGER]   - Updated existing, refCount=${existing.refCount}`);
+    }
+    else {
+        // 新建
+        activeSessions.set(sessionKey, {
+            ...context,
+            refCount: 1,
+        });
+        logger.log(`[SESSION_MANAGER]   - Created new, refCount=1`);
+    }
     logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
     logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
@@ -25,14 +40,18 @@ export function unregisterSession(sessionKey) {
     logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
     logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
     logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
-    // Get session context before deleting to clear associated pushId
-    const context = activeSessions.get(sessionKey);
-    const existed = activeSessions.delete(sessionKey);
-    // Clear cached pushId for this session
-    if (context) {
-        configManager.clearSession(context.sessionId);
+    const existing = activeSessions.get(sessionKey);
+    if (!existing) {
+        logger.log(`[SESSION_MANAGER]   - Session not found`);
+        return;
+    }
+    existing.refCount--;
+    logger.log(`[SESSION_MANAGER]   - Decremented refCount: ${existing.refCount}`);
+    if (existing.refCount <= 0) {
+        activeSessions.delete(sessionKey);
+        configManager.clearSession(existing.sessionId);
+        logger.log(`[SESSION_MANAGER]   - Deleted (refCount=0)`);
     }
-    logger.log(`[SESSION_MANAGER]   - Deleted: ${existed}`);
     logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
     logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
@@ -43,12 +62,15 @@ export function unregisterSession(sessionKey) {
 export function getSessionContext(sessionKey) {
     logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
     logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
-    const context = activeSessions.get(sessionKey) ?? null;
-    logger.log(`[SESSION_MANAGER]   - Found: ${context !== null}`);
-    if (context) {
-        logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    const contextWithRef = activeSessions.get(sessionKey) ?? null;
+    logger.log(`[SESSION_MANAGER]   - Found: ${contextWithRef !== null}`);
+    if (contextWithRef) {
+        logger.log(`[SESSION_MANAGER]   - sessionId: ${contextWithRef.sessionId}`);
+        // 返回时去掉refCount字段
+        const { refCount, ...context } = contextWithRef;
+        return context;
     }
-    return context;
+    return null;
 }
 /**
  * Get the most recent session context.
@@ -65,10 +87,12 @@ export function getLatestSessionContext() {
     }
     // Return the last added session
     const sessions = Array.from(activeSessions.values());
-    const latestSession = sessions[sessions.length - 1];
+    const latestSessionWithRef = sessions[sessions.length - 1];
     logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
-    logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSession.sessionId}`);
-    logger.log(`[SESSION_MANAGER]     - taskId: ${latestSession.taskId}`);
-    logger.log(`[SESSION_MANAGER]     - messageId: ${latestSession.messageId}`);
+    logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSessionWithRef.sessionId}`);
+    logger.log(`[SESSION_MANAGER]     - taskId: ${latestSessionWithRef.taskId}`);
+    logger.log(`[SESSION_MANAGER]     - messageId: ${latestSessionWithRef.messageId}`);
+    // 返回时去掉refCount字段
+    const { refCount, ...latestSession } = latestSessionWithRef;
     return latestSession;
 }

package/dist/src/tools/xiaoyi-gui-tool.js

@@ -21,18 +21,18 @@ export const xiaoyiGuiTool = {
 - 需要在APP中发布或发送内容
 - 需要修改APP或手机设置
 
-理论上，所有可以通过人在手机上操作完成的任务，该Agent都可以尝试执行。
-
 注意事项：
-- 操作超时时间为5分钟（300秒）
+- 操作超时时间为3分钟（180秒）
 - 该工具执行时间较长，请勿重复调用
-- 如果超时或失败，最多重试一次`,
+- 该工具执行期间不要执行别的工具调用，必须等到该工具有结果返回或者超时之后才能执行别的操作，无论是新的文本回复还是下一步的工具调用，在此工具执行期间必须严格等待
+- 如果超时或失败，最多重试一次
+- 如果用户指令中包含备忘录读写，日程查看，不需要将这类操作放在gui tool的query参数中，需要使用预置的note相关工具与calendar相关工具完成相关操作`,
     parameters: {
         type: "object",
         properties: {
             query: {
                 type: "string",
-                description: "操作手机的指令以及期望返回的结果。例如：'打开微信，查看最新一条消息的内容' 或 '在设置中开启蓝牙'",
+                description: "操作手机的指令以及期望返回的结果。",
             },
         },
         required: ["query"],
@@ -87,7 +87,7 @@ export const xiaoyiGuiTool = {
                 logger.error(`[XIAOYI_GUI_TOOL] ⏰ Timeout: No response received within 300 seconds (5 minutes)`);
                 wsManager.off("gui-agent-response", handler);
                 reject(new Error("XiaoYi GUI Agent 操作超时（5分钟）"));
-            }, 300000); // 5 minutes timeout
+            }, 180000); // 5 minutes timeout
             // Listen for GUI agent response events
             const handler = (event) => {
                 logger.log(`[XIAOYI_GUI_TOOL] 📨 Received event:`, JSON.stringify(event));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.24-beta",
+  "version": "0.0.26-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",