@ynhcj/xiaoyi-channel 0.0.210-beta → 0.0.212-beta

package/dist/src/bot.js

@@ -597,13 +597,24 @@ async function dispatchSteerWhenReady(params) {
         : "";
     const steerMessage = `${steerText}${fileHint}`;
     log.log(`[STEER-QUEUE] Injecting steer message directly into active run`);
-    const injected = queueAgentHarnessMessage(sessionId, steerMessage, {
-        steeringMode: "all",
-    });
+    const STEER_RETRY_MAX = 3;
+    const STEER_RETRY_DELAY_MS = 500;
+    let injected = false;
+    for (let attempt = 0; attempt < STEER_RETRY_MAX; attempt++) {
+        injected = queueAgentHarnessMessage(sessionId, steerMessage, {
+            steeringMode: "all",
+        });
+        if (injected)
+            break;
+        if (attempt < STEER_RETRY_MAX - 1 && hasActiveTask(sessionId)) {
+            log.log(`[STEER-QUEUE] Retry ${attempt + 1}/${STEER_RETRY_MAX}: run not accepting, waiting ${STEER_RETRY_DELAY_MS}ms`);
+            await new Promise(r => setTimeout(r, STEER_RETRY_DELAY_MS));
+        }
+    }
     if (injected) {
         log.log(`[STEER-QUEUE] Steer message injected successfully`);
     }
     else {
-        log.log(`[STEER-QUEUE] Steer injection failed — run may not be accepting messages`);
+        log.log(`[STEER-QUEUE] Steer injection failed after ${STEER_RETRY_MAX} attempts — run may not be accepting messages`);
     }
 }

package/dist/src/channel.js

