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

package/dist/index.js

@@ -1,12 +1,14 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { xiaoyiProvider } from "./src/provider.js";
 import { xyPlugin } from "./src/channel.js";
-import { callCsplApi } from "./src/cspl/call-api.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 { setXYRuntime } from "./src/runtime.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 { tryInjectSteer } from "./src/steer-injector.js";
+import { setXYRuntime } from "./src/runtime.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";
@@ -23,17 +25,25 @@ function registerFullHooks(api) {
     const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
     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;
         }
-        logger.log(`[SENTINEL HOOK] after_tool_call triggered: toolName=${event.toolName}, sessionKey=${ctx.sessionKey ?? "none"}`);
         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,
@@ -48,11 +58,28 @@ function registerFullHooks(api) {
                 questionText.output[0].content = trimmed;
                 finalJson = JSON.stringify(questionText);
             }
-            const response = await callCsplApi(finalJson, api.config);
+            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}`);
+            logger.log(`[SENTINEL HOOK] Security result: status=${result.status}, toolName=${event.toolName}, elapsed=${csplElapsed}ms`);
             if (result.status === "REJECT") {
-                await tryInjectSteer(ctx.sessionKey, STEER_ABORT_MESSAGE);
+                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) {
@@ -83,6 +110,7 @@ export default definePluginEntry({
         }
         if (api.registrationMode === "full") {
             registerFullHooks(api);
+            registerCsplHook(api);
         }
     },
 });

package/dist/src/bot.d.ts

@@ -11,6 +11,12 @@ export interface HandleXYMessageParams {
     webSocketSessionId?: string;
     /** Called after dispatch init is complete (agentTools/wrapStreamFn done). */
     onInitComplete?: () => void;
+    /**
+     * When true, skip taskId/session registration. Used by tryInjectSteer to
+     * inject a steer message without overwriting the active taskId or leaking
+     * session refCount.
+     */
+    skipRegistration?: boolean;
 }
 /**
  * Handle an incoming A2A message.
@@ -18,3 +24,8 @@ export interface HandleXYMessageParams {
  * Runtime is expected to be validated before calling this function.
  */
 export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
+/**
+ * 由 provider.ts 在 wrapStreamFn 调用时触发。
+ * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
+ */
+export declare function notifyModelStreaming(sessionId: string): void;

package/dist/src/bot.js

@@ -1,5 +1,4 @@
 import { getXYRuntime } from "./runtime.js";
-import { setCachedContext } from "./steer-injector.js";
 import { createXYReplyDispatcher } from "./reply-dispatcher.js";
 import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId, extractDeviceType, extractTriggerData } from "./parser.js";
 import { downloadFilesFromParts } from "./file-download.js";
@@ -13,7 +12,8 @@ import { getPushDataById } from "./utils/pushdata-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { saveRuntimeInfo } from "./utils/runtime-manager.js";
 import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
-import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
+import { setCsplSteerContext } from "./cspl/steer-context.js";
+import { registerTaskId, decrementTaskIdRef, hasActiveTask, } from "./task-manager.js";
 import { logger } from "./utils/logger.js";
 /**
  * Handle an incoming A2A message.
@@ -22,8 +22,8 @@ import { logger } from "./utils/logger.js";
  */
 export async function handleXYMessage(params) {
     const { cfg, runtime, message, accountId, webSocketSessionId } = params;
-    // 每次收到消息时更新缓存，供 steer 注入使用
-    setCachedContext(cfg, runtime, accountId);
+    // 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)
     const core = getXYRuntime();
     try {
@@ -99,47 +99,43 @@ export async function handleXYMessage(params) {
             }
         }
         // ========================================
-        // 🔑 检测steer模式和是否是第二条消息
-        const isSteerMode = cfg.messages?.queue?.mode === "steer";
-        const isSecondMessage = isSteerMode && hasActiveTask(parsed.sessionId);
-        if (isSecondMessage) {
-            logger.log(`[BOT] 🔄 STEER MODE - Second message detected (will be follower)`);
+        // 🔑 注册taskId（检测是否是已有活跃任务的 session）
+        const isUpdate = hasActiveTask(parsed.sessionId);
+        const skipReg = params.skipRegistration === true;
+        if (isUpdate) {
+            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} (will replace current)`);
+            logger.log(`[BOT]   - New taskId: ${parsed.taskId}`);
         }
-        // 🔑 注册taskId（第二条消息会覆盖第一条的taskId）
-        const { isUpdate, refCount } = registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId, { incrementRef: true } // 增加引用计数
-        );
-        // 🔑 如果是第一条消息，锁定taskId防止被过早清理
-        if (!isUpdate) {
-            lockTaskId(parsed.sessionId);
-            logger.log(`[BOT] 🔒 Locked taskId for first message`);
-        }
-        // Extract and update push_id if present
-        const pushId = extractPushId(parsed.parts);
-        if (pushId) {
-            logger.log(`[BOT] 📌 Extracted push_id from user message`);
-            configManager.updatePushId(parsed.sessionId, pushId);
-            // 持久化 pushId 到本地文件（异步，不阻塞主流程）
-            addPushId(pushId).catch((err) => {
-                logger.error(`[BOT] Failed to persist pushId:`, err);
+        // Steer injections skip taskId registration to avoid overwriting the active taskId
+        if (!skipReg) {
+            registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId);
+            // Extract and update push_id if present
+            const pushId = extractPushId(parsed.parts);
+            if (pushId) {
+                logger.log(`[BOT] 📌 Extracted push_id from user message`);
+                configManager.updatePushId(parsed.sessionId, pushId);
+                // 持久化 pushId 到本地文件（异步，不阻塞主流程）
+                addPushId(pushId).catch((err) => {
+                    logger.error(`[BOT] Failed to persist pushId:`, err);
+                });
+            }
+            else {
+                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) => {
+                logger.error(`[BOT] Failed to save runtime info:`, err);
             });
         }
-        else {
-            logger.log(`[BOT] ℹ️  No push_id found in message, will use config default`);
-        }
-        // Extract deviceType if present (same level as push_id in systemVariables)
+        // Extract deviceType if present (always parse — used in ctxPayload.MessageSid)
         const deviceType = extractDeviceType(parsed.parts);
         if (deviceType) {
             logger.log(`[BOT] 📱 Extracted deviceType from user message: ${deviceType}`);
         }
-        // 保存 runtime 信息到 .xiaoyiruntime 文件（异步，不阻塞主流程）
-        saveRuntimeInfo(webSocketSessionId || parsed.sessionId, // SESSION_ID (WebSocket 层级，如果没有则 fallback)
-        parsed.sessionId, // CONVERSATION_ID (param 里的 sessionId)
-        parsed.taskId // TASK_ID (param.id)
-        ).catch((err) => {
-            logger.error(`[BOT] Failed to save runtime info:`, err);
-        });
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
         // ✅ Resolve agent route (following feishu pattern)
@@ -155,30 +151,34 @@ export async function handleXYMessage(params) {
             },
         });
         logger.log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
