axon-code 2.4.0 → 2.6.1

package/dist/web/server/conversation.js

@@ -2,7 +2,6 @@
  * 对话管理器
  * 封装核心对话逻辑，提供 WebUI 专用接口
  */
-import { ClaudeClient } from '../../core/client.js';
 import { Session } from '../../core/session.js';
 import { runWithCwd } from '../../core/cwd-context.js';
 import { runWithSessionId } from '../../core/session-context.js';
@@ -15,6 +14,7 @@ import { createOAuthApiKey } from '../../auth/index.js';
 import { UserInteractionHandler } from './user-interaction.js';
 import { PermissionHandler } from './permission-handler.js';
 import { runPreToolUseHooks, runPostToolUseHooks, runPostToolUseFailureHooks } from '../../hooks/index.js';
+import { getChangeTracker } from '../../hooks/auto-verify.js';
 import { WebSessionManager } from './session-manager.js';
 import { walAppend, walCheckpoint } from '../../session/index.js';
 import { TaskManager } from './task-manager.js';
@@ -45,6 +45,13 @@ import { appendRunLog } from '../../daemon/run-log.js';
 import { promptSnippetsManager } from './prompt-snippets.js';
 import { isEvolveRestartRequested, triggerGracefulShutdown } from './evolve-state.js';
 import { loadActiveGoals } from '../../goals/index.js';
