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

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

@@ -1,14 +1,13 @@
 /**
- * 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 { query } from '@anthropic-ai/claude-agent-sdk';
+import type { SDKSessionInfo, SessionMessage, ModelInfo, SDKControlGetContextUsageResponse, AccountInfo } from '@anthropic-ai/claude-agent-sdk';
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
 interface ClaudeSessionMeta {
     sessionId: string;
@@ -18,29 +17,51 @@ 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[]>;
+    /**
+     * Get session messages for a given session ID.
+     */
+    static getSessionMessagesForId(sessionId: string, workDir: string, limit?: number): Promise<SessionMessage[]>;
+    /**
+     * Delete a session by ID.
+     */
+    static deleteSessionById(sessionId: string, workDir?: string): Promise<boolean>;
+    /**
+     * Rename a session.
+     */
+    static renameSessionById(sessionId: string, title: string, workDir?: string): Promise<boolean>;
+    /**
+     * Fork a session.
+     */
+    static forkSessionById(sessionId: string, workDir?: string): Promise<string | undefined>;
+    /**
+     * Create a short-lived query for fetching session info (models, context, etc).
+     * The caller must close the returned query when done.
+     */
+    static createInfoQuery(workDir: string, model?: string): Promise<ReturnType<typeof query>>;
+    /**
+     * Get available models for a work directory.
+     */
+    static getSupportedModels(workDir: string, model?: string): Promise<ModelInfo[]>;
+    /**
+     * Get context usage for a work directory.
+     */
+    static getContextUsage(workDir: string, model?: string): Promise<SDKControlGetContextUsageResponse | undefined>;
+    /**
+     * Get account info for a work directory.
+     */
+    static getAccountInfo(workDir: string, model?: string): Promise<AccountInfo | undefined>;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }
 export {};

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, getSessionMessages, deleteSession, renameSession, forkSession } 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,179 +192,163 @@ 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.`);
+export class ClaudeSDKAdapter {
+    toolId = 'claude-sdk';
+    /**
+     * 清理所有活跃的查询
+     */
+    static destroy() {
+        // query() API 的 Query 对象通过 abortController.abort() 清理
     }
-    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();
+    /**
+     * List sessions for a directory using the SDK's listSessions API.
+     */
+    static async listSessionsForDir(workDir, limit = 20) {
         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 };
+            return await listSessions({ dir: workDir, limit });
         }
-        finally {
-            if (workDir && workDir !== originalCwd) {
-                process.chdir(originalCwd);
-            }
+        catch (err) {
+            log.warn(`Failed to list sessions for ${workDir}: ${err}`);
+            return [];
         }
-    });
-}
-export class ClaudeSDKAdapter {
-    toolId = 'claude-sdk';
+    }
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * Get session messages for a given session ID.
      */
-    static destroy() {
-        clearInterval(cleanupInterval);
-        for (const stream of activeStreams) {
-            try {
-                if (stream && typeof stream.return === 'function') {
-                    stream.return();
-                }
-            }
-            catch {
-                /* ignore */
-            }
+    static async getSessionMessagesForId(sessionId, workDir, limit = 50) {
+        try {
+            return await getSessionMessages(sessionId, { dir: workDir, limit });
         }
-        activeStreams.clear();
-        for (const session of activeSessions.values()) {
-            try {
-                session.close();
-            }
-            catch {
-                /* ignore */
+        catch (err) {
+            log.warn(`Failed to get session messages for ${sessionId}: ${err}`);
+            return [];
+        }
+    }
+    /**
+     * Delete a session by ID.
+     */
+    static async deleteSessionById(sessionId, workDir) {
+        try {
+            await deleteSession(sessionId, { dir: workDir });
+            return true;
+        }
+        catch (err) {
+            log.warn(`Failed to delete session ${sessionId}: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Rename a session.
+     */
+    static async renameSessionById(sessionId, title, workDir) {
+        try {
+            await renameSession(sessionId, title, { dir: workDir });
+            return true;
+        }
+        catch (err) {
+            log.warn(`Failed to rename session ${sessionId}: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Fork a session.
+     */
+    static async forkSessionById(sessionId, workDir) {
+        try {
+            const result = await forkSession(sessionId, { dir: workDir });
+            return result.sessionId;
+        }
+        catch (err) {
+            log.warn(`Failed to fork session ${sessionId}: ${err}`);
+            return undefined;
+        }
+    }
+    /**
+     * Create a short-lived query for fetching session info (models, context, etc).
+     * The caller must close the returned query when done.
+     */
+    static async createInfoQuery(workDir, model) {
+        const resolvedModel = model?.trim() || process.env.ANTHROPIC_MODEL?.trim() || 'claude-opus-4-5';
+        return query({
+            prompt: '',
+            options: {
+                cwd: workDir,
+                model: resolvedModel,
+                permissionMode: 'default',
+            },
+        });
+    }
+    /**
+     * Get available models for a work directory.
+     */
+    static async getSupportedModels(workDir, model) {
+        let q;
+        try {
+            q = await this.createInfoQuery(workDir, model);
+            return await q.supportedModels();
+        }
+        catch (err) {
+            log.warn(`Failed to get supported models: ${err}`);
+            return [];
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
+                }
+                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.
+     * Get context usage for a work directory.
      */
-    static removeSession(sessionId) {
-        const session = activeSessions.get(sessionId);
-        if (session) {
-            try {
-                session.close();
+    static async getContextUsage(workDir, model) {
+        let q;
+        try {
+            q = await this.createInfoQuery(workDir, model);
+            return await q.getContextUsage();
+        }
+        catch (err) {
+            log.warn(`Failed to get context usage: ${err}`);
+            return undefined;
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
+                }
+                catch { /* ignore */ }
             }
-            catch { /* ignore */ }
-            activeSessions.delete(sessionId);
-            sessionLastUsed.delete(sessionId);
-            sessionWorkDirs.delete(sessionId);
-            log.info(`Explicitly removed session: ${sessionId}`);
         }
     }
     /**
-     * List sessions for a directory using the SDK's listSessions API.
-     * Replaces the custom file-scanning logic in findLatestClaudeSession.
+     * Get account info for a work directory.
      */
-    static async listSessionsForDir(workDir, limit = 20) {
+    static async getAccountInfo(workDir, model) {
+        let q;
         try {
-            return await listSessions({ dir: workDir, limit });
+            q = await this.createInfoQuery(workDir, model);
+            return await q.accountInfo();
         }
         catch (err) {
-            log.warn(`Failed to list sessions for ${workDir}: ${err}`);
-            return [];
+            log.warn(`Failed to get account info: ${err}`);
+            return undefined;
+        }
+        finally {
+            if (q) {
+                try {
+                    await q.return(undefined);
+                }
+                catch { /* ignore */ }
+            }
         }
     }
     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 +357,66 @@ 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 } : {}),
+                        ...(options?.fallbackModel ? { fallbackModel: options.fallbackModel } : {}),
+                        ...(options?.disallowedTools?.length ? { disallowedTools: options.disallowedTools } : {}),
+                        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 +448,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 +492,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 +507,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 +514,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/dist/adapters/tool-adapter.interface.d.ts

@@ -30,6 +30,10 @@ export interface RunOptions {
     hookPort?: number;
     /** Codex 专用：HTTP/HTTPS 代理地址，如 http://127.0.0.1:7890 */
     proxy?: string;
+    /** 备用模型，主模型过载时自动切换 */
+    fallbackModel?: string;
+    /** 禁用的工具列表 */
+    disallowedTools?: string[];
 }
 export interface RunHandle {
     abort: () => void;

package/dist/commands/handler.d.ts

@@ -30,6 +30,12 @@ export declare class CommandHandler {
     private handlePwd;
     private handleStatus;
     private handleCd;
+    private handleHistory;
+    private handleDelete;
+    private handleRename;
+    private handleFork;
+    private handleModels;
+    private handleContext;
     private getAiVersion;
 }
 /**

package/dist/commands/handler.js

@@ -81,6 +81,18 @@ export class CommandHandler {
                 return this.handleSessions(chatId, userId, platform);
             if (t.startsWith('/resume '))
                 return this.handleResume(chatId, userId, t.slice(8).trim(), platform);
+            if (t.startsWith('/history'))
+                return this.handleHistory(chatId, userId, t.slice(8).trim());
+            if (t.startsWith('/delete '))
+                return this.handleDelete(chatId, userId, t.slice(8).trim());
+            if (t.startsWith('/rename '))
+                return this.handleRename(chatId, userId, t.slice(8).trim());
+            if (t.startsWith('/fork'))
+                return this.handleFork(chatId, userId, t.slice(5).trim());
+            if (t === '/models')
+                return this.handleModels(chatId, userId, platform);
+            if (t === '/context')
+                return this.handleContext(chatId, userId, platform);
             if (t === '/pwd')
                 return this.handlePwd(chatId, userId);
             if (t === '/status')
@@ -108,6 +120,12 @@ export class CommandHandler {
             '/new - 开始新会话（AI 上下文重置）',
             '/sessions - 查看历史会话',
             '/resume [序号] - 恢复历史会话（无参数恢复最近一条）',
+            '/history [序号] - 查看会话对话记录',
+            '/delete <序号> - 删除历史会话',
+            '/rename <标题> - 重命名当前会话',
+            '/fork [序号] - 分支会话（创建副本）',
+            '/models - 查看可用模型',
+            '/context - 查看上下文窗口占用',
             '/status - 显示状态',
             '/cd <路径> - 切换工作目录',
             '/pwd - 当前工作目录',
@@ -191,6 +209,20 @@ export class CommandHandler {
             `工作目录: ${escapePathForMarkdown(workDir)}`,
             `会话: ${sessionId ?? '无'}`,
         ];
+        // 账号信息（仅 claude）
+        if (aiCommand === 'claude') {
+            try {
+                const account = await ClaudeSDKAdapter.getAccountInfo(workDir);
+                if (account) {
+                    lines.push('', '👤 账号:');
+                    if (account.email)
+                        lines.push(`邮箱: ${account.email}`);
+                    if (account.organization)
+                        lines.push(`组织: ${account.organization}`);
+                }
+            }
+            catch { /* ignore */ }
+        }
         await this.replySender().sendTextReply(chatId, lines.join('\n'));
         return true;
     }
@@ -217,6 +249,155 @@ export class CommandHandler {
         }
         return true;
     }
+    async handleHistory(chatId, userId, arg) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        if (sessions.length === 0) {
+            await this.replySender().sendTextReply(chatId, '暂无会话记录。');
+            return true;
+        }
+        let targetSession = sessions[0]; // 默认当前/最近会话
+        if (arg) {
+            const index = parseInt(arg, 10);
+            if (isNaN(index) || index < 1 || index > sessions.length) {
+                await this.replySender().sendTextReply(chatId, `序号无效，共 ${sessions.length} 个会话。`);
+                return true;
+            }
+            targetSession = sessions[index - 1];
+        }
+        const messages = await ClaudeSDKAdapter.getSessionMessagesForId(targetSession.sessionId, workDir, 30);
+        if (messages.length === 0) {
+            await this.replySender().sendTextReply(chatId, '该会话暂无对话记录。');
+            return true;
+        }
+        const preview = truncateSummary(targetSession);
+        const lines = [`📜 会话记录: ${preview}`, ''];
+        for (const msg of messages) {
+            if (msg.type === 'system')
+                continue;
+            const m = msg.message;
+            let text = '';
+            if (typeof m === 'string') {
+                text = m;
+            }
+            else if (m && typeof m === 'object') {
+                const content = m.content;
+                if (Array.isArray(content) && content[0]?.text) {
+                    text = content[0].text;
+                }
+                else if (typeof content === 'string') {
+                    text = content;
+                }
+            }
+            if (!text)
+                continue;
+            const prefix = msg.type === 'user' ? '👤' : '🤖';
+            lines.push(`${prefix} ${text.slice(0, 200)}`);
+        }
+        await this.replySender().sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
+    async handleDelete(chatId, userId, arg) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        const index = parseInt(arg, 10);
+        if (isNaN(index) || index < 1 || index > sessions.length) {
+            await this.replySender().sendTextReply(chatId, `用法: /delete <序号>\n共 ${sessions.length} 个会话。`);
+            return true;
+        }
+        const session = sessions[index - 1];
+        const preview = truncateSummary(session);
+        const ok = await ClaudeSDKAdapter.deleteSessionById(session.sessionId, workDir);
+        await this.replySender().sendTextReply(chatId, ok ? `✅ 已删除会话: ${preview}` : `❌ 删除失败`);
+        return true;
+    }
+    async handleRename(chatId, userId, title) {
+        if (!title) {
+            await this.replySender().sendTextReply(chatId, '用法: /rename <新标题>');
+            return true;
+        }
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const convId = this.deps.sessionManager.getConvId(userId);
+        const aiCommand = 'claude';
+        const sessionId = this.deps.sessionManager.getSessionIdForConv(userId, convId, aiCommand);
+        if (!sessionId) {
+            await this.replySender().sendTextReply(chatId, '当前没有活动会话。');
+            return true;
+        }
+        const ok = await ClaudeSDKAdapter.renameSessionById(sessionId, title, workDir);
+        await this.replySender().sendTextReply(chatId, ok ? `✅ 会话已重命名为: ${title}` : '❌ 重命名失败');
+        return true;
+    }
+    async handleFork(chatId, userId, arg) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const sessions = await ClaudeSDKAdapter.listSessionsForDir(workDir);
+        if (sessions.length === 0) {
+            await this.replySender().sendTextReply(chatId, '暂无会话可分支。');
+            return true;
+        }
+        let targetSession = sessions[0];
+        if (arg) {
+            const index = parseInt(arg, 10);
+            if (isNaN(index) || index < 1 || index > sessions.length) {
+                await this.replySender().sendTextReply(chatId, `序号无效，共 ${sessions.length} 个会话。`);
+                return true;
+            }
+            targetSession = sessions[index - 1];
+        }
+        const newSessionId = await ClaudeSDKAdapter.forkSessionById(targetSession.sessionId, workDir);
+        if (newSessionId) {
+            this.deps.sessionManager.setActiveSessionId(userId, newSessionId);
+            const preview = truncateSummary(targetSession);
+            await this.replySender().sendTextReply(chatId, `✅ 已分支会话: ${preview}\n新会话 ID: ${newSessionId.slice(0, 8)}...\n继续发消息即可。`);
+        }
+        else {
+            await this.replySender().sendTextReply(chatId, '❌ 分支失败');
+        }
+        return true;
+    }
+    async handleModels(chatId, userId, _platform) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const models = await ClaudeSDKAdapter.getSupportedModels(workDir);
+        if (models.length === 0) {
+            await this.replySender().sendTextReply(chatId, '暂无可用模型信息。');
+            return true;
+        }
+        const lines = ['🤖 可用模型:', ''];
+        for (const model of models) {
+            const name = model.displayName || model.value;
+            const desc = model.description ? ` - ${model.description.slice(0, 60)}` : '';
+            lines.push(`• ${name}${desc}`);
+        }
+        await this.replySender().sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
+    async handleContext(chatId, userId, _platform) {
+        const workDir = this.deps.sessionManager.getWorkDir(userId);
+        const usage = await ClaudeSDKAdapter.getContextUsage(workDir);
+        if (!usage) {
+            await this.replySender().sendTextReply(chatId, '暂无上下文信息。');
+            return true;
+        }
+        const lines = ['📏 上下文窗口占用:', ''];
+        if (usage.model)
+            lines.push(`模型: ${usage.model}`);
+        if (usage.totalTokens)
+            lines.push(`已用: ${usage.totalTokens.toLocaleString()} tokens`);
+        if (usage.maxTokens)
+            lines.push(`上限: ${usage.maxTokens.toLocaleString()} tokens`);
+        if (usage.percentage != null)
+            lines.push(`使用率: ${usage.percentage}%`);
+        if (usage.categories?.length) {
+            lines.push('', '分类:');
+            for (const cat of usage.categories) {
+                if (cat.tokens > 0) {
+                    lines.push(`  ${cat.name}: ${cat.tokens.toLocaleString()}`);
+                }
+            }
+        }
+        await this.replySender().sendTextReply(chatId, lines.join('\n'));
+        return true;
+    }
     getAiVersion(aiCommand) {
         if (aiCommand === 'claude') {
             return Promise.resolve('SDK Mode');

package/dist/constants.js

@@ -35,7 +35,6 @@ export const IMAGE_DIR = join(tmpdir(), "open-im-images");
  */
 export const DEFAULT_OPEN_IM_COAUTHOR_ADDR = "529778790@qq.com";
 export const TERMINAL_ONLY_COMMANDS = new Set([
-    "/context",
     "/rewind",
     "/copy",
     "/export",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.1-beta.7",
+  "version": "1.11.1-beta.9",
   "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",