axon-code 2.4.0 → 2.6.1

package/dist/web/server/websocket.js

@@ -26,8 +26,12 @@ import { TerminalManager } from './terminal-manager.js';
 import { logger } from '../../utils/logger.js';
 // 错误感知
 import { errorWatcher } from '../../utils/error-watcher.js';
+import { buildImageAttachmentPathHints, saveBase64AttachmentToTempFile, } from './image-attachments.js';
+import { getDefaultWebModelForBackend, normalizeWebRuntimeModelForBackend, } from '../shared/model-catalog.js';
 // Git WebSocket 处理函数
 import { handleGitGetStatus, handleGitGetLog, handleGitGetBranches, handleGitGetStashes, handleGitStage, handleGitUnstage, handleGitCommit, handleGitPush, handleGitPull, handleGitCheckout, handleGitStashAndCheckout, handleGitForceCheckout, handleGitCreateBranch, handleGitDeleteBranch, handleGitStashSave, handleGitStashPop, handleGitStashDrop, handleGitStashApply, handleGitGetDiff, handleGitGetCommitDetail, handleGitGetCommitFileDiff, handleGitSmartCommit, handleGitSmartReview, handleGitSmartCommitAndReview, handleGitExplainCommit, handleGitMerge, handleGitRebase, handleGitMergeAbort, handleGitRebaseContinue, handleGitRebaseAbort, handleGitReset, handleGitDiscardFile, handleGitStageAll, handleGitUnstageAll, handleGitDiscardAll, handleGitAmendCommit, handleGitRevertCommit, handleGitCherryPick, handleGitGetTags, handleGitCreateTag, handleGitDeleteTag, handleGitPushTags, handleGitGetRemotes, handleGitAddRemote, handleGitRemoveRemote, handleGitFetch, handleGitSearchCommits, handleGitGetFileHistory, handleGitGetBlame, handleGitCompareBranches, handleGitGetMergeStatus, handleGitGetConflicts, handleGitResolveLock, } from './websocket-git-handlers.js';
+// cmux 终端集成（macOS 原生 AI 终端 https://github.com/manaflow-ai/cmux）
+import { getCmuxBridge } from '../../notifications/cmux.js';
 // ============================================================================
 // 工具分类函数 - 用于 Web UI 状态反馈
 // ============================================================================
@@ -63,6 +67,19 @@ const activeE2EState = new Map();
 const activeLeadAgentState = new Map();
 // 背压阈值：单连接缓冲区超过此字节数则视为慢客户端（参考 OpenClaw server-broadcast.ts）
 const MAX_BUFFERED_BYTES = 10 * 1024 * 1024; // 10MB
