axon-code 2.4.0 → 2.5.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();
@@ -1913,6 +1947,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
         const newSession = sessionManager.createSession({
             name: firstPrompt, // 使用 firstPrompt 作为会话标题
             model: model,
+            runtimeBackend: client.runtimeBackend,
             tags: ['webui'],
             projectPath: client.projectPath, // 传递项目路径
         });
@@ -1928,6 +1963,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 +1981,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 +2029,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 +2079,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 +2111,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 +2152,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 +2185,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 +2215,7 @@ async function handleChatMessage(client, content, attachments, conversationManag
                     type: 'status',
                     payload: { status: 'idle', sessionId: chatSessionId },
                 });
+                cmux.onComplete();
             },
             onError: (error) => {
                 // 页面刷新恢复：错误时也需要重发 history 确保客户端状态一致
@@ -2130,6 +2234,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 +2265,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 +2282,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 +2326,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 +2353,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 +2435,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 +2467,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 +2515,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 +2532,7 @@ async function handleSessionNew(client, payload, conversationManager) {
             payload: {
                 sessionId: tempSessionId,
                 model: model,
+                runtimeBackend,
                 projectPath,
             },
         });
@@ -2456,9 +2574,21 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
             // 获取会话历史（使用 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);
+            client.model = sessionModel;
+            client.runtimeBackend = sessionRuntimeBackend;
             sendMessage(ws, {
                 type: 'session_switched',
-                payload: { sessionId, projectPath: client.projectPath, history },
+                payload: {
+                    sessionId,
+                    sessionName,
+                    projectPath: client.projectPath,
+                    history,
+                    model: sessionModel,
+                    runtimeBackend: sessionRuntimeBackend,
+                },
             });
             // 同步权限配置到客户端（刷新后客户端 permissionMode 会重置为 'default'，需要从服务端恢复）
             const permConfig = conversationManager.getPermissionConfig(sessionId);
@@ -2527,12 +2657,13 @@ async function handleSessionSwitch(client, sessionId, conversationManager) {
                     });
                     console.log(`[WebSocket] Resending pending permission request: ${req.tool} (${req.requestId})`);
                 }
-                const pendingQuestions = conversationManager.getPendingUserQuestions(sessionId);
+                const pendingQuestions = conversationManager.getUndeliveredPendingUserQuestions(sessionId);
                 for (const q of pendingQuestions) {
                     sendMessage(ws, {
                         type: 'user_question',
                         payload: { ...q, sessionId },
                     });
+                    conversationManager.markPendingUserQuestionDelivered(sessionId, q.requestId);
                     console.log(`[WebSocket] Resending pending user question: ${q.header} (${q.requestId})`);
                 }
             }
@@ -2589,6 +2720,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 +2819,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 {
@@ -2844,9 +2989,13 @@ async function handleSessionResume(client, sessionId, conversationManager) {
             // 重要：更新会话的 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);
+            client.model = sessionModel;
+            client.runtimeBackend = sessionRuntimeBackend;
             sendMessage(ws, {
                 type: 'session_switched',
-                payload: { sessionId, history },
+                payload: { sessionId, history, model: sessionModel, runtimeBackend: sessionRuntimeBackend },
             });
         }
         else {