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

package/dist/src/tools/check-plugin-privilege-tool.js

@@ -0,0 +1,182 @@
+// Check plugin privilege tool implementation
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Mapping from intent name to required permission IDs.
+ */
+const INTENT_PERMISSION_MAP = {
+    GetCurrentLocation: ["ohos.permission.LOCATION", "ohos.permission.APPROXIMATELY_LOCATION"],
+    SearchCalendarEvent: ["ohos.permission.READ_WHOLE_CALENDAR"],
+    CreateCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    DeleteCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    ModifyCalendarEvent: ["ohos.permission.WRITE_WHOLE_CALENDAR"],
+    SearchNote: ["ohos.permission.READ_NOTE"],
+    CreateNote: ["ohos.permission.WRITE_NOTE"],
+    ModifyNote: ["ohos.permission.WRITE_NOTE"],
+    SearchContactLocal: ["ohos.permission.READ_CONTACTS"],
+    SearchPhotoVideo: ["ohos.permission.READ_IMAGEVIDEO"],
+    SaveMediaToGallery: ["ohos.permission.WRITE_IMAGEVIDEO"],
+    SearchFile: ["ohos.permission.FILE_ACCESS_MANAGER"],
+    SaveFileToFileManager: ["ohos.permission.FILE_SAVE_MANAGER"],
+    SearchAlarm: ["ohos.permission.READ_ALARM"],
+    CreateAlarm: ["ohos.permission.WRITE_ALARM"],
+    ModifyAlarm: ["ohos.permission.WRITE_ALARM"],
+    DeleteAlarm: ["ohos.permission.WRITE_ALARM"],
+    SearchMessage: ["ohos.permission.READ_SMS"],
+    SendShortMessage: ["ohos.permission.SEND_MESSAGES"],
+    StartCall: ["ohos.permission.PLACE_CALL"],
+};
+/**
+ * XY check plugin privilege tool - checks user authorization for device-side tools
+ * used in scheduled tasks.
+ */
+export function createCheckPluginPrivilegeTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "check_plugin_privilege",
+        label: "Check Plugin Privilege",
+        description: "定时任务权限检查工具。" +
+            "【使用场景】仅在创建定时任务时使用，严禁在其他场景调用。当识别到定时任务中需要使用用户设备侧工具时，必须调用此工具进行权限检查。" +
+            "【调用前提】调用此工具前，必须确认用户定时任务中提到的工具在当前模型可使用的工具列表中存在。如果当前工具列表中不存在符合用户诉求的工具定义，则不要调用此工具，而是直接告知用户当前设备不支持该功能。" +
+            "【支持的意图名称及对应权限】" +
+            "GetCurrentLocation（获取用户位置）, " +
+            "SearchCalendarEvent（搜索用户日程）, " +
+            "CreateCalendarEvent（新建用户日程）, " +
+            "DeleteCalendarEvent（删除用户日程）, " +
+            "ModifyCalendarEvent（修改用户日程）, " +
+            "SearchNote（搜索用户备忘录）, " +
+            "CreateNote（新建用户备忘录）, " +
+            "ModifyNote（修改用户备忘录）, " +
+            "SearchContactLocal（搜索用户联系人）, " +
+            "SearchPhotoVideo（搜索用户图库照片或视频）, " +
+            "SaveMediaToGallery（保存图片/视频到图库）, " +
+            "SearchFile（搜索用户文件管理里面的文件）, " +
+            "SaveFileToFileManager（保存文件到文件管理）, " +
+            "SearchAlarm（搜索闹钟）, " +
+            "CreateAlarm（新建闹钟）, " +
+            "ModifyAlarm（修改闹钟）, " +
+            "DeleteAlarm（删除闹钟）, " +
+            "SearchMessage（搜索短信）, " +
+            "SendShortMessage（发送短信）, " +
+            "StartCall（打电话）。" +
+            "【多次调用】如果用户的定时任务指令中涉及多个端侧工具，则依次分别调用此工具检查每个工具的权限。如果调用超时失败，最多重试一次。" +
+            "【回复约束】如果工具返回没有授权或其他报错，只需要完整描述没有授权或其他报错内容即可，不需要主动给用户提供解决方案。" +
+            "【使用约束1】只要是创建定时任务且涉及端插件的使用，则必须调用此工具检查权限" +
+            "【使用约束2】如果是定时任务执行过程中，禁止调用此工具，此工具仅在创建定时任务时按需调用",
+        parameters: {
+            type: "object",
+            properties: {
+                checkIntentName: {
+                    type: "string",
+                    description: "需要检查权限的意图名称，必须是支持的意图名称之一，例如：GetCurrentLocation、SearchCalendarEvent、CreateCalendarEvent 等。",
+                },
+            },
+            required: ["checkIntentName"],
+        },
+        async execute(toolCallId, params) {
+            const { checkIntentName } = params;
+            // Look up permission IDs for the given intent name
+            const permissionId = INTENT_PERMISSION_MAP[checkIntentName];
+            if (!permissionId) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `不支持的工具意图名称: ${checkIntentName}。请确认该意图名称在支持列表中。`,
+                        },
+                    ],
+                };
+            }
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Build CheckPlugInPrivilege command
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "Action",
+                },
+                payload: {
+                    cardParam: {},
+                    executeParam: {
+                        achieveType: "INTENT",
+                        actionResponse: true,
+                        bundleName: "com.huawei.hmos.vassistant",
+                        dimension: "",
+                        executeMode: "background",
+                        intentName: "CheckPlugInPrivilege",
+                        intentParam: {
+                            checkIntentName,
+                            permissionId,
+                        },
+                        needUnlock: false,
+                        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);
+                    logger.error("超时: 检查插件权限超时（60秒）", { toolCallId, checkIntentName });
+                    reject(new Error(`检查插件权限超时（60秒）, intentName: ${checkIntentName}`));
+                }, 60000);
+                // Listen for data events from WebSocket
+                const handler = (event) => {
+                    if (event.intentName === "CheckPlugInPrivilege") {
+                        clearTimeout(timeout);
+                        wsManager.off("data-event", handler);
+                        if (event.status === "success" && event.outputs) {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    },
+                                ],
+                            });
+                        }
+                        else {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    },
+                                ],
+                            });
+                        }
+                    }
+                };
+                // Register event handler
+                wsManager.on("data-event", handler);
+                // Send the command
+                const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+                sendCommand({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId,
+                    command,
+                    toolCallId,
+                }).then(() => {
+                }).catch((error) => {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    reject(error);
+                });
+            });
+        },
+    };
+}

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

