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

package/dist/src/skill-retriever/tool-search.js

@@ -0,0 +1,172 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const SKILL_ID = "celia_find_skills";
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+export function extractUserQuery(fullPrompt) {
+    const lastNewlineIndex = fullPrompt.lastIndexOf("\n");
+    if (lastNewlineIndex === -1) {
+        return fullPrompt.trim();
+    }
+    const afterLastNewline = fullPrompt.slice(lastNewlineIndex + 1).trim();
+    if (!afterLastNewline || afterLastNewline === "```") {
+        return "";
+    }
+    if (fullPrompt.toLowerCase().includes("cron")) {
+        return "";
+    }
+    return afterLastNewline;
+}
+function expandPath(filePath) {
+    if (filePath.startsWith("~")) {
+        return path.join(os.homedir(), filePath.slice(1).replace(/^\/+/, ""));
+    }
+    return filePath;
+}
+export function readEnvFile(filePath) {
+    const expandedPath = expandPath(filePath);
+    const envDict = {};
+    try {
+        const content = fs.readFileSync(expandedPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            const eqIndex = trimmed.indexOf("=");
+            if (eqIndex > 0) {
+                let key = trimmed.substring(0, eqIndex).trim();
+                const value = trimmed.substring(eqIndex + 1).trim();
+                key = key.replace(/-/g, "_");
+                envDict[key] = value;
+            }
+        }
+    }
+    catch {
+        // File not found or read error - return empty config
+    }
+    return envDict;
+}
+export function getInstalledSkills() {
+    const skillsDir = expandPath("~/.openclaw/workspace/skills");
+    const installedSkills = [];
+    try {
+        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+            const entries = fs.readdirSync(skillsDir);
+            for (const entry of entries) {
+                const entryPath = path.join(skillsDir, entry);
+                if (fs.statSync(entryPath).isDirectory()) {
+                    installedSkills.push(entry);
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or read error - return empty list
+    }
+    return installedSkills;
+}
+function formatSkillData(rawSkills, installedSkills) {
+    const formattedSkills = [];
+    for (const skill of rawSkills) {
+        const isInstalled = installedSkills.includes(skill.skillId);
+        formattedSkills.push({
+            skillId: skill.skillId,
+            skillName: skill.skillName,
+            skillDesc: skill.skillDesc,
+            downloadPath: skill.packUrl,
+            status: isInstalled ? "已安装" : "未安装",
+            rrfScore: skill.rrfScore,
+        });
+    }
+    return formattedSkills;
+}
+export async function searchTools(options) {
+    const { query, maxTools = 5, includeUninstalledOnly = true, envFilePath = "~/.openclaw/.xiaoyienv", serviceUrl: configServiceUrl, apiKey: configApiKey, uid: configUid, timeoutMs = 1000, } = options;
+    const envConfig = readEnvFile(envFilePath);
+    const hasRequiredConfig = !!envConfig.SERVICE_URL && !!envConfig.PERSONAL_API_KEY && !!envConfig.PERSONAL_UID;
+    const serviceUrl = configServiceUrl ?? envConfig.SERVICE_URL;
+    const apiKey = configApiKey ?? envConfig.PERSONAL_API_KEY;
+    const uid = configUid ?? envConfig.PERSONAL_UID;
+    if (!serviceUrl || !apiKey || !uid) {
+        console.warn(`${PLUGIN_LOG_PREFIX} Missing required configuration. serviceUrl: "${serviceUrl}", apiKey: "${apiKey ? '(set)' : '(missing)'} ", uid: "${uid ? '(set)' : '(missing)'}"`);
+        return null;
+    }
+    const traceId = crypto.randomUUID();
+    const apiUrl = `${serviceUrl}/celia-claw/v1/rest-api/skill/execute`;
+    const headers = {
+        "Content-Type": "application/json",
+        "x-skill-id": SKILL_ID,
+        "x-hag-trace-id": traceId,
+        "x-uid": uid,
+        "x-api-key": apiKey,
+        "x-request-from": "openclaw",
+    };
+    const payload = { query };
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            console.warn(`${PLUGIN_LOG_PREFIX} HTTP error: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} Received response, status: ${response.status}`);
+        const responseData = await response.json();
+        if (responseData.errorCode === "0" &&
+            responseData.content &&
+            responseData.content.skills) {
+            const rawSkills = responseData.content.skills;
+            const installedSkills = getInstalledSkills();
+            const formattedData = formatSkillData(rawSkills, installedSkills);
+            const topTools = formattedData.slice(0, 2);
+            const allInstalled = topTools.every((tool) => tool.status === "已安装");
+            if (allInstalled) {
+                console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] All top 2 skills are installed, returning null`);
+                return null;
+            }
+            const hasInstalledWithHighScore = topTools.some((tool) => tool.status === "已安装" && (tool.rrfScore ?? 0) >= 0.016);
+            if (hasInstalledWithHighScore) {
+                console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Top 2 has installed skill with rrfScore >= 0.016, returning null`);
+                return null;
+            }
+            let filteredTools = topTools.filter((tool) => tool.status === "未安装" && (tool.rrfScore ?? 0) >= 0.016);
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] After filtering uninstalled with rrfScore >= 0.016: ${filteredTools.length}, details: ${filteredTools.map((t) => `${t.skillId}(rrfScore=${t.rrfScore})`).join(", ")}`);
+            if (filteredTools.length === 0) {
+                console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] No uninstalled skills with rrfScore >= 0.016, returning null`);
+                return null;
+            }
+            return {
+                tools: filteredTools,
+                query,
+                timestamp: Date.now(),
+            };
+        }
+        console.warn(`${PLUGIN_LOG_PREFIX} Invalid response format: ${JSON.stringify(responseData).slice(0, 200)}`);
+        return null;
+    }
+    catch (error) {
+        const errorName = error instanceof Error ? error.name : "Unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCause = error instanceof Error && error.cause ? JSON.stringify(error.cause) : "N/A";
+        const errorStack = error instanceof Error ? error.stack?.split("\n").slice(0, 3).join(" | ") : "N/A";
+        console.warn(`${PLUGIN_LOG_PREFIX} [ERROR] Fetch failed - name: ${errorName}, message: ${errorMessage}, cause: ${errorCause}, stack: ${errorStack}`);
+        return null;
+    }
+}
+export function formatToolsForContext(result, includeInstallUrl = true) {
+    if (!result.tools || result.tools.length === 0) {
+        return "";
+    }
+    const toolDescriptions = [];
+    for (const tool of result.tools) {
+        let description = `### ${tool.skillName}\n`;
+        description += `name: ${tool.skillId}\n`;
+        description += `description: ${tool.skillDesc}\n`;
+        toolDescriptions.push(description);
+    }
+    return toolDescriptions.join("\n\n");
+}