+import { getAppManager } from './app-manager.js';
+import { createConversationClient } from './runtime/factory.js';
+import { resolveRuntimeSelection } from './runtime/runtime-selection.js';
+import { normalizeToolInputForWebRuntime } from './runtime/tool-input-normalizer.js';
+import { resolveImageGenSource, } from './image-attachments.js';
+import { getProviderForRuntimeBackend, } from '../shared/model-catalog.js';
+import { mapThinkingConfigToRuntimeOptions, } from '../shared/thinking-config.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -360,7 +367,7 @@ export class ConversationManager {
     temporarilyEnabledMcpServers = new Set();
     constructor(cwd, defaultModel = 'opus', options) {
         this.cwd = cwd;
-        this.defaultModel = defaultModel;
+        this.defaultModel = this.normalizeRuntimeModel(defaultModel);
         this.options = options;
         this.sessionManager = new WebSessionManager(cwd);
         this.mcpConfigManager = new McpConfigManager({
@@ -384,6 +391,13 @@ export class ConversationManager {
         });
         // 注册蓝图工具（仅 Web 模式需要，CLI 模式不加载）
         registerBlueprintTools();
+        // 初始化插件工具同步 — 将插件注册的工具桥接到 toolRegistry
+        // 这样 ConversationLoop 通过 toolRegistry.getDefinitions() 能拿到插件工具，模型 API 可以调用
+        const { initPluginToolSync } = await import('../../tools/index.js');
+        initPluginToolSync();
+        // 发现并加载已安装的插件，触发工具注册事件
+        await pluginManager.discover();
+        console.log(`[ConversationManager] Plugin discover completed, ${pluginManager.getTools().length} plugin tools synced`);
         // v12.0: 注入 StartLeadAgent 自包含执行上下文（支持 TaskPlan + 结构化错误）
         StartLeadAgentTool.setContext({
             getBlueprint: (id) => blueprintStore.get(id),
@@ -734,36 +748,79 @@ export class ConversationManager {
     /**
      * 计算凭据指纹，用于检测认证变更
      */
-    getCredentialsFingerprint() {
-        const creds = webAuth.getCredentials();
+    getCredentialsFingerprint(runtimeBackend = this.getRuntimeBackend()) {
+        const creds = webAuth.getCredentials(runtimeBackend);
         // 用凭据的关键字段拼接成指纹，任何变更都会导致指纹不同
-        return `${creds.apiKey || ''}\0${creds.authToken || ''}\0${creds.baseUrl || ''}`;
+        return `${this.getRuntimeProvider(runtimeBackend)}\0${creds.apiKey || ''}\0${creds.authToken || ''}\0${creds.baseUrl || ''}\0${creds.accountId || ''}`;
     }
     /**
      * 检查凭据是否变更，如果变更则重建客户端
      * 处理场景：用户在 WebUI 重新登录/切换 API Key 后，已有会话自动使用新凭据
      */
     ensureClientCredentialsFresh(state) {
-        const currentFingerprint = this.getCredentialsFingerprint();
+        const currentFingerprint = this.getCredentialsFingerprint(state.runtimeBackend);
         if (state.credentialsFingerprint && state.credentialsFingerprint !== currentFingerprint) {
             console.log('[ConversationManager] Detected auth credentials change, rebuilding client');
-            const newConfig = this.buildClientConfig(state.model);
-            state.client = new ClaudeClient({ ...newConfig });
+            const newConfig = this.buildClientConfig(state.model, state.runtimeBackend);
+            state.client = createConversationClient(newConfig);
             state.credentialsFingerprint = currentFingerprint;
         }
     }
+    getRuntimeBackend() {
+        return webAuth.getRuntimeBackend();
+    }
+    getRuntimeSelection(model, runtimeBackend = this.getRuntimeBackend()) {
+        return resolveRuntimeSelection({
+            runtimeBackend,
+            model,
+            defaultModelByBackend: webAuth.getDefaultModelByBackend(),
+            customModelCatalogByBackend: webAuth.getCustomModelCatalogByBackend(),
+            codexModelName: webAuth.getCodexModelName(),
+            customModelName: webAuth.getCustomModelName(),
+        });
+    }
+    getRuntimeProvider(runtimeBackend = this.getRuntimeBackend()) {
+        return this.getRuntimeSelection(undefined, runtimeBackend).provider;
+    }
+    getRuntimeCustomModelName(runtimeBackend = this.getRuntimeBackend()) {
+        return this.getRuntimeSelection(undefined, runtimeBackend).customModelName;
+    }
+    normalizeRuntimeModel(model, runtimeBackend = this.getRuntimeBackend()) {
+        return this.getRuntimeSelection(model, runtimeBackend).normalizedModel;
+    }
+    ensureStateModelMatchesRuntime(state) {
+        const normalizedModel = this.normalizeRuntimeModel(state.model, state.runtimeBackend);
+        if (normalizedModel === state.model) {
+            return;
+        }
+        state.model = normalizedModel;
+        state.client = createConversationClient(this.buildClientConfig(normalizedModel, state.runtimeBackend));
+    }
     /**
      * 构建 ClaudeClient 配置
      * 认证全部委托给 webAuth（唯一认证入口）
      */
-    buildClientConfig(model) {
-        const creds = webAuth.getCredentials();
-        const customModel = webAuth.getCustomModelName();
+    buildClientConfig(model, runtimeBackend = this.getRuntimeBackend()) {
+        const creds = webAuth.getCredentials(runtimeBackend);
+        const selection = this.getRuntimeSelection(model, runtimeBackend);
+        const normalizedModel = selection.normalizedModel;
+        const provider = selection.provider;
+        const customModel = selection.customModelName;
+        const authStatus = webAuth.getStatus();
+        const identityVariant = provider === 'anthropic'
+            && runtimeBackend === 'claude-compatible-api'
+            && authStatus.type === 'oauth'
+            ? 'agent'
+            : undefined;
         return {
-            model: customModel || this.getModelId(model),
+            provider,
+            model: provider === 'codex' ? normalizedModel : this.getModelId(normalizedModel),
             apiKey: creds.apiKey,
             authToken: creds.authToken,
             baseUrl: creds.baseUrl,
+            accountId: creds.accountId,
+            customModelName: customModel,
+            identityVariant,
             timeout: 300000,
         };
     }
@@ -777,6 +834,7 @@ export class ConversationManager {
             apiKey: config.apiKey,
             authToken: config.authToken,
             baseUrl: config.baseUrl,
+            accountId: config.accountId,
         };
     }
     /**
@@ -784,6 +842,26 @@ export class ConversationManager {
      * 这个方法在每次调用 API 之前被调用，检查 token 是否过期，如果过期则自动刷新
      */
     async ensureValidOAuthToken(state) {
+        const runtimeProvider = getProviderForRuntimeBackend(state.runtimeBackend, state.model);
+        const authStatus = webAuth.getStatus();
+        if (runtimeProvider !== 'anthropic') {
+            const tokenBefore = webAuth.getCredentials(state.runtimeBackend).authToken;
+            const refreshOk = await webAuth.ensureValidToken(state.runtimeBackend);
+            if (!refreshOk) {
+                throw new Error('OAuth token expired, refresh failed. Please log in again.');
+            }
+            const tokenAfter = webAuth.getCredentials(state.runtimeBackend).authToken;
+            if (tokenBefore !== tokenAfter) {
+                const newConfig = this.buildClientConfig(state.model, state.runtimeBackend);
+                state.client = createConversationClient(newConfig);
+                state.credentialsFingerprint = this.getCredentialsFingerprint(state.runtimeBackend);
+                console.log('[ConversationManager] Client now using refreshed OAuth credentials');
+            }
+            return;
+        }
+        if (authStatus.type !== 'oauth') {
+            return;
+        }
         // 只在使用 OAuth 时处理
         const oauthConfig = oauthManager.getOAuthConfig();
         if (!oauthConfig) {
@@ -799,9 +877,9 @@ export class ConversationManager {
                 if (apiKey) {
                     await oauthManager.saveOAuthConfig({ oauthApiKey: apiKey });
                     console.log('[ConversationManager] OAuth API Key auto-created, rebuilding client');
-                    const newConfig = this.buildClientConfig(state.model);
-                    state.client = new ClaudeClient({ ...newConfig });
-                    state.credentialsFingerprint = this.getCredentialsFingerprint();
+                    const newConfig = this.buildClientConfig(state.model, state.runtimeBackend);
+                    state.client = createConversationClient(newConfig);
+                    state.credentialsFingerprint = this.getCredentialsFingerprint(state.runtimeBackend);
                 }
                 else {
                     console.warn('[ConversationManager] createOAuthApiKey returned null, inference may fail');
@@ -814,16 +892,16 @@ export class ConversationManager {
         // 记住刷新前的 token，用于判断是否需要重建客户端
         const tokenBefore = oauthManager.getOAuthConfig()?.accessToken;
         // 统一的 token 有效性检查（对齐官方 NM() 语义）
-        const refreshOk = await webAuth.ensureValidToken();
+        const refreshOk = await webAuth.ensureValidToken(state.runtimeBackend);
         if (!refreshOk) {
             throw new Error('OAuth token expired, refresh failed. Please log in again.');
         }
         // 只有 token 真正变更了才重建客户端
         const tokenAfter = oauthManager.getOAuthConfig()?.accessToken;
         if (tokenBefore !== tokenAfter) {
-            const newConfig = this.buildClientConfig(state.model);
-            state.client = new ClaudeClient({ ...newConfig });
-            state.credentialsFingerprint = this.getCredentialsFingerprint();
+            const newConfig = this.buildClientConfig(state.model, state.runtimeBackend);
+            state.client = createConversationClient(newConfig);
+            state.credentialsFingerprint = this.getCredentialsFingerprint(state.runtimeBackend);
             console.log('[ConversationManager] Client now using refreshed OAuth credentials');
         }
     }
@@ -834,6 +912,8 @@ export class ConversationManager {
     async getOrCreateSession(sessionId, model, projectPath, permissionMode) {
         let state = this.sessions.get(sessionId);
         if (state) {
+            state.runtimeBackend = state.runtimeBackend || this.getRuntimeBackend();
+            this.ensureStateModelMatchesRuntime(state);
             // 会话已存在，检查是否需要更新工作目录
             if (projectPath && state.session.cwd !== projectPath) {
                 console.log(`[ConversationManager] Updated session ${sessionId} working directory: ${state.session.cwd} -> ${projectPath}`);
@@ -848,15 +928,14 @@ export class ConversationManager {
         }
         // 创建新会话
         const workingDir = projectPath || this.cwd;
+        const runtimeBackend = this.getRuntimeBackend();
+        const resolvedModel = this.normalizeRuntimeModel(model || this.defaultModel, runtimeBackend);
         console.log(`[ConversationManager] Creating new session ${sessionId}, workingDir: ${workingDir}, permissionMode: ${permissionMode || 'default'}`);
         const session = new Session(workingDir, sessionId);
         await session.initializeGitInfo();
         // 使用与核心 loop.ts 一致的认证逻辑
-        const clientConfig = this.buildClientConfig(model || this.defaultModel);
-        const client = new ClaudeClient({
-            ...clientConfig,
-            timeout: clientConfig.timeout,
-        });
+        const clientConfig = this.buildClientConfig(resolvedModel, runtimeBackend);
+        const client = createConversationClient(clientConfig);
         // 创建用户交互处理器
         const userInteractionHandler = new UserInteractionHandler();
         userInteractionHandler.setSessionId(sessionId);
@@ -870,7 +949,8 @@ export class ConversationManager {
             session,
             client,
             messages: [],
-            model: model || this.defaultModel,
+            model: resolvedModel,
+            runtimeBackend,
             cancelled: false,
             chatHistory: [],
             userInteractionHandler,
@@ -887,8 +967,9 @@ export class ConversationManager {
             processingGeneration: 0,
             lastActualInputTokens: 0,
             messagesLenAtLastApiCall: 0,
+            latestImageAttachments: [],
             lastPersistedMessageCount: 0,
-            credentialsFingerprint: this.getCredentialsFingerprint(),
+            credentialsFingerprint: this.getCredentialsFingerprint(runtimeBackend),
         };
         this.sessions.set(sessionId, state);
         // 初始化 session memory（官方 session-memory 功能）
@@ -925,15 +1006,28 @@ export class ConversationManager {
     setModel(sessionId, model) {
         const state = this.sessions.get(sessionId);
         if (state) {
-            state.model = model;
+            const normalizedModel = this.normalizeRuntimeModel(model, state.runtimeBackend);
+            state.model = normalizedModel;
             // 使用与核心 loop.ts 一致的认证逻辑
-            const clientConfig = this.buildClientConfig(model);
-            state.client = new ClaudeClient({
-                ...clientConfig,
-                timeout: clientConfig.timeout,
-            });
+            const clientConfig = this.buildClientConfig(normalizedModel, state.runtimeBackend);
+            state.client = createConversationClient(clientConfig);
         }
     }
+    getSessionModel(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state) {
+            return null;
+        }
+        this.ensureStateModelMatchesRuntime(state);
+        return state.model;
+    }
+    getSessionRuntimeBackend(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state) {
+            return null;
+        }
+        return state.runtimeBackend;
+    }
     /**
      * 获取历史记录
      */
@@ -961,7 +1055,7 @@ export class ConversationManager {
         const hasCompactBoundary = state.chatHistory.some(m => m.isCompactBoundary);
         if (!hasCompactBoundary) {
             // 未压缩：messages 是完整的，可以安全重建
-            return this.convertMessagesToChatHistory(state.messages);
+            return this.convertMessagesToChatHistory(state.messages, state.runtimeBackend);
         }
         // 已压缩：以 chatHistory 为基础，找出 messages 中还没同步的增量部分
         // chatHistory 中最后一条记录的 _messagesLen 表示已经同步到 messages 的哪个位置
@@ -975,7 +1069,7 @@ export class ConversationManager {
         if (incrementalMessages.length === 0) {
             return state.chatHistory;
         }
-        const incrementalHistory = this.convertMessagesToChatHistory(incrementalMessages);
+        const incrementalHistory = this.convertMessagesToChatHistory(incrementalMessages, state.runtimeBackend);
         return [...state.chatHistory, ...incrementalHistory];
     }
     /**
@@ -1134,13 +1228,28 @@ export class ConversationManager {
         const state = this.sessions.get(sessionId);
         return state?.userInteractionHandler.getPendingPayloads() ?? [];
     }
+    /**
+     * 获取当前 ws 还未收到的待处理用户问题。
+     * 用于恢复会话时补发，避免重复弹窗。
+     */
+    getUndeliveredPendingUserQuestions(sessionId) {
+        const state = this.sessions.get(sessionId);
+        return state?.userInteractionHandler.getUndeliveredPayloadsForCurrentWebSocket() ?? [];
+    }
+    /**
+     * 标记问题已经送达当前 ws，防止同一连接被重复补发。
+     */
+    markPendingUserQuestionDelivered(sessionId, requestId) {
+        const state = this.sessions.get(sessionId);
+        state?.userInteractionHandler.markDeliveredToCurrentWebSocket(requestId);
+    }
     /**
      * 媒体附件信息（图片或 PDF）
      */
     /**
      * 发送聊天消息
      */
-    async chat(sessionId, content, mediaAttachments, model, callbacks, projectPath, ws, permissionMode, messageId) {
+    async chat(sessionId, content, mediaAttachments, model, callbacks, projectPath, ws, permissionMode, messageId, thinkingConfig) {
         const state = await this.getOrCreateSession(sessionId, model, projectPath, permissionMode);
         // 插话模式：如果会话正在处理中，取消当前操作并等待其完成
         if (state.isProcessing) {
@@ -1184,6 +1293,9 @@ export class ConversationManager {
             catch {
                 // 增强失败不影响主流程
             }
+            if (mediaAttachments && mediaAttachments.length > 0) {
+                state.latestImageAttachments = mediaAttachments.map(attachment => ({ ...attachment }));
+            }
             // 构建用户消息
             const userMessage = {
                 role: 'user',
@@ -1217,6 +1329,7 @@ export class ConversationManager {
                             media_type: attachment.mimeType,
                             data: attachment.data,
                         },
+                        fileName: attachment.name,
                     });
                 }
             }
@@ -1226,6 +1339,7 @@ export class ConversationManager {
                 role: 'user',
                 timestamp: Date.now(),
                 content: chatContentItems,
+                runtimeBackend: state.runtimeBackend,
                 _messagesLen: state.messages.length,
             };
             state.chatHistory.push(chatEntry);
@@ -1237,7 +1351,7 @@ export class ConversationManager {
             // 使用工作目录上下文包裹对话循环（与 CLI loop.ts 保持一致）
             // 确保所有工具执行都在正确的工作目录上下文中
             await runWithCwd(state.session.cwd, async () => {
-                await this.conversationLoop(state, callbacks, sessionId);
+                await this.conversationLoop(state, callbacks, sessionId, thinkingConfig);
             });
         }
         catch (error) {
@@ -1272,7 +1386,7 @@ export class ConversationManager {
     /**
      * 对话循环
      */
-    async conversationLoop(state, callbacks, sessionId) {
+    async conversationLoop(state, callbacks, sessionId, thinkingConfig) {
         let continueLoop = true;
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
@@ -1289,12 +1403,23 @@ export class ConversationManager {
         let messageConsistencyHealed = false;
         // 创建 AbortController，用于在取消时中断正在执行的工具
         state.currentAbortController = new AbortController();
+        // Auto-verify: 设置全局 sessionId 供工具层追踪文件变更
+        if (sessionId) {
+            globalThis.__currentSessionId = sessionId;
+        }
         while (continueLoop && !state.cancelled) {
             // 标记本次迭代是否已有内容流式输出到前端
             // 如果有内容已输出，则不进行自动重试（避免前端内容重复）
             let hasStreamedContent = false;
             // 初始化流式中间内容追踪（用于浏览器刷新后恢复）
             state.streamingContent = { thinkingText: '', textContent: '' };
+            // Auto-verify: 每轮迭代重置注入标记
+            if (sessionId) {
+                try {
+                    getChangeTracker(sessionId).resetTurnFlag();
+                }
+                catch { /* ignore */ }
+            }
             // 凭据变更检测（处理用户在 WebUI 重新登录后已有会话自动使用新凭据）
             this.ensureClientCredentialsFresh(state);
             // OAuth Token 自动刷新检查（在调用 API 之前）
@@ -1507,10 +1632,18 @@ export class ConversationManager {
             }
             // 将流式状态变量提升到 try 外，以便 catch 中断流自愈时可以访问
             const assistantContent = [];
+            let currentThinkingContent = '';
             let currentTextContent = '';
             let currentToolUse = null;
             let stopReason = null;
             let thinkingStarted = false;
+            const flushThinkingContent = () => {
+                if (!currentThinkingContent) {
+                    return;
+                }
+                assistantContent.push({ type: 'thinking', thinking: currentThinkingContent });
+                currentThinkingContent = '';
+            };
             // 对齐官方 v2.1.70：检查是否有 ToolSearch 工具（Mcp），决定是否启用 deferred tools
             const hasToolSearch = tools.some(t => t.name === 'Mcp');
             // 对齐官方 v2.1.70：注入 <available-deferred-tools> 列表到消息中
@@ -1542,11 +1675,13 @@ export class ConversationManager {
                 }
             }
             try {
-                // 调用 Claude API（使用 createMessageStream，默认开启 Extended Thinking）
+                const thinkingOptions = mapThinkingConfigToRuntimeOptions(state.runtimeBackend, state.model, thinkingConfig);
+                // 调用运行时 API（思考能力由前端 per-message 配置映射到真实 runtime 选项）
                 // 传递 abort signal，取消时可直接中止 HTTP 流（对齐官方 CLI）
                 const stream = state.client.createMessageStream(cleanedMessages, tools, systemPrompt.content, {
-                    enableThinking: true,
-                    thinkingBudget: 10000,
+                    enableThinking: thinkingOptions.enableThinking,
+                    thinkingBudget: thinkingOptions.thinkingBudget,
+                    reasoningEffort: thinkingOptions.reasoningEffort,
                     signal: state.currentAbortController?.signal,
                     promptBlocks: systemPrompt.blocks,
                     toolSearchEnabled: hasToolSearch,
@@ -1561,6 +1696,7 @@ export class ConversationManager {
                                 thinkingStarted = true;
                             }
                             if (event.thinking) {
+                                currentThinkingContent += event.thinking;
                                 // 追踪 thinking 内容（用于浏览器刷新恢复）
                                 if (state.streamingContent) {
                                     state.streamingContent.thinkingText += event.thinking;
@@ -1573,6 +1709,7 @@ export class ConversationManager {
                                 callbacks.onThinkingComplete?.();
                                 thinkingStarted = false;
                             }
+                            flushThinkingContent();
                             if (event.text) {
                                 hasStreamedContent = true;
                                 currentTextContent += event.text;
@@ -1584,6 +1721,11 @@ export class ConversationManager {
                             }
                             break;
                         case 'tool_use_start':
+                            if (thinkingStarted) {
+                                callbacks.onThinkingComplete?.();
+                                thinkingStarted = false;
+                            }
+                            flushThinkingContent();
                             hasStreamedContent = true;
                             // 保存之前的文本内容
                             if (currentTextContent) {
@@ -1592,25 +1734,38 @@ export class ConversationManager {
                             }
                             // 如果有未完成的工具调用（多工具响应时 content_block_stop 不产生事件），先完成它
                             if (currentToolUse) {
+                                // 优先使用 SDK 注入的 parsedInput
+                                const sdkPrev = currentToolUse.parsedInput;
                                 let prevInput = {};
-                                try {
-                                    prevInput = JSON.parse(currentToolUse.inputJson || '{}');
+                                if (sdkPrev && typeof sdkPrev === 'object' && Object.keys(sdkPrev).length > 0) {
+                                    prevInput = sdkPrev;
                                 }
-                                catch { /* 解析失败用空对象 */ }
+                                else {
+                                    try {
+                                        prevInput = JSON.parse(currentToolUse.inputJson || '{}');
+                                    }
+                                    catch {
+                                        console.warn(`[StreamDebug] Failed to parse tool input JSON for ${currentToolUse.name} (length=${currentToolUse.inputJson.length}), raw start: ${currentToolUse.inputJson.slice(0, 100)}`);
+                                    }
+                                }
+                                console.log(`[StreamDebug] tool_use_start: completing previous tool ${currentToolUse.name}(${currentToolUse.id}), keys=[${Object.keys(prevInput)}]`);
                                 assistantContent.push({
                                     type: 'tool_use',
                                     id: currentToolUse.id,
                                     name: currentToolUse.name,
                                     input: prevInput,
                                 });
-                                callbacks.onToolUseStart?.(currentToolUse.id, currentToolUse.name, prevInput);
+                                // 通知前端完整 input（参数流完毕）
+                                callbacks.onToolUseInputReady?.(currentToolUse.id, prevInput);
                             }
-                            // 开始新的工具调用（先不发送 onToolUseStart，等参数解析完成后再发送）
+                            // 开始新的工具调用 — 立即通知前端（参数尚在流式传输）
                             currentToolUse = {
                                 id: event.id || '',
                                 name: event.name || '',
                                 inputJson: '',
                             };
+                            console.log(`[StreamDebug] tool_use_start: new tool ${currentToolUse.name}(${currentToolUse.id}), sending _streaming=true to frontend`);
+                            callbacks.onToolUseStart?.(currentToolUse.id, currentToolUse.name, { _streaming: true });
                             break;
                         case 'tool_use_delta':
                             if (currentToolUse && event.input) {
@@ -1618,7 +1773,37 @@ export class ConversationManager {
                                 callbacks.onToolUseDelta?.(currentToolUse.id, event.input);
                             }
                             break;
+                        case 'tool_use_complete': {
+                            // 来自 SDK finalMessage 的完整 tool_use（input 已由 SDK parse 好）
+                            // 覆盖手动拼接的 inputJson，确保 input 的正确性
+                            const completeId = event.id;
+                            const completeInput = event.input;
+                            console.log(`[StreamDebug] tool_use_complete: id=${completeId}, inputKeys=${completeInput ? Object.keys(completeInput) : 'null'}`);
+                            // 如果当前有正在流式接收的工具且 id 匹配，直接注入解析好的 input
+                            if (currentToolUse && currentToolUse.id === completeId) {
+                                // 把 SDK 解析好的 input 保存到 currentToolUse（stop 事件会用）
+                                currentToolUse.parsedInput = completeInput;
+                            }
+                            else {
+                                // 可能是之前已经 push 到 assistantContent 的工具（多工具场景）
+                                // 用 SDK 的 input 覆盖手动 parse 的结果
+                                for (const block of assistantContent) {
+                                    if (block.type === 'tool_use' && block.id === completeId) {
+                                        block.input = completeInput || {};
+                                        // 同时通知前端更新
+                                        callbacks.onToolUseInputReady?.(completeId, completeInput || {});
+                                        break;
+                                    }
+                                }
+                            }
+                            break;
+                        }
                         case 'stop':
+                            if (thinkingStarted) {
+                                callbacks.onThinkingComplete?.();
+                                thinkingStarted = false;
+                            }
+                            flushThinkingContent();
                             // 完成当前文本块
                             if (currentTextContent) {
                                 assistantContent.push({ type: 'text', text: currentTextContent });
@@ -1626,12 +1811,22 @@ export class ConversationManager {
                             }
                             // 完成当前工具调用
                             if (currentToolUse) {
+                                // 优先使用 SDK finalMessage 中的 input（由 tool_use_complete 事件注入）
+                                // 回退到手动拼接 inputJson + JSON.parse（兼容非标准 API）
                                 let parsedInput = {};
-                                try {
-                                    parsedInput = JSON.parse(currentToolUse.inputJson || '{}');
+                                const sdkInput = currentToolUse.parsedInput;
+                                if (sdkInput && typeof sdkInput === 'object' && Object.keys(sdkInput).length > 0) {
+                                    parsedInput = sdkInput;
+                                    console.log(`[StreamDebug] stop: using SDK input for ${currentToolUse.name}(${currentToolUse.id}), keys=[${Object.keys(parsedInput)}]`);
                                 }
-                                catch (e) {
-                                    // 解析失败使用空对象
+                                else {
+                                    try {
+                                        parsedInput = JSON.parse(currentToolUse.inputJson || '{}');
+                                        console.log(`[StreamDebug] stop: using manual JSON.parse for ${currentToolUse.name}(${currentToolUse.id}), inputJson.length=${currentToolUse.inputJson.length}, keys=[${Object.keys(parsedInput)}]`);
+                                    }
+                                    catch (e) {
+                                        console.warn(`[StreamDebug] stop: JSON.parse FAILED for ${currentToolUse.name} (length=${currentToolUse.inputJson.length}, stopReason=${event.stopReason}), raw start: ${currentToolUse.inputJson.slice(0, 200)}`);
+                                    }
                                 }
                                 assistantContent.push({
                                     type: 'tool_use',
@@ -1639,8 +1834,8 @@ export class ConversationManager {
                                     name: currentToolUse.name,
                                     input: parsedInput,
                                 });
-                                // 现在发送 onToolUseStart（参数已完整解析，只发送一次）
-                                callbacks.onToolUseStart?.(currentToolUse.id, currentToolUse.name, parsedInput);
+                                // 通知前端完整 input（onToolUseStart 已在 tool_use_start 事件时发送）
+                                callbacks.onToolUseInputReady?.(currentToolUse.id, parsedInput);
                                 currentToolUse = null;
                             }
                             stopReason = event.stopReason || null;
@@ -1706,6 +1901,7 @@ export class ConversationManager {
                 networkRetryCount = 0;
                 justForceCompacted = false;
                 // 中断或正常结束时，保存未完成的文本内容
+                flushThinkingContent();
                 if (currentTextContent) {
                     assistantContent.push({ type: 'text', text: currentTextContent });
                     currentTextContent = '';
@@ -1794,6 +1990,28 @@ export class ConversationManager {
                             allNewMessages.push(...result.newMessages);
                         }
                     }
+                    // Auto-verify: 注入验证提示到最后一个工具结果
+                    if (sessionId && toolResults.length > 0) {
+                        try {
+                            const tracker = getChangeTracker(sessionId);
+                            const cwd = state.session.cwd || process.cwd();
+                            const hint = tracker.generateHint(cwd);
+                            if (hint) {
+                                // 找到最后一个 text 类型的工具结果并追加提示
+                                const lastResult = toolResults[toolResults.length - 1];
+                                if (typeof lastResult.content === 'string') {
+                                    lastResult.content += `\n\n<auto-verify>${hint}</auto-verify>`;
+                                }
+                                else if (Array.isArray(lastResult.content)) {
+                                    const textBlocks = lastResult.content.filter((b) => b.type === 'text');
+                                    if (textBlocks.length > 0) {
+                                        textBlocks[textBlocks.length - 1].text += `\n\n<auto-verify>${hint}</auto-verify>`;
+                                    }
+                                }
+                            }
+                        }
+                        catch { /* auto-verify 失败不影响主流程 */ }
+                    }
                     // 添加工具结果到消息
                     if (toolResults.length > 0) {
                         const toolResultMsg = {
@@ -1834,6 +2052,13 @@ export class ConversationManager {
                 else {
                     // 对话结束
                     continueLoop = false;
+                    // 对齐官方：max_tokens 截断时，流式输出错误消息告知用户
+                    if (stopReason === 'max_tokens') {
+                        const currentMax = getMaxOutputTokens(resolvedModel);
+                        const errorMsg = `\n\nClaude's response exceeded the ${currentMax} output token maximum. ` +
+                            `Set CLAUDE_CODE_MAX_OUTPUT_TOKENS environment variable to a higher value to configure.`;
+                        callbacks.onTextDelta?.(errorMsg);
+                    }
                     // 添加到聊天历史
                     const chatContent = assistantContent.map(block => {
                         if (block.type === 'text') {
@@ -1857,6 +2082,7 @@ export class ConversationManager {
                         timestamp: Date.now(),
                         content: chatContent,
                         model: state.model,
+                        runtimeBackend: state.runtimeBackend,
                         usage: {
                             inputTokens: totalInputTokens,
                             outputTokens: totalOutputTokens,
@@ -2083,6 +2309,7 @@ export class ConversationManager {
                 sessionData.messages = state.messages;
                 sessionData.chatHistory = state.chatHistory;
                 sessionData.currentModel = state.model;
+                sessionData.metadata.runtimeBackend = state.runtimeBackend;
                 sessionData.toolFilterConfig = state.toolFilterConfig;
                 sessionData.systemPromptConfig = state.systemPromptConfig;
                 sessionData.metadata.messageCount = state.messages.length;
@@ -2124,7 +2351,7 @@ export class ConversationManager {
         // 如果 messages 中的 assistant 消息比 chatHistory 多，说明有消息没有同步
         if (assistantMsgCount > assistantChatCount) {
             // 从 messages 重建 chatHistory
-            state.chatHistory = this.convertMessagesToChatHistory(state.messages);
+            state.chatHistory = this.convertMessagesToChatHistory(state.messages, state.runtimeBackend);
             console.log(`[ConversationManager] Syncing chatHistory: messages=${assistantMsgCount}, chatHistory=${state.chatHistory.filter(m => m.role === 'assistant').length}`);
         }
     }
@@ -2246,17 +2473,13 @@ export class ConversationManager {
         // --- 阶段 2: 执行子 agent ---
         sendCountdown('executing', 0);
         console.log(`[ScheduleTask] Countdown finished, starting execution: ${taskName}`);
-        const mainClientConfig = this.buildClientConfig(input.model || state.model);
+        const mainClientConfig = this.buildClientConfig(input.model || state.model, state.runtimeBackend);
         const startedAt = Date.now();
         try {
             const result = await state.taskManager.executeScheduleTaskInline(taskName, task.prompt, {
                 model: task.model || 'sonnet',
                 workingDirectory: task.workingDir,
-                clientConfig: {
-                    apiKey: mainClientConfig.apiKey,
-                    authToken: mainClientConfig.authToken,
-                    baseUrl: mainClientConfig.baseUrl,
-                },
+                clientConfig: mainClientConfig,
             });
             const endedAt = Date.now();
             // --- 阶段 3: 更新任务状态 + 返回精简结果 ---
@@ -2370,20 +2593,24 @@ export class ConversationManager {
             callbacks.onToolResult?.(toolUse.id, false, undefined, error);
             return { success: false, error };
         }
+        const normalizedToolInput = normalizeToolInputForWebRuntime(toolUse.input, tool?.getInputSchema());
+        const normalizedToolUse = normalizedToolInput === toolUse.input
+            ? toolUse
+            : { ...toolUse, input: normalizedToolInput };
         // 检查工具是否被过滤
-        if (!this.isToolEnabled(toolUse.name, state.toolFilterConfig)) {
-            const error = `Tool ${toolUse.name} is disabled`;
-            callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+        if (!this.isToolEnabled(normalizedToolUse.name, state.toolFilterConfig)) {
+            const error = `Tool ${normalizedToolUse.name} is disabled`;
+            callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
             return { success: false, error };
         }
         // ========================================================================
         // 权限检查（对齐 CLI loop.ts 的 handlePermissionRequest 逻辑）
         // ========================================================================
         try {
-            const permissionResult = await this.checkToolPermission(toolUse, state, callbacks);
+            const permissionResult = await this.checkToolPermission(normalizedToolUse, state, callbacks);
             if (permissionResult === 'denied') {
-                const error = `User denied execution permission for ${toolUse.name}`;
-                callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                const error = `User denied execution permission for ${normalizedToolUse.name}`;
+                callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                 return { success: false, error };
             }
             // permissionResult === 'allowed' 或 'skipped'（无需权限），继续执行
@@ -2391,7 +2618,7 @@ export class ConversationManager {
         catch (permError) {
             // 权限请求超时或被取消
             const error = permError instanceof Error ? permError.message : 'Permission request failed';
-            callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+            callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
             return { success: false, error };
         }
         // ========================================================================
@@ -2399,10 +2626,10 @@ export class ConversationManager {
         // ========================================================================
         const hookSessionId = state.session.sessionId || '';
         try {
-            const hookResult = await runPreToolUseHooks(toolUse.name, toolUse.input, hookSessionId);
+            const hookResult = await runPreToolUseHooks(normalizedToolUse.name, normalizedToolUse.input, hookSessionId);
             if (!hookResult.allowed) {
-                const error = hookResult.message || `PreToolUse hook blocked execution of ${toolUse.name}`;
-                callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                const error = hookResult.message || `PreToolUse hook blocked execution of ${normalizedToolUse.name}`;
+                callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                 return { success: false, error };
             }
         }
@@ -2411,34 +2638,30 @@ export class ConversationManager {
             console.warn(`[Hook] PreToolUse hook execution failed:`, hookError);
         }
         try {
-            console.log(`[Tool] Executing ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, 200));
+            console.log(`[Tool] Executing ${normalizedToolUse.name}:`, JSON.stringify(normalizedToolUse.input).slice(0, 200));
             // 拦截 Task 工具 - WebUI 模式下使用同步执行 + WebSocket 实时推送
             // 不再默认后台执行，避免 TaskOutput 多次轮询的性能浪费
-            if (toolUse.name === 'Task') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'Task') {
+                const input = normalizedToolUse.input;
                 const description = input.description || 'Background task';
                 const prompt = input.prompt || '';
                 const agentType = input.subagent_type || 'general-purpose';
                 // 验证必需参数
                 if (!prompt) {
                     const error = 'Task prompt is required';
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                     return { success: false, error };
                 }
                 try {
                     // 获取主 agent 的认证信息，传递给子 agent 复用（避免子 agent initAuth 拿到不同凭证导致 403）
-                    const mainClientConfig = this.buildClientConfig(input.model || state.model);
+                    const mainClientConfig = this.buildClientConfig(input.model || state.model, state.runtimeBackend);
                     // WebUI 始终使用同步执行：await 拿结果，中间过程由 TaskManager 通过 WebSocket 实时推送
                     const result = await state.taskManager.executeTaskSync(description, prompt, agentType, {
                         model: input.model || state.model,
                         parentMessages: state.messages,
                         workingDirectory: state.session.cwd,
-                        clientConfig: {
-                            apiKey: mainClientConfig.apiKey,
-                            authToken: mainClientConfig.authToken,
-                            baseUrl: mainClientConfig.baseUrl,
-                        },
-                        toolUseId: toolUse.id,
+                        clientConfig: mainClientConfig,
+                        toolUseId: normalizedToolUse.id,
                         maxTurns: input.max_turns,
                     });
                     let output;
@@ -2460,7 +2683,7 @@ export class ConversationManager {
                         }
                         output = parts.join('');
                     }
-                    callbacks.onToolResult?.(toolUse.id, result.success, output, result.success ? undefined : result.error, {
+                    callbacks.onToolResult?.(normalizedToolUse.id, result.success, output, result.success ? undefined : result.error, {
                         tool: 'Task',
                         agentType,
                         description,
@@ -2472,13 +2695,13 @@ export class ConversationManager {
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     console.error(`[Tool] Task execution failed:`, errorMessage);
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                     return { success: false, error: errorMessage };
                 }
             }
             // 拦截 ScheduleTask 工具 - inline 执行时提供倒计时 + 子 agent 渲染
-            if (toolUse.name === 'ScheduleTask') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'ScheduleTask') {
+                const input = normalizedToolUse.input;
                 // 只拦截 create + once + 10分钟内的情况（即 inline 执行路径）
                 if (input.action === 'create' && input.type === 'once' && input.triggerAt) {
                     try {
@@ -2506,15 +2729,15 @@ export class ConversationManager {
                     const scheduleTool = toolRegistry.get('ScheduleTask');
                     if (!scheduleTool) {
                         const error = 'ScheduleTask tool not found in registry';
-                        callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                        callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                         return { success: false, error };
                     }
-                    const rawResult = await scheduleTool.execute(toolUse.input);
+                    const rawResult = await scheduleTool.execute(normalizedToolUse.input);
                     const result = typeof rawResult === 'object' && rawResult !== null
                         ? rawResult
                         : { success: true, output: String(rawResult) };
                     // 通知前端工具结果
-                    callbacks.onToolResult?.(toolUse.id, result.success, result.output, result.error);
+                    callbacks.onToolResult?.(normalizedToolUse.id, result.success, result.output, result.error);
                     // 用差集精确找到新创建的任务
                     if (result.success && existingIds) {
                         try {
@@ -2533,15 +2756,15 @@ export class ConversationManager {
                 // list/cancel/watch 走正常工具执行路径
             }
             // 拦截 TaskOutput 工具 - 从 TaskManager 获取任务输出
-            if (toolUse.name === 'TaskOutput') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'TaskOutput') {
+                const input = normalizedToolUse.input;
                 const taskId = input.task_id;
                 const block = input.block !== false;
                 const timeout = input.timeout || 300000; // 默认5分钟超时
                 const showHistory = input.show_history || false;
                 if (!taskId) {
                     const error = 'task_id is required';
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                     return { success: false, error };
                 }
                 try {
@@ -2560,11 +2783,11 @@ export class ConversationManager {
                             const fallbackSuccess = typeof fallbackResult === 'string'
                                 ? true
                                 : fallbackResult?.success ?? false;
-                            callbacks.onToolResult?.(toolUse.id, fallbackSuccess, fallbackOutput, fallbackSuccess ? undefined : fallbackOutput);
+                            callbacks.onToolResult?.(normalizedToolUse.id, fallbackSuccess, fallbackOutput, fallbackSuccess ? undefined : fallbackOutput);
                             return { success: fallbackSuccess, output: fallbackOutput, error: fallbackSuccess ? undefined : fallbackOutput };
                         }
                         const error = `Task ${taskId} not found`;
-                        callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                        callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                         return { success: false, error };
                     }
                     // 如果需要阻塞等待完成
@@ -2575,7 +2798,7 @@ export class ConversationManager {
                         }
                         if (task.status === 'running') {
                             const output = `Task ${taskId} is still running (timeout reached).\n\nStatus: ${task.status}\nDescription: ${task.description}`;
-                            callbacks.onToolResult?.(toolUse.id, true, output);
+                            callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                             return { success: true, output };
                         }
                     }
@@ -2608,23 +2831,23 @@ export class ConversationManager {
                     else if (task.error) {
                         output += `\nError: ${task.error}`;
                     }
-                    callbacks.onToolResult?.(toolUse.id, true, output);
+                    callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                     return { success: true, output };
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     console.error(`[Tool] TaskOutput execution failed:`, errorMessage);
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                     return { success: false, error: errorMessage };
                 }
             }
             // 拦截 AskUserQuestion 工具 - 通过 WebSocket 向前端发送问题
-            if (toolUse.name === 'AskUserQuestion') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'AskUserQuestion') {
+                const input = normalizedToolUse.input;
                 const questions = input.questions || [];
                 if (questions.length === 0) {
                     const error = 'No questions provided';
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                     return { success: false, error };
                 }
                 const answers = {};
@@ -2645,19 +2868,19 @@ export class ConversationManager {
                         .map(([header, answer]) => `"${header}"="${answer}"`)
                         .join(', ');
                     const output = `User has answered your questions: ${formattedAnswers}. You can now continue with the user's answers in mind.`;
-                    callbacks.onToolResult?.(toolUse.id, true, output);
+                    callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                     return { success: true, output };
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     console.error(`[Tool] AskUserQuestion failed:`, errorMessage);
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                     return { success: false, error: errorMessage };
                 }
             }
             // 拦截 GenerateBlueprint 工具 - 将对话需求结构化为蓝图
-            if (toolUse.name === 'GenerateBlueprint') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'GenerateBlueprint') {
+                const input = normalizedToolUse.input;
                 try {
                     const blueprintId = `bp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
                     const hasModules = Array.isArray(input.modules) && input.modules.length > 0;
@@ -2735,19 +2958,19 @@ export class ConversationManager {
                         ? `Modules: ${moduleCount}, Processes: ${processCount}, NFR: ${nfrCount}`
                         : `Requirements: ${reqCount}`;
                     const output = `Blueprint generated and saved.\nBlueprint ID: ${blueprint.id}\nProject: ${blueprint.name}\nType: ${isCodebase ? 'Panoramic Blueprint' : 'Requirements Blueprint'}\n${stats}\n\nYou can now call StartLeadAgent to start execution.`;
-                    callbacks.onToolResult?.(toolUse.id, true, output);
+                    callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                     return { success: true, output };
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     console.error(`[Tool] GenerateBlueprint execution failed:`, errorMessage);
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                     return { success: false, error: errorMessage };
                 }
             }
             // v11.0: StartLeadAgent 不再拦截，走正常 tool.execute() 路径
             // 执行前动态绑定当前会话的 WebSocket 和工作目录，确保蜂群在正确的项目路径下执行
-            if (toolUse.name === 'StartLeadAgent') {
+            if (normalizedToolUse.name === 'StartLeadAgent') {
                 const currentCtx = StartLeadAgentTool.getContext();
                 if (currentCtx) {
                     StartLeadAgentTool.setContext({
@@ -2766,15 +2989,30 @@ export class ConversationManager {
                 }
             }
             // 拦截 ImageGen 工具 - 文生图 / 图生图
-            if (toolUse.name === 'ImageGen') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'ImageGen') {
+                const input = normalizedToolUse.input;
                 try {
-                    const { prompt, style, image_path } = input;
-                    console.log(`[Tool] ImageGen: ${image_path ? 'image-to-image' : 'text-to-image'} - ${prompt.substring(0, 50)}...`);
-                    const result = await geminiImageService.generateImage(prompt, style, image_path);
+                    const { prompt, style, size, edit_strength, image_path, image_base64, image_mime_type, output_path } = input;
+                    console.log(`[Tool] ImageGen: ${image_path || image_base64 ? 'image-to-image' : 'text-to-image'} - ${prompt.substring(0, 50)}...`);
+                    const resolvedImageSource = resolveImageGenSource({
+                        image_path,
+                        image_base64,
+                        image_mime_type,
+                    }, state.latestImageAttachments);
+                    if (image_path && resolvedImageSource.imagePath && resolvedImageSource.imagePath !== image_path) {
+                        console.log(`[Tool] ImageGen: remapped uploaded image_path "${image_path}" -> "${resolvedImageSource.imagePath}"`);
+                    }
+                    else if (image_path && resolvedImageSource.imageBase64) {
+                        console.log(`[Tool] ImageGen: fell back to uploaded image base64 for "${image_path}"`);
+                    }
+                    const result = await geminiImageService.generateImage(prompt, style, {
+                        imagePath: resolvedImageSource.imagePath,
+                        imageBase64: resolvedImageSource.imageBase64,
+                        imageMimeType: resolvedImageSource.imageMimeType,
+                    }, output_path, size, edit_strength);
                     if (!result.success) {
                         const error = result.error || 'Image generation failed';
-                        callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                        callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                         return { success: false, error };
                     }
                     // 通过 WebSocket 发送图片给前端显示
@@ -2789,21 +3027,28 @@ export class ConversationManager {
                             },
                         }));
                     }
-                    const output = `Image generated and sent to user for preview.${result.generatedText ? `\n\nDescription: ${result.generatedText}` : ''}\n\nUser can view the generated image in the chat interface.`;
-                    callbacks.onToolResult?.(toolUse.id, true, output);
+                    const parts = ['Image generated and sent to user for preview.'];
+                    if (result.savedPath) {
+                        parts.push(`\nSaved to: ${result.savedPath}`);
+                    }
+                    if (result.generatedText) {
+                        parts.push(`\nDescription: ${result.generatedText}`);
+                    }
+                    const output = parts.join('');
+                    callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                     return { success: true, output };
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     console.error(`[Tool] ImageGen execution failed:`, errorMessage);
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                     return { success: false, error: errorMessage };
                 }
             }
             // 拦截 Mcp 工具的 server management actions (action=list/enable/disable)
             // 这些 action 需要访问 ConversationManager 的 toggleMcpServer/listMcpServers
-            if (toolUse.name === 'Mcp') {
-                const input = toolUse.input;
+            if (normalizedToolUse.name === 'Mcp') {
+                const input = normalizedToolUse.input;
                 if (input.action) {
                     try {
                         if (input.action === 'list') {
@@ -2812,13 +3057,13 @@ export class ConversationManager {
                             const output = servers.length > 0
                                 ? `MCP Servers (${servers.length}):\n${lines.join('\n')}`
                                 : 'No MCP servers configured.';
-                            callbacks.onToolResult?.(toolUse.id, true, output);
+                            callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                             return { success: true, output };
                         }
                         if (input.action === 'enable' || input.action === 'disable') {
                             if (!input.name) {
                                 const error = `"name" parameter is required for ${input.action} action.`;
-                                callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                                callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                                 return { success: false, error };
                             }
                             const enabled = input.action === 'enable';
@@ -2832,23 +3077,23 @@ export class ConversationManager {
                                     this.temporarilyEnabledMcpServers.delete(input.name);
                                 }
                                 const output = `MCP server "${input.name}" has been ${result.enabled ? 'enabled' : 'disabled'}.`;
-                                callbacks.onToolResult?.(toolUse.id, true, output);
+                                callbacks.onToolResult?.(normalizedToolUse.id, true, output);
                                 return { success: true, output };
                             }
                             else {
                                 const error = `Failed to ${input.action} MCP server "${input.name}". The server may not exist in the configuration. Use action="list" to see available servers.`;
-                                callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                                callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                                 return { success: false, error };
                             }
                         }
                         const error = `Unknown Mcp action: ${input.action}. Use "list", "enable", or "disable".`;
-                        callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                        callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                         return { success: false, error };
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
                         console.error(`[Tool] Mcp server management failed:`, errorMessage);
-                        callbacks.onToolResult?.(toolUse.id, false, undefined, errorMessage);
+                        callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, errorMessage);
                         return { success: false, error: errorMessage };
                     }
                 }
@@ -2856,34 +3101,34 @@ export class ConversationManager {
             }
             // MCP 工具执行：解析 mcp__{serverName}__{toolName} 格式，调用 callMcpTool()
             if (isMcpTool) {
-                const parts = toolUse.name.split('__');
+                const parts = normalizedToolUse.name.split('__');
                 // 格式: mcp__{serverName}__{toolName}
                 const mcpServerName = parts[1];
                 const mcpToolName = parts.slice(2).join('__');
                 if (!mcpServerName || !mcpToolName) {
-                    const error = `Invalid MCP tool name format: ${toolUse.name}`;
-                    callbacks.onToolResult?.(toolUse.id, false, undefined, error);
+                    const error = `Invalid MCP tool name format: ${normalizedToolUse.name}`;
+                    callbacks.onToolResult?.(normalizedToolUse.id, false, undefined, error);
                     return { success: false, error };
                 }
-                const mcpResult = await callMcpTool(mcpServerName, mcpToolName, toolUse.input);
+                const mcpResult = await callMcpTool(mcpServerName, mcpToolName, normalizedToolUse.input);
                 const mcpOutput = mcpResult.output || mcpResult.error || JSON.stringify(mcpResult);
                 const truncatedMcpOutput = mcpOutput.length > 50000
                     ? mcpOutput.slice(0, 50000) + '\n... (output truncated)'
                     : mcpOutput;
                 // PostToolUse Hook
                 try {
-                    await runPostToolUseHooks(toolUse.name, toolUse.input, truncatedMcpOutput, hookSessionId);
+                    await runPostToolUseHooks(normalizedToolUse.name, normalizedToolUse.input, truncatedMcpOutput, hookSessionId);
                 }
                 catch (hookError) {
                     console.warn(`[Hook] PostToolUse hook execution failed:`, hookError);
                 }
-                callbacks.onToolResult?.(toolUse.id, mcpResult.success, truncatedMcpOutput, mcpResult.error ? mcpResult.error : undefined);
+                callbacks.onToolResult?.(normalizedToolUse.id, mcpResult.success, truncatedMcpOutput, mcpResult.error ? mcpResult.error : undefined);
                 return { success: mcpResult.success, output: truncatedMcpOutput, error: mcpResult.error };
             }
             // 执行其他工具（内置 registry 工具）
-            const result = await tool.execute(toolUse.input);
+            const result = await tool.execute(normalizedToolUse.input);
             // 构建结构化数据
-            const data = this.buildToolResultData(toolUse.name, toolUse.input, result);
+            const data = this.buildToolResultData(normalizedToolUse.name, normalizedToolUse.input, result);
             // 格式化输出
             let output;
             if (typeof result === 'string') {
@@ -2918,7 +3163,7 @@ export class ConversationManager {
                 : undefined;
             // PostToolUse Hook
             try {
-                await runPostToolUseHooks(toolUse.name, toolUse.input, output, hookSessionId);
+                await runPostToolUseHooks(normalizedToolUse.name, normalizedToolUse.input, output, hookSessionId);
             }
             catch (hookError) {
                 console.warn(`[Hook] PostToolUse hook execution failed:`, hookError);
@@ -3467,6 +3712,10 @@ Respond ONLY with valid JSON, no other text.`;
             }
             // 构建提示上下文（与 CLI loop.ts 保持一致）
             // 注意：不注入 contextUsage，保持 system prompt 稳定可缓存
+            const runtimeBackend = state.runtimeBackend || this.getRuntimeBackend();
+            const authStatus = webAuth.getStatus();
+            const isAnthropicOauth = authStatus.type === 'oauth'
+                && getProviderForRuntimeBackend(runtimeBackend, state.model) === 'anthropic';
             const promptContext = {
                 workingDir: state.session.cwd,
                 model: this.getModelId(state.model),
@@ -3480,8 +3729,12 @@ Respond ONLY with valid JSON, no other text.`;
                 debug: false,
                 // v2.1.0+: 语言配置 - 与 CLI 保持一致
                 language: configManager.get('language'),
-                // 是否使用官方订阅认证（有 oauthToken 或 oauthAccount 说明通过 Claude.ai 登录）
-                isOfficialAuth: webAuth.getStatus().type === 'oauth',
+                // 只有 Claude 官方订阅 OAuth 才使用官方 CLI 身份前缀
+                isOfficialAuth: isAnthropicOauth && runtimeBackend === 'claude-subscription',
+                // Console OAuth + oauthApiKey 必须使用 Agent SDK 身份前缀
+                coreIdentityVariant: isAnthropicOauth && runtimeBackend === 'claude-compatible-api'
+                    ? 'agent'
+                    : undefined,
                 // Agent 笔记本内容
                 notebookSummary,
                 // MCP 服务器信息（用于系统提示中的 MCP 指令）
@@ -3638,6 +3891,29 @@ You are running in web server mode accessible by multiple users. HIGHEST PRIORIT
         // 端口转发功能提示 — 精简版
         sections.push(`# Port Forwarding
 When starting a web server for the user, they access it via \`/proxy/:port/\` (e.g. \`/proxy/9090/\`). After starting a server, tell the user: "Preview it here: [Open Preview](/proxy/9090/)". Supports HTTP and WebSocket, ports 1024-65535, localhost only.`);
+        // 已注册应用感知
+        try {
+            const apps = getAppManager().list();
+            if (apps.length > 0) {
+                const appLines = apps.map(a => {
+                    const status = a.status === 'running' ? `running (pid ${a.pid}, port ${a.port || '?'})` : a.status;
+                    return `- **${a.name}** [${status}]: ${a.description || 'no description'} (dir: \`${a.directory}\`, cmd: \`${a.startCommand}\`)`;
+                }).join('\n');
+                sections.push(`# Managed Apps
+You have ${apps.length} registered app(s) in the Apps page. You can start/stop/manage them via \`GET/POST /api/apps\`.
+${appLines}`);
+            }
+        }
+        catch {
+            // AppManager 未初始化时忽略
+        }
+        // ImageGen 使用约束
+        sections.push(`## ImageGen tool usage
+- When the user provides an image attachment and asks to edit or transform that image, prefer calling ImageGen instead of only describing edits in text.
+- If the conversation context includes image attachment edit preferences, copy that preference into the ImageGen tool call as \`edit_strength\` ('low' | 'medium' | 'high').
+- For conservative/local edits, prefer \`edit_strength: 'low'\`.
+- For broader but still recognizable edits, prefer \`edit_strength: 'medium'\` or \`edit_strength: 'high'\` as appropriate.
+- When editing an uploaded image, pass the image through \`image_base64\` (or \`image_path\` if you truly have a file path) and keep the tool prompt focused on the requested change.`);
         if (sections.length === 0) {
             return null;
         }
@@ -3894,6 +4170,9 @@ Guidelines:
                 broadcast({ type: 'tool_use_start', payload: { messageId, toolUseId, toolName, input, sessionId: targetSessionId } });
                 broadcast({ type: 'status', payload: { status: 'tool_executing', message: `Executing ${toolName}...`, sessionId: targetSessionId } });
             },
+            onToolUseInputReady: (toolUseId, input) => {
+                broadcast({ type: 'tool_use_input_ready', payload: { toolUseId, input, sessionId: targetSessionId } });
+            },
             onToolUseDelta: (toolUseId, partialJson) => broadcast({ type: 'tool_use_delta', payload: { toolUseId, partialJson, sessionId: targetSessionId } }),
             onToolResult: (toolUseId, success, output, error, data) => {
                 broadcast({ type: 'tool_result', payload: { toolUseId, success, output, error, data: data, defaultCollapsed: true, sessionId: targetSessionId } });
@@ -3934,6 +4213,13 @@ Guidelines:
         }
         return state.session.cwd;
     }
+    /**
+     * 获取会话名称（从 sessionManager 的持久化数据中读取）
+     */
+    getSessionName(sessionId) {
+        const sessionData = this.sessionManager.loadSessionById(sessionId);
+        return sessionData?.metadata?.name;
+    }
     /**
      * 持久化会话
      */
@@ -3963,6 +4249,7 @@ Guidelines:
             sessionData.messages = state.messages;
             sessionData.chatHistory = state.chatHistory;
             sessionData.currentModel = state.model;
+            sessionData.metadata.runtimeBackend = state.runtimeBackend;
             sessionData.toolFilterConfig = state.toolFilterConfig;
             sessionData.systemPromptConfig = state.systemPromptConfig;
             // 关键：更新 messageCount（官方规范：统计消息数）
@@ -4019,9 +4306,10 @@ Guidelines:
         try {
             // 如果会话已经在内存中，直接返回成功（避免重复创建）
             if (this.sessions.has(sessionId)) {
+                const state = this.sessions.get(sessionId);
+                this.ensureStateModelMatchesRuntime(state);
                 // 同步权限模式（修复切换会话后 YOLO 模式丢失的问题）
                 if (permissionMode) {
-                    const state = this.sessions.get(sessionId);
                     state.permissionHandler.updateConfig({ mode: permissionMode });
                 }
                 return true;
@@ -4035,15 +4323,14 @@ Guidelines:
             const session = new Session(sessionData.metadata.workingDirectory || this.cwd);
             // 在后台异步获取 Git 信息，不阻塞会话切换（Git 信息主要用于 system prompt，在用户发送消息时才需要）
             session.initializeGitInfo().catch(() => { });
-            const clientConfig = this.buildClientConfig(sessionData.currentModel || this.defaultModel);
-            const client = new ClaudeClient({
-                ...clientConfig,
-                timeout: clientConfig.timeout,
-            });
+            const runtimeBackend = sessionData.metadata.runtimeBackend || this.getRuntimeBackend();
+            const resolvedModel = this.normalizeRuntimeModel(sessionData.currentModel || sessionData.metadata.model || this.defaultModel, runtimeBackend);
+            const clientConfig = this.buildClientConfig(resolvedModel, runtimeBackend);
+            const client = createConversationClient(clientConfig);
             // 如果 chatHistory 为空但 messages 不为空，从 messages 构建 chatHistory
             let chatHistory = sessionData.chatHistory || [];
             if (chatHistory.length === 0 && sessionData.messages && sessionData.messages.length > 0) {
-                chatHistory = this.convertMessagesToChatHistory(sessionData.messages);
+                chatHistory = this.convertMessagesToChatHistory(sessionData.messages, runtimeBackend);
             }
             const resumeUserInteractionHandler = new UserInteractionHandler();
             resumeUserInteractionHandler.setSessionId(sessionId);
@@ -4051,7 +4338,8 @@ Guidelines:
                 session,
                 client,
                 messages: sessionData.messages,
-                model: sessionData.currentModel || sessionData.metadata.model,
+                model: resolvedModel,
+                runtimeBackend,
                 cancelled: false,
                 chatHistory,
                 userInteractionHandler: resumeUserInteractionHandler,
@@ -4068,8 +4356,9 @@ Guidelines:
                 processingGeneration: 0,
                 lastActualInputTokens: 0,
                 messagesLenAtLastApiCall: 0,
+                latestImageAttachments: [],
                 lastPersistedMessageCount: sessionData.messages.length, // 从磁盘加载时，初始化为当前消息数
-                credentialsFingerprint: this.getCredentialsFingerprint(),
+                credentialsFingerprint: this.getCredentialsFingerprint(runtimeBackend),
             };
             this.sessions.set(sessionId, state);
             // 初始化 NotebookManager（SelfEvolve 重启后 resumeSession 不经过 getOrCreateSession，需要在这里初始化）
@@ -4141,7 +4430,7 @@ Guidelines:
     /**
      * 将 API 消息格式转换为 ChatHistory 格式
      */
-    convertMessagesToChatHistory(messages) {
+    convertMessagesToChatHistory(messages, runtimeBackend = this.getRuntimeBackend()) {
         const chatHistory = [];
         // 预构建 tool_use_id → tool_result 映射，用于将工具结果关联回工具调用
         const toolResultMap = new Map();
@@ -4192,6 +4481,7 @@ Guidelines:
                 role: msg.role,
                 timestamp: Date.now(),
                 content: [],
+                runtimeBackend,
                 // 记录此 chatEntry 对应的 messages 位置（i+1 表示包含当前消息）
                 _messagesLen: i + 1,
             };
@@ -4204,6 +4494,9 @@ Guidelines:
                     if (block.type === 'text') {
                         chatMsg.content.push({ type: 'text', text: block.text });
                     }
+                    else if (block.type === 'thinking') {
+                        chatMsg.content.push({ type: 'thinking', text: block.thinking });
+                    }
                     else if (block.type === 'image') {
                         // 保留图片内容以便刷新后回显
                         const imgBlock = block;