@ynhcj/xiaoyi-channel 1.1.15 → 1.1.17

package/dist/index.js

@@ -1,5 +1,6 @@
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { xyPlugin } from "./src/channel.js";
+import { xiaoyiProvider } from "./src/provider.js";
 import { setXYRuntime } from "./src/runtime.js";
 import { tryInjectSteer } from "./src/steer-injector.js";
 import { callCsplApi } from "./src/cspl/call-api.js";
@@ -18,13 +19,14 @@ const plugin = {
     register(api) {
         setXYRuntime(api.runtime);
         api.registerChannel({ plugin: xyPlugin });
-        // CSPL after_tool_call hook: 监听工具结果，发送至 CSPL API 进行安全检测
+        api.registerProvider(xiaoyiProvider);
+        // SENTINEL HOOK after_tool_call hook: 监听工具结果，发送至安全检测 API 进行安全检测
         // 如果响应为 REJECT，注入 steer 消息中止当前对话
         api.on("after_tool_call", async (event, ctx) => {
             if (!ALLOWED_TOOLS.includes(event.toolName)) {
                 return;
             }
-            console.log(`[CSPL] after_tool_call triggered: toolName=${event.toolName}, sessionKey=${ctx.sessionKey ?? "none"}`);
+            console.log(`[SENTINEL HOOK] after_tool_call triggered: toolName=${event.toolName}, sessionKey=${ctx.sessionKey ?? "none"}`);
             try {
                 const resultText = extractResultText(event, event.toolName);
                 const resultLength = resultText.length;
@@ -33,6 +35,7 @@ const plugin = {
                 }
                 // 构造 sentinel_hook 格式的 payload: { tool, output: [{ content }] }
                 const questionText = {
+                    subSceneID: 'TOOL_OUTPUT',
                     tool: event.toolName,
                     output: [{ content: "" }],
                 };
@@ -47,13 +50,13 @@ const plugin = {
                 }
                 const response = await callCsplApi(finalJson, api.config);
                 const result = parseSecurityResult(response);
-                console.log(`[CSPL] Security result: status=${result.status}`);
+                console.log(`[SENTINEL HOOK] Security result: status=${result.status}`);
                 if (result.status === "REJECT") {
                     await tryInjectSteer(ctx.sessionKey, STEER_ABORT_MESSAGE);
                 }
             }
             catch (err) {
-                api.logger.error(`[CSPL] after_tool_call error: ${err}`);
+                api.logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
             }
         });
     },

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 { 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 { saveFileToPhoneTool } from "./tools/save-file-to-phone-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, xiaoyiCollectionTool, xiaoyiAddCollectionTool, xiaoyiDeleteCollectionTool, saveMediaToGalleryTool, saveFileToPhoneTool];
+        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/cspl/call-api.js

@@ -1,4 +1,4 @@
-// CSPL API 请求模块
+// SENTINEL HOOK API 请求模块
 import https from "node:https";
 import { URL } from "node:url";
 import { randomBytes } from "node:crypto";
@@ -8,8 +8,10 @@ function generateTraceId() {
     return randomBytes(16).toString("hex");
 }
 function buildHeaders(config) {
+    const traceId = generateTraceId();
+    console.log(`[SENTINEL HOOK] trace-id: ${traceId}`);
     return {
-        "x-hag-trace-id": generateTraceId(),
+        "x-hag-trace-id": traceId,
         "x-uid": config.uid,
         "x-api-key": config.apiKey,
         "x-request-from": config.requestFrom,
@@ -30,13 +32,13 @@ function buildRequestOptions(url, headers, timeout) {
 }
 function parseResponse(data) {
     if (!data?.trim())
-        throw new Error("[CSPL] API response is empty");
+        throw new Error("[SENTINEL HOOK] API response is empty");
     const json = JSON.parse(data);
     if (json.retCode && json.retCode !== "0") {
-        throw new Error(`[CSPL] API error: ${json.retMsg || "unknown"}`);
+        throw new Error(`[SENTINEL HOOK] API error: ${json.retMsg || "unknown"}`);
     }
     if (!json.retCode && json.code) {
-        throw new Error(`[CSPL] Backend error: ${json.desc || "unknown"}`);
+        throw new Error(`[SENTINEL HOOK] Backend error: ${json.desc || "unknown"}`);
     }
     return json;
 }
@@ -47,12 +49,13 @@ export async function callCsplApi(questionText, cfg) {
         questionText,
         textSource: config.textSource,
         action: config.action,
+        extra: JSON.stringify({ userId: config.uid }),
     };
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(config.api.url, headers, config.api.timeout);
         const req = https.request(options, (res) => {
             if (res.statusCode && res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
-                reject(new Error(`[CSPL] HTTP error: ${res.statusCode}`));
+                reject(new Error(`[SENTINEL HOOK] HTTP error: ${res.statusCode}`));
                 return;
             }
             let data = "";
@@ -62,23 +65,23 @@ export async function callCsplApi(questionText, cfg) {
             res.on("end", () => {
                 try {
                     const result = parseResponse(data);
-                    console.log(`[CSPL API] ✅ 请求成功`);
+                    console.log(`[SENTINEL HOOK] ✅ 请求成功`);
                     resolve(result);
                 }
                 catch (e) {
-                    console.error(`[CSPL API] ❌ 请求失败: ${e instanceof Error ? e.message : String(e)}`);
+                    console.error(`[SENTINEL HOOK] ❌ 请求失败: ${e instanceof Error ? e.message : String(e)}`);
                     reject(e);
                 }
             });
         });
         req.on("error", (error) => {
-            console.error(`[CSPL API] ❌ 请求错误: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(`[SENTINEL HOOK] ❌ 请求错误: ${error instanceof Error ? error.message : String(error)}`);
             reject(error);
         });
         req.on("timeout", () => {
-            console.error(`[CSPL API] ⏰ 请求超时 (${config.api.timeout}ms)`);
+            console.error(`[SENTINEL HOOK] ⏰ 请求超时 (${config.api.timeout}ms)`);
             req.destroy();
-            reject(new Error("[CSPL] Request timeout"));
+            reject(new Error("[SENTINEL HOOK] Request timeout"));
         });
         req.write(JSON.stringify(payload));
         req.end();

package/dist/src/cspl/config.js

@@ -7,7 +7,7 @@ import { logger } from "../utils/logger.js";
 let cachedConfig = null;
 function readServiceUrl() {
     if (!fs.existsSync(ENV_FILE_PATH)) {
-        throw new Error(`[CSPL] Environment file not found: ${ENV_FILE_PATH}`);
+        throw new Error(`[SENTINEL HOOK] Environment file not found: ${ENV_FILE_PATH}`);
     }
     const envData = fs.readFileSync(ENV_FILE_PATH, "utf-8");
     for (const line of envData.split("\n")) {
@@ -22,7 +22,7 @@ function readServiceUrl() {
         if (key === "SERVICE_URL" && value)
             return value;
     }
-    throw new Error("[CSPL] Missing SERVICE_URL in env file");
+    throw new Error("[SENTINEL HOOK] Missing SERVICE_URL in env file");
 }
 /**
  * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
@@ -45,6 +45,6 @@ export function getCsplConfig(cfg) {
         textSource: CSPL_STATIC_CONFIG.textSource,
         action: CSPL_STATIC_CONFIG.action,
     };
-    logger.log("[CSPL] Config loaded (uid/apiKey from XYChannelConfig)");
+    logger.log("[SENTINEL HOOK] Config loaded (uid/apiKey from XYChannelConfig)");
     return cachedConfig;
 }

package/dist/src/cspl/constants.d.ts

@@ -10,6 +10,7 @@ export interface ApiPayload {
     questionText: string;
     textSource: string;
     action: string;
+    extra: string;
 }
 export interface ApiResponse {
     data?: {

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,116 @@
+// 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}`);
+            }
+            const stream = await underlying(model, context, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    ...dynamicHeaders,
+                },
+            });
+            // 异步监听输出（不阻塞 stream 返回）
+            stream.result().then((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,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;

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

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

package/dist/src/tools/save-file-to-phone-tool.d.ts

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