@ynhcj/xiaoyi-channel 0.0.145-next → 0.0.146-next

package/dist/index.js

@@ -1,32 +1,17 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
-import registerSentinelHook from "./src/cspl/sentinel_hook.js";
+import { callCsplApiWithConfig } from "./src/cspl/call-api.js";
+import { getCsplConfig, initCsplConfigFromXYConfig } from "./src/cspl/config.js";
+import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./src/cspl/constants.js";
+import { extractResultText, parseSecurityResult, processText, validateAndTruncateText, } from "./src/cspl/utils.js";
+import { tryInjectSteer } from "./src/cspl/steer-context.js";
+import { getSessionContext } from "./src/tools/session-manager.js";
+import { logger } from "./src/utils/logger.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 || {};
@@ -41,6 +26,67 @@ function registerFullHooks(api) {
     api.on("before_prompt_build", beforePromptBuildHandler);
     registerSelfEvolutionToolResultNudge(api);
 }
+function registerCsplHook(api) {
+    // CSPL security scanning via after_tool_call hook.
+    // When CSPL returns REJECT, injects a steer message via tryInjectSteer
+    // to interrupt the agent. Uses skipRegistration to avoid refCount leaks
+    // and taskId overwrites.
+    // Only registered in "full" mode because it depends on handleXYMessage
+    // having cached cfg/runtime via setCsplSteerContext.
+    api.on("after_tool_call", async (event, ctx) => {
+        if (!ALLOWED_TOOLS.includes(event.toolName)) {
+            return;
+        }
+        try {
+            const resultText = extractResultText(event, event.toolName);
+            const resultLength = resultText.length;
+            if (resultLength <= MIN_TEXT_LENGTH || resultLength > MAX_TOTAL_LENGTH) {
+                return;
+            }
+            logger.log(`[SENTINEL HOOK] after_tool_call: toolName=${event.toolName}, textLength=${resultLength}`);
+            const questionText = {
+                subSceneID: "TOOL_OUTPUT",
+                tool: event.toolName,
+                output: [{ content: "" }],
+            };
+            const originText = processText(resultText);
+            questionText.output[0].content = originText;
+            let finalJson = JSON.stringify(questionText);
+            if (finalJson.length > MAX_TEXT_LENGTH) {
+                const diff = finalJson.length - MAX_TEXT_LENGTH;
+                const { text: trimmed } = validateAndTruncateText(originText, MAX_TEXT_LENGTH - diff);
+                questionText.output[0].content = trimmed;
+                finalJson = JSON.stringify(questionText);
+            }
+            const sessionCtx = getSessionContext(ctx.sessionKey ?? "");
+            const csplConfig = sessionCtx
+                ? initCsplConfigFromXYConfig(sessionCtx.config)
+                : getCsplConfig();
+            const csplStartTime = Date.now();
+            const response = await callCsplApiWithConfig(finalJson, csplConfig);
+            const csplElapsed = Date.now() - csplStartTime;
+            const result = parseSecurityResult(response);
+            logger.log(`[SENTINEL HOOK] Security result: status=${result.status}, toolName=${event.toolName}, elapsed=${csplElapsed}ms`);
+            if (result.status === "REJECT") {
+                logger.log(`[SENTINEL HOOK] REJECT - injecting steer via tryInjectSteer`);
+                if (sessionCtx) {
+                    await tryInjectSteer({
+                        sessionId: sessionCtx.sessionId,
+                        taskId: sessionCtx.taskId,
+                        message: STEER_ABORT_MESSAGE,
+                        source: "cspl",
+                    });
+                }
+                else {
+                    logger.error("[SENTINEL HOOK] No session context, cannot inject steer");
+                }
+            }
+        }
+        catch (err) {
+            logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
+        }
+    });
+}
 export default definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
@@ -64,10 +110,7 @@ export default definePluginEntry({
         }
         if (api.registrationMode === "full") {
             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);
+            registerCsplHook(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, extractRunCrossTaskContext } from "./parser.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractTriggerData } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
@@ -22,9 +22,6 @@ 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)
@@ -38,8 +35,7 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("clearContext request missing sessionId in params");
             }
