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

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-declare const plugin: {
+declare const _default: {
     id: string;
     name: string;
     description: string;
     configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
-    register(api: OpenClawPluginApi): void;
-};
-export default plugin;
+    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,146 +1,87 @@
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-import { xyPlugin } from "./src/channel.js";
+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 { 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/steer-injector.js";
-import { callCsplApi } from "./src/cspl/call-api.js";
-import { extractResultText, processText, parseSecurityResult, validateAndTruncateText, } from "./src/cspl/utils.js";
-import { selfEvolutionManager } from "./src/utils/self-evolution-manager.js";
-import { TOOL_CALL_NUDGE_THRESHOLD, toolCallNudgeManager, } from "./src/utils/tool-call-nudge-manager.js";
-import { ALLOWED_TOOLS, MIN_TEXT_LENGTH, MAX_TOTAL_LENGTH, MAX_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./src/cspl/constants.js";
-const SELF_EVOLUTION_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前任务已经调用了较多工具。如果你识别到其中存在稳定、可复用的踩坑经验或排错模式，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
-const SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前用户请求中可能包含希望沉淀经验、避免重复踩坑的意图。如果你已经从当前问题中识别出稳定、可复用的处理规则或排错经验，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
-const SELF_EVOLUTION_KEYWORD_PATTERNS = [
-    /进化/u,
-    /记住/u,
-    /永远/u,
-    /下次必须/u,
-    /沉淀为/u,
-    /总结为/u,
-    /归纳为/u,
-    /以后(?:不要再犯|别再犯|必须|注意|记住)/u,
-    /记住这个坑/u,
-    /避免下次/u,
-    /别再踩坑/u,
-    /不要再踩坑/u,
-    /下次(?:别再|不要再)/u,
-    /以后(?:别再|不要再)(?:出错|犯错|漏掉|踩坑)/u,
-    /这个坑要记住/u,
-    /记住这次(?:教训|经验|问题)/u,
-    /吸取这次(?:教训|经验)/u,
-    /总结(?:一下)?这个坑/u,
-    /把这个(?:经验|教训|规则)记住/u,
-    /以后按这个规则/u,
-    /以后都按这个来/u,
-    /以后遇到这种情况/u,
-    /类似情况(?:下)?不要再/u,
-    /这种问题下次不能再出现/u,
-    /永远不要再(?:犯|踩|漏)/u,
-    /永远记住这次(?:教训|经验)/u,
-];
-function shouldCountToolCall(toolName) {
-    if (toolName === "save_self_evolution_skill") {
-        return false;
-    }
-    if (toolName === "call_device_tool") {
-        return false;
-    }
-    if (toolName.endsWith("_tool_schema")) {
-        return false;
-    }
-    return true;
-}
-function getUserMessageForKeywordDetection(event) {
-    return event.body?.trim() || event.content.trim();
-}
-function shouldNudgeForSelfEvolutionKeyword(text) {
-    if (!text) {
-        return false;
-    }
-    return SELF_EVOLUTION_KEYWORD_PATTERNS.some((pattern) => pattern.test(text));
+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";
+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);
+    api.on("after_tool_call", async (event, ctx) => {
+        if (!ALLOWED_TOOLS.includes(event.toolName)) {
+            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);
+            }
+            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);
+            }
+        }
+        catch (err) {
+            api.logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
+        }
+    });
 }
