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

package/dist/src/tools/agent-as-skill-tool.js

@@ -3,6 +3,7 @@ import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
 import { logger } from "../utils/logger.js";
+import { XYFileUploadService } from "../file-upload.js";
 /**
  * Agent-as-skill tool - invokes a registered agent by agentId as a skill.
  * The tool receives the agentId, query, and optional file attachments,
@@ -11,7 +12,7 @@ import { logger } from "../utils/logger.js";
 export function createAgentAsSkillTool(ctx) {
     const { config, sessionId, taskId, messageId } = ctx;
     return {
-        name: "agent-as-skill-tool",
+        name: "agent_as_a_tool",
         label: "Agent as Skill Tool",
         description: `智能体作为skill的执行元工具。当需要调用其他已注册的Agent来执行特定任务时使用此工具。
 该工具会将用户请求和可选的附件文件转发给目标Agent执行，并返回执行结果。
@@ -37,8 +38,7 @@ export function createAgentAsSkillTool(ctx) {
                     description: "用户原始请求文本，原样转发给目标Agent执行",
                 },
                 filesInfo: {
-                    type: "array",
-                    description: "附件文件/图片信息列表，无文件时可传null或空数组",
+                    description: "附件文件/图片信息列表，无文件时可传null或空数组，支持传入数组或JSON字符串",
                     items: {
                         type: "object",
                         properties: {
@@ -55,6 +55,10 @@ export function createAgentAsSkillTool(ctx) {
                                 type: "string",
                                 description: "文件可访问下载链接（完整HTTP/HTTPS地址）",
                             },
+                            fileUrlLocal: {
+                                type: "string",
+                                description: "文件本地路径，如果提供此字段，工具会自动上传文件并将公网URL填入fileUrl",
+                            },
                         },
                     },
                 },
@@ -71,6 +75,53 @@ export function createAgentAsSkillTool(ctx) {
             if (!params.query || typeof params.query !== "string") {
                 throw new Error("Missing or invalid required parameter: query must be a non-empty string");
             }
+            // Robust parsing: normalize filesInfo from array or JSON string
+            let filesInfo = null;
+            if (params.filesInfo) {
+                if (Array.isArray(params.filesInfo)) {
+                    filesInfo = params.filesInfo;
+                }
+                else if (typeof params.filesInfo === 'string') {
+                    try {
+                        const parsed = JSON.parse(params.filesInfo);
+                        if (Array.isArray(parsed)) {
+                            filesInfo = parsed;
+                        }
+                        else {
+                            throw new Error("filesInfo must be an array or a JSON string representing an array");
+                        }
+                    }
+                    catch (parseError) {
+                        throw new Error(`filesInfo JSON解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    }
+                }
+                else {
+                    filesInfo = null;
+                }
+            }
+            // Upload local files and fill fileUrl
+            if (filesInfo && filesInfo.length > 0) {
+                const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+                for (const fileInfo of filesInfo) {
+                    if (fileInfo.fileUrlLocal && !fileInfo.fileUrl) {
+                        try {
+                            const publicUrl = await uploadService.uploadFileAndGetUrl(fileInfo.fileUrlLocal, "TEMPORARY_MATERIAL_DOC");
+                            if (publicUrl) {
+                                fileInfo.fileUrl = publicUrl;
+                            }
+                            else {
+                                logger.warn("[AGENT-AS-SKILL] 上传文件未返回公网URL", { fileUrlLocal: fileInfo.fileUrlLocal });
+                            }
+                        }
+                        catch (uploadError) {
+                            logger.error("[AGENT-AS-SKILL] 上传本地文件失败", { fileUrlLocal: fileInfo.fileUrlLocal, error: uploadError });
+                            throw new Error(`上传本地文件失败 (${fileInfo.fileUrlLocal}): ${uploadError instanceof Error ? uploadError.message : String(uploadError)}`);
+                        }
+                    }
+                    // Remove fileUrlLocal from the final payload
+                    delete fileInfo.fileUrlLocal;
+                }
+            }
             // Get WebSocket manager
             const wsManager = getXYWebSocketManager(config);
             // Build ExecuteAgentAsSkill command
@@ -82,7 +133,7 @@ export function createAgentAsSkillTool(ctx) {
                 payload: {
                     agentId: params.agentId,
                     query: params.query,
-                    filesInfo: params.filesInfo || null,
+                    filesInfo: filesInfo || null,
                 },
             };
             // Send command and wait for response (5 minute timeout)
@@ -125,6 +176,7 @@ export function createAgentAsSkillTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 }).then(() => {
                     logger.log("[AGENT-AS-SKILL] Command sent successfully", { agentId: params.agentId });
                 }).catch((error) => {

package/dist/src/tools/calendar-tool.js

@@ -106,7 +106,7 @@ export function createCalendarTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`创建日程失败: ${event.status}`));
+                            reject(new Error(`创建日程失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -120,6 +120,7 @@ export function createCalendarTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

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

@@ -22,7 +22,6 @@ import { createUploadFileTool } from "./upload-file-tool.js";
 import { createSaveFileToPhoneTool } from "./save-file-to-phone-tool.js";
 import { createSendEmailTool } from "./send-email-tool.js";
 import { createSearchEmailTool } from "./search-email-tool.js";
-import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
 import { sendStatusUpdate } from "../formatter.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 /**
@@ -55,7 +54,6 @@ export function createCallDeviceTool(ctx) {
     const searchFileTool = createSearchFileTool(ctx);
     const saveFileToPhoneTool = createSaveFileToPhoneTool(ctx);
     const searchEmailTool = createSearchEmailTool(ctx);
-    const findPcDevicesTool = createFindPcDevicesTool(ctx);
     /**
      * 端工具注册表 —— 按 name 索引所有可通过 call_device_tool 调度的工具。
      */