-        registerSession(route.sessionKey, {
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            agentId: route.accountId,
-            deviceType,
-        });
-        // 🔑 发送初始状态更新（第二条消息也要发，用新taskId）
-        logger.log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
-        void sendStatusUpdate({
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            text: isSecondMessage ? "新消息已接收，正在处理..." : "任务正在处理中，请稍候~",
-            state: "working",
-        }).catch((err) => {
-            logger.error(`Failed to send initial status update:`, err);
-        });
+        // Steer injections skip session registration to avoid refCount leaks
+        if (!skipReg) {
+            registerSession(route.sessionKey, {
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                agentId: route.accountId,
+                deviceType,
+            });
+            // 🔑 发送初始状态更新
+            logger.log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+            void sendStatusUpdate({
+                config,
+                sessionId: parsed.sessionId,
+                taskId: parsed.taskId,
+                messageId: parsed.messageId,
+                text: "任务正在处理中，请稍候~",
+                state: "working",
+            }).catch((err) => {
+                logger.error(`Failed to send initial status update:`, err);
+            });
+        }
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         let textForAgent = text || "";
-        if (route.sessionKey && textForAgent) {
+        // Self-evolution keyword nudge — only for real user messages, not steer injections
+        if (!skipReg && route.sessionKey && textForAgent) {
             try {
                 const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
                 if (selfEvolutionEnabled && shouldNudgeForSelfEvolutionKeyword(textForAgent)) {
@@ -197,11 +197,36 @@ export async function handleXYMessage(params) {
                 logger.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
-        const fileParts = extractFileParts(parsed.parts);
-        // Download files to local disk
-        const downloadedFiles = await downloadFilesFromParts(fileParts);
-        logger.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
-        const mediaPayload = buildXYMediaPayload(downloadedFiles);
+        // 🔑 Steer消息: 跳过旧路径直接进入 streaming-signal 队列
+        // /steer 前缀由 dispatchSteerWhenReady 内部添加
+        if (isUpdate) {
+            logger.log(`[BOT] 🔄 Steer message — enqueuing to streaming-signal queue`);
+            await enqueueSteer({
+                sessionId: parsed.sessionId,
+                sessionKey: route.sessionKey,
+                steerText: textForAgent, // 原始文本，不带 /steer 前缀
+                cfg,
+                runtime,
+                parsed,
+                route,
+                deviceType,
+            });
+            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 ──────────────────────
+        // 🔑 立即创建 streaming 信号——必须在文件下载等耗时操作之前，
+        // 否则 steer 消息的 dispatchSteerWhenReady 会找不到信号而跳过等待。
+        createStreamingSignal(parsed.sessionId);
+        // File download — only for real user messages, steer injections have no files
+        let mediaPayload = {};
+        if (!skipReg) {
+            const fileParts = extractFileParts(parsed.parts);
+            const downloadedFiles = await downloadFilesFromParts(fileParts);
+            logger.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
+            mediaPayload = buildXYMediaPayload(downloadedFiles);
+        }
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // Build message body with speaker prefix (following feishu pattern)
@@ -242,7 +267,9 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // 🔑 创建dispatcher（dispatcher会自动使用动态taskId）
+        // 🔑 Streaming 信号已在上方创建（在文件下载之前）
+        const steerState = { steered: false };
+        // 🔑 创建dispatcher
         logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
         logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
@@ -252,13 +279,11 @@ export async function handleXYMessage(params) {
             taskId: parsed.taskId,
             messageId: parsed.messageId,
             accountId: route.accountId,
-            isSteerFollower: isSecondMessage, // 🔑 标记第二条消息
+            steerState,
         });
-        // 🔑 只有第一条消息启动状态定时器
-        // 第二条消息会很快返回，不需要定时器
-        if (!isSecondMessage) {
+        // Steer injections don't need status intervals
+        if (!skipReg) {
             startStatusInterval();
-            logger.log(`[BOT-DISPATCHER] ✅ Status interval started for first message`);
         }
         // Build session context for AsyncLocalStorage
         const sessionContext = {
@@ -274,15 +299,13 @@ export async function handleXYMessage(params) {
             dispatcher,
             onSettled: () => {
                 logger.log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                logger.log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
-                // 🔑 减少引用计数
-                decrementTaskIdRef(parsed.sessionId);
-                // 🔑 如果是第一条消息完成，解锁
-                if (!isSecondMessage) {
-                    unlockTaskId(parsed.sessionId);
-                    logger.log(`[BOT] 🔓 Unlocked taskId (first message completed)`);
+                logger.log(`[BOT]   - steered: ${steerState.steered}`);
+                // 🔑 When steered, skip heavy cleanup — the first message's dispatcher is still running
+                if (steerState.steered) {
+                    logger.log(`[BOT] ✅ Steered dispatch settled (skipping cleanup)`);
+                    return;
                 }
-                // 减少session引用计数
+                decrementTaskIdRef(parsed.sessionId);
                 unregisterSession(route.sessionKey);
                 logger.log(`[BOT] ✅ Cleanup completed`);
             },
@@ -339,7 +362,6 @@ export async function handleXYMessage(params) {
                 logger.log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
                 // 清理 taskId
                 decrementTaskIdRef(sessionId);
-                unlockTaskId(sessionId);
                 // 清理 session
                 const core = getXYRuntime();
                 const route = core.channel.routing.resolveAgentRoute({
@@ -379,3 +401,158 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
+// Use globalThis to survive module deduplication — provider.ts may load a
+// different copy of bot.ts, so a plain module-level Map would be two objects.
+const _g = globalThis;
+if (!_g.__xyStreamingSignals)
+    _g.__xyStreamingSignals = new Map();
+if (!_g.__xySteerQueues)
+    _g.__xySteerQueues = new Map();
+const streamingSignals = _g.__xyStreamingSignals;
+const steerQueues = _g.__xySteerQueues;
+/**
+ * 由 provider.ts 在 wrapStreamFn 调用时触发。
+ * 这是模型 API 被调用的精确时刻，此时 isStreaming 一定为 true。
+ */
+export function notifyModelStreaming(sessionId) {
+    const signal = streamingSignals.get(sessionId);
+    if (signal) {
+        streamingSignals.delete(sessionId);
+        signal.notify();
+        logger.log(`[STEER-QUEUE] 📡 Model streaming signal fired for session=${sessionId}`);
+    }
+}
+function createStreamingSignal(sessionId) {
+    let resolve;
+    const promise = new Promise(r => { resolve = r; });
+    const signal = { promise, notify: resolve };
+    streamingSignals.set(sessionId, signal);
+    logger.log(`[STEER-QUEUE] 🟢 Streaming signal created for session ${sessionId}`);
+    return signal;
+}
+/**
+ * 将 steer 消息放入 per-session 串行队列。
+ * 等待第一条消息的 streaming 信号（deliver 首次触发），然后 dispatch。
+ * 多个 steer 按到达顺序串行处理，无需重试。
+ */
+function enqueueSteer(params) {
+    const { sessionId } = params;
+    // 取出当前队列尾部（或 undefined），然后链上新的 Promise
+    const prev = steerQueues.get(sessionId);
+    const next = (prev ?? Promise.resolve()).then(() => dispatchSteerWhenReady(params));
+    steerQueues.set(sessionId, next);
+    // 链条结束后清理
+    next.catch(() => { }).finally(() => {
+        if (steerQueues.get(sessionId) === next) {
+            steerQueues.delete(sessionId);
+        }
+    });
+    return next;
+}
+async function dispatchSteerWhenReady(params) {
+    const { sessionId, sessionKey, steerText } = params;
+    // 1. 等待第一条消息开始 streaming
+    //    signal 可能尚未创建（第一条消息还在文件下载等耗时操作中），
+    //    轮询等待直到 signal 出现，最長等待 ~5 秒。
+    let signal = streamingSignals.get(sessionId);
+    if (!signal) {
+        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)) {
+                logger.log(`[STEER-QUEUE] ℹ️ First message completed while waiting, skip steer`);
+                return;
+            }
+        }
+    }
+    if (signal) {
+        logger.log(`[STEER-QUEUE] ⏳ Waiting for streaming signal, session=${sessionId}`);
+        await signal.promise;
+        streamingSignals.delete(sessionId);
+        logger.log(`[STEER-QUEUE] ✅ Streaming signal received, session=${sessionId}`);
+    }
+    else {
+        logger.log(`[STEER-QUEUE] ⚠️ Signal never appeared, proceeding without wait`);
+    }
+    // 2. 第一条消息已结束 → 放弃
+    if (!hasActiveTask(sessionId)) {
+        logger.log(`[STEER-QUEUE] ℹ️ First message completed, skip steer`);
+        return;
+    }
+    // 3. 构建 dispatch 上下文并 dispatch /steer
+    const core = getXYRuntime();
+    const speaker = sessionId;
+    const steerCommand = `/steer ${steerText}`;
+    const messageBody = `${speaker}: ${steerCommand}`;
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
+    const body = core.channel.reply.formatAgentEnvelope({
+        channel: "xiaoyi-channel",
+        from: speaker,
+        timestamp: new Date(),
+        envelope: envelopeOptions,
+        body: messageBody,
+    });
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+        Body: body,
+        RawBody: steerCommand,
+        CommandBody: steerCommand,
+        From: sessionId,
+        To: sessionId,
+        SessionKey: params.route.sessionKey,
+        AccountId: params.route.accountId,
+        ChatType: "direct",
+        GroupSubject: undefined,
+        SenderName: sessionId,
+        SenderId: sessionId,
+        Provider: "xiaoyi-channel",
+        Surface: "xiaoyi-channel",
+        MessageSid: `${params.parsed.taskId}_${params.deviceType}`,
+        Timestamp: Date.now(),
+        WasMentioned: false,
+        CommandAuthorized: true,
+        OriginatingChannel: "xiaoyi-channel",
+        OriginatingTo: sessionId,
+        ReplyToBody: undefined,
+    });
+    const steerState = { steered: true };
+    const { dispatcher, replyOptions } = createXYReplyDispatcher({
+        cfg: params.cfg,
+        runtime: params.runtime,
+        sessionId,
+        taskId: params.parsed.taskId,
+        messageId: params.parsed.messageId,
+        accountId: params.route.accountId,
+        steerState,
+    });
+    const sessionContext = {
+        config: resolveXYConfig(params.cfg),
+        sessionId,
+        taskId: params.parsed.taskId,
+        messageId: params.parsed.messageId,
+        agentId: params.route.accountId,
+        deviceType: params.deviceType,
+    };
+    logger.log(`[STEER-QUEUE] 🚀 Dispatching steer for session=${sessionId}`);
+    await core.channel.reply.withReplyDispatcher({
+        dispatcher,
+        onSettled: () => {
+            logger.log(`[STEER-QUEUE] 🏁 Steer dispatch settled for session=${sessionId}`);
+        },
+        run: () => {
+            return runWithSessionContext(sessionContext, async () => {
+                const result = await core.channel.reply.dispatchReplyFromConfig({
+                    ctx: ctxPayload,
+                    cfg: params.cfg,
+                    dispatcher,
+                    replyOptions,
+                });
+                logger.log(`[STEER-QUEUE] dispatch result: ${JSON.stringify(result)}`);
+                return result;
+            });
+        },
+    });
+    logger.log(`[STEER-QUEUE] ✅ Steer dispatch completed for session=${sessionId}`);
+}

package/dist/src/cspl/call-api.d.ts

@@ -1,3 +1,9 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import { type CsplConfig } from "./config.js";
 import type { ApiResponse } from "./constants.js";
 export declare function callCsplApi(questionText: string, cfg: ClawdbotConfig): Promise<ApiResponse>;
+/**
+ * Call CSPL API with a pre-resolved CsplConfig.
+ * Used by after_tool_call hook which has session context but not ClawdbotConfig.
+ */
+export declare function callCsplApiWithConfig(questionText: string, config: CsplConfig): Promise<ApiResponse>;

package/dist/src/cspl/call-api.js

@@ -1,4 +1,5 @@
 // SENTINEL HOOK API 请求模块
+import http from "node:http";
 import https from "node:https";
 import { URL } from "node:url";
 import { randomBytes } from "node:crypto";
@@ -43,18 +44,12 @@ function parseResponse(data) {
     }
     return json;
 }
-export async function callCsplApi(questionText, cfg) {
-    const config = getCsplConfig(cfg);
-    const headers = buildHeaders(config);
-    const payload = {
-        questionText,
-        textSource: config.textSource,
-        action: config.action,
-        extra: JSON.stringify({ userId: config.uid }),
-    };
+function doApiRequest(url, headers, payload, timeout) {
+    const isHttp = url.startsWith("http://");
+    const module = isHttp ? http : https;
+    const options = buildRequestOptions(url, headers, timeout);
     return new Promise((resolve, reject) => {
-        const options = buildRequestOptions(config.api.url, headers, config.api.timeout);
-        const req = https.request(options, (res) => {
+        const req = module.request(options, (res) => {
             if (res.statusCode && res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
                 reject(new Error(`[SENTINEL HOOK] HTTP error: ${res.statusCode}`));
                 return;
@@ -66,7 +61,7 @@ export async function callCsplApi(questionText, cfg) {
             res.on("end", () => {
                 try {
                     const result = parseResponse(data);
-                    logger.log(`[SENTINEL HOOK] ✅ 请求成功`);
+                    logger.log(`[SENTINEL HOOK] ✅ 请求成功, securityResult=${result?.data?.securityResult ?? "N/A"}`);
                     resolve(result);
                 }
                 catch (e) {
@@ -80,7 +75,7 @@ export async function callCsplApi(questionText, cfg) {
             reject(error);
         });
         req.on("timeout", () => {
-            logger.error(`[SENTINEL HOOK] ⏰ 请求超时 (${config.api.timeout}ms)`);
+            logger.error(`[SENTINEL HOOK] ⏰ 请求超时 (${timeout}ms)`);
             req.destroy();
             reject(new Error("[SENTINEL HOOK] Request timeout"));
         });
@@ -88,3 +83,28 @@ export async function callCsplApi(questionText, cfg) {
         req.end();
     });
 }
+export async function callCsplApi(questionText, cfg) {
+    const config = getCsplConfig(cfg);
+    const headers = buildHeaders(config);
+    const payload = {
+        questionText,
+        textSource: config.textSource,
+        action: config.action,
+        extra: JSON.stringify({ userId: config.uid }),
+    };
+    return doApiRequest(config.api.url, headers, payload, config.api.timeout);
+}
+/**
+ * Call CSPL API with a pre-resolved CsplConfig.
+ * Used by after_tool_call hook which has session context but not ClawdbotConfig.
+ */
+export async function callCsplApiWithConfig(questionText, config) {
+    const headers = buildHeaders(config);
+    const payload = {
+        questionText,
+        textSource: config.textSource,
+        action: config.action,
+        extra: JSON.stringify({ userId: config.uid }),
+    };
+    return doApiRequest(config.api.url, headers, payload, config.api.timeout);
+}

package/dist/src/cspl/config.d.ts

@@ -1,4 +1,5 @@
 import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { XYChannelConfig } from "../types.js";
 export interface ApiConfig {
     url: string;
     timeout: number;
@@ -15,5 +16,14 @@ export interface CsplConfig {
 /**
  * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
  * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
+ *
+ * Accepts either ClawdbotConfig (legacy after_tool_call path) or
+ * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
+ * after the first successful call so subsequent calls can omit the arg.
  */
-export declare function getCsplConfig(cfg: ClawdbotConfig): CsplConfig;
+export declare function getCsplConfig(cfg?: ClawdbotConfig): CsplConfig;
+/**
+ * Initialize CSPL config from an already-resolved XYChannelConfig.
+ * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
+ */
+export declare function initCsplConfigFromXYConfig(xyConfig: XYChannelConfig): CsplConfig;

package/dist/src/cspl/config.js

@@ -27,10 +27,17 @@ function readServiceUrl() {
 /**
  * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
  * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
+ *
+ * Accepts either ClawdbotConfig (legacy after_tool_call path) or
+ * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
+ * after the first successful call so subsequent calls can omit the arg.
  */
 export function getCsplConfig(cfg) {
     if (cachedConfig)
         return cachedConfig;
+    if (!cfg) {
+        throw new Error("[SENTINEL HOOK] CSPL config not initialized: pass ClawdbotConfig on first call");
+    }
     const xyConfig = resolveXYConfig(cfg);
     const serviceUrl = readServiceUrl();
     cachedConfig = {
@@ -48,3 +55,26 @@ export function getCsplConfig(cfg) {
     logger.log("[SENTINEL HOOK] Config loaded (uid/apiKey from XYChannelConfig)");
     return cachedConfig;
 }
+/**
+ * Initialize CSPL config from an already-resolved XYChannelConfig.
+ * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
+ */
+export function initCsplConfigFromXYConfig(xyConfig) {
+    if (cachedConfig)
+        return cachedConfig;
+    const serviceUrl = readServiceUrl();
+    cachedConfig = {
+        api: {
+            url: `${serviceUrl}${API_URL_SUFFIX}`,
+            timeout: CSPL_STATIC_CONFIG.api.timeout,
+        },
+        uid: xyConfig.uid,
+        apiKey: xyConfig.apiKey,
+        skillId: CSPL_STATIC_CONFIG.skillId,
+        requestFrom: CSPL_STATIC_CONFIG.requestFrom,
+        textSource: CSPL_STATIC_CONFIG.textSource,
+        action: CSPL_STATIC_CONFIG.action,
+    };
+    logger.log("[SENTINEL HOOK] Config loaded via XYChannelConfig");
+    return cachedConfig;
+}

package/dist/src/cspl/middleware.d.ts

@@ -0,0 +1,8 @@
+import type { AgentToolResultMiddleware } from "openclaw/plugin-sdk/agent-harness-runtime";
+/**
+ * Create the CSPL AgentToolResultMiddleware.
+ *
+ * Gets XYChannelConfig from session context (via sessionKey) to initialize
+ * the CSPL API config on first call, then caches it for subsequent calls.
+ */
+export declare function createCsplMiddleware(): AgentToolResultMiddleware;

package/dist/src/cspl/middleware.js

@@ -0,0 +1,90 @@
+// CSPL AgentToolResultMiddleware
+// Replaces the after_tool_call hook with a middleware that intercepts tool results
+// BEFORE they reach the LLM, enabling true security interruption.
+import { callCsplApiWithConfig } from "./call-api.js";
+import { getCsplConfig, initCsplConfigFromXYConfig } from "./config.js";
+import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./constants.js";
+import { parseSecurityResult, processText, validateAndTruncateText, } from "./utils.js";
+import { getSessionContext } from "../tools/session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Extract text content from an OpenClawAgentToolResult.
+ */
+function extractMiddlewareResultText(event) {
+    const result = event.result;
+    if (!result?.content || !Array.isArray(result.content)) {
+        return "";
+    }
+    const texts = [];
+    // Special handling for web_fetch: text is in details.text
+    if (event.toolName === "web_fetch" && result.details?.text) {
+        texts.push(String(result.details.text));
+    }
+    else {
+        for (const item of result.content) {
+            if (item?.type === "text" && typeof item.text === "string") {
+                texts.push(item.text);
+            }
+        }
+    }
+    return texts.length > 0 ? texts.join("; ") : "";
+}
+/**
+ * Create the CSPL AgentToolResultMiddleware.
+ *
+ * Gets XYChannelConfig from session context (via sessionKey) to initialize
+ * the CSPL API config on first call, then caches it for subsequent calls.
+ */
+export function createCsplMiddleware() {
+    return async (event, ctx) => {
+        if (!ALLOWED_TOOLS.includes(event.toolName)) {
+            return;
+        }
+        try {
+            const resultText = extractMiddlewareResultText(event);
+            const resultLength = resultText.length;
+            if (resultLength <= MIN_TEXT_LENGTH || resultLength > MAX_TOTAL_LENGTH) {
+                return;
+            }
+            logger.log(`[CSPL MIDDLEWARE] Scanning tool result: toolName=${event.toolName}, textLength=${resultLength}`);
+            // Build CSPL request payload
+            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);
+            }
+            // Get CSPL config (cached after first call)
+            // Try session context first (XYChannelConfig), then fall back to cached config
+            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(`[CSPL MIDDLEWARE] Security result: status=${result.status}, toolName=${event.toolName}, elapsed=${csplElapsed}ms`);
+            if (result.status === "REJECT") {
+                logger.log(`[CSPL MIDDLEWARE] REJECT - replacing tool result with security message`);
+                return {
+                    result: {
+                        content: [{ type: "text", text: STEER_ABORT_MESSAGE }],
+                        details: {},
+                    },
+                };
+            }
+        }
+        catch (err) {
+            logger.error(`[CSPL MIDDLEWARE] Error: ${err}`);
+        }
+    };
+}

package/dist/src/cspl/steer-context.d.ts

@@ -0,0 +1,21 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
+export declare function setCsplSteerContext(cfg: ClawdbotConfig, runtime: RuntimeEnv): void;
+/** Parameters for steer message injection. */
+export interface SteerInjectionParams {
+    sessionId: string;
+    taskId: string;
+    message: string;
+    /** Human-readable source label for logging (e.g. "cspl", "self-evolution"). */
+    source: string;
+}
+/**
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
+ */
+export declare function tryInjectSteer(params: SteerInjectionParams): Promise<boolean>;

package/dist/src/cspl/steer-context.js

@@ -0,0 +1,78 @@
+import { handleXYMessage } from "../bot.js";
+import { logger } from "../utils/logger.js";
+import { randomUUID } from "node:crypto";
+// Use globalThis to ensure a single cache across all module copies.
+// The xy_channel plugin may be loaded by openclaw from different module
+// resolution paths, causing steer-context.ts to be instantiated multiple
+// times. globalThis guarantees all copies share the same cfg/runtime.
+const _g = globalThis;
+if (!_g.__xySteerCachedCfg) {
+    _g.__xySteerCachedCfg = null;
+}
+if (!_g.__xySteerCachedRuntime) {
+    _g.__xySteerCachedRuntime = null;
+}
+function getCachedCfg() {
+    return _g.__xySteerCachedCfg;
+}
+function setCachedCfg(cfg) {
+    _g.__xySteerCachedCfg = cfg;
+}
+function getCachedRuntime() {
+    return _g.__xySteerCachedRuntime;
+}
+function setCachedRuntime(runtime) {
+    _g.__xySteerCachedRuntime = runtime;
+}
+/** Called from handleXYMessage on every inbound A2A message to keep cfg/runtime fresh. */
+export function setCsplSteerContext(cfg, runtime) {
+    setCachedCfg(cfg);
+    setCachedRuntime(runtime);
+}
+/**
+ * Inject a steer message into an active session by constructing a synthetic
+ * A2A tasks/send message and dispatching it through handleXYMessage.
+ *
+ * Uses skipRegistration so the steer message doesn't register a new taskId,
+ * increment session refCount, or send extra status updates.
+ *
+ * Returns true if the injection was dispatched successfully.
+ */
+export async function tryInjectSteer(params) {
+    const { sessionId, taskId, message, source } = params;
+    const cfg = getCachedCfg();
+    const runtime = getCachedRuntime();
+    if (!cfg || !runtime) {
+        logger.error(`[STEER:${source}] No cached cfg/runtime, cannot inject steer`);
+        return false;
+    }
+    const syntheticMessage = {
+        jsonrpc: "2.0",
+        method: "tasks/send",
+        id: `steer-${source}-${randomUUID()}`,
+        params: {
+            sessionId,
+            id: taskId,
+            agentLoginSessionId: "",
+            message: {
+                role: "user",
+                parts: [{ kind: "text", text: message }],
+            },
+        },
+    };
+    logger.log(`[STEER:${source}] Injecting steer for sessionId=${sessionId}, taskId=${taskId}`);
+    try {
+        await handleXYMessage({
+            cfg,
+            runtime,
+            message: syntheticMessage,
+            accountId: "default",
+            skipRegistration: true,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[STEER:${source}] Failed to inject steer: ${err}`);
+        return false;
+    }
+}

package/dist/src/provider.js

@@ -11,6 +11,7 @@ import { createHash } from "crypto";
 import { logger } from "./utils/logger.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
+import { notifyModelStreaming } from "./bot.js";
 // ── Retry config ──────────────────────────────────────────────
 const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
 const MAX_RETRY_ATTEMPTS = 5;
@@ -536,6 +537,11 @@ export const xiaoyiProvider = {
             }
             // 记录输入
             logger.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);
+            // 🔑 通知 steer 队列：模型 API 已被调用，此时 isStreaming 一定为 true
+            const sessionCtx = getCurrentSessionContext();
+            if (sessionCtx?.sessionId) {
+                notifyModelStreaming(sessionCtx.sessionId);
+            }
             if (context.systemPrompt) {
                 logger.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }

package/dist/src/reply-dispatcher.d.ts

@@ -6,7 +6,9 @@ export interface CreateXYReplyDispatcherParams {
     taskId: string;
     messageId: string;
     accountId: string;
-    isSteerFollower?: boolean;
+    steerState: {
+        steered: boolean;
+    };
 }
 /**
  * 清理 /tmp/xy_channel 目录中超过 24 小时的旧文件

package/dist/src/reply-dispatcher.js

@@ -45,10 +45,9 @@ export async function cleanupStaleTempFiles(tempDir = "/tmp/xy_channel") {
  * Runtime is expected to be validated before calling this function.
  */
 export function createXYReplyDispatcher(params) {
-    const { cfg, runtime, sessionId, taskId, messageId, accountId, isSteerFollower } = params;
+    const { cfg, runtime, sessionId, taskId, messageId, accountId, steerState } = params;
     logger.log(`[DISPATCHER-CREATE] ******* Creating dispatcher *******`);
     logger.log(`[DISPATCHER-CREATE]   - taskId: ${taskId}`);
-    logger.log(`[DISPATCHER-CREATE]   - isSteerFollower: ${isSteerFollower ?? false}`);
     // 初始taskId和messageId（作为fallback）
     const initialTaskId = taskId;
     const initialMessageId = messageId;
@@ -111,9 +110,14 @@ export function createXYReplyDispatcher(params) {
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
         onReplyStart: () => {
             const currentTaskId = getActiveTaskId();
-            logger.log(`[REPLY START] Reply started for session ${sessionId}, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
+            logger.log(`[REPLY START] Reply started for session ${sessionId}, taskId=${currentTaskId}, steered=${steerState.steered}`);
         },
         deliver: async (payload, info) => {
+            // 🔑 steered dispatch不发送内容（让主dispatcher处理）
+            if (steerState.steered) {
+                logger.log(`[DELIVER] Steered dispatch - skipping deliver, info.kind=${info?.kind}`);
+                return;
+            }
             const text = payload.text ?? "";
             const currentTaskId = getActiveTaskId();
             const currentMessageId = getActiveMessageId();
@@ -143,9 +147,9 @@ export function createXYReplyDispatcher(params) {
         onError: async (err, info) => {
             runtime.error?.(`xy: ${info.kind} reply failed: ${String(err)}`);
             stopStatusInterval();
-            // 🔑 steer follower不发送错误状态（让主dispatcher处理）
-            if (isSteerFollower) {
-                logger.log(`[ON_ERROR] Steer follower - skipping error response`);
+            // 🔑 steered dispatcher不发送错误状态（让主dispatcher处理）
+            if (steerState.steered) {
+                logger.log(`[ON_ERROR] Steered dispatch - skipping error response`);
                 return;
             }
             if (!hasSentResponse) {
@@ -172,17 +176,16 @@ export function createXYReplyDispatcher(params) {
             logger.log(`[ON_IDLE] Reply idle`);
             logger.log(`[ON_IDLE]   - sessionId: ${sessionId}`);
             logger.log(`[ON_IDLE]   - taskId: ${currentTaskId}`);
-            logger.log(`[ON_IDLE]   - isSteerFollower: ${isSteerFollower}`);
+            logger.log(`[ON_IDLE]   - steered: ${steerState.steered}`);
             logger.log(`[ON_IDLE]   - hasSentResponse: ${hasSentResponse}`);
             logger.log(`[ON_IDLE]   - finalSent: ${finalSent}`);
-            // 🔑 核心改动：steer follower不发送final响应
-            if (isSteerFollower) {
-                logger.log(`[ON_IDLE] Steer follower - skipping final response`);
-                logger.log(`[ON_IDLE]   - Message queued successfully, waiting for primary dispatcher`);
+            // 🔑 steered dispatch不发送final响应（核心已注入到活跃 Pi run）
+            if (steerState.steered) {
+                logger.log(`[ON_IDLE] Steered dispatch - skipping final response`);
                 stopStatusInterval();
                 return; // ← 直接返回，不发送任何东西！
             }
-            // 正常模式（或steer的第一条消息）
+            // 正常模式（或未被steer的dispatch）
             if (hasSentResponse && !finalSent) {
                 logger.log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
@@ -214,7 +217,7 @@ export function createXYReplyDispatcher(params) {
                 }
             }
             else {
-                // 正常失败场景（非steer follower）
+                // 正常失败场景（非steered）
                 logger.log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
                 try {
                     await sendStatusUpdate({
@@ -248,7 +251,7 @@ export function createXYReplyDispatcher(params) {
         },
         onCleanup: () => {
             const currentTaskId = getActiveTaskId();
-            logger.log(`[ON_CLEANUP] Reply cleanup, taskId=${currentTaskId}, isSteerFollower=${isSteerFollower}`);
+            logger.log(`[ON_CLEANUP] Reply cleanup, taskId=${currentTaskId}, steered=${steerState.steered}`);
         },
     });
     return {
@@ -257,8 +260,8 @@ export function createXYReplyDispatcher(params) {
             ...replyOptions,
             onModelSelected: prefixContext.onModelSelected,
             onToolStart: async ({ name, phase }) => {
-                // 🔑 steer follower不发送tool状态（让主dispatcher处理）
-                if (isSteerFollower) {
+                // 🔑 steered dispatch不发送tool状态（让主dispatcher处理）
+                if (steerState.steered) {
                     return;
                 }
                 const currentTaskId = getActiveTaskId();
@@ -289,8 +292,8 @@ export function createXYReplyDispatcher(params) {
                 }
             },
             onToolResult: async (payload) => {
-                // 🔑 steer follower不发送tool结果（让主dispatcher处理）
-                if (isSteerFollower) {
+                // 🔑 steered dispatch不发送tool结果（让主dispatcher处理）
+                if (steerState.steered) {
                     return;
                 }
                 const currentTaskId = getActiveTaskId();
@@ -317,8 +320,8 @@ export function createXYReplyDispatcher(params) {
                 }
             },
             onReasoningStream: async (payload) => {
-                // 🔑 steer follower不发送reasoning stream
-                if (isSteerFollower) {
+                // 🔑 steered dispatch不发送reasoning stream
+                if (steerState.steered) {
                     return;
                 }
                 const text = payload.text ?? "";
@@ -327,8 +330,8 @@ export function createXYReplyDispatcher(params) {
                 // 如果需要可以启用
             },
             onPartialReply: async (payload) => {
-                // 🔑 steer follower不发送partial reply（让主dispatcher处理）
-                if (isSteerFollower) {
+                // 🔑 steered dispatch不发送partial reply（让主dispatcher处理）
+                if (steerState.steered) {
                     return;
                 }
                 const currentTaskId = getActiveTaskId();

package/dist/src/task-manager.d.ts

@@ -2,36 +2,17 @@ interface TaskIdBinding {
     sessionId: string;
     currentTaskId: string;
     currentMessageId: string;
-    refCount: number;
     updatedAt: number;
-    locked: boolean;
 }
 /**
- * 注册或更新session的活跃taskId
- * 返回是否是更新（用于判断是否是第二条消息）
+ * 注册或更新session的活跃taskId。
+ * Returns true if this was an update (session already had an active task).
  */
-export declare function registerTaskId(sessionId: string, taskId: string, messageId: string, options?: {
-    incrementRef?: boolean;
-}): {
-    isUpdate: boolean;
-    refCount: number;
-};
+export declare function registerTaskId(sessionId: string, taskId: string, messageId: string): boolean;
 /**
- * 增加引用计数（消息开始处理时调用）
- */
-export declare function incrementTaskIdRef(sessionId: string): void;
-/**
- * 减少引用计数，当refCount=0时才真正清理
+ * 移除session的活跃taskId（消息处理完成时调用）。
  */
 export declare function decrementTaskIdRef(sessionId: string): void;
-/**
- * 锁定taskId，防止被清理（第一个消息使用）
- */
-export declare function lockTaskId(sessionId: string): void;
-/**
- * 解锁taskId（第一个消息完成时使用）
- */
-export declare function unlockTaskId(sessionId: string): void;
 /**
  * 获取session的当前活跃taskId
  */
@@ -44,10 +25,6 @@ export declare function getCurrentMessageId(sessionId: string): string | null;
  * 检查session是否有活跃的taskId
  */
 export declare function hasActiveTask(sessionId: string): boolean;
-/**
- * 获取完整的binding信息（用于调试）
- */
-export declare function getTaskIdBinding(sessionId: string): TaskIdBinding | null;
 /**
  * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
  */

package/dist/src/task-manager.js

@@ -1,9 +1,9 @@
 // TaskId Manager - 管理session级别的活跃taskId
-// 支持动态切换taskId，用于steer模式下的消息插队
+// 用于 monitor.ts 检测活跃任务（决定是否并发执行steer消息）
 import { logger } from "./utils/logger.js";
 /**
  * Session到活跃TaskId的映射
- * Key: sessionId (注意：这里用sessionId，不是sessionKey)
+ * Key: sessionId
  * Value: TaskIdBinding
  * Uses globalThis to ensure a single Map across all module copies.
  */
@@ -13,98 +13,39 @@ if (!_g.__xyActiveTaskIds) {
 }
 const activeTaskIds = _g.__xyActiveTaskIds;
 /**
- * 注册或更新session的活跃taskId
- * 返回是否是更新（用于判断是否是第二条消息）
+ * 注册或更新session的活跃taskId。
+ * Returns true if this was an update (session already had an active task).
  */
-export function registerTaskId(sessionId, taskId, messageId, options) {
+export function registerTaskId(sessionId, taskId, messageId) {
     logger.log(`[TASK_MANAGER] 📝 Registering/Updating taskId for session: ${sessionId}`);
-    logger.log(`[TASK_MANAGER]   - New taskId: ${taskId}`);
-    logger.log(`[TASK_MANAGER]   - New messageId: ${messageId}`);
-    logger.log(`[TASK_MANAGER]   - incrementRef: ${options?.incrementRef ?? false}`);
+    logger.log(`[TASK_MANAGER]   - taskId: ${taskId}`);
     const existing = activeTaskIds.get(sessionId);
     if (existing) {
         logger.log(`[TASK_MANAGER]   - Previous taskId: ${existing.currentTaskId}`);
-        logger.log(`[TASK_MANAGER]   - Previous refCount: ${existing.refCount}`);
-        logger.log(`[TASK_MANAGER]   - 🔄 Switching taskId (steer mode detected)`);
-        // 更新taskId，但保持引用计数
+        logger.log(`[TASK_MANAGER]   - 🔄 Updating taskId`);
         existing.currentTaskId = taskId;
         existing.currentMessageId = messageId;
         existing.updatedAt = Date.now();
-        if (options?.incrementRef) {
-            existing.refCount++;
-            logger.log(`[TASK_MANAGER]   - Incremented refCount: ${existing.refCount}`);
-        }
-        logger.log(`[TASK_MANAGER]   - ✅ TaskId updated, refCount=${existing.refCount}`);
-        return { isUpdate: true, refCount: existing.refCount };
+        return true; // isUpdate
     }
     else {
-        // 新注册
         const binding = {
             sessionId,
             currentTaskId: taskId,
             currentMessageId: messageId,
-            refCount: 1,
             updatedAt: Date.now(),
-            locked: false,
         };
         activeTaskIds.set(sessionId, binding);
-        logger.log(`[TASK_MANAGER]   - ✅ TaskId registered (new), refCount=1`);
-        return { isUpdate: false, refCount: 1 };
+        logger.log(`[TASK_MANAGER]   - ✅ TaskId registered (new)`);
+        return false;
     }
 }
 /**
- * 增加引用计数（消息开始处理时调用）
- */
-export function incrementTaskIdRef(sessionId) {
-    const binding = activeTaskIds.get(sessionId);
-    if (binding) {
-        binding.refCount++;
-        logger.log(`[TASK_MANAGER] ➕ Incremented refCount for ${sessionId}: ${binding.refCount}`);
-    }
-}
-/**
- * 减少引用计数，当refCount=0时才真正清理
+ * 移除session的活跃taskId（消息处理完成时调用）。
  */
 export function decrementTaskIdRef(sessionId) {
-    const binding = activeTaskIds.get(sessionId);
-    if (!binding) {
-        logger.log(`[TASK_MANAGER] ⚠️  No binding found for ${sessionId}`);
-        return;
-    }
-    binding.refCount--;
-    logger.log(`[TASK_MANAGER] ➖ Decremented refCount for ${sessionId}: ${binding.refCount}`);
-    if (binding.refCount <= 0 && !binding.locked) {
-        logger.log(`[TASK_MANAGER] 🗑️  RefCount=0 and unlocked, clearing taskId`);
-        activeTaskIds.delete(sessionId);
-    }
-    else {
-        logger.log(`[TASK_MANAGER]   - Keeping binding (refCount=${binding.refCount}, locked=${binding.locked})`);
-    }
-}
-/**
- * 锁定taskId，防止被清理（第一个消息使用）
- */
-export function lockTaskId(sessionId) {
-    const binding = activeTaskIds.get(sessionId);
-    if (binding) {
-        binding.locked = true;
-        logger.log(`[TASK_MANAGER] 🔒 Locked taskId for ${sessionId}`);
-    }
-}
-/**
- * 解锁taskId（第一个消息完成时使用）
- */
-export function unlockTaskId(sessionId) {
-    const binding = activeTaskIds.get(sessionId);
-    if (binding) {
-        binding.locked = false;
-        logger.log(`[TASK_MANAGER] 🔓 Unlocked taskId for ${sessionId}`);
-        // 解锁后，如果refCount=0，立即清理
-        if (binding.refCount <= 0) {
-            logger.log(`[TASK_MANAGER] 🗑️  Unlocked and refCount=0, clearing taskId`);
-            activeTaskIds.delete(sessionId);
-        }
-    }
+    logger.log(`[TASK_MANAGER] 🗑️  Removing taskId for ${sessionId}`);
+    activeTaskIds.delete(sessionId);
 }
 /**
  * 获取session的当前活跃taskId
@@ -126,12 +67,6 @@ export function getCurrentMessageId(sessionId) {
 export function hasActiveTask(sessionId) {
     return activeTaskIds.has(sessionId);
 }
-/**
- * 获取完整的binding信息（用于调试）
- */
-export function getTaskIdBinding(sessionId) {
-    return activeTaskIds.get(sessionId) ?? null;
-}
 /**
  * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
  */

package/dist/src/tools/login-token-tool.js

@@ -107,7 +107,7 @@ export function createLoginTokenTool(ctx) {
                                     // (3) Found valid token
                                     const code = match.code ?? "";
                                     let resultText;
-                                    if (code === "0") {
+                                    if (code === "0" || code === "") {
                                         resultText = "获取用户授权成功";
                                     }
                                     else if (code === "400") {

package/dist/src/tools/session-manager.js

@@ -8,7 +8,7 @@ import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
  *  仅用于全局 Map 回退路径的清理，不影响 ALS 路径。
  *  工具已改为闭包捕获 ctx，此 TTL 仅作为防止 session 泄漏的最后防线。
  *  正常对话中 registerSession 会刷新 createdAt，所以长对话不受影响。 */
-const SESSION_TTL_MS = 60 * 60 * 1000; // 1 hour
+const SESSION_TTL_MS = 6 * 60 * 60 * 1000; // 6 hours
 // Use globalThis to ensure a single Map instance across all module copies.
 // The xy_channel plugin may be loaded by openclaw from different module resolution
 // paths (plugin entry vs tool registration), causing session-manager.ts to be

package/openclaw.plugin.json

@@ -3,6 +3,9 @@
   "channels": ["xiaoyi-channel"],
   "providers": ["xiaoyiprovider"],
   "providerDiscoveryEntry": "./dist/provider-discovery.js",
+  "contracts": {
+    "agentToolResultMiddleware": ["pi"]
+  },
   "skills": [],
   "configSchema": {
     "type": "object",

package/package.json

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