-const plugin = {
+export default definePluginEntry({
     id: "xiaoyi-channel",
     name: "Xiaoyi Channel",
     description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
-    configSchema: emptyPluginConfigSchema(),
     register(api) {
-        setXYRuntime(api.runtime);
-        api.registerChannel({ plugin: xyPlugin });
+        // Always register the provider so wrapStreamFn/prepareExtraParams work
+        // in ALL registration modes (not just "full").
         api.registerProvider(xiaoyiProvider);
-        api.on("before_dispatch", async (event, ctx) => {
-            const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
-            if (!ctx.sessionKey || !selfEvolutionEnabled) {
-                return;
-            }
-            const userText = getUserMessageForKeywordDetection(event);
-            if (!shouldNudgeForSelfEvolutionKeyword(userText)) {
-                return;
-            }
-            try {
-                const shouldNudge = toolCallNudgeManager.tryMarkKeywordNudge(ctx.sessionKey);
-                api.logger.debug?.(`[SELF_EVOLUTION] Keyword check hit: sessionKey=${ctx.sessionKey}, shouldNudge=${shouldNudge}`);
-                if (shouldNudge) {
-                    api.logger.info?.(`[SELF_EVOLUTION] Keyword-triggered nudge injected: sessionKey=${ctx.sessionKey}`);
-                    await tryInjectSteer(ctx.sessionKey, SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE);
-                }
-            }
-            catch (err) {
-                api.logger.error(`[SELF_EVOLUTION] before_dispatch keyword nudge error: ${err}`);
-            }
-        });
-        api.on("after_tool_call", async (event, ctx) => {
-            const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
-            if (ctx.sessionKey &&
-                selfEvolutionEnabled &&
-                shouldCountToolCall(event.toolName)) {
-                try {
-                    const { count, shouldNudge } = toolCallNudgeManager.recordToolCall(ctx.sessionKey);
-                    api.logger.debug?.(`[SELF_EVOLUTION] Tool call counted: tool=${event.toolName}, count=${count}, threshold=${TOOL_CALL_NUDGE_THRESHOLD}, sessionKey=${ctx.sessionKey}`);
-                    if (shouldNudge) {
-                        api.logger.info?.(`[SELF_EVOLUTION] Tool call threshold reached, injecting nudge: count=${count}, sessionKey=${ctx.sessionKey}`);
-                        await tryInjectSteer(ctx.sessionKey, SELF_EVOLUTION_NUDGE_MESSAGE);
-                    }
-                }
-                catch (err) {
-                    api.logger.error(`[SELF_EVOLUTION] after_tool_call nudge error: ${err}`);
-                }
-            }
-            if (!ALLOWED_TOOLS.includes(event.toolName)) {
-                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);
-                }
-                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);
-                }
-            }
-            catch (err) {
-                api.logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
-            }
-        });
+        if (api.registrationMode === "cli-metadata") {
+            return;
+        }
+        if (api.registrationMode === "tool-discovery") {
+            registerFullHooks(api);
+            return;
+        }
+        // Register channel plugin and set runtime
+        api.registerChannel({ plugin: xyPlugin });
+        setXYRuntime(api.runtime);
+        if (api.registrationMode === "discovery") {
+            return;
+        }
+        if (api.registrationMode === "full") {
+            registerFullHooks(api);
+        }
     },
-};
-export default plugin;
+});

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.js

@@ -5,12 +5,14 @@ import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId,
 import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
-import { registerSession, unregisterSession, runWithSessionContext } from "./tools/session-manager.js";
+import { appendSelfEvolutionKeywordNudge, shouldNudgeForSelfEvolutionKeyword, } from "./self-evolution-keyword.js";
 import { configManager } from "./utils/config-manager.js";
 import { addPushId } from "./utils/pushid-manager.js";
 import { getPushDataById } from "./utils/pushdata-manager.js";
+import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 import { saveRuntimeInfo } from "./utils/runtime-manager.js";
-import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
+import { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
+import { registerSession, unregisterSession, hasActiveSession, xyAsyncLocalStorage, } from "./xy-session-store.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -87,6 +89,7 @@ export async function handleXYMessage(params) {
                     text: pushDataItem.dataDetail,
                     append: false,
                     final: true,
+                    runtime,
                 });
                 log(`[BOT] ✅ Trigger response sent successfully, exiting early`);
                 return; // 提前返回，不继续处理
@@ -97,22 +100,26 @@ export async function handleXYMessage(params) {
             }
         }
         // ========================================