package/dist/src/skill-retriever/types.d.ts

@@ -0,0 +1,36 @@
+export interface ToolRetrieverConfig {
+    enabled: boolean;
+    maxTools: number;
+    includeUninstalledOnly: boolean;
+    envFilePath: string;
+    serviceUrl?: string;
+    apiKey?: string;
+    uid?: string;
+    timeoutMs?: number;
+}
+export interface RawSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    packUrl: string;
+    rrfScore?: number;
+}
+export interface FormattedSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    downloadPath: string;
+    status: "已安装" | "未安装";
+    rrfScore?: number;
+}
+export interface ToolSearchResult {
+    tools: FormattedSkill[];
+    query: string;
+    timestamp: number;
+}
+export interface EnvConfig {
+    PERSONAL_API_KEY?: string;
+    PERSONAL_UID?: string;
+    SERVICE_URL?: string;
+    [key: string]: string | undefined;
+}

package/dist/src/skill-retriever/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/task-manager.d.ts

@@ -48,6 +48,10 @@ export declare function hasActiveTask(sessionId: string): boolean;
  * 获取完整的binding信息（用于调试）
  */
 export declare function getTaskIdBinding(sessionId: string): TaskIdBinding | null;
+/**
+ * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
+ */
+export declare function getAllActiveTaskBindings(): TaskIdBinding[];
 /**
  * 强制清理（错误恢复用）
  */

package/dist/src/task-manager.js

