@ynhcj/xiaoyi-channel 0.0.153-beta → 0.0.154-beta

package/dist/index.js

@@ -3,9 +3,30 @@ import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
 import registerSentinelHook from "./src/cspl/sentinel_hook.js";
 import { setXYRuntime } from "./src/runtime.js";
+import { markCronToolCall, clearCronToolCall } from "./src/tools/session-manager.js";
 import { registerSelfEvolutionToolResultNudge } from "./src/self-evolution-tool-result-nudge.js";
 import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
 import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
+/**
+ * Register the cron detection hook.
+ *
+ * When openclaw's cron runner triggers a tool call, the sessionKey has the
+ * format "cron:<jobId>".  We use this to mark the toolCallId in a global Map
+ * so that sendCommand() can route the command through the push channel
+ * instead of the (non-existent) WebSocket session.
+ */
+function registerCronDetectionHook(api) {
+    api.on("before_tool_call", async (event, ctx) => {
+        if (ctx.sessionKey?.startsWith("cron:") && event.toolCallId) {
+            markCronToolCall(event.toolCallId);
+        }
+    });
+    api.on("after_tool_call", async (event, ctx) => {
+        if (event.toolCallId) {
+            clearCronToolCall(event.toolCallId);
+        }
+    });
+}
 function registerFullHooks(api) {
     // SKILL RETRIEVER HOOK: before_prompt_build hook
     const pluginConfig = api.pluginConfig || {};
@@ -45,6 +66,8 @@ export default definePluginEntry({
             registerFullHooks(api);
             // CSPL sentinel hook: before_tool_call + after_tool_call security scanning
             registerSentinelHook(api);
+            // Cron detection hook: marks toolCallIds from cron sessions
+            registerCronDetectionHook(api);
         }
     },
 });

package/dist/src/bot.js

@@ -1,6 +1,6 @@
 import { getXYRuntime } from "./runtime.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
