@ynhcj/xiaoyi-channel 0.0.55-next → 0.0.56-next

package/dist/src/channel.js

@@ -7,7 +7,7 @@ import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
 import { viewPushResultTool } from "./tools/view-push-result-tool.js";
 import { imageReadingTool } from "./tools/image-reading-tool.js";
 import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
-import { searchEmailTool } from "./tools/search-email-tool.js";
+import { getEmailToolSchemaTool } from "./tools/get-email-tool-schema.js";
 import { callDeviceTool } from "./tools/call-device-tool.js";
 import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
 import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
@@ -16,6 +16,9 @@ import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
 import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
 import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
 import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { queryAppMessageTool } from "./tools/query-app-message-tool.js";
+import { queryMemoryDataTool } from "./tools/query-memory-data-tool.js";
+import { queryTodoTaskTool } from "./tools/query-todo-task-tool.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -58,7 +61,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     agentTools: () => {
-        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, searchEmailTool];
+        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, getEmailToolSchemaTool, queryAppMessageTool, queryMemoryDataTool, queryTodoTaskTool];
         const ctx = getCurrentSessionContext();
         const filtered = filterToolsByDevice(allTools, ctx?.deviceType);
         logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);

package/dist/src/provider.js

@@ -8,7 +8,34 @@
 //   models.providers.xiaoyiprovider.api = "openai-completions"
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
+// ── Retry config ──────────────────────────────────────────────
+const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000];
+const MAX_RETRY_ATTEMPTS = 6;
+/** Check if an errorMessage is a retryable provider error. */
+function isRetryableProviderError(message) {
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    // server_error: "The server had an error while processing your request"
+    if (lower.includes("server_error") || lower.includes("server had an error"))
+        return true;
+    // rate_limit_error: "Rate limit reached for requests"
+    if (lower.includes("rate_limit") || lower.includes("rate limit reached"))
+        return true;
+    return false;
+}
+/** Compute retry delay in ms for the given 1-based attempt. */
+function getRetryDelayMs(attempt) {
+    // attempt 1→10s, 2→20s, 3→40s, 4+→60s
+    if (attempt <= RETRY_DELAYS_MS.length)
+        return RETRY_DELAYS_MS[attempt - 1];
+    return RETRY_DELAYS_MS[RETRY_DELAYS_MS.length - 1]; // 60s cap
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 /**
  * Dynamic header keys injected via extraParams and forwarded to the HTTP request.
  * Correspond to the three fields written to .xiaoyiruntime:
@@ -73,10 +100,12 @@ export const xiaoyiProvider = {
     },
     /**
      * Wrap the stream function to inject dynamic headers into every
-     * HTTP request to the model provider.
+     * HTTP request to the model provider, and retry on retryable errors
+     * (server_error / rate_limit_error) with backoff: 10s, 20s, 40s, 60s (cap).
      *
-     * Reads the values injected by prepareExtraParams and adds them
-     * as HTTP headers on the outgoing request.
+     * The retry loop awaits stream.result() to detect errors before deciding
+     * whether to retry. This keeps the agent loop waiting (no timeout risk
+     * since the default agent timeout is 48 hours).
      */
     wrapStreamFn: (ctx) => {
         const underlying = ctx.streamFn;
@@ -135,21 +164,63 @@ export const xiaoyiProvider = {
             if (sessionCtx?.deviceType) {
                 const rawDevice = sessionCtx.deviceType;
                 const displayDevice = (rawDevice === "2in1") ? "鸿蒙PC" : rawDevice;
-                const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user’s current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user’s current device, using device-specific references such as “saved to the Notes/Calendar on your {deviceType}.\n”`;
+                const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user's current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user's current device, using device-specific references such as "saved to the Notes/Calendar on your {deviceType}.\n"`;
                 context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
             }
-            const stream = await underlying(model, context, {
+            // ── Retry loop ─────────────────────────────────────────
+            for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+                const stream = await underlying(model, context, {
+                    ...options,
+                    headers: {
+                        ...options?.headers,
+                        ...dynamicHeaders,
+                    },
+                });
+                // Wait for the stream to settle (done or error) to inspect the result.
+                // stream.result() resolves to the final AssistantMessage (even on error).
+                const result = await stream.result();
+                // Check if this is a retryable error
+                if (result.stopReason === "error" && isRetryableProviderError(result.errorMessage)) {
+                    const delayMs = getRetryDelayMs(attempt);
+                    console.log(`[xiaoyiprovider] retryable error (attempt ${attempt + 1}/${MAX_RETRY_ATTEMPTS}): ` +
+                        `${result.errorMessage} — retrying in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue;
+                }
+                // Success or non-retryable error — log and return
+                if (result.stopReason === "error") {
+                    console.log(`[xiaoyiprovider] non-retryable error: ${result.errorMessage}`);
+                }
+                else {
+                    console.log(`[xiaoyiprovider] stream completed, usage: input=${result.usage?.input} output=${result.usage?.output}`);
+                }
+                // The original stream has already been consumed by result().
+                // We need to return a new stream that replays the result.
+                const replayStream = createAssistantMessageEventStream();
+                // Re-emit events from the result as a single done/error event
+                if (result.stopReason === "error") {
+                    replayStream.push({ type: "error", reason: "error", error: result });
+                }
+                else {
+                    replayStream.push({ type: "done", reason: result.stopReason, message: result });
+                }
+                replayStream.end();
+                return replayStream;
+            }
+            // All retries exhausted — return the last attempt's real error via a new stream
+            console.log(`[xiaoyiprovider] all ${MAX_RETRY_ATTEMPTS} retries exhausted, surfacing last error`);
+            const lastStream = await underlying(model, context, {
                 ...options,
                 headers: {
                     ...options?.headers,
                     ...dynamicHeaders,
                 },
             });
-            // 异步监听输出（不阻塞 stream 返回）
-            stream.result().then((result) => {
-                console.log(`[xiaoyiprovider] stream completed, usage: input=${result.usage?.input} output=${result.usage?.output}`);
-            }, (err) => console.log(`[xiaoyiprovider] stream error: ${JSON.stringify(err)}`));
-            return stream;
+            const lastResult = await lastStream.result();
+            const exhaustedStream = createAssistantMessageEventStream();
+            exhaustedStream.push({ type: "error", reason: "error", error: lastResult });
+            exhaustedStream.end();
+            return exhaustedStream;
         };
     },
 };

package/dist/src/reply-dispatcher.js

@@ -268,8 +268,9 @@ export function createXYReplyDispatcher(params) {
                 if (phase === "start") {
                     const toolName = name || "unknown";
                     // call_device_tool 由自身 execute() 内部发送具体子工具名的状态更新
-                    if (toolName === "call_device_tool") {
-                        log(`[TOOL START] Skipping generic status for call_device_tool, will be handled by execute()`);
+                    // get_xxx_tool_schema 是给 LLM 查 schema 用的，无需向用户展示
+                    if (toolName === "call_device_tool" || toolName.endsWith("_tool_schema")) {
+                        log(`[TOOL START] Skipping generic status for ${toolName}`);
                         return;
                     }
                     try {

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

@@ -20,6 +20,8 @@ import { saveMediaToGalleryTool } from "./save-media-to-gallery-tool.js";
 import { searchFileTool } from "./search-file-tool.js";
 import { uploadFileTool } from "./upload-file-tool.js";
 import { saveFileToPhoneTool } from "./save-file-to-phone-tool.js";
+import { sendEmailTool } from "./send-email-tool.js";
+import { searchEmailTool } from "./search-email-tool.js";
 import { sendStatusUpdate } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
@@ -49,6 +51,8 @@ const deviceToolRegistry = new Map([
     [searchFileTool.name, searchFileTool],
     [uploadFileTool.name, uploadFileTool],
     [saveFileToPhoneTool.name, saveFileToPhoneTool],
+    [sendEmailTool.name, sendEmailTool],
+    [searchEmailTool.name, searchEmailTool],
 ]);
 /**
  * call_device_tool - 通用端工具调度器。

package/dist/src/tools/get-email-tool-schema.d.ts

@@ -0,0 +1,16 @@
+export declare const getEmailToolSchemaTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+    execute(_toolCallId: string, _params: any): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};

package/dist/src/tools/get-email-tool-schema.js

@@ -0,0 +1,9 @@
+import { createSchemaTool } from "./schema-tool-factory.js";
+import { sendEmailTool } from "./send-email-tool.js";
+import { searchEmailTool } from "./search-email-tool.js";
+export const getEmailToolSchemaTool = createSchemaTool({
+    name: "get_email_tool_schema",
+    label: "Get Email Tool Schema",
+    description: "获取可在用户设备上发送邮件、检索邮件的相关端工具列表。",
+    tools: [sendEmailTool, searchEmailTool],
+});

package/dist/src/tools/query-app-message-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export declare const queryAppMessageTool: any;

package/dist/src/tools/query-app-message-tool.js

@@ -0,0 +1,138 @@
+// QueryAppMessage tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 查询指定时间范围内的设备通知消息。
+ */
+export const queryAppMessageTool = {
+    name: "query_app_message",
+    label: "Query App Message",
+    description: `获取指定时间范围内的设备通知消息。适用于需要查询历史通知、按应用筛选通知、或仅查看未读通知的场景。支持按时间范围、应用包名、已读/未读状态进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "查询通知的起始时间（ISO 8601 字符串）。若endTime为空，则默认值为24小时前。",
+            },
+            endTime: {
+                type: "string",
+                description: "查询通知的结束时间（ISO 8601 字符串）。默认值为当前时间。",
+            },
+            packageName: {
+                type: "string",
+                description: "按应用名称过滤通知（例如「微信」「小红书」）。默认值为所有应用。",
+            },
+            state: {
+                type: "integer",
+                description: "通知的已读/未读状态。0 = 全部，1 = 仅未读。默认值为 0。",
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (params.startTime !== undefined)
+            intentParam.startTime = params.startTime;
+        if (params.endTime !== undefined)
+            intentParam.endTime = params.endTime;
+        if (params.packageName !== undefined)
+            intentParam.packageName = params.packageName;
+        if (params.state !== undefined) {
+            if (params.state !== 0 && params.state !== 1) {
+                throw new ToolInputError("state 参数只能为 0（全部）或 1（仅未读）");
+            }
+            intentParam.state = params.state;
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryAppMessage",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询通知消息超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryAppMessage") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询通知消息失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/query-memory-data-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 查询存储在设备本地的结构化记忆数据。
+ */
+export declare const queryMemoryDataTool: any;

package/dist/src/tools/query-memory-data-tool.js

@@ -0,0 +1,154 @@
+// QueryMemoryData tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+const VALID_CATEGORIES = ["ImportantDay", "Address", "Card", "ServiceOrder", "Event"];
+const VALID_SUB_CATEGORIES = {
+    ImportantDay: ["Birthday", "Anniversary", "RepaymentDate", "ExamDate", "SalaryDate", "BigDay"],
+    Card: [
+        "IDCard", "Passport", "DrivingLicense", "VehicleLicense", "EEPtoHKMO",
+        "EEPtoTW", "Invoice", "BusinessCard", "VehicleInspectionCertificate",
+        "SocialSecurityCard", "BankCard",
+    ],
+    ServiceOrder: ["FilmTicket", "HotelOrder", "TrainTicket", "AirTicket"],
+    Event: [
+        "Delicacy", "Work", "FamilyActivities", "Travel", "Training",
+        "Health", "Life", "Entertainment", "Calendar",
+    ],
+};
+/**
+ * 查询存储在设备本地的结构化记忆数据。
+ */
+export const queryMemoryDataTool = {
+    name: "query_memory_data",
+    label: "Query Memory Data",
+    description: `查询存储在设备本地的结构化记忆数据。适用于获取特定类别的个人信息，如重要日子、证件卡证、服务订单或日程事件。支持按分类、子分类进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            category: {
+                type: "string",
+                description: '按数据大类进行过滤。可选值为 ""、"ImportantDay"、"Address"、"Card"、"ServiceOrder"、"Event"。默认值为 ""。',
+            },
+            subCategory: {
+                description: '在指定 category 下的子类别过滤，默认值为""。支持字符串或字符串数组。',
+                oneOf: [
+                    { type: "string" },
+                    { type: "array", items: { type: "string" } },
+                ],
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const { category, subCategory } = params;
+        // Validate category
+        if (category && !VALID_CATEGORIES.includes(category)) {
+            throw new ToolInputError(`category 参数无效，可选值为：${VALID_CATEGORIES.join("、")}`);
+        }
+        // Validate subCategory when category is specified
+        if (category && subCategory && VALID_SUB_CATEGORIES[category]) {
+            const validValues = VALID_SUB_CATEGORIES[category];
+            const subValues = Array.isArray(subCategory) ? subCategory : [subCategory];
+            for (const sv of subValues) {
+                if (sv && !validValues.includes(sv)) {
+                    throw new ToolInputError(`category 为 "${category}" 时，subCategory 可选值为：${validValues.join("、")}`);
+                }
+            }
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (category)
+            intentParam.category = category;
+        if (subCategory !== undefined)
+            intentParam.subCategory = subCategory;
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryMemoryData",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询记忆数据超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryMemoryData") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询记忆数据失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/query-todo-task-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 获取指定时间范围内的全局待办任务列表。
+ */
+export declare const queryTodoTaskTool: any;

package/dist/src/tools/query-todo-task-tool.js

@@ -0,0 +1,133 @@
+// QueryTodoTask tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * 获取指定时间范围内的全局待办任务列表。
+ */
+export const queryTodoTaskTool = {
+    name: "query_todo_task",
+    label: "Query Todo Task",
+    description: `获取指定时间范围内的全局待办任务列表。适用于需要查询历史任务、按完成状态筛选、或仅查看待处理任务的场景。支持按时间范围、任务状态进行过滤。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+d. 当只传入 startTime 时，返回该时间点之后的所有任务；当只传入 endTime 时，返回该时间点之前的所有任务；两者都不传则返回所有时间段的任务。
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "查询创建时间大于此值的任务（ISO 8601 字符串，如 2024-01-01T00:00:00Z）。",
+            },
+            endTime: {
+                type: "string",
+                description: "查询创建时间小于此值的任务（ISO 8601 字符串，如 2024-01-31T23:59:59Z）。",
+            },
+            status: {
+                type: "string",
+                description: '任务完成状态过滤。可选值为 "all"、"completed"、"pending"。默认为 "all"。',
+            },
+        },
+        required: [],
+    },
+    async execute(_toolCallId, params) {
+        const { status } = params;
+        if (status && !["all", "completed", "pending"].includes(status)) {
+            throw new ToolInputError('status 参数只能为 "all"、"completed" 或 "pending"');
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const intentParam = {};
+        if (params.startTime !== undefined)
+            intentParam.startTime = params.startTime;
+        if (params.endTime !== undefined)
+            intentParam.endTime = params.endTime;
+        if (status !== undefined)
+            intentParam.status = status;
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "QueryTodoTask",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("查询待办任务超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "QueryTodoTask") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`查询待办任务失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/send-email-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * XY send email tool - sends an email via 花瓣邮箱 on user's device.
+ */
+export declare const sendEmailTool: any;

package/dist/src/tools/send-email-tool.js

@@ -0,0 +1,134 @@
+// Send Email tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * XY send email tool - sends an email via 花瓣邮箱 on user's device.
+ */
+export const sendEmailTool = {
+    name: "send_email",
+    label: "Send Email",
+    description: `在用户设备上通过花瓣邮箱发送邮件。
+注意：
+a. 操作超时时间为60秒，请勿重复调用此工具
+b. 如果遇到各类调用失败场景，最多只能重试一次，不可以重复调用多次。
+c. 调用工具前需认真检查调用参数是否满足工具要求
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            subject: {
+                type: "string",
+                description: "邮件主题，必填",
+            },
+            to: {
+                type: "string",
+                description: "收件人邮箱地址，必填",
+            },
+            body: {
+                type: "string",
+                description: "邮件内容，必填",
+            },
+        },
+        required: ["subject", "to", "body"],
+    },
+    async execute(_toolCallId, params) {
+        if (typeof params.subject !== "string" || !params.subject.trim()) {
+            throw new ToolInputError("缺少必填参数 subject（邮件主题）");
+        }
+        if (typeof params.to !== "string" || !params.to.trim()) {
+            throw new ToolInputError("缺少必填参数 to（收件人邮箱地址）");
+        }
+        if (typeof params.body !== "string" || !params.body.trim()) {
+            throw new ToolInputError("缺少必填参数 body（邮件内容）");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Send email tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const wsManager = getXYWebSocketManager(config);
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SendEmail",
+                    bundleName: "com.huawei.hmos.email",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        subject: params.subject.trim(),
+                        to: [params.to.trim()],
+                        body: params.body.trim(),
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("发送邮件超时（60秒）"));
+            }, 60000);
+            const handler = (event) => {
+                if (event.intentName === "SendEmail") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`发送邮件失败: ${event.status}`));
+                    }
+                }
+            };
+            wsManager.on("data-event", handler);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => { })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/package.json

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