@wu529778790/open-im 1.7.0-beta.2 → 1.7.1-beta.0

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

@@ -0,0 +1,26 @@
+import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
+export declare class ClaudeAdapter implements ToolAdapter {
+    private cliPath;
+    readonly toolId = "claude";
+    constructor(cliPath: string, adapterOptions?: {
+        useProcessPool?: boolean;
+        idleTimeoutMs?: number;
+    });
+    run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
+    /**
+     * Get the number of cached entries in the pool.
+     */
+    static getCacheSize(): number;
+    /**
+     * Get the number of active processes in the pool.
+     */
+    static getActiveProcessCount(): number;
+    /**
+     * Terminate all cached entries and processes.
+     */
+    static terminateAll(): void;
+    /**
+     * Destroy the process pool and cleanup resources.
+     */
+    static destroy(): void;
+}

package/dist/adapters/claude-adapter.js

@@ -0,0 +1,76 @@
+import { runClaude } from '../claude/cli-runner.js';
+import { ClaudeProcessPool } from '../claude/process-pool.js';
+// Global process pool instance
+let processPool = null;
+export class ClaudeAdapter {
+    cliPath;
+    toolId = 'claude';
+    constructor(cliPath, adapterOptions) {
+        this.cliPath = cliPath;
+        const useProcessPool = adapterOptions?.useProcessPool ?? true;
+        const idleTimeoutMs = adapterOptions?.idleTimeoutMs ?? 2 * 60 * 1000; // 2 minutes default
+        if (useProcessPool && !processPool) {
+            // Initialize process pool with configurable idle timeout
+            processPool = new ClaudeProcessPool(idleTimeoutMs);
+        }
+    }
+    run(prompt, sessionId, workDir, callbacks, options) {
+        const opts = {
+            skipPermissions: options?.skipPermissions,
+            permissionMode: options?.permissionMode,
+            timeoutMs: options?.timeoutMs,
+            model: options?.model,
+            chatId: options?.chatId,
+            hookPort: options?.hookPort,
+        };
+        // Use process pool if enabled and userId is available
+        if (processPool && opts.chatId) {
+            let aborted = false;
+            // Execute using process pool with userId from chatId
+            processPool
+                .execute(opts.chatId, sessionId, this.cliPath, prompt, workDir, callbacks, opts)
+                .catch((err) => {
+                if (!aborted && callbacks.onError) {
+                    callbacks.onError(err.message);
+                }
+            });
+            return {
+                abort: () => {
+                    aborted = true;
+                    processPool.terminate(opts.chatId, sessionId);
+                },
+            };
+        }
+        // Fall back to original implementation
+        return runClaude(this.cliPath, prompt, sessionId, workDir, callbacks, opts);
+    }
+    /**
+     * Get the number of cached entries in the pool.
+     */
+    static getCacheSize() {
+        return processPool?.size() ?? 0;
+    }
+    /**
+     * Get the number of active processes in the pool.
+     */
+    static getActiveProcessCount() {
+        return processPool?.activeCount() ?? 0;
+    }
+    /**
+     * Terminate all cached entries and processes.
+     */
+    static terminateAll() {
+        if (processPool) {
+            processPool.terminateAll();
+        }
+    }
+    /**
+     * Destroy the process pool and cleanup resources.
+     */
+    static destroy() {
+        if (processPool) {
+            processPool.destroy();
+            processPool = null;
+        }
+    }
+}

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

