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

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

@@ -0,0 +1,365 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+// Enum definitions for alarm parameters (same as create-alarm-tool)
+const ALARM_SNOOZE_DURATION_VALUES = [5, 10, 15, 20, 25, 30];
+const ALARM_SNOOZE_TOTAL_VALUES = [0, 1, 3, 5, 10];
+const ALARM_RING_DURATION_VALUES = [1, 5, 10, 15, 20, 30];
+const DAYS_OF_WAKE_TYPE_VALUES = [0, 1, 2, 3, 4];
+const DAYS_OF_WEEK_VALUES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+/**
+ * XY modify alarm tool - modifies an existing alarm on user's device.
+ * Requires entityId from search_alarm or create_alarm tool.
+ *
+ * Prerequisites:
+ * 1. Call search_alarm or create_alarm tool first to get entityId
+ * 2. Use the entityId to identify which alarm to modify
+ */
+export const modifyAlarmTool = {
+    name: "modify_alarm",
+    label: "Modify Alarm",
+    description: `修改用户设备上已存在的闹钟。
+
+必需参数：
+- entityId: 闹钟的唯一标识符，必须先通过 search_alarm 或 create_alarm 工具获取
+
+可选参数（与创建闹钟的参数完全一致）：
+- alarmTime: 闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）
+- alarmTitle: 闹钟名称/标题
+- alarmState: 闹钟开启状态，0=关闭，1=开启
+- alarmSnoozeDuration: 小睡间隔（分钟），枚举值：5,10,15,20,25,30
+- alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10
+- alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30
+- daysOfWakeType: 闹钟响铃类型，枚举值：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
+
+使用流程：
+1. 先调用 search_alarm 工具查询闹钟，获取 entityId，
+2. 调用此工具修改闹钟，传入 entityId 和需要修改的参数
+3. 其余不涉及需改的参数，如果search_alarm 或 create_alarm的结果中有相应的值，需要一并填上，需要与原有的保持一致，防止不填采用默认值
+
+注意事项：操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
+
+回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {
+            entityId: {
+                type: "string",
+                description: "闹钟的唯一标识符，必须先通过 search_alarm 或 create_alarm 工具获取",
+            },
+            alarmTime: {
+                type: "string",
+                description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）",
+            },
+            alarmTitle: {
+                type: "string",
+                description: "闹钟名称/标题",
+            },
+            alarmState: {
+                type: "number",
+                description: "闹钟开启状态：0=关闭，1=开启",
+            },
+            alarmSnoozeDuration: {
+                type: "number",
+                description: "小睡间隔（分钟），枚举值：5,10,15,20,25,30",
+            },
+            alarmSnoozeTotal: {
+                type: "number",
+                description: "再响次数，枚举值：0,1,3,5,10",
+            },
+            alarmRingDuration: {
+                type: "number",
+                description: "响铃时长（分钟），枚举值：1,5,10,15,20,30",
+            },
+            daysOfWakeType: {
+                type: "number",
+                description: "闹钟响铃类型：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日",
+            },
+            daysOfWeek: {
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
+            },
+        },
+        required: ["entityId"],
+    },
+    async execute(toolCallId, params) {
+        // ===== Validate required parameter: entityId =====
+        if (!params.entityId || typeof params.entityId !== "string") {
+            throw new Error("Missing required parameter: entityId must be a string obtained from search_alarm or create_alarm");
+        }
+        // ===== Build intentParam with provided parameters =====
+        const intentParam = {
+            entityName: "Alarm",
+            entityId: params.entityId,
+        };
+        // Parse and convert alarmTime if provided
+        if (params.alarmTime !== undefined && params.alarmTime !== null) {
+            if (typeof params.alarmTime !== "string") {
+                throw new Error("alarmTime must be a string in format YYYYMMDD hhmmss");
+            }
+            const alarmTimeMs = parseAlarmTimeToTimestamp(params.alarmTime);
+            if (alarmTimeMs === null) {
+                throw new Error("Invalid alarmTime format. Required format: YYYYMMDD hhmmss (e.g., 20240315 143000)");
+            }
+            intentParam.alarmTime = alarmTimeMs;
+        }
+        // Add alarmTitle if provided
+        if (params.alarmTitle !== undefined && params.alarmTitle !== null) {
+            if (typeof params.alarmTitle !== "string") {
+                throw new Error("alarmTitle must be a string");
+            }
+            intentParam.alarmTitle = params.alarmTitle;
+        }
+        // Add alarmState if provided
+        if (params.alarmState !== undefined && params.alarmState !== null) {
+            if (typeof params.alarmState !== "number") {
+                throw new Error("alarmState must be a number");
+            }
+            if (!ALARM_STATE_VALUES.includes(params.alarmState)) {
+                throw new Error(`alarmState must be one of: ${ALARM_STATE_VALUES.join(", ")}`);
+            }
+            intentParam.alarmState = params.alarmState;
+        }
+        // Add alarmSnoozeDuration if provided
+        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(", ")}`);
+            }
+            intentParam.alarmSnoozeDuration = params.alarmSnoozeDuration;
+        }
+        // Add alarmSnoozeTotal if provided
+        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(", ")}`);
+            }
+            intentParam.alarmSnoozeTotal = params.alarmSnoozeTotal;
+        }
+        // Add alarmRingDuration if provided
+        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(", ")}`);
+            }
+            intentParam.alarmRingDuration = params.alarmRingDuration;
+        }
+        // Add daysOfWakeType if provided
+        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(", ")}`);
+            }
+            intentParam.daysOfWakeType = params.daysOfWakeType;
+        }
+        // Add daysOfWeek if provided - only valid when daysOfWakeType is 3
+        if (params.daysOfWeek !== undefined && params.daysOfWeek !== null) {
+            // Check if daysOfWakeType is 3 or will be set to 3
+            const targetDaysOfWakeType = params.daysOfWakeType !== undefined ? params.daysOfWakeType : null;
+            if (targetDaysOfWakeType !== null && targetDaysOfWakeType !== 3) {
+                // Skip processing daysOfWeek when daysOfWakeType is not 3
+            }
+            else {
+                // ===== 参数规范化：兼容数组和 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");
+                        }
+                    }
+                    catch (parseError) {
+                        throw new Error(`daysOfWeek must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    }
+                }
+                // 情况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");
+                }
+                // 验证数组长度必须为1
+                if (normalizedDaysOfWeek.length !== 1) {
+                    throw new Error("daysOfWeek 仅支持长度为1的数组。如果需要一周中不同的几天，需要多次调用此工具");
+                }
+                // 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(", ")}`);
+                    }
+                }
+                intentParam.daysOfWeek = normalizedDaysOfWeek;
+            }
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Modify alarm tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build ModifyAlarm command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "ModifyAlarm",
+                    bundleName: "com.huawei.hmos.clock",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                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);
+                reject(new Error("修改闹钟超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "ModifyAlarm") {
+                    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(`修改闹钟失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};
+// Enum for alarm state
+const ALARM_STATE_VALUES = [0, 1];
+/**
+ * Parse alarmTime string (YYYYMMDD hhmmss) to timestamp in milliseconds
+ * @param alarmTime - Time string in format "YYYYMMDD hhmmss" (e.g., "20240315 143000")
+ * @returns Timestamp in milliseconds, or null if parsing fails
+ */
+function parseAlarmTimeToTimestamp(alarmTime) {
+    try {
+        // Expected format: YYYYMMDD hhmmss
+        // Example: 20240315 143000
+        const trimmed = alarmTime.trim();
+        // Check basic format (should have at least 13 characters: YYYYMMDD hhmmss)
+        if (trimmed.length < 13) {
+            return null;
+        }
+        // Extract date and time parts
+        // Format: YYYYMMDD hhmmss
+        const datePart = trimmed.substring(0, 8); // YYYYMMDD
+        const timePart = trimmed.substring(8).trim(); // hhmmss (may have leading space)
+        // Validate lengths
+        if (datePart.length !== 8 || timePart.length !== 6) {
+            return null;
+        }
+        // Parse components
+        const year = parseInt(datePart.substring(0, 4), 10);
+        const month = parseInt(datePart.substring(4, 6), 10);
+        const day = parseInt(datePart.substring(6, 8), 10);
+        const hour = parseInt(timePart.substring(0, 2), 10);
+        const minute = parseInt(timePart.substring(2, 4), 10);
+        const second = parseInt(timePart.substring(4, 6), 10);
+        // Validate values
+        if (isNaN(year) || isNaN(month) || isNaN(day) ||
+            isNaN(hour) || isNaN(minute) || isNaN(second)) {
+            return null;
+        }
+        // Validate ranges
+        if (month < 1 || month > 12) {
+            return null;
+        }
+        if (day < 1 || day > 31) {
+            return null;
+        }
+        if (hour < 0 || hour > 23) {
+            return null;
+        }
+        if (minute < 0 || minute > 59) {
+            return null;
+        }
+        if (second < 0 || second > 59) {
+            return null;
+        }
+        // Create Date object and get timestamp
+        const date = new Date(year, month - 1, day, hour, minute, second);
+        const timestamp = date.getTime();
+        if (isNaN(timestamp)) {
+            return null;
+        }
+        return timestamp;
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/src/tools/modify-note-tool.js

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 /**
  * XY modify note tool - appends content to an existing note on user's device.
  * Requires entityId from search_notes tool as prerequisite.
@@ -13,7 +12,7 @@ import { logger } from "../utils/logger.js";
 export const modifyNoteTool = {
     name: "modify_note",
     label: "Modify Note",
-    description: "在指定备忘录中追加新内容。使用前必须先调用 search_notes 工具获取备忘录的 entityId。参数说明：entityId 是备忘录的唯一标识符（从 search_notes 工具获取），text 是要追加的文本内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "在指定备忘录中追加新内容。使用前必须先调用 search_notes 工具获取备忘录的 entityId。参数说明：entityId 是备忘录的唯一标识符（从 search_notes 工具获取），text 是要追加的文本内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -29,34 +28,19 @@ export const modifyNoteTool = {
         required: ["entityId", "text"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[MODIFY_NOTE_TOOL] 🚀 Starting execution`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[MODIFY_NOTE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.entityId || !params.text) {
-            logger.error(`[MODIFY_NOTE_TOOL] ❌ Missing required parameters`);
             throw new Error("Missing required parameters: entityId and text are required");
         }
         // Get session context
-        logger.log(`[MODIFY_NOTE_TOOL] 🔍 Attempting to get session context...`);
-        const sessionContext = getLatestSessionContext();
+        const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[MODIFY_NOTE_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[MODIFY_NOTE_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Modify note tool can only be used during an active conversation.");
         }
-        logger.log(`[MODIFY_NOTE_TOOL] ✅ Session context found`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[MODIFY_NOTE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[MODIFY_NOTE_TOOL] ✅ WebSocket manager obtained`);
         // Build ModifyNote command
-        logger.log(`[MODIFY_NOTE_TOOL] 📦 Building ModifyNote command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -92,56 +76,36 @@ export const modifyNoteTool = {
                 pageControlRelated: false,
             },
         };
-        logger.log(`[MODIFY_NOTE_TOOL]   - entityId: ${params.entityId}`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - contentType: 1 (append mode)`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - text length: ${params.text.length} characters`);
         // Send command and wait for response (60 second timeout)
-        logger.log(`[MODIFY_NOTE_TOOL] ⏳ Setting up promise to wait for note modification response...`);
-        logger.log(`[MODIFY_NOTE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[MODIFY_NOTE_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(`[MODIFY_NOTE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "ModifyNote") {
-                    logger.log(`[MODIFY_NOTE_TOOL] 🎯 ModifyNote event received`);
-                    logger.log(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[MODIFY_NOTE_TOOL] ✅ Note modified successfully`);
-                        logger.log(`[MODIFY_NOTE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
-                        // Return the result directly as requested
-                        const result = event.outputs.result;
-                        logger.log(`[MODIFY_NOTE_TOOL] 📝 Note updated:`);
-                        logger.log(`[MODIFY_NOTE_TOOL]   - entityId: ${result?.entityId}`);
-                        logger.log(`[MODIFY_NOTE_TOOL]   - title: ${result?.title}`);
-                        logger.log(`[MODIFY_NOTE_TOOL]   - modifiedDate: ${result?.modifiedDate}`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
                     }
                     else {
-                        logger.error(`[MODIFY_NOTE_TOOL] ❌ Note modification failed`);
-                        logger.error(`[MODIFY_NOTE_TOOL]   - status: ${event.status}`);
                         reject(new Error(`修改备忘录失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[MODIFY_NOTE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[MODIFY_NOTE_TOOL] 📤 Sending ModifyNote command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -150,10 +114,8 @@ export const modifyNoteTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[MODIFY_NOTE_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[MODIFY_NOTE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

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

@@ -1,7 +1,18 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+/**
+ * Duck-typed ToolInputError: openclaw 按 .name 字段匹配，不用 instanceof。
+ * 抛出此错误会让 openclaw 返回 HTTP 400 而非 500，
+ * LLM 会将其识别为参数错误而非瞬时故障，不会触发重试。
+ */
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
 /**
  * XY note tool - creates a note on user's device.
  * Requires title and content parameters.
@@ -9,29 +20,39 @@ import { logger } from "../utils/logger.js";
 export const noteTool = {
     name: "create_note",
     label: "Create Note",
-    description: "在用户设备上创建备忘录。需要提供备忘录标题和内容。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: `在用户设备上创建备忘录。需要提供备忘录标题和内容。
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
     parameters: {
         type: "object",
         properties: {
             title: {
                 type: "string",
-                description: "备忘录标题",
+                description: "备忘录标题，必填",
             },
             content: {
                 type: "string",
-                description: "备忘录内容",
+                description: "备忘录内容，必填",
             },
         },
         required: ["title", "content"],
     },
     async execute(toolCallId, params) {
-        logger.debug("Executing note tool, toolCallId:", toolCallId);
-        // Validate parameters
-        if (!params.title || !params.content) {
-            throw new Error("Missing required parameters: title and content are required");
+        // Validate parameters — 抛 ToolInputError 而非普通 Error，
+        // 让 openclaw 返回 400 而非 500，明确告知 LLM 这是参数错误，不应重试。
+        if (typeof params.title !== "string" || !params.title) {
+            throw new ToolInputError("缺少必填参数 title（备忘录标题）");
+        }
+        if (typeof params.content !== "string" || !params.content) {
+            throw new ToolInputError("缺少必填参数 content（备忘录内容）");
         }
         // Get session context
-        const sessionContext = getLatestSessionContext();
+        const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
             throw new Error("No active XY session found. Note tool can only be used during an active conversation.");
         }
@@ -80,28 +101,16 @@ export const noteTool = {
             }, 60000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.debug("Received data event:", event);
                 if (event.intentName === "CreateNote") {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        const { result, code } = event.outputs;
-                        logger.log(`Note created: title=${result?.title}, id=${result?.entityId}`);
+                        // 成功，直接返回完整的 event.outputs JSON 字符串
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify({
-                                        success: true,
-                                        note: {
-                                            entityId: result?.entityId,
-                                            title: result?.title,
-                                            content: result?.content,
-                                            entityName: result?.entityName,
-                                            modifiedDate: result?.modifiedDate,
-                                        },
-                                        code,
-                                    }),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });

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

@@ -0,0 +1,8 @@
+/**
+ * XY search alarm tool - searches alarms on user's device.
+ * Returns matching alarms based on various filter criteria.
+ *
+ * At least one search criterion must be provided.
+ * Multiple criteria can be combined.
+ */
+export declare const searchAlarmTool: any;