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

package/dist/src/reply-dispatcher.js

@@ -2,7 +2,7 @@ import { getXYRuntime } from "./runtime.js";
 import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate, sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
-import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { clearRunCrossTaskSentFiles, getCurrentSessionContext } from "./tools/session-manager.js";
 import fs from "fs/promises";
 import path from "path";
 import { logger } from "./utils/logger.js";
@@ -23,7 +23,7 @@ function buildDistributionStatusCommand(context) {
         },
     };
 }
-function buildCrossTaskExecuteResultCommand(code, message, fileUrls = []) {
+function buildCrossTaskExecuteResultCommand(code, message, sentFiles = []) {
     return {
         header: {
             namespace: "DistributionInteraction",
@@ -32,15 +32,15 @@ function buildCrossTaskExecuteResultCommand(code, message, fileUrls = []) {
         payload: {
             code,
             message,
-            fileUrls,
+            sentFiles,
         },
     };
 }
 async function sendRunCrossTaskResult(params) {
     const { config, sessionId, taskId, messageId, context, resultCode, resultMessage } = params;
-    const fileUrls = Array.isArray(context.fileUrls) ? context.fileUrls : [];
+    const sentFiles = Array.isArray(context.sentFiles) ? context.sentFiles : [];
     const statusCommand = buildDistributionStatusCommand(context);
-    const resultCommand = buildCrossTaskExecuteResultCommand(resultCode, resultMessage, fileUrls);
+    const resultCommand = buildCrossTaskExecuteResultCommand(resultCode, resultMessage, sentFiles);
     await sendCommand({
         config,
         sessionId,
@@ -48,7 +48,8 @@ async function sendRunCrossTaskResult(params) {
         messageId,
         commands: [statusCommand, resultCommand],
     });
-    logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, fileUrlCount=${fileUrls.length}, messageLength=${resultMessage.length}`);
+    clearRunCrossTaskSentFiles(context);
+    logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, sentFileCount=${sentFiles.length}, clearedSentFileCount=${sentFiles.length}, messageLength=${resultMessage.length}`);
 }
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
@@ -115,6 +116,8 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     let finalSent = false;
     let accumulatedText = "";
+    let accumulatedReasoningHistory = "";
+    let lastReasoningText = "";
     const initialRunCrossTaskContext = getCurrentSessionContext()?.runCrossTaskContext;
     const getRunCrossTaskContext = () => {
         return getCurrentSessionContext()?.runCrossTaskContext ?? initialRunCrossTaskContext;
@@ -171,18 +174,23 @@ export function createXYReplyDispatcher(params) {
                     scopedLog().log(`[DELIVER SKIP] Empty text, skipping`);
                     return;
                 }
+                // 🔑 如果 onPartialReply 已经流式发送过文本，deliver 不再重复发送
+                if (hasSentResponse) {
+                    scopedLog().log(`[DELIVER SKIP] Already sent via onPartialReply`);
+                    return;
+                }
                 accumulatedText += text;
                 hasSentResponse = true;
-                scopedLog().log(`[DELIVER] Accumulated text, length=${accumulatedText.length}`);
-                // 🔑 使用动态taskId发送reasoningText更新
-                await sendReasoningTextUpdate({
+                // 🔑 使用动态taskId发送A2A响应（流式append）
+                await sendA2AResponse({
                     config,
                     sessionId,
                     taskId: currentTaskId,
                     messageId: currentMessageId,
                     text,
+                    append: true,
+                    final: false,
                 });
-                scopedLog().log(`[DELIVER] Sent deliver text as reasoningText update`);
             }
             catch (deliverError) {
                 scopedLog().error(`Failed to deliver message:`, deliverError);
@@ -250,18 +258,18 @@ export function createXYReplyDispatcher(params) {
                         state: "completed",
                     });
                     scopedLog().log(`[ON-IDLE] Sent completion status update`);
-                    // 🔑 使用动态taskId发送最终响应
+                    // 🔑 使用动态taskId发送最终响应（空字符串表示流结束）
                     await sendA2AResponse({
                         config,
                         sessionId,
                         taskId: currentTaskId,
                         messageId: currentMessageId,
-                        text: accumulatedText,
-                        append: false,
+                        text: "",
+                        append: true,
                         final: true,
                     });
                     finalSent = true;
-                    scopedLog().log(`[ON-IDLE] Sent final response`);
+                    scopedLog().log(`[ON-IDLE] Sent final response (empty, stream end)`);
                 }
                 catch (err) {
                     scopedLog().error(`[ON-IDLE] Failed to send final response:`, err);
@@ -298,7 +306,7 @@ export function createXYReplyDispatcher(params) {
                         taskId: currentTaskId,
                         messageId: currentMessageId,
                         text: "任务执行异常，请重试~",
-                        append: false,
+                        append: true,
                         final: true,
                         errorCode: 99921111,
                         errorMessage: "任务执行异常，请重试",
@@ -321,6 +329,7 @@ export function createXYReplyDispatcher(params) {
         dispatcher,
         replyOptions: {
             ...replyOptions,
+            suppressToolErrorWarnings: true,
             onModelSelected: prefixContext.onModelSelected,
             onToolStart: async ({ name, phase }) => {
                 // 🔑 steered dispatch不发送tool状态（让主dispatcher处理）
@@ -387,10 +396,43 @@ export function createXYReplyDispatcher(params) {
                 if (steerState.steered) {
                     return;
                 }
-                const text = payload.text ?? "";
-                scopedLog().log(`[REASONING-STREAM] Reasoning chunk received, text.length: ${text.length}`);
-                // Reasoning stream 目前被注释掉
-                // 如果需要可以启用
+                const currentTaskId = getActiveTaskId();
+                const currentMessageId = getActiveMessageId();
+                let text = payload.text ?? "";
+                // Strip "Reasoning:" prefix that some reasoning models add to their thinking output
+                const lines = text.split(/\r?\n/);
+                if (lines[0]?.trim() === "Reasoning:") {
+                    text = lines.slice(1).join("\n").trim();
+                }
+                try {
+                    if (text.length > 0) {
+                        // 🔑 检测是否是新一轮思考：当前text比上一次短，或不以上次内容开头
+                        const isNewRound = lastReasoningText.length > 0 &&
+                            text.length < lastReasoningText.length;
+                        if (isNewRound) {
+                            // 将上一轮思考追加到历史
+                            accumulatedReasoningHistory += (accumulatedReasoningHistory ? "\n\n" : "") + lastReasoningText;
+                        }
+                        // 更新当前轮最后一次text
+                        lastReasoningText = text;
+                        // 🔑 拼接历史 + 当前轮内容
+                        const fullText = accumulatedReasoningHistory
+                            ? accumulatedReasoningHistory + "\n\n" + text
+                            : text;
+                        // 🔑 将模型真实的thinking/reasoning内容通过reasoningText转发
+                        await sendReasoningTextUpdate({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            text: fullText,
+                            append: false,
+                        });
+                    }
+                }
+                catch (err) {
+                    scopedLog().error(`[REASONING-STREAM] Failed to send reasoning text:`, err);
+                }
             },
             onPartialReply: async (payload) => {
                 // 🔑 steered dispatch不发送partial reply（让主dispatcher处理）
@@ -402,18 +444,22 @@ export function createXYReplyDispatcher(params) {
                 const text = payload.text ?? "";
                 try {
                     if (text.length > 0) {
-                        await sendReasoningTextUpdate({
+                        accumulatedText += text;
+                        hasSentResponse = true;
+                        await sendA2AResponse({
                             config,
                             sessionId,
                             taskId: currentTaskId,
                             messageId: currentMessageId,
                             text,
                             append: false,
+                            final: false,
+                            log: false,
                         });
                     }
                 }
                 catch (err) {
-                    scopedLog().error(`[PARTIAL REPLY] Failed to send partial reply:`, err);
+                    scopedLog().error(`[PARTIAL-REPLY] Failed to send partial reply:`, err);
                 }
             },
         },

package/dist/src/self-evolution-handler.d.ts

@@ -1,5 +1,5 @@
 import type { XYWebSocketManager } from "./websocket.js";
-export declare function handleSelfEvolutionEvent(context: any, runtime: any): void;
+export declare function handleSelfEvolutionEvent(context: any, cfg: any): Promise<void>;
 /**
  * 读取 .xiaoyiruntime 中的 selfEvolutionState 并直接通过 wsManager 下发指令回复设备
  * 参考trigger实现：直接使用当前已连接的 wsManager 发送消息，避免 getXYWebSocketManager 返回未连接实例

package/dist/src/self-evolution-handler.js

@@ -1,14 +1,20 @@
 import { readFileSync, writeFileSync } from "fs";
 import { v4 as uuidv4 } from "uuid";
+import { resolveXYConfig } from "./config.js";
+import { sendA2AResponse } from "./formatter.js";
 import { logger } from "./utils/logger.js";
 const XIAOYIRUNTIME_PATH = "/home/sandbox/.openclaw/.xiaoyiruntime";
-export function handleSelfEvolutionEvent(context, runtime) {
+export async function handleSelfEvolutionEvent(context, cfg) {
     try {
         const state = context.event?.payload?.selfEvolutionState;
         if (typeof state !== "string") {
             logger.error("[SELF_EVOLUTION] invalid payload: missing selfEvolutionState");
             return;
         }
+        const sessionId = context.sessionId ?? "";
+        const taskId = context.taskId ?? sessionId;
+        const messageId = context.messageId ?? uuidv4();
+        const config = resolveXYConfig(cfg);
         logger.log(`[SELF_EVOLUTION] received state: ${state}`);
         let content;
         try {
@@ -19,6 +25,8 @@ export function handleSelfEvolutionEvent(context, runtime) {
             logger.log(`[SELF_EVOLUTION] ${XIAOYIRUNTIME_PATH} not found, creating new file`);
             writeFileSync(XIAOYIRUNTIME_PATH, `selfEvolutionState=${state}\n`, "utf-8");
             logger.log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
+            await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+            logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
             return;
         }
         const lines = content.split("\n");
@@ -40,6 +48,9 @@ export function handleSelfEvolutionEvent(context, runtime) {
             writeFileSync(XIAOYIRUNTIME_PATH, updated.join("\n"), "utf-8");
         }
         logger.log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIRUNTIME_PATH}`);
+        // Reply with final empty response to acknowledge the state update
+        await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+        logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
     }
     catch (err) {
         logger.error("[SELF_EVOLUTION] failed to handle event:", err);

package/dist/src/tools/calendar-tool.js

@@ -106,7 +106,7 @@ export function createCalendarTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`创建日程失败: ${event.status}`));
+                            reject(new Error(`创建日程失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };

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

@@ -22,7 +22,6 @@ import { createUploadFileTool } from "./upload-file-tool.js";
 import { createSaveFileToPhoneTool } from "./save-file-to-phone-tool.js";
 import { createSendEmailTool } from "./send-email-tool.js";
 import { createSearchEmailTool } from "./search-email-tool.js";
-import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
 import { sendStatusUpdate } from "../formatter.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 /**
@@ -55,7 +54,6 @@ export function createCallDeviceTool(ctx) {
     const searchFileTool = createSearchFileTool(ctx);
     const saveFileToPhoneTool = createSaveFileToPhoneTool(ctx);
     const searchEmailTool = createSearchEmailTool(ctx);
-    const findPcDevicesTool = createFindPcDevicesTool(ctx);
     /**
      * 端工具注册表 —— 按 name 索引所有可通过 call_device_tool 调度的工具。
      */
@@ -84,7 +82,6 @@ export function createCallDeviceTool(ctx) {
         [saveFileToPhoneTool.name, saveFileToPhoneTool],
         [sendEmailTool.name, sendEmailTool],
         [searchEmailTool.name, searchEmailTool],
-        [findPcDevicesTool.name, findPcDevicesTool],
     ]);
     return {
         name: "call_device_tool",

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

@@ -98,7 +98,7 @@ export function createCallPhoneTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`拨打电话失败: ${event.status}`));
+                            reject(new Error(`拨打电话失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };

package/dist/src/tools/check-plugin-privilege-tool.d.ts

@@ -0,0 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * XY check plugin privilege tool - checks user authorization for device-side tools
+ * used in scheduled tasks.
+ */
+export declare function createCheckPluginPrivilegeTool(ctx: SessionContext): any;

package/dist/src/tools/check-plugin-privilege-tool.js

@@ -0,0 +1,182 @@
+// Check plugin privilege tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Mapping from intent name to required permission IDs.
+ */
+const INTENT_PERMISSION_MAP = {
+    GetCurrentLocation: ["ohos.permission.LOCATION", "ohos.permission.APPROXIMATELY_LOCATION"],
+    SearchCalendarEvent: ["ohos.permission.READ_WHOLE_CALENDAR"],
+    CreateCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    DeleteCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    ModifyCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    SearchNote: ["ohos.permission.READ_NOTE"],
+    CreateNote: ["ohos.permission.WRITE_NOTE"],
+    ModifyNote: ["ohos.permission.WRITE_NOTE"],
+    SearchContactLocal: ["ohos.permission.READ_CONTACTS"],
+    SearchPhotoVideo: ["ohos.permission.READ_IMAGEVIDEO"],
+    SaveMediaToGallery: ["ohos.permission.WRITE_IMAGEVIDEO"],
+    SearchFile: ["ohos.permission.FILE_ACCESS_MANAGER"],
+    SaveFileToFileManager: ["ohos.permission.FILE_SAVE_MANAGER"],
+    SearchAlarm: ["ohos.permission.READ_ALARM"],
+    CreateAlarm: ["ohos.permission.WRITE_ALARM"],
+    ModifyAlarm: ["ohos.permission.WRITE_ALARM"],
+    DeleteAlarm: ["ohos.permission.WRITE_ALARM"],
+    SearchMessage: ["ohos.permission.READ_SMS"],
+    SendShortMessage: ["ohos.permission.SEND_MESSAGES"],
+    StartCall: ["ohos.permission.PLACE_CALL"],
+};
+/**
+ * XY check plugin privilege tool - checks user authorization for device-side tools
+ * used in scheduled tasks.
+ */
+export function createCheckPluginPrivilegeTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "check_plugin_privilege",
+        label: "Check Plugin Privilege",
+        description: "定时任务权限检查工具。" +
+            "【使用场景】仅在创建定时任务时使用，严禁在其他场景调用。当识别到定时任务中需要使用用户设备侧工具时，必须调用此工具进行权限检查。" +
+            "【调用前提】调用此工具前，必须确认用户定时任务中提到的工具在当前模型可使用的工具列表中存在。如果当前工具列表中不存在符合用户诉求的工具定义，则不要调用此工具，而是直接告知用户当前设备不支持该功能。" +
+            "【支持的意图名称及对应权限】" +
+            "GetCurrentLocation（获取用户位置）, " +
+            "SearchCalendarEvent（搜索用户日程）, " +
+            "CreateCalendarEvent（新建用户日程）, " +
+            "DeleteCalendarEvent（删除用户日程）, " +
+            "ModifyCalendarEvent（修改用户日程）, " +
+            "SearchNote（搜索用户备忘录）, " +
+            "CreateNote（新建用户备忘录）, " +
+            "ModifyNote（修改用户备忘录）, " +
+            "SearchContactLocal（搜索用户联系人）, " +
+            "SearchPhotoVideo（搜索用户图库照片或视频）, " +
+            "SaveMediaToGallery（保存图片/视频到图库）, " +
+            "SearchFile（搜索用户文件管理里面的文件）, " +
+            "SaveFileToFileManager（保存文件到文件管理）, " +
+            "SearchAlarm（搜索闹钟）, " +
+            "CreateAlarm（新建闹钟）, " +
+            "ModifyAlarm（修改闹钟）, " +
+            "DeleteAlarm（删除闹钟）, " +
+            "SearchMessage（搜索短信）, " +
+            "SendShortMessage（发送短信）, " +
+            "StartCall（打电话）。" +
+            "【多次调用】如果用户的定时任务指令中涉及多个端侧工具，则依次分别调用此工具检查每个工具的权限。如果调用超时失败，最多重试一次。" +
+            "【回复约束】如果工具返回没有授权或其他报错，只需要完整描述没有授权或其他报错内容即可，不需要主动给用户提供解决方案。" +
+            "【使用约束1】只要是创建定时任务且涉及端插件的使用，则必须调用此工具检查权限" +
+            "【使用约束2】如果是定时任务执行过程中，禁止调用此工具，此工具仅在创建定时任务时按需调用",
+        parameters: {
+            type: "object",
+            properties: {
+                checkIntentName: {
+                    type: "string",
+                    description: "需要检查权限的意图名称，必须是支持的意图名称之一，例如：GetCurrentLocation、SearchCalendarEvent、CreateCalendarEvent 等。",
+                },
+            },
+            required: ["checkIntentName"],
+        },
+        async execute(toolCallId, params) {
+            const { checkIntentName } = params;
+            // Look up permission IDs for the given intent name
+            const permissionId = INTENT_PERMISSION_MAP[checkIntentName];
+            if (!permissionId) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `不支持的工具意图名称: ${checkIntentName}。请确认该意图名称在支持列表中。`,
+                        },
+                    ],
+                };
+            }
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Build CheckPlugInPrivilege command
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "Action",
+                },
+                payload: {
+                    cardParam: {},
+                    executeParam: {
+                        achieveType: "INTENT",
+                        actionResponse: true,
+                        bundleName: "com.huawei.hmos.vassistant",
+                        dimension: "",
+                        executeMode: "background",
+                        intentName: "CheckPlugInPrivilege",
+                        intentParam: {
+                            checkIntentName,
+                            permissionId,
+                        },
+                        needUnlock: false,
+                        permissionId: [],
+                        timeOut: 5,
+                    },
+                    needUploadResult: true,
+                    pageControlRelated: false,
+                    responses: [
+                        {
+                            displayText: "",
+                            resultCode: "",
+                            ttsText: "",
+                        },
+                    ],
+                },
+            };
+            // Send command and wait for response (60 second timeout)
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    wsManager.off("data-event", handler);
+                    logger.error("超时: 检查插件权限超时（60秒）", { toolCallId, checkIntentName });
+                    reject(new Error(`检查插件权限超时（60秒）, intentName: ${checkIntentName}`));
+                }, 60000);
+                // Listen for data events from WebSocket
+                const handler = (event) => {
+                    if (event.intentName === "CheckPlugInPrivilege") {
+                        clearTimeout(timeout);
+                        wsManager.off("data-event", handler);
+                        if (event.status === "success" && event.outputs) {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    },
+                                ],
+                            });
+                        }
+                        else {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    },
+                                ],
+                            });
+                        }
+                    }
+                };
+                // Register event handler
+                wsManager.on("data-event", handler);
+                // Send the command
+                const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+                sendCommand({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId,
+                    command,
+                    toolCallId,
+                }).then(() => {
+                }).catch((error) => {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    reject(error);
+                });
+            });
+        },
+    };
+}

package/dist/src/tools/create-alarm-tool.js

@@ -244,7 +244,7 @@ b. 使用该工具之前需获取当前真实时间
                             });
                         }
                         else {
-                            reject(new Error(`创建闹钟失败: ${event.status}`));
+                            reject(new Error(`创建闹钟失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };

package/dist/src/tools/create-all-tools.js

@@ -1,6 +1,7 @@
 import { createLocationTool } from "./location-tool.js";
 import { createXiaoyiGuiTool } from "./xiaoyi-gui-tool.js";
 import { createSendFileToUserTool } from "./send-file-to-user-tool.js";
+import { createSendHtmlCardTool } from "./send-html-card-tool.js";
 import { viewPushResultTool } from "./view-push-result-tool.js";
 import { createImageReadingTool } from "./image-reading-tool.js";
 import { timestampToUtc8Tool } from "./timestamp-to-utc8-tool.js";
@@ -13,12 +14,9 @@ import { createGetPhotoToolSchemaTool } from "./get-photo-tool-schema.js";
 import { createGetDeviceFileToolSchemaTool } from "./get-device-file-tool-schema.js";
 import { createGetAlarmToolSchemaTool } from "./get-alarm-tool-schema.js";
 import { createGetCollectionToolSchemaTool } from "./get-collection-tool-schema.js";
-import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
+// import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
 import { createLoginTokenTool } from "./login-token-tool.js";
 import { createAgentAsSkillTool } from "./agent-as-skill-tool.js";
-import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
-import { createDiscoverCrossDevicesTool } from "./discover-cross-devices-tool.js";
-import { createSendCrossDeviceTaskTool } from "./send-cross-device-task-tool.js";
 import { logger } from "../utils/logger.js";
 /**
  * Create all XY channel tools for the given session context.
@@ -34,8 +32,9 @@ export function createAllTools(ctx) {
     logger.log(`[CREATE-ALL-TOOLS] creating tools`);
     return [
         createLocationTool(ctx),
-        createDiscoverCrossDevicesTool(ctx),
-        createSendCrossDeviceTaskTool(ctx),
+        // createDiscoverCrossDevicesTool(ctx),
+        // createSendCrossDeviceTaskTool(ctx),
+        // createDisplayA2UICardTool(ctx),
         createCallDeviceTool(ctx),
         createGetNoteToolSchemaTool(ctx),
         createGetCalendarToolSchemaTool(ctx),
@@ -46,13 +45,14 @@ export function createAllTools(ctx) {
         createGetAlarmToolSchemaTool(ctx),
         createGetCollectionToolSchemaTool(ctx),
         createSendFileToUserTool(ctx),
-        createGetEmailToolSchemaTool(ctx),
+        createSendHtmlCardTool(ctx),
+        // createGetEmailToolSchemaTool(ctx),
         viewPushResultTool,
         createImageReadingTool(ctx),
         timestampToUtc8Tool,
         createSaveSelfEvolutionSkillTool(ctx),
         createLoginTokenTool(ctx),
         createAgentAsSkillTool(ctx),
-        createFindPcDevicesTool(ctx),
+        // createCheckPluginPrivilegeTool(ctx),
     ];
 }

package/dist/src/tools/delete-alarm-tool.js

@@ -143,7 +143,7 @@ export function createDeleteAlarmTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`删除闹钟失败: ${event.status}`));
+                            reject(new Error(`删除闹钟失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };

package/dist/src/tools/device-tool-map.js

@@ -25,6 +25,7 @@ const DEVICE_TOOL_POLICY = {
             "image_reading",
             "convert_time_to_utc8_time",
             "save_self_evolution_skill",
+            "displayA2UICard",
         ],
     },
 };

package/dist/src/tools/discover-cross-devices-tool.js

@@ -106,7 +106,7 @@ export function createDiscoverCrossDevicesTool(ctx) {
 
 当用户明确表达要从另一台设备获取、查找、使用或操作内容时，必须优先调用本工具，例如从 PC、电脑、平板、手机等设备获取文件或查找内容。
 
-本工具只做设备发现和目标设备推荐，不会读取副设备文件内容，不会上传文件，也不会真正下发跨端执行任务。`,
+本工具只做设备发现和目标设备推荐，不会读取副设备文件内容，不会上传文件，也不会真正下发跨端执行任务。下发跨端执行任务需要使用SendCrossDeviceTaskTool`,
         parameters: {
             type: "object",
             properties: {

package/dist/src/tools/display-a2ui-card-tool.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContext } from "./session-manager.js";
+export declare function createDisplayA2UICardTool(ctx: SessionContext): any;

package/dist/src/tools/display-a2ui-card-tool.js

@@ -0,0 +1,85 @@
+import { sendCommand } from "../formatter.js";
+import { getCurrentMessageId, getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+function isJsonObjectOrArray(value) {
+    return !!value && typeof value === "object";
+}
+export function createDisplayA2UICardTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "displayA2UICard",
+        label: "Display A2UI Card",
+        description: "当模型根据 MCP 工具返回结果判断需要向端侧下发 A2UI card 时调用。参数 cardId 和 cardData 由模型根据 MCP 工具返回结果传入，本工具只负责下发卡片展示指令。",
+        parameters: {
+            type: "object",
+            properties: {
+                cardId: {
+                    type: "string",
+                    description: "A2UI card 的唯一标识。",
+                },
+                cardData: {
+                    oneOf: [
+                        { type: "object" },
+                        { type: "array" },
+                    ],
+                    description: "A2UI card 渲染所需的 JSON 对象或 JSON 数组，由模型根据 MCP 工具返回结果填充。",
+                },
+            },
+            required: ["cardId", "cardData"],
+        },
+        async execute(toolCallId, params) {
+            const cardId = typeof params?.cardId === "string" ? params.cardId.trim() : "";
+            const cardData = params?.cardData;
+            if (!cardId) {
+                throw new ToolInputError("缺少必填参数: cardId");
+            }
+            if (!isJsonObjectOrArray(cardData)) {
+                throw new ToolInputError("缺少必填参数: cardData，且必须是 JSON 对象或 JSON 数组");
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "DisplayFACard",
+                },
+                payload: {
+                    isA2ui: true,
+                    a2uiParam: {
+                        cardId,
+                        cardData,
+                    },
+                },
+            };
+            logger.log(`[DISPLAY-A2UI-CARD] sending card, cardId=${cardId}`);
+            await sendCommand({
+                config,
+                sessionId,
+                taskId: currentTaskId,
+                messageId: currentMessageId,
+                command,
+                toolCallId,
+            });
+            logger.log(`[DISPLAY-A2UI-CARD] card sent successfully, cardId=${cardId}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            cardId,
+                            message: "A2UI card display command sent successfully.",
+                        }),
+                    },
+                ],
+            };
+        },
+    };
+}