@ynhcj/xiaoyi-channel 1.1.6 → 1.1.8

package/dist/src/bot.js

@@ -4,8 +4,9 @@ import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
-import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { registerSession, unregisterSession, runWithSessionContext } 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,51 +173,66 @@ 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}`);
+        // Build session context for AsyncLocalStorage
+        const sessionContext = {
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            agentId: route.accountId,
+        };
         await core.channel.reply.withReplyDispatcher({
             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({
+            run: () => 
+            // 🔐 Use AsyncLocalStorage to provide session context to tools
+            runWithSessionContext(sessionContext, () => core.channel.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
                 cfg,
                 dispatcher,
                 replyOptions,
-            }),
+            })),
         });
         log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);
@@ -209,25 +242,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/channel.js

@@ -8,9 +8,20 @@ import { searchNoteTool } from "./tools/search-note-tool.js";
 import { modifyNoteTool } from "./tools/modify-note-tool.js";
 import { calendarTool } from "./tools/calendar-tool.js";
 import { searchCalendarTool } from "./tools/search-calendar-tool.js";
-// import { searchContactTool } from "./tools/search-contact-tool.js"; // 暂时禁用
+import { searchContactTool } from "./tools/search-contact-tool.js";
 import { searchPhotoGalleryTool } from "./tools/search-photo-gallery-tool.js";
 import { uploadPhotoTool } from "./tools/upload-photo-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { callPhoneTool } from "./tools/call-phone-tool.js";
+import { searchMessageTool } from "./tools/search-message-tool.js";
+import { searchFileTool } from "./tools/search-file-tool.js";
+import { uploadFileTool } from "./tools/upload-file-tool.js";
+import { createAlarmTool } from "./tools/create-alarm-tool.js";
+import { searchAlarmTool } from "./tools/search-alarm-tool.js";
+import { modifyAlarmTool } from "./tools/modify-alarm-tool.js";
+import { deleteAlarmTool } from "./tools/delete-alarm-tool.js";
+import { sendMessageTool } from "./tools/send-message-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -50,7 +61,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool], // searchContactTool 已暂时禁用
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendMessageTool, sendFileToUserTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

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/outbound.js

@@ -1,7 +1,6 @@
 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";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -65,8 +64,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}`);
@@ -130,81 +129,94 @@ export const xyOutbound = {
             mediaUrl,
             mediaLocalRoots,
         });
-        // Parse to: "sessionId::taskId"
-        const parts = to.split("::");
-        if (parts.length !== 2) {
-            throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
-        }
-        const [sessionId, taskId] = parts;
-        // Resolve configuration
-        const config = resolveXYConfig(cfg);
-        // Create upload service
-        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-        // Validate mediaUrl
-        if (!mediaUrl) {
-            throw new Error("mediaUrl is required for sendMedia");
-        }
-        // Upload file
-        const fileId = await uploadService.uploadFile(mediaUrl);
-        // Check if fileId is empty
-        if (!fileId) {
-            console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
-            return {
-                channel: "xiaoyi-channel",
-                messageId: "",
-                chatId: to,
-            };
-        }
-        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
-            fileId,
-            sessionId,
-            taskId,
-        });
-        // Get filename and mime type from mediaUrl
-        // mediaUrl may be a local file path or URL
-        const fileName = mediaUrl.split("/").pop() || "unknown";
-        const mimeType = getMimeTypeFromFilename(fileName);
-        // Build agent_response message
-        const agentResponse = {
-            msgType: "agent_response",
-            agentId: config.agentId,
-            sessionId: sessionId,
-            taskId: taskId,
-            msgDetail: JSON.stringify({
-                jsonrpc: "2.0",
-                id: taskId,
-                result: {
-                    kind: "artifact-update",
-                    append: true,
-                    lastChunk: false,
-                    final: false,
-                    artifact: {
-                        artifactId: taskId,
-                        parts: [
-                            {
-                                kind: "file",
-                                file: {
-                                    name: fileName,
-                                    mimeType: mimeType,
-                                    fileId: fileId,
-                                },
-                            },
-                        ],
-                    },
-                },
-                error: { code: 0 },
-            }),
-        };
-        // Get WebSocket manager and send message
-        const { getXYWebSocketManager } = await import("./client.js");
-        const wsManager = getXYWebSocketManager(config);
-        await wsManager.sendMessage(sessionId, agentResponse);
-        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
-        // Return message info
+        // All sendMedia processing logic has been disabled
+        // Use send_file_to_user tool instead for file transfers to user device
+        console.log(`[xyOutbound.sendMedia] Processing disabled, use send_file_to_user tool`);
+        // Return empty message info
         return {
             channel: "xiaoyi-channel",
-            messageId: fileId,
+            messageId: "把文件/图片发送给用户请使用send_file_to_user工具",
             chatId: to,
         };
+        // // Parse to: "sessionId::taskId"
+        // const parts = to.split("::");
+        // if (parts.length !== 2) {
+        //   throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
+        // }
+        // const [sessionId, taskId] = parts;
+        // // Resolve configuration
+        // const config = resolveXYConfig(cfg);
+        // // Create upload service
+        // const uploadService = new XYFileUploadService(
+        //   config.fileUploadUrl,
+        //   config.apiKey,
+        //   config.uid
+        // );
+        // // Validate mediaUrl
+        // if (!mediaUrl) {
+        //   throw new Error("mediaUrl is required for sendMedia");
+        // }
+        // // Upload file
+        // const fileId = await uploadService.uploadFile(mediaUrl);
+        // // Check if fileId is empty
+        // if (!fileId) {
+        //   console.log(`[xyOutbound.sendMedia] ⚠️ File upload failed: fileId is empty, aborting sendMedia`);
+        //   return {
+        //     channel: "xiaoyi-channel",
+        //     messageId: "",
+        //     chatId: to,
+        //   };
+        // }
+        // console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+        //   fileId,
+        //   sessionId,
+        //   taskId,
+        // });
+        // // Get filename and mime type from mediaUrl
+        // // mediaUrl may be a local file path or URL
+        // const fileName = mediaUrl.split("/").pop() || "unknown";
+        // const mimeType = getMimeTypeFromFilename(fileName);
+        // // Build agent_response message
+        // const agentResponse: OutboundWebSocketMessage = {
+        //   msgType: "agent_response",
+        //   agentId: config.agentId,
+        //   sessionId: sessionId,
+        //   taskId: taskId,
+        //   msgDetail: JSON.stringify({
+        //     jsonrpc: "2.0",
+        //     id: taskId,
+        //     result: {
+        //       kind: "artifact-update",
+        //       append: true,
+        //       lastChunk: false,
+        //       final: false,
+        //       artifact: {
+        //         artifactId: taskId,
+        //         parts: [
+        //           {
+        //             kind: "file",
+        //             file: {
+        //               name: fileName,
+        //               mimeType: mimeType,
+        //               fileId: fileId,
+        //             },
+        //           },
+        //         ],
+        //       },
+        //     },
+        //     error: { code: 0 },
+        //   }),
+        // };
+        // // Get WebSocket manager and send message
+        // const { getXYWebSocketManager } = await import("./client.js");
+        // const wsManager = getXYWebSocketManager(config);
+        // await wsManager.sendMessage(sessionId, agentResponse);
+        // console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        // // Return message info
+        // return {
+        //   channel: "xiaoyi-channel",
+        //   messageId: fileId,
+        //   chatId: to,
+        // };
     },
 };

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.