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

package/dist/index.d.ts

@@ -1,11 +1,8 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 declare const _default: {
     id: string;
     name: string;
     description: string;
-    configSchema: import("openclaw/plugin-sdk").ChannelConfigSchema;
-    register: (api: OpenClawPluginApi) => void;
-    channelPlugin: import("openclaw/plugin-sdk").ChannelPlugin;
-    setChannelRuntime?: (runtime: import("openclaw/plugin-sdk").PluginRuntime) => void;
-};
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
+} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "kind" | "reload" | "nodeHostCommands" | "securityAuditCollectors">;
 export default _default;

package/dist/index.js

@@ -1,69 +1,100 @@
-import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+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 { injectCsplSteer } 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 { tryInjectSteer } from "./src/steer-injector.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";
-export default defineChannelPluginEntry({
-    id: "xiaoyi-channel",
-    name: "Xiaoyi Channel",
-    description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
-    plugin: xyPlugin,
-    setRuntime: setXYRuntime,
-    registerFull(api) {
-        api.registerProvider(xiaoyiProvider);
-        // SKILL RETRIEVER HOOK: before_prompt_build hook
-        const pluginConfig = api.pluginConfig || {};
-        const skillRetrieverConfig = normalizeToolRetrieverConfig({
-            enabled: pluginConfig.skillRetrieverEnabled ?? true,
-            maxTools: pluginConfig.skillRetrieverMaxTools ?? 2,
-            includeUninstalledOnly: true,
-            envFilePath: "~/.openclaw/.xiaoyienv",
-            timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
-        });
-        const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
-        api.on("before_prompt_build", beforePromptBuildHandler);
-        registerSelfEvolutionToolResultNudge(api);
-        api.on("after_tool_call", async (event, ctx) => {
-            if (!ALLOWED_TOOLS.includes(event.toolName)) {
+function registerFullHooks(api) {
+    // SKILL RETRIEVER HOOK: before_prompt_build hook
+    const pluginConfig = api.pluginConfig || {};
+    const skillRetrieverConfig = normalizeToolRetrieverConfig({
+        enabled: pluginConfig.skillRetrieverEnabled ?? true,
+        maxTools: pluginConfig.skillRetrieverMaxTools ?? 2,
+        includeUninstalledOnly: true,
+        envFilePath: "~/.openclaw/.xiaoyienv",
+        timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
+    });
+    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 (with /steer prefix)
+    // into the active Pi run to interrupt the agent.
+    // 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;
             }
-            console.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;
-                }
-                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);
+            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 message`);
+                if (sessionCtx) {
+                    await injectCsplSteer(sessionCtx.sessionId, sessionCtx.taskId, STEER_ABORT_MESSAGE);
                 }
-                const response = await callCsplApi(finalJson, api.config);
-                const result = parseSecurityResult(response);
-                console.log(`[SENTINEL HOOK] Security result: status=${result.status}`);
-                if (result.status === "REJECT") {
-                    await tryInjectSteer(ctx.sessionKey, STEER_ABORT_MESSAGE);
+                else {
+                    logger.error("[SENTINEL HOOK] No session context, cannot inject steer");
                 }
             }
-            catch (err) {
-                api.logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
-            }
-        });
+        }
+        catch (err) {
+            logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
+        }
+    });
+}
+export default definePluginEntry({
+    id: "xiaoyi-channel",
+    name: "Xiaoyi Channel",
+    description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
+    register(api) {
+        // Always register the provider so wrapStreamFn/prepareExtraParams work
+        // in ALL registration modes (not just "full").
+        api.registerProvider(xiaoyiProvider);
+        // Register channel plugin and set runtime
+        api.registerChannel({ plugin: xyPlugin });
+        setXYRuntime(api.runtime);
+        if (api.registrationMode === "full") {
+            registerFullHooks(api);
+            registerCsplHook(api);
+        }
     },
 });

package/dist/provider-discovery.d.ts

@@ -0,0 +1,2 @@
+import { xiaoyiProvider } from "./src/provider.js";
+export default xiaoyiProvider;

package/dist/provider-discovery.js

@@ -0,0 +1,4 @@
+// Provider discovery entry for fast-path provider resolution.
+// Exported as default so normalizeDiscoveryModule can unwrap it via .default.
+import { xiaoyiProvider } from "./src/provider.js";
+export default xiaoyiProvider;

package/dist/src/bot.d.ts

@@ -9,6 +9,8 @@ export interface HandleXYMessageParams {
     message: A2AJsonRpcRequest;
     accountId: string;
     webSocketSessionId?: string;
+    /** Called after dispatch init is complete (agentTools/wrapStreamFn done). */
+    onInitComplete?: () => void;
 }
 /**
  * Handle an incoming A2A message.

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,9 @@ 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.
  * This is the main entry point for message processing.
@@ -21,10 +22,8 @@ import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActive
  */
 export async function handleXYMessage(params) {
     const { cfg, runtime, message, accountId, webSocketSessionId } = params;
-    const log = runtime?.log ?? console.log;
-    const error = runtime?.error ?? console.error;
-    // 每次收到消息时更新缓存，供 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 {
@@ -36,7 +35,7 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("clearContext request missing sessionId in params");
             }
-            log(`Clear context request for session ${sessionId}`);
+            logger.log(`Clear context request for session ${sessionId}`);
             const config = resolveXYConfig(cfg);
             await sendClearContextResponse({
                 config,
@@ -52,7 +51,7 @@ export async function handleXYMessage(params) {
             if (!sessionId) {
                 throw new Error("tasks/cancel request missing sessionId in params");
             }
-            log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
+            logger.log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
             const config = resolveXYConfig(cfg);
             await sendTasksCancelResponse({
                 config,
@@ -68,18 +67,18 @@ export async function handleXYMessage(params) {
         // 如果消息中包含 Trigger 事件数据，直接返回 pushData 内容，不走正常流程
         const triggerData = extractTriggerData(parsed.parts);
         if (triggerData) {
-            log(`[BOT] 📌 Detected Trigger message with pushDataId: ${triggerData.pushDataId}`);
-            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
-            log(`[BOT]   - Task ID: ${parsed.taskId}`);
+            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) {
-                    error(`[BOT] ❌ pushData not found for ID: ${triggerData.pushDataId}`);
+                    logger.error(`[BOT] ❌ pushData not found for ID: ${triggerData.pushDataId}`);
                     return;
                 }
-                log(`[BOT] ✅ Found pushData, sending direct response`);
-                log(`[BOT]   - 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({
@@ -91,55 +90,47 @@ export async function handleXYMessage(params) {
                     append: false,
                     final: true,
                 });
-                log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
+                logger.log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
                 return; // 提前返回，不继续处理
             }
             catch (err) {
-                error(`[BOT] ❌ Failed to handle Trigger message:`, err);
+                logger.error(`[BOT] ❌ Failed to handle Trigger message:`, err);
                 return;
             }
         }
         // ========================================
-        // 🔑 检测steer模式和是否是第二条消息
-        const isSteerMode = cfg.messages?.queue?.mode === "steer";
-        const isSecondMessage = isSteerMode && hasActiveTask(parsed.sessionId);
-        if (isSecondMessage) {
-            log(`[BOT] 🔄 STEER MODE - Second message detected (will be follower)`);
-            log(`[BOT]   - Session: ${parsed.sessionId}`);
-            log(`[BOT]   - New taskId: ${parsed.taskId} (will replace current)`);
-        }
-        // 🔑 注册taskId（第二条消息会覆盖第一条的taskId）
-        const { isUpdate, refCount } = registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId, { incrementRef: true } // 增加引用计数
-        );
-        // 🔑 如果是第一条消息，锁定taskId防止被过早清理
-        if (!isUpdate) {
-            lockTaskId(parsed.sessionId);
-            log(`[BOT] 🔒 Locked taskId for first message`);
+        // 🔑 注册taskId（检测是否是已有活跃任务的 session）
+        const isUpdate = hasActiveTask(parsed.sessionId);
+        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}`);
         }
+        registerTaskId(parsed.sessionId, parsed.taskId, parsed.messageId);
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
-            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) => {
-                error(`[BOT] Failed to persist pushId:`, err);
+                logger.error(`[BOT] Failed to persist pushId:`, err);
             });
         }
         else {
-            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+            logger.log(`[BOT] ℹ️  No push_id found in message, will use config default`);
         }
         // Extract deviceType if present (same level as push_id in systemVariables)
         const deviceType = extractDeviceType(parsed.parts);
         if (deviceType) {
-            log(`[BOT] 📱 Extracted deviceType from user message: ${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) => {
-            error(`[BOT] Failed to save runtime info:`, err);
+            logger.error(`[BOT] Failed to save runtime info:`, err);
         });
         // Resolve configuration (needed for status updates)
         const config = resolveXYConfig(cfg);
@@ -155,25 +146,26 @@ export async function handleXYMessage(params) {
                 id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
             },
         });