@@ -127,6 +127,12 @@ export function hasActiveTask(sessionId) {
 export function getTaskIdBinding(sessionId) {
     return activeTaskIds.get(sessionId) ?? null;
 }
+/**
+ * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
+ */
+export function getAllActiveTaskBindings() {
+    return Array.from(activeTaskIds.values());
+}
 /**
  * 强制清理（错误恢复用）
  */

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

@@ -0,0 +1,5 @@
+/**
+ * call_device_tool - 通用端工具调度器。
+ * LLM 必须先通过 get_xxx_tool_schema 获取具体工具 schema，再用本工具执行。
+ */
+export declare const callDeviceTool: any;

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

@@ -0,0 +1,130 @@
+import { noteTool } from "./note-tool.js";
+import { searchNoteTool } from "./search-note-tool.js";
+import { modifyNoteTool } from "./modify-note-tool.js";
+import { createAlarmTool } from "./create-alarm-tool.js";
+import { searchAlarmTool } from "./search-alarm-tool.js";
+import { modifyAlarmTool } from "./modify-alarm-tool.js";
+import { deleteAlarmTool } from "./delete-alarm-tool.js";
+import { searchContactTool } from "./search-contact-tool.js";
+import { callPhoneTool } from "./call-phone-tool.js";
+import { searchMessageTool } from "./search-message-tool.js";
+import { sendMessageTool } from "./send-message-tool.js";
+import { xiaoyiAddCollectionTool } from "./xiaoyi-add-collection-tool.js";
+import { xiaoyiCollectionTool } from "./xiaoyi-collection-tool.js";
+import { xiaoyiDeleteCollectionTool } from "./xiaoyi-delete-collection-tool.js";
+import { calendarTool } from "./calendar-tool.js";
+import { searchCalendarTool } from "./search-calendar-tool.js";
+import { searchPhotoGalleryTool } from "./search-photo-gallery-tool.js";
+import { uploadPhotoTool } from "./upload-photo-tool.js";
+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";
+/**
+ * 端工具注册表 —— 按 name 索引所有可通过 call_device_tool 调度的工具。
+ */
+const deviceToolRegistry = new Map([
+    [noteTool.name, noteTool],
+    [searchNoteTool.name, searchNoteTool],
+    [modifyNoteTool.name, modifyNoteTool],
+    [createAlarmTool.name, createAlarmTool],
+    [searchAlarmTool.name, searchAlarmTool],
+    [modifyAlarmTool.name, modifyAlarmTool],
+    [deleteAlarmTool.name, deleteAlarmTool],
+    [searchContactTool.name, searchContactTool],
+    [callPhoneTool.name, callPhoneTool],
+    [searchMessageTool.name, searchMessageTool],
+    [sendMessageTool.name, sendMessageTool],
+    [xiaoyiAddCollectionTool.name, xiaoyiAddCollectionTool],
+    [xiaoyiCollectionTool.name, xiaoyiCollectionTool],
+    [xiaoyiDeleteCollectionTool.name, xiaoyiDeleteCollectionTool],
+    [calendarTool.name, calendarTool],
+    [searchCalendarTool.name, searchCalendarTool],
+    [searchPhotoGalleryTool.name, searchPhotoGalleryTool],
+    [uploadPhotoTool.name, uploadPhotoTool],
+    [saveMediaToGalleryTool.name, saveMediaToGalleryTool],
+    [searchFileTool.name, searchFileTool],
+    [uploadFileTool.name, uploadFileTool],
+    [saveFileToPhoneTool.name, saveFileToPhoneTool],
+    [sendEmailTool.name, sendEmailTool],
+    [searchEmailTool.name, searchEmailTool],
+]);
+/**
+ * call_device_tool - 通用端工具调度器。
+ * LLM 必须先通过 get_xxx_tool_schema 获取具体工具 schema，再用本工具执行。
+ */
+export const callDeviceTool = {
+    name: "call_device_tool",
+    label: "Call Device Tool",
+    description: "用户设备侧工具调用。必须先调用get_xxx_tool_schema获取了具体的工具schema，才能使用本工具执行对应设备侧工具。",
+    parameters: {
+        type: "object",
+        properties: {
+            toolName: {
+                type: "string",
+                description: "要调用的具体端工具名称，即get_xxx_tool_schema返回的工具的name",
+            },
+            arguments: {
+                type: "object",
+                description: "工具所需的具体参数JSON键值对",
+            },
+        },
+        required: ["toolName", "arguments"],
+    },
+    async execute(toolCallId, params) {
+        const { toolName, arguments: toolArgs } = params;
+        // 向用户端发送具体工具名的状态更新
+        const ctx = getCurrentSessionContext();
+        if (ctx) {
+            const currentTaskId = getCurrentTaskId(ctx.sessionId) ?? ctx.taskId;
+            const currentMessageId = getCurrentMessageId(ctx.sessionId) ?? ctx.messageId;
+            try {
+                await sendStatusUpdate({
+                    config: ctx.config,
+                    sessionId: ctx.sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    text: `正在使用工具: ${toolName}...`,
+                    state: "working",
+                });
+            }
+            catch (_) {
+                // 状态更新失败不影响工具执行
+            }
+        }
+        const tool = deviceToolRegistry.get(toolName);
+        if (!tool) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `端工具${toolName}不存在。请确保toolName为get_xxx_tool_schema返回的工具的name。`,
+                    },
+                ],
+            };
+        }
+        try {
+            return await tool.execute(toolCallId, toolArgs);
+        }
+        catch (error) {
+            // ToolInputError (.name === "ToolInputError") 或其他参数校验错误
+            if (error.name === "ToolInputError") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `端工具参数错误：${error.message}。请确保arguments符合get_xxx_tool_schema返回的工具schema。`,
+                        },
+                    ],
+                };
+            }
+            // 非参数错误（网络超时等），直接向上抛出
+            throw error;
+        }
+    },
+};

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

