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

package/dist/src/tools/image-reading-tool.js

@@ -1,6 +1,5 @@
 // Image Reading tool implementation
 import { XYFileUploadService } from "../file-upload.js";
-import { getCurrentSessionContext } from "./session-manager.js";
 import fetch from "node-fetch";
 import fs from "fs/promises";
 import path from "path";
@@ -201,10 +200,12 @@ async function callImageUnderstandingAPI(imageUrl, text, apiKey, uid, fileUpload
  * XY Image Reading tool - performs image understanding using local or remote image URLs.
  * Supports both local file paths and remote URLs.
  */
-export const imageReadingTool = {
-    name: "image_reading",
-    label: "Image Reading",
-    description: `
+export function createImageReadingTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "image_reading",
+        label: "Image Reading",
+        description: `
 工具使用场景：
 【必须调用此工具的情况】
 1. 用户消息中包含 mediaPath 字段且不为空（表示用户发送了图片）
@@ -230,96 +231,91 @@ a. 支持常见图片格式（jpg, png, gif等）
 b. 远程图片会先下载到本地再处理
 c. 操作超时时间为2分钟（120秒）
 d. 返回图像理解的文本描述内容`,
-    parameters: {
-        type: "object",
-        properties: {
-            localUrl: {
-                type: "string",
-                description: "本地图片文件路径（可选，通常从用户消息的 mediaPath 字段获取）",
-            },
-            remoteUrl: {
-                type: "string",
-                description: "公网图片地址（可选）,公网图片地址（HTTP/HTTPS URL）",
-            },
-            prompt: {
-                type: "string",
-                description: "对图片的提示问题，默认为'描述这张图片内容'，可根据用户的具体问题自定义",
+        parameters: {
+            type: "object",
+            properties: {
+                localUrl: {
+                    type: "string",
+                    description: "本地图片文件路径（可选，通常从用户消息的 mediaPath 字段获取）",
+                },
+                remoteUrl: {
+                    type: "string",
+                    description: "公网图片地址（可选）,公网图片地址（HTTP/HTTPS URL），注意不要对原始url做任何截断（例如裁减掉链接后面的鉴权信息或者修改域名后缀），必须使用上下文中完整的图片地址",
+                },
+                prompt: {
+                    type: "string",
+                    description: "对图片的提示问题，默认为'描述这张图片内容'，可根据用户的具体问题自定义",
+                },
             },
         },
-    },
-    async execute(toolCallId, params) {
-        // Validate that at least one parameter is provided
-        if (!params.localUrl && !params.remoteUrl) {
-            throw new Error("At least one of localUrl or remoteUrl must be provided");
-        }
-        // Get prompt (default to "描述这张图片内容")
-        const prompt = params.prompt || "描述这张图片内容";
-        // Get session context
-        const sessionContext = getCurrentSessionContext();
-        if (!sessionContext) {
-            throw new Error("No active XY session found. Image reading tool can only be used during an active conversation.");
-        }
-        const { config } = sessionContext;
-        // Create upload service
-        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-        let processedImage = null;
-        let downloadedFile = null;
-        try {
-            // Process image input (prefer localUrl over remoteUrl)
-            const imageInput = params.localUrl || params.remoteUrl;
-            processedImage = await processImageInput(imageInput, uploadService);
-            // Track downloaded file for cleanup
-            if (processedImage.localPath) {
-                downloadedFile = processedImage.localPath;
+        async execute(toolCallId, params) {
+            // Validate that at least one parameter is provided
+            if (!params.localUrl && !params.remoteUrl) {
+                throw new Error("At least one of localUrl or remoteUrl must be provided");
             }
-            // Call image understanding API
-            const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid, config.fileUploadUrl);
-            // Clean up downloaded file if any
-            if (downloadedFile) {
-                try {
-                    await fs.unlink(downloadedFile);
+            // Get prompt (default to "描述这张图片内容")
+            const prompt = params.prompt || "描述这张图片内容";
+            // Create upload service
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            let processedImage = null;
+            let downloadedFile = null;
+            try {
+                // Process image input (prefer localUrl over remoteUrl)
+                const imageInput = params.localUrl || params.remoteUrl;
+                processedImage = await processImageInput(imageInput, uploadService);
+                // Track downloaded file for cleanup
+                if (processedImage.localPath) {
+                    downloadedFile = processedImage.localPath;
                 }
-                catch (error) {
+                // Call image understanding API
+                const caption = await callImageUnderstandingAPI(processedImage.imageUrl, prompt, config.apiKey, config.uid, config.fileUploadUrl);
+                // Clean up downloaded file if any
+                if (downloadedFile) {
+                    try {
+                        await fs.unlink(downloadedFile);
+                    }
+                    catch (error) {
+                    }
                 }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                caption,
+                                prompt,
+                                imageSource: params.localUrl ? "local" : "remote",
+                                success: true,
+                            }),
+                        },
+                    ],
+                };
             }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            caption,
-                            prompt,
-                            imageSource: params.localUrl ? "local" : "remote",
-                            success: true,
-                        }),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            // Clean up downloaded file on error
-            if (downloadedFile) {
-                try {
-                    await fs.unlink(downloadedFile);
-                }
-                catch (cleanupError) {
+            catch (error) {
+                // Clean up downloaded file on error
+                if (downloadedFile) {
+                    try {
+                        await fs.unlink(downloadedFile);
+                    }
+                    catch (cleanupError) {
+                    }
                 }
+                const errorMessage = error instanceof Error ? error.message : "图片分析失败";
+                // Return error result instead of throwing
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                error: errorMessage,
+                                prompt,
+                                imageSource: params.localUrl ? "local" : "remote",
+                                success: false,
+                            }),
+                        },
+                    ],
+                };
             }
-            const errorMessage = error instanceof Error ? error.message : "图片分析失败";
-            // Return error result instead of throwing
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: errorMessage,
-                            prompt,
-                            imageSource: params.localUrl ? "local" : "remote",
-                            success: false,
-                        }),
-                    },
-                ],
-            };
-        }
-    },
-};
+        },
+    };
+}

package/dist/src/tools/location-tool.d.ts

@@ -1,5 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
 /**
  * XY location tool - gets user's current location.
  * Returns WGS84 coordinates (latitude, longitude).
  */
-export declare const locationTool: any;
+export declare function createLocationTool(ctx: SessionContext): any;

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

@@ -1,102 +1,98 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getCurrentSessionContext } from "./session-manager.js";
 /**
  * XY location tool - gets user's current location.
  * Returns WGS84 coordinates (latitude, longitude).
  */
-export const locationTool = {
-    name: "get_user_location",
-    label: "Get User Location",
-    description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
-    parameters: {
-        type: "object",
-        properties: {},
-        required: [],
-    },
-    async execute(toolCallId, params) {
-        // Get session context
-        const sessionContext = getCurrentSessionContext();
-        if (!sessionContext) {
-            throw new Error("No active XY session found. Location tool can only be used during an active conversation.");
-        }
-        const { config, sessionId, taskId, messageId } = sessionContext;
-        // Get WebSocket manager
-        const wsManager = getXYWebSocketManager(config);
-        // Build GetCurrentLocation command
-        const command = {
-            header: {
-                namespace: "Common",
-                name: "Action",
-            },
-            payload: {
-                cardParam: {},
-                executeParam: {
-                    achieveType: "INTENT",
-                    actionResponse: true,
-                    bundleName: "com.huawei.hmos.aidispatchservice",
-                    dimension: "",
-                    executeMode: "background",
-                    intentName: "GetCurrentLocation",
-                    intentParam: {
-                        isNeedGeoAddress: true,
+export function createLocationTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "get_user_location",
+        label: "Get User Location",
+        description: "获取用户当前位置（经纬度坐标，WGS84坐标系）。需要用户设备授权位置访问权限。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
+        parameters: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+        async execute(toolCallId, params) {
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Build GetCurrentLocation command
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "Action",
+                },
+                payload: {
+                    cardParam: {},
+                    executeParam: {
+                        achieveType: "INTENT",
+                        actionResponse: true,
+                        bundleName: "com.huawei.hmos.aidispatchservice",
+                        dimension: "",
+                        executeMode: "background",
+                        intentName: "GetCurrentLocation",
+                        intentParam: {
+                            isNeedGeoAddress: true,
+                        },
+                        needUnlock: true,
+                        permissionId: [],
+                        timeOut: 5,
                     },
-                    needUnlock: true,
-                    permissionId: [],
-                    timeOut: 5,
+                    needUploadResult: true,
+                    pageControlRelated: false,
+                    responses: [{
+                            displayText: "",
+                            resultCode: "",
+                            ttsText: "",
+                        }],
                 },
-                needUploadResult: true,
-                pageControlRelated: false,
-                responses: [{
-                        displayText: "",
-                        resultCode: "",
-                        ttsText: "",
-                    }],
-            },
-        };
-        // Send command and wait for response (60 second timeout)
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                wsManager.off("data-event", handler);
-                reject(new Error("获取位置超时（60秒）"));
-            }, 60000);
-            // Listen for data events from WebSocket
-            const handler = (event) => {
-                if (event.intentName === "GetCurrentLocation") {
-                    clearTimeout(timeout);
+            };
+            // Send command and wait for response (60 second timeout)
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
                     wsManager.off("data-event", handler);
-                    if (event.status === "success" && event.outputs) {
-                        // 成功，直接返回完整的 event.outputs JSON 字符串
-                        resolve({
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify(event.outputs),
-                                }
-                            ]
-                        });
-                    }
-                    else {
-                        reject(new Error(`获取位置失败: ${event.status}`));
+                    reject(new Error("获取位置超时（60秒）"));
+                }, 60000);
+                // Listen for data events from WebSocket
+                const handler = (event) => {
+                    if (event.intentName === "GetCurrentLocation") {
+                        clearTimeout(timeout);
+                        wsManager.off("data-event", handler);
+                        if (event.status === "success" && event.outputs) {
+                            // 成功，直接返回完整的 event.outputs JSON 字符串
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    }
+                                ]
+                            });
+                        }
+                        else {
+                            reject(new Error(`获取位置失败: ${event.status}`));
+                        }
                     }
-                }
-            };
-            // Register event handler
-            // Note: The WebSocket manager needs to emit 'data-event' when receiving data events
-            wsManager.on("data-event", handler);
-            // Send the command
-            sendCommand({
-                config,
-                sessionId,
-                taskId,
-                messageId,
-                command,
-            }).then(() => {
-            }).catch((error) => {
-                clearTimeout(timeout);
-                wsManager.off("data-event", handler);
-                reject(error);
+                };
+                // Register event handler
+                // Note: The WebSocket manager needs to emit 'data-event' when receiving data events
+                wsManager.on("data-event", handler);
+                // Send the command
+                sendCommand({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    command,
+                }).then(() => {
+                }).catch((error) => {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    reject(error);
+                });
             });
-        });
-    },
-};
+        },
+    };
+}

package/dist/src/tools/login-token-tool.d.ts

@@ -0,0 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * huawei_id_tool 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export declare function createLoginTokenTool(ctx: SessionContext): any;

package/dist/src/tools/login-token-tool.js

@@ -0,0 +1,133 @@
+// Login Token tool - 自动获取用户授权信息
+import { v4 as uuidv4 } from "uuid";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
+import { readFileSync, existsSync } from "fs";
+import { logger } from "../utils/logger.js";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 60000; // 1 minute
+const TOKEN_VALIDITY_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * huawei_id_tool 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export function createLoginTokenTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "huawei_id_tool",
+        label: "Get Login Token",
+        description: "获取用户授权信息。当skill需要用户鉴权时调用此工具，工具会向用户端发送授权请求，等待用户完成授权后返回结果。请勿重复调用此工具。",
+        parameters: {
+            type: "object",
+            properties: {
+                clientId: {
+                    type: "string",
+                    description: "账号服务唯一标识，在执行具体skill过程中会提供",
+                },
+                skillName: {
+                    type: "string",
+                    description: "具体skill的名称",
+                },
+            },
+            required: ["clientId", "skillName"],
+        },
+        async execute(toolCallId, params) {
+            const { clientId, skillName } = params;
+            if (!clientId || typeof clientId !== "string" || clientId.trim() === "") {
+                throw new Error("Missing required parameter: clientId must be a non-empty string");
+            }
+            if (!skillName || typeof skillName !== "string" || skillName.trim() === "") {
+                throw new Error("Missing required parameter: skillName must be a non-empty string");
+            }
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+            // (1) Build and send getLoginToken artifact
+            const artifactId = uuidv4();
+            const artifact = {
+                taskId: currentTaskId,
+                kind: "artifact-update",
+                append: false,
+                lastChunk: true,
+                final: false,
+                artifact: {
+                    artifactId,
+                    parts: [
+                        {
+                            kind: "getLoginToken",
+                            clientId: clientId.trim(),
+                            skillName: skillName.trim(),
+                        },
+                    ],
+                },
+            };
+            const jsonRpcResponse = {
+                jsonrpc: "2.0",
+                id: currentMessageId,
+                result: artifact,
+            };
+            const wsManager = getXYWebSocketManager(config);
+            const outboundMessage = {
+                msgType: "agent_response",
+                agentId: config.agentId,
+                sessionId,
+                taskId: currentTaskId,
+                msgDetail: JSON.stringify(jsonRpcResponse),
+            };
+            logger.log(`[LOGIN_TOKEN] Sending getLoginToken artifact for clientId=${clientId}, skillName=${skillName}`);
+            await wsManager.sendMessage(sessionId, outboundMessage);
+            logger.log(`[LOGIN_TOKEN] Artifact sent successfully`);
+            // (2) Poll .xiaoyitoken.json every 5 seconds
+            const startTime = Date.now();
+            return new Promise((resolve) => {
+                const poll = () => {
+                    const elapsed = Date.now() - startTime;
+                    if (elapsed >= TIMEOUT_MS) {
+                        // (4) Timeout after 1 minute
+                        logger.log(`[LOGIN_TOKEN] Timeout: failed to get login token for clientId=${clientId}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "获取用户授权失败",
+                                },
+                            ],
+                        });
+                        return;
+                    }
+                    try {
+                        if (existsSync(TOKEN_FILE_PATH)) {
+                            const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                            const tokens = JSON.parse(content);
+                            const match = tokens.find((t) => t.clientId === clientId.trim());
+                            if (match) {
+                                const tokenTime = Number(match.timestamp);
+                                const diff = Date.now() - tokenTime;
+                                if (diff <= TOKEN_VALIDITY_MS) {
+                                    // (3) Found valid token
+                                    logger.log(`[LOGIN_TOKEN] Successfully got login token for clientId=${clientId}`);
+                                    resolve({
+                                        content: [
+                                            {
+                                                type: "text",
+                                                text: "获取用户授权成功",
+                                            },
+                                        ],
+                                    });
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger.log(`[LOGIN_TOKEN] Error reading token file: ${err}`);
+                    }
+                    // Not found or not valid, poll again after 5 seconds
+                    setTimeout(poll, POLL_INTERVAL_MS);
+                };
+                // Start polling after 5 seconds
+                setTimeout(poll, POLL_INTERVAL_MS);
+            });
+        },
+    };
+}

package/dist/src/tools/modify-alarm-tool.d.ts

@@ -1,3 +1,4 @@
+import type { SessionContext } from "./session-manager.js";
 /**
  * XY modify alarm tool - modifies an existing alarm on user's device.
  * Requires entityId from search_alarm or create_alarm tool.
@@ -6,4 +7,4 @@
  * 1. Call search_alarm or create_alarm tool first to get entityId
  * 2. Use the entityId to identify which alarm to modify
  */
-export declare const modifyAlarmTool: any;
+export declare function createModifyAlarmTool(ctx: SessionContext): any;