+function getDefaultChatModel(runtimeBackend = webAuth.getRuntimeBackend()) {
+    return getDefaultWebModelForBackend(runtimeBackend, webAuth.getDefaultModelByBackend()[runtimeBackend]);
+}
+/**
+ * 会话操作互斥锁：确保修改 client.sessionId 的操作不会并发执行
+ * 使用 Promise 链模式：每个操作 await 上一个操作完成后才开始
+ */
+function withSessionMutex(client, fn) {
+    const prev = client.sessionMutex || Promise.resolve();
+    let resolve;
+    client.sessionMutex = new Promise(r => { resolve = r; });
+    return prev.then(() => fn()).finally(() => resolve());
+}
 // 全局检查点管理器实例（惰性初始化，避免模块加载时的副作用日志）
 let _checkpointManager = null;
 function getCheckpointManager() {
@@ -1026,11 +1043,14 @@ export function setupWebSocket(wss, conversationManager) {
     wss.on('connection', (ws) => {
         const clientId = randomUUID();
         const sessionId = randomUUID();
+        const runtimeBackend = webAuth.getRuntimeBackend();
+        const defaultModel = getDefaultChatModel(runtimeBackend);
         const client = {
             id: clientId,
             ws,
             sessionId,
-            model: 'opus',
+            model: defaultModel,
+            runtimeBackend,
             isAlive: true,
             swarmSubscriptions: new Set(),
             permissionMode: 'bypassPermissions',
@@ -1042,7 +1062,8 @@ export function setupWebSocket(wss, conversationManager) {
             type: 'connected',
             payload: {
                 sessionId,
-                model: client.model,
+                model: defaultModel,
+                runtimeBackend,
                 serverStartTime,
             },
         });
@@ -1192,15 +1213,27 @@ async function handleClientMessage(client, message, conversationManager, swarmSu
             });
             break;
         }
-        case 'chat':
-            // 确保会话关联 WebSocket
-            conversationManager.setWebSocket(client.sessionId, ws);
-            // 如果消息中包含 projectPath，更新 client.projectPath
-            if (message.payload.projectPath !== undefined) {
-                client.projectPath = message.payload.projectPath;
+        case 'chat': {
+            // 使用会话互斥锁保护 session 初始化阶段（读取/修改 client.sessionId）
+            // 但不锁住整个流式响应，否则 session_new/session_switch 会被阻塞到 AI 回复完成
+            const chatContext = await withSessionMutex(client, async () => {
+                // 确保会话关联 WebSocket
+                conversationManager.setWebSocket(client.sessionId, ws);
+                // 如果消息中包含 projectPath，更新 client.projectPath
+                if (message.payload.projectPath !== undefined) {
+                    client.projectPath = message.payload.projectPath;
+                }
+                // prepareChatSession: 初始化会话并返回闭包需要的上下文
+                // 这里完成所有需要互斥保护的操作：读取 sessionId、创建持久化会话、更新 client.sessionId
+                const ctx = await prepareChatSession(client, message.payload.content, message.payload.attachments || message.payload.images, conversationManager, message.payload.thinkingConfig);
+                return ctx;
+            });
+            // Phase 2: 在锁外执行流式 chat（chatContext 中的 chatSessionId 已是闭包安全值）
+            if (chatContext) {
+                await executeChatStreaming(chatContext, conversationManager, message.payload.messageId);
             }
-            await handleChatMessage(client, message.payload.content, message.payload.attachments || message.payload.images, conversationManager, message.payload.messageId);
             break;
+        }
         case 'cancel':
             conversationManager.cancel(client.sessionId);
             sendMessage(ws, {
@@ -1223,8 +1256,8 @@ async function handleClientMessage(client, message, conversationManager, swarmSu
             });
             break;
         case 'set_model':
-            client.model = message.payload.model;
-            conversationManager.setModel(client.sessionId, message.payload.model);
+            client.model = normalizeWebRuntimeModelForBackend(client.runtimeBackend, message.payload.model, webAuth.getDefaultModelByBackend()[client.runtimeBackend]);
+            conversationManager.setModel(client.sessionId, client.model);
             break;
         case 'set_language':
             try {
@@ -1279,15 +1312,15 @@ async function handleClientMessage(client, message, conversationManager, swarmSu
             await handleSessionList(client, message.payload, conversationManager);
             break;
         case 'session_create':
-            await handleSessionCreate(client, message.payload, conversationManager);
+            await withSessionMutex(client, () => handleSessionCreate(client, message.payload, conversationManager));
             break;
         case 'session_new':
             // 官方规范：创建新的临时会话（不立即持久化）
             // 会话只有在发送第一条消息后才会真正创建
-            await handleSessionNew(client, message.payload, conversationManager);
+            await withSessionMutex(client, () => handleSessionNew(client, message.payload, conversationManager));
             break;
         case 'session_switch':
-            await handleSessionSwitch(client, message.payload.sessionId, conversationManager);
+            await withSessionMutex(client, () => handleSessionSwitch(client, message.payload.sessionId, conversationManager));
             break;
         case 'session_delete':
             await handleSessionDelete(client, message.payload.sessionId, conversationManager);
@@ -1882,9 +1915,10 @@ async function handleClientMessage(client, message, conversationManager, swarmSu
     }
 }
 /**
- * 处理聊天消息
+ * Phase 1: 在互斥锁内执行 — 初始化会话并返回流式 chat 所需的上下文
+ * 所有读取/修改 client.sessionId 的操作在此完成
  */
-async function handleChatMessage(client, content, attachments, conversationManager, userMessageId) {
+async function prepareChatSession(client, content, attachments, conversationManager, thinkingConfig) {
     const { ws, model, projectPath } = client;
     let { sessionId } = client;
     console.log(`[WebSocket] handleChatMessage - sessionId: ${sessionId}, projectPath: ${projectPath || 'undefined'}`);
@@ -1894,12 +1928,12 @@ async function handleChatMessage(client, content, attachments, conversationManag
             type: 'error',
             payload: { message: 'API Key not configured. Please configure an API Key in settings or log in via OAuth before sending messages.' },
         });
-        return;
+        return null;
     }
     // 检查是否为斜杠命令
     if (isSlashCommand(content)) {
-        await handleSlashCommand(client, content, conversationManager);
-        return;
+        await handleSlashCommand(client, content, conversationManager, thinkingConfig);
+        return null;
     }
     // 确保会话存在于 sessionManager 中（处理临时会话 ID 的情况）
     const sessionManager = conversationManager.getSessionManager();
@@ -1908,14 +1942,17 @@ async function handleChatMessage(client, content, attachments, conversationManag
     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({
             name: firstPrompt, // 使用 firstPrompt 作为会话标题
             model: model,
+            runtimeBackend: client.runtimeBackend,
             tags: ['webui'],
             projectPath: client.projectPath, // 传递项目路径
         });
+        sessionManager.registerTemporarySessionId(newSession.metadata.id, temporarySessionId);
         // 更新 client 的 sessionId
         client.sessionId = newSession.metadata.id;
         sessionId = newSession.metadata.id;
@@ -1928,6 +1965,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                 sessionId: newSession.metadata.id,
                 name: newSession.metadata.name,
                 model: newSession.metadata.model,
+                runtimeBackend: client.runtimeBackend,
                 createdAt: newSession.metadata.createdAt,
             },
         });
@@ -1945,22 +1983,43 @@ async function handleChatMessage(client, content, attachments, conversationManag
             console.log(`[WebSocket] Updating session title to firstPrompt: ${firstPrompt}`);
         }
     }
-    const messageId = randomUUID();
-    // 处理附件：图片直接传递给 Claude API，其他文件保存为临时文件传路径
+    // 处理附件：图片传递给模型视觉输入，同时也落盘为稳定的临时文件引用
     let mediaAttachments;
     let fileAttachments;
     let enhancedContent = content;
     if (attachments && Array.isArray(attachments)) {
         if (attachments.length > 0 && typeof attachments[0] === 'object') {
             const typedAttachments = attachments;
-            // 提取图片附件（直接传递给 Claude API）
+            // 提取图片附件（视觉输入 + 稳定临时文件路径）
             mediaAttachments = typedAttachments
                 .filter(att => att.type === 'image')
-                .map(att => ({
-                data: att.data,
-                mimeType: att.mimeType || 'image/png',
-                type: 'image',
-            }));
+                .map(att => {
+                const imageAttachment = {
+                    name: att.name,
+                    data: att.data,
+                    mimeType: att.mimeType || 'image/png',
+                    type: 'image',
+                };
+                try {
+                    imageAttachment.filePath = saveBase64AttachmentToTempFile(att.name, att.data);
+                    console.log('[WebSocket] Image attachment saved to temp file: ' + imageAttachment.filePath);
+                }
+                catch (error) {
+                    console.warn(`[WebSocket] Failed to persist image attachment ${att.name}:`, error);
+                }
+                return imageAttachment;
+            });
+            const imagePathHints = buildImageAttachmentPathHints(mediaAttachments);
+            if (imagePathHints.length > 0) {
+                enhancedContent = `Uploaded image files:\n${imagePathHints.join('\n')}\nUse the exact local image path above if you call ImageGen for one of these uploads.${enhancedContent ? `\n\n${enhancedContent}` : ''}`;
+            }
+            // 将图片编辑偏好显式注入到本轮文本上下文，降低模型忽略附件元数据的概率
+            const imageEditHints = typedAttachments
+                .filter(att => att.type === 'image' && att.imageEditStrength)
+                .map(att => `- ${att.name}: preferred image edit strength = ${att.imageEditStrength}`);
+            if (imageEditHints.length > 0) {
+                enhancedContent = `Image attachment edit preferences:\n${imageEditHints.join('\n')}${enhancedContent ? `\n\n${enhancedContent}` : ''}`;
+            }
             // 所有非图片附件统一保存为临时文件（包括 pdf/docx/xlsx/pptx/text/file 等任意格式）
             fileAttachments = typedAttachments
                 .filter(att => att.type !== 'image')
@@ -1972,11 +2031,26 @@ async function handleChatMessage(client, content, attachments, conversationManag
         }
         else {
             // 旧格式：直接是 base64 字符串数组（默认图片 png）
-            mediaAttachments = attachments.map(data => ({
-                data,
-                mimeType: 'image/png',
-                type: 'image',
-            }));
+            mediaAttachments = attachments.map((data, index) => {
+                const imageAttachment = {
+                    name: `uploaded-image-${index + 1}.png`,
+                    data,
+                    mimeType: 'image/png',
+                    type: 'image',
+                };
+                try {
+                    imageAttachment.filePath = saveBase64AttachmentToTempFile(imageAttachment.name, data);
+                    console.log('[WebSocket] Legacy image attachment saved to temp file: ' + imageAttachment.filePath);
+                }
+                catch (error) {
+                    console.warn(`[WebSocket] Failed to persist legacy image attachment ${imageAttachment.name}:`, error);
+                }
+                return imageAttachment;
+            });
+            const imagePathHints = buildImageAttachmentPathHints(mediaAttachments);
+            if (imagePathHints.length > 0) {
+                enhancedContent = `Uploaded image files:\n${imagePathHints.join('\n')}\nUse the exact local image path above if you call ImageGen for one of these uploads.${enhancedContent ? `\n\n${enhancedContent}` : ''}`;
+            }
         }
     }
     // 处理非图片文件附件：保存到临时目录，将文件路径告知模型
@@ -2007,6 +2081,26 @@ async function handleChatMessage(client, content, attachments, conversationManag
     const getActiveWs = () => {
         return conversationManager.getWebSocket(chatSessionId) || ws;
     };
+    return {
+        chatSessionId,
+        model,
+        projectPath: client.projectPath,
+        ws,
+        enhancedContent,
+        mediaAttachments,
+        permissionMode: client.permissionMode,
+        runtimeBackend: client.runtimeBackend,
+        thinkingConfig,
+        getActiveWs,
+    };
+}
+/**
+ * Phase 2: 在互斥锁外执行 — 实际的流式 AI 对话
+ * 使用 chatSessionId 闭包值，不再读写 client.sessionId
+ */
+async function executeChatStreaming(ctx, conversationManager, userMessageId) {
+    const { chatSessionId, model, enhancedContent, mediaAttachments, thinkingConfig, getActiveWs } = ctx;
+    const messageId = randomUUID();
     // 始终发送流式消息到 WebSocket，不做服务端门控
     // 客户端已有基于 sessionId 的会话隔离过滤（useMessageHandler），
     // 服务端门控（isActiveSession）会导致用户切换会话或刷新页面时消息永久丢失，
@@ -2019,6 +2113,9 @@ async function handleChatMessage(client, content, attachments, conversationManag
         type: 'status',
         payload: { status: 'thinking', sessionId: chatSessionId },
     });
+    // cmux 集成：通知 cmux 终端 Agent 开始思考
+    const cmux = getCmuxBridge();
+    cmux.onThinking();
     try {
         // 调用对话管理器，传入流式回调（媒体附件包含 mimeType 和类型）
         // 所有回调使用 getActiveWs() 动态获取 WebSocket，确保刷新后消息仍能送达
@@ -2057,6 +2154,13 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     type: 'status',
                     payload: { status: 'tool_executing', message: `Executing ${toolName}...`, sessionId: chatSessionId },
                 });
+                cmux.onToolStart(toolName);
+            },
+            onToolUseInputReady: (toolUseId, input) => {
+                sendMessage(getActiveWs(), {
+                    type: 'tool_use_input_ready',
+                    payload: { toolUseId, input, sessionId: chatSessionId },
+                });
             },
             onToolUseDelta: (toolUseId, partialJson) => {
                 sendMessage(getActiveWs(), {
@@ -2083,6 +2187,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     type: 'permission_request',
                     payload: { ...request, sessionId: chatSessionId },
                 });
+                cmux.onPermissionRequest(request.toolName || 'Unknown', request.description || 'execute');
             },
             onComplete: async (stopReason, usage) => {
                 // 保存会话到磁盘（确保 messageCount 正确更新）
@@ -2112,6 +2217,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     type: 'status',
                     payload: { status: 'idle', sessionId: chatSessionId },
                 });
