@ynhcj/xiaoyi-channel 0.0.107-next → 0.0.108-next

package/dist/src/bot.js

@@ -6,13 +6,14 @@ import { downloadFilesFromParts } from "./file-download.js";
 import { resolveXYConfig } from "./config.js";
 import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse, sendA2AResponse } from "./formatter.js";
 import { appendSelfEvolutionKeywordNudge, shouldNudgeForSelfEvolutionKeyword, } from "./self-evolution-keyword.js";
+import { registerSession, unregisterSession, runWithSessionContext } from "./tools/session-manager.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 { toolCallNudgeManager } from "./utils/tool-call-nudge-manager.js";
-import { registerSession, unregisterSession, hasActiveSession, xyAsyncLocalStorage, } from "./xy-session-store.js";
+import { registerTaskId, decrementTaskIdRef, lockTaskId, unlockTaskId, hasActiveTask, } from "./task-manager.js";
 /**
  * Handle an incoming A2A message.
  * This is the main entry point for message processing.
@@ -100,26 +101,22 @@ export async function handleXYMessage(params) {
             }
         }
         // ========================================
-        // 🔑 检测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}`);
+        // 🔑 检测steer模式和是否是第二条消息
         const isSteerMode = cfg.messages?.queue?.mode === "steer";
-        const isSecondMessage = isSteerMode && hasActiveSession(route.sessionKey);
+        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`);
+        }
         // Extract and update push_id if present
         const pushId = extractPushId(parsed.parts);
         if (pushId) {
@@ -145,13 +142,27 @@ export async function handleXYMessage(params) {
         ).catch((err) => {
             error(`[BOT] Failed to save runtime info:`, err);
         });
-        // 🔑 Register / update session in unified store
+        // 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}`);
         registerSession(route.sessionKey, {
             config,
-            a2aSessionId: parsed.sessionId,
+            sessionId: parsed.sessionId,
             taskId: parsed.taskId,
             messageId: parsed.messageId,
-            accountId: route.accountId,
+            agentId: route.accountId,
             deviceType,
         });
         // 🔑 发送初始状态更新（第二条消息也要发，用新taskId）
@@ -252,18 +263,35 @@ 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}`);
-        // 🔐 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({
+        await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
                 log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
-                // Cleanup session from store
+                log(`[BOT]   - isSecondMessage: ${isSecondMessage}`);
+                // 🔑 减少引用计数
+                decrementTaskIdRef(parsed.sessionId);
+                // 🔑 如果是第一条消息完成，解锁
+                if (!isSecondMessage) {
+                    unlockTaskId(parsed.sessionId);
+                    log(`[BOT] 🔓 Unlocked taskId (first message completed)`);
+                }
+                // 减少session引用计数
                 unregisterSession(route.sessionKey);
                 log(`[BOT] ✅ Cleanup completed`);
             },
-            run: async () => {
+            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}`);
@@ -288,8 +316,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})`);
     }
@@ -298,14 +326,18 @@ 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...`);
-        // 🔑 错误时也要清理session
+        // 🔑 错误时也要清理taskId和session
         try {
-            const msgParams = message.params;
-            const sessionId = msgParams?.sessionId;
+            const params = message.params;
+            const sessionId = params?.sessionId;
             if (sessionId) {
                 log(`[BOT] 🧹 Cleaning up after error: ${sessionId}`);
-                const core2 = getXYRuntime();
-                const errorRoute = core2.channel.routing.resolveAgentRoute({
+                // 清理 taskId
+                decrementTaskIdRef(sessionId);
+                unlockTaskId(sessionId);
+                // 清理 session
+                const core = getXYRuntime();
+                const route = core.channel.routing.resolveAgentRoute({
                     cfg,
                     channel: "xiaoyi-channel",
                     accountId,
@@ -314,12 +346,13 @@ export async function handleXYMessage(params) {
                         id: sessionId,
                     },
                 });
-                unregisterSession(errorRoute.sessionKey);
+                unregisterSession(route.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

@@ -2,7 +2,7 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getSession, xyAsyncLocalStorage } from "./xy-session-store.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { createAllTools } from "./tools/create-all-tools.js";
 import { logger } from "./utils/logger.js";
 /**
@@ -44,20 +44,10 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     agentTools: () => {
-        // agentTools factory may be called before ALS is active (e.g. during
-        // dispatcher setup).  Don't bail out — tools will resolve their
-        // session at execute time via requireSession() which falls back to ALS.
-        const alsContext = xyAsyncLocalStorage.getStore();
-        const sessionKey = alsContext?.openclawSessionKey;
-        const allTools = createAllTools(sessionKey ?? undefined);
-        const session = sessionKey ? getSession(sessionKey) : null;
-        const filtered = filterToolsByDevice(allTools, session?.deviceType);
-        if (sessionKey) {
-            logger.log(`[CHANNEL-TOOLS] sessionKey=${sessionKey} deviceType=${session?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length}`);
-        }
-        else {
-            logger.log(`[CHANNEL-TOOLS] no ALS at factory time, created ${filtered.length} tools (will resolve session at execute time)`);
-        }
+        const ctx = getCurrentSessionContext();
+        const allTools = createAllTools(ctx);
+        const filtered = filterToolsByDevice(allTools, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {

package/dist/src/formatter.js

@@ -2,7 +2,7 @@
 import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
 import { logger } from "./utils/logger.js";
-import { getSessionByA2AId } from "./xy-session-store.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 /**
  * Send an A2A artifact update response.
  */
