@wu529778790/open-im 1.11.1-beta.7 → 1.11.1-beta.8

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

@@ -1,12 +1,10 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK query() API 实现多轮对话
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
- *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * query() API:
+ * - 返回 AsyncGenerator<SDKMessage>，直接迭代即可
+ * - 支持 resume/cwd/model 等 options，无需 process.chdir hack
+ * - SDK 内部管理 session 生命周期，无需手动维护 session pool
  */
 import type { SDKSessionInfo } from '@anthropic-ai/claude-agent-sdk';
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
@@ -18,27 +16,16 @@ interface ClaudeSessionMeta {
 }
 /**
  * Find the latest CLI session for a work directory using the SDK's listSessions.
- * Falls back to undefined if no sessions found.
  */
 export declare function findLatestClaudeSession(workDir: string): Promise<ClaudeSessionMeta | undefined>;
-/**
- * 由 initAdapters 根据配置调用。ttlMinutes≤0 时关闭空闲回收（仍受 MAX_ACTIVE_SESSIONS 限制）。
- */
-export declare function configureClaudeSdkSessionIdle(ttlMinutes: number): void;
 export declare class ClaudeSDKAdapter implements ToolAdapter {
     readonly toolId = "claude-sdk";
     /**
-     * 清理所有活跃的 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;
     /**
      * List sessions for a directory using the SDK's listSessions API.
-     * Replaces the custom file-scanning logic in findLatestClaudeSession.
      */
     static listSessionsForDir(workDir: string, limit?: number): Promise<SDKSessionInfo[]>;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;

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

@@ -1,14 +1,12 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK query() API 实现多轮对话
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
- *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * query() API:
+ * - 返回 AsyncGenerator<SDKMessage>，直接迭代即可
+ * - 支持 resume/cwd/model 等 options，无需 process.chdir hack
+ * - SDK 内部管理 session 生命周期，无需手动维护 session pool
  */
-import { unstable_v2_createSession, unstable_v2_resumeSession, listSessions } from '@anthropic-ai/claude-agent-sdk';
+import { query, listSessions } from '@anthropic-ai/claude-agent-sdk';
 import { existsSync, readFileSync, statSync, openSync, readSync, closeSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
@@ -53,8 +51,6 @@ loadUserPluginSettings();
  * ~/.claude/projects/-Users-mac-github-open-im/
  */
 function workDirToProjectPath(workDir) {
-    // Claude Code 将路径中的 / 替换为 -，leading - 保留
-    // /Users/mac/github/open-im → -Users-mac-github-open-im
     return workDir.replace(/\//g, '-');
 }
 /**
@@ -71,14 +67,9 @@ function workDirToProjectPath(workDir) {
  */
 function isCliSessionActive(sessionId, sessionFilePath) {
     try {
-        // macOS/Linux: 用 ps 搜索包含该 sessionId 的 claude 进程
-        // 排除 open-im 自己的 SDK 子进程（路径含 claude-agent-sdk），只匹配用户交互式 CLI
-        // -F 固定字符串匹配，避免正则意外；-- 防止 sessionId 被误认为 flag
         const result = execSync(`ps -axo pid,command 2>/dev/null | grep -v grep | grep "claude" | grep -v "claude-agent-sdk" | grep -F -- "${sessionId}" || true`, { encoding: 'utf-8', timeout: 3000 });
         if (result.trim().length === 0)
             return false;
-        // 进程存在，但可能只是 idle 在终端等输入。检查文件 mtime：
-        // 如果 session 文件超过 30 秒未修改，说明 CLI 没在活跃处理。
         if (sessionFilePath) {
             try {
                 const stat = statSync(sessionFilePath);
@@ -100,7 +91,6 @@ function isCliSessionActive(sessionId, sessionFilePath) {
 }
 /**
  * Find the latest CLI session for a work directory using the SDK's listSessions.
- * Falls back to undefined if no sessions found.
  */
 export async function findLatestClaudeSession(workDir) {
     try {
@@ -110,7 +100,6 @@ export async function findLatestClaudeSession(workDir) {
             return undefined;
         }
         const latest = sessions[0];
-        // filePath is needed for isCliSessionActive check — derive from standard path
         const projectDir = join(homedir(), '.claude', 'projects', workDirToProjectPath(workDir));
         const filePath = join(projectDir, `${latest.sessionId}.jsonl`);
         log.info(`Found latest session via SDK: ${latest.sessionId} (lastModified: ${new Date(latest.lastModified).toISOString()})`);
@@ -156,104 +145,6 @@ function validateSessionFile(filePath, expectedSessionId) {
         }
     }
 }
-// 存储所有活跃的 SDKSession 对象，key 为 sessionId
-// 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
-const activeSessions = new Map();
-// 记录每个 session 创建/恢复时的 workDir，防止跨 workDir 复用已固定 cwd 的子进程
-const sessionWorkDirs = new Map();
-// 存储正在进行的流式迭代器，用于中断
-const activeStreams = new Set();
-// 空闲会话清理：跟踪最后使用时间，定期清除超时会话
-const sessionLastUsed = new Map();
-// 跟踪正在执行任务的 session ID，防止空闲清理误杀运行中的长任务
-const runningSessions = new Set();
-let sessionIdleTtlMs = 30 * 60 * 1000; // 默认 30 分钟未使用则清理
-let sessionIdleCleanupDisabled = false;
-const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 每 5 分钟检查一次
-const MAX_ACTIVE_SESSIONS = 100;
-const MAX_CAPTURED_STDERR_CHARS = 4000;
-const MAX_EXPOSED_STDERR_CHARS = 500;
-let sessionSeq = 0;
-/**
- * 由 initAdapters 根据配置调用。ttlMinutes≤0 时关闭空闲回收（仍受 MAX_ACTIVE_SESSIONS 限制）。
- */
-export function configureClaudeSdkSessionIdle(ttlMinutes) {
-    if (ttlMinutes <= 0) {
-        sessionIdleCleanupDisabled = true;
-        log.info('Claude SDK: idle session cleanup disabled (sessionIdleTtlMinutes=0)');
-    }
-    else {
-        sessionIdleCleanupDisabled = false;
-        sessionIdleTtlMs = ttlMinutes * 60 * 1000;
-    }
-}
-const cleanupInterval = setInterval(() => {
-    if (sessionIdleCleanupDisabled)
-        return;
-    const now = Date.now();
-    for (const [id, lastUsed] of sessionLastUsed) {
-        if (runningSessions.has(id))
-            continue; // 跳过正在运行任务的 session
-        if (now - lastUsed > sessionIdleTtlMs) {
-            const session = activeSessions.get(id);
-            if (session) {
-                try {
-                    session.close();
-                }
-                catch { /* ignore */ }
-                activeSessions.delete(id);
-            }
-            sessionLastUsed.delete(id);
-            sessionWorkDirs.delete(id);
-            log.info(`Cleaned up idle session (unused ${Math.round((now - lastUsed) / 60000)}min): ${id}`);
-        }
-    }
-}, CLEANUP_INTERVAL_MS);
-cleanupInterval.unref(); // 不阻止进程退出
-/**
- * 串行化进程级 process.chdir() —— 同一时刻仅一个 chdir 生效。
- *
- * SDK V2 的 createSession/resumeSession 不接受 cwd 参数；且 send()/stream()
- * 会以「调用时的 process.cwd()」派生 Claude Code 子进程。必须用互斥锁串行化
- * 「整个 turn 的 cwd 切换」，否则并发多用户会让工具跑错目录。
- *
- * **TODO:** SDK 支持 cwd 选项后移除此锁。upstream:
- * https://github.com/anthropics/claude-agent-sdk/issues
- */
-let chdirMutex = Promise.resolve();
-function withChdirMutex(fn) {
-    const previous = chdirMutex;
-    let release;
-    chdirMutex = new Promise((r) => { release = r; });
-    return previous.then(async () => {
-        try {
-            return await fn();
-        }
-        finally {
-            release();
-        }
-    });
-}
-/**
- * 在持有全局 chdir 互斥锁期间，把进程 cwd 切到 workDir 执行 fn，结束后恢复。
- * 用于包裹 session.send()+stream()，确保子进程在正确 workDir 派生。
- */
-function runWithWorkDir(workDir, fn) {
-    return withChdirMutex(async () => {
-        const originalCwd = process.cwd();
-        if (workDir && workDir !== originalCwd) {
-            process.chdir(workDir);
-        }
-        try {
-            return await fn();
-        }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-    });
-}
 function isStreamEvent(msg) {
     return msg.type === 'stream_event';
 }
@@ -270,6 +161,8 @@ function isResult(msg) {
 function isSessionCorruptionError(msg) {
     return /session\s*(not found|expired|corrupt)|no\s*conversation\s*found/i.test(msg);
 }
+const MAX_CAPTURED_STDERR_CHARS = 4000;
+const MAX_EXPOSED_STDERR_CHARS = 500;
 function appendStderrSnippet(previous, chunk) {
     const next = previous + chunk;
     if (next.length <= MAX_CAPTURED_STDERR_CHARS)
@@ -299,161 +192,17 @@ function enrichClaudeErrorMessage(message, stderr) {
     }
     return message;
 }
-/**
- * 获取或创建 SDKSession
- * @param sessionId 已有的 sessionId，如果为 undefined 则创建新会话
- * @param workDir 工作目录
- * @param model 模型名称
- * @param permissionMode 权限模式
- * @returns SDKSession 对象和实际的 sessionId
- */
-async function getOrCreateSession(sessionId, workDir, model, permissionMode, onStderr) {
-    // 刷新 Claude 环境变量（支持 cc switch 后无需重启即可生效）
-    refreshClaudeEnvToProcess();
-    const resolvedModel = model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
-    if (activeSessions.size >= MAX_ACTIVE_SESSIONS) {
-        throw new Error(`Session pool is full (${MAX_ACTIVE_SESSIONS}). Cannot create new session.`);
-    }
-    const sessionOptions = {
-        model: resolvedModel,
-        permissionMode,
-        stderr: onStderr,
-    };
-    const baseUrl = process.env.ANTHROPIC_BASE_URL ?? '(default)';
-    log.info(`[V2] getOrCreateSession model param=${String(model ?? '')} resolved=${resolvedModel} baseUrl=${baseUrl} workDir=${workDir}`);
-    // NOTE: process.chdir() 是进程级全局副作用，在并发服务器中不理想。
-    // 但 SDK 的 createSession/resumeSession 不接受 cwd 参数，且这些调用是同步的，
-    // 所以 mutex + try/finally 已是最优方案。如果 SDK 未来支持 cwd 选项，应移除 chdir。
-    return withChdirMutex(async () => {
-        let session;
-        const originalCwd = process.cwd();
-        try {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(workDir);
-            }
-            if (sessionId) {
-                // 优先复用内存中已有的 SDKSession，避免每次都启动新进程。
-                // 仅当 workDir 与创建时一致才复用：否则子进程 cwd 已固定在旧目录，
-                // 需走 resume 重新派生（在当前 workDir 启动新子进程）。
-                const existing = activeSessions.get(sessionId);
-                if (existing && sessionWorkDirs.get(sessionId) === workDir) {
-                    log.info(`Reusing existing in-memory session: ${sessionId}`);
-                    sessionLastUsed.set(sessionId, Date.now());
-                    return { session: existing, sessionId };
-                }
-                // 内存中没有（或 workDir 变了），尝试通过 resume 恢复（会启动新 CLI 进程）
-                try {
-                    log.info(`Attempting to resume session: ${sessionId}`);
-                    session = unstable_v2_resumeSession(sessionId, sessionOptions);
-                    activeSessions.set(sessionId, session);
-                    sessionWorkDirs.set(sessionId, workDir);
-                    sessionLastUsed.set(sessionId, Date.now());
-                    log.info(`Successfully resumed session: ${sessionId}`);
-                    return { session, sessionId };
-                }
-                catch (err) {
-                    log.warn(`Failed to resume session ${sessionId}, creating new one: ${err}`);
-                    // 恢复失败，创建新会话
-                }
-            }
-            // 没有指定 sessionId 时，尝试自动恢复 Claude Code CLI 的最新 session
-            // 实现手机/电脑无缝切换：同目录下默认共享同一个对话
-            if (!sessionId) {
-                const latest = await findLatestClaudeSession(workDir);
-                if (latest) {
-                    // 检测 CLI 是否正在使用该 session（用于日志，不阻止 resume）
-                    const cliActive = isCliSessionActive(latest.sessionId, latest.filePath);
-                    if (cliActive) {
-                        log.info(`CLI is actively using session ${latest.sessionId}, attempting resume anyway (SDK handles concurrency)`);
-                    }
-                    // 验证文件内容一致性
-                    if (validateSessionFile(latest.filePath, latest.sessionId)) {
-                        try {
-                            log.info(`Auto-resuming latest CLI session: ${latest.sessionId}${cliActive ? ' (CLI active)' : ''}`);
-                            session = unstable_v2_resumeSession(latest.sessionId, sessionOptions);
-                            activeSessions.set(latest.sessionId, session);
-                            sessionWorkDirs.set(latest.sessionId, workDir);
-                            sessionLastUsed.set(latest.sessionId, Date.now());
-                            log.info(`Successfully auto-resumed CLI session: ${latest.sessionId}`);
-                            return { session, sessionId: latest.sessionId };
-                        }
-                        catch (err) {
-                            log.warn(`Failed to auto-resume CLI session ${latest.sessionId}, creating new one: ${err}`);
-                        }
-                    }
-                    else {
-                        log.warn(`Session file validation failed for ${latest.sessionId}, skipping`);
-                    }
-                }
-            }
-            // 创建新会话
-            session = unstable_v2_createSession(sessionOptions);
-            // 新会话的 sessionId 需要从第一个消息中获取
-            // 暂时返回 undefined，稍后在 init 消息中获取
-            const tempId = `pending-${++sessionSeq}`;
-            activeSessions.set(tempId, session);
-            sessionWorkDirs.set(tempId, workDir);
-            sessionLastUsed.set(tempId, Date.now());
-            log.info(`Created new session (tempId: ${tempId})`);
-            return { session, sessionId: tempId, wasReused: false };
-        }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-    });
-}
 export class ClaudeSDKAdapter {
     toolId = 'claude-sdk';
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * 清理所有活跃的查询
      */
     static destroy() {
-        clearInterval(cleanupInterval);
-        for (const stream of activeStreams) {
-            try {
-                if (stream && typeof stream.return === 'function') {
-                    stream.return();
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        activeStreams.clear();
-        for (const session of activeSessions.values()) {
-            try {
-                session.close();
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        activeSessions.clear();
-        sessionLastUsed.clear();
-        sessionWorkDirs.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);
-            sessionWorkDirs.delete(sessionId);
-            log.info(`Explicitly removed session: ${sessionId}`);
-        }
+        // query() API 的 Query 对象通过 abortController.abort() 清理
+        // 不再需要手动管理 session pool
     }
     /**
      * List sessions for a directory using the SDK's listSessions API.
-     * Replaces the custom file-scanning logic in findLatestClaudeSession.
      */
     static async listSessionsForDir(workDir, limit = 20) {
         try {
@@ -465,13 +214,10 @@ export class ClaudeSDKAdapter {
         }
     }
     run(prompt, sessionId, workDir, callbacks, options) {
-        log.info(`[V2] run() entry model=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
+        // 刷新 Claude 环境变量（支持 cc switch 后无需重启即可生效）
+        refreshClaudeEnvToProcess();
         const abortController = new AbortController();
-        let streamClosed = false;
-        let actualSessionId;
-        let pendingTempId; // 记录临时 ID，用于 abort 时清理
         let runSettled = false;
-        let currentStream; // 用于 abort 时立即中断 stream
         let recentStderr = '';
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
@@ -480,79 +226,64 @@ export class ClaudeSDKAdapter {
                 : options?.permissionMode === 'plan'
                     ? 'plan'
                     : 'default';
-        const runSession = async () => {
-            let trackedRunningId; // 用于 finally 中清理 runningSessions
+        const resolvedModel = options?.model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
+        const baseUrl = process.env.ANTHROPIC_BASE_URL ?? '(default)';
+        log.info(`[query] run() entry model=${resolvedModel} baseUrl=${baseUrl} sessionId=${sessionId ?? 'new'} workDir=${workDir}`);
+        const runQuery = async () => {
+            let accumulated = '';
+            let accumulatedThinking = '';
+            const toolStats = {};
+            let actualSessionId;
+            let hadSessionInvalid = false;
             try {
-                // 检查环境变量
-                const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-                const hasAuthToken = !!process.env.ANTHROPIC_AUTH_TOKEN;
-                if (!hasApiKey && !hasAuthToken) {
-                    log.warn('Claude SDK: No API credentials found in environment variables');
-                }
-                log.info(`[V2] Session: ${sessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
-                log.info(`[V2] model param=${String(options?.model ?? '')} baseUrl=${process.env.ANTHROPIC_BASE_URL ?? '(default)'}`);
-                // 获取或创建会话
-                const { session, sessionId: returnedId } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode, (data) => {
-                    recentStderr = appendStderrSnippet(recentStderr, data);
-                });
-                if (returnedId.startsWith('pending-')) {
-                    pendingTempId = returnedId;
+                // 先尝试自动恢复 CLI 的最新 session（如果用户没有指定 sessionId）
+                let resumeId = sessionId;
+                if (!resumeId) {
+                    const latest = await findLatestClaudeSession(workDir);
+                    if (latest) {
+                        const cliActive = isCliSessionActive(latest.sessionId, latest.filePath);
+                        if (cliActive) {
+                            log.info(`CLI is actively using session ${latest.sessionId}, attempting resume anyway`);
+                        }
+                        if (validateSessionFile(latest.filePath, latest.sessionId)) {
+                            resumeId = latest.sessionId;
+                            log.info(`Auto-resuming latest CLI session: ${latest.sessionId}${cliActive ? ' (CLI active)' : ''}`);
+                        }
+                        else {
+                            log.warn(`Session file validation failed for ${latest.sessionId}, skipping`);
+                        }
+                    }
                 }
-                runningSessions.add(returnedId);
-                trackedRunningId = returnedId;
-                // 在持有 chdir 锁期间完成 send() + stream() 获取：SDK V2 会以当前
-                // process.cwd() 派生 Claude Code 子进程，必须保证此刻 cwd 为 workDir。
-                // 锁串行化后，并发多用户的子进程不会在错误的目录派生。
-                const stream = await runWithWorkDir(workDir, async () => {
-                    await session.send(prompt);
-                    const s = session.stream();
-                    currentStream = s;
-                    activeStreams.add(s);
-                    return s;
+                const q = query({
+                    prompt,
+                    options: {
+                        cwd: workDir,
+                        model: resolvedModel,
+                        permissionMode,
+                        ...(resumeId ? { resume: resumeId } : {}),
+                        abortController,
+                        stderr: (data) => {
+                            recentStderr = appendStderrSnippet(recentStderr, data);
+                        },
+                    },
                 });
-                let accumulated = '';
-                let accumulatedThinking = '';
-                const toolStats = {};
                 try {
-                    for await (const msg of stream) {
+                    for await (const msg of q) {
                         if (abortController.signal.aborted) {
-                            log.info('Stream aborted by user');
+                            log.info('Query aborted by user');
                             break;
                         }
                         // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
                             const initMsg = msg;
-                            // 记录 session 加载的插件和技能
                             const pluginNames = initMsg.plugins?.map(p => p.name).join(', ') ?? 'none';
                             const skillCount = initMsg.skills?.length ?? 0;
                             const toolCount = initMsg.tools?.length ?? 0;
-                            log.info(`[V2] Init: plugins=[${pluginNames}], skills=${skillCount}, tools=${toolCount}`);
-                            const newSessionId = initMsg.session_id;
-                            if (newSessionId && newSessionId !== actualSessionId) {
-                                // 更新 sessionId 映射
-                                // 清理 pending 临时 ID（actualSessionId 尚未赋值时用 pendingTempId）
-                                const idToClean = actualSessionId ?? pendingTempId;
-                                const inheritedWorkDir = idToClean ? sessionWorkDirs.get(idToClean) : undefined;
-                                if (idToClean?.startsWith('pending-')) {
-                                    activeSessions.delete(idToClean);
-                                }
-                                activeSessions.set(newSessionId, session);
-                                if (inheritedWorkDir !== undefined) {
-                                    sessionWorkDirs.set(newSessionId, inheritedWorkDir);
-                                }
-                                sessionLastUsed.set(newSessionId, Date.now());
-                                if (idToClean) {
-                                    sessionLastUsed.delete(idToClean);
-                                    sessionWorkDirs.delete(idToClean);
-                                }
-                                // 更新 runningSessions：移除旧 ID，添加新 ID
-                                if (idToClean)
-                                    runningSessions.delete(idToClean);
-                                runningSessions.add(newSessionId);
-                                trackedRunningId = newSessionId;
-                                actualSessionId = newSessionId;
-                                log.info(`[V2] Got actual sessionId: ${newSessionId}`);
-                                callbacks.onSessionId?.(newSessionId);
+                            log.info(`[query] Init: plugins=[${pluginNames}], skills=${skillCount}, tools=${toolCount}`);
+                            if (initMsg.session_id) {
+                                actualSessionId = initMsg.session_id;
+                                log.info(`[query] Got sessionId: ${actualSessionId}`);
+                                callbacks.onSessionId?.(actualSessionId);
                             }
                             continue;
                         }
@@ -584,25 +315,21 @@ export class ClaudeSDKAdapter {
                         }
                         // 处理结果消息
                         if (isResult(msg)) {
-                            streamClosed = true;
                             const m = msg;
                             const success = m.subtype === 'success';
                             const errs = m.errors ?? [];
-                            log.info(`[V2] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
-                            // 检查会话错误
+                            // 更新 sessionId（如果 init 消息中没有）
+                            if (m.session_id && !actualSessionId) {
+                                actualSessionId = m.session_id;
+                                callbacks.onSessionId?.(actualSessionId);
+                            }
+                            log.info(`[query] Result: subtype=${m.subtype}, num_turns=${m.num_turns}, sessionId=${actualSessionId ?? 'unknown'}`);
                             if (!success) {
                                 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, removing from active sessions`);
-                                    if (actualSessionId) {
-                                        activeSessions.delete(actualSessionId);
-                                        sessionLastUsed.delete(actualSessionId);
-                                        try {
-                                            session.close();
-                                        }
-                                        catch { /* ignore */ }
-                                    }
+                                    log.warn(`Session ${actualSessionId} not found`);
+                                    hadSessionInvalid = true;
                                     callbacks.onSessionInvalid?.();
                                 }
                                 const errMsg = enrichClaudeErrorMessage(errs[0] || '未知错误', recentStderr);
@@ -632,7 +359,7 @@ export class ClaudeSDKAdapter {
                         }
                     }
                     // 如果流正常结束但没有收到 result 消息
-                    if (!streamClosed) {
+                    if (!runSettled) {
                         if (accumulated) {
                             log.info('Stream ended without result message, using accumulated text');
                             runSettled = true;
@@ -647,7 +374,6 @@ export class ClaudeSDKAdapter {
                             });
                         }
                         else {
-                            // 流结束但无 result 也无 accumulated：必须触发回调，否则 Promise 永远挂起
                             log.warn('Stream ended with no result and no accumulated text, calling onError to prevent stuck state');
                             runSettled = true;
                             callbacks.onError(enrichClaudeErrorMessage('AI 响应异常结束（无输出），请重试', recentStderr));
@@ -655,81 +381,41 @@ export class ClaudeSDKAdapter {
                     }
                 }
                 finally {
-                    // 从活跃列表中移除流
-                    activeStreams.delete(stream);
+                    // Query 的 cleanup 由 SDK 内部管理
                 }
             }
             catch (err) {
                 if (abortController.signal.aborted) {
-                    log.info('Session run aborted');
-                    // 清理 pending tempId（abort 可能在 init 消息之前发生）
-                    const idToClean = actualSessionId ?? pendingTempId;
-                    if (idToClean?.startsWith('pending-')) {
-                        activeSessions.delete(idToClean);
-                        log.info(`Cleaned up pending session: ${idToClean}`);
-                    }
+                    log.info('Query run aborted');
                     return;
                 }
                 runSettled = true;
                 const errorObj = err;
                 const msg = enrichClaudeErrorMessage(errorObj.message || String(err), recentStderr);
-                log.error(`Claude SDK V2 error: ${msg}`);
+                log.error(`Claude SDK error: ${msg}`);
                 if (errorObj.stack) {
                     log.error(`Error stack: ${errorObj.stack}`);
                 }
-                // 清理 pending tempId（session 在获取真实 ID 前就失败了）
-                const errIdToClean = actualSessionId ?? pendingTempId;
-                if (errIdToClean?.startsWith('pending-')) {
-                    activeSessions.delete(errIdToClean);
-                    log.warn(`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}`);
+                if (isSessionCorruptionError(msg)) {
+                    log.warn(`Session corruption detected: ${msg}`);
                     callbacks.onSessionInvalid?.();
                 }
                 callbacks.onError(msg);
             }
-            finally {
-                // 无论成功、失败还是 abort，都从运行中集合移除
-                if (trackedRunningId) {
-                    runningSessions.delete(trackedRunningId);
-                }
-                // 也清理 actualSessionId（可能在 init 后更新了）
-                if (actualSessionId && actualSessionId !== trackedRunningId) {
-                    runningSessions.delete(actualSessionId);
-                }
-            }
         };
-        // 启动会话（不等待），catch 兜底防止 unhandledRejection 导致用户请求挂起
-        runSession().catch((err) => {
+        // 启动查询（不等待），catch 兜底防止 unhandledRejection
+        runQuery().catch((err) => {
             if (!runSettled) {
                 runSettled = true;
                 const msg = err instanceof Error ? err.message : String(err);
-                log.error(`Unhandled runSession error: ${msg}`);
+                log.error(`Unhandled runQuery error: ${msg}`);
                 callbacks.onError(msg);
             }
         });
         return {
             abort: () => {
-                log.info('Aborting session run');
+                log.info('Aborting query');
                 abortController.abort();
-                // 立即中断 stream，不等下一条消息
-                if (currentStream) {
-                    try {
-                        currentStream.return?.();
-                    }
-                    catch { /* ignore */ }
-                }
             },
         };
     }

package/dist/adapters/registry.js

@@ -1,5 +1,5 @@
 import { getConfiguredAiCommands } from '../config.js';
-import { ClaudeSDKAdapter, configureClaudeSdkSessionIdle } from './claude-sdk-adapter.js';
+import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
 import { OpenCodeAdapter } from './opencode-adapter.js';
@@ -12,7 +12,6 @@ export function initAdapters(config) {
     for (const aiCommand of getConfiguredAiCommands(config)) {
         if (aiCommand === 'claude') {
             log.info('Claude Agent SDK adapter enabled');
-            configureClaudeSdkSessionIdle(config.claudeSessionIdleTtlMinutes);
             adapters.set('claude', new ClaudeSDKAdapter());
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.1-beta.7",
+  "version": "1.11.1-beta.8",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",
@@ -51,7 +51,8 @@
     "url": "https://github.com/wu529778790/open-im/issues"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.179",
+    "@anthropic-ai/sdk": "^0.104.2",
     "@aws-sdk/client-s3": "^3.1035.0",
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "centrifuge": "^5.5.3",