-        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        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）
-        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        // 🔑 发送初始状态更新
+        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 ? "新消息已接收，正在处理..." : "任务正在处理中，请稍候~",
+            text: "任务正在处理中，请稍候~",
             state: "working",
         }).catch((err) => {
-            error(`Failed to send initial status update:`, err);
+            logger.error(`Failed to send initial status update:`, err);
         });
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
@@ -183,24 +175,29 @@ export async function handleXYMessage(params) {
                 const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
                 if (selfEvolutionEnabled && shouldNudgeForSelfEvolutionKeyword(textForAgent)) {
                     const shouldNudge = toolCallNudgeManager.tryMarkKeywordNudge(route.sessionKey);
-                    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(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
+                            logger.log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
                         }
                     }
                 }
             }
             catch (selfEvolutionError) {
-                error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
+                logger.error(`[SELF_EVOLUTION] Failed to append inline keyword nudge: ${String(selfEvolutionError)}`);
             }
         }
+        // 🔑 Steer消息加 /steer 前缀，触发core的 queueEmbeddedPiMessage
+        if (isUpdate && textForAgent) {
+            textForAgent = `/steer ${textForAgent}`;
+            logger.log(`[BOT] 🔄 Prepended /steer for steer injection`);
+        }
         const fileParts = extractFileParts(parsed.parts);
         // Download files to local disk
         const downloadedFiles = await downloadFilesFromParts(fileParts);