@@ -114,8 +114,8 @@ export async function sendStatusUpdate(params) {
     const log = runtime?.log ?? console.log;
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
     // fall back to closure-captured values
-    const currentTaskId = getSessionByA2AId(sessionId)?.taskId ?? taskId;
-    const currentMessageId = getSessionByA2AId(sessionId)?.messageId ?? messageId;
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build status update event following A2A protocol standard
     const statusUpdate = {
         taskId: currentTaskId,
@@ -162,8 +162,8 @@ export async function sendCommand(params) {
     const { config, sessionId, taskId, messageId, command } = params;
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
     // fall back to closure-captured values
-    const currentTaskId = getSessionByA2AId(sessionId)?.taskId ?? taskId;
-    const currentMessageId = getSessionByA2AId(sessionId)?.messageId ?? messageId;
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {

package/dist/src/monitor.js

@@ -2,13 +2,13 @@ import { resolveXYConfig } from "./config.js";
 import { getXYWebSocketManager, setClientRuntime, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
-import { getAllActiveSessions, getSessionByA2AId } from "./xy-session-store.js";
+import { hasActiveTask, getAllActiveTaskBindings } from "./task-manager.js";
 import { sendA2AResponse } from "./formatter.js";
 import { handleTriggerEvent } from "./trigger-handler.js";
 import { handleSelfEvolutionEvent, handleSelfEvolutionStateGetEvent } from "./self-evolution-handler.js";
 import { handleLoginTokenEvent } from "./login-token-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
-import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./xy-session-store.js";
+import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./tools/session-manager.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -106,7 +106,7 @@ export async function monitorXYProvider(opts = {}) {
             try {
                 const parsed = parseA2AMessage(message);
                 const steerMode = cfg.messages?.queue?.mode === "steer";
-                const hasActiveRun = Boolean(getSessionByA2AId(parsed.sessionId));
+                const hasActiveRun = hasActiveTask(parsed.sessionId);
                 if (steerMode && hasActiveRun) {
                     // Steer模式且有活跃任务：不入队列，直接并发执行
                     log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
@@ -214,25 +214,25 @@ export async function monitorXYProvider(opts = {}) {
             log("XY gateway: abort signal received, sending notifications before stopping");
             // 📤 Send restart notification to all active sessions before disconnecting
             try {
-                const activeSessions = getAllActiveSessions();
-                if (activeSessions.length > 0) {
+                const activeBindings = getAllActiveTaskBindings();
+                if (activeBindings.length > 0) {
                     const config = resolveXYConfig(cfg);
                     const notificationText = "Gateway即将重启，重启期间可能短暂出现\u201c环境异常\u201d提示，请稍候并耐心重试~";
-                    log(`[MONITOR] 📤 Sending restart notifications to ${activeSessions.length} active session(s)`);
-                    const sendPromises = activeSessions.map(({ session }) => sendA2AResponse({
+                    log(`[MONITOR] 📤 Sending restart notifications to ${activeBindings.length} active session(s)`);
+                    const sendPromises = activeBindings.map(binding => sendA2AResponse({
                         config,
-                        sessionId: session.a2aSessionId,
-                        taskId: session.taskId,
-                        messageId: session.messageId,
+                        sessionId: binding.sessionId,
+                        taskId: binding.currentTaskId,
+                        messageId: binding.currentMessageId,
                         text: notificationText,
                         append: false,
                         final: true,
                         runtime,
                     }).catch(err => {
-                        error(`[MONITOR] Failed to send restart notification to session ${session.a2aSessionId}: ${String(err)}`);
+                        error(`[MONITOR] Failed to send restart notification to session ${binding.sessionId}: ${String(err)}`);
                     }));
                     await Promise.all(sendPromises);
-                    log(`[MONITOR] ✅ Restart notifications sent to ${activeSessions.length} session(s)`);
+                    log(`[MONITOR] ✅ Restart notifications sent to ${activeBindings.length} session(s)`);
                 }
                 else {
                     log(`[MONITOR] No active sessions, skipping restart notifications`);

package/dist/src/outbound.js

@@ -1,7 +1,7 @@
 import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
-import { getSessionByA2AId } from "./xy-session-store.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { savePushData } from "./utils/pushdata-manager.js";
 import { getAllPushIds } from "./utils/pushid-manager.js";
 import { logger } from "./utils/logger.js";
@@ -68,10 +68,10 @@ export const xyOutbound = {
         // If the target doesn't contain "::", try to enhance it with taskId from session context
         if (!trimmedTo.includes("::")) {
             logger.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
-            // Try to get the current session context via A2A sessionId
-            const session = getSessionByA2AId(trimmedTo);
-            if (session) {
-                const enhancedTarget = `${trimmedTo}::${session.taskId}`;
+            // Try to get the current session context
+            const sessionContext = getCurrentSessionContext();
+            if (sessionContext && sessionContext.sessionId === trimmedTo) {
+                const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
                 logger.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
                 return {
                     ok: true,

package/dist/src/provider.js

@@ -8,7 +8,8 @@
 //   models.providers.xiaoyiprovider.api = "openai-completions"
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
-import { getSession, getSessionByA2AId, getAllActiveSessions, xyAsyncLocalStorage } from "./xy-session-store.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { getCurrentTaskId } from "./task-manager.js";
 import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 // ── Retry config ──────────────────────────────────────────────
 const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
@@ -404,12 +405,9 @@ export const xiaoyiProvider = {
      *   3. No uid available → return undefined (no headers injected)
      */
     prepareExtraParams: (ctx) => {
-        // Try to get session from ALS (valid during agent run setup)
-        const alsContext = xyAsyncLocalStorage.getStore();
-        const sessionKey = alsContext?.openclawSessionKey;
-        const session = sessionKey ? getSession(sessionKey) : null;
-        if (session) {
-            const taskId = session.taskId;
+        const sessionCtx = getCurrentSessionContext();
+        if (sessionCtx) {
+            const taskId = sessionCtx.taskId;
             const sessionId = taskId.split("&")[0];
             const interactionId = taskId.split("&")[1] || "";
             return {
@@ -417,7 +415,7 @@ export const xiaoyiProvider = {
                 [HEADER_TRACE_ID]: taskId,
                 [HEADER_SESSION_ID]: sessionId,
                 [HEADER_INTERACTION_ID]: interactionId,
-                [DEVICE_TYPE_KEY]: session.deviceType ?? "",
+                [DEVICE_TYPE_KEY]: sessionCtx.deviceType ?? "",
             };
         }
         // Fallback: store uid prefix for lazy timestamp generation in wrapStreamFn.
@@ -446,54 +444,17 @@ export const xiaoyiProvider = {
         if (!underlying)
             return underlying;
         // Capture A2A sessionId at agent setup time for multi-session isolation.
-        // wrapStreamFn is called per-agent (per session), ALS is still valid here.
-        // We capture the a2aSessionId and look up the store at each request time
-        // to always get the latest taskId (supports steer).
-        const alsContext = xyAsyncLocalStorage.getStore();
-        const capturedA2ASessionId = alsContext?.openclawSessionKey
-            ? getSession(alsContext.openclawSessionKey)?.a2aSessionId ?? null
-            : null;
+        // openclaw calls wrapStreamFn per-agent (per session), so this runs inside
+        // the correct runWithSessionContext() ALS scope.  When multiple sessions are
+        // active concurrently, getCurrentSessionContext() may later return the WRONG
+        // session (lastRegisteredKey fallback).  The captured sessionId lets us
+        // bypass that fallback and look up the correct taskId directly from
+        // task-manager.
+        const capturedA2ASessionId = getCurrentSessionContext()?.sessionId ?? null;
         return async (model, context, options) => {
+            // 每次请求时从 ctx.extraParams 动态读取 header
             const dynamicHeaders = {};
-            // Resolve taskId via three-layer fallback (same pattern as requireSession):
-            //   1. capturedA2ASessionId → store lookup (set at wrapStreamFn setup if ALS was active)
-            //   2. ALS → store lookup (works at request time if async chain preserved context)
-            //   3. Store enumeration (safe when only one session is active)
-            let resolvedTaskId = null;
-            if (capturedA2ASessionId) {
-                resolvedTaskId = getSessionByA2AId(capturedA2ASessionId)?.taskId ?? null;
-            }
-            if (!resolvedTaskId) {
-                const alsContext = xyAsyncLocalStorage.getStore();
-                const alsKey = alsContext?.openclawSessionKey;
-                if (alsKey) {
-                    resolvedTaskId = getSession(alsKey)?.taskId ?? null;
-                }
-            }
-            if (!resolvedTaskId) {
-                const allSessions = getAllActiveSessions();
-                if (allSessions.length === 1) {
-                    resolvedTaskId = allSessions[0].session.taskId;
-                }
-            }
-            if (resolvedTaskId) {
-                // Session mode: use taskId from store (supports steer).
-                const sessionId = resolvedTaskId.split("&")[0];
-                const interactionId = resolvedTaskId.split("&")[1] || "";
-                const isCron = isCronTriggered(context.messages);
-                dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${resolvedTaskId}_${Date.now()}` : resolvedTaskId;
-                dynamicHeaders[HEADER_SESSION_ID] = sessionId;
-                dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
-                if (isCron) {
-                    const cronTitle = extractCronTitle(context.messages);
-                    if (cronTitle)
-                        dynamicHeaders["x-cron-title"] = encodeURIComponent(cronTitle);
-                    if (context.messages?.length === 1)
-                        dynamicHeaders["x-cron-flag"] = "begin";
-                }
-            }
-            else if (ctx.extraParams) {
-                // No active session — fall back to prepareExtraParams cache.
+            if (ctx.extraParams) {
                 const fallbackPrefix = ctx.extraParams[FALLBACK_PREFIX_KEY];
                 if (typeof fallbackPrefix === "string") {
                     // Fallback mode: generate fresh timestamp per request
@@ -511,10 +472,28 @@ export const xiaoyiProvider = {
                     }
                 }
                 else {
-                    // No captured session, no fallback — use whatever is in prepareExtraParams cache.
-                    const traceId = ctx.extraParams[HEADER_TRACE_ID];
-                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
-                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                    // Session mode: resolve taskId for the correct session.
+                    //
+                    // Priority:
+                    //   1. capturedA2ASessionId → getCurrentTaskId()  (most reliable,
+                    //      bypasses lastRegisteredKey fallback)
+                    //   2. getCurrentSessionContext()?.taskId           (works when ALS
+                    //      is intact)
+                    //   3. ctx.extraParams cached values                (last resort,
+                    //      may be stale / from wrong session)
+                    let resolvedTaskId = null;
+                    if (capturedA2ASessionId) {
+                        resolvedTaskId = getCurrentTaskId(capturedA2ASessionId);
+                    }
+                    if (!resolvedTaskId) {
+                        resolvedTaskId = getCurrentSessionContext()?.taskId ?? null;
+                    }
+                    const traceId = resolvedTaskId ?? ctx.extraParams[HEADER_TRACE_ID];
+                    const sessionId = resolvedTaskId?.split("&")[0]
+                        ?? ctx.extraParams[HEADER_SESSION_ID];
+                    const interactionId = resolvedTaskId?.split("&")[1]
+                        ?? ctx.extraParams[HEADER_INTERACTION_ID]
+                        ?? "";
                     if (typeof traceId === "string") {
                         const isCron = isCronTriggered(context.messages);
                         dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}_${Date.now()}` : traceId;
@@ -538,27 +517,12 @@ export const xiaoyiProvider = {
                 console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
             // Prefer deviceType from extraParams (set by prepareExtraParams).
-            // Fall back to store lookup because OpenClaw caches
+            // Fall back to getCurrentSessionContext() because OpenClaw caches
             // resolvePreparedExtraParams by provider/modelId – the cache key does
             // not include session-specific data, so deviceType may be missing
             // from the cached extraParams even when a session is active.
             const extraParamsDeviceType = ctx.extraParams?.[DEVICE_TYPE_KEY] || undefined;
-            let storeDeviceType;
-            if (capturedA2ASessionId) {
-                storeDeviceType = getSessionByA2AId(capturedA2ASessionId)?.deviceType;
-            }
-            if (!storeDeviceType) {
-                const alsCtx = xyAsyncLocalStorage.getStore();
-                const key = alsCtx?.openclawSessionKey;
-                if (key)
-                    storeDeviceType = getSession(key)?.deviceType;
-            }
-            if (!storeDeviceType) {
-                const all = getAllActiveSessions();
-                if (all.length === 1)
-                    storeDeviceType = all[0].session.deviceType;
-            }
-            const deviceType = extraParamsDeviceType ?? storeDeviceType;
+            const deviceType = extraParamsDeviceType ?? getCurrentSessionContext()?.deviceType;
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;

package/dist/src/reply-dispatcher.js

@@ -1,7 +1,7 @@
 import { getXYRuntime } from "./runtime.js";
 import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
-import { getSessionByA2AId } from "./xy-session-store.js";
+import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
 import fs from "fs/promises";
 import path from "path";
 import { logger } from "./utils/logger.js";
@@ -59,12 +59,10 @@ export function createXYReplyDispatcher(params) {
      * 每次需要taskId时，都从TaskManager获取最新值
      */
     const getActiveTaskId = () => {
-        const session = getSessionByA2AId(sessionId);
-        return session?.taskId ?? initialTaskId;
+        return getCurrentTaskId(sessionId) ?? initialTaskId;
     };
     const getActiveMessageId = () => {
-        const session = getSessionByA2AId(sessionId);
-        return session?.messageId ?? initialMessageId;
+        return getCurrentMessageId(sessionId) ?? initialMessageId;
     };
     const core = getXYRuntime();
     const config = resolveXYConfig(cfg);

package/dist/src/steer-injector.js

@@ -1,5 +1,6 @@
 // Steer message injector for CSPL hook integration
-import { getSession, hasActiveSession } from "./xy-session-store.js";
+import { getSessionContext } from "./tools/session-manager.js";
+import { hasActiveTask, getCurrentTaskId } from "./task-manager.js";
 import { handleXYMessage } from "./bot.js";
 import { logger } from "./utils/logger.js";
 import { randomUUID } from "node:crypto";
@@ -28,12 +29,13 @@ export async function tryInjectSteer(sessionKey, message) {
     if (!sessionKey) {
         return false;
     }
-    const session = getSession(sessionKey);
-    if (!session) {
+    const sessionCtx = getSessionContext(sessionKey);
+    if (!sessionCtx) {
         return false;
     }
-    const { a2aSessionId: sessionId, taskId: activeTaskId } = session;
-    if (!hasActiveSession(sessionKey)) {
+    const { sessionId } = sessionCtx;
+    const activeTaskId = getCurrentTaskId(sessionId);
+    if (!hasActiveTask(sessionId)) {
         return false;
     }
     if (!cachedCfg || !cachedRuntime) {

package/dist/src/tools/calendar-tool.d.ts

@@ -1,6 +1,7 @@
+import type { SessionContext } from "./session-manager.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-export declare function createCalendarTool(sessionKey: string | undefined): any;
+export declare function createCalendarTool(ctx: SessionContext): any;

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

@@ -1,12 +1,12 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { requireSession } from "./session-helper.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-export function createCalendarTool(sessionKey) {
+export function createCalendarTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
     return {
         name: "create_calendar_event",
         label: "Create Calendar Event",
@@ -34,7 +34,6 @@ export function createCalendarTool(sessionKey) {
             required: ["title", "dtStart", "dtEnd"],
         },
         async execute(toolCallId, params) {
-            const session = requireSession(sessionKey);
             // Validate parameters
             if (!params.title || !params.dtStart || !params.dtEnd) {
                 throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
@@ -46,7 +45,7 @@ export function createCalendarTool(sessionKey) {
                 throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
             }
             // Get WebSocket manager
-            const wsManager = getXYWebSocketManager(session.config);
+            const wsManager = getXYWebSocketManager(config);
             // Build CreateCalendarEvent command
             const command = {
                 header: {
@@ -112,10 +111,10 @@ export function createCalendarTool(sessionKey) {
                 wsManager.on("data-event", handler);
                 // Send the command
                 sendCommand({
-                    config: session.config,
-                    sessionId: session.a2aSessionId,
-                    taskId: session.taskId,
-                    messageId: session.messageId,
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
                     command,
                 })
                     .then(() => {

package/dist/src/tools/call-device-tool.d.ts

@@ -1,5 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
 /**
  * call_device_tool - 通用端工具调度器。
  * LLM 必须先通过 get_xxx_tool_schema 获取具体工具 schema，再用本工具执行。
  */
-export declare function createCallDeviceTool(sessionKey: string | undefined): any;
+export declare function createCallDeviceTool(ctx: SessionContext): any;