@@ -1,6 +1,7 @@
 import { createLocationTool } from "./location-tool.js";
 import { createXiaoyiGuiTool } from "./xiaoyi-gui-tool.js";
 import { createSendFileToUserTool } from "./send-file-to-user-tool.js";
+import { createSendHtmlCardTool } from "./send-html-card-tool.js";
 import { viewPushResultTool } from "./view-push-result-tool.js";
 import { createImageReadingTool } from "./image-reading-tool.js";
 import { timestampToUtc8Tool } from "./timestamp-to-utc8-tool.js";
@@ -19,6 +20,7 @@ import { createAgentAsSkillTool } from "./agent-as-skill-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 { createCheckPluginPrivilegeTool } from "./check-plugin-privilege-tool.js";
 import { logger } from "../utils/logger.js";
 /**
  * Create all XY channel tools for the given session context.
@@ -47,6 +49,7 @@ export function createAllTools(ctx) {
         createGetAlarmToolSchemaTool(ctx),
         createGetCollectionToolSchemaTool(ctx),
         createSendFileToUserTool(ctx),
+        createSendHtmlCardTool(ctx),
         // createGetEmailToolSchemaTool(ctx),
         viewPushResultTool,
         createImageReadingTool(ctx),
@@ -54,5 +57,6 @@ export function createAllTools(ctx) {
         createSaveSelfEvolutionSkillTool(ctx),
         createLoginTokenTool(ctx),
         createAgentAsSkillTool(ctx),
+        createCheckPluginPrivilegeTool(ctx),
     ];
 }

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", "web"];
+export declare const DEVICE_TYPES: readonly ["car", "2in1", "phone", "web", "pad"];
 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", "web"];
+export const DEVICE_TYPES = ["car", "2in1", "phone", "web", "pad"];
 const DEVICE_TOOL_POLICY = {
     "2in1": {
         allowlist: false,
@@ -15,6 +15,13 @@ const DEVICE_TOOL_POLICY = {
             "search_message",
             "search_contact",
             "get_contact_tool_schema",
+            "send_html_card"
+        ],
+    },
+    "pad": {
+        allowlist: false,
+        tools: [
+            "xiaoyi_gui_agent"
         ],
     },
     "web": {

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

@@ -75,6 +75,23 @@ export function createModifyAlarmTool(ctx) {
             required: ["entityId"],
         },
         async execute(toolCallId, params) {
+            // Coerce numeric string params to actual numbers
+            // The model may produce "1" instead of 1, which would fail typeof checks
+            const numericParams = [
+                "alarmState",
+                "alarmSnoozeDuration",
+                "alarmSnoozeTotal",
+                "alarmRingDuration",
+                "daysOfWakeType",
+            ];
+            for (const key of numericParams) {
+                if (typeof params[key] === "string") {
+                    const num = Number(params[key]);
+                    if (!isNaN(num)) {
+                        params[key] = num;
+                    }
+                }
+            }
             // ===== Validate required parameter: entityId =====
             if (!params.entityId || typeof params.entityId !== "string") {
                 throw new Error("Missing required parameter: entityId must be a string obtained from search_alarm or create_alarm");

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

@@ -1,7 +1,6 @@
 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]";
@@ -28,7 +27,7 @@ function buildModelToolResult(result) {
     let message = `跨端任务执行结果：${baseMessage}`;
     if (resultStatus === "对端设备执行任务成功且返回有文件") {
         if (result.autoSendFileToUser?.success) {
-            message += "\n\n对端设备返回了文件，系统已自动通过 send_file_to_user 将文件卡片发送给用户。请你基于跨端任务结果生成最终回复，告知用户任务已完成且文件已发送。";
+            message += "\n\n对端设备返回了文件，系统已自动将文件卡片发送给用户。请你基于跨端任务结果生成最终回复，告知用户任务已完成且文件已发送。";
         }
         else {
             const errorMessage = result.autoSendFileToUser?.error || "未知错误";
@@ -56,22 +55,92 @@ function buildCrossDeviceResult(params) {
     };
     return result;
 }
+function collectSentFileCards(sentFiles) {
+    const cardsByFileId = new Map();
+    for (const card of sentFiles) {
+        const fileId = typeof card.fileId === "string" ? card.fileId.trim() : "";
+        const fileName = typeof card.fileName === "string" ? card.fileName.trim() : "";
+        const mimeType = typeof card.mimeType === "string" ? card.mimeType.trim() : "";
+        if (!fileId || !fileName || cardsByFileId.has(fileId)) {
+            continue;
+        }
+        cardsByFileId.set(fileId, {
+            fileId,
+            fileName,
+            ...(mimeType ? { mimeType } : {}),
+        });
+    }
+    return Array.from(cardsByFileId.values());
+}
+function countSentFileCards(sentFiles) {
+    return collectSentFileCards(sentFiles).length;
+}
+async function sendFileCardsToUser(ctx, fileCards) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const wsManager = getXYWebSocketManager(config);
+    const sentFileCards = [];
+    for (const card of fileCards) {
+        const agentResponse = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId,
+            taskId: currentTaskId,
+            msgDetail: JSON.stringify({
+                jsonrpc: "2.0",
+                id: currentMessageId,
+                result: {
+                    kind: "artifact-update",
+                    append: true,
+                    lastChunk: false,
+                    final: false,
+                    artifact: {
+                        artifactId: currentTaskId,
+                        parts: [
+                            {
+                                kind: "file",
+                                file: {
+                                    name: card.fileName,
+                                    mimeType: card.mimeType,
+                                    fileId: card.fileId,
+                                },
+                            },
+                        ],
+                    },
+                },
+                error: { code: 0 },
+            }),
+        };
+        logger.log(`${SEND_CROSS_RESULT_LOG_TAG} sending file card by fileId, fileName=${card.fileName}`);
+        await wsManager.sendMessage(sessionId, agentResponse);
+        sentFileCards.push({ fileName: card.fileName, fileId: card.fileId });
+    }
+    return sentFileCards;
+}
 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`);
+    const fileCards = collectSentFileCards(sentFiles);
+    if (fileCards.length === 0) {
+        const errorMessage = "Cross-device result contains no valid fileCards.";
+        logger.error(`${SEND_CROSS_RESULT_LOG_TAG} auto file card send skipped, error=${errorMessage}`);
+        return {
+            ...result,
+            autoSendFileToUser: {
+                success: false,
+                error: errorMessage,
+            },
+        };
+    }
+    logger.log(`${SEND_CROSS_RESULT_LOG_TAG} auto sending cross-device file cards, fileCardCount=${fileCards.length}`);
     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`);
+        const sendFileResult = {
+            fileCards: await sendFileCardsToUser(ctx, fileCards),
+        };
+        logger.log(`${SEND_CROSS_RESULT_LOG_TAG} auto file card send completed, fileCardCount=${sendFileResult.fileCards.length}`);
         return {
             ...result,
             autoSendFileToUser: {
@@ -82,7 +151,7 @@ async function autoSendFileToUserIfNeeded(result, ctx) {
     }
     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}`);
+        logger.error(`${SEND_CROSS_RESULT_LOG_TAG} auto file card send failed, error=${errorMessage}`);
         return {
             ...result,
             autoSendFileToUser: {
@@ -218,7 +287,7 @@ export function createSendCrossDeviceTaskTool(ctx) {
                     }
                     settled = true;
                     const modelResult = buildModelToolResult(result);
-                    logger.log(`${LOG_TAG} completed, success=${result.success}, code=${result.code}, sentFileCount=${result.sentFiles.length}`);
+                    logger.log(`${LOG_TAG} completed, success=${result.success}, code=${result.code}, fileCardCount=${countSentFileCards(result.sentFiles)}`);
                     cleanup();
                     resolve(buildResultText(modelResult));
                 };
@@ -226,7 +295,7 @@ export function createSendCrossDeviceTaskTool(ctx) {
                     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}`);
+                    logger.log(`${SEND_CROSS_RESULT_LOG_TAG} received result, status=${event.status}, code=${event.code}, fileCardCount=${countSentFileCards(event.sentFiles)}`);
                     void (async () => {
                         if (resultHandlingStarted) {
                             return;

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

@@ -174,16 +174,6 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                         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
@@ -237,6 +227,7 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                 }
                 // Build and send agent_response messages for each file
                 const sentFiles = [];
+                let cachedSentFilesForReturn = [];
                 for (const uploadedFile of uploadedFiles) {
                     const { fileName, fileId, mimeType } = uploadedFile;
                     const agentResponse = {
@@ -273,6 +264,12 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                     // Send WebSocket message
                     await wsManager.sendMessage(sessionId, agentResponse);
                     logger.log(`[SEND-FILE-TO-USER] send ${fileName} file to user success`);
+                    if (ctx.runCrossTaskContext) {
+                        const sentFileCard = { fileName, fileId, mimeType };
+                        const cachedSentFiles = appendRunCrossTaskSentFiles([sentFileCard], ctx.runCrossTaskContext);
+                        cachedSentFilesForReturn = cachedSentFiles;
+                        logger.log(`[RunCrossTask] cached file card for cross-task result, fileName=${fileName}, cachedFileCardCount=${cachedSentFiles.length}`);
+                    }
                     sentFiles.push({ fileName, fileId });
                 }
                 return {
@@ -282,7 +279,8 @@ b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如
                             text: JSON.stringify({
                                 sentFiles,
                                 count: sentFiles.length,
-                                message: `成功发送 ${sentFiles.length} 个文件到用户设备`
+                                message: `成功发送 ${sentFiles.length} 个文件到用户设备`,
+                                cachedSentFiles: cachedSentFilesForReturn
                             }),
                         },
                     ],

package/dist/src/tools/send-html-card-tool.d.ts

@@ -0,0 +1,7 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * XY send HTML card tool - sends HTML content as an H5 card to user's device.
+ * Prefer this tool over send_file_to_user when sending HTML files to users.
+ * Only use send_file_to_user for HTML files when the user explicitly requests the raw file.
+ */
+export declare function createSendHtmlCardTool(ctx: SessionContext): any;