-        console.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
+        logger.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
         const mediaPayload = buildXYMediaPayload(downloadedFiles);
         // Resolve envelope format options (following feishu pattern)
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
@@ -233,7 +230,7 @@ export async function handleXYMessage(params) {
             SenderId: parsed.sessionId,
             Provider: "xiaoyi-channel",
             Surface: "xiaoyi-channel",
-            MessageSid: parsed.messageId,
+            MessageSid: `${parsed.taskId}_${deviceType}`,
             Timestamp: Date.now(),
             WasMentioned: false,
             CommandAuthorized: true,
@@ -242,9 +239,13 @@ export async function handleXYMessage(params) {
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
         });
-        // 🔑 创建dispatcher（dispatcher会自动使用动态taskId）
-        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
-        log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
+        // 🔑 Dynamic steer state: when isUpdate (second message), start as steered=true
+        // so the dispatcher skips all user-facing callbacks (deliver, onIdle, etc.)
+        // and onSettled skips cleanup.
+        const steerState = { steered: isUpdate };
+        // 🔑 创建dispatcher
+        logger.log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher`);
+        logger.log(`[BOT-DISPATCHER]   - taskId: ${parsed.taskId}`);
         const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
             cfg,
             runtime,
@@ -252,14 +253,9 @@ export async function handleXYMessage(params) {
             taskId: parsed.taskId,
             messageId: parsed.messageId,
             accountId: route.accountId,
-            isSteerFollower: isSecondMessage, // 🔑 标记第二条消息
+            steerState,
         });
-        // 🔑 只有第一条消息启动状态定时器
-        // 第二条消息会很快返回，不需要定时器
-        if (!isSecondMessage) {
-            startStatusInterval();
-            log(`[BOT-DISPATCHER] ✅ Status interval started for first message`);
-        }
+        startStatusInterval();
         // Build session context for AsyncLocalStorage
         const sessionContext = {
             config,
@@ -269,69 +265,74 @@ export async function handleXYMessage(params) {
             agentId: route.accountId,
             deviceType,
         };
-        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(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
-                // 🔑 减少引用计数
-                decrementTaskIdRef(parsed.sessionId);
-                // 🔑 如果是第一条消息完成，解锁
-                if (!isSecondMessage) {
-                    unlockTaskId(parsed.sessionId);
-                    log(`[BOT] 🔓 Unlocked taskId (first message completed)`);
+                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) {
+                    logger.log(`[BOT] ✅ Steered dispatch settled (skipping cleanup)`);
+                    return;
                 }
-                // 减少session引用计数
+                decrementTaskIdRef(parsed.sessionId);
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Cleanup completed`);
+                logger.log(`[BOT] ✅ Cleanup completed`);
+            },
+            run: () => {
+                // 🔐 Use AsyncLocalStorage to provide session context to tools.
+                // runWithSessionContext returns after the sync part of dispatch
+                // (including agentTools + wrapStreamFn) has executed, so we
+                // signal init complete to release the global dispatch gate
+                // for the next session.
+                const dispatchPromise = runWithSessionContext(sessionContext, async () => {
+                    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,
+                            cfg,
+                            dispatcher,
+                            replyOptions,
+                        });
+                        logger.log(`[BOT-DISPATCH] ✅ dispatchReplyFromConfig returned`);
+                        logger.log(`[BOT-DISPATCH]   - result: ${JSON.stringify(result)}`);
+                        return result;
+                    }
+                    catch (dispatchErr) {
+                        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;
+                    }
+                });
+                // Signal init complete — sync part (agentTools, wrapStreamFn) is done
+                params.onInitComplete?.();
+                return dispatchPromise;
             },