-import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractTriggerData } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractTriggerData, extractRunCrossTaskContext } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
@@ -22,6 +22,9 @@ import { logger } from "./utils/logger.js";
  */
 export async function handleXYMessage(params) {
     const { cfg, runtime, message, accountId, webSocketSessionId } = params;
+    const distributionSessionId = typeof message?.sessionId === "string" && message.sessionId.length > 0
+        ? message.sessionId
+        : undefined;
     // Cache context for CSPL steer injection (after_tool_call hook)
     setCsplSteerContext(cfg, runtime);
     // Get runtime (already validated in monitor.ts, but get reference for use)
@@ -135,6 +138,7 @@ export async function handleXYMessage(params) {
         if (deviceType) {
             log.log(`[BOT] Extracted deviceType: ${deviceType}`);
         }
+        const runCrossTaskContext = extractRunCrossTaskContext(parsed.parts);
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -155,10 +159,12 @@ export async function handleXYMessage(params) {
             registerSession(route.sessionKey, {
                 config,
                 sessionId: parsed.sessionId,
+                distributionSessionId,
                 taskId: parsed.taskId,
                 messageId: parsed.messageId,
                 agentId: route.accountId,
                 deviceType,
+                runCrossTaskContext: runCrossTaskContext ?? undefined,
             });
             // 🔑 发送初始状态更新
             log.log(`[BOT] Sending initial status update`);
@@ -300,10 +306,12 @@ export async function handleXYMessage(params) {
         const sessionContext = {
             config,
             sessionId: parsed.sessionId,
+            distributionSessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
             agentId: route.accountId,
             deviceType,
+            runCrossTaskContext: runCrossTaskContext ?? undefined,
         };
         log.log(`[BOT-DISPATCH] withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({

package/dist/src/channel.js

@@ -2,9 +2,15 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 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 { getCurrentSessionContext, registerSession } 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-";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -43,11 +49,59 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    agentTools: () => {
-        const ctx = getCurrentSessionContext();
+    /**
+     * 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 ──────────────────────────────
+        // When no active xy WebSocket session exists but the openclaw cfg
+        // is provided (framework calls agentTools({ cfg })), create a
+        // synthetic "cron session".  This enables cron-triggered agent
+        // turns and cross-channel tool calls to use xiaoyi tools via the
+        // push channel.  sendCommand() detects the "cron-" sessionId
+        // prefix and routes commands through push instead of WebSocket.
+        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,
+                };
+                // Register so getCurrentSessionContext() fallback can find it
+                registerSession(`__cron__${cronId}`, ctx);
+                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
+            }
+            catch (err) {
+                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
+            }
+        }
+        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(", ")})`);
+        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(", ")})`);
         return filtered;
     },
     messaging: {

package/dist/src/cron-command.d.ts

@@ -0,0 +1,16 @@
+import type { XYChannelConfig, A2ACommand } from "./types.js";
+export interface SendCommandViaPushParams {
+    config: XYChannelConfig;
+    command: A2ACommand;
+}
+/**
+ * Send a tool command through the push channel (for cron-triggered tool calls).
+ *
+ * Flow:
+ *  1. Command JSON is persisted via savePushData → pushDataId
+ *  2. Push notification is sent to all registered pushIds, referencing pushDataId
+ *  3. Device receives push → retrieves command → executes it
+ *  4. Device returns result via WebSocket (data-event / gui-agent-response / …)
+ *  5. The calling tool listens on the WebSocket manager as usual
+ */
+export declare function sendCommandViaPush(params: SendCommandViaPushParams): Promise<void>;

package/dist/src/cron-command.js

@@ -0,0 +1,64 @@
+// Cron-triggered tool command delivery via push channel.
+// When a cron/scheduled task executes a tool, there is no active WebSocket
+// session to carry the command. Instead, the command is delivered through
+// the push notification channel (agent-webhook), which reaches the device
+// independently of any session. The device processes the command and returns
+// results through the normal WebSocket connection, so response listening
+// works the same as for regular tool calls.
+import { XYPushService } from "./push.js";
+import { savePushData } from "./utils/pushdata-manager.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
+import { logger } from "./utils/logger.js";
+/**
+ * Send a tool command through the push channel (for cron-triggered tool calls).
+ *
+ * Flow:
+ *  1. Command JSON is persisted via savePushData → pushDataId
+ *  2. Push notification is sent to all registered pushIds, referencing pushDataId
+ *  3. Device receives push → retrieves command → executes it
+ *  4. Device returns result via WebSocket (data-event / gui-agent-response / …)
+ *  5. The calling tool listens on the WebSocket manager as usual
+ */
+export async function sendCommandViaPush(params) {
+    const { config, command } = params;
+    const commandJson = JSON.stringify(command);
+    const intentName = command.payload?.executeParam?.intentName ??
+        command.header?.name ??
+        "Command";
+    logger.log(`[CRON-CMD] Sending command via push, intent=${intentName}`);
+    // 1. Persist command data
+    let pushDataId = "";
+    try {
+        pushDataId = await savePushData(commandJson);
+        logger.log(`[CRON-CMD] Command data saved, pushDataId=${pushDataId.substring(0, 20)}`);
+    }
+    catch (error) {
+        logger.error("[CRON-CMD] Failed to save command data:", error);
+    }
+    // 2. Load push IDs
+    let pushIdList = [];
+    try {
+        pushIdList = await getAllPushIds();
+    }
+    catch (error) {
+        logger.error("[CRON-CMD] Failed to load pushIds:", error);
+    }
+    if (pushIdList.length === 0) {
+        pushIdList = [config.pushId];
+    }
+    // 3. Broadcast push notification
+    const pushService = new XYPushService(config);
+    const title = `定时任务: ${intentName}`;
+    const pushText = commandJson.length > 1000 ? commandJson.slice(0, 1000) : commandJson;
+    let successCount = 0;
+    for (const pushId of pushIdList) {
+        try {
+            await pushService.sendPush(pushText, title, undefined, config.defaultSessionId || "", pushDataId, pushId);
+            successCount++;
+        }
+        catch (error) {
+            logger.error(`[CRON-CMD] Failed to send push to pushId=${pushId.substring(0, 20)}`, error);
+        }
+    }
+    logger.log(`[CRON-CMD] Push sent to ${successCount}/${pushIdList.length} pushId(s), intent=${intentName}`);
+}

package/dist/src/formatter.d.ts

@@ -63,10 +63,20 @@ export interface SendCommandParams {
     sessionId: string;
     taskId: string;
     messageId: string;
-    command: A2ACommand;
+    command?: A2ACommand;
+    commands?: A2ACommand[];
+    /** toolCallId from the tool's execute() — used for cron detection via hook-set Map. */
+    toolCallId?: string;
 }
 /**
  * Send a command as an artifact update (final=false).
+ *
+ * Cron-aware: if the sessionId starts with the cron prefix ("cron-"),
+ * the command is delivered through the push channel instead of the
+ * WebSocket session, because cron-triggered tool calls have no active
+ * WebSocket session.  The device receives the push, executes the command,
+ * and returns results through the normal WebSocket path — so response
+ * listening in the calling tool works unchanged.
  */
 export declare function sendCommand(params: SendCommandParams): Promise<void>;
 /**

package/dist/src/formatter.js

@@ -5,6 +5,7 @@ import { logger } from "./utils/logger.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import { redactSensitiveText, containsSensitiveInfo } from "./sensitive-redactor.js";
 import { rewriteOutboundApprovalText } from "./approval-bridge.js";
+import { isCronToolCall } from "./tools/session-manager.js";
 // ─────────────────────────────────────────────────────────────
 // 敏感信息脱敏辅助函数
 // ─────────────────────────────────────────────────────────────
@@ -199,9 +200,28 @@ export async function sendStatusUpdate(params) {
 }
 /**
  * Send a command as an artifact update (final=false).
+ *
+ * Cron-aware: if the sessionId starts with the cron prefix ("cron-"),
+ * the command is delivered through the push channel instead of the
+ * WebSocket session, because cron-triggered tool calls have no active
+ * WebSocket session.  The device receives the push, executes the command,
+ * and returns results through the normal WebSocket path — so response
+ * listening in the calling tool works unchanged.
  */
 export async function sendCommand(params) {
-    const { config, sessionId, taskId, messageId, command } = params;
+    const { config, sessionId, taskId, messageId, toolCallId } = params;
+    const commands = params.commands ?? (params.command ? [params.command] : []);
+    if (commands.length === 0) {
+        throw new Error("sendCommand requires command or commands.");
+    }
+    // ── Cron mode: route through push channel ──────────────────────
+    // Detected via: (a) sessionId "cron-" prefix from synthetic session, OR
+    //               (b) toolCallId marked by before_tool_call hook from openclaw's sessionKey.
+    if (sessionId.startsWith("cron-") || isCronToolCall(toolCallId)) {
+        const { sendCommandViaPush } = await import("./cron-command.js");
+        return sendCommandViaPush({ config, command: commands[0] });
+    }
+    // ── Normal mode: WebSocket ─────────────────────────────────────
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
     // fall back to closure-captured values
     const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
@@ -221,7 +241,7 @@ export async function sendCommand(params) {
                 {
                     kind: "data",
                     data: {
-                        commands: [command],
+                        commands,
                     },
                 },
             ],

package/dist/src/parser.d.ts

@@ -1,4 +1,4 @@
-import type { A2AJsonRpcRequest, A2AMessagePart, A2ADataEvent } from "./types.js";
+import type { A2AJsonRpcRequest, A2AMessagePart, A2ADataEvent, RunCrossTaskContext } from "./types.js";
 /**
  * Parsed message information extracted from A2A request.
  * Note: agentId is not extracted from message - it should come from config.
@@ -30,6 +30,7 @@ export declare function extractFileParts(parts: A2AMessagePart[]): Array<{
  * Extract data events from message parts (for tool responses).
  */
 export declare function extractDataEvents(parts: A2AMessagePart[]): A2ADataEvent[];
+export declare function extractRunCrossTaskContext(parts: A2AMessagePart[]): RunCrossTaskContext | null;
 /**
  * Check if message is a clearContext request.
  */

package/dist/src/parser.js

@@ -45,6 +45,31 @@ export function extractDataEvents(parts) {
         .map((part) => part.data.event)
         .filter((event) => event !== undefined);
 }
+export function extractRunCrossTaskContext(parts) {
+    for (const part of parts) {
+        if (part.kind !== "data" || !part.data) {
+            continue;
+        }
+        const context = part.data.runCrossTaskContext;
+        if (!context || typeof context !== "object") {
+            continue;
+        }
+        const networkId = typeof context.networkId === "string" ? context.networkId : "";
+        if (!networkId) {
+            continue;
+        }
+        return {
+            agentId: typeof context.agentId === "string" ? context.agentId : "",
+            sessionId: typeof context.sessionId === "string" ? context.sessionId : "",
+            isDistributed: context.isDistributed === true,
+            networkId,
+            isSupportAgent: context.isSupportAgent !== false,
+            fileUrls: Array.isArray(context.fileUrls) ? context.fileUrls.filter((url) => typeof url === "string") : [],
+            rawContext: context,
+        };
+    }
+    return null;
+}
 /**
  * Check if message is a clearContext request.
  */

package/dist/src/reply-dispatcher.js

@@ -1,11 +1,55 @@
 import { getXYRuntime } from "./runtime.js";
-import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
+import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate, sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import fs from "fs/promises";
 import path from "path";
 import { logger } from "./utils/logger.js";
 const TEMP_FILE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const RUN_CROSS_TASK_LOG_TAG = "[RunCrossTask]";
+function buildDistributionStatusCommand(context) {
+    return {
+        header: {
+            namespace: "DistributionInteraction",
+            name: "DistributionStatus",
+        },
+        payload: {
+            agentId: context.agentId,
+            isDistributed: true,
+            networkId: context.networkId,
+            distributionType: "softbus",
+            distributionExecutePolicy: "backgroundExecution",
+        },
+    };
+}
+function buildCrossTaskExecuteResultCommand(code, message, fileUrls = []) {
+    return {
+        header: {
+            namespace: "DistributionInteraction",
+            name: "CrossTaskExecuteResult",
+        },
+        payload: {
+            code,
+            message,
+            fileUrls,
+        },
+    };
+}
+async function sendRunCrossTaskResult(params) {
+    const { config, sessionId, taskId, messageId, context, resultCode, resultMessage } = params;
+    const fileUrls = Array.isArray(context.fileUrls) ? context.fileUrls : [];
+    const statusCommand = buildDistributionStatusCommand(context);
+    const resultCommand = buildCrossTaskExecuteResultCommand(resultCode, resultMessage, fileUrls);
+    await sendCommand({
+        config,
+        sessionId,
+        taskId,
+        messageId,
+        commands: [statusCommand, resultCommand],
+    });
+    logger.log(`${RUN_CROSS_TASK_LOG_TAG} sent cross-task result, sessionId=${sessionId}, taskId=${taskId}, code=${resultCode}, fileUrlCount=${fileUrls.length}, messageLength=${resultMessage.length}`);
+}
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件
  */
@@ -71,6 +115,10 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     let finalSent = false;
     let accumulatedText = "";
+    const initialRunCrossTaskContext = getCurrentSessionContext()?.runCrossTaskContext;
+    const getRunCrossTaskContext = () => {
+        return getCurrentSessionContext()?.runCrossTaskContext ?? initialRunCrossTaskContext;
+    };
     /**
      * Start the status update interval
      */
@@ -180,6 +228,18 @@ export function createXYReplyDispatcher(params) {
             if (hasSentResponse && !finalSent) {
                 scopedLog().log(`[ON-IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
+                    const runCrossTaskContext = getRunCrossTaskContext();
+                    if (runCrossTaskContext) {
+                        await sendRunCrossTaskResult({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            context: runCrossTaskContext,
+                            resultCode: "0",
+                            resultMessage: accumulatedText,
+                        });
+                    }
                     // 🔑 使用动态taskId发送完成状态
                     await sendStatusUpdate({
                         config,
@@ -211,6 +271,18 @@ export function createXYReplyDispatcher(params) {
                 // 正常失败场景（非steered）
                 scopedLog().log(`[ON-IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
                 try {
+                    const runCrossTaskContext = getRunCrossTaskContext();
+                    if (runCrossTaskContext) {
+                        await sendRunCrossTaskResult({
+                            config,
+                            sessionId,
+                            taskId: currentTaskId,
+                            messageId: currentMessageId,
+                            context: runCrossTaskContext,
+                            resultCode: "1",
+                            resultMessage: "任务执行异常，请重试",
+                        });
+                    }
                     await sendStatusUpdate({
                         config,
                         sessionId,

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

@@ -125,6 +125,7 @@ export function createAgentAsSkillTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 }).then(() => {
                     logger.log("[AGENT-AS-SKILL] Command sent successfully", { agentId: params.agentId });
                 }).catch((error) => {

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

@@ -120,6 +120,7 @@ export function createCalendarTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/call-phone-tool.js

@@ -112,6 +112,7 @@ export function createCallPhoneTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/create-alarm-tool.js

@@ -258,6 +258,7 @@ b. 使用该工具之前需获取当前真实时间
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/create-all-tools.js

@@ -17,6 +17,8 @@ import { createGetEmailToolSchemaTool } from "./get-email-tool-schema.js";
 import { createLoginTokenTool } from "./login-token-tool.js";
 import { createAgentAsSkillTool } from "./agent-as-skill-tool.js";
 import { createFindPcDevicesTool } from "./find-pc-devices-tool.js";
+import { createDiscoverCrossDevicesTool } from "./discover-cross-devices-tool.js";
+import { createSendCrossDeviceTaskTool } from "./send-cross-device-task-tool.js";
 import { logger } from "../utils/logger.js";
 /**
  * Create all XY channel tools for the given session context.
@@ -32,6 +34,8 @@ export function createAllTools(ctx) {
     logger.log(`[CREATE-ALL-TOOLS] creating tools`);
     return [
         createLocationTool(ctx),
+        createDiscoverCrossDevicesTool(ctx),
+        createSendCrossDeviceTaskTool(ctx),
         createCallDeviceTool(ctx),
         createGetNoteToolSchemaTool(ctx),
         createGetCalendarToolSchemaTool(ctx),

package/dist/src/tools/delete-alarm-tool.js

@@ -157,6 +157,7 @@ export function createDeleteAlarmTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/discover-cross-devices-tool.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContext } from "./session-manager.js";
+export declare function createDiscoverCrossDevicesTool(ctx: SessionContext): any;