+                cmux.onComplete();
             },
             onError: (error) => {
                 // 页面刷新恢复：错误时也需要重发 history 确保客户端状态一致
@@ -2130,6 +2236,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     type: 'status',
                     payload: { status: 'idle', sessionId: chatSessionId },
                 });
+                cmux.onError(error.message);
             },
             onContextUpdate: (usage) => {
                 sendMessage(getActiveWs(), {
@@ -2160,7 +2267,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     });
                 }
             },
-        }, client.projectPath, getActiveWs(), client.permissionMode, userMessageId); // 传入动态 ws、权限模式和前端消息 ID，确保跨会话持久化
+        }, ctx.projectPath, getActiveWs(), ctx.permissionMode, userMessageId, thinkingConfig); // 传入动态 ws、权限模式和前端消息 ID，确保跨会话持久化
     }
     catch (error) {
         console.error('[WebSocket] Chat handling error:', error);
@@ -2177,7 +2284,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
 /**
  * 处理斜杠命令
  */
-async function handleSlashCommand(client, command, conversationManager) {
+async function handleSlashCommand(client, command, conversationManager, thinkingConfig) {
     const { ws, sessionId, model, projectPath } = client;
     try {
         // 获取当前工作目录（优先使用项目路径）
@@ -2221,7 +2328,9 @@ async function handleSlashCommand(client, command, conversationManager) {
         }
         // 如果命令返回 chatPrompt，将其作为聊天消息发送给 AI（用于 /init 等命令）
         if (result.success && result.data?.chatPrompt) {
-            await handleChatMessage(client, result.data.chatPrompt, undefined, conversationManager);
+            const ctx = await withSessionMutex(client, () => prepareChatSession(client, result.data.chatPrompt, undefined, conversationManager, thinkingConfig));
+            if (ctx)
+                await executeChatStreaming(ctx, conversationManager);
             return;
         }
         // 如果内置命令未找到，尝试作为 skill 执行
@@ -2246,7 +2355,9 @@ async function handleSlashCommand(client, command, conversationManager) {
                 }
                 const messageContent = `[Skill: ${skill.skillName}]\n\n${skillContent}`;
                 console.log(`[WebSocket] Executing skill ${skill.skillName}, content length: ${skillContent.length}`);
-                await handleChatMessage(client, messageContent, undefined, conversationManager);
+                const skillCtx = await withSessionMutex(client, () => prepareChatSession(client, messageContent, undefined, conversationManager, thinkingConfig));
+                if (skillCtx)
+                    await executeChatStreaming(skillCtx, conversationManager);
                 return;
             }
         }
@@ -2326,6 +2437,7 @@ async function handleSessionList(client, payload, conversationManager) {
                     updatedAt: s.updatedAt,
                     messageCount: s.messageCount,
                     model: s.model,
+                    runtimeBackend: s.runtimeBackend,
                     cost: s.cost,
                     tokenUsage: s.tokenUsage,
                     tags: s.tags,
@@ -2357,22 +2469,27 @@ async function handleSessionCreate(client, payload, conversationManager) {
     try {
         const { name, model, tags, projectPath } = payload;
         const sessionManager = conversationManager.getSessionManager();
+        const runtimeBackend = payload?.runtimeBackend || client.runtimeBackend || webAuth.getRuntimeBackend();
+        const effectiveModel = normalizeWebRuntimeModelForBackend(runtimeBackend, model || client.model || getDefaultChatModel(runtimeBackend), webAuth.getDefaultModelByBackend()[runtimeBackend]);
         const newSession = sessionManager.createSession({
             name: name || `WebUI Session - ${new Date().toLocaleString('en-US')}`,
-            model: model || 'opus',
+            model: effectiveModel,
+            runtimeBackend,
             tags: tags || ['webui'],
             projectPath,
         });
         // 更新客户端会话状态
         client.sessionId = newSession.metadata.id;
-        client.model = model || 'opus';
+        client.model = effectiveModel;
+        client.runtimeBackend = runtimeBackend;
         client.projectPath = projectPath;
         sendMessage(ws, {
             type: 'session_created',
             payload: {
                 sessionId: newSession.metadata.id,
                 name: newSession.metadata.name,
-                model: newSession.metadata.model,
+                model: effectiveModel,
+                runtimeBackend,
                 createdAt: newSession.metadata.createdAt,
                 projectPath: newSession.metadata.projectPath,
             },
@@ -2400,11 +2517,13 @@ async function handleSessionNew(client, payload, conversationManager) {
         await conversationManager.persistSession(client.sessionId);
         // 生成新的临时 sessionId（使用 crypto 生成 UUID）
         const tempSessionId = randomUUID();
-        const model = payload?.model || client.model || 'opus';
+        const runtimeBackend = payload?.runtimeBackend || client.runtimeBackend || webAuth.getRuntimeBackend();
+        const model = normalizeWebRuntimeModelForBackend(runtimeBackend, payload?.model || client.model || getDefaultChatModel(runtimeBackend), webAuth.getDefaultModelByBackend()[runtimeBackend]);
         const projectPath = payload?.projectPath;
         // 更新 client 的 sessionId、model 和 projectPath
         client.sessionId = tempSessionId;
         client.model = model;
+        client.runtimeBackend = runtimeBackend;
         client.projectPath = projectPath;
         // 清空内存中的会话状态（如果存在）
         // 不创建持久化会话，等待用户发送第一条消息时再创建
@@ -2415,6 +2534,7 @@ async function handleSessionNew(client, payload, conversationManager) {
             payload: {
                 sessionId: tempSessionId,
                 model: model,
+                runtimeBackend,
                 projectPath,
             },
         });
@@ -2429,39 +2549,68 @@ 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 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, projectPath: client.projectPath, history },
+                payload: {
+                    sessionId: targetSessionId,
+                    sessionName,
+                    projectPath: client.projectPath,
+                    history,
+                    model: sessionModel,
+                    runtimeBackend: sessionRuntimeBackend,
+                },
             });
             // 同步权限配置到客户端（刷新后客户端 permissionMode 会重置为 'default'，需要从服务端恢复）
-            const permConfig = conversationManager.getPermissionConfig(sessionId);
+            const permConfig = conversationManager.getPermissionConfig(targetSessionId);
             if (permConfig) {
                 sendMessage(ws, {
                     type: 'permission_config_update',
@@ -2475,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 },
                             });
                         }
                     }
@@ -2509,39 +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.getPendingUserQuestions(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(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;
                 };
@@ -2589,6 +2739,12 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
                             payload: { status: 'tool_executing', message: `Executing ${toolName}...`, sessionId: chatSessionId },
                         });
                     },
