@wu529778790/open-im 1.7.0-beta.1 → 1.7.0

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

@@ -1,18 +1,18 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
+ * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
  *
- * 优势：
- * 1. 进程内执行 - 无 fork/exec 开销，响应更快
- * 2. 会话复用 - resume 保留上下文，无需重新加载历史
- * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
+ * V2 API 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销
+ * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
+ * 3. 流式输出 - 支持实时增量更新
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_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,18 +1,21 @@
 /**
- * Claude SDK Adapter - 使用 Agent SDK 实现持久会话，无需每次 spawn 进程
+ * Claude SDK Adapter - 使用 Agent SDK V2 Session API 实现真正的多轮对话
  *
- * 优势：
- * 1. 进程内执行 - 无 fork/exec 开销，响应更快
- * 2. 会话复用 - resume 保留上下文，无需重新加载历史
- * 3. 流式输出 - includePartialMessages 支持 text_delta、thinking_delta
+ * V2 API 优势：
+ * 1. 进程内执行 - 无 fork/exec 开销
+ * 2. 持久会话 - SDKSession 对象保持会话状态，支持真正的多轮对话
+ * 3. 流式输出 - 支持实时增量更新
  *
- * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN（claude setup-token）
+ * 认证：ANTHROPIC_API_KEY 或 CLAUDE_CODE_OAUTH_TOKEN
  */
-import { query } from '@anthropic-ai/claude-agent-sdk';
+import { unstable_v2_createSession, unstable_v2_resumeSession } from '@anthropic-ai/claude-agent-sdk';
 import { createLogger } from '../logger.js';
 const log = createLogger('ClaudeSDK');
-// 存储所有活跃的查询，用于清理
-const activeQueries = new Set();
+// 存储所有活跃的 SDKSession 对象，key 为 sessionId
+// 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
+const activeSessions = new Map();
+// 存储正在进行的流式迭代器，用于中断
+const activeStreams = new Set();
 function isStreamEvent(msg) {
     return msg.type === 'stream_event';
 }
@@ -20,33 +23,82 @@ 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';
 }
