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

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

@@ -1,6 +1,6 @@
-import { getXYWebSocketManager } from "../client.js";
+import { getCachedXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getCurrentTaskId } from "../task-manager.js";
+import { getCurrentSessionContext } from './session-manager.js';
 import { logger } from "../utils/logger.js";
 // Enum definitions for alarm parameters
 const ALARM_SNOOZE_DURATION_VALUES = [5, 10, 15, 20, 25, 30];
@@ -14,263 +14,261 @@ const DAYS_OF_WEEK_VALUES = ["Mon", "Tues", "Wed", "Thur", "Fri", "Sat", "Sun"];
  *
  * Time format: YYYYMMDD hhmmss (e.g., 20240315 143000)
  */
-export function makeAlarmTool(ctx) {
-    const { config, sessionId, taskId, messageId } = ctx;
-    return {
-        name: "create_alarm",
-        label: "Create Alarm",
-        description: `在用户设备上创建闹钟。
+export const createAlarmTool = {
+    name: "create_alarm",
+    label: "Create Alarm",
+    description: `在用户设备上创建闹钟。
 
 注意事项：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
 b. 使用该工具之前需获取当前真实时间
 
 回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
-        parameters: {
-            type: "object",
-            properties: {
-                alarmTime: {
-                    type: "string",
-                    description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000，表示2024年3月15日14:30:00）",
-                },
-                alarmTitle: {
-                    type: "string",
-                    description: "闹钟名称/标题，默认为'闹钟'",
-                },
-                alarmSnoozeDuration: {
-                    type: "number",
-                    description: "小睡间隔（分钟），枚举值：5,10,15,20,25,30，默认10",
-                },
-                alarmSnoozeTotal: {
-                    type: "number",
-                    description: "再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）",
-                },
-                alarmRingDuration: {
-                    type: "number",
-                    description: "响铃时长（分钟），枚举值：1,5,10,15,20,30，默认5",
-                },
-                daysOfWakeType: {
-                    type: "number",
-                    description: "闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0",
-                },
-                daysOfWeek: {
-                    // 不指定 type，允许传入数组或 JSON 字符串
-                    // 具体的类型验证和转换在 execute 函数内部进行
-                    description: "自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
-                },
+    parameters: {
+        type: "object",
+        properties: {
+            alarmTime: {
+                type: "string",
+                description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000，表示2024年3月15日14:30:00）",
+            },
+            alarmTitle: {
+                type: "string",
+                description: "闹钟名称/标题，默认为'闹钟'",
+            },
+            alarmSnoozeDuration: {
+                type: "number",
+                description: "小睡间隔（分钟），枚举值：5,10,15,20,25,30，默认10",
+            },
+            alarmSnoozeTotal: {
+                type: "number",
+                description: "再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）",
+            },
+            alarmRingDuration: {
+                type: "number",
+                description: "响铃时长（分钟），枚举值：1,5,10,15,20,30，默认5",
+            },
+            daysOfWakeType: {
+                type: "number",
+                description: "闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0",
+            },
+            daysOfWeek: {
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
             },
-            required: ["alarmTime"],
         },
-        async execute(toolCallId, params) {
-            // ===== Validate required parameter: alarmTime =====
-            if (!params.alarmTime || typeof params.alarmTime !== "string") {
-                throw new Error("Missing required parameter: alarmTime must be a string in format YYYYMMDD hhmmss");
+        required: ["alarmTime"],
+    },
+    async execute(toolCallId, params) {
+        const _c = getCurrentSessionContext();
+        const { config, sessionId, taskId, messageId } = _c;
+        // ===== Validate required parameter: alarmTime =====
+        if (!params.alarmTime || typeof params.alarmTime !== "string") {
+            throw new Error("Missing required parameter: alarmTime must be a string in format YYYYMMDD hhmmss");
+        }
+        // Parse and convert alarmTime to timestamp
+        const alarmTimeMs = parseAlarmTimeToTimestamp(params.alarmTime);
+        if (alarmTimeMs === null) {
+            throw new Error("Invalid alarmTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 143000)");
+        }
+        // ===== Validate and set optional parameters with defaults =====
+        // alarmTitle - default to "闹钟"
+        const alarmTitle = params.alarmTitle && typeof params.alarmTitle === "string"
+            ? params.alarmTitle
+            : "闹钟";
+        // alarmSnoozeDuration - default 10
+        let alarmSnoozeDuration = 10;
+        if (params.alarmSnoozeDuration !== undefined && params.alarmSnoozeDuration !== null) {
+            if (typeof params.alarmSnoozeDuration !== "number") {
+                throw new Error("alarmSnoozeDuration must be a number");
             }
-            // Parse and convert alarmTime to timestamp
-            const alarmTimeMs = parseAlarmTimeToTimestamp(params.alarmTime);
-            if (alarmTimeMs === null) {
-                throw new Error("Invalid alarmTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 143000)");
+            if (!ALARM_SNOOZE_DURATION_VALUES.includes(params.alarmSnoozeDuration)) {
+                throw new Error(`alarmSnoozeDuration must be one of: ${ALARM_SNOOZE_DURATION_VALUES.join(", ")}`);
             }
-            // ===== Validate and set optional parameters with defaults =====
-            // alarmTitle - default to "闹钟"
-            const alarmTitle = params.alarmTitle && typeof params.alarmTitle === "string"
-                ? params.alarmTitle
-                : "闹钟";
-            // alarmSnoozeDuration - default 10
-            let alarmSnoozeDuration = 10;
-            if (params.alarmSnoozeDuration !== undefined && params.alarmSnoozeDuration !== null) {
-                if (typeof params.alarmSnoozeDuration !== "number") {
-                    throw new Error("alarmSnoozeDuration must be a number");
-                }
-                if (!ALARM_SNOOZE_DURATION_VALUES.includes(params.alarmSnoozeDuration)) {
-                    throw new Error(`alarmSnoozeDuration must be one of: ${ALARM_SNOOZE_DURATION_VALUES.join(", ")}`);
-                }
-                alarmSnoozeDuration = params.alarmSnoozeDuration;
+            alarmSnoozeDuration = params.alarmSnoozeDuration;
+        }
+        // alarmSnoozeTotal - default 0
+        let alarmSnoozeTotal = 0;
+        if (params.alarmSnoozeTotal !== undefined && params.alarmSnoozeTotal !== null) {
+            if (typeof params.alarmSnoozeTotal !== "number") {
+                throw new Error("alarmSnoozeTotal must be a number");
             }
-            // alarmSnoozeTotal - default 0
-            let alarmSnoozeTotal = 0;
-            if (params.alarmSnoozeTotal !== undefined && params.alarmSnoozeTotal !== null) {
-                if (typeof params.alarmSnoozeTotal !== "number") {
-                    throw new Error("alarmSnoozeTotal must be a number");
-                }
-                if (!ALARM_SNOOZE_TOTAL_VALUES.includes(params.alarmSnoozeTotal)) {
-                    throw new Error(`alarmSnoozeTotal must be one of: ${ALARM_SNOOZE_TOTAL_VALUES.join(", ")}`);
-                }
-                alarmSnoozeTotal = params.alarmSnoozeTotal;
+            if (!ALARM_SNOOZE_TOTAL_VALUES.includes(params.alarmSnoozeTotal)) {
+                throw new Error(`alarmSnoozeTotal must be one of: ${ALARM_SNOOZE_TOTAL_VALUES.join(", ")}`);
             }
-            // alarmRingDuration - default 20
-            let alarmRingDuration = 20;
-            if (params.alarmRingDuration !== undefined && params.alarmRingDuration !== null) {
-                if (typeof params.alarmRingDuration !== "number") {
-                    throw new Error("alarmRingDuration must be a number");
-                }
-                if (!ALARM_RING_DURATION_VALUES.includes(params.alarmRingDuration)) {
-                    throw new Error(`alarmRingDuration must be one of: ${ALARM_RING_DURATION_VALUES.join(", ")}`);
-                }
-                alarmRingDuration = params.alarmRingDuration;
+            alarmSnoozeTotal = params.alarmSnoozeTotal;
+        }
+        // alarmRingDuration - default 20
+        let alarmRingDuration = 20;
+        if (params.alarmRingDuration !== undefined && params.alarmRingDuration !== null) {
+            if (typeof params.alarmRingDuration !== "number") {
+                throw new Error("alarmRingDuration must be a number");
             }
-            // daysOfWakeType - default 0
-            let daysOfWakeType = 0;
-            if (params.daysOfWakeType !== undefined && params.daysOfWakeType !== null) {
-                if (typeof params.daysOfWakeType !== "number") {
-                    throw new Error("daysOfWakeType must be a number");
-                }
-                if (!DAYS_OF_WAKE_TYPE_VALUES.includes(params.daysOfWakeType)) {
-                    throw new Error(`daysOfWakeType must be one of: ${DAYS_OF_WAKE_TYPE_VALUES.join(", ")}`);
-                }
-                daysOfWakeType = params.daysOfWakeType;
+            if (!ALARM_RING_DURATION_VALUES.includes(params.alarmRingDuration)) {
+                throw new Error(`alarmRingDuration must be one of: ${ALARM_RING_DURATION_VALUES.join(", ")}`);
             }
-            // daysOfWeek - only required when daysOfWakeType is 3
-            let daysOfWeek = [];
-            if (daysOfWakeType === 3) {
-                if (!params.daysOfWeek) {
-                    throw new Error("daysOfWeek is required when daysOfWakeType is 3 (custom)");
-                }
-                // ===== 参数规范化：兼容数组和 JSON 字符串 =====
-                let normalizedDaysOfWeek = null;
-                // 情况1: 已经是数组
-                if (Array.isArray(params.daysOfWeek)) {
-                    normalizedDaysOfWeek = params.daysOfWeek;
-                }
-                // 情况2: 是字符串，尝试解析为 JSON 数组
-                else if (typeof params.daysOfWeek === 'string') {
-                    try {
-                        const parsed = JSON.parse(params.daysOfWeek);
-                        if (Array.isArray(parsed)) {
-                            normalizedDaysOfWeek = parsed;
-                        }
-                        else {
-                            throw new Error("daysOfWeek must be an array or a JSON string representing an array");
-                        }
+            alarmRingDuration = params.alarmRingDuration;
+        }
+        // daysOfWakeType - default 0
+        let daysOfWakeType = 0;
+        if (params.daysOfWakeType !== undefined && params.daysOfWakeType !== null) {
+            if (typeof params.daysOfWakeType !== "number") {
+                throw new Error("daysOfWakeType must be a number");
+            }
+            if (!DAYS_OF_WAKE_TYPE_VALUES.includes(params.daysOfWakeType)) {
+                throw new Error(`daysOfWakeType must be one of: ${DAYS_OF_WAKE_TYPE_VALUES.join(", ")}`);
+            }
+            daysOfWakeType = params.daysOfWakeType;
+        }
+        // daysOfWeek - only required when daysOfWakeType is 3
+        let daysOfWeek = [];
+        if (daysOfWakeType === 3) {
+            if (!params.daysOfWeek) {
+                throw new Error("daysOfWeek is required when daysOfWakeType is 3 (custom)");
+            }
+            // ===== 参数规范化：兼容数组和 JSON 字符串 =====
+            let normalizedDaysOfWeek = null;
+            // 情况1: 已经是数组
+            if (Array.isArray(params.daysOfWeek)) {
+                normalizedDaysOfWeek = params.daysOfWeek;
+            }
+            // 情况2: 是字符串，尝试解析为 JSON 数组
+            else if (typeof params.daysOfWeek === 'string') {
+                try {
+                    const parsed = JSON.parse(params.daysOfWeek);
+                    if (Array.isArray(parsed)) {
+                        normalizedDaysOfWeek = parsed;
                     }
-                    catch (parseError) {
-                        throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    else {
+                        throw new Error("daysOfWeek must be an array or a JSON string representing an array");
                     }
                 }
-                // 情况3: 其他类型，报错
-                else {
-                    throw new Error(`daysOfWeek must be an array or a JSON string, got ${typeof params.daysOfWeek}`);
-                }
-                // 验证数组非空
-                if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
-                    throw new Error("daysOfWeek array cannot be empty");
-                }
-                // Validate each day
-                for (const day of normalizedDaysOfWeek) {
-                    if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
-                        throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
-                    }
+                catch (parseError) {
+                    throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
                 }
-                daysOfWeek = normalizedDaysOfWeek;
             }
+            // 情况3: 其他类型，报错
             else {
-                // daysOfWakeType is not 3, daysOfWeek should not be provided
-                if (params.daysOfWeek) {
-                }
-                // Explicitly set to empty array
-                daysOfWeek = [];
+                throw new Error(`daysOfWeek must be an array or a JSON string, got ${typeof params.daysOfWeek}`);
             }
-            // Get WebSocket manager
-            const wsManager = getXYWebSocketManager(config);
-            // Build CreateAlarm command
-            // Build intentParam - only include daysOfWeek when daysOfWakeType is 3
-            const intentParam = {
-                entityName: "Alarm",
-                alarmTime: alarmTimeMs,
-                alarmTitle: alarmTitle,
-                alarmSnoozeDuration: alarmSnoozeDuration,
-                alarmSnoozeTotal: alarmSnoozeTotal,
-                alarmRingDuration: alarmRingDuration,
-                daysOfWakeType: daysOfWakeType,
-            };
-            // Only include daysOfWeek when daysOfWakeType is 3
-            if (daysOfWakeType === 3 && daysOfWeek.length > 0) {
-                intentParam.daysOfWeek = daysOfWeek;
+            // 验证数组非空
+            if (!normalizedDaysOfWeek || normalizedDaysOfWeek.length === 0) {
+                throw new Error("daysOfWeek array cannot be empty");
             }
-            else {
+            // Validate each day
+            for (const day of normalizedDaysOfWeek) {
+                if (typeof day !== "string" || !DAYS_OF_WEEK_VALUES.includes(day)) {
+                    throw new Error(`daysOfWeek must contain only: ${DAYS_OF_WEEK_VALUES.join(", ")}`);
+                }
             }
-            const command = {
-                header: {
-                    namespace: "Common",
-                    name: "Action",
+            daysOfWeek = normalizedDaysOfWeek;
+        }
+        else {
+            // daysOfWakeType is not 3, daysOfWeek should not be provided
+            if (params.daysOfWeek) {
+            }
+            // Explicitly set to empty array
+            daysOfWeek = [];
+        }
+        // Get WebSocket manager
+        const wsManager = getCachedXYWebSocketManager();
+        // Build CreateAlarm command
+        // Build intentParam - only include daysOfWeek when daysOfWakeType is 3
+        const intentParam = {
+            entityName: "Alarm",
+            alarmTime: alarmTimeMs,
+            alarmTitle: alarmTitle,
+            alarmSnoozeDuration: alarmSnoozeDuration,
+            alarmSnoozeTotal: alarmSnoozeTotal,
+            alarmRingDuration: alarmRingDuration,
+            daysOfWakeType: daysOfWakeType,
+        };
+        // Only include daysOfWeek when daysOfWakeType is 3
+        if (daysOfWakeType === 3 && daysOfWeek.length > 0) {
+            intentParam.daysOfWeek = daysOfWeek;
+        }
+        else {
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "CreateAlarm",
+                    bundleName: "com.huawei.hmos.clock",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
                 },
-                payload: {
-                    cardParam: {},
-                    executeParam: {
-                        executeMode: "background",
-                        intentName: "CreateAlarm",
-                        bundleName: "com.huawei.hmos.clock",
-                        needUnlock: true,
-                        actionResponse: true,
-                        appType: "OHOS_APP",
-                        timeOut: 5,
-                        intentParam: intentParam,
-                        permissionId: [],
-                        achieveType: "INTENT",
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
                     },
-                    responses: [
-                        {
-                            resultCode: "",
-                            displayText: "",
-                            ttsText: "",
-                        },
-                    ],
-                    needUploadResult: true,
-                    noHalfPage: false,
-                    pageControlRelated: false,
-                },
-            };
-            // 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 });
-                    reject(new Error("创建闹钟超时（60秒）"));
-                }, 60000);
-                // Listen for data events from WebSocket
-                const handler = (event) => {
-                    if (event.intentName === "CreateAlarm") {
-                        clearTimeout(timeout);
-                        wsManager.off("data-event", handler);
-                        if (event.status === "success" && event.outputs) {
-                            // 成功，直接返回完整的 event.outputs JSON 字符串
-                            resolve({
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify(event.outputs),
-                                    },
-                                ],
-                            });
-                        }
-                        else {
-                            reject(new Error(`创建闹钟失败: ${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) => {
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // 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 });
+                reject(new Error("创建闹钟超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "CreateAlarm") {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
-                    reject(error);
-                });
+                    if (event.status === "success" && event.outputs) {
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`创建闹钟失败: ${JSON.stringify(event.outputs)}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                toolCallId,
+            })
+                .then(() => {
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
             });
-        },
-    };
-}
+        });
+    },
+};
 /**
  * Parse alarmTime string (YYYYMMDD hhmmss) to timestamp in milliseconds
  * @param alarmTime - Time string in format "YYYYMMDD hhmmss" (e.g., "20240315 143000")

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

@@ -17,6 +17,10 @@ import { createGetCollectionToolSchemaTool } from "./get-collection-tool-schema.
 // import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
 import { createLoginTokenTool } from "./login-token-tool.js";
 import { createAgentAsSkillTool } from "./agent-as-skill-tool.js";
+import { createDiscoverCrossDevicesTool } from "./discover-cross-devices-tool.js";
+import { createSendCrossDeviceTaskTool } from "./send-cross-device-task-tool.js";
+import { createDisplayA2UICardByPathTool } from "./display-a2ui-card-bypath-tool.js";
+import { createCheckPluginPrivilegeTool } from "./check-plugin-privilege-tool.js";
 import { logger } from "../utils/logger.js";
 /**
  * Create all XY channel tools for the given session context.
@@ -32,9 +36,9 @@ export function createAllTools(ctx) {
     logger.log(`[CREATE-ALL-TOOLS] creating tools`);
     return [
         createLocationTool(ctx),
-        // createDiscoverCrossDevicesTool(ctx),
-        // createSendCrossDeviceTaskTool(ctx),
-        // createDisplayA2UICardTool(ctx),
+        createDiscoverCrossDevicesTool(ctx),
+        createSendCrossDeviceTaskTool(ctx),
+        createDisplayA2UICardByPathTool(ctx),
         createCallDeviceTool(ctx),
         createGetNoteToolSchemaTool(ctx),
         createGetCalendarToolSchemaTool(ctx),
@@ -53,6 +57,6 @@ export function createAllTools(ctx) {
         createSaveSelfEvolutionSkillTool(ctx),
         createLoginTokenTool(ctx),
         createAgentAsSkillTool(ctx),
-        // createCheckPluginPrivilegeTool(ctx),
+        createCheckPluginPrivilegeTool(ctx),
     ];
 }

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

@@ -1,4 +1,3 @@
-import type { SessionContext } from "./session-manager.js";
 /**
  * XY delete alarm tool - deletes existing alarms on user's device.
  * Requires entityId(s) from search_alarm or create_alarm tool as prerequisite.
@@ -9,4 +8,18 @@ import type { SessionContext } from "./session-manager.js";
  *
  * Supports deleting single or multiple alarms in one call.
  */
-export declare function createDeleteAlarmTool(ctx: SessionContext): any;
+export declare const deleteAlarmTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            items: {
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(toolCallId: string, params: any): Promise<unknown>;
+};