@ynhcj/xiaoyi-channel 0.0.152-beta → 0.0.154-beta

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

@@ -0,0 +1,303 @@
+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 fileUrls = result.fileUrls;
+    const resultStatus = result.success
+        ? fileUrls.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 extractFileUrl(message) {
+    const matches = message.match(/https?:\/\/[^\s<>"']+/g);
+    const firstUrl = matches?.[0] ?? "";
+    return firstUrl.replace(/[，。；、！？,.!?;:)\]}]+$/u, "");
+}
+function buildCrossDeviceResult(params) {
+    const payloadFileUrls = params.success ? params.fileUrls.filter((url) => typeof url === "string" && url.length > 0) : [];
+    const messageFileUrl = params.success ? extractFileUrl(params.message) : "";
+    const fileUrls = Array.from(new Set([...payloadFileUrls, ...(messageFileUrl ? [messageFileUrl] : [])]));
+    const result = {
+        success: params.success,
+        code: params.code,
+        message: params.message,
+        fileUrls,
+        rawEvent: params.rawEvent,
+    };
+    return result;
+}
+async function autoSendFileToUserIfNeeded(result, ctx) {
+    const fileUrls = result.fileUrls;
+    if (fileUrls.length === 0) {
+        return result;
+    }
+    logger.log(`${SEND_CROSS_RESULT_LOG_TAG} auto sending ${fileUrls.length} cross-device file(s) to user`);
+    try {
+        const sendFileTool = createSendFileToUserTool(ctx);
+        const sendFileResult = await sendFileTool.execute("auto_send_cross_device_file", {
+            fileRemoteUrls: fileUrls,
+        });
+        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}, fileUrlCount=${result.fileUrls.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}, fileUrlCount=${event.fileUrls.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,
+                            fileUrls: event.fileUrls,
+                            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.`,
+                        fileUrls: [],
+                        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)}`,
+                        fileUrls: [],
+                        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) => {
@@ -122,6 +122,7 @@ c. 调用工具前需认真检查调用参数是否满足工具要求
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => { })
                     .catch((error) => {

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, 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,5 @@ export declare function cleanupStaleSessions(): number;
  * Get the current number of active sessions (for diagnostics).
  */
 export declare function getActiveSessionCount(): number;
+export declare function appendRunCrossTaskFileUrls(fileUrls: string[], explicitRunCrossTaskContext?: RunCrossTaskContext): string[];
 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,21 @@ export function cleanupStaleSessions() {
 export function getActiveSessionCount() {
     return activeSessions.size;
 }
+export function appendRunCrossTaskFileUrls(fileUrls, explicitRunCrossTaskContext) {
+    const context = asyncLocalStorage.getStore() ?? null;
+    const runCrossTaskContext = explicitRunCrossTaskContext ?? context?.runCrossTaskContext;
+    if (!runCrossTaskContext || fileUrls.length === 0) {
+        return runCrossTaskContext?.fileUrls ?? [];
+    }
+    const existing = Array.isArray(runCrossTaskContext.fileUrls) ? runCrossTaskContext.fileUrls : [];
+    const merged = Array.from(new Set([...existing, ...fileUrls.filter((url) => typeof url === "string" && url.length > 0)]));
+    runCrossTaskContext.fileUrls = merged;
+    const sessionWithRef = Array.from(activeSessions.values()).find((session) => session.runCrossTaskContext === runCrossTaskContext);
+    if (sessionWithRef?.runCrossTaskContext) {
+        sessionWithRef.runCrossTaskContext.fileUrls = merged;
+    }
+    return merged;
+}
 /**
  * Enrich a base session context with the latest taskId/messageId
  * from task-manager (supports interruption scenarios).

package/dist/src/tools/upload-file-tool.d.ts

@@ -1,4 +1,4 @@
-import type { SessionContext } from "./session-manager.js";
+import { type SessionContext } from "./session-manager.js";
 /**
  * XY upload file tool - uploads local files to get publicly accessible URLs.
  * Requires file URIs from search_file tool as prerequisite.

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

@@ -1,5 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
+import { appendRunCrossTaskFileUrls } from "./session-manager.js";
 import { getCurrentTaskId } from "../task-manager.js";
 import { logger } from "../utils/logger.js";
 /**
@@ -106,7 +107,11 @@ 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);
+            if (ctx.runCrossTaskContext && fileUrls.length > 0) {
+                const cachedFileUrls = appendRunCrossTaskFileUrls(fileUrls, ctx.runCrossTaskContext);
+                logger.log(`[RunCrossTask] cached ${fileUrls.length} upload_file URL(s) for cross-task result, total=${cachedFileUrls.length}`);
+            }
             return {
                 content: [
                     {
@@ -126,7 +131,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",
@@ -214,6 +219,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 = {
@@ -169,6 +169,7 @@ async function getPhotoUrls(wsManager, config, sessionId, taskId, messageId, med
             taskId,
             messageId,
             command,
+            toolCallId,
         })
             .then(() => {
         })

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

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

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

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

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

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

package/dist/src/tools/xiaoyi-gui-tool.js

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

package/dist/src/types.d.ts

@@ -62,6 +62,23 @@ export interface A2ADataEvent {
     outputs: Record<string, any>;
     status: "success" | "failed";
 }
+export interface CrossDeviceTaskResultEvent {
+    sessionId: string;
+    code: string;
+    message: string;
+    fileUrls: string[];
+    status: "success" | "failed";
+    rawEvent: any;
+}
+export interface RunCrossTaskContext {
+    agentId: string;
+    sessionId: string;
+    isDistributed: boolean;
+    networkId: string;
+    isSupportAgent: boolean;
+    fileUrls?: string[];
+    rawContext: any;
+}
 export interface A2ATaskArtifactUpdateEvent {
     taskId: string;
     kind: "artifact-update";

package/dist/src/websocket.d.ts

@@ -102,6 +102,9 @@ export declare class XYWebSocketManager extends EventEmitter {
      * Start heartbeat.
      */
     private startHeartbeat;
+    private toUploadExeDataEvent;
+    private toCrossDeviceTaskResultEvent;
+    private toRunCrossTaskA2ARequest;
     /**
      * Handle incoming message from server.
      */