@@ -84,7 +82,6 @@ export function createCallDeviceTool(ctx) {
         [saveFileToPhoneTool.name, saveFileToPhoneTool],
         [sendEmailTool.name, sendEmailTool],
         [searchEmailTool.name, searchEmailTool],
-        [findPcDevicesTool.name, findPcDevicesTool],
     ]);
     return {
         name: "call_device_tool",

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

@@ -98,7 +98,7 @@ export function createCallPhoneTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`拨打电话失败: ${event.status}`));
+                            reject(new Error(`拨打电话失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -112,6 +112,7 @@ export function createCallPhoneTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

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

@@ -244,7 +244,7 @@ b. 使用该工具之前需获取当前真实时间
                             });
                         }
                         else {
-                            reject(new Error(`创建闹钟失败: ${event.status}`));
+                            reject(new Error(`创建闹钟失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -258,6 +258,7 @@ b. 使用该工具之前需获取当前真实时间
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/create-all-tools.js

@@ -13,10 +13,12 @@ import { createGetPhotoToolSchemaTool } from "./get-photo-tool-schema.js";
 import { createGetDeviceFileToolSchemaTool } from "./get-device-file-tool-schema.js";
 import { createGetAlarmToolSchemaTool } from "./get-alarm-tool-schema.js";
 import { createGetCollectionToolSchemaTool } from "./get-collection-tool-schema.js";
-import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
+// import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
 import { createLoginTokenTool } from "./login-token-tool.js";
 import { createAgentAsSkillTool } from "./agent-as-skill-tool.js";
-import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
+import { createDiscoverCrossDevicesTool } from "./discover-cross-devices-tool.js";
+import { createSendCrossDeviceTaskTool } from "./send-cross-device-task-tool.js";
+import { createDisplayA2UICardTool } from "./display-a2ui-card-tool.js";
 import { logger } from "../utils/logger.js";
 /**
  * Create all XY channel tools for the given session context.
@@ -32,6 +34,9 @@ export function createAllTools(ctx) {
     logger.log(`[CREATE-ALL-TOOLS] creating tools`);
     return [
         createLocationTool(ctx),
+        createDiscoverCrossDevicesTool(ctx),
+        createSendCrossDeviceTaskTool(ctx),
+        createDisplayA2UICardTool(ctx),
         createCallDeviceTool(ctx),
         createGetNoteToolSchemaTool(ctx),
         createGetCalendarToolSchemaTool(ctx),
@@ -42,13 +47,12 @@ export function createAllTools(ctx) {
         createGetAlarmToolSchemaTool(ctx),
         createGetCollectionToolSchemaTool(ctx),
         createSendFileToUserTool(ctx),
-        createGetEmailToolSchemaTool(ctx),
+        // createGetEmailToolSchemaTool(ctx),
         viewPushResultTool,
         createImageReadingTool(ctx),
         timestampToUtc8Tool,
         createSaveSelfEvolutionSkillTool(ctx),
         createLoginTokenTool(ctx),
         createAgentAsSkillTool(ctx),
-        createFindPcDevicesTool(ctx),
     ];
 }

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

@@ -143,7 +143,7 @@ export function createDeleteAlarmTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`删除闹钟失败: ${event.status}`));
+                            reject(new Error(`删除闹钟失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -157,6 +157,7 @@ export function createDeleteAlarmTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

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

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

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

@@ -4,7 +4,7 @@
 //   - 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"];
+export const DEVICE_TYPES = ["car", "2in1", "phone", "web"];
 const DEVICE_TOOL_POLICY = {
     "2in1": {
         allowlist: false,
@@ -15,10 +15,17 @@ const DEVICE_TOOL_POLICY = {
             "search_message",
             "search_contact",
             "get_contact_tool_schema",
-            "query_collection",
-            "add_collection",
-            "delete_collection",
-            "get_collection_tool_schema",
+        ],
+    },
+    "web": {
+        allowlist: true,
+        tools: [
+            "send_file_to_user",
+            "view_push_result",
+            "image_reading",
+            "convert_time_to_utc8_time",
+            "save_self_evolution_skill",
+            "displayA2UICard",
         ],
     },
 };

package/dist/src/tools/discover-cross-devices-tool.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContext } from "./session-manager.js";
+export declare function createDiscoverCrossDevicesTool(ctx: SessionContext): any;

package/dist/src/tools/discover-cross-devices-tool.js

@@ -0,0 +1,235 @@
+import { sendCommand, sendStatusUpdate } from "../formatter.js";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentMessageId, getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+const DISCOVER_DEVICES_INTENT = "SearchAllDeviceInfo";
+const DISCOVER_DEVICES_BUNDLE = "com.huawei.hmos.vassistant";
+const DISCOVER_DEVICES_TIMEOUT_MS = 30_000;
+const LOG_TAG = "[GetPCDeviceList]";
+const DISCOVER_DEVICES_STATUS_TEXT = "正在查询设备列表...";
+const DEVICE_TYPE_LABELS = {
+    "14": "phone",
+    "17": "pad",
+    "131": "car",
+    "2607": "PC",
+};
+function buildResultText(result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+        ],
+    };
+}
+function normalizeDevices(rawDevices) {
+    if (!Array.isArray(rawDevices)) {
+        return [];
+    }
+    return rawDevices
+        .filter((item) => Boolean(item) && typeof item === "object")
+        .map((device) => {
+        const networkId = typeof device.networkId === "string"
+            ? device.networkId
+            : typeof device.deviceId === "string"
+                ? device.deviceId
+                : "";
+        const deviceTypeId = typeof device.deviceTypeId === "string"
+            ? device.deviceTypeId
+            : typeof device.deviceType === "string"
+                ? device.deviceType
+                : "";
+        return {
+            networkId,
+            deviceName: typeof device.deviceName === "string" ? device.deviceName : "",
+            deviceTypeId,
+            deviceTypeLabel: DEVICE_TYPE_LABELS[deviceTypeId] ?? "unknown",
+            nearby: device.nearby === true,
+            rawDevice: device,
+        };
+    });
+}
+function inferDesiredDeviceTypes(query) {
+    const normalized = query.toLowerCase();
+    if (/(pc|computer|desktop|laptop|notebook)/iu.test(normalized) || /电脑|台式机|笔记本/iu.test(query)) {
+        return ["2607"];
+    }
+    if (/(tablet|pad|ipad)/iu.test(normalized) || /平板/iu.test(query)) {
+        return ["17"];
+    }
+    if (/(phone|mobile)/iu.test(normalized) || /手机/iu.test(query)) {
+        return ["14"];
+    }
+    return [];
+}
+function sortByNearby(devices) {
+    return [...devices].sort((a, b) => Number(b.nearby) - Number(a.nearby));
+}
+function recommendDevices(query, devices) {
+    const desiredTypes = inferDesiredDeviceTypes(query);
+    if (desiredTypes.length === 0) {
+        return {
+            recommendedDevices: [],
+            recommendationReason: "No explicit target device type was detected in the query.",
+            needsUserSelection: devices.length > 1,
+            selectionPrompt: devices.length > 1
+                ? "The query does not identify a unique device type. Ask the user to choose a target device by deviceName or networkId before sending a cross-device task."
+                : "",
+        };
+    }
+    const matches = devices.filter((device) => desiredTypes.includes(device.deviceTypeId));
+    if (matches.length === 0) {
+        return {
+            recommendedDevices: [],
+            recommendationReason: `No discovered device matches requested type(s): ${desiredTypes.join(", ")}.`,
+            needsUserSelection: false,
+            selectionPrompt: "",
+        };
+    }
+    const sortedMatches = sortByNearby(matches);
+    return {
+        recommendedDevices: sortedMatches,
+        recommendationReason: `Matched requested device type(s): ${desiredTypes.join(", ")}. Nearby devices are ranked first.`,
+        needsUserSelection: sortedMatches.length > 1,
+        selectionPrompt: sortedMatches.length > 1
+            ? "Multiple candidate devices match the user request. Ask the user to choose one target device by deviceName or networkId before calling send_cross_device_task."
+            : "",
+    };
+}
+export function createDiscoverCrossDevicesTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "discover_cross_devices",
+        label: "发现跨设备协作设备",
+        description: `跨设备协作的设备发现工具。
+
+当用户明确表达要从另一台设备获取、查找、使用或操作内容时，必须优先调用本工具，例如从 PC、电脑、平板、手机等设备获取文件或查找内容。
+
+本工具只做设备发现和目标设备推荐，不会读取副设备文件内容，不会上传文件，也不会真正下发跨端执行任务。下发跨端执行任务需要使用SendCrossDeviceTaskTool`,
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "The user's original cross-device request, used to recommend the target device type.",
+                },
+            },
+            required: ["query"],
+        },
+        async execute(_toolCallId, params) {
+            const query = typeof params.query === "string" ? params.query.trim() : "";
+            logger.log(`${LOG_TAG} tool invoked`);
+            if (!query) {
+                return buildResultText({
+                    success: false,
+                    rawOutputs: null,
+                    devices: [],
+                    recommendedDevices: [],
+                    recommendationReason: "",
+                    message: "Missing required parameter: query.",
+                });
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+            const wsManager = getXYWebSocketManager(config);
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "Action",
+                },
+                payload: {
+                    needUploadResult: true,
+                    actionResponseConfig: {},
+                    response: [],
+                    executeParam: {
+                        executeMode: "background",
+                        intentName: DISCOVER_DEVICES_INTENT,
+                        intentParam: {},
+                        bundleName: DISCOVER_DEVICES_BUNDLE,
+                    },
+                },
+            };
+            return new Promise((resolve) => {
+                let timeout;
+                let handler;
+                let settled = false;
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                };
+                const finish = (result) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    cleanup();
+                    resolve(buildResultText(result));
+                };
+                handler = (event) => {
+                    if (event.intentName !== DISCOVER_DEVICES_INTENT) {
+                        return;
+                    }
+                    const rawOutputs = event.outputs ?? {};
+                    const code = rawOutputs.code;
+                    const success = event.status === "success" && String(code) === "0";
+                    const devices = normalizeDevices(rawOutputs.result?.devices);
+                    const recommendation = recommendDevices(query, devices);
+                    logger.log(`${LOG_TAG} completed, success=${success}, deviceCount=${devices.length}, recommendedCount=${recommendation.recommendedDevices.length}`);
+                    finish({
+                        success,
+                        rawOutputs,
+                        devices,
+                        recommendedDevices: recommendation.recommendedDevices,
+                        recommendationReason: recommendation.recommendationReason,
+                        needsUserSelection: recommendation.needsUserSelection,
+                        selectionPrompt: recommendation.selectionPrompt,
+                        message: success
+                            ? recommendation.needsUserSelection
+                                ? `Discovered ${devices.length} device(s). Multiple candidates may match; ask the user to choose the target device before sending a cross-device task.`
+                                : `Discovered ${devices.length} device(s). The model should choose the final target device based on the user request.`
+                            : "Device discovery failed on the device side.",
+                    });
+                };
+                timeout = setTimeout(() => {
+                    logger.log(`${LOG_TAG} timeout waiting UploadExeResult after ${DISCOVER_DEVICES_TIMEOUT_MS}ms`);
+                    finish({
+                        success: false,
+                        rawOutputs: null,
+                        devices: [],
+                        recommendedDevices: [],
+                        recommendationReason: "",
+                        message: `Device discovery timed out after ${DISCOVER_DEVICES_TIMEOUT_MS / 1000} seconds.`,
+                    });
+                }, DISCOVER_DEVICES_TIMEOUT_MS);
+                wsManager.on("data-event", handler);
+                sendStatusUpdate({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    text: DISCOVER_DEVICES_STATUS_TEXT,
+                    state: "working",
+                })
+                    .then(() => sendCommand({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    command,
+                }))
+                    .catch((error) => {
+                    logger.error(`${LOG_TAG} failed to send device discovery command: ${error instanceof Error ? error.message : String(error)}`);
+                    finish({
+                        success: false,
+                        rawOutputs: null,
+                        devices: [],
+                        recommendedDevices: [],
+                        recommendationReason: "",
+                        message: `Failed to send device discovery command: ${error instanceof Error ? error.message : String(error)}`,
+                    });
+                });
+            });
+        },
+    };
+}

package/dist/src/tools/display-a2ui-card-tool.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContext } from "./session-manager.js";
+export declare function createDisplayA2UICardTool(ctx: SessionContext): any;

package/dist/src/tools/display-a2ui-card-tool.js

@@ -0,0 +1,85 @@
+import { sendCommand } from "../formatter.js";
+import { getCurrentMessageId, getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+function isJsonObjectOrArray(value) {
+    return !!value && typeof value === "object";
+}
+export function createDisplayA2UICardTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "displayA2UICard",
+        label: "Display A2UI Card",
+        description: "当模型根据 MCP 工具返回结果判断需要向端侧下发 A2UI card 时调用。参数 cardId 和 cardData 由模型根据 MCP 工具返回结果传入，本工具只负责下发卡片展示指令。",
+        parameters: {
+            type: "object",
+            properties: {
+                cardId: {
+                    type: "string",
+                    description: "A2UI card 的唯一标识。",
+                },
+                cardData: {
+                    oneOf: [
+                        { type: "object" },
+                        { type: "array" },
+                    ],
+                    description: "A2UI card 渲染所需的 JSON 对象或 JSON 数组，由模型根据 MCP 工具返回结果填充。",
+                },
+            },
+            required: ["cardId", "cardData"],
+        },
+        async execute(toolCallId, params) {
+            const cardId = typeof params?.cardId === "string" ? params.cardId.trim() : "";
+            const cardData = params?.cardData;
+            if (!cardId) {
+                throw new ToolInputError("缺少必填参数: cardId");
+            }
+            if (!isJsonObjectOrArray(cardData)) {
+                throw new ToolInputError("缺少必填参数: cardData，且必须是 JSON 对象或 JSON 数组");
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "DisplayFACard",
+                },
+                payload: {
+                    isA2ui: true,
+                    a2uiParam: {
+                        cardId,
+                        cardData,
+                    },
+                },
+            };
+            logger.log(`[DISPLAY-A2UI-CARD] sending card, cardId=${cardId}`);
+            await sendCommand({
+                config,
+                sessionId,
+                taskId: currentTaskId,
+                messageId: currentMessageId,
+                command,
+                toolCallId,
+            });
+            logger.log(`[DISPLAY-A2UI-CARD] card sent successfully, cardId=${cardId}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            cardId,
+                            message: "A2UI card display command sent successfully.",
+                        }),
+                    },
+                ],
+            };
+        },
+    };
+}

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

@@ -82,6 +82,7 @@ export function createFindPcDevicesTool(ctx) {
                     taskId,
                     messageId,
                     command,
+                    toolCallId,
                 }).then(() => {
                 }).catch((error) => {
                     clearTimeout(timeout);

package/dist/src/tools/get-collection-tool-schema.js

@@ -6,7 +6,7 @@ export function createGetCollectionToolSchemaTool(ctx) {
     return createSchemaTool({
         name: "get_collection_tool_schema",
         label: "Get Collection Tool Schema",
-        description: "获取可在用户设备上添加、检索、删除小艺收藏中的公共知识数据的相关端工具列表。",
+        description: "获取可在用户设备上添加、检索、删除小艺收藏（也叫小艺帮记）中的公共知识数据的相关端工具列表。",
         tools: [createXiaoyiAddCollectionTool(ctx), createXiaoyiCollectionTool(ctx), createXiaoyiDeleteCollectionTool(ctx)],
     });
 }

package/dist/src/tools/get-device-file-tool-schema.js

@@ -2,14 +2,13 @@ import { createSchemaTool } from "./schema-tool-factory.js";
 import { createSearchFileTool } from "./search-file-tool.js";
 import { createUploadFileTool } from "./upload-file-tool.js";
 import { createSaveFileToPhoneTool } from "./save-file-to-phone-tool.js";
-import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
 export function createGetDeviceFileToolSchemaTool(ctx) {
     const searchFileTool = createSearchFileTool(ctx);
     const saveFileToPhoneTool = createSaveFileToPhoneTool(ctx);
     return createSchemaTool({
         name: "get_device_file_tool_schema",
         label: "Get Device File Tool Schema",
-        description: "获取可在用户设备上搜索文件系统的文件、将用户设备本地文件上传到公网并获取链接、保存文件到文件管理器、查找PC设备的相关端工具列表。",
-        tools: [searchFileTool, createUploadFileTool(ctx), saveFileToPhoneTool, createFindPcDevicesTool(ctx)],
+        description: "获取可在用户设备上搜索文件系统的文件、将用户设备本地文件上传到公网并获取链接、保存文件到文件管理器的相关端工具列表。",
+        tools: [searchFileTool, createUploadFileTool(ctx), saveFileToPhoneTool],
     });
 }

package/dist/src/tools/location-tool.js

@@ -75,7 +75,7 @@ export function createLocationTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`获取位置失败: ${event.status}`));
+                            reject(new Error(`获取位置失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -90,6 +90,7 @@ export function createLocationTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 }).then(() => {
                 }).catch((error) => {
                     clearTimeout(timeout);