-            const log = logger.withContext(sessionId, "");
-            log.log(`[BOT] Clear context request`);
+            logger.log(`Clear context request for session ${sessionId}`);
             const config = resolveXYConfig(cfg);
             await sendClearContextResponse({
                 config,
@@ -55,8 +51,7 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("tasks/cancel request missing sessionId in params");
             }
-            const log = logger.withContext(sessionId, taskId);
-            log.log(`[BOT] Tasks cancel request`);
+            logger.log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
             const config = resolveXYConfig(cfg);
             await sendTasksCancelResponse({
                 config,
@@ -68,21 +63,22 @@ export async function handleXYMessage(params) {
         }
         // Parse the A2A message (for regular messages)
         const parsed = parseA2AMessage(message);
-        // Scoped logger for this session — avoids concurrent session log mixing
-        const log = logger.withContext(parsed.sessionId, parsed.taskId);
         // ========== 检测 Trigger 消息 ==========
         // 如果消息中包含 Trigger 事件数据，直接返回 pushData 内容，不走正常流程
         const triggerData = extractTriggerData(parsed.parts);
         if (triggerData) {
-            log.log(`[BOT] Detected Trigger message, pushDataId=${triggerData.pushDataId}`);
+            logger.log(`[BOT] 📌 Detected Trigger message with pushDataId: ${triggerData.pushDataId}`);
+            logger.log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            logger.log(`[BOT]   - Task ID: ${parsed.taskId}`);
             try {
                 // 读取 pushData
                 const pushDataItem = await getPushDataById(triggerData.pushDataId);
                 if (!pushDataItem) {
-                    log.error(`[BOT] pushData not found for ID: ${triggerData.pushDataId}`);
+                    logger.error(`[BOT] ❌ pushData not found for ID: ${triggerData.pushDataId}`);
                     return;
                 }
-                log.log(`[BOT] Found pushData, sending direct response, pushDataId=${pushDataItem.pushDataId}`);
+                logger.log(`[BOT] ✅ Found pushData, sending direct response`);
+                logger.log(`[BOT]   - pushDataId: ${pushDataItem.pushDataId}`);
                 const config = resolveXYConfig(cfg);
                 // 直接发送响应（final=true，不走 openclaw 流程）
                 await sendA2AResponse({
@@ -94,11 +90,11 @@ export async function handleXYMessage(params) {
                     append: false,
                     final: true,
                 });
-                log.log(`[BOT] Trigger response sent successfully`);
+                logger.log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
                 return; // 提前返回，不继续处理
             }
             catch (err) {
-                log.error(`[BOT] Failed to handle Trigger message:`, err);
+                logger.error(`[BOT] ❌ Failed to handle Trigger message:`, err);
                 return;
             }
         }
@@ -107,7 +103,9 @@ export async function handleXYMessage(params) {
         const isUpdate = hasActiveTask(parsed.sessionId);
         const skipReg = params.skipRegistration === true;
         if (isUpdate) {
-            log.log(`[BOT] STEER MODE - Second message detected, new taskId=${parsed.taskId}`);
+            logger.log(`[BOT] 🔄 STEER MODE - Second message detected (core will handle steer)`);
+            logger.log(`[BOT]   - Session: ${parsed.sessionId}`);
+            logger.log(`[BOT]   - New taskId: ${parsed.taskId}`);
         }
         // Steer injections skip taskId registration to avoid overwriting the active taskId
         if (!skipReg) {
@@ -115,30 +113,29 @@ export async function handleXYMessage(params) {
             // Extract and update push_id if present
             const pushId = extractPushId(parsed.parts);
             if (pushId) {
-                log.log(`[BOT] Extracted push_id from user message`);
+                logger.log(`[BOT] 📌 Extracted push_id from user message`);
                 configManager.updatePushId(parsed.sessionId, pushId);
                 // 持久化 pushId 到本地文件（异步，不阻塞主流程）
                 addPushId(pushId).catch((err) => {
-                    log.error(`[BOT] Failed to persist pushId:`, err);
+                    logger.error(`[BOT] Failed to persist pushId:`, err);
                 });
             }
             else {
-                log.log(`[BOT] No push_id found in message, using config default`);
+                logger.log(`[BOT] ℹ️  No push_id found in message, will use config default`);
             }
             // 保存 runtime 信息到 .xiaoyiruntime 文件（异步，不阻塞主流程）
             saveRuntimeInfo(webSocketSessionId || parsed.sessionId, // SESSION_ID (WebSocket 层级，如果没有则 fallback)
             parsed.sessionId, // CONVERSATION_ID (param 里的 sessionId)
             parsed.taskId // TASK_ID (param.id)
             ).catch((err) => {
-                log.error(`[BOT] Failed to save runtime info:`, err);
+                logger.error(`[BOT] Failed to save runtime info:`, err);
             });
         }
         // Extract deviceType if present (always parse — used in ctxPayload.MessageSid)
         const deviceType = extractDeviceType(parsed.parts);
         if (deviceType) {
-            log.log(`[BOT] Extracted deviceType: ${deviceType}`);
+            logger.log(`[BOT] 📱 Extracted deviceType from user message: ${deviceType}`);
         }
-        const runCrossTaskContext = extractRunCrossTaskContext(parsed.parts);
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -153,21 +150,19 @@ export async function handleXYMessage(params) {
                 id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
             },
         });
-        log.log(`[BOT] Resolved route, sessionKey=${route.sessionKey}`);
+        logger.log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
         // Steer injections skip session registration to avoid refCount leaks
         if (!skipReg) {
             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`);
+            logger.log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
             void sendStatusUpdate({
                 config,
                 sessionId: parsed.sessionId,
@@ -176,7 +171,7 @@ export async function handleXYMessage(params) {
                 text: "任务正在处理中，请稍候~",
                 state: "working",
             }).catch((err) => {
-                log.error(`Failed to send initial status update:`, err);
+                logger.error(`Failed to send initial status update:`, err);
             });
         }
         // Extract text and files from parts
@@ -188,18 +183,18 @@ export async function handleXYMessage(params) {
                 const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
                 if (selfEvolutionEnabled && shouldNudgeForSelfEvolutionKeyword(textForAgent)) {
                     const shouldNudge = toolCallNudgeManager.tryMarkKeywordNudge(route.sessionKey);
-                    log.log(`[SELF_EVOLUTION] Keyword check hit during inbound build: sessionKey=${route.sessionKey}, shouldNudge=${shouldNudge}`);
+                    logger.log(`[SELF_EVOLUTION] Keyword check hit during inbound build: sessionKey=${route.sessionKey}, shouldNudge=${shouldNudge}`);
                     if (shouldNudge) {
                         const augmented = appendSelfEvolutionKeywordNudge(textForAgent);
                         textForAgent = augmented.text;
                         if (augmented.appended) {
-                            log.log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
+                            logger.log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
                         }
                     }
                 }
             }
             catch (selfEvolutionError) {
-                log.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
+                logger.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
         // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
@@ -214,11 +209,9 @@ export async function handleXYMessage(params) {
             const steerDownloadedFiles = await downloadFilesFromParts(steerFileParts);
             const steerMediaPayload = buildXYMediaPayload(steerDownloadedFiles);
             if (steerFileParts.length > 0) {
-                log.log(`[BOT] Steer message with ${steerFileParts.length} file(s), enqueuing to streaming-signal queue`);
-            }
-            else {
-                log.log(`[BOT] Steer message — enqueuing to streaming-signal queue`);
+                logger.log(`[BOT] 📎 Steer message with files: ${steerFileParts.length} file(s)`);
             }
+            logger.log(`[BOT] 🔄 Steer message — enqueuing to streaming-signal queue`);
             await enqueueSteer({
                 sessionId: parsed.sessionId,
                 sessionKey: route.sessionKey,
@@ -230,7 +223,8 @@ export async function handleXYMessage(params) {
                 route,
                 deviceType,
             });
-            log.log(`[BOT] Steer queue completed`);
+            logger.log(`[BOT] ✅ Steer queue completed for session: ${parsed.sessionId}`);
+            logger.log(`xy: dispatch complete (session=${parsed.sessionId})`);
             return;
         }
         // ── First message (non-steer) path below ──────────────────────
@@ -242,7 +236,7 @@ export async function handleXYMessage(params) {
         if (!skipReg) {
             const fileParts = extractFileParts(parsed.parts);
             const downloadedFiles = await downloadFilesFromParts(fileParts);
-            log.log(`[BOT] Downloaded ${downloadedFiles.length} file(s)`);
+            logger.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
             mediaPayload = buildXYMediaPayload(downloadedFiles);
         }
         // Resolve envelope format options (following feishu pattern)
@@ -288,7 +282,8 @@ export async function handleXYMessage(params) {
         // 🔑 Streaming 信号已在上方创建（在文件下载之前）
         const steerState = { steered: false };
         // 🔑 创建dispatcher
-        log.log(`[BOT-DISPATCHER] Creating reply dispatcher`);
+        logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
+        logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
@@ -306,27 +301,26 @@ 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}`);
+        logger.log(`[BOT-DISPATCH] ⏳ withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
-                log.log(`[BOT] onSettled, steered=${steerState.steered}`);
+                logger.log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                logger.log(`[BOT]   - steered: ${steerState.steered}`);
                 // 🔑 When steered, skip heavy cleanup — the first message's dispatcher is still running
                 if (steerState.steered) {
-                    log.log(`[BOT] Steered dispatch settled, skipping cleanup`);
+                    logger.log(`[BOT] ✅ Steered dispatch settled (skipping cleanup)`);
                     return;
                 }
                 streamingSignals.delete(parsed.sessionId);
                 decrementTaskIdRef(parsed.sessionId);
                 unregisterSession(route.sessionKey);
-                log.log(`[BOT] Cleanup completed`);
+                logger.log(`[BOT] ✅ Cleanup completed`);
             },
             run: () => {
                 // 🔐 Use AsyncLocalStorage to provide session context to tools.
@@ -335,7 +329,12 @@ export async function handleXYMessage(params) {
                 // signal init complete to release the global dispatch gate
                 // for the next session.
                 const dispatchPromise = runWithSessionContext(sessionContext, async () => {
-                    log.log(`[BOT-DISPATCH] dispatchReplyFromConfig starting, body.length=${ctxPayload.Body?.length ?? 0}`);
+                    logger.log(`[BOT-DISPATCH] ⏳ dispatchReplyFromConfig starting...`);
+                    logger.log(`[BOT-DISPATCH]   - sessionKey: ${ctxPayload.SessionKey}`);
+                    logger.log(`[BOT-DISPATCH]   - provider: ${ctxPayload.Provider}`);
+                    logger.log(`[BOT-DISPATCH]   - surface: ${ctxPayload.Surface}`);
+                    logger.log(`[BOT-DISPATCH]   - from: ${ctxPayload.From}`);
+                    logger.log(`[BOT-DISPATCH]   - body length: ${ctxPayload.Body?.length ?? 0}`);
                     try {
                         const result = await core.channel.reply.dispatchReplyFromConfig({
                             ctx: ctxPayload,
@@ -343,11 +342,15 @@ export async function handleXYMessage(params) {
                             dispatcher,
                             replyOptions,
                         });
-                        log.log(`[BOT-DISPATCH] dispatchReplyFromConfig returned, result=${JSON.stringify(result)}`);
+                        logger.log(`[BOT-DISPATCH] ✅ dispatchReplyFromConfig returned`);
+                        logger.log(`[BOT-DISPATCH]   - result: ${JSON.stringify(result)}`);
                         return result;
                     }
                     catch (dispatchErr) {
-                        log.error(`[BOT-DISPATCH] dispatchReplyFromConfig threw: ${dispatchErr instanceof Error ? `${dispatchErr.name}: ${dispatchErr.message}` : String(dispatchErr)}`, dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : undefined);
+                        logger.error(`[BOT-DISPATCH] ❌ dispatchReplyFromConfig threw`);
+                        logger.error(`[BOT-DISPATCH]   - error name: ${dispatchErr instanceof Error ? dispatchErr.name : "unknown"}`);
+                        logger.error(`[BOT-DISPATCH]   - error message: ${String(dispatchErr)}`);
+                        logger.error(`[BOT-DISPATCH]   - error stack: ${dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : "N/A"}`);
                         throw dispatchErr;
                     }
                 });
@@ -356,23 +359,20 @@ export async function handleXYMessage(params) {
                 return dispatchPromise;
             },
         });
-        log.log(`[BOT] Dispatcher completed`);
+        logger.log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
+        logger.log(`xy: dispatch complete (session=${parsed.sessionId})`);
     }
     catch (err) {
         // ✅ Only log error, don't re-throw to prevent gateway restart
-        // Note: if error occurs before parseA2AMessage, `log` may not be defined yet
-        const errSessionId = message.params?.sessionId || "";
-        const errTaskId = message.params?.id || message.id || "";
-        const errLog = logger.withContext(errSessionId, errTaskId);
-        errLog.error("Failed to handle XY message:", err);
+        logger.error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
-        errLog.log(`[BOT] Error occurred, attempting cleanup`);
+        logger.log(`[BOT] ❌ Error occurred, attempting cleanup...`);
         // 🔑 错误时也要清理taskId和session
         try {
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
-                errLog.log(`[BOT] Cleaning up after error`);
+                logger.log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
                 // 清理 taskId
                 decrementTaskIdRef(sessionId);
                 // 清理 session
@@ -387,11 +387,11 @@ export async function handleXYMessage(params) {
                     },
                 });
                 unregisterSession(route.sessionKey);
-                errLog.log(`[BOT] Cleanup completed after error`);
+                logger.log(`[BOT] ✅ Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {
-            errLog.log(`[BOT] Cleanup failed:`, cleanupErr);
+            logger.log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
             // Ignore cleanup errors
         }
         // ❌ Don't re-throw: message processing error should not affect gateway stability
@@ -428,22 +428,20 @@ const steerQueues = _g.__xySteerQueues;
  * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
  */
 export function notifyModelStreaming(sessionId) {
-    const log = logger.withContext(sessionId, "");
     const signal = streamingSignals.get(sessionId);
     if (signal) {
         // 不删除 signal——后续 steer 需要靠它判断模型已在 streaming。
         // 清理由第一条消息的 onSettled 兜底。
         signal.notify();
-        log.log(`[STEER-QUEUE] Model streaming signal fired`);
+        logger.log(`[STEER-QUEUE] 📡 Model streaming signal fired for session=${sessionId}`);
     }
 }
 function createStreamingSignal(sessionId) {
-    const log = logger.withContext(sessionId, "");
     let resolve;
     const promise = new Promise(r => { resolve = r; });
     const signal = { promise, notify: resolve };
     streamingSignals.set(sessionId, signal);
-    log.log(`[STEER-QUEUE] Streaming signal created`);
+    logger.log(`[STEER-QUEUE] 🟢 Streaming signal created for session ${sessionId}`);
     return signal;
 }
 /**
@@ -453,14 +451,13 @@ function createStreamingSignal(sessionId) {
  */
 function enqueueSteer(params) {
     const { sessionId } = params;
-    const log = logger.withContext(sessionId, params.parsed.taskId);
     // 取出当前队列尾部（或 undefined），然后链上新的 Promise
     const prev = steerQueues.get(sessionId);
     const next = (prev ?? Promise.resolve()).then(() => dispatchSteerWhenReady(params));
     steerQueues.set(sessionId, next);
     // 链条结束后清理
     next.catch((err) => {
-        log.error(`[STEER-QUEUE] Steer chain failed: ${String(err)}`);
+        logger.error(`[STEER-QUEUE] ❌ Steer chain failed: ${String(err)}`);
     }).finally(() => {
         if (steerQueues.get(sessionId) === next) {
             steerQueues.delete(sessionId);
@@ -470,38 +467,37 @@ function enqueueSteer(params) {
 }
 async function dispatchSteerWhenReady(params) {
     const { sessionId, sessionKey, steerText } = params;
-    const log = logger.withContext(sessionId, params.parsed.taskId);
     // 1. 等待第一条消息开始 streaming
     //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
     //    轮询等待直到 signal 出现，最長等待 ~5 秒。
     let signal = streamingSignals.get(sessionId);
     if (!signal) {
-        log.log(`[STEER-QUEUE] Signal not yet created, polling`);
+        logger.log(`[STEER-QUEUE] ⏳ Signal not yet created, polling for session=${sessionId}`);
         for (let i = 0; i < 50; i++) {
             await new Promise(r => setTimeout(r, 100));
             signal = streamingSignals.get(sessionId);
             if (signal)
                 break;
             if (!hasActiveTask(sessionId)) {
-                log.log(`[STEER-QUEUE] First message completed while waiting, skip steer`);
+                logger.log(`[STEER-QUEUE] ℹ️ First message completed while waiting, skip steer`);
                 return;
             }
         }
     }
     if (signal) {
-        log.log(`[STEER-QUEUE] Waiting for streaming signal`);
+        logger.log(`[STEER-QUEUE] ⏳ Waiting for streaming signal, session=${sessionId}`);
         await signal.promise;
-        log.log(`[STEER-QUEUE] Streaming signal received`);
+        logger.log(`[STEER-QUEUE] ✅ Streaming signal received, session=${sessionId}`);
     }
     else {
         // 轮询超时且 hasActiveTask 仍为 true——说明第一条消息可能卡在异常路径，
         // 没有创建 signal。此时 dispatch 会与第一条消息的模型调用并发冲突，放弃。
-        log.log(`[STEER-QUEUE] Signal never appeared after polling, skip steer to avoid collision`);
+        logger.log(`[STEER-QUEUE] ⚠️ Signal never appeared after polling, skip steer to avoid collision`);
         return;
     }
     // 2. 第一条消息已结束 → 放弃
     if (!hasActiveTask(sessionId)) {
-        log.log(`[STEER-QUEUE] First message completed, skip steer`);
+        logger.log(`[STEER-QUEUE] ℹ️ First message completed, skip steer`);
         return;
     }
     // 3. 构建 dispatch 上下文并 dispatch /steer
@@ -563,11 +559,11 @@ async function dispatchSteerWhenReady(params) {
         agentId: params.route.accountId,
         deviceType: params.deviceType,
     };
-    log.log(`[STEER-QUEUE] Dispatching steer`);
+    logger.log(`[STEER-QUEUE] 🚀 Dispatching steer for session=${sessionId}`);
     await core.channel.reply.withReplyDispatcher({
         dispatcher,
         onSettled: () => {
-            log.log(`[STEER-QUEUE] Steer dispatch settled`);
+            logger.log(`[STEER-QUEUE] 🏁 Steer dispatch settled for session=${sessionId}`);
         },
         run: () => {
             return runWithSessionContext(sessionContext, async () => {
@@ -577,10 +573,10 @@ async function dispatchSteerWhenReady(params) {
                     dispatcher,
                     replyOptions,
                 });
-                log.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
+                logger.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
                 return result;
             });
         },
     });
-    log.log(`[STEER-QUEUE] Steer dispatch completed`);
+    logger.log(`[STEER-QUEUE] ✅ Steer dispatch completed for session=${sessionId}`);
 }

package/dist/src/channel.js

@@ -2,15 +2,9 @@ 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, registerSession } from "./tools/session-manager.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-";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -49,59 +43,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 ──────────────────────────────
-        // 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 [];
-        }
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
         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: {