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

package/dist/src/monitor.js

@@ -4,6 +4,7 @@ import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
 import { hasActiveTask } from "./task-manager.js";
 import { handleTriggerEvent } from "./trigger-handler.js";
+import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -67,7 +68,7 @@ export async function monitorXYProvider(opts = {}) {
         // Event handlers (defined early so they can be referenced in cleanup)
         const messageHandler = (message, sessionId, serverId) => {
             const messageKey = `${sessionId}::${message.id}`;
-            log(`[MONITOR-HANDLER] ####### messageHandler triggered: serverId=${serverId}, sessionId=${sessionId}, messageId=${message.id} #######`);
+            log(`[MONITOR-HANDLER] ####### messageHandler triggered: sessionId=${sessionId}, messageId=${message.id} #######`);
             // ✅ Report health: received a message
             trackEvent?.();
             // Check for duplicate message handling
@@ -75,17 +76,15 @@ export async function monitorXYProvider(opts = {}) {
                 error(`[MONITOR-HANDLER] ⚠️ WARNING: Duplicate message detected! messageKey=${messageKey}, this may cause duplicate dispatchers!`);
             }
             activeMessages.add(messageKey);
-            log(`[MONITOR-HANDLER] 📝 Active messages count: ${activeMessages.size}, messageKey: ${messageKey}`);
             const task = async () => {
                 try {
-                    log(`[MONITOR-HANDLER] 🚀 Starting handleXYMessage for messageKey=${messageKey}`);
                     await handleXYMessage({
                         cfg,
                         runtime,
                         message,
                         accountId, // ✅ Pass accountId ("default")
+                        webSocketSessionId: sessionId, // ✅ 传递 WebSocket 层级的 sessionId
                     });
-                    log(`[MONITOR-HANDLER] ✅ Completed handleXYMessage for messageKey=${messageKey}`);
                 }
                 catch (err) {
                     // ✅ Only log error, don't re-throw to prevent gateway restart
@@ -94,7 +93,6 @@ export async function monitorXYProvider(opts = {}) {
                 finally {
                     // Remove from active messages when done
                     activeMessages.delete(messageKey);
-                    log(`[MONITOR-HANDLER] 🧹 Cleaned up messageKey=${messageKey}, remaining active: ${activeMessages.size}`);
                 }
             };
             // 🔑 核心改造：检测steer模式
@@ -107,7 +105,6 @@ export async function monitorXYProvider(opts = {}) {
                     // Steer模式且有活跃任务：不入队列，直接并发执行
                     log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
                     log(`[MONITOR-HANDLER]   - sessionId: ${parsed.sessionId}`);
-                    log(`[MONITOR-HANDLER]   - Bypassing queue to allow message insertion`);
                     void task().catch((err) => {
                         error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
                         activeMessages.delete(messageKey);
@@ -115,7 +112,6 @@ export async function monitorXYProvider(opts = {}) {
                 }
                 else {
                     // 正常模式：入队列串行执行
-                    log(`[MONITOR-HANDLER] 📋 NORMAL MODE: Enqueuing for messageKey=${messageKey}`);
                     void enqueue(sessionId, task).catch((err) => {
                         error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
                         activeMessages.delete(messageKey);
@@ -207,8 +203,8 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
         wsManager.on("trigger-event", triggerEventHandler);
-        // Start periodic health check (every 5 minutes)
-        console.log("🏥 Starting periodic health check (every 5 minutes)...");
+        // Start periodic health check (every 6 hours)
+        console.log("🏥 Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {
             console.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
             diagnoseAllManagers();
@@ -217,7 +213,9 @@ export async function monitorXYProvider(opts = {}) {
             if (cleaned > 0) {
                 console.log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
             }
-        }, 5 * 60 * 1000); // 5 minutes
+            // Cleanup stale temp files (older than 24 hours)
+            void cleanupStaleTempFiles();
+        }, 6 * 60 * 60 * 1000); // 6 hours
         // Connect to WebSocket servers
         wsManager.connect()
             .then(() => {

package/dist/src/outbound.js

@@ -90,13 +90,6 @@ export const xyOutbound = {
         };
     },
     sendText: async ({ cfg, to, text, accountId }) => {
-        // Log parameters
-        console.log(`[xyOutbound.sendText] Called with:`, {
-            to,
-            accountId,
-            textLength: text?.length || 0,
-            textPreview: text?.slice(0, 100),
-        });
         // Resolve configuration
         const config = resolveXYConfig(cfg);
         // Handle default push marker (for cron jobs without explicit target)
@@ -112,7 +105,7 @@ export const xyOutbound = {
         let pushDataId;
         try {
             pushDataId = await savePushData(text);
-            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId}`);
+            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId.substring(0, 20)}`);
         }
         catch (error) {
             console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
@@ -146,7 +139,6 @@ export const xyOutbound = {
         let failureCount = 0;
         for (const pushId of pushIdList) {
             try {
-                console.log(`[xyOutbound.sendText] Sending to pushId: ${pushId.substring(0, 20)}...`);
                 // 传入 pushId 和 pushDataId，使用 kind="data" 格式
                 await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId, pushId);
                 successCount++;
@@ -158,8 +150,6 @@ export const xyOutbound = {
                 // 单个 pushId 发送失败不影响其他，继续处理下一个
             }
         }
-        console.log(`[xyOutbound.sendText] 📊 Broadcast summary: ${successCount} success, ${failureCount} failures`);
-        console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",
@@ -168,14 +158,6 @@ export const xyOutbound = {
         };
     },
     sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
-        // Log parameters
-        console.log(`[xyOutbound.sendMedia] Called with:`, {
-            to,
-            accountId,
-            text,
-            mediaUrl,
-            mediaLocalRoots,
-        });
         // Parse to: "sessionId::taskId"
         const parts = to.split("::");
         if (parts.length !== 2) {

package/dist/src/parser.d.ts

@@ -43,6 +43,12 @@ export declare function isTasksCancelMessage(method: string): boolean;
  * Looks for push_id in data parts under variables.systemVariables.push_id
  */
 export declare function extractPushId(parts: A2AMessagePart[]): string | null;
+/**
+ * Extract deviceType from message parts.
+ * Looks for deviceType in data parts under variables.systemVariables.deviceType
+ * (same level as push_id).
+ */
+export declare function extractDeviceType(parts: A2AMessagePart[]): string | null;
 /**
  * Extract Trigger event data from message parts.
  * Looks for Trigger events with pushDataId in data parts.

package/dist/src/parser.js

@@ -72,6 +72,22 @@ export function extractPushId(parts) {
     }
     return null;
 }
+/**
+ * Extract deviceType from message parts.
+ * Looks for deviceType in data parts under variables.systemVariables.deviceType
+ * (same level as push_id).
+ */
+export function extractDeviceType(parts) {
+    for (const part of parts) {
+        if (part.kind === "data" && part.data) {
+            const deviceType = part.data.variables?.systemVariables?.device_type;
+            if (deviceType && typeof deviceType === "string") {
+                return deviceType;
+            }
+        }
+    }
+    return null;
+}
 /**
  * Extract Trigger event data from message parts.
  * Looks for Trigger events with pushDataId in data parts.

package/dist/src/provider.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-models";
+export declare const xiaoyiProvider: ProviderPlugin;

package/dist/src/provider.js

@@ -0,0 +1,124 @@
+// 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";
+/**
+ * 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 plugin config (OpenClawConfig -> plugins -> xiaoyi-channel -> config).
+ */
+function getUidFromConfig(config) {
+    return config?.plugins?.entries?.["xiaoyi-channel"]?.config?.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.
+     *
+     * Reads the values injected by prepareExtraParams and adds them
+     * as HTTP headers on the outgoing request.
+     */
+    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 中 ## Tooling 与 TOOLS.md 声明之间的内容
+            if (context.systemPrompt) {
+                const before = context.systemPrompt.length;
+                context.systemPrompt = context.systemPrompt.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");
+                console.log(`[xiaoyiprovider] system prompt trimmed: ${before} -> ${context.systemPrompt.length}`);
+            }
+            const stream = await underlying(model, context, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    ...dynamicHeaders,
+                },
+            });
+            // 异步监听输出（不阻塞 stream 返回）
+            stream.result().then((result) => {
+                console.log(`[xiaoyiprovider] stream completed, usage: input=${result.usage?.input} output=${result.usage?.output}`);
+            }, (err) => console.log(`[xiaoyiprovider] stream error: ${JSON.stringify(err)}`));
+            return stream;
+        };
+    },
+};

package/dist/src/push.js

@@ -34,15 +34,7 @@ export class XYPushService {
         // Use provided pushId or fall back to config pushId
         const actualPushId = pushId || this.config.pushId;
         console.log(`[PUSH] 📤 Preparing to send push message`);
-        console.log(`[PUSH]   - Title: "${title}"`);
-        console.log(`[PUSH]   - Content length: ${content.length} chars`);
-        console.log(`[PUSH]   - Session ID: ${sessionId || 'none'}`);
-        console.log(`[PUSH]   - Trace ID: ${traceId}`);
-        console.log(`[PUSH]   - Push URL: ${pushUrl}`);
         console.log(`[PUSH]   - Using pushId: ${actualPushId.substring(0, 20)}...`);
-        console.log(`[PUSH]   - Full pushId: ${actualPushId}`);
-        console.log(`[PUSH]   - API ID: ${this.config.apiId}`);
-        console.log(`[PUSH]   - UID: ${this.config.uid}`);
         try {
             const requestBody = {
                 jsonrpc: "2.0",
@@ -75,7 +67,6 @@ export class XYPushService {
                     ],
                 },
             };
-            console.log(`[PUSH] Full request body:`, JSON.stringify(requestBody, null, 2));
             const response = await fetch(pushUrl, {
                 method: "POST",
                 headers: {
@@ -91,21 +82,16 @@ export class XYPushService {
             // Log response status and headers
             console.log(`[PUSH] 📥 Response received`);
             console.log(`[PUSH]   - HTTP Status: ${response.status} ${response.statusText}`);
-            console.log(`[PUSH]   - Content-Type: ${response.headers.get('content-type')}`);
-            console.log(`[PUSH]   - Content-Length: ${response.headers.get('content-length')}`);
             if (!response.ok) {
                 const errorText = await response.text();
                 console.log(`[PUSH] ❌ Push request failed`);
                 console.log(`[PUSH]   - HTTP Status: ${response.status}`);
-                console.log(`[PUSH]   - Response body: ${errorText}`);
                 throw new Error(`Push failed: HTTP ${response.status} - ${errorText}`);
             }
             // Try to parse JSON response with detailed error handling
             let result;
             try {
                 const responseText = await response.text();
-                console.log(`[PUSH] 📄 Response body length: ${responseText.length} chars`);
-                console.log(`[PUSH] 📄 Response body preview: ${responseText.substring(0, 200)}`);
                 if (!responseText || responseText.trim() === '') {
                     console.log(`[PUSH] ⚠️ Received empty response body`);
                     result = {};
@@ -120,20 +106,13 @@ export class XYPushService {
                 throw new Error(`Invalid JSON response from push service: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
             }
             console.log(`[PUSH] ✅ Push message sent successfully`);
-            console.log(`[PUSH]   - Title: "${title}"`);
             console.log(`[PUSH]   - Trace ID: ${traceId}`);
-            console.log(`[PUSH]   - Used pushId: ${actualPushId.substring(0, 20)}...`);
-            console.log(`[PUSH]   - Response:`, result);
         }
         catch (error) {
             console.log(`[PUSH] ❌ Failed to send push message`);
-            console.log(`[PUSH]   - Trace ID: ${traceId}`);
-            console.log(`[PUSH]   - Target URL: ${pushUrl}`);
-            console.log(`[PUSH]   - Push ID: ${actualPushId.substring(0, 20)}...`);
             if (error instanceof Error) {
                 console.log(`[PUSH]   - Error name: ${error.name}`);
                 console.log(`[PUSH]   - Error message: ${error.message}`);
-                console.log(`[PUSH]   - Error stack:`, error.stack);
             }
             else {
                 console.log(`[PUSH]   - Error:`, error);

package/dist/src/reply-dispatcher.d.ts

@@ -8,6 +8,10 @@ export interface CreateXYReplyDispatcherParams {
     accountId: string;
     isSteerFollower?: boolean;
 }
+/**
+ * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
+ */
+export declare function cleanupStaleTempFiles(tempDir?: string): Promise<void>;
 /**
  * Create a reply dispatcher for XY channel messages.
  * Follows feishu pattern with status updates and streaming support.

package/dist/src/reply-dispatcher.js

@@ -4,29 +4,34 @@ import { resolveXYConfig } from "./config.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import fs from "fs/promises";
 import path from "path";
+const TEMP_FILE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 /**
- * 清理 /tmp/xy_channel 目录中的所有文件
+ * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
  */
-async function cleanupTempDir(tempDir = "/tmp/xy_channel") {
+export async function cleanupStaleTempFiles(tempDir = "/tmp/xy_channel") {
     try {
         const stats = await fs.stat(tempDir).catch(() => null);
         if (!stats?.isDirectory()) {
-            return; // 目录不存在，直接返回
+            return;
         }
         const files = await fs.readdir(tempDir);
+        const now = Date.now();
         let cleanedCount = 0;
         for (const file of files) {
             const filePath = path.join(tempDir, file);
             try {
-                await fs.unlink(filePath);
-                cleanedCount++;
+                const fileStat = await fs.stat(filePath);
+                if (now - fileStat.mtimeMs > TEMP_FILE_TTL_MS) {
+                    await fs.unlink(filePath);
+                    cleanedCount++;
+                }
             }
             catch (err) {
-                // 忽略单个文件删除失败，继续处理其他文件
+                // 忽略单个文件处理失败
             }
         }
         if (cleanedCount > 0) {
-            console.log(`[CLEANUP] 🧹 Cleaned ${cleanedCount} files from ${tempDir}`);
+            console.log(`[CLEANUP] 🧹 Cleaned ${cleanedCount} stale files (>${TEMP_FILE_TTL_MS / 1000 / 3600}h) from ${tempDir}`);
         }
     }
     catch (err) {
@@ -43,9 +48,7 @@ export function createXYReplyDispatcher(params) {
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
     log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
-    log(`[DISPATCHER-CREATE]   - sessionId: ${sessionId}`);
     log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
-    log(`[DISPATCHER-CREATE]   - messageId: ${messageId}`);
     log(`[DISPATCHER-CREATE]   - isSteerFollower: ${isSteerFollower ?? false}`);
     // 初始taskId和messageId（作为fallback）
     const initialTaskId = taskId;
@@ -232,16 +235,17 @@ export function createXYReplyDispatcher(params) {
                         text: "任务执行异常，请重试~",
                         append: false,
                         final: true,
+                        errorCode: 99921111,
+                        errorMessage: "任务执行异常，请重试",
                     });
                     finalSent = true;
-                    log(`[ON_IDLE] ✅ Sent error response`);
+                    log(`[ON_IDLE] ✅ Sent error response with code: 99921111`);
                 }
                 catch (err) {
                     error(`[ON_IDLE] Failed to send error response:`, err);
                 }
             }
             stopStatusInterval();
-            void cleanupTempDir();
         },
         onCleanup: () => {
             const currentTaskId = getActiveTaskId();

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

@@ -90,33 +90,17 @@ export const callPhoneTool = {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        // Check for error code in outputs
-                        const code = event.outputs.code !== undefined ? event.outputs.code : null;
-                        if (code !== null && code !== 0) {
-                            const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            reject(new Error(`拨打电话失败: ${errorMsg} (错误代码: ${code})`));
-                            return;
-                        }
-                        // Return the outputs directly
-                        const result = {
-                            success: true,
-                            code: code,
-                            phoneNumber: params.phoneNumber,
-                            slotId: slotId,
-                            message: "电话拨打成功",
-                        };
                         resolve({
                             content: [
                                 {
                                     type: "text",
-                                    text: JSON.stringify(result),
+                                    text: JSON.stringify(event.outputs),
                                 },
                             ],
                         });
                     }
                     else {
-                        const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
-                        reject(new Error(`拨打电话失败: ${errorDetail}`));
+                        reject(new Error(`拨打电话失败: ${event.status}`));
                     }
                 }
             };

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

@@ -6,7 +6,7 @@ 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"];
+const DAYS_OF_WEEK_VALUES = ["Mon", "Tues", "Wed", "Thur", "Fri", "Sat", "Sun"];
 /**
  * XY create alarm tool - creates an alarm on user's device.
  * Requires alarmTime parameter. Other parameters are optional with sensible defaults.
@@ -27,7 +27,7 @@ export const createAlarmTool = {
 - 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,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具
+- daysOfWeek: 自定义响铃星期，仅当daysOfWakeType=3（自定义时间）时必需且有效，其他情况不要传递此参数。数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。
 
 注意事项：
 a. 操作超时时间为60秒，请勿重复调用此工具，如果超时或失败，最多重试一次。
@@ -64,7 +64,7 @@ b. 使用该工具之前需获取当前真实时间
             daysOfWeek: {
                 // 不指定 type，允许传入数组或 JSON 字符串
                 // 具体的类型验证和转换在 execute 函数内部进行
-                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tue,Wed,Thu,Fri,Sat,Sun。注意：仅支持长度为1的数组，如果需要一周中不同的几天，需要多次调用此工具",
+                description: "自定义响铃星期（仅当daysOfWakeType=3时需要，其他情况不要传递），数组或JSON字符串，枚举值：Mon,Tues,Wed,Thur,Fri,Sat,Sun。",
             },
         },
         required: ["alarmTime"],
@@ -163,10 +163,6 @@ b. 使用该工具之前需获取当前真实时间
             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)) {

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,35 @@
+// 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",
+            "QueryCollection",
+            "AddCollection",
+            "DeleteCollection",
+        ],
+    },
+};
+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;