axon-code 2.5.1 → 2.6.1

package/dist/web/server/websocket.js

@@ -1942,6 +1942,7 @@ async function prepareChatSession(client, content, attachments, conversationMana
     if (!existingSession) {
         // 当前 sessionId 是临时的（WebSocket 连接时生成的），需要创建持久化会话
         // 官方规范：使用第一条消息的前50个字符作为会话标题
+        const temporarySessionId = sessionId;
         const firstPrompt = content.substring(0, 50);
         console.log(`[WebSocket] Temporary session ${sessionId}, creating persistent session, title: ${firstPrompt}, projectPath: ${client.projectPath || 'global'}`);
         const newSession = sessionManager.createSession({
@@ -1951,6 +1952,7 @@ async function prepareChatSession(client, content, attachments, conversationMana
             tags: ['webui'],
             projectPath: client.projectPath, // 传递项目路径
         });
+        sessionManager.registerTemporarySessionId(newSession.metadata.id, temporarySessionId);
         // 更新 client 的 sessionId
         client.sessionId = newSession.metadata.id;
         sessionId = newSession.metadata.id;
@@ -2547,42 +2549,59 @@ async function handleSessionNew(client, payload, conversationManager) {
         });
     }
 }
+function resolveSessionRestoreTargetId(conversationManager, requestedSessionId) {
+    const resolvedSessionId = conversationManager.getSessionManager().findSessionIdByTemporarySessionId(requestedSessionId);
+    if (resolvedSessionId && resolvedSessionId !== requestedSessionId) {
+        console.log(`[WebSocket] Resolved temporary session ${requestedSessionId} -> ${resolvedSessionId}`);
+        return resolvedSessionId;
+    }
+    return requestedSessionId;
+}
 /**
  * 处理切换会话请求
  */
 async function handleSessionSwitch(client, sessionId, conversationManager) {
     const { ws } = client;
     try {
+        let targetSessionId = sessionId;
         // 提前更新 ws：如果目标会话已在内存中（正在处理），立即将其 ws 指向新连接
         // 这样在 await resumeSession() 期间，流式回调就能通过 getActiveWs() 获取到新 ws，
         // 避免消息发送到已关闭的旧连接而丢失
-        conversationManager.setWebSocket(sessionId, ws);
+        conversationManager.setWebSocket(targetSessionId, ws);
         // 保存当前会话
         await conversationManager.persistSession(client.sessionId);
         // 恢复目标会话（传入客户端权限模式，确保 YOLO 等模式跨会话持久化）
-        const success = await conversationManager.resumeSession(sessionId, client.permissionMode);
+        let success = await conversationManager.resumeSession(targetSessionId, client.permissionMode);
+        if (!success) {
+            const resolvedSessionId = resolveSessionRestoreTargetId(conversationManager, targetSessionId);
+            if (resolvedSessionId !== targetSessionId) {
+                targetSessionId = resolvedSessionId;
+                conversationManager.setWebSocket(targetSessionId, ws);
+                success = await conversationManager.resumeSession(targetSessionId, client.permissionMode);
+            }
+        }
         if (success) {
             // 更新客户端会话ID
-            client.sessionId = sessionId;
+            client.sessionId = targetSessionId;
             // 恢复后再次更新 ws（resumeSession 可能从磁盘新建了 SessionState）
-            conversationManager.setWebSocket(sessionId, ws);
+            conversationManager.setWebSocket(targetSessionId, ws);
             // 更新客户端项目路径（优化：从内存中的 SessionState 获取，避免重复读磁盘）
-            const projectPath = conversationManager.getSessionProjectPath(sessionId);
+            const projectPath = conversationManager.getSessionProjectPath(targetSessionId);
             if (projectPath) {
                 client.projectPath = projectPath;
             }
             // 获取会话历史（使用 getLiveHistory：处理中时从 messages 实时构建，确保工具调用中间 turn 不丢失）
-            const history = conversationManager.getLiveHistory(sessionId);
-            console.log(`[WebSocket] handleSessionSwitch: sessionId=${sessionId}, history.length=${history.length}, isProcessing=${conversationManager.isSessionProcessing(sessionId)}`);
-            const sessionName = conversationManager.getSessionName(sessionId);
-            const sessionRuntimeBackend = conversationManager.getSessionRuntimeBackend(sessionId) || webAuth.getRuntimeBackend();
-            const sessionModel = conversationManager.getSessionModel(sessionId) || getDefaultChatModel(sessionRuntimeBackend);
+            const history = conversationManager.getLiveHistory(targetSessionId);
+            console.log(`[WebSocket] handleSessionSwitch: sessionId=${targetSessionId}, history.length=${history.length}, isProcessing=${conversationManager.isSessionProcessing(targetSessionId)}`);
+            const sessionName = conversationManager.getSessionName(targetSessionId);
+            const sessionRuntimeBackend = conversationManager.getSessionRuntimeBackend(targetSessionId) || webAuth.getRuntimeBackend();
+            const sessionModel = conversationManager.getSessionModel(targetSessionId) || getDefaultChatModel(sessionRuntimeBackend);
             client.model = sessionModel;
             client.runtimeBackend = sessionRuntimeBackend;
             sendMessage(ws, {
                 type: 'session_switched',
                 payload: {
-                    sessionId,
+                    sessionId: targetSessionId,
                     sessionName,
                     projectPath: client.projectPath,
                     history,
@@ -2591,7 +2610,7 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
                 },
             });
             // 同步权限配置到客户端（刷新后客户端 permissionMode 会重置为 'default'，需要从服务端恢复）
-            const permConfig = conversationManager.getPermissionConfig(sessionId);
+            const permConfig = conversationManager.getPermissionConfig(targetSessionId);
             if (permConfig) {
                 sendMessage(ws, {
                     type: 'permission_config_update',
@@ -2605,33 +2624,33 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
             }
             // 如果会话正在处理中（如页面刷新），恢复流式状态
             // 补发 message_start + 已累积的内容，让客户端立即显示已生成的内容
-            const isProcessing = conversationManager.isSessionProcessing(sessionId);
+            const isProcessing = conversationManager.isSessionProcessing(targetSessionId);
             if (isProcessing) {
                 const resumeMessageId = `resume-${Date.now()}`;
                 // 补发 message_start，客户端收到后会创建 currentMessageRef
                 sendMessage(ws, {
                     type: 'message_start',
-                    payload: { messageId: resumeMessageId, sessionId },
+                    payload: { messageId: resumeMessageId, sessionId: targetSessionId },
                 });
                 // 获取已累积的流式中间内容，补发给客户端
                 // 这样用户刷新后能立即看到 API 已经生成的内容，而不是空气泡
-                const streamingContent = conversationManager.getStreamingContent(sessionId);
+                const streamingContent = conversationManager.getStreamingContent(targetSessionId);
                 if (streamingContent) {
                     // 补发 thinking 内容（如果有）
                     if (streamingContent.thinkingText) {
                         sendMessage(ws, {
                             type: 'thinking_start',
-                            payload: { messageId: resumeMessageId, sessionId },
+                            payload: { messageId: resumeMessageId, sessionId: targetSessionId },
                         });
                         sendMessage(ws, {
                             type: 'thinking_delta',
-                            payload: { messageId: resumeMessageId, text: streamingContent.thinkingText, sessionId },
+                            payload: { messageId: resumeMessageId, text: streamingContent.thinkingText, sessionId: targetSessionId },
                         });
                         // 如果已有 text 内容，说明 thinking 已经结束
                         if (streamingContent.textContent) {
                             sendMessage(ws, {
                                 type: 'thinking_complete',
-                                payload: { messageId: resumeMessageId, sessionId },
+                                payload: { messageId: resumeMessageId, sessionId: targetSessionId },
                             });
                         }
                     }
@@ -2639,40 +2658,40 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
                     if (streamingContent.textContent) {
                         sendMessage(ws, {
                             type: 'text_delta',
-                            payload: { messageId: resumeMessageId, text: streamingContent.textContent, sessionId },
+                            payload: { messageId: resumeMessageId, text: streamingContent.textContent, sessionId: targetSessionId },
                         });
                     }
                 }
                 sendMessage(ws, {
                     type: 'status',
-                    payload: { status: 'streaming', message: 'Processing conversation...', sessionId },
+                    payload: { status: 'streaming', message: 'Processing conversation...', sessionId: targetSessionId },
                 });
                 // 重发待处理的权限请求和用户问题
                 // 会话正在处理中且被阻塞在等待用户响应时，切换回来后需要重新弹出对话框
-                const pendingPermissions = conversationManager.getPendingPermissionRequests(sessionId);
+                const pendingPermissions = conversationManager.getPendingPermissionRequests(targetSessionId);
                 for (const req of pendingPermissions) {
                     sendMessage(ws, {
                         type: 'permission_request',
-                        payload: { ...req, sessionId },
+                        payload: { ...req, sessionId: targetSessionId },
                     });
                     console.log(`[WebSocket] Resending pending permission request: ${req.tool} (${req.requestId})`);
                 }
-                const pendingQuestions = conversationManager.getUndeliveredPendingUserQuestions(sessionId);
+                const pendingQuestions = conversationManager.getUndeliveredPendingUserQuestions(targetSessionId);
                 for (const q of pendingQuestions) {
                     sendMessage(ws, {
                         type: 'user_question',
-                        payload: { ...q, sessionId },
+                        payload: { ...q, sessionId: targetSessionId },
                     });
-                    conversationManager.markPendingUserQuestionDelivered(sessionId, q.requestId);
+                    conversationManager.markPendingUserQuestionDelivered(targetSessionId, q.requestId);
                     console.log(`[WebSocket] Resending pending user question: ${q.header} (${q.requestId})`);
                 }
             }
-            else if (conversationManager.needsContinuation(sessionId)) {
+            else if (conversationManager.needsContinuation(targetSessionId)) {
                 // SelfEvolve 重启等场景：工具结果已保存但模型还没来得及继续回复
                 // 自动触发对话继续，让模型接着上次中断的地方回复
-                console.log(`[WebSocket] Session ${sessionId} needs continuation (last message is tool_result), auto-triggering`);
+                console.log(`[WebSocket] Session ${targetSessionId} needs continuation (last message is tool_result), auto-triggering`);
                 const continueMessageId = randomUUID();
-                const chatSessionId = sessionId;
+                const chatSessionId = targetSessionId;
                 const getActiveWs = () => {
                     return conversationManager.getWebSocket(chatSessionId) || ws;
                 };
@@ -2983,19 +3002,27 @@ async function handleSessionImport(client, content, format, conversationManager)
 async function handleSessionResume(client, sessionId, conversationManager) {
     const { ws } = client;
     try {
-        const success = await conversationManager.resumeSession(sessionId, client.permissionMode);
+        let targetSessionId = sessionId;
+        let success = await conversationManager.resumeSession(targetSessionId, client.permissionMode);
+        if (!success) {
+            const resolvedSessionId = resolveSessionRestoreTargetId(conversationManager, targetSessionId);
+            if (resolvedSessionId !== targetSessionId) {
+                targetSessionId = resolvedSessionId;
+                success = await conversationManager.resumeSession(targetSessionId, client.permissionMode);
+            }
+        }
         if (success) {
-            client.sessionId = sessionId;
+            client.sessionId = targetSessionId;
             // 重要：更新会话的 WebSocket 连接，确保 UserInteractionHandler 和 TaskManager 使用新连接
-            conversationManager.setWebSocket(sessionId, ws);
-            const history = conversationManager.getHistory(sessionId);
-            const sessionRuntimeBackend = conversationManager.getSessionRuntimeBackend(sessionId) || webAuth.getRuntimeBackend();
-            const sessionModel = conversationManager.getSessionModel(sessionId) || getDefaultChatModel(sessionRuntimeBackend);
+            conversationManager.setWebSocket(targetSessionId, ws);
+            const history = conversationManager.getHistory(targetSessionId);
+            const sessionRuntimeBackend = conversationManager.getSessionRuntimeBackend(targetSessionId) || webAuth.getRuntimeBackend();
+            const sessionModel = conversationManager.getSessionModel(targetSessionId) || getDefaultChatModel(sessionRuntimeBackend);
             client.model = sessionModel;
             client.runtimeBackend = sessionRuntimeBackend;
             sendMessage(ws, {
                 type: 'session_switched',
-                payload: { sessionId, history, model: sessionModel, runtimeBackend: sessionRuntimeBackend },
+                payload: { sessionId: targetSessionId, history, model: sessionModel, runtimeBackend: sessionRuntimeBackend },
             });
         }
         else {