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

package/dist/src/bot.js

@@ -4,7 +4,7 @@ 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";
 /**
@@ -200,6 +200,14 @@ export async function handleXYMessage(params) {
         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: () => {
@@ -217,12 +225,14 @@ export async function handleXYMessage(params) {
                 unregisterSession(route.sessionKey);
                 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})`);

package/dist/src/channel.js

@@ -12,6 +12,16 @@ import { searchCalendarTool } from "./tools/search-calendar-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.
@@ -51,7 +61,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool], // searchContactTool 已暂时禁用
+    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendMessageTool, sendFileToUserTool], // searchContactTool 已暂时禁用
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

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: "",
             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/tools/calendar-tool.js

@@ -1,6 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { logger } from "../utils/logger.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
@@ -54,7 +54,7 @@ export const calendarTool = {
         logger.log(`[CALENDAR_TOOL]   - dtEnd timestamp: ${dtEndMs}`);
         // Get session context
         logger.log(`[CALENDAR_TOOL] 🔍 Attempting to get session context...`);
-        const sessionContext = getLatestSessionContext();
+        const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
             logger.error(`[CALENDAR_TOOL] ❌ FAILED: No active session found!`);
             logger.error(`[CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);

package/dist/src/tools/call-phone-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY call phone tool - makes a phone call on user's device.
+ * Requires phoneNumber parameter and optional slotId (0 for primary SIM, 1 for secondary SIM).
+ */
+export declare const callPhoneTool: any;

package/dist/src/tools/call-phone-tool.js

@@ -0,0 +1,183 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY call phone tool - makes a phone call on user's device.
+ * Requires phoneNumber parameter and optional slotId (0 for primary SIM, 1 for secondary SIM).
+ */
+export const callPhoneTool = {
+    name: "call_phone",
+    label: "Call Phone",
+    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            phoneNumber: {
+                type: "string",
+                description: "要拨打的电话号码",
+            },
+            slotId: {
+                type: "number",
+                description: "SIM卡槽ID，默认为0（主卡），设置为1表示副卡。仅当用户明确要求使用副卡时才设置为1",
+                default: 0,
+            },
+        },
+        required: ["phoneNumber"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[CALL_PHONE_TOOL] 🚀 Starting execution`);
+        logger.log(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[CALL_PHONE_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[CALL_PHONE_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate phoneNumber parameter
+        if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
+            logger.error(`[CALL_PHONE_TOOL] ❌ Missing or invalid phoneNumber parameter`);
+            throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
+        }
+        // Set default slotId if not provided
+        const slotId = params.slotId !== undefined && params.slotId !== null ? params.slotId : 0;
+        // Validate slotId (must be 0 or 1)
+        if (slotId !== 0 && slotId !== 1) {
+            logger.error(`[CALL_PHONE_TOOL] ❌ Invalid slotId: ${slotId}`);
+            throw new Error("Invalid slotId: must be 0 (primary SIM) or 1 (secondary SIM)");
+        }
+        logger.log(`[CALL_PHONE_TOOL] 📞 Preparing to call phone number: ${params.phoneNumber}`);
+        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId} (${slotId === 0 ? "主卡" : "副卡"})`);
+        // Get session context
+        logger.log(`[CALL_PHONE_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            logger.error(`[CALL_PHONE_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Call phone tool can only be used during an active conversation.");
+        }
+        logger.log(`[CALL_PHONE_TOOL] ✅ Session context found`);
+        logger.log(`[CALL_PHONE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[CALL_PHONE_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[CALL_PHONE_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[CALL_PHONE_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[CALL_PHONE_TOOL] ✅ WebSocket manager obtained`);
+        // Build StartCall command
+        logger.log(`[CALL_PHONE_TOOL] 📦 Building StartCall command...`);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "StartCall",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        phoneNumber: params.phoneNumber.trim(),
+                        slotId: slotId,
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        logger.log(`[CALL_PHONE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[CALL_PHONE_TOOL] ⏳ Setting up promise to wait for call response...`);
+        logger.log(`[CALL_PHONE_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[CALL_PHONE_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("拨打电话超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[CALL_PHONE_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "StartCall") {
+                    logger.log(`[CALL_PHONE_TOOL] 🎯 StartCall event received`);
+                    logger.log(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[CALL_PHONE_TOOL] ✅ Call response received`);
+                        logger.log(`[CALL_PHONE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Check for error code in outputs
+                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
+                        if (code !== null && code !== 0) {
+                            logger.error(`[CALL_PHONE_TOOL] ❌ Device returned error`);
+                            logger.error(`[CALL_PHONE_TOOL]   - code: ${code}`);
+                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
+                            logger.error(`[CALL_PHONE_TOOL]   - errorMsg: ${errorMsg}`);
+                            reject(new Error(`拨打电话失败: ${errorMsg} (错误代码: ${code})`));
+                            return;
+                        }
+                        // Return the outputs directly
+                        const result = {
+                            success: true,
+                            code: code,
+                            phoneNumber: params.phoneNumber,
+                            slotId: slotId,
+                            message: "电话拨打成功",
+                        };
+                        logger.log(`[CALL_PHONE_TOOL] 🎉 Call initiated successfully`);
+                        logger.log(`[CALL_PHONE_TOOL]   - phoneNumber: ${params.phoneNumber}`);
+                        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[CALL_PHONE_TOOL] ❌ Call failed`);
+                        logger.error(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
+                        logger.error(`[CALL_PHONE_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
+                        const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
+                        reject(new Error(`拨打电话失败: ${errorDetail}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[CALL_PHONE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[CALL_PHONE_TOOL] 📤 Sending StartCall command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[CALL_PHONE_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[CALL_PHONE_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/create-alarm-tool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * XY create alarm tool - creates an alarm on user's device.
+ * Requires alarmTime parameter. Other parameters are optional with sensible defaults.
+ *
+ * Time format: YYYYMMDD hhmmss (e.g., 20240315 143000)
+ */
+export declare const createAlarmTool: any;