@ynhcj/xiaoyi-channel 0.0.131-beta → 0.0.132-beta

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

@@ -236,7 +236,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,
@@ -289,34 +289,42 @@ export async function handleXYMessage(params) {
                 unregisterSession(route.sessionKey);
                 log(`[BOT] ✅ Cleanup completed`);
             },
-            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;
-                }
-            }),
+            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 () => {
+                    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;
+                    }
+                });
+                // Signal init complete — sync part (agentTools, wrapStreamFn) is done
+                params.onInitComplete?.();
+                return dispatchPromise;
+            },
         });
         log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);

package/dist/src/monitor.js

@@ -68,6 +68,12 @@ export async function monitorXYProvider(opts = {}) {
     const activeMessages = new Set();
     // Create session queue for ordered message processing
     const enqueue = createSessionQueue();
+    // Global gate that serializes dispatch initialization across sessions.
+    // When a new session starts dispatching, it acquires this gate and holds it
+    // until agent setup (agentTools + wrapStreamFn) is complete, then releases it.
+    // This prevents lastRegisteredKey races when multiple sessions initialize
+    // concurrently.
+    let globalDispatchInitGate = Promise.resolve();
     // Health check interval
     let healthCheckInterval = null;
     return new Promise((resolve, reject) => {
@@ -83,6 +89,11 @@ export async function monitorXYProvider(opts = {}) {
             }
             activeMessages.add(messageKey);
             const task = async () => {
+                // Wait for the previous session's init to complete (global gate),
+                // then acquire the gate for this session's init.
+                await globalDispatchInitGate;
+                let releaseGate;
+                globalDispatchInitGate = new Promise((r) => { releaseGate = r; });
                 try {
                     await handleXYMessage({
                         cfg,
@@ -90,10 +101,12 @@ export async function monitorXYProvider(opts = {}) {
                         message,
                         accountId, // ✅ Pass accountId ("default")
                         webSocketSessionId: sessionId, // ✅ 传递 WebSocket 层级的 sessionId
+                        onInitComplete: () => releaseGate(),
                     });
                 }
                 catch (err) {
                     // ✅ Only log error, don't re-throw to prevent gateway restart
+                    releaseGate();
                     error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
                 }
                 finally {

package/dist/src/provider.js

@@ -9,7 +9,6 @@
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
 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];
@@ -389,6 +388,22 @@ function trimUserMetadata(text) {
     text = text.replace(/\n*Sender \(untrusted metadata\):\n```json\n[\s\S]*?\n```\n*/, "\n");
     return text.replace(/\n{3,}/g, "\n\n");
 }
+/**
+ * Extract A2A taskId and deviceType from Conversation info JSON.
+ * bot.ts stores them as MessageSid = "taskId_deviceType".
+ */
+function extractA2AFromConversationInfo(text) {
+    const match = text.match(/Conversation info \(untrusted metadata\):\n```json\n([\s\S]*?)\n```/);
+    if (!match)
+        return null;
+    const msgIdMatch = match[1].match(/"message_id"\s*:\s*"([^"]+)"/);
+    if (!msgIdMatch)
+        return null;
+    const parts = msgIdMatch[1].split("_");
+    if (parts.length < 2)
+        return null;
+    return { taskId: parts[0], deviceType: parts[1] };
+}
 export const xiaoyiProvider = {
     id: "xiaoyiprovider",
     label: "Xiaoyi Provider",
@@ -443,17 +458,34 @@ export const xiaoyiProvider = {
         const underlying = ctx.streamFn;
         if (!underlying)
             return underlying;
-        // Capture A2A sessionId at agent setup time for multi-session isolation.
-        // 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 = {};
+            // ── Extract A2A taskId/deviceType from Conversation info ──
+            // bot.ts stores taskId_deviceType as MessageSid, which the framework
+            // renders as message_id in the Conversation info JSON block.
+            let extractedTaskId = null;
+            let extractedDeviceType = null;
+            if (context.messages) {
+                for (let i = context.messages.length - 1; i >= 0; i--) {
+                    const msg = context.messages[i];
+                    if (msg.role !== "user")
+                        continue;
+                    const text = typeof msg.content === "string"
+                        ? msg.content
+                        : Array.isArray(msg.content)
+                            ? msg.content.find((b) => b.type === "text")?.text ?? ""
+                            : "";
+                    if (!text)
+                        continue;
+                    const extracted = extractA2AFromConversationInfo(text);
+                    if (extracted) {
+                        extractedTaskId = extracted.taskId;
+                        extractedDeviceType = extracted.deviceType;
+                        break;
+                    }
+                }
+            }
+            // ── Build dynamic headers ────────────────────────────
             if (ctx.extraParams) {
                 const fallbackPrefix = ctx.extraParams[FALLBACK_PREFIX_KEY];
                 if (typeof fallbackPrefix === "string") {
@@ -471,40 +503,30 @@ export const xiaoyiProvider = {
                             dynamicHeaders["x-cron-flag"] = "begin";
                     }
                 }
-                else {
-                    // 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;
-                        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 (extractedTaskId) {
+                    // Session mode: taskId extracted from Conversation info
+                    const traceId = extractedTaskId;
+                    const sessionId = traceId.split("&")[0];
+                    const interactionId = traceId.split("&")[1] ?? "";
+                    const isCron = isCronTriggered(context.messages);
+                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}_${Date.now()}` : traceId;
+                    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";
                     }
+                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
+                }
+                else {
+                    // Fallback: use extraParams cached values
+                    const traceId = ctx.extraParams[HEADER_TRACE_ID];
+                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
+                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                    if (typeof traceId === "string")
+                        dynamicHeaders[HEADER_TRACE_ID] = traceId;
                     if (typeof sessionId === "string")
                         dynamicHeaders[HEADER_SESSION_ID] = sessionId;
                     if (typeof interactionId === "string")
@@ -516,13 +538,11 @@ export const xiaoyiProvider = {
             if (context.systemPrompt) {
                 console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
-            // Prefer deviceType from extraParams (set by prepareExtraParams).
-            // 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.
+            // deviceType: prefer value extracted from Conversation info,
+            // then extraParams, then ALS fallback.
             const extraParamsDeviceType = ctx.extraParams?.[DEVICE_TYPE_KEY] || undefined;
-            const deviceType = extraParamsDeviceType ?? getCurrentSessionContext()?.deviceType;
+            const deviceType = (extractedDeviceType || extraParamsDeviceType)
+                ?? getCurrentSessionContext()?.deviceType;
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;
@@ -555,7 +575,7 @@ export const xiaoyiProvider = {
             const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
             console.log(`[selfEvolution] selfEvolution flag: ${selfEvolutionEnabled}`);
             context.systemPrompt = applySelfEvolutionPrompt(context.systemPrompt, selfEvolutionEnabled);
-            // Append device context to systemPrompt (using pre-captured deviceType from prepareExtraParams)
+            // Append device context to systemPrompt
             if (deviceType) {
                 const displayDevice = (deviceType === "2in1") ? "鸿蒙PC" : deviceType;
                 const deviceSection = `\n\n## Current User Device Context\nThe current user is using the following device: ${displayDevice}\nYou need to be aware of the user's current device and provide guidance accordingly. If the response involves device-related tools or actions, you must tailor the reply based on the user's current device, using device-specific references such as "saved to the Notes/Calendar on your {deviceType}.\n"`;

package/dist/src/tools/session-helper.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tool session helper — provides a simple API for tools to access
+ * the current session context via sessionKey.
+ *
+ * Tools capture `sessionKey` at creation time (may be empty if ALS
+ * was not available at agentTools factory time) and call
+ * `requireSession()` at execute time. If the captured sessionKey
+ * doesn't resolve, we fall back to ALS — the agent run is always
+ * within the ALS context set by bot.ts.
+ */
+import { type XYSession } from "../xy-session-store.js";
+/**
+ * Get the session for a sessionKey, throwing if not found.
+ *
+ * Resolution order:
+ *   1. Closure-captured sessionKey (set at agentTools factory time)
+ *   2. ALS (set by bot.ts before the agent run)
+ *   3. Store enumeration — safe only when a single session is active
+ *
+ * Layers 1 and 2 can both fail: agentTools may be called before ALS is
+ * active, and pi-agent-core tool execute may cross async boundaries that
+ * lose the ALS context.  Layer 3 is the ultimate fallback.
+ */
+export declare function requireSession(sessionKey?: string | null): XYSession;

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

@@ -0,0 +1,45 @@
+/**
+ * Tool session helper — provides a simple API for tools to access
+ * the current session context via sessionKey.
+ *
+ * Tools capture `sessionKey` at creation time (may be empty if ALS
+ * was not available at agentTools factory time) and call
+ * `requireSession()` at execute time. If the captured sessionKey
+ * doesn't resolve, we fall back to ALS — the agent run is always
+ * within the ALS context set by bot.ts.
+ */
+import { getSession, xyAsyncLocalStorage, getAllActiveSessions } from "../xy-session-store.js";
+/**
+ * Get the session for a sessionKey, throwing if not found.
+ *
+ * Resolution order:
+ *   1. Closure-captured sessionKey (set at agentTools factory time)
+ *   2. ALS (set by bot.ts before the agent run)
+ *   3. Store enumeration — safe only when a single session is active
+ *
+ * Layers 1 and 2 can both fail: agentTools may be called before ALS is
+ * active, and pi-agent-core tool execute may cross async boundaries that
+ * lose the ALS context.  Layer 3 is the ultimate fallback.
+ */
+export function requireSession(sessionKey) {
+    // Layer 1: closure-captured sessionKey
+    if (sessionKey) {
+        const session = getSession(sessionKey);
+        if (session)
+            return session;
+    }
+    // Layer 2: ALS (works when the async chain preserves the context)
+    const alsContext = xyAsyncLocalStorage.getStore();
+    const alsKey = alsContext?.openclawSessionKey;
+    if (alsKey) {
+        const session = getSession(alsKey);
+        if (session)
+            return session;
+    }
+    // Layer 3: store enumeration — reliable when only one session is active
+    const allSessions = getAllActiveSessions();
+    if (allSessions.length === 1) {
+        return allSessions[0].session;
+    }
+    throw new Error(`XY session not found (sessionKey=${sessionKey ?? "none"}, alsKey=${alsKey ?? "none"}, activeSessions=${allSessions.length})`);
+}

package/dist/src/tools/session-manager.d.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "async_hooks";
 import type { XYChannelConfig } from "../types.js";
 export interface SessionContext {
     config: XYChannelConfig;
@@ -7,6 +8,12 @@ export interface SessionContext {
     agentId: string;
     deviceType?: string;
 }
+interface SessionContextWithRef extends SessionContext {
+    refCount: number;
+    createdAt: number;
+}
+export declare const activeSessions: Map<string, SessionContextWithRef>;
+export declare const asyncLocalStorage: AsyncLocalStorage<SessionContext>;
 /**
  * Register a session context for tool access.
  * Should be called when starting to process a message.
@@ -58,3 +65,4 @@ export declare function cleanupStaleSessions(): number;
  * Get the current number of active sessions (for diagnostics).
  */
 export declare function getActiveSessionCount(): number;
+export {};

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

@@ -18,7 +18,7 @@ const _g = globalThis;
 if (!_g.__xyActiveSessions) {
     _g.__xyActiveSessions = new Map();
 }
-const activeSessions = _g.__xyActiveSessions;
+export const activeSessions = _g.__xyActiveSessions;
 // Track the most recently registered sessionKey for reliable fallback
 // when AsyncLocalStorage context is lost across openclaw's embedded runner boundary.
 if (!_g.__xyLastRegisteredSessionKey) {
@@ -27,7 +27,7 @@ if (!_g.__xyLastRegisteredSessionKey) {
 const getLastRegisteredKey = () => _g.__xyLastRegisteredSessionKey;
 const setLastRegisteredKey = (key) => { _g.__xyLastRegisteredSessionKey = key; };
 // AsyncLocalStorage for thread-safe session context isolation
-const asyncLocalStorage = new AsyncLocalStorage();
+export const asyncLocalStorage = new AsyncLocalStorage();
 /**
  * Register a session context for tool access.
  * Should be called when starting to process a message.

package/dist/src/xy-session-store.d.ts

@@ -0,0 +1,79 @@
+/**
+ * XYSessionStore — unified session state management.
+ *
+ * Replaces the old session-manager.ts + task-manager.ts + tool-context.ts
+ * with a single Map<sessionKey, XYSession>.
+ *
+ * Design:
+ *   - Closures in tools/providers capture only `sessionKey` (a string).
+ *   - Actual values (taskId, messageId, …) are looked up at execution time
+ *     so steer-mode updates are always visible.
+ *   - No refCount / lock — cleanup is driven by onSettled callbacks.
+ *   - globalThis protection guards against duplicate module instances.
+ */
+import type { XYChannelConfig } from "./types.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface XYSession {
+    config: XYChannelConfig;
+    /** A2A protocol sessionId — identifies the conversation. */
+    a2aSessionId: string;
+    /** A2A taskId — updated in-place on steer. */
+    taskId: string;
+    /** A2A messageId — updated in-place on steer. */
+    messageId: string;
+    /** Device type (phone / tablet / 2in1). */
+    deviceType?: string;
+    /** OpenClaw accountId from route resolution ("default"). */
+    accountId: string;
+}
+export interface XYSessionALSContext {
+    openclawSessionKey: string;
+}
+export declare const xyAsyncLocalStorage: AsyncLocalStorage<XYSessionALSContext>;
+/**
+ * Register or update a session.
+ * Called from bot.ts after resolveAgentRoute().
+ */
+export declare function registerSession(sessionKey: string, session: XYSession): void;
+/**
+ * Update specific fields of an active session (used for steer).
+ */
+export declare function updateSession(sessionKey: string, partial: Partial<Pick<XYSession, "taskId" | "messageId" | "deviceType">>): void;
+/**
+ * Get session by OpenClaw sessionKey.
+ * Returns null if not found.
+ */
+export declare function getSession(sessionKey: string): XYSession | null;
+/**
+ * Get session by A2A sessionId.
+ * Used by provider.ts which only knows the A2A sessionId.
+ */
+export declare function getSessionByA2AId(a2aSessionId: string): XYSession | null;
+/**
+ * Unregister a session. Called from onSettled / error cleanup.
+ */
+export declare function unregisterSession(sessionKey: string): void;
+/**
+ * Check whether a session has an active task (used for steer detection).
+ */
+export declare function hasActiveSession(sessionKey: string): boolean;
+/**
+ * Get all active sessions (for gateway stop / diagnostics).
+ */
+export declare function getAllActiveSessions(): Array<{
+    sessionKey: string;
+    session: XYSession;
+}>;
+/**
+ * Get count of active sessions.
+ */
+export declare function getActiveSessionCount(): number;
+/**
+ * Force-clean all sessions (gateway shutdown / reload).
+ */
+export declare function cleanupAllSessions(): void;
+/**
+ * Clean up stale sessions (older than TTL).
+ * Returns number of cleaned sessions.
+ */
+export declare function cleanupStaleSessions(ttlMs?: number): number;

package/dist/src/xy-session-store.js

@@ -0,0 +1,153 @@
+import { logger } from "./utils/logger.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+// ── AsyncLocalStorage ─────────────────────────────────────────
+// Used by bot.ts to carry sessionKey through the agent run so
+// channel.ts agentTools factory can read it.
+export const xyAsyncLocalStorage = new AsyncLocalStorage();
+const STORE_KEY = "__xySessionStore";
+const A2A_INDEX_KEY = "__xyA2ASessionIndex";
+const _g = globalThis;
+function getStore() {
+    if (!_g[STORE_KEY]) {
+        _g[STORE_KEY] = new Map();
+    }
+    return _g[STORE_KEY];
+}
+/** Reverse index: a2aSessionId → openclawSessionKey (for provider lookups). */
+function getA2AIndex() {
+    if (!_g[A2A_INDEX_KEY]) {
+        _g[A2A_INDEX_KEY] = new Map();
+    }
+    return _g[A2A_INDEX_KEY];
+}
+// ── API ───────────────────────────────────────────────────────
+/**
+ * Register or update a session.
+ * Called from bot.ts after resolveAgentRoute().
+ */
+export function registerSession(sessionKey, session) {
+    const store = getStore();
+    const a2aIndex = getA2AIndex();
+    const existing = store.get(sessionKey);
+    if (existing) {
+        // Update in place — steer mode
+        existing.taskId = session.taskId;
+        existing.messageId = session.messageId;
+        existing.deviceType = session.deviceType;
+        existing.createdAt = Date.now();
+        logger.log(`[SESSION-STORE] update: sessionKey=${sessionKey} a2a=${session.a2aSessionId} taskId=${session.taskId}`);
+    }
+    else {
+        store.set(sessionKey, { ...session, createdAt: Date.now() });
+        a2aIndex.set(session.a2aSessionId, sessionKey);
+        logger.log(`[SESSION-STORE] register: sessionKey=${sessionKey} a2a=${session.a2aSessionId} taskId=${session.taskId}`);
+    }
+}
+/**
+ * Update specific fields of an active session (used for steer).
+ */
+export function updateSession(sessionKey, partial) {
+    const store = getStore();
+    const entry = store.get(sessionKey);
+    if (!entry) {
+        logger.log(`[SESSION-STORE] update skipped: sessionKey=${sessionKey} not found`);
+        return;
+    }
+    if (partial.taskId !== undefined)
+        entry.taskId = partial.taskId;
+    if (partial.messageId !== undefined)
+        entry.messageId = partial.messageId;
+    if (partial.deviceType !== undefined)
+        entry.deviceType = partial.deviceType;
+    logger.log(`[SESSION-STORE] update: sessionKey=${sessionKey} taskId=${entry.taskId}`);
+}
+/**
+ * Get session by OpenClaw sessionKey.
+ * Returns null if not found.
+ */
+export function getSession(sessionKey) {
+    const store = getStore();
+    const entry = store.get(sessionKey);
+    if (!entry)
+        return null;
+    // Strip internal fields
+    const { createdAt, ...session } = entry;
+    return session;
+}
+/**
+ * Get session by A2A sessionId.
+ * Used by provider.ts which only knows the A2A sessionId.
+ */
+export function getSessionByA2AId(a2aSessionId) {
+    const a2aIndex = getA2AIndex();
+    const sessionKey = a2aIndex.get(a2aSessionId);
+    if (!sessionKey)
+        return null;
+    return getSession(sessionKey);
+}
+/**
+ * Unregister a session. Called from onSettled / error cleanup.
+ */
+export function unregisterSession(sessionKey) {
+    const store = getStore();
+    const a2aIndex = getA2AIndex();
+    const entry = store.get(sessionKey);
+    if (!entry)
+        return;
+    a2aIndex.delete(entry.a2aSessionId);
+    store.delete(sessionKey);
+    logger.log(`[SESSION-STORE] unregister: sessionKey=${sessionKey}`);
+}
+/**
+ * Check whether a session has an active task (used for steer detection).
+ */
+export function hasActiveSession(sessionKey) {
+    return getStore().has(sessionKey);
+}
+/**
+ * Get all active sessions (for gateway stop / diagnostics).
+ */
+export function getAllActiveSessions() {
+    const store = getStore();
+    const result = [];
+    for (const [key, entry] of store) {
+        const { createdAt, ...session } = entry;
+        result.push({ sessionKey: key, session });
+    }
+    return result;
+}
+/**
+ * Get count of active sessions.
+ */
+export function getActiveSessionCount() {
+    return getStore().size;
+}
+/**
+ * Force-clean all sessions (gateway shutdown / reload).
+ */
+export function cleanupAllSessions() {
+    getStore().clear();
+    getA2AIndex().clear();
+    logger.log("[SESSION-STORE] all sessions cleaned up");
+}
+/**
+ * Clean up stale sessions (older than TTL).
+ * Returns number of cleaned sessions.
+ */
+export function cleanupStaleSessions(ttlMs = 60 * 60 * 1000) {
+    const store = getStore();
+    const a2aIndex = getA2AIndex();
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, entry] of store) {
+        if (now - entry.createdAt > ttlMs) {
+            a2aIndex.delete(entry.a2aSessionId);
+            store.delete(key);
+            cleaned++;
+        }
+    }
+    if (cleaned > 0) {
+        logger.log(`[SESSION-STORE] cleaned ${cleaned} stale session(s)`);
+    }
+    return cleaned;
+}

package/package.json

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