-        // 🔑 检测steer模式和是否是第二条消息
+        // 🔑 检测steer模式
+        // Resolve route early to determine steer state
+        const config = resolveXYConfig(cfg);
+        let route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "xiaoyi-channel",
+            accountId,
+            peer: {
+                kind: "direct",
+                id: parsed.sessionId,
+            },
+        });
+        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
         const isSteerMode = cfg.messages?.queue?.mode === "steer";
-        const isSecondMessage = isSteerMode && hasActiveTask(parsed.sessionId);
+        const isSecondMessage = isSteerMode && hasActiveSession(route.sessionKey);
         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`);
-        }
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
@@ -138,27 +145,14 @@ export async function handleXYMessage(params) {
         ).catch((err) => {
             error(`[BOT] Failed to save runtime info:`, err);
         });
-        // Resolve configuration (needed for status updates)
-        const config = resolveXYConfig(cfg);
-        // ✅ Resolve agent route (following feishu pattern)
-        // accountId is "default" for XY (single account mode)
-        // Use sessionId as peer.id to ensure all messages in the same session share context
-        let route = core.channel.routing.resolveAgentRoute({
-            cfg,
-            channel: "xiaoyi-channel",
-            accountId, // "default"
-            peer: {
-                kind: "direct",
-                id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
-            },
-        });
-        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        // 🔑 Register / update session in unified store
         registerSession(route.sessionKey, {
             config,
-            sessionId: parsed.sessionId,
+            a2aSessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            agentId: route.accountId,
+            accountId: route.accountId,
+            deviceType,
         });
         // 🔑 发送初始状态更新（第二条消息也要发，用新taskId）
         log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
@@ -169,20 +163,41 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             text: isSecondMessage ? "新消息已接收，正在处理..." : "任务正在处理中，请稍候~",
             state: "working",
+            runtime,
         }).catch((err) => {
             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) {
+            try {
+                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}`);
+                    if (shouldNudge) {
+                        const augmented = appendSelfEvolutionKeywordNudge(textForAgent);
+                        textForAgent = augmented.text;
+                        if (augmented.appended) {
+                            log(`[SELF_EVOLUTION] Keyword-triggered inline nudge appended: sessionKey=${route.sessionKey}`);
+                        }
+                    }
+                }
+            }
+            catch (selfEvolutionError) {
+                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);
-        console.log("Downloaded files:", JSON.stringify(downloadedFiles, null, 2));
+        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);
         // Build message body with speaker prefix (following feishu pattern)
-        let messageBody = text || "";
+        let messageBody = textForAgent;
         // Add speaker prefix for clarity
         const speaker = parsed.sessionId;
         messageBody = `${speaker}: ${messageBody}`;
