@ynhcj/xiaoyi-channel 1.1.15 → 1.1.16

package/dist/src/bot.d.ts

@@ -8,6 +8,7 @@ export interface HandleXYMessageParams {
     runtime: RuntimeEnv;
     message: A2AJsonRpcRequest;
     accountId: string;
+    webSocketSessionId?: string;
 }
 /**
  * Handle an incoming A2A message.

package/dist/src/bot.js

@@ -1,7 +1,7 @@
 import { getXYRuntime } from "./runtime.js";
 import { setCachedContext } from "./steer-injector.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractTriggerData } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractTriggerData } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
@@ -9,6 +9,7 @@ import { registerSession, unregisterSession, runWithSessionContext } from "./too
 import { configManager } from "./utils/config-manager.js";
 import { addPushId } from "./utils/pushid-manager.js";
 import { getPushDataById } from "./utils/pushdata-manager.js";
+import { saveRuntimeInfo } from "./utils/runtime-manager.js";
 import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
 /**
  * Handle an incoming A2A message.
@@ -16,7 +17,7 @@ import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActive
  * Runtime is expected to be validated before calling this function.
  */
 export async function handleXYMessage(params) {
-    const { cfg, runtime, message, accountId } = params;
+    const { cfg, runtime, message, accountId, webSocketSessionId } = params;
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
     // 每次收到消息时更新缓存，供 steer 注入使用
@@ -125,6 +126,18 @@ export async function handleXYMessage(params) {
         else {
             log(`[BOT] ℹ️  No push_id found in message, will use config default`);
         }
+        // Extract deviceType if present (same level as push_id in systemVariables)
+        const deviceType = extractDeviceType(parsed.parts);
+        if (deviceType) {
+            log(`[BOT] 📱 Extracted deviceType from user message: ${deviceType}`);
+        }
+        // 保存 runtime 信息到 .xiaoyiruntime 文件（异步，不阻塞主流程）
+        saveRuntimeInfo(webSocketSessionId || parsed.sessionId, // SESSION_ID (WebSocket 层级，如果没有则 fallback)
+        parsed.sessionId, // CONVERSATION_ID (param 里的 sessionId)
+        parsed.taskId // TASK_ID (param.id)
+        ).catch((err) => {
+            error(`[BOT] Failed to save runtime info:`, err);
+        });
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -230,7 +243,9 @@ export async function handleXYMessage(params) {
             taskId: parsed.taskId,
             messageId: parsed.messageId,
             agentId: route.accountId,
+            deviceType,
         };
+        log(`[BOT-DISPATCH] ⏳ withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
@@ -249,12 +264,32 @@ export async function handleXYMessage(params) {
             },
             run: () => 
             // 🔐 Use AsyncLocalStorage to provide session context to tools
-            runWithSessionContext(sessionContext, () => core.channel.reply.dispatchReplyFromConfig({
-                ctx: ctxPayload,
-                cfg,
-                dispatcher,
-                replyOptions,
-            })),
+            runWithSessionContext(sessionContext, async () => {
+                log(`[BOT-DISPATCH] ⏳ dispatchReplyFromConfig starting...`);
+                log(`[BOT-DISPATCH]   - sessionKey: ${ctxPayload.SessionKey}`);
+                log(`[BOT-DISPATCH]   - provider: ${ctxPayload.Provider}`);
+                log(`[BOT-DISPATCH]   - surface: ${ctxPayload.Surface}`);
+                log(`[BOT-DISPATCH]   - from: ${ctxPayload.From}`);
+                log(`[BOT-DISPATCH]   - body length: ${ctxPayload.Body?.length ?? 0}`);
+                try {
+                    const result = await core.channel.reply.dispatchReplyFromConfig({
+                        ctx: ctxPayload,
+                        cfg,
+                        dispatcher,
+                        replyOptions,
+                    });
+                    log(`[BOT-DISPATCH] ✅ dispatchReplyFromConfig returned`);
+                    log(`[BOT-DISPATCH]   - result: ${JSON.stringify(result)}`);
+                    return result;
+                }
+                catch (dispatchErr) {
+                    error(`[BOT-DISPATCH] ❌ dispatchReplyFromConfig threw`);
+                    error(`[BOT-DISPATCH]   - error name: ${dispatchErr instanceof Error ? dispatchErr.name : "unknown"}`);
+                    error(`[BOT-DISPATCH]   - error message: ${String(dispatchErr)}`);
+                    error(`[BOT-DISPATCH]   - error stack: ${dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : "N/A"}`);
+                    throw dispatchErr;
+                }
+            }),
         });
         log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);

package/dist/src/channel.js

@@ -24,6 +24,14 @@ import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
 import { viewPushResultTool } from "./tools/view-push-result-tool.js";
 import { imageReadingTool } from "./tools/image-reading-tool.js";
 import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { sendCommandToCarTool } from "./tools/send-command-to-car-tool.js";
+import { xiaoyiCollectionTool } from "./tools/xiaoyi-collection-tool.js";
+import { xiaoyiAddCollectionTool } from "./tools/xiaoyi-add-collection-tool.js";
+import { xiaoyiDeleteCollectionTool } from "./tools/xiaoyi-delete-collection-tool.js";
+import { saveMediaToGalleryTool } from "./tools/save-media-to-gallery-tool.js";
+import { filterToolsByDevice } from "./tools/device-tool-map.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { logger } from "./utils/logger.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -62,7 +70,13 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    agentTools: [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, sendMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool],
+    agentTools: () => {
+        const allTools = [locationTool, noteTool, searchNoteTool, modifyNoteTool, calendarTool, searchCalendarTool, searchContactTool, searchPhotoGalleryTool, uploadPhotoTool, xiaoyiGuiTool, callPhoneTool, searchMessageTool, sendMessageTool, searchFileTool, uploadFileTool, createAlarmTool, searchAlarmTool, modifyAlarmTool, deleteAlarmTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, sendCommandToCarTool, xiaoyiCollectionTool, xiaoyiAddCollectionTool, xiaoyiDeleteCollectionTool, saveMediaToGalleryTool];
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(allTools, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+        return filtered;
+    },
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

package/dist/src/monitor.js

@@ -83,6 +83,7 @@ export async function monitorXYProvider(opts = {}) {
                         runtime,
                         message,
                         accountId, // ✅ Pass accountId ("default")
+                        webSocketSessionId: sessionId, // ✅ 传递 WebSocket 层级的 sessionId
                     });
                 }
                 catch (err) {

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,107 @@
+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_TASK_ID = "x-task-id";
+const HEADER_SESSION_ID = "x-session-id";
+const HEADER_CONVERSATION_ID = "x-conversation-id";
+const EXTRA_PARAM_TASK_ID = "x-task-id";
+const EXTRA_PARAM_SESSION_ID = "x-session-id";
+const EXTRA_PARAM_CONVERSATION_ID = "x-conversation-id";
+/**
+ * Encode uid to base64 and take first 32 chars.
+ */
+function encodeUid(uid) {
+    return Buffer.from(uid).toString("base64").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: [],
+    /**
+     * 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: base64(uid)[:32]_timestamp
+     *   3. No uid available → return undefined (no headers injected)
+     */
+    prepareExtraParams: (ctx) => {
+        const sessionCtx = getCurrentSessionContext();
+        if (sessionCtx) {
+            return {
+                ...ctx.extraParams,
+                [EXTRA_PARAM_TASK_ID]: sessionCtx.taskId,
+                [EXTRA_PARAM_SESSION_ID]: sessionCtx.sessionId,
+                [EXTRA_PARAM_CONVERSATION_ID]: sessionCtx.messageId,
+            };
+        }
+        // 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,
+            [EXTRA_PARAM_TASK_ID]: fallbackValue,
+            [EXTRA_PARAM_SESSION_ID]: fallbackValue,
+            [EXTRA_PARAM_CONVERSATION_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;
+        const dynamicHeaders = {};
+        if (ctx.extraParams) {
+            const taskId = ctx.extraParams[EXTRA_PARAM_TASK_ID];
+            const sessionId = ctx.extraParams[EXTRA_PARAM_SESSION_ID];
+            const conversationId = ctx.extraParams[EXTRA_PARAM_CONVERSATION_ID];
+            if (typeof taskId === "string")
+                dynamicHeaders[HEADER_TASK_ID] = taskId;
+            if (typeof sessionId === "string")
+                dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+            if (typeof conversationId === "string")
+                dynamicHeaders[HEADER_CONVERSATION_ID] = conversationId;
+        }
+        if (Object.keys(dynamicHeaders).length === 0)
+            return underlying;
+        return async (model, context, options) => {
+            // 记录输入
+            console.log(`[xiaoyiprovider] input messages count: ${context.messages.length}`);
+            if (context.systemPrompt) {
+                console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
+            }
+            console.log(`[xiaoyiprovider] headers: ${JSON.stringify(dynamicHeaders)}`);
+            const stream = await underlying(model, context, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    ...dynamicHeaders,
+                },
+            });
+            // 异步监听输出（不阻塞 stream 返回）
+            stream.result().then((msg) => console.log(`[xiaoyiprovider] output: ${JSON.stringify(msg)}`), (err) => console.log(`[xiaoyiprovider] error: ${err}`));
+            return stream;
+        };
+    },
+};

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,36 @@
+// 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",
+            "send_command_to_car",
+            "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/save-media-to-gallery-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY save media to gallery tool - saves image or video files to user's device gallery.
+ * Supports local file paths (auto-uploaded to get public URL) and public URLs.
+ */
+export declare const saveMediaToGalleryTool: any;

package/dist/src/tools/save-media-to-gallery-tool.js

@@ -0,0 +1,178 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { XYFileUploadService } from "../file-upload.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 save media to gallery tool - saves image or video files to user's device gallery.
+ * Supports local file paths (auto-uploaded to get public URL) and public URLs.
+ */
+export const saveMediaToGalleryTool = {
+    name: "SaveMediaToGallery",
+    label: "Save Media to Gallery",
+    description: `将图片文件或者视频文件保存到手机图库。
+  工具参数说明：
+  a. mediaType：非必填，string类型，不传端侧默认为pic。支持传 pic(图片) 或 video(视频)。
+  b. fileName：非必填，string类型，文件名称，不传手机侧默认生成随机uuid。
+  c. url：必填，string类型，支持本地路径或者公网url路径。如果是本地路径，会先上传获取公网url再保存到图库。
+
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            mediaType: {
+                type: "string",
+                description: "非必填，不传默认为pic。支持 pic(图片) 或 video(视频)。",
+            },
+            fileName: {
+                type: "string",
+                description: "非必填，文件名称，不传手机侧默认生成随机uuid。",
+            },
+            url: {
+                type: "string",
+                description: "必填，支持本地路径或者公网url路径。如果是本地路径会先上传获取公网url。",
+            },
+        },
+        required: ["url"],
+    },
+    async execute(toolCallId, params) {
+        // Validate parameters
+        const { mediaType, fileName, url } = params;
+        if (!url || typeof url !== "string") {
+            throw new ToolInputError("缺少必填参数: url");
+        }
+        if (mediaType && !["pic", "video"].includes(mediaType)) {
+            throw new ToolInputError(`mediaType只支持 pic 或 video，当前值: ${mediaType}`);
+        }
+        // Strip file extension from fileName if present
+        let sanitizedFileName = fileName;
+        if (sanitizedFileName && typeof sanitizedFileName === "string") {
+            const lastDot = sanitizedFileName.lastIndexOf(".");
+            if (lastDot > 0) {
+                sanitizedFileName = sanitizedFileName.substring(0, lastDot);
+            }
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. SaveMediaToGallery tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Determine the URL: if it's a local path, upload first to get public URL
+        let publicUrl = url;
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            // Local file path - upload to get public URL
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            publicUrl = await uploadService.uploadFileAndGetUrl(url);
+            if (!publicUrl) {
+                throw new Error("本地文件上传失败，无法获取公网URL");
+            }
+        }
+        // Build intentParam
+        const intentParam = {
+            url: publicUrl,
+        };
+        if (mediaType) {
+            intentParam.mediaType = mediaType;
+        }
+        if (sanitizedFileName) {
+            intentParam.fileName = sanitizedFileName;
+        }
+        // Build SaveMediaToGallery command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SaveMediaToGallery",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: ["ohos.permission.WRITE_IMAGEVIDEO"],
+                    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 === "SaveMediaToGallery") {
+                    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(`保存媒体到图库失败: ${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/send-command-to-car-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Send command to car (小艺车机) tool - sends an output command to the car's Xiaoyi system.
+ * The command will be received and executed on the car's Xiaoyi device.
+ */
+export declare const sendCommandToCarTool: any;

package/dist/src/tools/send-command-to-car-tool.js

@@ -0,0 +1,85 @@
+// Send Command To Car tool implementation
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Send command to car (小艺车机) tool - sends an output command to the car's Xiaoyi system.
+ * The command will be received and executed on the car's Xiaoyi device.
+ */
+export const sendCommandToCarTool = {
+    name: "send_command_to_car",
+    label: "Send Command To Car",
+    description: "将输出指令发送给小艺车机，车机小艺会接收并执行该指令。注意:请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案。",
+    parameters: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "要发送给车机的指令内容（对应intentParam中的out字段）",
+            },
+        },
+        required: ["command"],
+    },
+    async execute(toolCallId, params) {
+        // Validate command parameter
+        if (!params.command || typeof params.command !== "string" || params.command.trim() === "") {
+            throw new Error("Missing required parameter: command must be a non-empty string");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Send command to car tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Build PlayStoryBook command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    achieveType: "INTENT",
+                    actionResponse: true,
+                    bundleName: "com.huawei.vassistantcar",
+                    dimension: "",
+                    executeMode: "background",
+                    intentName: "PlayStoryBook",
+                    intentParam: {
+                        out: params.command,
+                    },
+                    needUnlock: true,
+                    permissionId: [],
+                    timeOut: 5,
+                },
+                needUploadResult: true,
+                pageControlRelated: false,
+                responses: [
+                    {
+                        displayText: "",
+                        resultCode: "",
+                        ttsText: "",
+                    },
+                ],
+            },
+        };
+        // Send command - fire and forget, return success once sent
+        await sendCommand({
+            config,
+            sessionId,
+            taskId,
+            messageId,
+            command,
+        });
+        logger.log("[sendCommandToCar] command sent to car successfully");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, message: "指令已成功下发给车机" }),
+                },
+            ],
+        };
+    },
+};

package/dist/src/tools/session-manager.d.ts

@@ -5,6 +5,7 @@ export interface SessionContext {
     taskId: string;
     messageId: string;
     agentId: string;
+    deviceType?: string;
 }
 /**
  * Register a session context for tool access.

package/dist/src/tools/upload-file-tool.js

@@ -18,10 +18,10 @@ export const uploadFileTool = {
     label: "Upload File",
     description: `工具能力描述：将手机本地文件上传并获取可公网访问的 URL。
 
-  前置工具调用：此工具使用前必须先调用 search_file 工具获取文件的 uri
+  前置工具调用：此工具使用前必须先调用 search_file 或者 QueryCollection 工具获取文件的 uri
 
   工具参数说明：
-  a. 入参中的fileInfos数组，每个元素必须包含mediaUri字段（对应于search_file工具返回结果中的uri），必须与search_file结果中对应的uri完全保持一致，不要自行修改。
+  a. 入参中的fileInfos数组，每个元素必须包含mediaUri字段（对应于search_file工具或者QueryCollection返回结果中的uri），必须与search_file或者QueryCollection结果中对应的uri完全保持一致，不要自行修改。
   b. fileInfos中的timeout字段是可选的，表示上传文件超时时间，单位是毫秒，默认是20000（20秒）。
   c. fileInfos 是文件在手机本地的信息数组（从 search_file 工具响应中获取）。限制：每次最多支持传入 5 条文件信息。
 

package/dist/src/tools/xiaoyi-add-collection-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * XY add collection tool - adds data to user's XiaoYi collection.
+ */
+export declare const xiaoyiAddCollectionTool: any;

package/dist/src/tools/xiaoyi-add-collection-tool.js

@@ -0,0 +1,173 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { XYFileUploadService } from "../file-upload.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 add collection tool - adds data to user's XiaoYi collection.
+ */
+export const xiaoyiAddCollectionTool = {
+    name: "AddCollection",
+    label: "Add XiaoYi Collection",
+    description: `向小艺收藏中添加公共知识数据，可以给用户提供个性化体验。用户希望保存到个人化知识库中的数据都可以调用本技能。不同类型的数据对应的数据要求如下：
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            content: {
+                type: "string",
+                description: "必填字段（HYPER_LINK/TEXT类型时）。用户添加收藏的链接url或文本原文。",
+            },
+            uri: {
+                type: "string",
+                description: "必填字段（IMAGE/FILE类型时）。图片或文件的地址链接。",
+            },
+            sourceAppBundleName: {
+                type: "string",
+                description: "非必填字段。标识该数据的来源应用。",
+            },
+            dataType: {
+                type: "string",
+                description: "必填字段。标识数据类型：HYPER_LINK表示网页，TEXT表示文本，IMAGE表示图片，FILE表示文件。",
+            },
+        },
+        required: ["dataType"],
+    },
+    async execute(toolCallId, params) {
+        // Validate parameters
+        const { content, uri, sourceAppBundleName, dataType } = params;
+        const validTypes = ["HYPER_LINK", "TEXT", "IMAGE", "FILE"];
+        if (!dataType || !validTypes.includes(dataType)) {
+            throw new ToolInputError(`dataType必填且必须为 HYPER_LINK、TEXT、IMAGE、FILE 之一，当前值: ${dataType}`);
+        }
+        if ((dataType === "HYPER_LINK" || dataType === "TEXT") && (!content || typeof content !== "string")) {
+            throw new ToolInputError(`dataType为${dataType}时，content字段必填且不能为空`);
+        }
+        if ((dataType === "IMAGE" || dataType === "FILE") && (!uri || typeof uri !== "string")) {
+            throw new ToolInputError(`dataType为${dataType}时，uri字段必填且不能为空`);
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. AddCollection tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Handle uri: upload local paths to get public URL
+        let publicUri = uri;
+        if (uri && !uri.startsWith("http://") && !uri.startsWith("https://") && !uri.startsWith("file://")) {
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            publicUri = await uploadService.uploadFileAndGetUrl(uri);
+            if (!publicUri) {
+                throw new Error("本地文件上传失败，无法获取公网URL");
+            }
+        }
+        // Build intentParam
+        const intentParam = {
+            dataType,
+        };
+        if (content) {
+            intentParam.content = content;
+        }
+        if (publicUri) {
+            intentParam.uri = publicUri;
+        }
+        if (sourceAppBundleName) {
+            intentParam.sourceAppBundleName = sourceAppBundleName;
+        }
+        // Build AddCollection command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "AddCollection",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    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 === "AddCollection") {
+                    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(`添加小艺收藏失败: ${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/xiaoyi-collection-tool.js

@@ -1,26 +1,54 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.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 collection tool - retrieves user's collection data from XiaoYi.
  * Returns personalized knowledge data saved in user's collection.
  */
 export const xiaoyiCollectionTool = {
-    name: "xiaoyi_collection",
+    name: "QueryCollection",
     label: "XiaoYi Collection",
-    description: "检索用户在小艺收藏中记下来的公共知识数据，可以给用户提供个性化体验。当用户语料中涉及从我的小艺收藏或者查看我的收藏或者我xx时候收藏的xxx帮我看一下这种类型的语料的时候需要使用此工具。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: `检索用户在小艺收藏中记下来的公共知识数据，本技能支持查询用户收藏的公共知识数据，也可以根据特定语义化描述进行特定内容的检索，通过参数进行控制。本技能返回结果中，linkTitle是收藏内容的标题，description是对收藏内容的总结，label是收藏内容的标签，linkUrl是可以直接访问的原始内容链接。如果你认为某条数据对用户交互有用，可以通过linkUrl抓取更加丰富的原始数据。
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
     parameters: {
         type: "object",
         properties: {
             queryAll: {
                 type: "string",
-                description: "描述是否需要查询用户所有收藏数据，默认为true",
-                default: "true",
+                description: "非必填参数，描述是否需要查询用户所有收藏数据。如果填入true则表示获取用户所有公共知识数据，其他参数无效。",
+            },
+            query: {
+                type: "string",
+                description: "非必填参数，queryAll不填或者为false则必填。用户的查询条件，可按照用户query进行检索。",
             },
         },
         required: [],
     },
     async execute(toolCallId, params) {
+        // Validate parameters
+        const queryAll = params.queryAll;
+        const query = params.query;
+        if (queryAll !== "true" && (!query || typeof query !== "string")) {
+            throw new ToolInputError("queryAll不为true时，query参数必填");
+        }
         // Get session context
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
@@ -29,6 +57,15 @@ export const xiaoyiCollectionTool = {
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
         const wsManager = getXYWebSocketManager(config);
+        // Build intentParam
+        const intentParam = {};
+        if (queryAll === "true") {
+            intentParam.queryAll = "true";
+        }
+        else {
+            intentParam.queryAll = "false";
+            intentParam.query = query;
+        }
         // Build QueryCollection command
         const command = {
             header: {
@@ -45,9 +82,7 @@ export const xiaoyiCollectionTool = {
                     actionResponse: true,
                     appType: "OHOS_APP",
                     timeOut: 5,
-                    intentParam: {
-                        queryAll: params.queryAll || "true",
-                    },
+                    intentParam,
                     permissionId: [],
                     achieveType: "INTENT",
                 },

package/dist/src/tools/xiaoyi-delete-collection-tool.d.ts

@@ -0,0 +1,4 @@
+/**
+ * XY delete collection tool - deletes data from user's XiaoYi collection.
+ */
+export declare const xiaoyiDeleteCollectionTool: any;

package/dist/src/tools/xiaoyi-delete-collection-tool.js

@@ -0,0 +1,163 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.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 delete collection tool - deletes data from user's XiaoYi collection.
+ */
+export const xiaoyiDeleteCollectionTool = {
+    name: "DeleteCollection",
+    label: "Delete XiaoYi Collection",
+    description: `从小艺收藏中删除之前已保存的公共知识数据。任何用户希望删除已保存到个人知识库的数据都可以调用本技能。如果用户想更新之前的收藏数据，需要先query获取itemId然后再delete，最后执行Add，按照这个步骤完成收藏数据更新。
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,最多只能重试一次，不可以重复调用多次。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            itemIds: {
+                // 不指定 type，允许传入数组或 JSON 字符串
+                // 具体的类型验证和转换在 execute 函数内部进行
+                description: "准备删除的数据的itemId合集。itemId可以由用户指定，也可以从之前检索回来的收藏数据项的itemId字段获取。",
+            },
+        },
+        required: ["itemIds"],
+    },
+    async execute(toolCallId, params) {
+        // ===== 参数规范化：兼容数组和 JSON 字符串 =====
+        let itemIds = null;
+        if (!params.itemIds) {
+            throw new ToolInputError("缺少必填参数: itemIds");
+        }
+        // 情况1: 已经是数组
+        if (Array.isArray(params.itemIds)) {
+            itemIds = params.itemIds;
+        }
+        // 情况2: 是字符串，尝试解析为 JSON 数组
+        else if (typeof params.itemIds === 'string') {
+            try {
+                const parsed = JSON.parse(params.itemIds);
+                if (Array.isArray(parsed)) {
+                    itemIds = parsed;
+                }
+                else {
+                    throw new ToolInputError("itemIds must be an array or a JSON string representing an array");
+                }
+            }
+            catch (parseError) {
+                if (parseError instanceof ToolInputError)
+                    throw parseError;
+                throw new ToolInputError(`itemIds must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+            }
+        }
+        // 情况3: 其他类型，报错
+        else {
+            throw new ToolInputError(`itemIds must be an array or a JSON string, got ${typeof params.itemIds}`);
+        }
+        // 验证数组非空
+        if (!itemIds || itemIds.length === 0) {
+            throw new ToolInputError("itemIds array cannot be empty");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. DeleteCollection tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build DeleteCollection command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "DeleteCollection",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        itemIds,
+                    },
+                    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 === "DeleteCollection") {
+                    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(`删除小艺收藏失败: ${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/utils/runtime-manager.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 保存 runtime 信息到 .xiaoyiruntime 文件
+ * @param webSocketSessionId - WebSocket 层级的 sessionId (SESSION_ID)
+ * @param conversationId - param 里的 sessionId (CONVERSATION_ID)
+ * @param taskId - 任务 ID (param.id)
+ */
+export declare function saveRuntimeInfo(webSocketSessionId: string, conversationId: string, taskId: string): Promise<void>;

package/dist/src/utils/runtime-manager.js

@@ -0,0 +1,42 @@
+// xiaoyi runtime 持久化管理器
+import { promises as fs } from "fs";
+import * as path from "path";
+import { logger } from "./logger.js";
+const RUNTIME_FILE = "/home/sandbox/.openclaw/.xiaoyiruntime";
+/**
+ * 确保目录存在
+ */
+async function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch (error) {
+        logger.error(`[RuntimeManager] Failed to create directory ${dir}:`, error);
+    }
+}
+/**
+ * 保存 runtime 信息到 .xiaoyiruntime 文件
+ * @param webSocketSessionId - WebSocket 层级的 sessionId (SESSION_ID)
+ * @param conversationId - param 里的 sessionId (CONVERSATION_ID)
+ * @param taskId - 任务 ID (param.id)
+ */
+export async function saveRuntimeInfo(webSocketSessionId, conversationId, taskId) {
+    if (!webSocketSessionId || !conversationId || !taskId) {
+        logger.warn(`[RuntimeManager] Invalid params: SESSION_ID=${webSocketSessionId}, CONVERSATION_ID=${conversationId}, TASK_ID=${taskId}`);
+        return;
+    }
+    try {
+        await ensureDirectoryExists(RUNTIME_FILE);
+        const content = `SESSION_ID=${webSocketSessionId}\nCONVERSATION_ID=${conversationId}\nTASK_ID=${taskId}\n`;
+        await fs.writeFile(RUNTIME_FILE, content, "utf-8");
+        logger.log(`[RuntimeManager] ✅ Saved runtime info to .xiaoyiruntime`);
+        logger.log(`[RuntimeManager]   - SESSION_ID: ${webSocketSessionId}`);
+        logger.log(`[RuntimeManager]   - CONVERSATION_ID: ${conversationId}`);
+        logger.log(`[RuntimeManager]   - TASK_ID: ${taskId}`);
+    }
+    catch (error) {
+        logger.error(`[RuntimeManager] Failed to save runtime info:`, error);
+        // 不抛出异常，避免影响主流程
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,13 +59,12 @@
   "dependencies": {
     "ws": "^8.14.2",
     "uuid": "^9.0.0",
-    "node-fetch": "^2.7.0"
+    "node-fetch": "^3.3.2"
   },
   "devDependencies": {
     "@types/ws": "^8.5.8",
     "@types/uuid": "^9.0.5",
     "@types/node": "^20.8.0",
-    "@types/node-fetch": "^2.6.2",
     "typescript": "^5.9.2"
   }
 }