package/dist/src/tools/send-html-card-tool.js

@@ -0,0 +1,113 @@
+import { XYFileUploadService } from "../file-upload.js";
+import { sendCard } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY send HTML card tool - sends HTML content as an H5 card to user's device.
+ * Prefer this tool over send_file_to_user when sending HTML files to users.
+ * Only use send_file_to_user for HTML files when the user explicitly requests the raw file.
+ */
+export function createSendHtmlCardTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "send_html_card",
+        label: "Send HTML Card",
+        description: `工具能力描述：支持以H5卡片的形式展示HTML页面内容，用户可以直接在卡片中查看。
+
+工具参数说明：
+a. htmlUrl 和 htmlLocal 至少填写一个
+b. htmlUrl 是在线链接，可以直接公网访问的HTML页面地址
+c. htmlLocal 是本地HTML文件路径，会先上传获取预览链接再以卡片形式发送
+
+注意事项：
+a. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如果超时或失败，最多重试一次
+b. 最后要把最终的html的公网地址作为工具执行结果返回回去，要以markdown超链接的形式返回给用户，必须严格保留完整的url，包含url的鉴权鉴权信息，返回给用户的url必须是完整的
+c. 仅当用户或者skill中显示说明使用send_html_card工具时才调用此工具`,
+        parameters: {
+            type: "object",
+            properties: {
+                htmlUrl: {
+                    type: "string",
+                    description: "在线HTML页面链接，可直接公网访问的URL地址",
+                },
+                htmlLocal: {
+                    type: "string",
+                    description: "本地HTML文件路径",
+                },
+            },
+            required: [],
+        },
+        async execute(toolCallId, params) {
+            // Validate at least one parameter is provided
+            if (!params.htmlUrl && !params.htmlLocal) {
+                throw new Error("htmlUrl 和 htmlLocal 至少需要填写一个");
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            // Set timeout for the entire operation (2 minutes)
+            const TOOL_TIMEOUT = 120000;
+            let timeoutHandle = null;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error("操作超时（2分钟）"));
+                }, TOOL_TIMEOUT);
+            });
+            const executionPromise = (async () => {
+                let url = params.htmlUrl;
+                // If htmlLocal is provided, upload it to get a preview URL
+                if (params.htmlLocal) {
+                    const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+                    logger.log(`[SEND-HTML-CARD] Uploading local HTML file: ${params.htmlLocal}`);
+                    const previewUrl = await uploadService.uploadFileAndGetPreviewUrl(params.htmlLocal);
+                    logger.log(`[SEND-HTML-CARD] Upload complete, preview URL obtained`);
+                    url = previewUrl;
+                }
+                if (!url) {
+                    throw new Error("未能获取HTML页面的URL");
+                }
+                // Build card data
+                const cardsInfo = [
+                    {
+                        cardName: "clawH5",
+                        cardData: {
+                            url,
+                        },
+                        displayType: "DisplayFaCard",
+                    },
+                ];
+                // Send card via sendCard
+                await sendCard({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId,
+                    toolCallId,
+                    cardsInfo,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `HTML卡片发送成功，html的在线链接如下，生成markdown超链接时与此url需保持完整一致 ${url}`,
+                            }),
+                        },
+                    ],
+                };
+            })();
+            try {
+                const result = await Promise.race([executionPromise, timeoutPromise]);
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                return result;
+            }
+            catch (error) {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                throw error;
+            }
+        },
+    };
+}

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

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "async_hooks";
-import type { RunCrossTaskContext, SentFileParams, XYChannelConfig } from "../types.js";
+import type { RunCrossTaskContext, SentFileCard, XYChannelConfig } from "../types.js";
 export interface SessionContext {
     config: XYChannelConfig;
     sessionId: string;
@@ -8,6 +8,9 @@ export interface SessionContext {
     messageId: string;
     agentId: string;
     deviceType?: string;
+    /** Model name extracted from A2A user variables (variables.clientVariables.modelName).
+     *  When set, provider.ts replaces model.id in the OpenAI request body. */
+    modelName?: 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. */
@@ -24,6 +27,12 @@ export declare function markCronToolCall(toolCallId: string): void;
 export declare function isCronToolCall(toolCallId?: string): boolean;
 /** Clean up a cron tool call marker after use. */
 export declare function clearCronToolCall(toolCallId: string): void;
+/** 把 fire 期解析出的 jobId 绑定到当前 cron run 的合成 sessionId。 */
+export declare function setCurrentCronJobId(cronSessionId: string, jobId: string): void;
+/** 凭合成 cron sessionId 取本次 run 的 jobId（供 sendCommand 反查 pushId）。 */
+export declare function getCurrentCronJobId(cronSessionId?: string): string | undefined;
+/** cron run 结束后清理。 */
+export declare function clearCronJobId(cronSessionId: string): void;
 export declare const asyncLocalStorage: AsyncLocalStorage<SessionContext>;
 /**
  * Register a session context for tool access.
@@ -76,6 +85,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 appendRunCrossTaskSentFiles(sentFiles: SentFileCard[], explicitRunCrossTaskContext?: RunCrossTaskContext): SentFileCard[];
 export declare function clearRunCrossTaskSentFiles(explicitRunCrossTaskContext?: RunCrossTaskContext): void;
 export {};