@@ -27,6 +27,7 @@ import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js
 import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
 import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
 import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+import { invokeTool } from "./tools/invoke.js";
 const ALL_TOOLS = [
     locationTool,
     discoverCrossDevicesTool,
@@ -50,6 +51,7 @@ const ALL_TOOLS = [
     loginTokenTool,
     agentAsSkillTool,
     checkPluginPrivilegeTool,
+    invokeTool,
 ];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.

package/dist/src/tools/hmos-cli.d.ts

@@ -38,6 +38,11 @@ export interface CLICache {
     getCLIs(skillName: string): CLICacheEntry[] | null;
     getCLI(skillName: string, cliName: string): CLICacheEntry | null;
     hasCLI(skillName: string, cliName: string): boolean;
+    /** Search all cached skills for a CLI whose name matches the command prefix. */
+    findCLIByCommand(command: string): {
+        entry: CLICacheEntry;
+        skillName: string;
+    } | null;
     refresh(): Promise<void>;
     getRootDir(): string;
 }
@@ -90,7 +95,8 @@ interface HookResult {
  * before_tool_call hook for CLI exec interception.
  *
  * Only handles built-in `exec` calls whose command prefix matches a CLI
- * declared in the current skill's metadata.clis + available_clis.json.
+ * from any skill's metadata.clis + available_clis.json (searched across
+ * all cached skills, not just the current session's skill).
  * Non-matching commands return undefined (noop) so native exec handles them.
  */
 export declare function cliBeforeToolCallHandler(event: BeforeToolCallEvent, ctx: HookContext): Promise<HookResult | undefined>;

package/dist/src/tools/hmos-cli.js

@@ -15,6 +15,7 @@ import path from "path";
 import os from "os";
 import { logger } from "../utils/logger.js";
 import { InvokeError, invokeErrorToResult } from "./invoke.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
@@ -215,6 +216,23 @@ function wrapState(state) {
             return entries.find(e => e.cliName === cliName) ?? null;
         },
         hasCLI(skillName, cliName) { return this.getCLI(skillName, cliName) !== null; },
+        findCLIByCommand(command) {
+            maybeRefresh(state);
+            const all = [];
+            for (const [skillName, entries] of state.skillClis) {
+                for (const entry of entries) {
+                    all.push({ entry, skillName });
+                }
+            }
+            // Longest CLI name first so "foo bar" matches before "foo"
+            all.sort((a, b) => b.entry.cliName.length - a.entry.cliName.length);
+            for (const item of all) {
+                if (command === item.entry.cliName || command.startsWith(item.entry.cliName + " ")) {
+                    return item;
+                }
+            }
+            return null;
+        },
         async refresh() {
             state.skillClis = scanCLIDirectories(state.rootDir);
             state.lastScanMs = Date.now();
@@ -469,7 +487,8 @@ export { parseSkillName as deriveSkillName };
  * before_tool_call hook for CLI exec interception.
  *
  * Only handles built-in `exec` calls whose command prefix matches a CLI
- * declared in the current skill's metadata.clis + available_clis.json.
+ * from any skill's metadata.clis + available_clis.json (searched across
+ * all cached skills, not just the current session's skill).
  * Non-matching commands return undefined (noop) so native exec handles them.
  */
 export async function cliBeforeToolCallHandler(event, ctx) {
@@ -480,37 +499,15 @@ export async function cliBeforeToolCallHandler(event, ctx) {
         return undefined;
     const t0 = performance.now();
     const command = rawCommand.trim();
-    // Need a current skill context
-    const workspaceDir = ctx.workspaceDir;
-    if (!workspaceDir) {
-        logger.log(`[CLI-HOOK] no workspaceDir, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
-    const skillName = parseSkillName(workspaceDir);
-    if (!skillName) {
-        logger.log(`[CLI-HOOK] no skill name in ${workspaceDir}, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
+    // Search all cached skills for a CLI matching the command prefix
     const cache = getCLICache();
-    const skillCLIs = cache.getCLIs(skillName);
-    if (!skillCLIs || skillCLIs.length === 0) {
-        logger.log(`[CLI-HOOK] Skill '${skillName}' has no CLIs, noop (${(performance.now() - t0).toFixed(1)}ms)`);
-        return undefined;
-    }
-    // Match longest CLI name first
-    const sorted = [...skillCLIs].sort((a, b) => b.cliName.length - a.cliName.length);
-    let matchedCLI = null;
-    for (const entry of sorted) {
-        if (command === entry.cliName || command.startsWith(entry.cliName + " ")) {
-            matchedCLI = entry;
-            break;
-        }
-    }
-    if (!matchedCLI) {
-        logger.log(`[CLI-HOOK] No CLI match for command prefix, noop (${(performance.now() - t0).toFixed(1)}ms)`);
+    const match = cache.findCLIByCommand(command);
+    if (!match) {
+        logger.log(`[CLI-HOOK] No CLI match for '${command}', noop (${(performance.now() - t0).toFixed(1)}ms)`);
         return undefined;
     }
-    logger.log(`[CLI-HOOK] Matched CLI '${matchedCLI.cliName}' (${(performance.now() - t0).toFixed(1)}ms)`);
+    const { entry: matchedCLI, skillName } = match;
+    logger.log(`[CLI-HOOK] Matched CLI '${matchedCLI.cliName}' in skill '${skillName}' (${(performance.now() - t0).toFixed(1)}ms)`);
     // Parse and validate
     let parsed;
     try {
@@ -534,8 +531,8 @@ export async function cliBeforeToolCallHandler(event, ctx) {
             },
         };
     }
-    // Get session context and execute
-    const sessionCtx = (await import("./session-manager.js")).getCurrentSessionContext();
+    // Get session context via ALS (propagated through the async call chain)
+    const sessionCtx = getCurrentSessionContext();
     if (!sessionCtx) {
         logger.warn(`[CLI-HOOK] No session context, blocking (${(performance.now() - t0).toFixed(1)}ms)`);
         return { block: true, blockReason: JSON.stringify({ code: "CONFIG_MISSING", message: "No active session context for CLI execution", retryable: false }) };

package/dist/src/tools/invoke.d.ts

@@ -18,8 +18,6 @@
  *   7. Device executor
  *   8. Invoke tool factory (public API)
  */
-import type { ChannelAgentTool } from "openclaw/plugin-sdk";
-import type { SessionContext } from "./session-manager.js";
 export type InvokeErrorCode = "INVALID_PARAM" | "INVALID_TOOL_DEFINITION" | "CONFIG_MISSING" | "AUTH_FAIL" | "PERMISSION_DENIED" | "CLI_COMMAND_BLOCKED" | "RATE_LIMIT" | "TIMEOUT" | "TOOL_NOT_FOUND" | "TOOL_CONFLICT" | "UNSUPPORTED_PLUGIN_TYPE" | "UNSUPPORTED_PROTOCOL" | "DEVICE_TOOL_BLOCKED" | "UPSTREAM_ERROR" | "NETWORK_ERROR" | "UNKNOWN";
 interface ExecuteResult {
     content: Array<{
@@ -38,11 +36,53 @@ export declare class InvokeError extends Error {
     get status(): number;
 }
 export declare function invokeErrorToResult(error: InvokeError): ExecuteResult;
-/**
- * Create the invoke meta-tool for the given session context.
- *
- * This is the ONLY exported function — the single integration point for
- * create-all-tools.ts.
- */
-export declare function createInvokeTool(ctx: SessionContext): ChannelAgentTool;
+export declare const invokeTool: {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            functionName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            funcName: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            arguments: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            params: {
+                type: string;
+                description: string;
+                properties: {
+                    bundleName: {
+                        type: string;
+                        minLength: number;
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        required: any[];
+        additionalProperties: boolean;
+    };
+    execute(toolCallId: string, rawParams: unknown, _signal?: AbortSignal, _onUpdate?: (partialResult: any) => void): Promise<ExecuteResult>;
+};
 export {};

package/dist/src/tools/invoke.js

@@ -27,6 +27,7 @@ import { logger } from "../utils/logger.js";
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentTaskId } from "../task-manager.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 const RETRYABLE_CODES = new Set([
     "RATE_LIMIT",
     "TIMEOUT",
@@ -46,6 +47,13 @@ const CLIENT_ERROR_CODES = new Set([
     "DEVICE_TOOL_BLOCKED",
     "UNKNOWN",
 ]);
+/** Parse the &-separated taskId into sessionId (part 0) and interactionId (part 1). */
+function parseTaskId(taskId) {
+    const parts = taskId.split("&");
+    const taskSessionId = parts[0] ?? taskId;
+    const interactionId = parseInt(parts[1] ?? "1", 10) || 1;
+    return { taskSessionId, interactionId };
+}
 // ═══════════════════════════════════════════════════════════════════════════
 // 2. Errors
 // ═══════════════════════════════════════════════════════════════════════════
@@ -126,7 +134,7 @@ const REFRESH_INTERVAL_MS = 30_000;
 const REQUIRED_FIELDS = ["schemaVersion", "bundleName", "toolName", "pluginType", "description", "arguments"];
 const CORE_FIELDS = ["bundleName", "toolName", "toolType", "pluginType", "protocol", "description", "arguments", "deviceCommand"];
 const VALID_PLUGIN_TYPES = new Set(["Cloud", "Device", "MCP"]);
-const VALID_PROTOCOLS = new Set(["REST", "SSE", "Websocket"]);
+const VALID_PROTOCOLS = new Set(["REST", "SSE", "Websocket", "WebSocket"]);
 const FILENAME_PATTERN = /^(.+)__(.+)\.json$/;
 const _g = globalThis;
 const CACHE_SLOT = "__xyInvokeToolCache";
@@ -525,13 +533,14 @@ function loadCloudConfig() {
     return { serviceUrl: env["SERVICE_URL"], apiKey: env["PERSONAL-API-KEY"], uid: env["PERSONAL-UID"] };
 }
 function buildCloudRequest(p) {
+    const { taskSessionId, interactionId } = parseTaskId(p.taskId);
     return {
         version: "1.0",
         session: {
             isNew: "true",
-            sessionId: p.sessionId,
-            interactionId: 1,
-            conversationId: uuidv4(),
+            sessionId: taskSessionId,
+            interactionId,
+            conversationId: p.sessionId, // ctx.sessionId
             agentLoginSessionId1: p.agentId,
         },
         endpoint: {
@@ -563,11 +572,11 @@ function buildCloudRequest(p) {
         },
     };
 }
-function buildHeaders(config, skillName, protocol) {
+function buildHeaders(config, skillName, protocol, taskId) {
     return {
         "content-type": "application/json",
         accept: protocol === "REST" ? "application/json" : "text/event-stream",
-        "x-hag-trace-id": uuidv4(),
+        "x-hag-trace-id": taskId,
         "x-uid": config.uid,
         "x-api-key": config.apiKey,
         "x-request-from": "openclaw",
@@ -581,10 +590,10 @@ function buildHeaders(config, skillName, protocol) {
 //   - REST: single JSON frame
 //   - SSE/Websocket: multiple SSE frames; only the final frame is used (§4.7)
 async function executePluginExecutor(config, requestBody, headers, toolName, bundleName, protocol) {
-    // Convert serviceUrl to wss:// regardless of original protocol (http, https, etc.)
-    const wsBaseUrl = config.serviceUrl.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//i, "wss://");
+    // Map http→ws, https→wss
+    const wsBaseUrl = config.serviceUrl.replace(/^http(s)?:\/\//i, "ws$1://");
     const url = `${wsBaseUrl}${UNIFIED_API_SUFFIX}`;
-    const isStreaming = protocol === "SSE" || protocol === "Websocket";
+    const isStreaming = protocol === "SSE" || protocol === "Websocket" || protocol === "WebSocket";
     logger.log(`[INVOKE-CLOUD] calling PluginExecutor via WebSocket`, { url, toolName, bundleName, protocol });
     const urlObj = new URL(url);
     const isWssWithIP = urlObj.protocol === "wss:" && /^(\d{1,3}\.){3}\d{1,3}$/.test(urlObj.hostname);
@@ -856,14 +865,14 @@ async function executeCloudTool(params) {
         toolName, bundleName, skillName, protocol,
         businessKeysCount: Object.keys(businessParams).length,
     });
-    if (protocol !== "REST" && protocol !== "SSE" && protocol !== "Websocket") {
+    if (protocol !== "REST" && protocol !== "SSE" && protocol !== "Websocket" && protocol !== "WebSocket") {
         logger.warn("[INVOKE-CLOUD] unknown protocol", { toolName, bundleName, protocol });
         throw new InvokeError("UNSUPPORTED_PROTOCOL", `Unknown protocol: ${protocol}`);
     }
     // Per invoke.md §4.3: REST, SSE, and Websocket all use the same endpoint.
     // Only the accept header and response handling differ.
     const config = loadCloudConfig();
-    return executePluginExecutor(config, buildCloudRequest(params), buildHeaders(config, skillName, protocol), toolName, bundleName, protocol);
+    return executePluginExecutor(config, buildCloudRequest(params), buildHeaders(config, skillName, protocol, params.taskId), toolName, bundleName, protocol);
 }
 // ═══════════════════════════════════════════════════════════════════════════
 // 7. Device executor
@@ -1066,136 +1075,135 @@ function validateBusinessParams(businessParams, definition) {
     }
     return null;
 }
-/**
- * Create the invoke meta-tool for the given session context.
- *
- * This is the ONLY exported function — the single integration point for
- * create-all-tools.ts.
- */
-export function createInvokeTool(ctx) {
-    return {
-        name: "invoke",
-        label: "Invoke",
-        description: "调用已安装 skill 中声明的工具。必须传 functionName(或funcName) 与 arguments(或params)；functionName 的值等于工具定义中的 toolName；arguments 是包含 bundleName 和业务参数字段的对象；完整业务参数定义见 references/tools/<bundleName>__<toolName>.json。",
-        parameters: {
-            type: "object",
-            properties: {
-                functionName: {
-                    type: "string",
-                    minLength: 1,
-                    description: "工具名称，值等于对应 references/tools JSON 中的 toolName，如 weather_query（优先使用；funcName 已废弃但仍兼容）。",
-                },
-                funcName: {
-                    type: "string",
-                    minLength: 1,
-                    description: "[废弃] 请使用 functionName 替代。工具名称，值等于对应 references/tools JSON 中的 toolName。",
-                },
-                arguments: {
-                    type: "object",
-                    description: "包含定位字段 bundleName 与业务参数字段；除 bundleName 外的字段遵循对应 references/tools JSON 中的 arguments schema（优先使用；params 已废弃但仍兼容）。",
-                    properties: {
-                        bundleName: {
-                            type: "string",
-                            minLength: 1,
-                            description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
-                        },
+// ═══════════════════════════════════════════════════════════════════════════
+// 8. Invoke tool (static — matches ALL_TOOLS pattern)
+// ═══════════════════════════════════════════════════════════════════════════
+export const invokeTool = {
+    name: "invoke",
+    label: "Invoke",
+    description: "调用已安装 skill 中声明的工具。必须传 functionName(或funcName) 与 arguments(或params)；functionName 的值等于工具定义中的 toolName；arguments 是包含 bundleName 和业务参数字段的对象；完整业务参数定义见 references/tools/<bundleName>__<toolName>.json。",
+    parameters: {
+        type: "object",
+        properties: {
+            functionName: {
+                type: "string",
+                minLength: 1,
+                description: "工具名称，值等于对应 references/tools JSON 中的 toolName，如 weather_query（优先使用；funcName 已废弃但仍兼容）。",
+            },
+            funcName: {
+                type: "string",
+                minLength: 1,
+                description: "[废弃] 请使用 functionName 替代。工具名称，值等于对应 references/tools JSON 中的 toolName。",
+            },
+            arguments: {
+                type: "object",
+                description: "包含定位字段 bundleName 与业务参数字段；除 bundleName 外的字段遵循对应 references/tools JSON 中的 arguments schema（优先使用；params 已废弃但仍兼容）。",
+                properties: {
+                    bundleName: {
+                        type: "string",
+                        minLength: 1,
+                        description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
                     },
-                    required: ["bundleName"],
-                    additionalProperties: true,
                 },
-                params: {
-                    type: "object",
-                    description: "[废弃] 请使用 arguments 替代。包含定位字段 bundleName 与业务参数字段。",
-                    properties: {
-                        bundleName: {
-                            type: "string",
-                            minLength: 1,
-                            description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
-                        },
+                required: ["bundleName"],
+                additionalProperties: true,
+            },
+            params: {
+                type: "object",
+                description: "[废弃] 请使用 arguments 替代。包含定位字段 bundleName 与业务参数字段。",
+                properties: {
+                    bundleName: {
+                        type: "string",
+                        minLength: 1,
+                        description: "HarmonyOS 应用唯一标识，如 com.example.weather。",
                     },
-                    required: ["bundleName"],
-                    additionalProperties: true,
                 },
+                required: ["bundleName"],
+                additionalProperties: true,
             },
-            required: [],
-            additionalProperties: false,
         },
-        async execute(toolCallId, rawParams, _signal, _onUpdate) {
-            // Layer 1: input validation
-            const validated = validateAndExtract(rawParams);
-            if ("content" in validated) {
-                logger.warn("[INVOKE] input validation failed", { toolCallId });
-                return validated;
-            }
-            const { toolName, bundleName, businessParams } = validated;
-            const businessKeys = Object.keys(businessParams);
-            logger.log("[INVOKE] tool called", {
-                toolCallId, toolName, bundleName,
-                businessKeys: businessKeys.join(","),
-                businessKeysCount: businessKeys.length,
-            });
-            // Layer 2: cache lookup
-            const cache = getToolCache();
-            const entry = cache.get(bundleName, toolName);
-            if (!entry) {
-                const conflict = cache.getConflict(bundleName, toolName);
-                if (conflict) {
-                    const files = conflict.entries.map((e) => e.filePath).join(", ");
-                    logger.warn("[INVOKE] tool conflict", { toolCallId, toolName, bundleName, conflictCount: conflict.entries.length });
-                    return invokeErrorToResult(new InvokeError("TOOL_CONFLICT", `Multiple conflicting definitions for '${toolName}' in bundle '${bundleName}': ${files}`));
-                }
-                logger.warn("[INVOKE] tool not found", { toolCallId, toolName, bundleName });
-                return invokeErrorToResult(new InvokeError("TOOL_NOT_FOUND", `Tool '${toolName}' not found in bundle '${bundleName}'.`));
+        required: [],
+        additionalProperties: false,
+    },
+    async execute(toolCallId, rawParams, _signal, _onUpdate) {
+        const ctx = getCurrentSessionContext();
+        // Layer 1: input validation
+        const validated = validateAndExtract(rawParams);
+        if ("content" in validated) {
+            logger.warn("[INVOKE] input validation failed", { toolCallId });
+            return validated;
+        }
+        const { toolName, bundleName, businessParams } = validated;
+        const businessKeys = Object.keys(businessParams);
+        logger.log("[INVOKE] tool called", {
+            toolCallId, toolName, bundleName,
+            businessKeys: businessKeys.join(","),
+            businessKeysCount: businessKeys.length,
+        });
+        // Layer 2: cache lookup
+        const cache = getToolCache();
+        const entry = cache.get(bundleName, toolName);
+        if (!entry) {
+            const conflict = cache.getConflict(bundleName, toolName);
+            if (conflict) {
+                const files = conflict.entries.map((e) => e.filePath).join(", ");
+                logger.warn("[INVOKE] tool conflict", { toolCallId, toolName, bundleName, conflictCount: conflict.entries.length });
+                return invokeErrorToResult(new InvokeError("TOOL_CONFLICT", `Multiple conflicting definitions for '${toolName}' in bundle '${bundleName}': ${files}`));
             }
-            const { definition, skillName } = entry;
-            logger.log("[INVOKE] cache hit", {
-                toolCallId, toolName, bundleName, skillName,
-                pluginType: definition.pluginType,
-                protocol: definition.protocol ?? "N/A",
-            });
-            // Layer 2b: business param validation
-            const paramError = validateBusinessParams(businessParams, definition);
-            if (paramError) {
-                logger.warn("[INVOKE] business param validation failed", { toolCallId, toolName, bundleName });
-                return paramError;
+            logger.warn("[INVOKE] tool not found", { toolCallId, toolName, bundleName });
+            return invokeErrorToResult(new InvokeError("TOOL_NOT_FOUND", `Tool '${toolName}' not found in bundle '${bundleName}'.`));
+        }
+        const { definition, skillName } = entry;
+        logger.log("[INVOKE] cache hit", {
+            toolCallId, toolName, bundleName, skillName,
+            pluginType: definition.pluginType,
+            protocol: definition.protocol ?? "N/A",
+        });
+        // Layer 2b: business param validation
+        const paramError = validateBusinessParams(businessParams, definition);
+        if (paramError) {
+            logger.warn("[INVOKE] business param validation failed", { toolCallId, toolName, bundleName });
+            return paramError;
+        }
+        // Layer 3: execute
+        const pluginType = definition.pluginType;
+        logger.log(`[INVOKE] dispatching to ${pluginType} executor`, { toolCallId, toolName, bundleName, pluginType });
+        try {
+            if (pluginType === "Cloud" || pluginType === "MCP") {
+                const result = await executeCloudTool({ definition, businessParams, skillName, sessionId: ctx?.sessionId ?? "", agentId: ctx?.agentId ?? "", taskId: ctx?.taskId ?? toolCallId });
+                logger.log("[INVOKE] cloud execution succeeded", {
+                    toolCallId, toolName, bundleName, pluginType,
+                    resultLength: result.content[0]?.text?.length ?? 0,
+                });
+                return result;
             }
-            // Layer 3: execute
-            const pluginType = definition.pluginType;
-            logger.log(`[INVOKE] dispatching to ${pluginType} executor`, { toolCallId, toolName, bundleName, pluginType });
-            try {
-                if (pluginType === "Cloud" || pluginType === "MCP") {
-                    const result = await executeCloudTool({ definition, businessParams, skillName, sessionId: ctx.sessionId, agentId: ctx.agentId });
-                    logger.log("[INVOKE] cloud execution succeeded", {
-                        toolCallId, toolName, bundleName, pluginType,
-                        resultLength: result.content[0]?.text?.length ?? 0,
-                    });
-                    return result;
+            if (pluginType === "Device") {
+                if (!ctx) {
+                    return invokeErrorToResult(new InvokeError("DEVICE_TOOL_BLOCKED", "Device tools require an active session context."));
                 }
-                if (pluginType === "Device") {
-                    const result = await executeDeviceTool({ definition, businessParams, toolCallId }, ctx);
-                    logger.log("[INVOKE] device execution succeeded", {
-                        toolCallId, toolName, bundleName,
-                        resultLength: result.content[0]?.text?.length ?? 0,
-                    });
-                    return result;
-                }
-                logger.warn("[INVOKE] unsupported pluginType", { toolCallId, toolName, bundleName, pluginType });
-                return invokeErrorToResult(new InvokeError("UNSUPPORTED_PLUGIN_TYPE", `Unsupported pluginType '${pluginType}'. Must be Cloud, Device, or MCP.`));
+                const result = await executeDeviceTool({ definition, businessParams, toolCallId }, ctx);
+                logger.log("[INVOKE] device execution succeeded", {
+                    toolCallId, toolName, bundleName,
+                    resultLength: result.content[0]?.text?.length ?? 0,
+                });
+                return result;
             }
-            catch (err) {
-                if (err instanceof InvokeError) {
-                    logger.warn("[INVOKE] invocation error", {
-                        toolCallId, toolName, bundleName, pluginType,
-                        errorCode: err.code, errorMessage: err.message, retryable: err.retryable,
-                    });
-                    return invokeErrorToResult(err);
-                }
-                logger.error("[INVOKE] unexpected execution error", {
+            logger.warn("[INVOKE] unsupported pluginType", { toolCallId, toolName, bundleName, pluginType });
+            return invokeErrorToResult(new InvokeError("UNSUPPORTED_PLUGIN_TYPE", `Unsupported pluginType '${pluginType}'. Must be Cloud, Device, or MCP.`));
+        }
+        catch (err) {
+            if (err instanceof InvokeError) {
+                logger.warn("[INVOKE] invocation error", {
                     toolCallId, toolName, bundleName, pluginType,
-                    error: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+                    errorCode: err.code, errorMessage: err.message, retryable: err.retryable,
                 });
-                return unknownErrorToResult(err);
+                return invokeErrorToResult(err);
             }
-        },
-    };
-}
+            logger.error("[INVOKE] unexpected execution error", {
+                toolCallId, toolName, bundleName, pluginType,
+                error: err instanceof Error ? `${err.name}: ${err.message}` : String(err),
+            });
+            return unknownErrorToResult(err);
+        }
+    },
+};

package/dist/src/websocket.js

@@ -512,6 +512,7 @@ export class XYWebSocketManager extends EventEmitter {
                 ? logger.withContext(sessionId, taskId)
                 : { log: (msg, ...args) => logger.log(msg, ...args) };
             log.log(`[WS-RECV] Raw message frame, size: ${messageStr.length} characters`);
+            log.log(`[WS-RECV] Full message body: ${messageStr}`);
             // Handle direct cross-task requests (top-level networkId)
             const directRunCrossTaskRequest = this.toRunCrossTaskA2ARequest(parsed);
             if (directRunCrossTaskRequest) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.210-beta",
+  "version": "0.0.212-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",