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

package/dist/src/tools/agent-as-skill-tool.js

@@ -1,7 +1,7 @@
 // Agent-as-skill tool implementation - invokes another agent as a skill
-import { getXYWebSocketManager } from "../client.js";
+import { getCachedXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getCurrentTaskId } from "../task-manager.js";
+import { getCurrentSessionContext } from './session-manager.js';
 import { logger } from "../utils/logger.js";
 import { XYFileUploadService } from "../file-upload.js";
 /**
@@ -9,12 +9,10 @@ import { XYFileUploadService } from "../file-upload.js";
  * The tool receives the agentId, query, and optional file attachments,
  * forwards the request to the target agent via WebSocket, and returns the result.
  */
-export function createAgentAsSkillTool(ctx) {
-    const { config, sessionId, taskId, messageId } = ctx;
-    return {
-        name: "agent_as_a_tool",
-        label: "Agent as Skill Tool",
-        description: `智能体作为skill的执行元工具。当需要调用其他已注册的Agent来执行特定任务时使用此工具。
+export const agentAsSkillTool = {
+    name: "agent_as_a_tool",
+    label: "Agent as Skill Tool",
+    description: `智能体作为skill的执行元工具。当需要调用其他已注册的Agent来执行特定任务时使用此工具。
 该工具会将用户请求和可选的附件文件转发给目标Agent执行，并返回执行结果。
 
 使用场景：
@@ -26,165 +24,160 @@ export function createAgentAsSkillTool(ctx) {
 - 操作超时时间为5分钟
 - 该工具执行期间必须严格等待结果返回，不要执行其他操作
 - 如果超时或失败，最多重试一次`,
-        parameters: {
-            type: "object",
-            properties: {
-                agentId: {
-                    type: "string",
-                    description: "待执行的AgentId，精准匹配系统注册的AgentId",
-                },
-                query: {
-                    type: "string",
-                    description: "用户原始请求文本，原样转发给目标Agent执行",
-                },
-                filesInfo: {
-                    description: "附件文件/图片信息列表，无文件时可传null或空数组，支持传入数组或JSON字符串",
-                    items: {
-                        type: "object",
-                        properties: {
-                            fileType: {
-                                type: "string",
-                                description: "文件类型：file 或 image",
-                                enum: ["file", "image"],
-                            },
-                            fileId: {
-                                type: "string",
-                                description: "文件全局唯一标识",
-                            },
-                            fileUrl: {
-                                type: "string",
-                                description: "文件可访问下载链接（完整HTTP/HTTPS地址）",
-                            },
-                            fileUrlLocal: {
-                                type: "string",
-                                description: "文件本地路径，如果提供此字段，工具会自动上传文件并将公网URL填入fileUrl",
-                            },
+    parameters: {
+        type: "object",
+        properties: {
+            agentId: {
+                type: "string",
+                description: "待执行的AgentId，精准匹配系统注册的AgentId",
+            },
+            query: {
+                type: "string",
+                description: "用户原始请求文本，原样转发给目标Agent执行",
+            },
+            filesInfo: {
+                description: "附件文件/图片信息列表，无文件时可传null或空数组，支持传入数组或JSON字符串",
+                items: {
+                    type: "object",
+                    properties: {
+                        fileType: {
+                            type: "string",
+                            description: "文件类型：file 或 image",
+                            enum: ["file", "image"],
+                        },
+                        fileId: {
+                            type: "string",
+                            description: "文件全局唯一标识",
+                        },
+                        fileUrl: {
+                            type: "string",
+                            description: "文件可访问下载链接（完整HTTP/HTTPS地址）或文件本地路径。若为本地路径，工具会自动上传文件并替换为公网URL",
                         },
                     },
                 },
             },
-            required: ["agentId", "query"],
         },
-        async execute(toolCallId, params) {
-            // Dynamic lookup: use latest taskId from task-manager (handles steer/interrupt)
-            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
-            // Validate parameters
-            if (!params.agentId || typeof params.agentId !== "string") {
-                throw new Error("Missing or invalid required parameter: agentId must be a non-empty string");
+        required: ["agentId", "query"],
+    },
+    async execute(toolCallId, params) {
+        const _c = getCurrentSessionContext();
+        const { config, sessionId, taskId, messageId } = _c;
+        // Dynamic lookup: use latest taskId from task-manager (handles steer/interrupt)
+        // Validate parameters
+        if (!params.agentId || typeof params.agentId !== "string") {
+            throw new Error("Missing or invalid required parameter: agentId must be a non-empty string");
+        }
+        if (!params.query || typeof params.query !== "string") {
+            throw new Error("Missing or invalid required parameter: query must be a non-empty string");
+        }
+        // Robust parsing: normalize filesInfo from array or JSON string
+        let filesInfo = null;
+        if (params.filesInfo) {
+            if (Array.isArray(params.filesInfo)) {
+                filesInfo = params.filesInfo;
             }
-            if (!params.query || typeof params.query !== "string") {
-                throw new Error("Missing or invalid required parameter: query must be a non-empty string");
-            }
-            // Robust parsing: normalize filesInfo from array or JSON string
-            let filesInfo = null;
-            if (params.filesInfo) {
-                if (Array.isArray(params.filesInfo)) {
-                    filesInfo = params.filesInfo;
-                }
-                else if (typeof params.filesInfo === 'string') {
-                    try {
-                        const parsed = JSON.parse(params.filesInfo);
-                        if (Array.isArray(parsed)) {
-                            filesInfo = parsed;
-                        }
-                        else {
-                            throw new Error("filesInfo must be an array or a JSON string representing an array");
-                        }
+            else if (typeof params.filesInfo === 'string') {
+                try {
+                    const parsed = JSON.parse(params.filesInfo);
+                    if (Array.isArray(parsed)) {
+                        filesInfo = parsed;
                     }
-                    catch (parseError) {
-                        throw new Error(`filesInfo JSON解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    else {
+                        throw new Error("filesInfo must be an array or a JSON string representing an array");
                     }
                 }
-                else {
-                    filesInfo = null;
+                catch (parseError) {
+                    throw new Error(`filesInfo JSON解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
                 }
             }
-            // Upload local files and fill fileUrl
-            if (filesInfo && filesInfo.length > 0) {
-                const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
-                for (const fileInfo of filesInfo) {
-                    if (fileInfo.fileUrlLocal && !fileInfo.fileUrl) {
-                        try {
-                            const publicUrl = await uploadService.uploadFileAndGetUrl(fileInfo.fileUrlLocal, "TEMPORARY_MATERIAL_DOC");
-                            if (publicUrl) {
-                                fileInfo.fileUrl = publicUrl;
-                            }
-                            else {
-                                logger.warn("[AGENT-AS-SKILL] 上传文件未返回公网URL", { fileUrlLocal: fileInfo.fileUrlLocal });
-                            }
-                        }
-                        catch (uploadError) {
-                            logger.error("[AGENT-AS-SKILL] 上传本地文件失败", { fileUrlLocal: fileInfo.fileUrlLocal, error: uploadError });
-                            throw new Error(`上传本地文件失败 (${fileInfo.fileUrlLocal}): ${uploadError instanceof Error ? uploadError.message : String(uploadError)}`);
-                        }
-                    }
-                    // Remove fileUrlLocal from the final payload
-                    delete fileInfo.fileUrlLocal;
-                }
+            else {
+                filesInfo = null;
             }
-            // Get WebSocket manager
-            const wsManager = getXYWebSocketManager(config);
-            // Build ExecuteAgentAsSkill command
-            const command = {
-                header: {
-                    namespace: "System",
-                    name: "ExecuteAgentAsSkill",
-                },
-                payload: {
-                    agentId: params.agentId,
-                    query: params.query,
-                    filesInfo: filesInfo || null,
-                },
-            };
-            // Send command and wait for response (5 minute timeout)
-            return new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    wsManager.off("agent-as-skill-response", handler);
-                    logger.error("超时: Agent-as-Skill 操作超时（5分钟）", { agentId: params.agentId, toolCallId });
-                    reject(new Error("Agent-as-Skill 操作超时（5分钟）"));
-                }, 300000); // 5 minutes timeout
-                // Listen for Agent-as-Skill response events
-                const handler = (event) => {
-                    // Check if this is the ExecuteAgentAsSkillResponse we're waiting for
-                    if (event.header?.namespace === "System" &&
-                        event.header?.name === "ExecuteAgentAsSkillResponse") {
-                        clearTimeout(timeout);
-                        wsManager.off("agent-as-skill-response", handler);
-                        // Return the payload directly as the tool result
-                        const payload = event.payload;
-                        if (payload) {
-                            resolve({
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: typeof payload === "string" ? payload : JSON.stringify(payload),
-                                    },
-                                ],
-                            });
+        }
+        // Upload local files and fill fileUrl
+        if (filesInfo && filesInfo.length > 0) {
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            for (const fileInfo of filesInfo) {
+                if (fileInfo.fileUrl && !/^https?:\/\//i.test(fileInfo.fileUrl)) {
+                    const localPath = fileInfo.fileUrl;
+                    try {
+                        const publicUrl = await uploadService.uploadFileAndGetUrl(localPath, "TEMPORARY_MATERIAL_DOC");
+                        if (publicUrl) {
+                            fileInfo.fileUrl = publicUrl;
                         }
                         else {
-                            reject(new Error("Agent-as-Skill 响应格式错误：缺少 payload"));
+                            logger.warn("[AGENT-AS-SKILL] 上传文件未返回公网URL", { localPath });
                         }
                     }
-                };
-                // Register event handler
-                wsManager.on("agent-as-skill-response", handler);
-                // Send the command
-                sendCommand({
-                    config,
-                    sessionId,
-                    taskId: currentTaskId,
-                    messageId,
-                    command,
-                    toolCallId,
-                }).then(() => {
-                    logger.log("[AGENT-AS-SKILL] Command sent successfully", { agentId: params.agentId });
-                }).catch((error) => {
+                    catch (uploadError) {
+                        logger.error("[AGENT-AS-SKILL] 上传本地文件失败", { localPath, error: uploadError });
+                        throw new Error(`上传本地文件失败 (${localPath}): ${uploadError instanceof Error ? uploadError.message : String(uploadError)}`);
+                    }
+                }
+            }
+        }
+        // Get WebSocket manager
+        const wsManager = getCachedXYWebSocketManager();
+        // Build ExecuteAgentAsSkill command
+        const command = {
+            header: {
+                namespace: "System",
+                name: "ExecuteAgentAsSkill",
+            },
+            payload: {
+                agentId: params.agentId,
+                query: params.query,
+                filesInfo: filesInfo || null,
+            },
+        };
+        // Send command and wait for response (5 minute timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("agent-as-skill-response", handler);
+                logger.error("超时: Agent-as-Skill 操作超时（5分钟）", { agentId: params.agentId, toolCallId });
+                reject(new Error("Agent-as-Skill 操作超时（5分钟）"));
+            }, 300000); // 5 minutes timeout
+            // Listen for Agent-as-Skill response events
+            const handler = (event) => {
+                // Check if this is the ExecuteAgentAsSkillResponse we're waiting for
+                if (event.header?.namespace === "System" &&
+                    event.header?.name === "ExecuteAgentAsSkillResponse") {
                     clearTimeout(timeout);
                     wsManager.off("agent-as-skill-response", handler);
-                    reject(error);
-                });
+                    // Return the payload directly as the tool result
+                    const payload = event.payload;
+                    if (payload) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: typeof payload === "string" ? payload : JSON.stringify(payload),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error("Agent-as-Skill 响应格式错误：缺少 payload"));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("agent-as-skill-response", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                toolCallId,
+            }).then(() => {
+                logger.log("[AGENT-AS-SKILL] Command sent successfully", { agentId: params.agentId });
+            }).catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("agent-as-skill-response", handler);
+                reject(error);
             });
-        },
-    };
-}
+        });
+    },
+};

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

@@ -1,7 +1,29 @@
-import type { SessionContext } from "./session-manager.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-export declare function createCalendarTool(ctx: SessionContext): any;
+export declare const calendarTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            title: {
+                type: string;
+                description: string;
+            };
+            dtStart: {
+                type: string;
+                description: string;
+            };
+            dtEnd: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(toolCallId: string, params: any): Promise<unknown>;
+};

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

@@ -1,135 +1,133 @@
-import { getXYWebSocketManager } from "../client.js";
+import { getCachedXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getCurrentTaskId } from "../task-manager.js";
+import { getCurrentSessionContext } from './session-manager.js';
 import { logger } from "../utils/logger.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-export function createCalendarTool(ctx) {
-    const { config, sessionId, taskId, messageId } = ctx;
-    return {
-        name: "create_calendar_event",
-        label: "Create Calendar Event",
-        description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
+export const calendarTool = {
+    name: "create_calendar_event",
+    label: "Create Calendar Event",
+    description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
   注意事项：使用该工具之前需获取当前真实时间
 
   回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
-        parameters: {
-            type: "object",
-            properties: {
-                title: {
-                    type: "string",
-                    description: "日程标题/名称",
-                },
-                dtStart: {
-                    type: "string",
-                    description: "日程开始时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）",
-                },
-                dtEnd: {
-                    type: "string",
-                    description: "日程结束时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 17:30:00）",
-                },
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "日程标题/名称",
+            },
+            dtStart: {
+                type: "string",
+                description: "日程开始时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）",
+            },
+            dtEnd: {
+                type: "string",
+                description: "日程结束时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 17:30:00）",
             },
-            required: ["title", "dtStart", "dtEnd"],
         },
-        async execute(toolCallId, params) {
-            // Validate parameters
-            if (!params.title || !params.dtStart || !params.dtEnd) {
-                throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
-            }
-            // Convert time strings to millisecond timestamps
-            const dtStartMs = new Date(params.dtStart).getTime();
-            const dtEndMs = new Date(params.dtEnd).getTime();
-            if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
-                throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
-            }
-            // Get WebSocket manager
-            const wsManager = getXYWebSocketManager(config);
-            // Build CreateCalendarEvent command
-            const command = {
-                header: {
-                    namespace: "Common",
-                    name: "ActionAndResult",
-                },
-                payload: {
-                    cardParam: {},
-                    executeParam: {
-                        executeMode: "background",
-                        intentName: "CreateCalendarEvent",
-                        bundleName: "com.huawei.hmos.calendardata",
-                        dimension: "",
-                        needUnlock: true,
-                        actionResponse: true,
-                        timeOut: 5,
-                        intentParam: {
-                            title: params.title,
-                            dtStart: dtStartMs,
-                            dtEnd: dtEndMs,
-                        },
-                        achieveType: "INTENT",
+        required: ["title", "dtStart", "dtEnd"],
+    },
+    async execute(toolCallId, params) {
+        const _c = getCurrentSessionContext();
+        const { config, sessionId, taskId, messageId } = _c;
+        // Validate parameters
+        if (!params.title || !params.dtStart || !params.dtEnd) {
+            throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
+        }
+        // Convert time strings to millisecond timestamps
+        const dtStartMs = new Date(params.dtStart).getTime();
+        const dtEndMs = new Date(params.dtEnd).getTime();
+        if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
+            throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
+        }
+        // Get WebSocket manager
+        const wsManager = getCachedXYWebSocketManager();
+        // Build CreateCalendarEvent command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "ActionAndResult",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "CreateCalendarEvent",
+                    bundleName: "com.huawei.hmos.calendardata",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        title: params.title,
+                        dtStart: dtStartMs,
+                        dtEnd: dtEndMs,
                     },
-                    responses: [
-                        {
-                            resultCode: "",
-                            displayText: "",
-                            ttsText: "",
-                        },
-                    ],
-                    needUploadResult: true,
-                    noHalfPage: false,
-                    pageControlRelated: false,
+                    achieveType: "INTENT",
                 },
-            };
-            // 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 });
-                    reject(new Error("创建日程超时（60秒）"));
-                }, 60000);
-                // Listen for data events from WebSocket
-                const handler = (event) => {
-                    if (event.intentName === "CreateCalendarEvent") {
-                        clearTimeout(timeout);
-                        wsManager.off("data-event", handler);
-                        if (event.status === "success" && event.outputs) {
-                            resolve({
-                                content: [
-                                    {
-                                        type: "text",
-                                        text: JSON.stringify(event.outputs),
-                                    },
-                                ],
-                            });
-                        }
-                        else {
-                            reject(new Error(`创建日程失败: ${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) => {
+                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);
+                logger.error("超时: 创建日程超时（60秒）", { toolCallId });
+                reject(new Error("创建日程超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "CreateCalendarEvent") {
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
-                    reject(error);
-                });
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`创建日程失败: ${JSON.stringify(event.outputs)}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                toolCallId,
+            })
+                .then(() => {
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
             });
-        },
-    };
-}
+        });
+    },
+};

package/dist/src/tools/call-device-tool.d.ts

@@ -1,6 +1,20 @@
-import type { SessionContext } from "./session-manager.js";
-/**
- * call_device_tool - 通用端工具调度器。
- * LLM 必须先通过 get_xxx_tool_schema 获取具体工具 schema，再用本工具执行。
- */
-export declare function createCallDeviceTool(ctx: SessionContext): any;
+export declare const callDeviceTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            toolName: {
+                type: string;
+                description: string;
+            };
+            arguments: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(toolCallId: string, params: any): Promise<any>;
+};