-            run: () => 
-            // 🔐 Use AsyncLocalStorage to provide session context to tools
-            runWithSessionContext(sessionContext, async () => {
-                log(`[BOT-DISPATCH] ⏳ dispatchReplyFromConfig starting...`);
-                log(`[BOT-DISPATCH]   - sessionKey: ${ctxPayload.SessionKey}`);
-                log(`[BOT-DISPATCH]   - provider: ${ctxPayload.Provider}`);
-                log(`[BOT-DISPATCH]   - surface: ${ctxPayload.Surface}`);
-                log(`[BOT-DISPATCH]   - from: ${ctxPayload.From}`);
-                log(`[BOT-DISPATCH]   - body length: ${ctxPayload.Body?.length ?? 0}`);
-                try {
-                    const result = await core.channel.reply.dispatchReplyFromConfig({
-                        ctx: ctxPayload,
-                        cfg,
-                        dispatcher,
-                        replyOptions,
-                    });
-                    log(`[BOT-DISPATCH] ✅ dispatchReplyFromConfig returned`);
-                    log(`[BOT-DISPATCH]   - result: ${JSON.stringify(result)}`);
-                    return result;
-                }
-                catch (dispatchErr) {
-                    error(`[BOT-DISPATCH] ❌ dispatchReplyFromConfig threw`);
-                    error(`[BOT-DISPATCH]   - error name: ${dispatchErr instanceof Error ? dispatchErr.name : "unknown"}`);
-                    error(`[BOT-DISPATCH]   - error message: ${String(dispatchErr)}`);
-                    error(`[BOT-DISPATCH]   - error stack: ${dispatchErr instanceof Error ? dispatchErr.stack?.slice(0, 500) : "N/A"}`);
-                    throw dispatchErr;
-                }
-            }),
         });
-        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
-        log(`xy: dispatch complete (session=${parsed.sessionId})`);
+        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
-        error("Failed to handle XY message:", err);
+        logger.error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
-        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) {
-                log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
+                logger.log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
                 // 清理 taskId
                 decrementTaskIdRef(sessionId);
-                unlockTaskId(sessionId);
                 // 清理 session
                 const core = getXYRuntime();
                 const route = core.channel.routing.resolveAgentRoute({
@@ -344,11 +345,11 @@ export async function handleXYMessage(params) {
                     },
                 });
                 unregisterSession(route.sessionKey);
-                log(`[BOT] ✅ Cleanup completed after error`);
+                logger.log(`[BOT] ✅ Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {
-            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

package/dist/src/client.d.ts

@@ -1,15 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
-/**
- * Set the runtime for logging in client module.
- */
-export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.
  */
-export declare function getXYWebSocketManager(config: XYChannelConfig): XYWebSocketManager;
+export declare function getXYWebSocketManager(config: XYChannelConfig, runtime?: RuntimeEnv): XYWebSocketManager;
 /**
  * Remove a specific WebSocket manager from cache.
  * Disconnects the manager and removes it from the cache.