@wu529778790/open-im 1.9.3-beta.5 → 1.9.3-beta.7

package/dist/adapters/claude-sdk-adapter.d.ts

@@ -15,5 +15,10 @@ export declare class ClaudeSDKAdapter implements ToolAdapter {
      * 清理所有活跃的 SDK 会话和流
      */
     static destroy(): void;
+    /**
+     * Remove a specific session from the in-memory cache and close it.
+     * Useful when the caller knows a session is corrupted.
+     */
+    static removeSession(sessionId: string): void;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }

package/dist/adapters/claude-sdk-adapter.js

@@ -38,6 +38,30 @@ const cleanupInterval = setInterval(() => {
     }
 }, CLEANUP_INTERVAL_MS);
 cleanupInterval.unref(); // 不阻止进程退出
+// Lazy cleanup: check idle sessions periodically during getOrCreateSession calls
+let lazyCleanupCounter = 0;
+const LAZY_CLEANUP_INTERVAL = 10;
+let sessionSeq = 0;
+function lazyCleanupIdleSessions() {
+    lazyCleanupCounter++;
+    if (lazyCleanupCounter % LAZY_CLEANUP_INTERVAL !== 0)
+        return;
+    const now = Date.now();
+    for (const [id, lastUsed] of sessionLastUsed) {
+        if (now - lastUsed > SESSION_IDLE_TTL_MS) {
+            const s = activeSessions.get(id);
+            if (s) {
+                try {
+                    s.close();
+                }
+                catch { /* ignore */ }
+                activeSessions.delete(id);
+            }
+            sessionLastUsed.delete(id);
+            log.info(`Lazy cleanup: idle session ${id} (unused ${Math.round((now - lastUsed) / 60000)}min)`);
+        }
+    }
+}
 // Mutex to serialize process.chdir() calls across concurrent users
 let chdirMutex = Promise.resolve();
 function withChdirMutex(fn) {
@@ -66,6 +90,9 @@ function isAssistant(msg) {
 function isResult(msg) {
     return msg.type === 'result';
 }
+function isSessionCorruptionError(msg) {
+    return /session\s*(not found|expired|corrupt)|no\s*conversation\s*found/i.test(msg);
+}
 /**
  * 获取或创建 SDKSession
  * @param sessionId 已有的 sessionId，如果为 undefined 则创建新会话
@@ -75,6 +102,7 @@ function isResult(msg) {
  * @returns SDKSession 对象和实际的 sessionId
  */
 async function getOrCreateSession(sessionId, workDir, model, permissionMode) {
+    lazyCleanupIdleSessions();
     const resolvedModel = model?.trim() || 'claude-opus-4-5';
     const sessionOptions = {
         model: resolvedModel,
@@ -118,7 +146,7 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode) {
             session = unstable_v2_createSession(sessionOptions);
             // 新会话的 sessionId 需要从第一个消息中获取
             // 暂时返回 undefined，稍后在 init 消息中获取
-            const tempId = `pending-${Date.now()}`;
+            const tempId = `pending-${++sessionSeq}`;
             activeSessions.set(tempId, session);
             sessionLastUsed.set(tempId, Date.now());
             log.info(`Created new session (tempId: ${tempId})`);
@@ -160,6 +188,22 @@ export class ClaudeSDKAdapter {
         activeSessions.clear();
         sessionLastUsed.clear();
     }
+    /**
+     * Remove a specific session from the in-memory cache and close it.
+     * Useful when the caller knows a session is corrupted.
+     */
+    static removeSession(sessionId) {
+        const session = activeSessions.get(sessionId);
+        if (session) {
+            try {
+                session.close();
+            }
+            catch { /* ignore */ }
+            activeSessions.delete(sessionId);
+            sessionLastUsed.delete(sessionId);
+            log.info(`Explicitly removed session: ${sessionId}`);
+        }
+    }
     run(prompt, sessionId, workDir, callbacks, options) {
         log.info(`[V2] run() entry model=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
         const abortController = new AbortController();
@@ -167,6 +211,8 @@ export class ClaudeSDKAdapter {
         let actualSessionId;
         let pendingTempId; // 记录临时 ID，用于 abort 时清理
         let runSettled = false;
+        let currentStream; // 用于 abort 时立即中断 stream
+        let timeoutHandle;
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
             : options?.permissionMode === 'acceptEdits'
@@ -193,6 +239,7 @@ export class ClaudeSDKAdapter {
                 await session.send(prompt);
                 // 获取响应流
                 const stream = session.stream();
+                currentStream = stream;
                 activeStreams.add(stream);
                 let accumulated = '';
                 let accumulatedThinking = '';
@@ -258,10 +305,20 @@ export class ClaudeSDKAdapter {
                             log.info(`[V2] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
                             // 检查会话错误
                             if (!success) {
+                                if (timeoutHandle)
+                                    clearTimeout(timeoutHandle);
                                 runSettled = true;
                                 const noConvErr = errs.find((e) => e.includes('No conversation found') || e.includes('session not found'));
                                 if (noConvErr) {
-                                    log.warn(`Session ${actualSessionId} not found, may need to create new one`);
+                                    log.warn(`Session ${actualSessionId} not found, removing from active sessions`);
+                                    if (actualSessionId) {
+                                        activeSessions.delete(actualSessionId);
+                                        sessionLastUsed.delete(actualSessionId);
+                                        try {
+                                            session.close();
+                                        }
+                                        catch { /* ignore */ }
+                                    }
                                     callbacks.onSessionInvalid?.();
                                 }
                                 const errMsg = errs[0] || '未知错误';
@@ -286,6 +343,8 @@ export class ClaudeSDKAdapter {
                                 result.result = accumulated;
                             }
                             runSettled = true;
+                            if (timeoutHandle)
+                                clearTimeout(timeoutHandle);
                             callbacks.onComplete(result);
                             return;
                         }
@@ -294,6 +353,8 @@ export class ClaudeSDKAdapter {
                     if (!streamClosed) {
                         if (accumulated) {
                             log.info('Stream ended without result message, using accumulated text');
+                            if (timeoutHandle)
+                                clearTimeout(timeoutHandle);
                             runSettled = true;
                             callbacks.onComplete({
                                 success: true,
@@ -308,6 +369,8 @@ export class ClaudeSDKAdapter {
                         else {
                             // 流结束但无 result 也无 accumulated：必须触发回调，否则 Promise 永远挂起
                             log.warn('Stream ended with no result and no accumulated text, calling onError to prevent stuck state');
+                            if (timeoutHandle)
+                                clearTimeout(timeoutHandle);
                             runSettled = true;
                             callbacks.onError('AI 响应异常结束（无输出），请重试');
                         }
@@ -330,6 +393,8 @@ export class ClaudeSDKAdapter {
                     return;
                 }
                 runSettled = true;
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
                 const errorObj = err;
                 const msg = errorObj.message || String(err);
                 log.error(`Claude SDK V2 error: ${msg}`);
@@ -342,6 +407,20 @@ export class ClaudeSDKAdapter {
                     activeSessions.delete(errIdToClean);
                     log.info(`Cleaned up pending session after error: ${errIdToClean}`);
                 }
+                // If error suggests a corrupted session, remove it from cache to prevent reuse
+                if (actualSessionId && isSessionCorruptionError(msg)) {
+                    const corrupted = activeSessions.get(actualSessionId);
+                    activeSessions.delete(actualSessionId);
+                    sessionLastUsed.delete(actualSessionId);
+                    if (corrupted) {
+                        try {
+                            corrupted.close();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    log.warn(`Removed corrupted session ${actualSessionId} after error: ${msg}`);
+                    callbacks.onSessionInvalid?.();
+                }
                 callbacks.onError(msg);
             }
         };
@@ -349,15 +428,45 @@ export class ClaudeSDKAdapter {
         runSession().catch((err) => {
             if (!runSettled) {
                 runSettled = true;
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
                 const msg = err instanceof Error ? err.message : String(err);
                 log.error(`Unhandled runSession error: ${msg}`);
                 callbacks.onError(msg);
             }
         });
+        // 强制执行超时
+        if (options?.timeoutMs && options.timeoutMs > 0) {
+            timeoutHandle = setTimeout(() => {
+                if (!runSettled) {
+                    log.warn(`Session timed out after ${options.timeoutMs}ms, aborting`);
+                    abortController.abort();
+                    // 立即中断 stream，不等下一条消息
+                    if (currentStream) {
+                        try {
+                            currentStream.return?.();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    runSettled = true;
+                    callbacks.onError(`AI 响应超时（${Math.round(options.timeoutMs / 1000)}s），请重试`);
+                }
+            }, options.timeoutMs);
+            timeoutHandle.unref();
+        }
         return {
             abort: () => {
                 log.info('Aborting session run');
                 abortController.abort();
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                // 立即中断 stream，不等下一条消息
+                if (currentStream) {
+                    try {
+                        currentStream.return?.();
+                    }
+                    catch { /* ignore */ }
+                }
             },
         };
     }

package/dist/config.js

@@ -4,7 +4,7 @@ try {
 catch {
     /* dotenv optional */
 }
-import { readFileSync, writeFileSync, accessSync, constants, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, accessSync, constants, existsSync, mkdirSync, statSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { join, dirname, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
@@ -22,6 +22,9 @@ const OLD_ROOT_KEYS = [
     'claudeWorkDir',
     'claudeTimeoutMs', 'claudeModel',
 ];
+// Config cache with mtime tracking
+let cachedConfig = null;
+let cachedClaudeEnv = null;
 function hasOldConfigFormat(raw) {
     const hasOld = OLD_ROOT_KEYS.some((k) => raw[k] !== undefined && raw[k] !== null);
     const hasNew = raw.tools && typeof raw.tools === 'object' && raw.tools.claude;
@@ -78,6 +81,16 @@ function migrateToNewConfigFormat(raw) {
 }
 export function loadFileConfig() {
     try {
+        // Check if file exists and get mtime for cache validation
+        if (!existsSync(CONFIG_PATH))
+            return {};
+        const stats = statSync(CONFIG_PATH);
+        const currentMtime = stats.mtimeMs;
+        // Return cached config if file hasn't changed
+        if (cachedConfig && cachedConfig.mtime === currentMtime) {
+            return cachedConfig.config;
+        }
+        // File changed or no cache, read and parse
         const raw = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
         if (!raw || typeof raw !== 'object')
             return {};
@@ -87,8 +100,12 @@ export function loadFileConfig() {
             if (!existsSync(dir))
                 mkdirSync(dir, { recursive: true });
             writeFileSync(CONFIG_PATH, JSON.stringify(migrated, null, 2), 'utf-8');
+            // Update cache with migrated config
+            cachedConfig = { config: migrated, mtime: currentMtime };
             return migrated;
         }
+        // Update cache
+        cachedConfig = { config: raw, mtime: currentMtime };
         return raw;
     }
     catch {
@@ -100,6 +117,8 @@ export function saveFileConfig(raw) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2), 'utf-8');
+    // Invalidate cache after save (next read will get fresh mtime)
+    cachedConfig = null;
 }
 /** 获取用户主目录（兼容不同运行环境，如 launchd、systemd 等） */
 export function getClaudeConfigHome() {
@@ -114,16 +133,26 @@ export function loadClaudeSettingsEnv() {
     ];
     for (const p of paths) {
         try {
-            const raw = JSON.parse(readFileSync(p, 'utf-8'));
-            const env = raw?.env;
-            if (env && typeof env === 'object') {
-                const result = {};
-                for (const [k, v] of Object.entries(env)) {
-                    if (v != null && typeof k === 'string') {
-                        result[k] = String(v);
+            // Check cache first
+            if (existsSync(p)) {
+                const stats = statSync(p);
+                const currentMtime = stats.mtimeMs;
+                if (cachedClaudeEnv && cachedClaudeEnv.mtime === currentMtime && cachedClaudeEnv.env) {
+                    return cachedClaudeEnv.env;
+                }
+                const raw = JSON.parse(readFileSync(p, 'utf-8'));
+                const env = raw?.env;
+                if (env && typeof env === 'object') {
+                    const result = {};
+                    for (const [k, v] of Object.entries(env)) {
+                        if (v != null && typeof k === 'string') {
+                            result[k] = String(v);
+                        }
                     }
+                    // Update cache
+                    cachedClaudeEnv = { env: result, mtime: currentMtime };
+                    return result;
                 }
-                return result;
             }
         }
         catch {
@@ -156,6 +185,8 @@ export function saveClaudeSettingsEnv(env) {
         existing.env = { ...existing.env, ...env };
         // 写入文件
         writeFileSync(claudeSettingsPath, JSON.stringify(existing, null, 2), 'utf-8');
+        // Invalidate cache after save
+        cachedClaudeEnv = null;
     }
     catch (error) {
         log.error('Failed to save Claude settings:', error);

package/dist/feishu/message-sender.js

@@ -164,9 +164,25 @@ export async function sendErrorCard(cardId, error) {
 // Track if patch API is working for this session
 let patchApiWorking = true;
 let patchFailCount = 0;
+let patchDisabledAt = null; // When patch was disabled
 const MAX_PATCH_FAILURES_BEFORE_DISABLE = 3;
+const PATCH_RECOVERY_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes before retrying
+// Attempt to recover patch API after cooldown period
+function attemptPatchRecovery() {
+    if (!patchApiWorking && patchDisabledAt !== null) {
+        const now = Date.now();
+        if (now - patchDisabledAt >= PATCH_RECOVERY_COOLDOWN_MS) {
+            log.info('Attempting to recover patch API after cooldown period');
+            patchApiWorking = true;
+            patchFailCount = 0;
+            patchDisabledAt = null;
+        }
+    }
+}
 export async function updateMessage(chatId, messageId, content, status, note, toolId = 'claude') {
     const client = getClient();
+    // Try to recover patch API if cooldown period has passed
+    attemptPatchRecovery();
     const title = getToolTitle(toolId, status);
     const cardContent = createFeishuCard(title, content, status, note);
     // Try to use patch API for in-place update (streaming)
@@ -198,6 +214,7 @@ export async function updateMessage(chatId, messageId, content, status, note, to
             if (patchFailCount >= MAX_PATCH_FAILURES_BEFORE_DISABLE) {
                 log.warn('Patch API disabled for this session due to repeated failures');
                 patchApiWorking = false;
+                patchDisabledAt = Date.now();
             }
             // 流式更新时不 fallback 到 delete+create，否则会生成新消息但 caller 仍持旧 msgId，导致后续 patch 全失败并不断创建新消息
             // 直接返回，下次节流周期会重试
@@ -210,6 +227,7 @@ export async function updateMessage(chatId, messageId, content, status, note, to
             if (patchFailCount >= MAX_PATCH_FAILURES_BEFORE_DISABLE) {
                 log.warn('Patch API disabled for this session due to repeated errors');
                 patchApiWorking = false;
+                patchDisabledAt = Date.now();
             }
         }
     }
@@ -219,6 +237,8 @@ export async function updateMessage(chatId, messageId, content, status, note, to
 export async function sendFinalMessages(chatId, messageId, fullContent, note, toolId = 'claude') {
     const client = getClient();
     const parts = splitLongContent(fullContent, MAX_FEISHU_MESSAGE_LENGTH);
+    // Try to recover patch API if cooldown period has passed
+    attemptPatchRecovery();
     // If content fits in one message and patch is working, try patch for smooth transition
     if (parts.length === 1 && patchApiWorking) {
         const cardContent = createFeishuCard(getToolTitle(toolId, 'done'), fullContent, 'done');
@@ -319,6 +339,7 @@ export async function sendImageReply(chatId, imagePath) {
                 Authorization: `Bearer ${token}`,
             },
             body: form,
+            signal: AbortSignal.timeout(60000),
         });
         if (!uploadResp.ok) {
             throw new Error(`Failed to upload image: ${uploadResp.statusText}`);

package/dist/qq/client.js

@@ -48,6 +48,7 @@ async function fetchAccessToken(config) {
             appId: config.qqAppId,
             clientSecret: config.qqSecret,
         }),
+        signal: AbortSignal.timeout(15000),
     });
     const data = (await response.json());
     if (!response.ok || !data.access_token) {
@@ -65,6 +66,7 @@ async function apiRequest(config, method, path, body) {
         method,
         headers: buildAuthHeaders(token),
         body: body ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(15000),
     });
     if (!response.ok) {
         const text = await response.text().catch(() => "");

package/dist/qq/message-sender.js

@@ -9,15 +9,15 @@ const MAX_QQ_MESSAGE_LENGTH = 1500;
 const pendingReplies = new Map();
 // Periodic cleanup of orphaned pending replies
 const PENDING_MAX_AGE_MS = 10 * 60 * 1000; // 10 minutes
+const CLEANUP_INTERVAL_MS = 2 * 60 * 1000; // Check every 2 minutes
 setInterval(() => {
     const now = Date.now();
     for (const [id, state] of pendingReplies) {
-        // pendingReplies don't have timestamps, but we can clear old ones based on size
-        if (pendingReplies.size > 100) {
+        if (now - state.createdAt > PENDING_MAX_AGE_MS) {
             pendingReplies.delete(id);
         }
     }
-}, PENDING_MAX_AGE_MS).unref();
+}, CLEANUP_INTERVAL_MS).unref();
 function parseChatTarget(chatId) {
     if (chatId.startsWith("group:")) {
         return { kind: "group", id: chatId.slice("group:".length) };
@@ -57,7 +57,7 @@ export async function sendImageReply(chatId, imagePath) {
 }
 export async function sendThinkingMessage(chatId, replyToMessageId, _toolId = "claude") {
     const messageId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    pendingReplies.set(messageId, { replyToMessageId });
+    pendingReplies.set(messageId, { replyToMessageId, createdAt: Date.now() });
     return messageId;
 }
 export async function updateMessage(_chatId, _messageId, _content, _status, _note, _toolId = "claude") {

package/dist/session/session-manager.js

@@ -68,16 +68,20 @@ export class SessionManager {
         return undefined;
     }
     setSessionIdForThread(userId, threadId, toolId, sessionId) {
-        const s = this.sessions.get(userId);
-        if (s && !s.threads)
-            s.threads = {};
-        const t = s?.threads?.[threadId];
-        if (t) {
-            if (!t.sessionIds)
-                t.sessionIds = {};
-            t.sessionIds[toolId] = sessionId;
-            this.save();
+        let s = this.sessions.get(userId);
+        if (!s) {
+            s = { workDir: this.defaultWorkDir, activeConvId: randomBytes(4).toString('hex') };
+            this.sessions.set(userId, s);
         }
+        if (!s.threads)
+            s.threads = {};
+        if (!s.threads[threadId])
+            s.threads[threadId] = {};
+        const t = s.threads[threadId];
+        if (!t.sessionIds)
+            t.sessionIds = {};
+        t.sessionIds[toolId] = sessionId;
+        this.save();
     }
     getWorkDir(userId) {
         return this.sessions.get(userId)?.workDir ?? this.defaultWorkDir;
@@ -103,8 +107,9 @@ export class SessionManager {
         const currentDir = this.getWorkDir(userId);
         const realPath = await this.resolveAndValidate(currentDir, workDir);
         const s = this.sessions.get(userId);
+        let oldConvId;
         if (s) {
-            const oldConvId = s.activeConvId;
+            oldConvId = s.activeConvId;
             this.persistActiveConvSessions(userId, s);
             s.workDir = realPath;
             s.sessionIds = {};
@@ -120,7 +125,7 @@ export class SessionManager {
             });
         }
         this.flushSync();
-        log.info(`WorkDir changed for user ${userId}: ${realPath}, oldConvId=${s?.activeConvId}`);
+        log.info(`WorkDir changed for user ${userId}: ${realPath}, oldConvId=${oldConvId}`);
         return realPath;
     }
     /**
@@ -294,8 +299,8 @@ export class SessionManager {
                 }
             }
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            log.warn('Failed to load sessions file, starting with empty state:', err instanceof Error ? err.message : err);
         }
     }
     save() {

package/dist/telegram/message-sender.js

@@ -120,9 +120,7 @@ export async function sendFinalMessages(chatId, messageId, fullContent, note, to
 export async function sendTextReply(chatId, text) {
     const bot = getBot();
     try {
-        await bot.telegram.sendMessage(Number(chatId), formatMessage(text, "done", undefined, OPEN_IM_SYSTEM_TITLE), {
-            parse_mode: "Markdown",
-        });
+        await bot.telegram.sendMessage(Number(chatId), formatMessage(text, "done", undefined, OPEN_IM_SYSTEM_TITLE));
     }
     catch (err) {
         log.error("Failed to send text:", err);

package/dist/wework/event-handler.js

@@ -4,7 +4,7 @@
 import { resolvePlatformAiCommand } from '../config.js';
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
-import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, sendImageReply, startTypingLoop, setCurrentReqId, } from './message-sender.js';
+import { sendThinkingMessage, updateMessage, sendFinalMessages, sendTextReply, sendImageReply, sendDirectorySelection, startTypingLoop, } from './message-sender.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
 import { runAITask } from '../shared/ai-task.js';
@@ -164,97 +164,98 @@ export function setupWeWorkHandlers(config, sessionManager) {
     const requestQueue = new RequestQueue();
     const runningTasks = new Map();
     const stopTaskCleanup = startTaskCleanup(runningTasks);
+    // Mutable ref that captures the req_id of the message currently being handled.
+    // WeWork requires req_id to reply; CommandHandler doesn't carry it, so we inject
+    // it via a closure.  WeWork delivers messages sequentially over WebSocket, so
+    // there is no race condition between concurrent messages from the same bot.
+    const senderCtx = { reqId: '' };
     const commandHandler = new CommandHandler({
         config,
         sessionManager,
         requestQueue,
-        sender: { sendTextReply },
+        sender: {
+            sendTextReply: (chatId, text) => sendTextReply(chatId, text, senderCtx.reqId),
+            sendDirectorySelection: (chatId, currentDir, userId) => sendDirectorySelection(chatId, currentDir, userId, senderCtx.reqId),
+        },
         getRunningTasksSize: () => runningTasks.size,
     });
     async function handleAIRequest(userId, chatId, prompt, workDir, convId, _threadCtx, replyToMessageId, reqId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
-        if (reqId)
-            setCurrentReqId(reqId);
+        const aiCommand = resolvePlatformAiCommand(config, 'wework');
+        const toolAdapter = getAdapter(aiCommand);
+        if (!toolAdapter) {
+            log.error(`[handleAIRequest] No adapter found for: ${aiCommand}`);
+            await sendTextReply(chatId, `AI tool is not configured: ${aiCommand}`, reqId);
+            return;
+        }
+        const sessionId = convId
+            ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
+            : undefined;
+        log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const toolId = aiCommand;
+        let msgId;
         try {
-            const aiCommand = resolvePlatformAiCommand(config, 'wework');
-            const toolAdapter = getAdapter(aiCommand);
-            if (!toolAdapter) {
-                log.error(`[handleAIRequest] No adapter found for: ${aiCommand}`);
-                await sendTextReply(chatId, `AI tool is not configured: ${aiCommand}`, reqId);
-                return;
-            }
-            const sessionId = convId
-                ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
-                : undefined;
-            log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
-            const toolId = aiCommand;
-            let msgId;
+            msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, reqId);
+        }
+        catch (err) {
+            log.error('Failed to send thinking message:', err);
             try {
-                msgId = await sendThinkingMessage(chatId, replyToMessageId, toolId, reqId);
+                await sendTextReply(chatId, '启动 AI 处理失败，请重试。', reqId);
             }
             catch (err) {
-                log.error('Failed to send thinking message:', err);
-                try {
-                    await sendTextReply(chatId, '启动 AI 处理失败，请重试。', reqId);
-                }
-                catch (err) {
-                    log.warn('Failed to send startup error reply:', err);
-                }
-                return;
+                log.warn('Failed to send startup error reply:', err);
             }
-            const stopTyping = startTypingLoop(chatId);
-            const taskKey = `${userId}:${msgId}`;
-            // Safety timeout: abort hung tasks before stream expires, unblocking the queue
-            let safetyTimer = setTimeout(() => {
+            return;
+        }
+        const stopTyping = startTypingLoop(chatId);
+        const taskKey = `${userId}:${msgId}`;
+        // Safety timeout: abort hung tasks before stream expires, unblocking the queue
+        let safetyTimer = setTimeout(() => {
+            safetyTimer = null;
+            const state = runningTasks.get(taskKey);
+            if (state) {
+                log.warn(`[SAFETY_TIMEOUT] Task ${taskKey} exceeded ${WEWORK_TASK_SAFETY_TIMEOUT_MS}ms, aborting`);
+                state.handle.abort();
+                runningTasks.delete(taskKey);
+                stopTyping();
+                sendTextReply(chatId, `AI 处理超时（${Math.round(WEWORK_TASK_SAFETY_TIMEOUT_MS / 1000)}s），已自动取消。请重试。`, reqId).catch(() => { });
+            }
+        }, WEWORK_TASK_SAFETY_TIMEOUT_MS);
+        const clearSafetyTimer = () => {
+            if (safetyTimer) {
+                clearTimeout(safetyTimer);
                 safetyTimer = null;
-                const state = runningTasks.get(taskKey);
-                if (state) {
-                    log.warn(`[SAFETY_TIMEOUT] Task ${taskKey} exceeded ${WEWORK_TASK_SAFETY_TIMEOUT_MS}ms, aborting`);
-                    state.handle.abort();
-                    runningTasks.delete(taskKey);
-                    stopTyping();
-                    sendTextReply(chatId, `AI 处理超时（${Math.round(WEWORK_TASK_SAFETY_TIMEOUT_MS / 1000)}s），已自动取消。请重试。`, reqId).catch(() => { });
+            }
+        };
+        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {
+            throttleMs: WEWORK_THROTTLE_MS,
+            streamUpdate: async (content, toolNote) => {
+                const note = buildProgressNote(toolNote);
+                try {
+                    await updateMessage(chatId, msgId, content, 'streaming', note, toolId, reqId);
                 }
-            }, WEWORK_TASK_SAFETY_TIMEOUT_MS);
-            const clearSafetyTimer = () => {
-                if (safetyTimer) {
-                    clearTimeout(safetyTimer);
-                    safetyTimer = null;
+                catch (err) {
+                    log.debug('Stream update failed:', err);
                 }
-            };
-            await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {
-                throttleMs: WEWORK_THROTTLE_MS,
-                streamUpdate: async (content, toolNote) => {
-                    const note = buildProgressNote(toolNote);
-                    try {
-                        await updateMessage(chatId, msgId, content, 'streaming', note, toolId, reqId);
-                    }
-                    catch (err) {
-                        log.debug('Stream update failed:', err);
-                    }
-                },
-                sendComplete: async (content, note) => {
-                    await sendFinalMessages(chatId, msgId, content, note ?? '', toolId, reqId);
-                },
-                sendError: async (error) => {
-                    await updateMessage(chatId, msgId, `Error: ${error}`, 'error', buildErrorNote(), toolId, reqId);
-                },
-                extraCleanup: () => {
-                    clearSafetyTimer();
-                    stopTyping();
-                    runningTasks.delete(taskKey);
-                },
-                onTaskReady: (state) => {
-                    runningTasks.set(taskKey, state);
-                },
-                sendImage: async (path) => {
-                    await sendImageReply(chatId, path);
-                },
-            });
-        }
-        finally {
-            setCurrentReqId(null);
-        }
+            },
+            sendComplete: async (content, note) => {
+                await sendFinalMessages(chatId, msgId, content, note ?? '', toolId, reqId);
+            },
+            sendError: async (error) => {
+                await updateMessage(chatId, msgId, `Error: ${error}`, 'error', buildErrorNote(), toolId, reqId);
+            },
+            extraCleanup: () => {
+                clearSafetyTimer();
+                stopTyping();
+                runningTasks.delete(taskKey);
+            },
+            onTaskReady: (state) => {
+                runningTasks.set(taskKey, state);
+            },
+            sendImage: async (path) => {
+                await sendImageReply(chatId, path);
+            },
+        });
     }
     async function enqueuePrompt(userId, chatId, prompt, reqId) {
         const workDir = sessionManager.getWorkDir(userId);
@@ -272,7 +273,7 @@ export function setupWeWorkHandlers(config, sessionManager) {
     async function handleEvent(data) {
         log.info('[handleEvent] Called with data:', JSON.stringify(data).slice(0, 800));
         const reqId = data.headers?.req_id ?? '';
-        setCurrentReqId(reqId);
+        senderCtx.reqId = reqId;
         try {
             const body = data.body;
             const msgType = body.msgtype;
@@ -329,9 +330,6 @@ export function setupWeWorkHandlers(config, sessionManager) {
         catch (err) {
             log.error('[handleEvent] Error processing event:', err);
         }
-        finally {
-            setCurrentReqId(null);
-        }
     }
     return {
         stop: () => stopTaskCleanup(),

package/dist/wework/message-sender.d.ts

@@ -2,7 +2,6 @@
  * WeWork (企业微信/WeCom) Message Sender
  * 通过 WebSocket `aibot_respond_msg` 发送消息，并透传 `req_id`
  */
-export declare function setCurrentReqId(reqId: string | null): void;
 type MessageStatus = 'thinking' | 'streaming' | 'done' | 'error';
 /**
  * Send thinking message to WeWork.
@@ -22,7 +21,7 @@ export declare function sendProactiveTextReply(chatId: string, text: string): Pr
  */
 export declare function sendTextReply(chatId: string, text: string, threadCtxOrReqId?: import('../shared/types.js').ThreadContext | string): Promise<void>;
 export declare function sendImageReply(chatId: string, imagePath: string): Promise<void>;
-export declare function sendDirectorySelection(chatId: string, currentDir: string, _userId: string): Promise<void>;
+export declare function sendDirectorySelection(chatId: string, currentDir: string, _userId: string, reqId?: string): Promise<void>;
 export declare function startTypingLoop(_chatId: string): () => void;
 export declare function sendErrorMessage(chatId: string, error: string, reqId?: string): Promise<void>;
 export {};

package/dist/wework/message-sender.js

@@ -14,18 +14,12 @@ import { readFile } from 'node:fs/promises';
 const log = createLogger('WeWorkSender');
 const STREAM_SEND_INTERVAL_MS = 900;
 const STREAM_SAFE_TTL_MS = 5 * 60 * 1000;
-/** 当前同步处理中的 req_id，仅用于 commandHandler 等同步调用。 */
-let currentReqId = null;
-export function setCurrentReqId(reqId) {
-    currentReqId = reqId;
-}
 function getReqId(explicitReqId) {
-    const id = explicitReqId ?? currentReqId;
-    if (!id) {
+    if (!explicitReqId) {
         log.warn('No req_id - cannot send WeWork reply');
         return '';
     }
-    return id;
+    return explicitReqId;
 }
 const STATUS_CONFIG = {
     thinking: { icon: '[thinking]', title: '思考中' },
@@ -300,10 +294,9 @@ export async function sendProactiveTextReply(chatId, text) {
  */
 export async function sendTextReply(chatId, text, threadCtxOrReqId) {
     const message = formatWeWorkMessage(OPEN_IM_SYSTEM_TITLE, text, 'done');
-    const explicitReqId = typeof threadCtxOrReqId === 'string' ? threadCtxOrReqId : undefined;
-    const effectiveReqId = explicitReqId ?? currentReqId;
+    const effectiveReqId = typeof threadCtxOrReqId === 'string' ? threadCtxOrReqId : undefined;
     try {
-        sendText(getReqId(effectiveReqId ?? undefined), message);
+        sendText(getReqId(effectiveReqId), message);
         log.info(`Text reply sent to user ${chatId}`);
     }
     catch (err) {
@@ -332,8 +325,8 @@ export async function sendImageReply(chatId, imagePath) {
         await sendTextReply(chatId, `Generated image saved at: ${imagePath}`);
     }
 }
-export async function sendDirectorySelection(chatId, currentDir, _userId) {
-    await sendTextReply(chatId, buildDirectoryMessage(currentDir));
+export async function sendDirectorySelection(chatId, currentDir, _userId, reqId) {
+    await sendTextReply(chatId, buildDirectoryMessage(currentDir), reqId);
 }
 export function startTypingLoop(_chatId) {
     return () => { };

package/dist/workbuddy/event-handler.js

@@ -20,18 +20,13 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
     const runningTasks = new Map();
     const taskKeyByChatId = new Map();
     const stopTaskCleanup = startTaskCleanup(runningTasks);
-    let currentMsgId = '';
-    const commandHandler = new CommandHandler({
+    // Base dependencies for creating per-event CommandHandler
+    const baseCommandDeps = {
         config,
         sessionManager,
         requestQueue,
-        sender: {
-            sendTextReply: async (chatId, text) => {
-                await sendTextReply(null, chatId, text, currentMsgId);
-            },
-        },
         getRunningTasksSize: () => runningTasks.size,
-    });
+    };
     async function handleAIRequest(userId, chatId, msgId, prompt, workDir, convId) {
         log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
         const aiCommand = resolvePlatformAiCommand(config, 'workbuddy');
@@ -72,7 +67,6 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         });
     }
     async function handleEvent(chatId, msgId, content) {
-        currentMsgId = msgId;
         log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
         // Use chatId as userId for WorkBuddy (WeChat KF doesn't have separate userId)
         const userId = chatId;
@@ -86,6 +80,15 @@ export function setupWorkBuddyHandlers(config, sessionManager) {
         setChatUser(chatId, userId, 'workbuddy');
         const workDir = sessionManager.getWorkDir(userId);
         const convId = sessionManager.getConvId(userId);
+        // Create a per-event CommandHandler with sender that captures msgId for this event
+        const commandHandler = new CommandHandler({
+            ...baseCommandDeps,
+            sender: {
+                sendTextReply: async (c, t) => {
+                    await sendTextReply(null, c, t, msgId);
+                },
+            },
+        });
         // Try command handler first
         try {
             const handled = await commandHandler.dispatch(text, chatId, userId, 'workbuddy', (u, c, p, w, conv, _r, m) => handleAIRequest(u, c, msgId, p, w, conv));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.9.3-beta.5",
+  "version": "1.9.3-beta.7",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",