@@ -17,18 +17,7 @@ export const createAlarmTool = {
     name: "create_alarm",
     label: "Create Alarm",
     description: `在用户设备上创建闹钟。
-
-必需参数：
-- alarmTime: 闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000，表示2024年3月15日14:30:00）
-
-可选参数（针对用户没有提及的参数，如果有默认参数，则发送请求时使用默认参数）：
-- alarmTitle: 闹钟名称/标题，默认为"闹钟"
-- alarmSnoozeDuration: 小睡间隔（分钟），枚举值：5,10,15,20,25,30，默认10
-- alarmSnoozeTotal: 再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）
-- alarmRingDuration: 响铃时长（分钟），枚举值：1,5,10,15,20,30，默认5
-- daysOfWakeType: 闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0
-- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。
-
+ 
 注意事项：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
 b. 使用该工具之前需获取当前真实时间
@@ -39,7 +28,7 @@ b. 使用该工具之前需获取当前真实时间
         properties: {
             alarmTime: {
                 type: "string",
-                description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000）",
+                description: "闹钟时间，格式必须为：YYYYMMDD hhmmss（例如：20240315 143000，表示2024年3月15日14:30:00）",
             },
             alarmTitle: {
                 type: "string",
@@ -51,7 +40,7 @@ b. 使用该工具之前需获取当前真实时间
             },
             alarmSnoozeTotal: {
                 type: "number",
-                description: "再响次数，枚举值：0,1,3,5,10，默认0",
+                description: "再响次数，枚举值：0,1,3,5,10，默认0（表示不再响）",
             },
             alarmRingDuration: {
                 type: "number",
@@ -59,12 +48,12 @@ b. 使用该工具之前需获取当前真实时间
             },
             daysOfWakeType: {
                 type: "number",
-                description: "闹钟响铃类型：0=单次，1=法定节假日，2=每天，3=自定义，4=法定工作日，默认0",
+                description: "闹钟响铃类型，枚举值：0=单次响铃，1=法定节假日，2=每天，3=自定义时间，4=法定工作日，默认0",
             },
             daysOfWeek: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
+                description: "自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
             },
         },
         required: ["alarmTime"],

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

@@ -16,9 +16,6 @@ export const deleteAlarmTool = {
     label: "Delete Alarm",
     description: `删除用户设备上的闹钟。使用前必须先调用 search_alarm 或 create_alarm 工具获取闹钟的 entityId。
 
-工具参数：
-- items: 要删除的闹钟列表，每个元素包含 entityId 字段。支持数组或 JSON 字符串格式。entityId 是闹钟的唯一标识符（从 search_alarm 或 create_alarm 工具获取）。
-
 使用示例：
 - 删除单个闹钟：{"items": [{"entityId": "6"}]}
 - 删除多个闹钟：{"items": [{"entityId": "6"}, {"entityId": "8"}]}
@@ -35,7 +32,7 @@ export const deleteAlarmTool = {
             items: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "要删除的闹钟列表，每个元素包含 entityId 字段。支持数组或 JSON 字符串格式。",
+                description: "要删除的闹钟列表，每个元素包含 entityId 字段。支持数组或 JSON 字符串格式。entityId 是闹钟的唯一标识符（从 search_alarm 或 create_alarm 工具获取）。",
             },
         },
         required: ["items"],

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