-function isAssistant(msg) {
-    return msg.type === 'assistant';
+/**
+ * 获取或创建 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 };
 }
 export class ClaudeSDKAdapter {
     toolId = 'claude-sdk';
     /**
-     * 清理所有活跃的 SDK 查询
+     * 清理所有活跃的 SDK 会话和流
      */
     static destroy() {
-        for (const q of activeQueries) {
+        for (const stream of activeStreams) {
             try {
-                if (q && typeof q.return === 'function') {
-                    q.return();
+                if (stream && typeof stream.return === 'function') {
+                    stream.return();
                 }
             }
             catch {
                 /* ignore */
             }
         }
-        activeQueries.clear();
+        activeStreams.clear();
+        for (const session of activeSessions.values()) {
+            try {
+                session.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        activeSessions.clear();
     }
     run(prompt, sessionId, workDir, callbacks, options) {
         const abortController = new AbortController();
-        let queryClosed = false;
+        let streamClosed = false;
+        let actualSessionId;
         const permissionMode = options?.skipPermissions
             ? 'bypassPermissions'
             : options?.permissionMode === 'acceptEdits'
@@ -54,41 +106,47 @@ export class ClaudeSDKAdapter {
                 : options?.permissionMode === 'plan'
                     ? 'plan'
                     : 'default';
-        const runQuery = async () => {
+        const runSession = async () => {
             try {
-                // 调试：检查关键环境变量
+                // 检查环境变量
                 const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
                 const hasAuthToken = !!process.env.ANTHROPIC_AUTH_TOKEN;
-                const hasBaseUrl = !!process.env.ANTHROPIC_BASE_URL;
-                if (!hasApiKey && !hasAuthToken && !hasBaseUrl) {
+                if (!hasApiKey && !hasAuthToken) {
                     log.warn('Claude SDK: No API credentials found in environment variables');
                 }
-                const opts = {
-                    cwd: workDir,
-                    resume: sessionId,
-                    includePartialMessages: true,
-                    permissionMode,
-                    model: options?.model,
-                    abortController,
-                    allowDangerouslySkipPermissions: permissionMode === 'bypassPermissions',
-                };
-                const q = query({
-                    prompt,
-                    options: opts,
-                });
-                // 将查询添加到活跃列表
-                activeQueries.add(q);
+                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);
                 let accumulated = '';
                 let accumulatedThinking = '';
                 const toolStats = {};
                 try {
-                    for await (const msg of q) {
-                        if (abortController.signal.aborted)
+                    for await (const msg of stream) {
+                        if (abortController.signal.aborted) {
+                            log.info('Stream aborted by user');
                             break;
+                        }
+                        // 获取实际的 sessionId（从 init 消息中）
                         if (isSystemInit(msg)) {
-                            callbacks.onSessionId?.(msg.session_id);
+                            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);
+                            }
                             continue;
                         }
+                        // 处理流式事件
                         if (isStreamEvent(msg)) {
                             const ev = msg.event;
                             if (ev?.type === 'content_block_delta' && ev.delta) {
@@ -103,6 +161,7 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
+                        // 处理助手消息（工具调用）
                         if (isAssistant(msg)) {
                             const content = msg.message?.content;
                             for (const block of content ?? []) {
@@ -113,16 +172,22 @@ export class ClaudeSDKAdapter {
                             }
                             continue;
                         }
+                        // 处理结果消息
                         if (isResult(msg)) {
-                            queryClosed = true;
+                            streamClosed = true;
                             const m = msg;
                             const success = m.subtype === 'success';
                             const errs = m.errors ?? [];
-                            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 开始新会话');
+                            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);
                                 return;
                             }
                             const resultText = m.result ?? '';
@@ -135,58 +200,55 @@ 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;
                         }
                     }
-                    if (!queryClosed) {
+                    // 如果流正常结束但没有收到 result 消息
+                    if (!streamClosed && accumulated) {
+                        log.info('Stream ended without result message, using accumulated text');
                         callbacks.onComplete({
                             success: true,
                             result: accumulated,
                             accumulated,
                             cost: 0,
                             durationMs: 0,
-                            numTurns: 0,
+                            numTurns: 1,
                             toolStats,
                         });
                     }
                 }
                 finally {
-                    q.close();
-                    // 从活跃列表中移除
-                    activeQueries.delete(q);
+                    // 从活跃列表中移除流
+                    activeStreams.delete(stream);
                 }
             }
             catch (err) {
-                if (abortController.signal.aborted)
+                if (abortController.signal.aborted) {
+                    log.info('Session run aborted');
                     return;
+                }
                 const errorObj = err;
                 const msg = errorObj.message || String(err);
-                const stack = errorObj.stack || '';
-                // 输出详细的错误信息用于调试
-                log.error(`Claude SDK error: ${msg}`);
-                if (stack) {
-                    log.error(`Error stack: ${stack}`);
+                log.error(`Claude SDK V2 error: ${msg}`);
+                if (errorObj.stack) {
+                    log.error(`Error stack: ${errorObj.stack}`);
                 }
                 callbacks.onError(msg);
             }
         };
-        runQuery();
+        // 启动会话（不等待）
+        runSession();
         return {
             abort: () => {
+                log.info('Aborting session run');
                 abortController.abort();
             },
         };

package/dist/shared/ai-task.js

@@ -112,14 +112,18 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                 ? config.codebuddyTimeoutMs
                 : config.claudeTimeoutMs;
         const startRun = () => {
+            log.info(`[AITask] Starting: userId=${ctx.userId}, initialSessionId=${currentSessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
             activeHandle = toolAdapter.run(prompt, currentSessionId, ctx.workDir, {
                 onSessionId: (id) => {
+                    log.info(`[AITask] SessionId callback: old=${currentSessionId ?? 'none'}, new=${id}, aiCommand=${aiCommand}, userId=${ctx.userId}`);
                     currentSessionId = id;
                     // 使用 aiCommand 而不是 toolId，确保与查询时使用相同的 key
                     if (ctx.threadId)
                         sessionManager.setSessionIdForThread(ctx.userId, ctx.threadId, aiCommand, id);
                     else if (ctx.convId)
                         sessionManager.setSessionIdForConv(ctx.userId, ctx.convId, aiCommand, id);
+                    else
+                        log.info(`[AITask] No threadId or convId, sessionId not persisted to storage`);
                 },
                 onSessionInvalid: () => {
                     if (ctx.convId)

package/package.json

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