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

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

@@ -0,0 +1,279 @@
+import { getXYWebSocketManager } from "../client.js";
+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";
+/**
+ * File extension to MIME type mapping
+ */
+const FILE_TYPE_TO_MIME_TYPE = {
+    txt: "text/plain",
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    json: "application/json",
+    png: "image/png",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+};
+/**
+ * Get MIME type from file extension
+ */
+function getMimeTypeFromFilename(filename) {
+    const extension = filename.split(".").pop()?.toLowerCase();
+    if (extension && FILE_TYPE_TO_MIME_TYPE[extension]) {
+        return FILE_TYPE_TO_MIME_TYPE[extension];
+    }
+    return "text/plain";
+}
+/**
+ * Normalize parameter to array (supports both array and JSON string)
+ */
+function normalizeToArray(param) {
+    if (Array.isArray(param)) {
+        return param;
+    }
+    if (typeof param === 'string') {
+        try {
+            const parsed = JSON.parse(param);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            throw new Error("Parameter must be an array or a JSON string representing an array");
+        }
+        catch (parseError) {
+            throw new Error(`Parameter must be a valid JSON array string. Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+        }
+    }
+    throw new Error(`Parameter must be an array or a JSON string, got ${typeof param}`);
+}
+/**
+ * Download remote file to local temp directory
+ */
+async function downloadRemoteFile(url) {
+    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];
+        // Ensure temp directory exists
+        const tempDir = "/tmp/xy_channel";
+        await fs.mkdir(tempDir, { recursive: true });
+        // Generate unique filename to avoid conflicts
+        const timestamp = Date.now();
+        const ext = path.extname(filename);
+        const baseName = path.basename(filename, ext);
+        const uniqueFilename = `${baseName}_${timestamp}${ext}`;
+        const localPath = path.join(tempDir, uniqueFilename);
+        // Save file to local temp directory
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await fs.writeFile(localPath, buffer);
+        return localPath;
+    }
+    catch (error) {
+        throw new Error(`Failed to download remote file: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * XY send file to user tool - sends local files or remote files to user's device.
+ * Supports both local file paths and remote URLs.
+ */
+export const sendFileToUserTool = {
+    name: "send_file_to_user",
+    label: "Send File to User",
+    description: `工具能力描述：帮助用户把本地的文件或者公网地址的文件传到手机。
+
+工具参数说明：
+a. fileLocalUrls：本地文件路径数组，包含用户需要回传的文件在本地的地址
+b. fileRemoteUrls：公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送）
+c. fileLocalUrls 与 fileRemoteUrls 任意一个不为空即可，两者都提供时都会处理
+
+注意事项：
+a. 支持传入数组或 JSON 字符串格式
+b. 操作超时时间为2分钟（120秒），请勿重复调用此工具，如果超时或失败，最多重试一次`,
+    parameters: {
+        type: "object",
+        properties: {
+            fileLocalUrls: {
+                description: "本地文件路径数组，包含用户需要回传的文件在本地的地址",
+            },
+            fileRemoteUrls: {
+                description: "公网地址数组，包含用户需要回传的文件的公网地址（会先下载到本地再发送）",
+            },
+        },
+    },
+    async execute(toolCallId, params) {
+        // Set timeout for the entire operation (2 minutes)
+        const TOOL_TIMEOUT = 120000; // 2 minutes in milliseconds
+        let timeoutHandle = null;
+        // Create a timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                reject(new Error("操作超时（2分钟）"));
+            }, TOOL_TIMEOUT);
+        });
+        // Create the main execution promise
+        const executionPromise = (async () => {
+            // Validate that at least one parameter is provided
+            if (!params.fileLocalUrls && !params.fileRemoteUrls) {
+                throw new Error("At least one of fileLocalUrls or fileRemoteUrls must be provided");
+            }
+            // Normalize fileLocalUrls parameter
+            let fileLocalUrls = [];
+            if (params.fileLocalUrls) {
+                fileLocalUrls = normalizeToArray(params.fileLocalUrls);
+                if (fileLocalUrls.length === 0) {
+                    throw new Error("fileLocalUrls array cannot be empty");
+                }
+            }
+            // Normalize fileRemoteUrls parameter
+            let fileRemoteUrls = [];
+            if (params.fileRemoteUrls) {
+                fileRemoteUrls = normalizeToArray(params.fileRemoteUrls);
+                if (fileRemoteUrls.length === 0) {
+                    throw new Error("fileRemoteUrls array cannot be empty");
+                }
+            }
+            // Get session context
+            const sessionContext = getCurrentSessionContext();
+            if (!sessionContext) {
+                throw new Error("No active XY session found. Send file to user tool can only be used during an active conversation.");
+            }
+            const { config, sessionId, taskId, messageId } = sessionContext;
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Create upload service
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            // Collect all local file paths to upload
+            const allLocalPaths = [...fileLocalUrls];
+            const downloadedFiles = [];
+            // Download remote files to local temp directory
+            if (fileRemoteUrls.length > 0) {
+                for (let i = 0; i < fileRemoteUrls.length; i++) {
+                    const remoteUrl = fileRemoteUrls[i];
+                    try {
+                        const localPath = await downloadRemoteFile(remoteUrl);
+                        allLocalPaths.push(localPath);
+                        downloadedFiles.push(localPath);
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to download remote file ${remoteUrl}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+            // Upload all local files and get fileIds
+            const uploadedFiles = [];
+            for (let i = 0; i < allLocalPaths.length; i++) {
+                const localPath = allLocalPaths[i];
+                try {
+                    // Upload file using three-phase upload
+                    const fileId = await uploadService.uploadFile(localPath);
+                    if (!fileId) {
+                        throw new Error(`Failed to upload file: ${localPath}`);
+                    }
+                    // Get filename and mime type
+                    const fileName = localPath.split("/").pop() || "unknown";
+                    const mimeType = getMimeTypeFromFilename(fileName);
+                    uploadedFiles.push({ fileName, fileId, mimeType });
+                }
+                catch (error) {
+                    throw new Error(`Failed to upload file ${localPath}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            // Clean up downloaded files
+            if (downloadedFiles.length > 0) {
+                for (const downloadedFile of downloadedFiles) {
+                    try {
+                        await fs.unlink(downloadedFile);
+                    }
+                    catch (error) {
+                    }
+                }
+            }
+            // Build and send agent_response messages for each file
+            const sentFiles = [];
+            for (const uploadedFile of uploadedFiles) {
+                const { fileName, fileId, mimeType } = uploadedFile;
+                const agentResponse = {
+                    msgType: "agent_response",
+                    agentId: config.agentId,
+                    sessionId: sessionId,
+                    taskId: taskId,
+                    msgDetail: JSON.stringify({
+                        jsonrpc: "2.0",
+                        id: taskId,
+                        result: {
+                            kind: "artifact-update",
+                            append: true,
+                            lastChunk: false,
+                            final: false,
+                            artifact: {
+                                artifactId: taskId,
+                                parts: [
+                                    {
+                                        kind: "file",
+                                        file: {
+                                            name: fileName,
+                                            mimeType: mimeType,
+                                            fileId: fileId,
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        error: { code: 0 },
+                    }),
+                };
+                // Send WebSocket message
+                await wsManager.sendMessage(sessionId, agentResponse);
+                sentFiles.push({ fileName, fileId });
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            sentFiles,
+                            count: sentFiles.length,
+                            message: `成功发送 ${sentFiles.length} 个文件到用户设备`
+                        }),
+                    },
+                ],
+            };
+        })();
+        // Race between execution and timeout
+        try {
+            const result = await Promise.race([executionPromise, timeoutPromise]);
+            // Clear timeout if execution completed
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            return result;
+        }
+        catch (error) {
+            // Clear timeout on error
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            throw error;
+        }
+    },
+};

package/dist/src/tools/send-message-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY send message tool - sends SMS message on user's device.
+ * Requires phoneNumber (with +86 prefix) and content parameters.
+ */
+export declare const sendMessageTool: any;

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

@@ -0,0 +1,138 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+/**
+ * XY send message tool - sends SMS message on user's device.
+ * Requires phoneNumber (with +86 prefix) and content parameters.
+ */
+export const sendMessageTool = {
+    name: "send_message",
+    label: "Send Message",
+    description: "通过手机发送短信。需要提供接收方手机号码和短信内容。手机号码会自动添加+86前缀（如果没有的话）。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
+    parameters: {
+        type: "object",
+        properties: {
+            phoneNumber: {
+                type: "string",
+                description: "接收方手机号码（会自动添加+86前缀）",
+            },
+            content: {
+                type: "string",
+                description: "短信内容",
+            },
+        },
+        required: ["phoneNumber", "content"],
+    },
+    async execute(toolCallId, params) {
+        // Validate phoneNumber parameter
+        if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
+            throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
+        }
+        // Validate content parameter
+        if (!params.content || typeof params.content !== "string" || params.content.trim() === "") {
+            throw new Error("Missing required parameter: content must be a non-empty string");
+        }
+        // Normalize phone number: add +86 prefix if not present
+        let phoneNumber = params.phoneNumber.trim();
+        if (!phoneNumber.startsWith("+86")) {
+            // Remove leading 0 if present (e.g., 086 -> 86)
+            if (phoneNumber.startsWith("0")) {
+                phoneNumber = phoneNumber.substring(1);
+            }
+            // Remove +86 or 86 prefix if already present to avoid duplication
+            if (phoneNumber.startsWith("86")) {
+                phoneNumber = phoneNumber.substring(2);
+            }
+            phoneNumber = `+86${phoneNumber}`;
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Send message tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build SendShortMessage command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SendShortMessage",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam: {
+                        phoneNumber: phoneNumber,
+                        content: params.content.trim(),
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // 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 === "SendShortMessage") {
+                    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 {
+                        const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
+                        reject(new Error(`发送短信失败: ${errorDetail}`));
+                    }
+                }
+            };
+            // Register event handler
+            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/session-manager.d.ts

@@ -23,7 +23,22 @@ export declare function unregisterSession(sessionKey: string): void;
 export declare function getSessionContext(sessionKey: string): SessionContext | null;
 /**
  * Get the most recent session context.
+ * @deprecated Use getCurrentSessionContext() instead for thread-safe access.
  * This is a fallback for tools that don't have access to sessionKey.
  * Returns null if no sessions are active.
  */
 export declare function getLatestSessionContext(): SessionContext | null;
+/**
+ * Run a callback with a session context stored in AsyncLocalStorage.
+ * This ensures thread-safe context isolation for concurrent requests.
+ */
+export declare function runWithSessionContext<T>(context: SessionContext, callback: () => Promise<T>): Promise<T>;
+/**
+ * Get the current session context from AsyncLocalStorage.
+ * This is the recommended way to access session context in tools.
+ * Returns null if not running within a session context.
+ *
+ * Enhanced version: Automatically fetches the latest taskId from task-manager
+ * to support interruption scenarios where a new message updates the taskId.
+ */
+export declare function getCurrentSessionContext(): SessionContext | null;

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

@@ -1,25 +1,23 @@
-import { logger } from "../utils/logger.js";
+// Session manager for XY tool context
+// Stores active session contexts that tools can access
+import { AsyncLocalStorage } from "async_hooks";
 import { configManager } from "../utils/config-manager.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 // Map of sessionKey -> SessionContextWithRef
 const activeSessions = new Map();
+// AsyncLocalStorage for thread-safe session context isolation
+const asyncLocalStorage = new AsyncLocalStorage();
 /**
  * Register a session context for tool access.
  * Should be called when starting to process a message.
  */
 export function registerSession(sessionKey, context) {
-    logger.log(`[SESSION_MANAGER] 📝 Registering session: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
-    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
-    logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
-    logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
     const existing = activeSessions.get(sessionKey);
     if (existing) {
         // 更新上下文，增加引用计数
         existing.taskId = context.taskId;
         existing.messageId = context.messageId;
         existing.refCount++;
-        logger.log(`[SESSION_MANAGER]   - Updated existing, refCount=${existing.refCount}`);
     }
     else {
         // 新建
@@ -27,45 +25,30 @@ export function registerSession(sessionKey, context) {
             ...context,
             refCount: 1,
         });
-        logger.log(`[SESSION_MANAGER]   - Created new, refCount=1`);
     }
-    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Unregister a session context.
  * Should be called when message processing is complete.
  */
 export function unregisterSession(sessionKey) {
-    logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
     const existing = activeSessions.get(sessionKey);
     if (!existing) {
-        logger.log(`[SESSION_MANAGER]   - Session not found`);
         return;
     }
     existing.refCount--;
-    logger.log(`[SESSION_MANAGER]   - Decremented refCount: ${existing.refCount}`);
     if (existing.refCount <= 0) {
         activeSessions.delete(sessionKey);
         configManager.clearSession(existing.sessionId);
-        logger.log(`[SESSION_MANAGER]   - Deleted (refCount=0)`);
     }
-    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Get session context by sessionKey.
  * Returns null if session not found.
  */
 export function getSessionContext(sessionKey) {
-    logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
     const contextWithRef = activeSessions.get(sessionKey) ?? null;
-    logger.log(`[SESSION_MANAGER]   - Found: ${contextWithRef !== null}`);
     if (contextWithRef) {
-        logger.log(`[SESSION_MANAGER]   - sessionId: ${contextWithRef.sessionId}`);
         // 返回时去掉refCount字段
         const { refCount, ...context } = contextWithRef;
         return context;
@@ -74,25 +57,54 @@ export function getSessionContext(sessionKey) {
 }
 /**
  * Get the most recent session context.
+ * @deprecated Use getCurrentSessionContext() instead for thread-safe access.
  * This is a fallback for tools that don't have access to sessionKey.
  * Returns null if no sessions are active.
  */
 export function getLatestSessionContext() {
-    logger.log(`[SESSION_MANAGER] 🔍 Getting latest session context`);
-    logger.log(`[SESSION_MANAGER]   - Active sessions count: ${activeSessions.size}`);
-    logger.log(`[SESSION_MANAGER]   - Active session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
     if (activeSessions.size === 0) {
-        logger.error(`[SESSION_MANAGER]   - ❌ No active sessions found!`);
         return null;
     }
     // Return the last added session
     const sessions = Array.from(activeSessions.values());
     const latestSessionWithRef = sessions[sessions.length - 1];
-    logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
-    logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSessionWithRef.sessionId}`);
-    logger.log(`[SESSION_MANAGER]     - taskId: ${latestSessionWithRef.taskId}`);
-    logger.log(`[SESSION_MANAGER]     - messageId: ${latestSessionWithRef.messageId}`);
     // 返回时去掉refCount字段
     const { refCount, ...latestSession } = latestSessionWithRef;
     return latestSession;
 }
+/**
+ * Run a callback with a session context stored in AsyncLocalStorage.
+ * This ensures thread-safe context isolation for concurrent requests.
+ */
+export function runWithSessionContext(context, callback) {
+    return asyncLocalStorage.run(context, callback);
+}
+/**
+ * Get the current session context from AsyncLocalStorage.
+ * This is the recommended way to access session context in tools.
+ * Returns null if not running within a session context.
+ *
+ * Enhanced version: Automatically fetches the latest taskId from task-manager
+ * to support interruption scenarios where a new message updates the taskId.
+ */
+export function getCurrentSessionContext() {
+    // 1. Get base context from AsyncLocalStorage
+    const context = asyncLocalStorage.getStore() ?? null;
+    if (!context) {
+        return null;
+    }
+    // 2. Get latest taskId and messageId from task-manager
+    const latestTaskId = getCurrentTaskId(context.sessionId);
+    const latestMessageId = getCurrentMessageId(context.sessionId);
+    // 3. If task-manager has a newer taskId, use the latest value
+    if (latestTaskId && latestTaskId !== context.taskId) {
+        // Return updated context (create new object, don't modify original)
+        return {
+            ...context,
+            taskId: latestTaskId,
+            messageId: latestMessageId ?? context.messageId,
+        };
+    }
+    // 4. No update needed, return original context
+    return context;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * XY upload file tool - uploads local files to get publicly accessible URLs.
+ * Requires file URIs from search_file tool as prerequisite.
+ *
+ * Prerequisites:
+ * 1. Call search_file tool first to get URIs of files
+ * 2. Use the URIs to get public URLs
+ *
+ * Usage Note:
+ * - After getting public URLs, if further processing is needed, download the file first
+ * - URLs returned are publicly accessible
+ */
+export declare const uploadFileTool: any;