@ynhcj/xiaoyi-channel 0.0.168-next → 0.0.169-next

package/dist/src/channel.js

@@ -3,14 +3,54 @@ import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
-import { createAllTools } from "./tools/create-all-tools.js";
 import { logger } from "./utils/logger.js";
-/**
- * Prefix used for synthetic sessionIds created during cron-triggered tool
- * execution.  `sendCommand()` checks this prefix to route commands through
- * the push channel instead of the (non-existent) WebSocket session.
- */
-const CRON_SESSION_PREFIX = "cron-";
+// Static tool imports (3.24 pattern)
+import { locationTool } from "./tools/location-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { sendHtmlCardTool } from "./tools/send-html-card-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
+import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
+import { callDeviceTool } from "./tools/call-device-tool.js";
+import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
+import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
+import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
+import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
+import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
+import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
+import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
+import { agentAsSkillTool } from "./tools/agent-as-skill-tool.js";
+import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js";
+import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
+import { displayA2UICardTool } from "./tools/display-a2ui-card-tool.js";
+import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+const ALL_TOOLS = [
+    locationTool,
+    discoverCrossDevicesTool,
+    sendCrossDeviceTaskTool,
+    displayA2UICardTool,
+    callDeviceTool,
+    getNoteToolSchemaTool,
+    getCalendarToolSchemaTool,
+    getContactToolSchemaTool,
+    getPhotoToolSchemaTool,
+    xiaoyiGuiTool,
+    getDeviceFileToolSchemaTool,
+    getAlarmToolSchemaTool,
+    getCollectionToolSchemaTool,
+    sendFileToUserTool,
+    sendHtmlCardTool,
+    viewPushResultTool,
+    imageReadingTool,
+    timestampToUtc8Tool,
+    saveSelfEvolutionSkillTool,
+    loginTokenTool,
+    agentAsSkillTool,
+    checkPluginPrivilegeTool,
+];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -32,7 +72,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"], // Only private chat (no group support)
+        chatTypes: ["direct"],
         polls: false,
         threads: false,
         media: true,
@@ -49,59 +89,11 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /**
-     * Provide channel-specific agent tools.
-     *
-     * Two execution contexts are supported:
-     *
-     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
-     *     a context that was registered by bot.ts during message processing.
-     *     Tools send commands through the WebSocket and listen for responses.
-     *
-     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
-     *     `agentTools({ cfg })` without an active WebSocket session.  When no
-     *     session context exists but `cfg` is provided, we create a synthetic
-     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
-     *     `sendCommand()` detects this prefix and routes commands through the
-     *     push channel.  Response listening (WebSocket events) works unchanged
-     *     because the gateway WebSocket connection is always active.
-     */
-    agentTools: (params) => {
-        let ctx = getCurrentSessionContext();
-        // ── Cron / non-session fallback ──────────────────────────────
-        // cron 路径不进 ALS: openclaw 的 cron runner 同步调 agentTools({cfg})
-        // 返回工具后才在别处跑 turn, xy_channel 没有 wrap 整个 turn 的点。
-        // 这里同步构造合成 ctx 给工具闭包捕获, 工具调用走 sendCommand/push,
-        // 不依赖 getCurrentSessionContext。所以不注册任何全局状态。
-        if (!ctx && params?.cfg) {
-            try {
-                const config = resolveXYConfig(params.cfg);
-                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-                ctx = {
-                    config,
-                    sessionId: cronId,
-                    taskId: cronId,
-                    messageId: cronId,
-                    agentId: "default",
-                    isCron: true,
-                };
-                logger.log(`[ALS-PROOF] agentTools ctx from ALS miss, using synthetic cron ctx sessionId=${cronId} isCron=true`);
-                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
-            }
-            catch (err) {
-                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
-            }
-        }
-        else {
-            logger.log(`[ALS-PROOF] agentTools ctx from ALS sessionId=${ctx?.sessionId} taskId=${ctx?.taskId} isCron=${ctx?.isCron === true}`);
-        }
-        if (!ctx) {
-            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
-            return [];
-        }
-        const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+    /** Static tool list (3.24 pattern). Tools read SessionContext at execute time via ALS. */
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(ALL_TOOLS, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${ALL_TOOLS.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {
@@ -113,7 +105,6 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
-                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -139,7 +130,6 @@ export const xyPlugin = {
     reload: {
         configPrefixes: ["channels.xiaoyi-channel"],
     },
-    // Gateway adapter for receiving messages
     gateway: {
         async startAccount(context) {
             const { monitorXYProvider } = await import("./monitor.js");

package/dist/src/client.d.ts

@@ -1,6 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export declare function getCachedXYWebSocketManager(): XYWebSocketManager;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/client.js

@@ -13,6 +13,16 @@ if (!_g.__xyWsManagerCache) {
     _g.__xyWsManagerCache = new Map();
 }
 const wsManagerCache = _g.__xyWsManagerCache;
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export function getCachedXYWebSocketManager() {
+    if (wsManagerCache.size === 0) {
+        throw new Error("No WebSocket manager available in cache");
+    }
+    return wsManagerCache.values().next().value;
+}
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/tools/agent-as-skill-tool.d.ts

@@ -1,7 +1,50 @@
-import type { SessionContext } from "./session-manager.js";
 /**
  * Agent-as-skill tool - invokes a registered agent by agentId as a skill.
  * The tool receives the agentId, query, and optional file attachments,
  * forwards the request to the target agent via WebSocket, and returns the result.
  */
-export declare function createAgentAsSkillTool(ctx: SessionContext): any;
+export declare const agentAsSkillTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            agentId: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+            filesInfo: {
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        fileType: {
+                            type: string;
+                            description: string;
+                            enum: string[];
+                        };
+                        fileId: {
+                            type: string;
+                            description: string;
+                        };
+                        fileUrl: {
+                            type: string;
+                            description: string;
+                        };
+                        fileUrlLocal: {
+                            type: string;
+                            description: string;
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+    execute(toolCallId: string, params: any): Promise<unknown>;
+};

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

@@ -1,5 +1,5 @@
 // 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 { getCurrentSessionContext } from './session-manager.js';
 import { logger } from "../utils/logger.js";
@@ -9,11 +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) {
-    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执行，并返回执行结果。
 
 使用场景：
@@ -25,166 +24,165 @@ 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地址）",
+                        },
+                        fileUrlLocal: {
+                            type: "string",
+                            description: "文件本地路径，如果提供此字段，工具会自动上传文件并将公网URL填入fileUrl",
                         },
                     },
                 },
             },
-            required: ["agentId", "query"],
         },
-        async execute(toolCallId, params) {
-            const _c = getCurrentSessionContext() ?? ctx;
-            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");
+        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;
             }
-            // 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.fileUrlLocal && !fileInfo.fileUrl) {
+                    try {
+                        const publicUrl = await uploadService.uploadFileAndGetUrl(fileInfo.fileUrlLocal, "TEMPORARY_MATERIAL_DOC");
+                        if (publicUrl) {
+                            fileInfo.fileUrl = publicUrl;
                         }
                         else {
-                            reject(new Error("Agent-as-Skill 响应格式错误：缺少 payload"));
+                            logger.warn("[AGENT-AS-SKILL] 上传文件未返回公网URL", { fileUrlLocal: fileInfo.fileUrlLocal });
                         }
                     }
-                };
-                // 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) => {
+                    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;
+            }
+        }
+        // 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>;
+};