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

package/dist/src/tools/send-cross-device-task-tool.js

@@ -0,0 +1,299 @@
+import { sendCommand, sendStatusUpdate } from "../formatter.js";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentMessageId, getCurrentTaskId } from "../task-manager.js";
+import { createSendFileToUserTool } from "./send-file-to-user-tool.js";
+import { logger } from "../utils/logger.js";
+const LOG_TAG = "[SendPcDeviceTask]";
+const SEND_CROSS_RESULT_LOG_TAG = "[SendCrossResult]";
+const CROSS_DEVICE_TASK_TIMEOUT_MS = 5 * 60_000;
+const PEER_TASK_COMPLETED_STATUS_TEXT = "对端设备已完成当前任务，正在处理中 ...";
+function buildResultText(result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+        ],
+    };
+}
+function buildModelToolResult(result) {
+    const sentFiles = result.sentFiles;
+    const resultStatus = result.success
+        ? sentFiles.length > 0
+            ? "对端设备执行任务成功且返回有文件"
+            : "对端设备执行任务成功且返回无文件"
+        : "对端设备任务失败";
+    const baseMessage = result.message || "对端设备未返回具体结果。";
+    let message = `跨端任务执行结果：${baseMessage}`;
+    if (resultStatus === "对端设备执行任务成功且返回有文件") {
+        if (result.autoSendFileToUser?.success) {
+            message += "\n\n对端设备返回了文件，系统已自动通过 send_file_to_user 将文件卡片发送给用户。请你基于跨端任务结果生成最终回复，告知用户任务已完成且文件已发送。";
+        }
+        else {
+            const errorMessage = result.autoSendFileToUser?.error || "未知错误";
+            message += `\n\n对端设备返回了文件，但系统自动发送文件卡片失败：${errorMessage}。请你向用户说明任务已完成但文件发送失败。`;
+        }
+    }
+    else if (resultStatus === "对端设备执行任务成功且返回无文件") {
+        message += "\n\n对端设备未返回文件。请你直接根据跨端任务结果向用户总结完成情况。";
+    }
+    else {
+        message += "\n\n对端设备任务失败。请你向用户说明失败情况，并给出可重试或调整任务描述的建议。";
+    }
+    return {
+        message,
+        resultStatus,
+    };
+}
+function buildCrossDeviceResult(params) {
+    const result = {
+        success: params.success,
+        code: params.code,
+        message: params.message,
+        sentFiles: params.sentFiles,
+        rawEvent: params.rawEvent,
+    };
+    return result;
+}
+async function autoSendFileToUserIfNeeded(result, ctx) {
+    const sentFiles = Array.isArray(result.sentFiles) ? result.sentFiles : [];
+    if (sentFiles.length === 0) {
+        return result;
+    }
+    logger.log(`${SEND_CROSS_RESULT_LOG_TAG} auto sending ${sentFiles.length} cross-device file(s) to user`);
+    try {
+        const sendFileTool = createSendFileToUserTool(ctx);
+        const sendFileResult = await (async () => {
+            const results = [];
+            for (const sentFileParams of sentFiles) {
+                results.push(await sendFileTool.execute("auto_send_cross_device_file", sentFileParams));
+            }
+            return results;
+        })();
+        logger.log(`${SEND_CROSS_RESULT_LOG_TAG} auto send_file_to_user completed`);
+        return {
+            ...result,
+            autoSendFileToUser: {
+                success: true,
+                result: sendFileResult,
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`${SEND_CROSS_RESULT_LOG_TAG} auto send_file_to_user failed, error=${errorMessage}`);
+        return {
+            ...result,
+            autoSendFileToUser: {
+                success: false,
+                error: errorMessage,
+            },
+        };
+    }
+}
+function normalizeTargetDeviceInfo(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    const networkId = typeof candidate.networkId === "string"
+        ? candidate.networkId.trim()
+        : typeof candidate.deviceId === "string"
+            ? candidate.deviceId.trim()
+            : "";
+    const deviceName = typeof candidate.deviceName === "string" ? candidate.deviceName.trim() : "";
+    const deviceTypeId = typeof candidate.deviceTypeId === "string"
+        ? candidate.deviceTypeId.trim()
+        : typeof candidate.deviceType === "string"
+            ? candidate.deviceType.trim()
+            : "";
+    if (!networkId || !deviceName || !deviceTypeId) {
+        return null;
+    }
+    return {
+        networkId,
+        deviceName,
+        deviceTypeId,
+    };
+}
+function buildUnifiedDistributeCommand(query, targetDeviceInfo, distributionSessionId) {
+    return {
+        header: {
+            namespace: "DistributionInteraction",
+            name: "UnifiedDistribute",
+        },
+        payload: {
+            targetDeviceInfo,
+            crossDeviceContent: {
+                query,
+                contexts: {
+                    agentClientContext: {
+                        header: {
+                            namespace: "System",
+                            name: "ClientContext",
+                        },
+                        payload: {
+                            agentId: "",
+                            isSupportAgent: true,
+                            distributionSessionId,
+                            localNetworkId: targetDeviceInfo.networkId,
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+export function createSendCrossDeviceTaskTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "send_cross_device_task",
+        label: "下发跨设备协作任务",
+        description: `向用户已经选定的目标设备下发跨设备协作任务。
+
+使用流程：
+1. 必须先调用 discover_cross_devices 获取设备列表。
+2. 根据用户原始需求选择唯一目标设备。
+3. 如果存在多个同类型候选设备，或无法判断目标设备，必须先询问用户选择设备，不要调用本工具。
+4. 只有当 targetDeviceInfo 中的 networkId、deviceName、deviceTypeId 都已明确时，才调用本工具。
+5. 传入的query必须是用户原始query，不要做任何更改。`,
+        parameters: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "用户原始跨设备任务需求，例如：从 PC 获取某文件。",
+                },
+                targetDeviceInfo: {
+                    type: "object",
+                    description: "模型从 discover_cross_devices 返回列表中选定的唯一目标设备。",
+                    properties: {
+                        networkId: {
+                            type: "string",
+                            description: "目标设备标识 networkId。",
+                        },
+                        deviceName: {
+                            type: "string",
+                            description: "目标设备名称。",
+                        },
+                        deviceTypeId: {
+                            type: "string",
+                            description: "目标设备类型编号 deviceTypeId，例如 14、17、131、2607。",
+                        },
+                    },
+                    required: ["networkId", "deviceName", "deviceTypeId"],
+                },
+            },
+            required: ["query", "targetDeviceInfo"],
+        },
+        async execute(_toolCallId, params) {
+            const query = typeof params.query === "string" ? params.query.trim() : "";
+            const targetDeviceInfo = normalizeTargetDeviceInfo(params.targetDeviceInfo);
+            if (!query || !targetDeviceInfo) {
+                return buildResultText({
+                    message: "Missing required parameters: query and targetDeviceInfo.networkId/deviceName/deviceTypeId.",
+                    resultStatus: "对端设备任务失败",
+                });
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+            const wsManager = getXYWebSocketManager(config);
+            const distributionSessionId = ctx.distributionSessionId || sessionId;
+            const command = buildUnifiedDistributeCommand(query, targetDeviceInfo, distributionSessionId);
+            const statusText = `正在调用${targetDeviceInfo.deviceName}执行“${query}”跨设备任务...`;
+            logger.log(`${LOG_TAG} sending task to ${targetDeviceInfo.deviceName}, distributionSessionId=${distributionSessionId}`);
+            return new Promise((resolve) => {
+                let timeout;
+                let handler;
+                let settled = false;
+                let resultHandlingStarted = false;
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    wsManager.off("cross-device-task-result", handler);
+                };
+                const finish = (result) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    const modelResult = buildModelToolResult(result);
+                    logger.log(`${LOG_TAG} completed, success=${result.success}, code=${result.code}, sentFileCount=${result.sentFiles.length}`);
+                    cleanup();
+                    resolve(buildResultText(modelResult));
+                };
+                handler = (event) => {
+                    if (event.sessionId && event.sessionId !== sessionId && event.sessionId !== distributionSessionId) {
+                        return;
+                    }
+                    logger.log(`${SEND_CROSS_RESULT_LOG_TAG} received result, status=${event.status}, code=${event.code}, sentFileCount=${event.sentFiles.length}`);
+                    void (async () => {
+                        if (resultHandlingStarted) {
+                            return;
+                        }
+                        resultHandlingStarted = true;
+                        clearTimeout(timeout);
+                        try {
+                            await sendStatusUpdate({
+                                config,
+                                sessionId,
+                                taskId: currentTaskId,
+                                messageId: currentMessageId,
+                                text: PEER_TASK_COMPLETED_STATUS_TEXT,
+                                state: "working",
+                            });
+                        }
+                        catch (error) {
+                            logger.error(`${SEND_CROSS_RESULT_LOG_TAG} failed to send peer task completed status update: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                        const result = buildCrossDeviceResult({
+                            success: event.status === "success",
+                            code: event.code,
+                            message: event.message,
+                            sentFiles: event.sentFiles,
+                            rawEvent: event.rawEvent,
+                        });
+                        const resultWithFileSend = await autoSendFileToUserIfNeeded(result, ctx);
+                        finish(resultWithFileSend);
+                    })();
+                };
+                timeout = setTimeout(() => {
+                    logger.log(`${LOG_TAG} timeout waiting cross-device result after ${CROSS_DEVICE_TASK_TIMEOUT_MS}ms`);
+                    finish({
+                        success: false,
+                        code: "",
+                        message: `Cross-device task timed out after ${CROSS_DEVICE_TASK_TIMEOUT_MS / 1000} seconds.`,
+                        sentFiles: [],
+                        rawEvent: null,
+                    });
+                }, CROSS_DEVICE_TASK_TIMEOUT_MS);
+                wsManager.on("cross-device-task-result", handler);
+                sendStatusUpdate({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    text: statusText,
+                    state: "working",
+                })
+                    .then(() => sendCommand({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId: currentMessageId,
+                    command,
+                }))
+                    .catch((error) => {
+                    logger.error(`${LOG_TAG} failed to send cross-device task command: ${error instanceof Error ? error.message : String(error)}`);
+                    finish({
+                        success: false,
+                        code: "",
+                        message: `Failed to send cross-device task command: ${error instanceof Error ? error.message : String(error)}`,
+                        sentFiles: [],
+                        rawEvent: null,
+                    });
+                });
+            });
+        },
+    };
+}

package/dist/src/tools/send-email-tool.js

@@ -43,7 +43,7 @@ c. 调用工具前需认真检查调用参数是否满足工具要求
             },
             required: ["subject", "to", "body"],
         },
-        async execute(_toolCallId, params) {
+        async execute(toolCallId, params) {
             if (typeof params.subject !== "string" || !params.subject.trim()) {
                 throw new ToolInputError("缺少必填参数 subject（邮件主题）");
             }
@@ -92,7 +92,7 @@ c. 调用工具前需认真检查调用参数是否满足工具要求
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     wsManager.off("data-event", handler);
-                    logger.error("超时: 发送邮件超时（60秒）", { toolCallId: _toolCallId });
+                    logger.error("超时: 发送邮件超时（60秒）", { toolCallId: toolCallId });
                     reject(new Error("发送邮件超时（60秒）"));
                 }, 60000);
                 const handler = (event) => {
@@ -110,7 +110,7 @@ c. 调用工具前需认真检查调用参数是否满足工具要求
                             });
                         }
                         else {
-                            reject(new Error(`发送邮件失败: ${event.status}`));
+                            reject(new Error(`发送邮件失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -122,6 +122,7 @@ c. 调用工具前需认真检查调用参数是否满足工具要求
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => { })
                     .catch((error) => {

package/dist/src/tools/send-file-to-user-tool.d.ts

@@ -1,4 +1,4 @@
-import type { SessionContext } from "./session-manager.js";
+import { type SessionContext } from "./session-manager.js";
 /**
  * XY send file to user tool - sends local files or remote files to user's device.
  * Supports both local file paths and remote URLs.

package/dist/src/tools/send-file-to-user-tool.js

@@ -1,5 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { XYFileUploadService } from "../file-upload.js";
+import { appendRunCrossTaskSentFiles } from "./session-manager.js";
 import { logger } from "../utils/logger.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 import fetch from "node-fetch";
@@ -64,16 +65,22 @@ function normalizeToArray(param) {
 /**
  * Download remote file to local temp directory
  */
-async function downloadRemoteFile(url) {
+async function downloadRemoteFile(url, desiredFilename) {
     try {
         const response = await fetch(url);
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
         }
-        // Get filename from URL or use default
-        let filename = url.split("/").pop() || "downloaded_file";
-        // Remove query parameters if present
-        filename = filename.split("?")[0];
+        // Use desired filename if provided, otherwise extract from URL
+        let filename;
+        if (desiredFilename) {
+            filename = desiredFilename;
+        }
+        else {
+            filename = url.split("/").pop() || "downloaded_file";
+            // Remove query parameters if present
+            filename = filename.split("?")[0];
+        }
         // Ensure temp directory exists
         const tempDir = "/tmp/xy_channel";
         await fs.mkdir(tempDir, { recursive: true });
@@ -119,6 +126,9 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                 fileRemoteUrls: {
                     description: "公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送），注意不要对原始url做任何截断（例如裁减掉链接后面的鉴权信息或者修改域名后缀），必须使用上下文中完整的文件地址",
                 },
+                fileNames: {
+                    description: "文件名数组，与 fileRemoteUrls 一一对应，用于指定下载后的文件名。必须从 search_file 工具返回结果中提取每个文件的原始文件名，根据uoploadfile工具的顺序传入。",
+                },
             },
         },
         async execute(toolCallId, params) {
@@ -156,6 +166,24 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                         throw new Error("fileRemoteUrls array cannot be empty");
                     }
                 }
+                // Normalize fileNames parameter
+                let fileNames = [];
+                if (params.fileNames) {
+                    fileNames = normalizeToArray(params.fileNames);
+                    if (fileNames.length > 0 && fileNames.length !== fileRemoteUrls.length) {
+                        throw new Error(`fileNames length (${fileNames.length}) must match fileRemoteUrls length (${fileRemoteUrls.length})`);
+                    }
+                }
+                if (ctx.runCrossTaskContext && (fileLocalUrls.length > 0 || fileRemoteUrls.length > 0)) {
+                    const cachedSentFiles = appendRunCrossTaskSentFiles([
+                        {
+                            ...(fileLocalUrls.length > 0 ? { fileLocalUrls } : {}),
+                            ...(fileRemoteUrls.length > 0 ? { fileRemoteUrls } : {}),
+                            ...(fileNames.length > 0 ? { fileNames } : {}),
+                        },
+                    ], ctx.runCrossTaskContext);
+                    logger.log(`[RunCrossTask] cached ${cachedSentFiles.length} send_file_to_user input(s) for cross-task result`);
+                }
                 // Get WebSocket manager
                 const wsManager = getXYWebSocketManager(config);
                 // Create upload service
@@ -168,7 +196,8 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                     for (let i = 0; i < fileRemoteUrls.length; i++) {
                         const remoteUrl = fileRemoteUrls[i];
                         try {
-                            const localPath = await downloadRemoteFile(remoteUrl);
+                            const desiredName = fileNames[i] || undefined;
+                            const localPath = await downloadRemoteFile(remoteUrl, desiredName);
                             allLocalPaths.push(localPath);
                             downloadedFiles.push(localPath);
                         }

package/dist/src/tools/send-message-tool.js

@@ -124,6 +124,7 @@ export function createSendMessageTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

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

@@ -1,18 +1,29 @@
 import { AsyncLocalStorage } from "async_hooks";
-import type { XYChannelConfig } from "../types.js";
+import type { RunCrossTaskContext, SentFileParams, XYChannelConfig } from "../types.js";
 export interface SessionContext {
     config: XYChannelConfig;
     sessionId: string;
+    distributionSessionId?: string;
     taskId: string;
     messageId: string;
     agentId: string;
     deviceType?: string;
+    runCrossTaskContext?: RunCrossTaskContext;
+    /** When true, this context was created for a cron/scheduled task execution.
+     *  Tools should use the push channel instead of WebSocket sendCommand. */
+    isCron?: boolean;
 }
 interface SessionContextWithRef extends SessionContext {
     refCount: number;
     createdAt: number;
 }
 export declare const activeSessions: Map<string, SessionContextWithRef>;
+/** Mark a toolCallId as originating from a cron trigger. */
+export declare function markCronToolCall(toolCallId: string): void;
+/** Check whether a toolCallId is from a cron trigger. */
+export declare function isCronToolCall(toolCallId?: string): boolean;
+/** Clean up a cron tool call marker after use. */
+export declare function clearCronToolCall(toolCallId: string): void;
 export declare const asyncLocalStorage: AsyncLocalStorage<SessionContext>;
 /**
  * Register a session context for tool access.
@@ -65,4 +76,6 @@ export declare function cleanupStaleSessions(): number;
  * Get the current number of active sessions (for diagnostics).
  */
 export declare function getActiveSessionCount(): number;
+export declare function appendRunCrossTaskSentFiles(sentFiles: SentFileParams[], explicitRunCrossTaskContext?: RunCrossTaskContext): SentFileParams[];
+export declare function clearRunCrossTaskSentFiles(explicitRunCrossTaskContext?: RunCrossTaskContext): void;
 export {};

package/dist/src/tools/session-manager.js

@@ -25,6 +25,29 @@ if (!_g.__xyLastRegisteredSessionKey) {
 }
 const getLastRegisteredKey = () => _g.__xyLastRegisteredSessionKey;
 const setLastRegisteredKey = (key) => { _g.__xyLastRegisteredSessionKey = key; };
+// ── Cron tool-call tracking ─────────────────────────────────────────
+// Global Map keyed by toolCallId to track whether a specific tool call
+// originated from a cron/scheduled task.  Populated by the
+// `before_tool_call` hook (which receives openclaw's sessionKey with
+// "cron:" prefix), consumed by sendCommand() to route through push channel.
+if (!_g.__xyCronToolCallMap) {
+    _g.__xyCronToolCallMap = new Map();
+}
+const cronToolCallMap = _g.__xyCronToolCallMap;
+/** Mark a toolCallId as originating from a cron trigger. */
+export function markCronToolCall(toolCallId) {
+    cronToolCallMap.set(toolCallId, true);
+}
+/** Check whether a toolCallId is from a cron trigger. */
+export function isCronToolCall(toolCallId) {
+    if (!toolCallId)
+        return false;
+    return cronToolCallMap.get(toolCallId) === true;
+}
+/** Clean up a cron tool call marker after use. */
+export function clearCronToolCall(toolCallId) {
+    cronToolCallMap.delete(toolCallId);
+}
 // AsyncLocalStorage for thread-safe session context isolation
 export const asyncLocalStorage = new AsyncLocalStorage();
 // Export AsyncLocalStorage to globalThis so logger.ts can access it
@@ -214,6 +237,56 @@ export function cleanupStaleSessions() {
 export function getActiveSessionCount() {
     return activeSessions.size;
 }
+function normalizeSentFileParams(params) {
+    const fileLocalUrls = Array.isArray(params.fileLocalUrls)
+        ? params.fileLocalUrls.filter((url) => typeof url === "string" && url.length > 0)
+        : [];
+    const fileRemoteUrls = Array.isArray(params.fileRemoteUrls)
+        ? params.fileRemoteUrls.filter((url) => typeof url === "string" && url.length > 0)
+        : [];
+    const fileNames = Array.isArray(params.fileNames)
+        ? params.fileNames.filter((name) => typeof name === "string" && name.length > 0)
+        : [];
+    if (fileLocalUrls.length === 0 && fileRemoteUrls.length === 0) {
+        return null;
+    }
+    return {
+        ...(fileLocalUrls.length > 0 ? { fileLocalUrls } : {}),
+        ...(fileRemoteUrls.length > 0 ? { fileRemoteUrls } : {}),
+        ...(fileNames.length > 0 && fileNames.length === fileRemoteUrls.length ? { fileNames } : {}),
+    };
+}
+export function appendRunCrossTaskSentFiles(sentFiles, explicitRunCrossTaskContext) {
+    const context = asyncLocalStorage.getStore() ?? null;
+    const runCrossTaskContext = explicitRunCrossTaskContext ?? context?.runCrossTaskContext;
+    const normalizedSentFiles = sentFiles
+        .map((params) => normalizeSentFileParams(params))
+        .filter((params) => params !== null);
+    if (!runCrossTaskContext || normalizedSentFiles.length === 0) {
+        return runCrossTaskContext?.sentFiles ?? [];
+    }
+    const existing = Array.isArray(runCrossTaskContext.sentFiles) ? runCrossTaskContext.sentFiles : [];
+    const merged = [...existing, ...normalizedSentFiles];
+    runCrossTaskContext.sentFiles = merged;
+    const sessionWithRef = Array.from(activeSessions.values()).find((session) => session.runCrossTaskContext === runCrossTaskContext);
+    if (sessionWithRef?.runCrossTaskContext) {
+        sessionWithRef.runCrossTaskContext.sentFiles = merged;
+    }
+    return merged;
+}
+export function clearRunCrossTaskSentFiles(explicitRunCrossTaskContext) {
+    const context = asyncLocalStorage.getStore() ?? null;
+    const runCrossTaskContext = explicitRunCrossTaskContext ?? context?.runCrossTaskContext;
+    if (!runCrossTaskContext) {
+        return;
+    }
+    runCrossTaskContext.sentFiles = [];
+    for (const sessionWithRef of activeSessions.values()) {
+        if (sessionWithRef.runCrossTaskContext === runCrossTaskContext) {
+            sessionWithRef.runCrossTaskContext.sentFiles = [];
+        }
+    }
+}
 /**
  * Enrich a base session context with the latest taskId/messageId
  * from task-manager (supports interruption scenarios).

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

@@ -19,19 +19,14 @@ export function createUploadFileTool(ctx) {
     return {
         name: "upload_file",
         label: "Upload File",
-        description: `工具能力描述：将手机或PC/电脑本地文件上传并获取可公网访问的 URL。
+        description: `工具能力描述：将用户设备（可以使手机或者鸿蒙PC等）本地文件上传并获取可公网访问的 URL。
 
   前置工具调用：此工具使用前必须先通过call_device_tool调用 search_file 或者 query_collection 工具获取文件的 uri
 
-  使用场景与调用流程：
-  1. 上传手机文件：直接调用此工具，无需传入 udid。
-  2. 上传PC/电脑文件：当用户要求上传PC/电脑上的文件时，需要先通过 find_pc_devices 工具获取设备ID（udid），然后将 udid 传入此工具。
-
   工具参数说明：
   a. 入参中的fileInfos数组，每个元素必须包含mediaUri字段（对应于search_file工具或者query_collection返回结果中的uri），必须与search_file或者query_collection结果中对应的uri完全保持一致，不要自行修改。
   b. fileInfos中的timeout字段是可选的，表示上传文件超时时间，单位是毫秒，默认是20000（20秒）。
   c. fileInfos 是文件在本地的信息数组（从 search_file 工具或者query_collection 工具响应中获取）。限制：每次最多支持传入 5 条文件信息。
-  d. udid 是PC/电脑设备ID，仅在上传PC/电脑文件时需要传入（通过 find_pc_devices 工具获取）。
 
   注意事项：
   a. 操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。
@@ -43,11 +38,7 @@ export function createUploadFileTool(ctx) {
                     // 不指定 type，允许传入数组或 JSON 字符串
                     // 具体的类型验证和转换在 execute 函数内部进行
                     description: "文件信息数组，每个元素包含mediaUri（必需）和timeout（可选，默认20000）。必须先通过 search_file 工具获取。每次最多支持 5 条文件信息。",
-                },
-                udid: {
-                    type: "string",
-                    description: "PC/电脑设备ID。当上传PC/电脑上的文件时，需要先通过 find_pc_devices 工具获取设备ID后传入。上传手机文件时不需要传入此参数。",
-                },
+                }
             },
             required: ["fileInfos"],
         },
@@ -106,7 +97,7 @@ export function createUploadFileTool(ctx) {
             const wsManager = getXYWebSocketManager(config);
             // Get public URLs for the files
             const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-            const fileUrls = await getFileUrls(wsManager, config, sessionId, currentTaskId, messageId, fileInfos, params.udid);
+            const fileUrls = await getFileUrls(wsManager, config, sessionId, currentTaskId, messageId, toolCallId, fileInfos, params.udid);
             return {
                 content: [
                     {
@@ -126,7 +117,7 @@ export function createUploadFileTool(ctx) {
  * Get public URLs for files using fileInfos
  * Returns array of publicly accessible file URLs
  */
-async function getFileUrls(wsManager, config, sessionId, taskId, messageId, fileInfos, udid) {
+async function getFileUrls(wsManager, config, sessionId, taskId, messageId, toolCallId, fileInfos, udid) {
     const command = {
         header: {
             namespace: "Common",
@@ -203,7 +194,7 @@ async function getFileUrls(wsManager, config, sessionId, taskId, messageId, file
                     resolve(fileUrls);
                 }
                 else {
-                    reject(new Error(`获取文件URL失败: ${event.status}`));
+                    reject(new Error(`获取文件URL失败: ${JSON.stringify(event.outputs)}`));
                 }
             }
         };
@@ -214,6 +205,7 @@ async function getFileUrls(wsManager, config, sessionId, taskId, messageId, file
             taskId,
             messageId,
             command,
+            toolCallId,
         })
             .then(() => {
         })

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

@@ -78,7 +78,7 @@ export function createUploadPhotoTool(ctx) {
             const wsManager = getXYWebSocketManager(config);
             // Get public URLs for the photos
             const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-            const imageUrls = await getPhotoUrls(wsManager, config, sessionId, currentTaskId, messageId, mediaUris);
+            const imageUrls = await getPhotoUrls(wsManager, config, sessionId, currentTaskId, messageId, toolCallId, mediaUris);
             return {
                 content: [
                     {
@@ -98,7 +98,7 @@ export function createUploadPhotoTool(ctx) {
  * Get public URLs for photos using mediaUris
  * Returns array of publicly accessible image URLs
  */
-async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, mediaUris) {
+async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, toolCallId, mediaUris) {
     // Build imageInfos array from mediaUris
     const imageInfos = mediaUris.map(mediaUri => ({ mediaUri }));
     const command = {
@@ -158,7 +158,7 @@ async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, med
                     resolve(imageUrls);
                 }
                 else {
-                    reject(new Error(`获取照片URL失败: ${event.status}`));
+                    reject(new Error(`获取照片URL失败: ${JSON.stringify(event.outputs)}`));
                 }
             }
         };
@@ -169,6 +169,7 @@ async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, med
             taskId,
             messageId,
             command,
+            toolCallId,
         })
             .then(() => {
         })