@@ -13,11 +13,12 @@ const DEVICE_TOOL_POLICY = {
             "call_phone",
             "send_message",
             "search_message",
-            "send_command_to_car",
             "search_contact",
-            "QueryCollection",
-            "AddCollection",
-            "DeleteCollection",
+            "get_contact_tool_schema",
+            "query_collection",
+            "add_collection",
+            "delete_collection",
+            "get_collection_tool_schema",
         ],
     },
 };

package/dist/src/tools/find-pc-devices-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY find PC devices tool - finds all PC devices associated with the user.
+ * Returns device IDs for use in subsequent file search operations.
+ */
+export declare const findPcDevicesTool: any;

package/dist/src/tools/find-pc-devices-tool.js

@@ -0,0 +1,98 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+/**
+ * XY find PC devices tool - finds all PC devices associated with the user.
+ * Returns device IDs for use in subsequent file search operations.
+ */
+export const findPcDevicesTool = {
+    name: "find_pc_devices",
+    label: "Find PC Devices",
+    description: `查找用户所有PC/电脑设备，获取设备ID列表。当用户说"帮我找一下PC/电脑上的xxx文件"、"帮我搜索电脑上的xxx"等涉及PC设备的请求时，先调用此工具获取设备ID，再进行后续操作。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，请严格遵守。`,
+    parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    async execute(toolCallId, params) {
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Find PC devices tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build GetAllDevice command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    achieveType: "INTENT",
+                    actionResponse: true,
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    dimension: "",
+                    executeMode: "background",
+                    intentName: "GetAllDevice",
+                    intentParam: {},
+                    needUnlock: true,
+                    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);
+                reject(new Error("查找PC设备超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "GetAllDevice") {
+                    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(`查找PC设备失败: ${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);
+            });
+        });
+    },
+};

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

@@ -0,0 +1,16 @@
+export declare const getAlarmToolSchemaTool: {
+    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-alarm-tool-schema.js

@@ -0,0 +1,11 @@
+import { createSchemaTool } from "./schema-tool-factory.js";
+import { createAlarmTool } from "./create-alarm-tool.js";
+import { searchAlarmTool } from "./search-alarm-tool.js";
+import { modifyAlarmTool } from "./modify-alarm-tool.js";
+import { deleteAlarmTool } from "./delete-alarm-tool.js";
+export const getAlarmToolSchemaTool = createSchemaTool({
+    name: "get_alarm_tool_schema",
+    label: "Get Alarm Tool Schema",
+    description: "获取可在用户设备上创建、检索、修改、删除闹钟的相关端工具列表。",
+    tools: [createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool],
+});

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

@@ -0,0 +1,16 @@
+export declare const getCalendarToolSchemaTool: {
+    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-calendar-tool-schema.js

@@ -0,0 +1,9 @@
+import { createSchemaTool } from "./schema-tool-factory.js";
+import { calendarTool } from "./calendar-tool.js";
+import { searchCalendarTool } from "./search-calendar-tool.js";
+export const getCalendarToolSchemaTool = createSchemaTool({
+    name: "get_calendar_tool_schema",
+    label: "Get Calendar Tool Schema",
+    description: "获取可在用户设备上创建、检索日程的相关端工具列表。",
+    tools: [calendarTool, searchCalendarTool],
+});

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

@@ -0,0 +1,16 @@
+export declare const getCollectionToolSchemaTool: {
+    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-collection-tool-schema.js

@@ -0,0 +1,10 @@
+import { createSchemaTool } from "./schema-tool-factory.js";
+import { xiaoyiAddCollectionTool } from "./xiaoyi-add-collection-tool.js";
+import { xiaoyiCollectionTool } from "./xiaoyi-collection-tool.js";
+import { xiaoyiDeleteCollectionTool } from "./xiaoyi-delete-collection-tool.js";
+export const getCollectionToolSchemaTool = createSchemaTool({
+    name: "get_collection_tool_schema",
+    label: "Get Collection Tool Schema",
+    description: "获取可在用户设备上添加、检索、删除小艺收藏中的公共知识数据的相关端工具列表。",
+    tools: [xiaoyiAddCollectionTool, xiaoyiCollectionTool, xiaoyiDeleteCollectionTool],
+});