+                    onToolUseInputReady: (toolUseId, input) => {
+                        sendMessage(getActiveWs(), {
+                            type: 'tool_use_input_ready',
+                            payload: { toolUseId, input, sessionId: chatSessionId },
+                        });
+                    },
                     onToolUseDelta: (toolUseId, partialJson) => {
                         sendMessage(getActiveWs(), {
                             type: 'tool_use_delta',
@@ -2682,9 +2838,17 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
             // IM 会话尚未创建（首条消息还在处理中），预先切换过去
             // chat() 运行时会在内存中创建该会话，流式消息会正常显示
             client.sessionId = sessionId;
+            client.runtimeBackend = webAuth.getRuntimeBackend();
+            client.model = getDefaultChatModel(client.runtimeBackend);
             sendMessage(ws, {
                 type: 'session_switched',
-                payload: { sessionId, projectPath: client.projectPath, history: [] },
+                payload: {
+                    sessionId,
+                    projectPath: client.projectPath,
+                    history: [],
+                    model: client.model,
+                    runtimeBackend: client.runtimeBackend,
+                },
             });
         }
         else {
@@ -2838,15 +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);
+            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 },
+                payload: { sessionId: targetSessionId, history, model: sessionModel, runtimeBackend: sessionRuntimeBackend },
             });
         }
         else {