@@ -1,18 +1,18 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
+ * 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销，响应更快
+ * 2. 会话复用 - resume 保留上下文，无需重新加载历史
+ * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
  */
 import type { ToolAdapter, RunCallbacks, RunOptions, RunHandle } from './tool-adapter.interface.js';
 export declare class ClaudeSDKAdapter implements ToolAdapter {
     readonly toolId = "claude-sdk";
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * 清理所有活跃的 SDK 查询
      */
     static destroy(): void;
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;

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

@@ -1,21 +1,18 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
+ * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
  *
- * V2 API 优势：
- * 1. 进程内执行 - 无 fork/exec 开销
- * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
- * 3. 流式输出 - 支持实时增量更新
+ * 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销，响应更快
+ * 2. 会话复用 - resume 保留上下文，无需重新加载历史
+ * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
  */
-import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
+import { query } from '@anthropic-ai/claude-agent-sdk';
 import { createLogger } from '../logger.js';
 const log = createLogger('ClaudeSDK');
-// 存储所有活跃的 SDKSession 对象，key 为 sessionId
-// 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
-const activeSessions = new Map();
-// 存储正在进行的流式迭代器，用于中断
-const activeStreams = new Set();
+// 存储所有活跃的查询，用于清理
+const activeQueries = new Set();
 function isStreamEvent(msg) {
     return msg.type === 'stream_event';
 }
@@ -23,82 +20,33 @@ function isSystemInit(msg) {
     const m = msg;
     return m.type === 'system' && m.subtype === 'init';
 }
-function isAssistant(msg) {
-    return msg.type === 'assistant';
-}
 function isResult(msg) {
     return msg.type === 'result';
 }
-/**
- * 获取或创建 SDKSession
- * @param sessionId 已有的 sessionId，如果为 undefined 则创建新会话
- * @param workDir 工作目录
- * @param model 模型名称
- * @param permissionMode 权限模式
- * @returns SDKSession 对象和实际的 sessionId
- */
-async function getOrCreateSession(sessionId, _workDir, // 保留参数以备将来使用
-model, permissionMode) {
-    const sessionOptions = {
-        model: model || 'claude-opus-4-5',
-        permissionMode,
-        // 可以添加其他选项，如 hooks, allowedTools 等
-    };
-    let session;
-    if (sessionId) {
-        // 尝试恢复已有会话
-        try {
-            log.info(`Attempting to resume session: ${sessionId}`);
-            session = unstable_v2_resumeSession(sessionId, sessionOptions);
-            activeSessions.set(sessionId, session);
-            log.info(`Successfully resumed session: ${sessionId}`);
-            return { session, sessionId };
-        }
-        catch (err) {
-            log.warn(`Failed to resume session ${sessionId}, creating new one: ${err}`);
-            // 恢复失败，创建新会话
-        }
-    }
-    // 创建新会话
-    session = unstable_v2_createSession(sessionOptions);
-    // 新会话的 sessionId 需要从第一个消息中获取
-    // 暂时返回 undefined，稍后在 init 消息中获取
-    const tempId = `pending-${Date.now()}`;
-    activeSessions.set(tempId, session);
-    log.info(`Created new session (tempId: ${tempId})`);
-    return { session, sessionId: tempId };
+function isAssistant(msg) {
+    return msg.type === 'assistant';
 }
 export class ClaudeSDKAdapter {
     toolId = 'claude-sdk';
     /**
-     * 清理所有活跃的 SDK 会话和流
+     * 清理所有活跃的 SDK 查询
      */
     static destroy() {
-        for (const stream of activeStreams) {
+        for (const q of activeQueries) {
             try {
-                if (stream && typeof stream.return === 'function') {
-                    stream.return();
+                if (q && typeof q.return === 'function') {
+                    q.return();
                 }
             }
             catch {
                 /* ignore */
             }
         }
-        activeStreams.clear();
-        for (const session of activeSessions.values()) {
-            try {
-                session.close();
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        activeSessions.clear();
+        activeQueries.clear();
     }
     run(prompt, sessionId, workDir, callbacks, options) {
         const abortController = new AbortController();
-        let streamClosed = false;
-        let actualSessionId;
+        let queryClosed = false;
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
             : options?.permissionMode === 'acceptEdits'
@@ -106,47 +54,65 @@ export class ClaudeSDKAdapter {
                 : options?.permissionMode === 'plan'
                     ? 'plan'
                     : 'default';
-        const runSession = async () => {
+        const runQuery = async () => {
             try {
-                // 检查环境变量
+                // 调试：检查关键环境变量
                 const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
                 const hasAuthToken = !!process.env.ANTHROPIC_AUTH_TOKEN;
-                if (!hasApiKey && !hasAuthToken) {
+                const hasBaseUrl = !!process.env.ANTHROPIC_BASE_URL;
+                if (!hasApiKey && !hasAuthToken && !hasBaseUrl) {
                     log.warn('Claude SDK: No API credentials found in environment variables');
                 }
-                log.info(`[V2] Session: ${sessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
-                // 获取或创建会话
-                const { session } = await getOrCreateSession(sessionId, workDir, options?.model, permissionMode);
-                // 发送用户消息
-                await session.send(prompt);
-                // 获取响应流
-                const stream = session.stream();
-                activeStreams.add(stream);
+                const opts = {
+                    cwd: workDir,
+                    resume: sessionId,
+                    includePartialMessages: true,
+                    permissionMode,
+                    model: options?.model,
+                    abortController,
+                    allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions',
+                };
+                log.info(`[ClaudeSDK] Starting query: prompt="${prompt.slice(0, 50)}...", sessionId=${sessionId ?? 'new'}, cwd=${workDir}`);
+                let q;
+                try {
+                    q = query({
+                        prompt,
+                        options: opts,
+                    });
+                }
+                catch (queryInitErr) {
+                    log.error(`[ClaudeSDK] Query initialization failed:`, queryInitErr);
+                    // 如果是会话文件问题，尝试作为新会话
+                    if (sessionId && (queryInitErr.code === 'ENOENT' ||
+                        queryInitErr.message.includes('ENOENT') ||
+                        queryInitErr.message.includes('not found'))) {
+                        log.warn(`[ClaudeSDK] Session file not found, starting new session`);
+                        callbacks.onSessionInvalid?.();
+                        // 重新创建查询，不带 resume
+                        const newOpts = { ...opts, resume: undefined };
+                        q = query({
+                            prompt,
+                            options: newOpts,
+                        });
+                    }
+                    else {
+                        callbacks.onError(`查询初始化失败: ${queryInitErr.message}`);
+                        return;
+                    }
+                }
+                // 将查询添加到活跃列表
+                activeQueries.add(q);
                 let accumulated = '';
                 let accumulatedThinking = '';
                 const toolStats = {};
                 try {
-                    for await (const msg of stream) {
-                        if (abortController.signal.aborted) {
-                            log.info('Stream aborted by user');
+                    for await (const msg of q) {
+                        if (abortController.signal.aborted)
                             break;
-                        }
-                        // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
-                            const newSessionId = msg.session_id;
-                            if (newSessionId && newSessionId !== actualSessionId) {
-                                // 更新 sessionId 映射
-                                if (actualSessionId && actualSessionId.startsWith('pending-')) {
-                                    activeSessions.delete(actualSessionId);
-                                }
-                                activeSessions.set(newSessionId, session);
-                                actualSessionId = newSessionId;
-                                log.info(`[V2] Got actual sessionId: ${newSessionId}`);
-                                callbacks.onSessionId?.(newSessionId);
-                            }
+                            callbacks.onSessionId?.(msg.session_id);
                             continue;
                         }
-                        // 处理流式事件
                         if (isStreamEvent(msg)) {
                             const ev = msg.event;
                             if (ev?.type === 'content_block_delta' && ev.delta) {
@@ -161,7 +127,6 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
-                        // 处理助手消息（工具调用）
                         if (isAssistant(msg)) {
                             const content = msg.message?.content;
                             for (const block of content ?? []) {
@@ -172,22 +137,16 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
-                        // 处理结果消息
                         if (isResult(msg)) {
-                            streamClosed = true;
+                            queryClosed = 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'}`);
-                            // 检查会话错误
-                            if (!success) {
-                                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`);
-                                    callbacks.onSessionInvalid?.();
-                                }
-                                const errMsg = errs[0] || '未知错误';
-                                callbacks.onError(errMsg);
+                            const noConvErr = errs.find((e) => e.includes('No conversation found with session ID'));
+                            if (!success && noConvErr) {
+                                log.warn(`SDK session invalid: ${noConvErr}`);
+                                callbacks.onSessionInvalid?.();
+                                callbacks.onError('会话已过期，请发送 /new 开始新会话');
                                 return;
                             }
                             const resultText = m.result ?? '';
@@ -200,55 +159,71 @@ export class ClaudeSDKAdapter {
                                 numTurns: m.num_turns ?? 0,
                                 toolStats,
                             };
-                            if (!result.accumulated && result.result) {
+                            if (!result.accumulated && result.result)
                                 result.accumulated = result.result;
-                            }
                             if (!result.accumulated && !result.result && accumulated) {
+                                log.debug(`Result event had no text but accumulated=${accumulated.length} chars, using accumulated`);
                                 result.accumulated = accumulated;
                                 result.result = accumulated;
                             }
+                            if (!result.accumulated && !result.result) {
+                                const errMsg = errs[0] ?? '未知错误';
+                                log.warn(`SDK result empty: subtype=${m.subtype}, errors=${JSON.stringify(errs)}`);
+                                callbacks.onError(errMsg);
+                                return;
+                            }
                             callbacks.onComplete(result);
                             return;
                         }
                     }
-                    // 如果流正常结束但没有收到 result 消息
-                    if (!streamClosed && accumulated) {
-                        log.info('Stream ended without result message, using accumulated text');
+                    if (!queryClosed) {
                         callbacks.onComplete({
                             success: true,
                             result: accumulated,
                             accumulated,
                             cost: 0,
                             durationMs: 0,
-                            numTurns: 1,
+                            numTurns: 0,
                             toolStats,
                         });
                     }
                 }
                 finally {
-                    // 从活跃列表中移除流
-                    activeStreams.delete(stream);
+                    q.close();
+                    // 从活跃列表中移除
+                    activeQueries.delete(q);
                 }
             }
             catch (err) {
                 if (abortController.signal.aborted) {
-                    log.info('Session run aborted');
+                    log.info('Query aborted by user');
                     return;
                 }
                 const errorObj = err;
                 const msg = errorObj.message || String(err);
-                log.error(`Claude SDK V2 error: ${msg}`);
-                if (errorObj.stack) {
-                    log.error(`Error stack: ${errorObj.stack}`);
+                const stack = errorObj.stack || '';
+                // 输出详细的错误信息用于调试
+                log.error(`Claude SDK error: ${msg}`);
+                if (stack) {
+                    log.error(`Error stack: ${stack}`);
+                }
+                // 特别处理会话文件不存在的情况
+                if (errorObj.code === 'ENOENT' ||
+                    errorObj.syscall === 'lstat' ||
+                    msg.includes('ENOENT') ||
+                    msg.includes('session')) {
+                    log.warn(`Session file access error, likely session is corrupted or missing`);
+                    callbacks.onSessionInvalid?.();
+                    callbacks.onError('会话文件不存在或已损坏，请发送 /new 开始新会话');
+                }
+                else {
+                    callbacks.onError(msg);
                 }
-                callbacks.onError(msg);
             }
         };
-        // 启动会话（不等待）
-        runSession();
+        runQuery();
         return {
             abort: () => {
-                log.info('Aborting session run');
                 abortController.abort();
             },
         };

package/dist/adapters/registry.js

@@ -1,4 +1,5 @@
 import { getConfiguredAiCommands } from '../config.js';
+import { ClaudeAdapter } from './claude-adapter.js';
 import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
@@ -9,8 +10,17 @@ export function initAdapters(config) {
     adapters.clear();
     for (const aiCommand of getConfiguredAiCommands(config)) {
         if (aiCommand === 'claude') {
-            log.info('Claude Agent SDK adapter enabled');
-            adapters.set('claude', new ClaudeSDKAdapter());
+            if (config.useSdkMode) {
+                log.info('Claude Agent SDK adapter enabled');
+                adapters.set('claude', new ClaudeSDKAdapter());
+            }
+            else {
+                log.info('Claude CLI adapter enabled');
+                adapters.set('claude', new ClaudeAdapter(config.claudeCliPath, {
+                    useProcessPool: true,
+                    idleTimeoutMs: 2 * 60 * 1000,
+                }));
+            }
             continue;
         }
         if (aiCommand === 'codex') {
@@ -28,6 +38,7 @@ export function getAdapter(aiCommand) {
     return adapters.get(aiCommand);
 }
 export function cleanupAdapters() {
+    ClaudeAdapter.destroy();
     ClaudeSDKAdapter.destroy();
     adapters.clear();
 }

package/dist/claude/cli-runner.d.ts

@@ -0,0 +1,29 @@
+export interface ClaudeRunCallbacks {
+    onText: (accumulated: string) => void;
+    onThinking?: (accumulated: string) => void;
+    onToolUse?: (toolName: string, toolInput?: Record<string, unknown>) => void;
+    onComplete: (result: {
+        success: boolean;
+        result: string;
+        accumulated: string;
+        cost: number;
+        durationMs: number;
+        model?: string;
+        numTurns: number;
+        toolStats: Record<string, number>;
+    }) => void;
+    onError: (error: string) => void;
+    onSessionId?: (sessionId: string) => void;
+}
+export interface ClaudeRunOptions {
+    skipPermissions?: boolean;
+    permissionMode?: 'default' | 'acceptEdits' | 'plan';
+    timeoutMs?: number;
+    model?: string;
+    chatId?: string;
+    hookPort?: number;
+}
+export interface ClaudeRunHandle {
+    abort: () => void;
+}
+export declare function runClaude(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: ClaudeRunCallbacks, options?: ClaudeRunOptions): ClaudeRunHandle;