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

package/dist/src/reply-dispatcher.js

@@ -2,63 +2,70 @@ 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,
-                text: "任务正在处理中，请稍后~",
+                taskId: currentTaskId, // 🔑 动态taskId
+                messageId: currentMessageId, // 🔑 动态messageId
+                text: "任务正在处理中，请稍候~",
                 state: "working",
             }).catch((err) => {
                 error(`Failed to send status update:`, err);
             });
         }, 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,
     };
 }

package/dist/src/steer-injector.d.ts

@@ -0,0 +1,16 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * 在 handleXYMessage 入口处调用，缓存 cfg/runtime 供 steer 注入使用。
+ */
+export declare function setCachedContext(cfg: ClawdbotConfig, runtime: RuntimeEnv, accountId: string): void;
+/**
+ * 尝试向当前活跃会话注入 steer 消息。
+ * 两层保险：
+ *   1. getSessionContext(sessionKey) 确认是当前 XY 活跃 session
+ *   2. hasActiveTask(sessionId) 确认任务仍在运行
+ *
+ * @param sessionKey  来自 after_tool_call ctx.sessionKey（per-peer 下精确对应一个 XY session）
+ * @param message     要注入的用户消息文本
+ * @returns           true=已注入，false=跳过
+ */
+export declare function tryInjectSteer(sessionKey: string | undefined, message: string): Promise<boolean>;

package/dist/src/steer-injector.js

@@ -0,0 +1,74 @@
+// Steer message injector for CSPL hook integration
+import { getSessionContext } from "./tools/session-manager.js";
+import { hasActiveTask, getCurrentTaskId } from "./task-manager.js";
+import { handleXYMessage } from "./bot.js";
+import { logger } from "./utils/logger.js";
+import { randomUUID } from "node:crypto";
+let cachedCfg = null;
+let cachedRuntime = null;
+let cachedAccountId = "default";
+/**
+ * 在 handleXYMessage 入口处调用，缓存 cfg/runtime 供 steer 注入使用。
+ */
+export function setCachedContext(cfg, runtime, accountId) {
+    cachedCfg = cfg;
+    cachedRuntime = runtime;
+    cachedAccountId = accountId;
+}
+/**
+ * 尝试向当前活跃会话注入 steer 消息。
+ * 两层保险：
+ *   1. getSessionContext(sessionKey) 确认是当前 XY 活跃 session
+ *   2. hasActiveTask(sessionId) 确认任务仍在运行
+ *
+ * @param sessionKey  来自 after_tool_call ctx.sessionKey（per-peer 下精确对应一个 XY session）
+ * @param message     要注入的用户消息文本
+ * @returns           true=已注入，false=跳过
+ */
+export async function tryInjectSteer(sessionKey, message) {
+    if (!sessionKey) {
+        return false;
+    }
+    const sessionCtx = getSessionContext(sessionKey);
+    if (!sessionCtx) {
+        return false;
+    }
+    const { sessionId } = sessionCtx;
+    const activeTaskId = getCurrentTaskId(sessionId);
+    if (!hasActiveTask(sessionId)) {
+        return false;
+    }
+    if (!cachedCfg || !cachedRuntime) {
+        logger.error("[STEER] No cached cfg/runtime available, cannot inject");
+        return false;
+    }
+    // 3. 构造合成 A2A 消息（伪装成用户在当前会话中发送的新消息）
+    const syntheticMessage = {
+        jsonrpc: "2.0",
+        method: "tasks/send",
+        id: `steer-msg-${randomUUID()}`,
+        params: {
+            sessionId,
+            id: activeTaskId ?? `steer-task-${randomUUID()}`,
+            agentLoginSessionId: "",
+            message: {
+                role: "user",
+                parts: [{ kind: "text", text: message }],
+            },
+        },
+    };
+    console.log(`[STEER] Injecting steer for sessionId=${sessionId}, taskId=${syntheticMessage.params.id}`);
+    try {
+        await handleXYMessage({
+            cfg: cachedCfg,
+            runtime: cachedRuntime,
+            message: syntheticMessage,
+            accountId: cachedAccountId,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[STEER] ❌ Failed to inject steer: ${err}`);
+        return false;
+    }
+}

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 {};