@@ -198,8 +213,8 @@ export async function handleXYMessage(params) {
         // Use route.accountId and route.sessionKey instead of parsed fields
         const ctxPayload = core.channel.reply.finalizeInboundContext({
             Body: body,
-            RawBody: text || "",
-            CommandBody: text || "",
+            RawBody: textForAgent,
+            CommandBody: textForAgent,
             From: parsed.sessionId,
             To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
             SessionKey: route.sessionKey, // ✅ Use route.sessionKey
@@ -237,35 +252,18 @@ export async function handleXYMessage(params) {
             startStatusInterval();
             log(`[BOT-DISPATCHER] ✅ Status interval started for first message`);
         }
-        // Build session context for AsyncLocalStorage
-        const sessionContext = {
-            config,
-            sessionId: parsed.sessionId,
-            taskId: parsed.taskId,
-            messageId: parsed.messageId,
-            agentId: route.accountId,
-            deviceType,
-        };
         log(`[BOT-DISPATCH] ⏳ withReplyDispatcher starting, sessionKey=${route.sessionKey}`);
-        await core.channel.reply.withReplyDispatcher({
+        // 🔐 Set ALS BEFORE withReplyDispatcher so agentTools factory can read it
+        // during dispatcher setup (which happens before run() is called).
+        await xyAsyncLocalStorage.run({ openclawSessionKey: route.sessionKey }, () => 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)`);
-                }
-                // 减少session引用计数
+                // Cleanup session from store
                 unregisterSession(route.sessionKey);
                 log(`[BOT] ✅ Cleanup completed`);
             },
-            run: () => 
-            // 🔐 Use AsyncLocalStorage to provide session context to tools
-            runWithSessionContext(sessionContext, async () => {
+            run: async () => {
                 log(`[BOT-DISPATCH] ⏳ dispatchReplyFromConfig starting...`);
                 log(`[BOT-DISPATCH]   - sessionKey: ${ctxPayload.SessionKey}`);
                 log(`[BOT-DISPATCH]   - provider: ${ctxPayload.Provider}`);
@@ -290,8 +288,8 @@ export async function handleXYMessage(params) {
                     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})`);
     }
@@ -300,18 +298,14 @@ export async function handleXYMessage(params) {
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
         log(`[BOT] ❌ Error occurred, attempting cleanup...`);
-        // 🔑 错误时也要清理taskId和session
+        // 🔑 错误时也要清理session
         try {
-            const params = message.params;
-            const sessionId = params?.sessionId;
+            const msgParams = message.params;
+            const sessionId = msgParams?.sessionId;
             if (sessionId) {
                 log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
-                // 清理 taskId
-                decrementTaskIdRef(sessionId);
-                unlockTaskId(sessionId);
-                // 清理 session
-                const core = getXYRuntime();
-                const route = core.channel.routing.resolveAgentRoute({
+                const core2 = getXYRuntime();
+                const errorRoute = core2.channel.routing.resolveAgentRoute({
                     cfg,
                     channel: "xiaoyi-channel",
                     accountId,
@@ -320,13 +314,12 @@ export async function handleXYMessage(params) {
                         id: sessionId,
                     },
                 });
-                unregisterSession(route.sessionKey);
+                unregisterSession(errorRoute.sessionKey);
                 log(`[BOT] ✅ Cleanup completed after error`);
             }
         }
         catch (cleanupErr) {
             log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
-            // Ignore cleanup errors
         }
         // ❌ Don't re-throw: message processing error should not affect gateway stability
     }

package/dist/src/channel.js

@@ -1,28 +1,9 @@
 import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./config.js";
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
-import { locationTool } from "./tools/location-tool.js";
-import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
-import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
-import { viewPushResultTool } from "./tools/view-push-result-tool.js";
-import { imageReadingTool } from "./tools/image-reading-tool.js";
-import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
-import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
-import { getEmailToolSchemaTool } from "./tools/get-email-tool-schema.js";
-import { callDeviceTool } from "./tools/call-device-tool.js";
-import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
-import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
-import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
-import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
-import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
-import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
-import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
-import { queryAppMessageTool } from "./tools/query-app-message-tool.js";
-import { queryMemoryDataTool } from "./tools/query-memory-data-tool.js";
-import { queryTodoTaskTool } from "./tools/query-todo-task-tool.js";
-import { loginTokenTool } from "./tools/login-token-tool.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { getSession, xyAsyncLocalStorage } from "./xy-session-store.js";
+import { createAllTools } from "./tools/create-all-tools.js";
 import { logger } from "./utils/logger.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
@@ -63,10 +44,18 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     agentTools: () => {
-        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, saveSelfEvolutionSkillTool, getEmailToolSchemaTool, queryAppMessageTool, queryMemoryDataTool, queryTodoTaskTool, loginTokenTool];
-        const ctx = getCurrentSessionContext();
-        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(", ")})`);
+        // agentTools factory is called during agent run setup.
+        // ALS is still valid at this point — read sessionKey from it.
+        const alsContext = xyAsyncLocalStorage.getStore();
+        const sessionKey = alsContext?.openclawSessionKey;
+        if (!sessionKey) {
+            logger.log("[CHANNEL-TOOLS] no sessionKey in ALS, returning empty tools");
+            return [];
+        }
+        const session = getSession(sessionKey);
+        const allTools = createAllTools(sessionKey);
+        const filtered = filterToolsByDevice(allTools, session?.deviceType);
+        logger.log(`[CHANNEL-TOOLS] sessionKey=${sessionKey} deviceType=${session?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {