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

package/dist/src/provider.js

@@ -0,0 +1,355 @@
+// Xiaoyi Provider
+// Wraps any OpenAI-compatible endpoint and injects dynamic headers
+// (taskId, sessionId, conversationId) from the current XY channel session.
+// Falls back to uid-based values when no session context is available.
+//
+// Users configure the underlying model in config:
+//   models.providers.xiaoyiprovider.baseUrl = "https://..."
+//   models.providers.xiaoyiprovider.api = "openai-completions"
+//   models.providers.xiaoyiprovider.models = [...]
+import { createHash } from "crypto";
+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 = 8;
+/** Check if an errorMessage indicates a retryable provider error by type. */
+function isRetryableProviderError(message) {
+    if (!message)
+        return false;
+    const lower = message.toLowerCase();
+    if (lower.includes("the server had an error while processing your request"))
+        return true;
+    if (lower.includes("rate limit reached for requests"))
+        return true;
+    return false;
+}
+/** Check if the request is triggered by a cron job by inspecting the first user message. */
+function isCronTriggered(messages) {
+    if (!messages)
+        return false;
+    const firstUser = messages.find(m => m.role === "user");
+    if (!firstUser)
+        return false;
+    let text = "";
+    if (typeof firstUser.content === "string") {
+        text = firstUser.content;
+    }
+    else if (Array.isArray(firstUser.content)) {
+        const block = firstUser.content.find(b => b.type === "text" && typeof b.text === "string");
+        if (block)
+            text = block.text;
+    }
+    return /^\[cron:/i.test(text.trim());
+}
+/** Compute retry delay in ms for the given 1-based attempt, with up to 10s jitter. */
+function getRetryDelayMs(attempt, isCron = false) {
+    if (isCron) {
+        return 60_000 + Math.floor(Math.random() * 10_000);
+    }
+    const base = attempt <= RETRY_DELAYS_MS.length
+        ? RETRY_DELAYS_MS[attempt - 1]
+        : RETRY_DELAYS_MS[RETRY_DELAYS_MS.length - 1];
+    const jitter = Math.floor(Math.random() * 10_000);
+    return base + jitter;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Build a minimal EventStream-compatible object that replays a single
+ * done/error event. This avoids importing @mariozechner/pi-ai at runtime
+ * (the package is not available in the extension sandbox).
+ */
+function buildReplayStream(result) {
+    let settled = false;
+    const queued = [
+        result.stopReason === "error"
+            ? { type: "error", reason: "error", error: result }
+            : { type: "done", reason: result.stopReason, message: result },
+    ];
+    return {
+        result: () => Promise.resolve(result),
+        push: () => { },
+        end: () => { },
+        [Symbol.asyncIterator]: () => {
+            return {
+                next: async () => {
+                    if (settled || queued.length === 0) {
+                        settled = true;
+                        return { value: undefined, done: true };
+                    }
+                    settled = true;
+                    return { value: queued.shift(), done: false };
+                },
+            };
+        },
+    };
+}
+/**
+ * Wrap the underlying stream with retry logic while preserving real-time streaming.
+ *
+ * Strategy:
+ *  1. Buffer events until the first content-bearing event is seen.
+ *  2. If the stream errors before any content, the buffer is tiny (start + error)
+ *     and we can safely retry with a fresh API call.
+ *  3. Once content events appear, flush the buffer and switch to pass-through mode
+ *     — the consumer sees every text_delta in real time.
+ */
+function createRetryingStream(createStream, cronJob) {
+    let resultResolve;
+    const resultPromise = new Promise(resolve => { resultResolve = resolve; });
+    const CONTENT_EVENT_TYPES = new Set([
+        "text_start", "text_delta", "text_end",
+        "thinking_start", "thinking_delta", "thinking_end",
+        "toolcall_start", "toolcall_delta", "toolcall_end",
+    ]);
+    async function* retryGenerator() {
+        for (let attempt = 0; attempt < MAX_RETRY_ATTEMPTS; attempt++) {
+            const stream = await createStream();
+            let hasContent = false;
+            const buffer = [];
+            let errorResult = null;
+            for await (const event of stream) {
+                const isContent = CONTENT_EVENT_TYPES.has(event.type);
+                if (!hasContent && !isContent) {
+                    // ── Buffer phase (no content yet) ──
+                    if (event.type === "done") {
+                        console.log(`[xiaoyiprovider] stream completed (no content), usage: input=${event.message?.usage?.input} output=${event.message?.usage?.output}`);
+                        for (const b of buffer)
+                            yield b;
+                        resultResolve(event.message);
+                        yield event;
+                        return;
+                    }
+                    if (event.type === "error") {
+                        errorResult = event.error;
+                    }
+                    buffer.push(event);
+                }
+                else {
+                    // ── Streaming phase ──
+                    if (!hasContent) {
+                        console.log("[xiaoyiprovider] first content event received, switching to streaming mode");
+                        hasContent = true;
+                        for (const b of buffer)
+                            yield b;
+                    }
+                    // IMPORTANT: resolve result() BEFORE yielding terminal events to avoid deadlock.
+                    // The SDK calls result() when it sees done/error — if we yield first, the generator
+                    // suspends and can never reach resolve, causing a permanent deadlock.
+                    if (event.type === "done") {
+                        console.log(`[xiaoyiprovider] stream completed, usage: input=${event.message?.usage?.input} output=${event.message?.usage?.output}`);
+                        resultResolve(event.message);
+                        yield event;
+                        return;
+                    }
+                    if (event.type === "error") {
+                        console.log(`[xiaoyiprovider] stream error after content: ${event.error?.errorMessage}`);
+                        resultResolve(event.error);
+                        yield event;
+                        return;
+                    }
+                    yield event;
+                }
+            }
+            // Stream ended during buffer phase — decide whether to retry
+            if (errorResult?.stopReason === "error" && isRetryableProviderError(errorResult.errorMessage)) {
+                if (attempt < MAX_RETRY_ATTEMPTS - 1) {
+                    const delayMs = getRetryDelayMs(attempt + 1, cronJob);
+                    console.log(`[xiaoyiprovider] retryable error (attempt ${attempt + 1}/${MAX_RETRY_ATTEMPTS}): ` +
+                        `${errorResult.errorMessage} — retrying in ${delayMs}ms`);
+                    await sleep(delayMs);
+                    continue; // discard buffer, retry with a new stream
+                }
+                console.log(`[xiaoyiprovider] all ${MAX_RETRY_ATTEMPTS} retries exhausted, surfacing last error`);
+            }
+            else if (errorResult) {
+                console.log(`[xiaoyiprovider] non-retryable error: ${errorResult.errorMessage}`);
+            }
+            // Non-retryable or retries exhausted — yield buffered events.
+            // Resolve before yielding the terminal event to avoid the same deadlock.
+            for (const b of buffer) {
+                if (b.type === "done") {
+                    resultResolve(b.message);
+                }
+                else if (b.type === "error") {
+                    resultResolve(b.error);
+                }
+                yield b;
+            }
+            if (errorResult && buffer.every(b => b.type !== "done" && b.type !== "error")) {
+                resultResolve(errorResult);
+            }
+            return;
+        }
+        // Safety: final fallback attempt
+        console.log("[xiaoyiprovider] entering final fallback attempt");
+        const lastStream = await createStream();
+        for await (const event of lastStream) {
+            if (event.type === "done") {
+                resultResolve(event.message);
+                yield event;
+                return;
+            }
+            if (event.type === "error") {
+                resultResolve(event.error);
+                yield event;
+                return;
+            }
+            yield event;
+        }
+    }
+    const gen = retryGenerator();
+    return {
+        result: () => resultPromise,
+        push: () => { },
+        end: () => { },
+        [Symbol.asyncIterator]: () => gen,
+    };
+}
+/**
+ * Dynamic header keys injected via extraParams and forwarded to the HTTP request.
+ * Correspond to the three fields written to .xiaoyiruntime:
+ *   TASK_ID, SESSION_ID, CONVERSATION_ID
+ */
+const HEADER_TRACE_ID = "x-hag-trace-id";
+const HEADER_SESSION_ID = "x-session-id";
+const HEADER_INTERACTION_ID = "x-interaction-id";
+/**
+ * Encode uid via SHA-256 and take first 32 hex chars.
+ */
+function encodeUid(uid) {
+    return createHash("sha256").update(uid).digest("hex").slice(0, 32);
+}
+/**
+ * Get uid from channel config (OpenClawConfig -> channels -> xiaoyi-channel -> uid).
+ */
+function getUidFromConfig(config) {
+    return config?.channels?.["xiaoyi-channel"]?.uid;
+}
+export const xiaoyiProvider = {
+    id: "xiaoyiprovider",
+    label: "Xiaoyi Provider",
+    docsPath: "/providers/models",
+    auth: [],
+    isCacheTtlEligible: () => true,
+    /**
+     * Inject dynamic session params into extraParams so they flow
+     * through to wrapStreamFn's ctx.extraParams.
+     *
+     * Priority:
+     *   1. Session context (from AsyncLocalStorage, set by bot.ts)
+     *   2. uid-based fallback: sha256(uid).hex[:32]_timestamp
+     *   3. No uid available → return undefined (no headers injected)
+     */
+    prepareExtraParams: (ctx) => {
+        const sessionCtx = getCurrentSessionContext();
+        if (sessionCtx) {
+            const taskId = sessionCtx.taskId;
+            const sessionId = taskId.split("&")[0];
+            const interactionId = taskId.split("&")[1] || "";
+            return {
+                ...ctx.extraParams,
+                [HEADER_TRACE_ID]: taskId,
+                [HEADER_SESSION_ID]: sessionId,
+                [HEADER_INTERACTION_ID]: interactionId,
+            };
+        }
+        // Fallback: uid-based values
+        const uid = getUidFromConfig(ctx.config);
+        if (!uid)
+            return undefined;
+        const prefix = encodeUid(uid);
+        const ts = Date.now();
+        const fallbackValue = `${prefix}_${ts}`;
+        return {
+            ...ctx.extraParams,
+            [HEADER_TRACE_ID]: fallbackValue,
+            [HEADER_SESSION_ID]: fallbackValue,
+            [HEADER_INTERACTION_ID]: fallbackValue,
+        };
+    },
+    /**
+     * Wrap the stream function to inject dynamic headers into every
+     * HTTP request to the model provider, and retry on retryable errors
+     * (server_error / rate_limit_error) with backoff: 10s, 20s, 40s, 60s (cap).
+     *
+     * 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;
+        if (!underlying)
+            return underlying;
+        return async (model, context, options) => {
+            // 每次请求时从 ctx.extraParams 动态读取 header
+            const dynamicHeaders = {};
+            if (ctx.extraParams) {
+                const traceId = ctx.extraParams[HEADER_TRACE_ID];
+                const sessionId = ctx.extraParams[HEADER_SESSION_ID];
+                const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                if (typeof traceId === "string")
+                    dynamicHeaders[HEADER_TRACE_ID] = traceId;
+                if (typeof sessionId === "string")
+                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                if (typeof interactionId === "string")
+                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+            }
+            // 记录输入
+            console.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);
+            if (context.systemPrompt) {
+                console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
+            }
+            // 在发送给模型前，优化 systemPrompt 结构
+            if (context.systemPrompt) {
+                let sp = context.systemPrompt;
+                const beforeLen = sp.length;
+                // 删除 ## Tooling 与 TOOLS.md 声明之间的内容
+                sp = sp.replace(/(## Tooling)[\s\S]*?(TOOLS\.md does not control tool availability; it is user guidance for how to use external tools\.)/, "$1\n\n$2");
+                // (1) 提取 ## Skills (mandatory) 到 </available_skills> 作为第一部分
+                const skillsMatch = sp.match(/(## Skills \(mandatory\)[\s\S]*?<\/available_skills>)/);
+                const part1 = skillsMatch ? skillsMatch[0] : '';
+                // (2) 提取 ## /home/sandbox/.openclaw/workspace/SOUL.md 到 ## /home/sandbox/.openclaw/workspace/TOOLS.md 之前的内容作为第二部分
+                const soulMatch = sp.match(/(## \/home\/sandbox\/\.openclaw\/workspace\/SOUL\.md[\s\S]*?)(?=## \/home\/sandbox\/\.openclaw\/workspace\/TOOLS\.md)/);
+                const part2 = soulMatch ? soulMatch[1].trim() : '';
+                if (part1 || part2) {
+                    // 从原始位置删除已提取的部分
+                    if (skillsMatch)
+                        sp = sp.replace(skillsMatch[0], '');
+                    if (soulMatch)
+                        sp = sp.replace(soulMatch[1], '');
+                    // 清理多余空行
+                    sp = sp.replace(/\n{3,}/g, '\n\n');
+                    // (3) 将 第二部分 + 第一部分 插入到 ## Runtime 上面
+                    const combined = (part2 + '\n\n' + part1).trim();
+                    if (combined && sp.includes('## Runtime')) {
+                        sp = sp.replace('## Runtime', combined + '\n\n## Runtime');
+                    }
+                }
+                console.log(`[xiaoyiprovider] system prompt optimized: ${beforeLen} -> ${sp.length}`);
+                context.systemPrompt = sp;
+            }
+            // Append device context to systemPrompt
+            const sessionCtx = getCurrentSessionContext();
+            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"`;
+                context.systemPrompt = (context.systemPrompt ?? "") + deviceSection;
+            }
+            // ── Retry-capable streaming ──────────────────────────────
+            const cronJob = isCronTriggered(context.messages);
+            if (cronJob)
+                console.log("[xiaoyiprovider] detected cron-triggered request, using extended retry delays");
+            const makeStream = () => underlying(model, context, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    ...dynamicHeaders,
+                },
+            });
+            return createRetryingStream(makeStream, cronJob);
+        };
+    },
+};

package/dist/src/reply-dispatcher.js

@@ -267,6 +267,12 @@ export function createXYReplyDispatcher(params) {
                 log(`[TOOL START] Tool: ${name}, phase: ${phase}, taskId: ${currentTaskId}`);
                 if (phase === "start") {
                     const toolName = name || "unknown";
+                    // call_device_tool 由自身 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 {
                         await sendStatusUpdate({
                             config,

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.d.ts

@@ -0,0 +1,4 @@
+/** Known device type enum. */
+export declare const DEVICE_TYPES: readonly ["car", "2in1", "phone"];
+export type DeviceType = (typeof DEVICE_TYPES)[number];
+export declare function filterToolsByDevice(tools: any[], deviceType?: string): any[];

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

@@ -0,0 +1,37 @@
+// Device type to tool name mapping.
+// Supports two modes:
+//   - allowlist: only listed tools are available (used for restrictive devices like car)
+//   - denylist: listed tools are blocked, everything else is available (used for permissive devices like pc)
+// Tools NOT listed in any device entry → available to all devices (no restriction).
+/** Known device type enum. */
+export const DEVICE_TYPES = ["car", "2in1", "phone"];
+const DEVICE_TOOL_POLICY = {
+    "2in1": {
+        allowlist: false,
+        tools: [
+            "xiaoyi_gui_agent",
+            "call_phone",
+            "send_message",
+            "search_message",
+            "search_contact",
+            "get_contact_tool_schema",
+            "query_collection",
+            "add_collection",
+            "delete_collection",
+            "get_collection_tool_schema",
+        ],
+    },
+};
+export function filterToolsByDevice(tools, deviceType) {
+    if (!deviceType)
+        return tools;
+    const policy = DEVICE_TOOL_POLICY[deviceType];
+    if (!policy)
+        return tools; // unrecognized device → no filtering
+    if (policy.allowlist) {
+        return tools.filter((tool) => policy.tools.includes(tool.name));
+    }
+    else {
+        return tools.filter((tool) => !policy.tools.includes(tool.name));
+    }
+}

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;