@xagent-ai/cli 1.2.2 → 1.3.1

package/dist/session.js

@@ -5,11 +5,18 @@ import axios from 'axios';
 import crypto from 'crypto';
 import ora from 'ora';
 import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import os from 'os';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
-import { ExecutionMode, AuthType } from './types.js';
-import { AIClient, detectThinkingKeywords, getThinkingTokens } from './ai-client.js';
-import { RemoteAIClient, TokenInvalidError } from './remote-ai-client.js';
+import { ExecutionMode, AuthType, } from './types.js';
+import { createAIClient } from './ai-client-factory.js';
+import { detectThinkingKeywords, getThinkingTokens } from './ai-client/types.js';
+import { TokenInvalidError } from './ai-client/types.js';
+import { fetchDefaultModels } from './ai-client/providers/remote.js';
 import { getConfigManager } from './config.js';
 import { AuthService, selectAuthType } from './auth.js';
 import { getToolRegistry } from './tools.js';
@@ -21,10 +28,11 @@ import { getConversationManager } from './conversation.js';
 import { getSessionManager } from './session-manager.js';
 import { SlashCommandHandler, parseInput } from './slash-commands.js';
 import { SystemPromptGenerator } from './system-prompt-generator.js';
-import { theme, icons, colors, styleHelpers, renderMarkdown, renderDiff, renderLines } from './theme.js';
+import { theme, icons, colors, styleHelpers, renderMarkdown, renderDiff, renderLines, } from './theme.js';
 import { getCancellationManager } from './cancellation.js';
-import { getContextCompressor } from './context-compressor.js';
+import { getContextCompressor, } from './context-compressor.js';
 import { getLogger } from './logger.js';
+import { ensureTtySane, setupEscKeyHandler } from './terminal.js';
 const logger = getLogger();
 export class InteractiveSession {
     conversationManager;
@@ -33,7 +41,7 @@ export class InteractiveSession {
     aiClient = null;
     remoteAIClient = null;
     conversation = [];
-    toolCalls = [];
+    tool_calls = [];
     executionMode;
     slashCommandHandler;
     configManager;
@@ -50,10 +58,21 @@ export class InteractiveSession {
     currentTaskId = null;
     taskCompleted = false;
     isFirstApiCall = true;
+    sdkOutputAdapter = null;
+    isSdkMode = false;
+    sdkInputBuffer = [];
+    resolveInput = null;
+    _currentRequestId = null;
+    heartbeatTimeout = null;
+    heartbeatTimeoutMs = 300000; // 5 minutes timeout for long AI responses
+    lastActivityTime = Date.now();
+    // SDK response handling for approvals and questions
+    approvalPromises = new Map();
+    questionPromises = new Map();
     constructor(indentLevel = 0) {
         this.rl = readline.createInterface({
             input: process.stdin,
-            output: process.stdout
+            output: process.stdout,
         });
         this.configManager = getConfigManager(process.cwd());
         this.agentManager = getAgentManager(process.cwd());
@@ -66,7 +85,7 @@ export class InteractiveSession {
         // Register /clear callback, clear local conversation when clearing dialogue
         this.slashCommandHandler.setClearCallback(() => {
             this.conversation = [];
-            this.toolCalls = [];
+            this.tool_calls = [];
             this.currentTaskId = null;
             this.taskCompleted = false;
             this.isFirstApiCall = true;
@@ -76,6 +95,10 @@ export class InteractiveSession {
         this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
             await this.updateSystemPrompt();
         });
+        // Register config update callback, update aiClient config when /auth changes config
+        this.slashCommandHandler.setConfigUpdateCallback(() => {
+            this.updateAiClientConfig();
+        });
         this.executionMode = ExecutionMode.DEFAULT;
         this.cancellationManager = getCancellationManager();
         this.indentLevel = indentLevel;
@@ -88,59 +111,226 @@ export class InteractiveSession {
     setAIClient(aiClient) {
         this.aiClient = aiClient;
     }
+    /**
+     * Update aiClient config when /auth changes config (called from callback)
+     */
+    updateAiClientConfig() {
+        const authConfig = this.configManager.getAuthConfig();
+        const isRemote = authConfig.type === AuthType.OAUTH_XAGENT;
+        if (isRemote) {
+            // Already in remote mode, no change needed
+            if (this.remoteAIClient !== null) {
+                return;
+            }
+            // Switch to remote: clear local client, create remote client
+            this.aiClient = null;
+            this.remoteAIClient = createAIClient(authConfig);
+        }
+        else {
+            // Already in local mode, no change needed
+            if (this.aiClient !== null) {
+                return;
+            }
+            // Switch to local: clear remote client, create local client
+            this.remoteAIClient = null;
+            this.aiClient = createAIClient(authConfig);
+        }
+        this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
+    }
     setExecutionMode(mode) {
         this.executionMode = mode;
     }
+    /**
+     * Set SDK mode for programmatic access.
+     * In SDK mode, output is formatted as JSON to stdout.
+     */
+    setSdkMode(adapter) {
+        this.isSdkMode = true;
+        this.sdkOutputAdapter = adapter;
+        // Initialize SDK mode for other modules using centralized output util
+        const { initOutputMode } = require('./output-util.js');
+        initOutputMode(true, adapter);
+        // Initialize SmartApprovalEngine in SDK mode
+        this.initSmartApprovalSdkMode(adapter).catch(() => {
+            // Silently ignore errors - not critical
+        });
+        // Initialize tool registry in SDK mode (fire and forget, doesn't need to await)
+        this.initToolRegistrySdkMode(adapter).catch(() => {
+            // Silently ignore errors - tool registry init is not critical
+        });
+    }
+    /**
+     * Initialize SmartApprovalEngine in SDK mode.
+     */
+    async initSmartApprovalSdkMode(adapter) {
+        const { getSmartApprovalEngine } = await import('./smart-approval.js');
+        const approvalEngine = getSmartApprovalEngine();
+        approvalEngine.setSdkMode(true, adapter);
+    }
+    /**
+     * Initialize tool registry in SDK mode.
+     */
+    async initToolRegistrySdkMode(adapter) {
+        const toolRegistry = getToolRegistry();
+        await toolRegistry.setSdkMode(true, adapter);
+    }
+    /**
+     * Get SDK mode status.
+     */
+    getIsSdkMode() {
+        return this.isSdkMode;
+    }
+    /**
+     * Output assistant response - handles SDK mode and normal mode differently.
+     */
+    outputAssistant(content, reasoningContent) {
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputAssistant(content, reasoningContent);
+        }
+        else {
+            const indent = this.getIndent();
+            console.log('');
+            console.log(`${indent}${colors.primaryBright(`${icons.robot} Assistant:`)}`);
+            console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
+            console.log('');
+            const renderedContent = renderMarkdown(content, (process.stdout.columns || 80) - indent.length * 2);
+            console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
+            console.log('');
+        }
+    }
     /**
      * Update system prompt to reflect MCP changes (called after add/remove MCP)
      */
     async updateSystemPrompt() {
+        // Reload skills to pick up any newly added/removed skills
+        // First reset the SkillLoader to clear all cached skills
+        const { resetSkillLoader } = await import('./skill-loader.js');
+        resetSkillLoader();
+        // Then reload the skill invoker
+        const skillInvoker = (await import('./skill-invoker.js')).getSkillInvoker();
+        await skillInvoker.reload();
         const toolRegistry = getToolRegistry();
         const promptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
         // Use the current agent's original system prompt as base
         const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are xAgent, an AI-powered CLI tool.';
         const newSystemPrompt = await promptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
         // Replace old system prompt with new one
-        this.conversation = this.conversation.filter(msg => msg.role !== 'system');
+        this.conversation = this.conversation.filter((msg) => msg.role !== 'system');
         this.conversation.unshift({
             role: 'system',
             content: newSystemPrompt,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         // Sync to slashCommandHandler
         this.slashCommandHandler.setConversationHistory(this.conversation);
     }
+    /**
+     * Watch for skill updates from CLI and update system prompt accordingly
+     */
+    startSkillUpdateWatcher() {
+        const SKILL_STATE_FILE = '.skill-state.json';
+        const configManager = getConfigManager();
+        const userSkillsPath = configManager.getUserSkillsPath();
+        const stateFilePath = userSkillsPath
+            ? path.join(userSkillsPath, SKILL_STATE_FILE)
+            : null;
+        if (!stateFilePath) {
+            return; // No user skills path configured
+        }
+        let lastUpdateTime = 0;
+        // Initialize with current state to avoid triggering update on first check
+        try {
+            const { existsSync, readFileSync } = require('fs');
+            if (existsSync(stateFilePath)) {
+                const content = readFileSync(stateFilePath, 'utf-8');
+                const state = JSON.parse(content);
+                lastUpdateTime = state.lastSkillUpdate || 0;
+            }
+        }
+        catch {
+            // Silent fail
+        }
+        // Check for updates every 2 seconds
+        const checkInterval = setInterval(async () => {
+            try {
+                const { existsSync, readFileSync } = await import('fs');
+                if (existsSync(stateFilePath)) {
+                    const content = readFileSync(stateFilePath, 'utf-8');
+                    const state = JSON.parse(content);
+                    if (state.lastSkillUpdate && state.lastSkillUpdate > lastUpdateTime) {
+                        lastUpdateTime = state.lastSkillUpdate;
+                        // Update system prompt with new skills
+                        await this.updateSystemPrompt();
+                        if (!this.isSdkMode) {
+                            console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+                        }
+                    }
+                }
+            }
+            catch {
+                // Silent fail - watcher is optional
+            }
+        }, 2000);
+        // Clean up on session end
+        this._skillWatcherInterval = checkInterval;
+    }
     setAgent(agent) {
         this.currentAgent = agent;
     }
-    async start() {
+    async start(initializedCount = 0) {
         // Set this session as the singleton for access from other modules
         setSingletonSession(this);
         // Initialize taskId for GUI operations
         this.currentTaskId = crypto.randomUUID();
-        const separator = icons.separator.repeat(60);
-        console.log('');
-        console.log(colors.gradient('╔════════════════════════════════════════════════════════════╗'));
-        console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
-        console.log(colors.gradient('║') + ' '.repeat(13) + '🤖 ' + colors.gradient('XAGENT CLI') + ' '.repeat(32) + colors.gradient('  ║'));
-        console.log(colors.gradient('║') + ' '.repeat(16) + colors.textMuted(`v${packageJson.version}`) + ' '.repeat(36) + colors.gradient('  ║'));
-        console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
-        console.log(colors.gradient('╚════════════════════════════════════════════════════════════╝'));
-        console.log(colors.textMuted('  AI-powered command-line assistant'));
-        console.log('');
+        const _separator = icons.separator.repeat(60);
+        if (!this.isSdkMode) {
+            // Normal mode: show ASCII art welcome
+            console.log('');
+            console.log(colors.gradient('╔════════════════════════════════════════════════════════════╗'));
+            console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
+            console.log(colors.gradient('║') +
+                ' '.repeat(13) +
+                '🤖 ' +
+                colors.gradient('XAGENT CLI') +
+                ' '.repeat(32) +
+                colors.gradient('  ║'));
+            console.log(colors.gradient('║') +
+                ' '.repeat(16) +
+                colors.textMuted(`v${packageJson.version}`) +
+                ' '.repeat(36) +
+                colors.gradient('  ║'));
+            console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
+            console.log(colors.gradient('╚════════════════════════════════════════════════════════════╝'));
+            console.log(colors.textMuted('  AI-powered command-line assistant'));
+            // Show initialization message if skills were initialized
+            if (initializedCount > 0) {
+                console.log(colors.textMuted(`  ✨ Initialized ${initializedCount} built-in skills`));
+            }
+            console.log('');
+        }
         await this.initialize();
         this.showWelcomeMessage();
+        // Start watching for skill updates from CLI
+        this.startSkillUpdateWatcher();
+        // SDK 模式初始化：设置输出适配器
+        if (this.isSdkMode) {
+            // Start heartbeat timeout monitoring in SDK mode
+            this.startHeartbeatMonitoring();
+        }
+        // Set up ESC key handler using the terminal module
+        // This avoids conflicts with readline and provides clean ESC detection
+        let _escCleanup;
+        if (process.stdin.isTTY) {
+            _escCleanup = setupEscKeyHandler(() => {
+                if (this._isOperationInProgress) {
+                    // An operation is running, let it be cancelled
+                    this.cancellationManager.cancel();
+                }
+                // No operation running, ignore ESC
+            });
+        }
         // Track if an operation is in progress
         this._isOperationInProgress = false;
-        // Listen for ESC cancellation - only cancel operations, don't exit the program
-        const cancelHandler = () => {
-            if (this._isOperationInProgress) {
-                // An operation is running, let it be cancelled
-                return;
-            }
-            // No operation running, ignore ESC or show a message
-        };
-        this.cancellationManager.on('cancelled', cancelHandler);
         this.promptLoop();
         // Keep the promise pending until shutdown
         return new Promise((resolve) => {
@@ -159,7 +349,7 @@ export class InteractiveSession {
                 frameIndex = (frameIndex + 1) % frames.length;
             }, 120);
             logger.debug('[SESSION] 调用 configManager.load()...');
-            await this.configManager.load();
+            this.configManager.load();
             logger.debug('[SESSION] Config loaded');
             let authConfig = this.configManager.getAuthConfig();
             let selectedAuthType = this.configManager.get('selectedAuthType');
@@ -186,9 +376,8 @@ export class InteractiveSession {
                     clearInterval(refreshInterval);
                     process.stdout.write('\r' + ' '.repeat(50) + '\r');
                     if (newToken) {
-                        // Save new token and persist
-                        await this.configManager.set('apiKey', newToken);
-                        await this.configManager.save('global');
+                        this.configManager.set('apiKey', newToken);
+                        this.configManager.save('global');
                         authConfig.apiKey = newToken;
                         isValid = true;
                     }
@@ -198,20 +387,18 @@ export class InteractiveSession {
                     console.log(colors.warning('Your xAgent session has expired or is not configured'));
                     console.log(colors.info('Please select an authentication method to continue.'));
                     console.log('');
-                    // Clear invalid credentials and persist
-                    // Note: Do NOT overwrite selectedAuthType - let user re-select their preferred auth method
-                    await this.configManager.set('apiKey', '');
-                    await this.configManager.set('refreshToken', '');
-                    await this.configManager.save('global');
-                    await this.configManager.load();
+                    this.configManager.set('apiKey', '');
+                    this.configManager.set('refreshToken', '');
+                    this.configManager.save('global');
+                    this.configManager.load();
                     authConfig = this.configManager.getAuthConfig();
                     await this.setupAuthentication();
                     authConfig = this.configManager.getAuthConfig();
-                    // Recreate readline interface after inquirer
+                    // Recreate readline interface after interactive prompt
                     this.rl.close();
                     this.rl = readline.createInterface({
                         input: process.stdin,
-                        output: process.stdout
+                        output: process.stdout,
                     });
                     this.rl.on('close', () => {
                         // readline closed
@@ -226,11 +413,11 @@ export class InteractiveSession {
                 authConfig = this.configManager.getAuthConfig();
                 selectedAuthType = this.configManager.get('selectedAuthType');
                 logger.debug('[SESSION] selectedAuthType (after setup):', String(selectedAuthType));
-                // Recreate readline interface after inquirer
+                // Recreate readline interface after interactive prompt
                 this.rl.close();
                 this.rl = readline.createInterface({
                     input: process.stdin,
-                    output: process.stdout
+                    output: process.stdout,
                 });
                 this.rl.on('close', () => {
                     // readline closed
@@ -241,21 +428,42 @@ export class InteractiveSession {
                 process.stdout.write('\r' + ' '.repeat(50) + '\r');
             }
             // For OPENAI_COMPATIBLE with API key, skip validation and proceed directly
-            this.aiClient = new AIClient(authConfig);
-            this.contextCompressor.setAIClient(this.aiClient);
-            // Initialize remote AI client for OAuth XAGENT mode
-            logger.debug('[SESSION] Final selectedAuthType:', String(selectedAuthType));
-            logger.debug('[SESSION] Creating RemoteAIClient?', String(selectedAuthType === AuthType.OAUTH_XAGENT));
+            // Initialize AI clients and set contextCompressor appropriately
             if (selectedAuthType === AuthType.OAUTH_XAGENT) {
-                const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
-                // In OAuth XAGENT mode, we still pass apiKey (can be empty or used for other purposes)
-                this.remoteAIClient = new RemoteAIClient(authConfig.apiKey || '', webBaseUrl, authConfig.showAIDebugInfo);
+                // Remote mode: fetch default models if not set
+                const currentLlm = this.configManager.get('remote_llmModelName');
+                const currentVlm = this.configManager.get('remote_vlmModelName');
+                if (!currentLlm || !currentVlm) {
+                    const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
+                    try {
+                        const defaults = await fetchDefaultModels(authConfig.apiKey || '', webBaseUrl);
+                        if (!currentLlm && defaults.llm?.name) {
+                            this.configManager.set('remote_llmModelName', defaults.llm.name);
+                        }
+                        if (!currentVlm && defaults.vlm?.name) {
+                            this.configManager.set('remote_vlmModelName', defaults.vlm.name);
+                        }
+                        this.configManager.save('global');
+                    }
+                    catch (error) {
+                        logger.debug('[SESSION] Failed to fetch default models:', error.message);
+                    }
+                }
+                // Remote mode: create RemoteAIClient and use it for context compression
+                this.remoteAIClient = createAIClient(authConfig);
+                this.contextCompressor.setAIClient(this.remoteAIClient);
                 logger.debug('[DEBUG Initialize] RemoteAIClient created successfully');
             }
             else {
+                // Local mode: create local AIClient
+                this.aiClient = createAIClient(authConfig);
+                this.contextCompressor.setAIClient(this.aiClient);
                 logger.debug('[DEBUG Initialize] RemoteAIClient NOT created (not OAuth XAGENT mode)');
             }
-            this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
+            // Sync remoteAIClient reference to slashCommandHandler for /provider command
+            this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
+            this.executionMode =
+                this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
             await this.agentManager.loadAgents();
             await this.memoryManager.loadMemory();
             await this.conversationManager.initialize();
@@ -267,24 +475,45 @@ export class InteractiveSession {
             this.slashCommandHandler.setConversationHistory(this.conversation);
             const mcpServers = this.configManager.getMcpServers();
             Object.entries(mcpServers).forEach(([name, config]) => {
-                console.log(`📝 Registering MCP server: ${name} (${config.transport})`);
+                if (this.isSdkMode && this.sdkOutputAdapter) {
+                    this.sdkOutputAdapter.outputMCPRegistering(name, config.transport || 'stdio');
+                }
+                else {
+                    console.log(`📝 Registering MCP server: ${name} (${config.transport})`);
+                }
                 this.mcpManager.registerServer(name, config);
             });
             // Eagerly connect to MCP servers to get tool definitions
             if (mcpServers && Object.keys(mcpServers).length > 0) {
                 try {
-                    console.log(`${colors.info(`${icons.brain} Connecting to ${Object.keys(mcpServers).length} MCP server(s)...`)}`);
+                    const serverCount = Object.keys(mcpServers).length;
+                    if (this.isSdkMode && this.sdkOutputAdapter) {
+                        this.sdkOutputAdapter.outputMCPLoading(serverCount);
+                    }
+                    else {
+                        console.log(`${colors.info(`${icons.brain} Connecting to ${serverCount} MCP server(s)...`)}`);
+                    }
                     await this.mcpManager.connectAllServers();
                     const connectedCount = Array.from(this.mcpManager.getAllServers()).filter((s) => s.isServerConnected()).length;
                     const mcpTools = this.mcpManager.getToolDefinitions();
-                    console.log(`${colors.success(`✓ ${connectedCount}/${Object.keys(mcpServers).length} MCP server(s) connected (${mcpTools.length} tools available)`)}`);
+                    if (this.isSdkMode && this.sdkOutputAdapter) {
+                        this.sdkOutputAdapter.outputMCPConnected(serverCount, connectedCount, mcpTools.length);
+                    }
+                    else {
+                        console.log(`${colors.success(`✓ ${connectedCount}/${serverCount} MCP server(s) connected (${mcpTools.length} tools available)`)}`);
+                    }
                     // Register MCP tools with the tool registry (hide MCP origin from LLM)
                     const toolRegistry = getToolRegistry();
                     const allMcpTools = this.mcpManager.getAllTools();
                     toolRegistry.registerMCPTools(allMcpTools);
                 }
                 catch (error) {
-                    console.log(`${colors.warning(`⚠ MCP connection failed: ${error.message}`)}`);
+                    if (this.isSdkMode && this.sdkOutputAdapter) {
+                        this.sdkOutputAdapter.outputMCPConnectionFailed(error.message);
+                    }
+                    else {
+                        console.log(`${colors.warning(`⚠ MCP connection failed: ${error.message}`)}`);
+                    }
                 }
             }
             const checkpointingConfig = this.configManager.getCheckpointingConfig();
@@ -292,8 +521,13 @@ export class InteractiveSession {
                 this.checkpointManager = getCheckpointManager(process.cwd(), checkpointingConfig.enabled, checkpointingConfig.maxCheckpoints);
                 await this.checkpointManager.initialize();
             }
-            this.currentAgent = this.agentManager.getAgent('general-purpose');
-            console.log(colors.success('✔ Initialization complete'));
+            this.currentAgent = this.agentManager.getAgent('general-purpose') ?? null;
+            if (this.isSdkMode && this.sdkOutputAdapter) {
+                this.sdkOutputAdapter.outputSuccess('Initialization complete');
+            }
+            else {
+                console.log(colors.success('✔ Initialization complete'));
+            }
         }
         catch (error) {
             const spinner = ora({ text: '', spinner: 'dots', color: 'red' }).start();
@@ -315,11 +549,11 @@ export class InteractiveSession {
             logger.debug('[SESSION] Sending validation request to:', url);
             const response = await axios.get(url, {
                 headers: {
-                    'Authorization': `Bearer ${apiKey}`,
-                    'Content-Type': 'application/json'
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
                 },
                 httpsAgent,
-                timeout: 10000
+                timeout: 10000,
             });
             logger.debug('[SESSION] Validation response status:', String(response.status));
             return response.status === 200;
@@ -341,7 +575,7 @@ export class InteractiveSession {
             const httpsAgent = new https.Agent({ rejectUnauthorized: false });
             const response = await axios.post(url, { refreshToken }, {
                 httpsAgent,
-                timeout: 10000
+                timeout: 10000,
             });
             if (response.status === 200) {
                 const data = response.data;
@@ -351,7 +585,7 @@ export class InteractiveSession {
                 return null;
             }
         }
-        catch (error) {
+        catch {
             return null;
         }
     }
@@ -363,11 +597,14 @@ export class InteractiveSession {
         console.log('');
         const authType = await selectAuthType();
         this.configManager.set('selectedAuthType', authType);
+        // Get xagentApiBaseUrl from config (respects XAGENT_BASE_URL env var)
+        const config = this.configManager.getAuthConfig();
         const authService = new AuthService({
             type: authType,
             apiKey: '',
             baseUrl: '',
-            modelName: ''
+            modelName: '',
+            xagentApiBaseUrl: config.xagentApiBaseUrl,
         });
         const success = await authService.authenticate();
         if (!success) {
@@ -377,67 +614,175 @@ export class InteractiveSession {
             process.exit(1);
         }
         const authConfig = authService.getAuthConfig();
+        // Clear modelName for remote mode
+        if (authType === AuthType.OAUTH_XAGENT) {
+            authConfig.modelName = '';
+        }
         // VLM configuration is optional - only show for non-OAuth (local) mode
         // Remote mode uses backend VLM configuration
         if (authType !== AuthType.OAUTH_XAGENT) {
-            console.log('');
-            console.log(colors.info(`${icons.info} VLM configuration is optional.`));
-            console.log(colors.info(`You can configure it later using the /vlm command if needed.`));
-            console.log('');
+            if (this.isSdkMode && this.sdkOutputAdapter) {
+                this.sdkOutputAdapter.outputInfo('VLM configuration is optional. You can configure it later using the /model command if needed.');
+            }
+            else {
+                console.log('');
+                console.log(colors.info(`${icons.info} VLM configuration is optional.`));
+                console.log(colors.info(`You can configure it later using the /model command if needed.`));
+                console.log('');
+            }
+        }
+        this.configManager.setAuthConfig(authConfig);
+        // Set default remote model settings if not already set
+        if (authType === AuthType.OAUTH_XAGENT) {
+            if (!this.configManager.get('remote_llmModelName')) {
+                this.configManager.set('remote_llmModelName', '');
+            }
+            if (!this.configManager.get('remote_vlmModelName')) {
+                this.configManager.set('remote_vlmModelName', '');
+            }
+            this.configManager.save('global');
         }
-        // Save LLM config only, skip VLM for now
-        await this.configManager.setAuthConfig(authConfig);
     }
     showWelcomeMessage() {
         const language = this.configManager.getLanguage();
         const separator = icons.separator.repeat(40);
-        console.log('');
-        console.log(colors.border(separator));
-        if (language === 'zh') {
-            console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
-            console.log(colors.textMuted('Type /help to see available commands'));
-        }
-        else {
-            console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
-            console.log(colors.textMuted('Type /help to see available commands'));
+        if (!this.isSdkMode) {
+            console.log('');
+            console.log(colors.border(separator));
+            if (language === 'zh') {
+                console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
+                console.log(colors.textMuted('Type /help to see available commands'));
+            }
+            else {
+                console.log(colors.primaryBright(`${icons.sparkles} Welcome to XAGENT CLI!`));
+                console.log(colors.textMuted('Type /help to see available commands'));
+            }
+            console.log(colors.border(separator));
+            console.log('');
         }
-        console.log(colors.border(separator));
-        console.log('');
         this.showExecutionMode();
+        // In SDK mode, output ready signal
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputReady();
+        }
+    }
+    /**
+     * Start heartbeat timeout monitoring in SDK mode
+     */
+    startHeartbeatMonitoring() {
+        this.stopHeartbeatMonitoring();
+        // Check heartbeat timeout periodically
+        this.heartbeatTimeout = setInterval(() => {
+            const elapsed = Date.now() - this.lastActivityTime;
+            if (elapsed > this.heartbeatTimeoutMs) {
+                // Heartbeat timeout - no activity for too long
+                this.sdkOutputAdapter?.output({
+                    type: 'error',
+                    subtype: 'heartbeat_timeout',
+                    timestamp: Date.now(),
+                    data: {
+                        message: 'Heartbeat timeout - no activity detected',
+                        elapsed_ms: elapsed,
+                        timeout_ms: this.heartbeatTimeoutMs
+                    }
+                });
+                // Stop monitoring
+                this.stopHeartbeatMonitoring();
+            }
+        }, 30000); // Check every 30 seconds
+    }
+    /**
+     * Stop heartbeat timeout monitoring
+     */
+    stopHeartbeatMonitoring() {
+        if (this.heartbeatTimeout) {
+            clearInterval(this.heartbeatTimeout);
+            this.heartbeatTimeout = null;
+        }
+    }
+    /**
+     * Reset heartbeat timeout (called on activity)
+     */
+    resetHeartbeatTimeout() {
+        this.lastActivityTime = Date.now();
+    }
+    /**
+     * Stop heartbeat monitoring (public method for cleanup)
+     * Used by SDK session to clean up when session ends
+     */
+    stopHeartbeatMonitor() {
+        this.stopHeartbeatMonitoring();
     }
     showExecutionMode() {
         const modeConfig = {
             [ExecutionMode.YOLO]: {
                 color: colors.error,
                 icon: icons.fire,
-                description: 'Execute commands without confirmation'
+                description: 'Execute commands without confirmation',
             },
             [ExecutionMode.ACCEPT_EDITS]: {
                 color: colors.warning,
                 icon: icons.check,
-                description: 'Accept all edits automatically'
+                description: 'Accept all edits automatically',
             },
             [ExecutionMode.PLAN]: {
                 color: colors.info,
                 icon: icons.brain,
-                description: 'Plan before executing'
+                description: 'Plan before executing',
             },
             [ExecutionMode.DEFAULT]: {
                 color: colors.success,
                 icon: icons.bolt,
-                description: 'Safe execution with confirmations'
+                description: 'Safe execution with confirmations',
             },
             [ExecutionMode.SMART]: {
                 color: colors.primaryBright,
                 icon: icons.sparkles,
-                description: 'Smart approval with intelligent security checks'
-            }
+                description: 'Smart approval with intelligent security checks',
+            },
         };
         const config = modeConfig[this.executionMode];
         const modeName = this.executionMode;
-        console.log(colors.textMuted(`${icons.info} Current Mode:`));
-        console.log(`  ${config.color(config.icon)} ${styleHelpers.text.bold(config.color(modeName))}`);
-        console.log(`  ${colors.textDim(`  ${config.description}`)}`);
+        if (!this.isSdkMode) {
+            console.log(colors.textMuted(`${icons.info} Current Mode:`));
+            console.log(`  ${config.color(config.icon)} ${styleHelpers.text.bold(config.color(modeName))}`);
+            console.log(`  ${colors.textDim(`  ${config.description}`)}`);
+            console.log('');
+        }
+        this.showRemoteModelInfo();
+    }
+    showRemoteModelInfo() {
+        const authConfig = this.configManager.getAuthConfig();
+        const isRemote = authConfig.type === AuthType.OAUTH_XAGENT;
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+            // SDK 模式：通过 adapter 输出
+            if (isRemote) {
+                const llmModel = authConfig.remote_llmModelName || 'Not set';
+                const vlmModel = authConfig.remote_vlmModelName || 'Not set';
+                this.sdkOutputAdapter.outputInfo(`Remote Models - LLM: ${llmModel}, VLM: ${vlmModel}`);
+            }
+            else {
+                const modelName = authConfig.modelName || 'Not set';
+                const guiSubagentModel = this.configManager.get('guiSubagentModel') || 'Not set';
+                this.sdkOutputAdapter.outputInfo(`Local Models - LLM: ${modelName}, VLM: ${guiSubagentModel}`);
+            }
+            return;
+        }
+        // 正常模式：控制台输出
+        if (isRemote) {
+            const llmModel = authConfig.remote_llmModelName || colors.textMuted('Not set');
+            const vlmModel = authConfig.remote_vlmModelName || colors.textMuted('Not set');
+            console.log(colors.textMuted(`${icons.brain} Remote Models:`));
+            console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('LLM:')} ${llmModel}`);
+            console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('VLM:')} ${vlmModel}`);
+        }
+        else {
+            const modelName = authConfig.modelName || colors.textMuted('Not set');
+            const guiSubagentModel = this.configManager.get('guiSubagentModel') || colors.textMuted('Not set');
+            console.log(colors.textMuted(`${icons.brain} Local Models:`));
+            console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('LLM:')} ${modelName}`);
+            console.log(`  ${colors.primaryBright(icons.arrowRight)} ${colors.info('VLM:')} ${guiSubagentModel}`);
+        }
         console.log('');
     }
     async promptLoop() {
@@ -445,19 +790,21 @@ export class InteractiveSession {
         if (this._isShuttingDown) {
             return;
         }
+        // In SDK mode, use a different input loop
+        if (this.isSdkMode) {
+            await this.sdkPromptLoop();
+            return;
+        }
         // Recreate readline interface for input
         if (this.rl) {
             this.rl.close();
         }
-        // Enable raw mode BEFORE emitKeypressEvents for better ESC detection
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        readline.emitKeypressEvents(process.stdin);
+        // Ensure TTY is in proper state for input handling
+        // This handles any state left by @clack/prompts or other interactions
+        ensureTtySane();
         this.rl = readline.createInterface({
             input: process.stdin,
-            output: process.stdout
+            output: process.stdout,
         });
         const prompt = `${colors.primaryBright('❯')} `;
         this.rl.question(prompt, async (input) => {
@@ -474,14 +821,58 @@ export class InteractiveSession {
         });
     }
     async handleInput(input) {
+        // Reset heartbeat timeout on any input activity
+        this.resetHeartbeatTimeout();
         const trimmedInput = input.trim();
         if (!trimmedInput) {
             return;
         }
+        // Check for SDK JSON message format
+        if (this.isSdkMode) {
+            const { isSdkMessage, parseSdkMessage } = await import('./types.js');
+            if (isSdkMessage(trimmedInput)) {
+                const sdkMessage = parseSdkMessage(trimmedInput);
+                if (sdkMessage) {
+                    if (sdkMessage.type === 'ping') {
+                        // Handle ping - respond with pong
+                        await this.handlePing(sdkMessage);
+                        return;
+                    }
+                    else if (sdkMessage.type === 'control_request') {
+                        // Handle control request
+                        await this.handleControlRequest(sdkMessage);
+                        return;
+                    }
+                    else if (sdkMessage.type === 'user') {
+                        // Store request_id for tracking
+                        this._currentRequestId = sdkMessage.request_id || null;
+                        // Handle user message from SDK
+                        await this.processUserMessage(sdkMessage.content);
+                        return;
+                    }
+                    else if (sdkMessage.type === 'approval_response') {
+                        // Handle approval response
+                        await this.handleApprovalResponse(sdkMessage);
+                        return;
+                    }
+                    else if (sdkMessage.type === 'question_response') {
+                        // Handle question response
+                        await this.handleQuestionResponse(sdkMessage);
+                        return;
+                    }
+                }
+            }
+            else {
+                // Not a JSON SDK message, treat as regular text
+                await this.processUserMessage(trimmedInput);
+                return;
+            }
+        }
         if (trimmedInput.startsWith('/')) {
             const handled = await this.slashCommandHandler.handleCommand(trimmedInput);
             if (handled) {
-                this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
+                this.executionMode =
+                    this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
                 // Sync conversation history to slashCommandHandler
                 this.slashCommandHandler.setConversationHistory(this.conversation);
             }
@@ -493,6 +884,297 @@ export class InteractiveSession {
         }
         await this.processUserMessage(trimmedInput);
     }
+    /**
+     * SDK prompt loop - reads input from stdin without showing prompt
+     */
+    async sdkPromptLoop() {
+        // Read input from stdin directly without outputting prompt
+        const input = await this.readSdkInput();
+        if (this._isShuttingDown || input === null) {
+            return;
+        }
+        try {
+            await this.handleInput(input);
+        }
+        catch (err) {
+            this.sdkOutputAdapter?.output({
+                type: 'error',
+                subtype: 'general',
+                timestamp: Date.now(),
+                data: { message: err.message }
+            });
+        }
+        // Continue the loop
+        this.sdkPromptLoop();
+    }
+    sdkRl = null;
+    sdkInputProcessing = false;
+    /**
+     * Check if a line is an SDK control message (approval_response, question_response)
+     */
+    isSdkControlMessage(line) {
+        try {
+            const parsed = JSON.parse(line);
+            return parsed.type === 'approval_response' || parsed.type === 'question_response';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Process an SDK input line (returns true if processed)
+     */
+    async processSdkInputLine(line) {
+        const { isSdkMessage, parseSdkMessage } = await import('./types.js');
+        if (isSdkMessage(line)) {
+            const sdkMessage = parseSdkMessage(line);
+            if (sdkMessage) {
+                if (sdkMessage.type === 'ping') {
+                    await this.handlePing(sdkMessage);
+                    return true;
+                }
+                else if (sdkMessage.type === 'control_request') {
+                    await this.handleControlRequest(sdkMessage);
+                    return true;
+                }
+                else if (sdkMessage.type === 'user') {
+                    this._currentRequestId = sdkMessage.request_id || null;
+                    await this.processUserMessage(sdkMessage.content);
+                    return true;
+                }
+                else if (sdkMessage.type === 'approval_response') {
+                    await this.handleApprovalResponse(sdkMessage);
+                    return true;
+                }
+                else if (sdkMessage.type === 'question_response') {
+                    await this.handleQuestionResponse(sdkMessage);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Read a line of input from stdin (SDK mode)
+     * Uses readline 'line' event for reliable stdin reading
+     * SDK control messages (approval_response, question_response) bypass the main loop
+     */
+    readSdkInput() {
+        return new Promise((resolve) => {
+            // Create readline interface if not exists
+            if (!this.sdkRl) {
+                this.sdkRl = readline.createInterface({
+                    input: process.stdin,
+                    crlfDelay: Infinity,
+                });
+                // Handle line events - SDK control messages bypass normal flow
+                this.sdkRl.on('line', async (line) => {
+                    const cleanLine = line
+                        .replace(/^\uFEFF/, '')
+                        // eslint-disable-next-line no-control-regex
+                        .replace(/[\x00-\x1F\x7F-\x9F]/g, '');
+                    // Check if this is an SDK control message
+                    if (this.isSdkControlMessage(cleanLine)) {
+                        // Process immediately, don't wait for main loop
+                        // We need to set a flag to prevent re-entrancy issues
+                        if (this.sdkInputProcessing) {
+                            // Already processing, queue it
+                            this.sdkInputBuffer.push(cleanLine);
+                        }
+                        else {
+                            this.sdkInputProcessing = true;
+                            try {
+                                await this.processSdkInputLine(cleanLine);
+                            }
+                            finally {
+                                this.sdkInputProcessing = false;
+                            }
+                        }
+                        return;
+                    }
+                    // Regular input
+                    if (this.resolveInput) {
+                        // Immediate handler available, resolve immediately
+                        this.resolveInput(cleanLine);
+                        this.resolveInput = null;
+                    }
+                    else {
+                        // No handler available, queue the message
+                        this.sdkInputBuffer.push(cleanLine);
+                    }
+                });
+                // Handle close events
+                this.sdkRl.on('close', () => {
+                    if (this.resolveInput) {
+                        this.resolveInput(null);
+                        this.resolveInput = null;
+                    }
+                });
+                // Handle errors
+                this.sdkRl.on('error', () => {
+                    if (this.resolveInput) {
+                        this.resolveInput(null);
+                        this.resolveInput = null;
+                    }
+                });
+            }
+            // Check for SDK control messages in buffer first
+            for (let i = 0; i < this.sdkInputBuffer.length; i++) {
+                const line = this.sdkInputBuffer[i];
+                if (this.isSdkControlMessage(line)) {
+                    this.sdkInputBuffer.splice(i, 1);
+                    resolve(line);
+                    return;
+                }
+            }
+            if (this.sdkInputBuffer.length > 0) {
+                const line = this.sdkInputBuffer.shift();
+                resolve(line);
+                return;
+            }
+            // Set up the resolve callback
+            this.resolveInput = (value) => {
+                resolve(value);
+            };
+        });
+    }
+    /**
+     * Handle SDK ping messages (heartbeat)
+     */
+    async handlePing(pingMessage) {
+        const requestId = pingMessage.request_id || `ping_${Date.now()}`;
+        // Reset activity timestamp on ping (heartbeat activity)
+        this.lastActivityTime = Date.now();
+        // Send pong response through SDK adapter for consistency
+        this.sdkOutputAdapter?.output({
+            type: 'system',
+            subtype: 'pong',
+            timestamp: Date.now(),
+            data: {
+                type: 'pong',
+                request_id: requestId,
+                timestamp: Date.now()
+            }
+        });
+    }
+    /**
+     * Handle SDK control requests
+     */
+    async handleControlRequest(request) {
+        // Update activity to prevent heartbeat timeout during control requests
+        this.lastActivityTime = Date.now();
+        const { request_id, request: req } = request;
+        switch (req.subtype) {
+            case 'interrupt':
+                this.sdkOutputAdapter?.outputSystem('interrupt', { request_id });
+                this._isShuttingDown = true;
+                process.exit(0);
+                break;
+            case 'set_permission_mode':
+                {
+                    const { ExecutionMode } = await import('./types.js');
+                    const modeMap = {
+                        'default': ExecutionMode.DEFAULT,
+                        'acceptEdits': ExecutionMode.ACCEPT_EDITS,
+                        'plan': ExecutionMode.PLAN,
+                        'bypassPermissions': ExecutionMode.YOLO,
+                    };
+                    const mode = modeMap[req.mode] || ExecutionMode.SMART;
+                    this.executionMode = mode;
+                    this.sdkOutputAdapter?.outputSystem('permission_mode_changed', {
+                        request_id,
+                        mode: req.mode
+                    });
+                }
+                break;
+            case 'set_model':
+                this.sdkOutputAdapter?.outputSystem('model_changed', {
+                    request_id,
+                    model: req.model
+                });
+                break;
+            default:
+                this.sdkOutputAdapter?.outputWarning(`Unknown control request: ${req.subtype}`);
+        }
+    }
+    /**
+     * Handle SDK approval responses
+     */
+    async handleApprovalResponse(response) {
+        const { request_id, approved } = response;
+        const pending = this.approvalPromises.get(request_id);
+        if (pending) {
+            pending.resolve(approved);
+            this.approvalPromises.delete(request_id);
+        }
+        else {
+            this.sdkOutputAdapter?.outputWarning(`Unknown approval request ID: ${request_id}`);
+        }
+    }
+    /**
+     * Handle SDK question responses
+     */
+    async handleQuestionResponse(response) {
+        const { request_id, answers } = response;
+        const pending = this.questionPromises.get(request_id);
+        if (pending) {
+            pending.resolve(answers);
+            this.questionPromises.delete(request_id);
+        }
+        else {
+            this.sdkOutputAdapter?.outputWarning(`Unknown question request ID: ${request_id}`);
+        }
+    }
+    /**
+     * Wait for SDK approval response
+     */
+    async waitForApprovalResponse(requestId, timeoutMs = 300000) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const pending = this.approvalPromises.get(requestId);
+                if (pending) {
+                    pending.reject(new Error('Approval request timeout'));
+                    this.approvalPromises.delete(requestId);
+                }
+                resolve(false);
+            }, timeoutMs);
+            this.approvalPromises.set(requestId, {
+                resolve: (approved) => {
+                    clearTimeout(timeout);
+                    resolve(approved);
+                },
+                reject: (err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Wait for SDK question response
+     */
+    async waitForQuestionResponse(requestId, timeoutMs = 300000) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const pending = this.questionPromises.get(requestId);
+                if (pending) {
+                    pending.reject(new Error('Question request timeout'));
+                    this.questionPromises.delete(requestId);
+                }
+                resolve([]); // Return empty array on timeout instead of rejecting
+            }, timeoutMs);
+            this.questionPromises.set(requestId, {
+                resolve: (answers) => {
+                    clearTimeout(timeout);
+                    resolve(answers);
+                },
+                reject: (err) => {
+                    clearTimeout(timeout);
+                    reject(err);
+                }
+            });
+        });
+    }
     async handleSubAgentCommand(input) {
         const [agentType, ...taskParts] = input.slice(1).split(' ');
         const task = taskParts.join(' ');
@@ -511,11 +1193,11 @@ export class InteractiveSession {
         this.currentAgent = agent;
         await this.processUserMessage(task, agent);
     }
-    async processUserMessage(message, agent) {
-        const inputs = parseInput(message);
-        const textInput = inputs.find(i => i.type === 'text');
-        const fileInputs = inputs.filter(i => i.type === 'file');
-        const commandInput = inputs.find(i => i.type === 'command');
+    async processUserMessage(message, _agent) {
+        const inputs = await parseInput(message);
+        const textInput = inputs.find((i) => i.type === 'text');
+        const fileInputs = inputs.filter((i) => i.type === 'file');
+        const commandInput = inputs.find((i) => i.type === 'command');
         if (commandInput) {
             await this.executeShellCommand(commandInput.content);
             return;
@@ -538,7 +1220,7 @@ export class InteractiveSession {
             type: 'text',
             content: userContent,
             rawInput: message,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         };
         await this.sessionManager.addInput(sessionInput);
         // Calculate thinking tokens based on config and user input
@@ -552,25 +1234,19 @@ export class InteractiveSession {
         const userMessage = {
             role: 'user',
             content: userContent,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         };
-        // Save last user message for recovery after compression
-        const lastUserMessage = userMessage;
         this.conversation.push(userMessage);
         await this.conversationManager.addMessage(userMessage);
-        // Check if context compression is needed
-        await this.checkAndCompressContext(lastUserMessage);
         // Use remote AI client if available (OAuth XAGENT mode)
         const currentSelectedAuthType = this.configManager.get('selectedAuthType');
-        logger.debug('[DEBUG processUserMessage] remoteAIClient exists:', !!this.remoteAIClient ? 'true' : 'false');
-        logger.debug('[DEBUG processUserMessage] selectedAuthType:', String(currentSelectedAuthType));
-        logger.debug('[DEBUG processUserMessage] AuthType.OAUTH_XAGENT:', String(AuthType.OAUTH_XAGENT));
+        logger.debug(`[DEBUG] processUserMessage: remoteAIClient exists=${!!this.remoteAIClient}, selectedAuthType=${currentSelectedAuthType}`);
         if (this.remoteAIClient) {
-            logger.debug('[DEBUG processUserMessage] Using generateRemoteResponse');
+            logger.debug('[DEBUG] Using generateRemoteResponse (remote mode)');
             await this.generateRemoteResponse(thinkingTokens);
         }
         else {
-            logger.debug('[DEBUG processUserMessage] Using generateResponse (local mode)');
+            logger.debug('[DEBUG] Using generateResponse (local mode)');
             await this.generateResponse(thinkingTokens);
         }
     }
@@ -578,6 +1254,11 @@ export class InteractiveSession {
         const indent = this.getIndent();
         const thinkingConfig = this.configManager.getThinkingConfig();
         const displayMode = thinkingConfig.displayMode || 'compact';
+        // SDK 模式：使用 adapter 输出
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputThinking(reasoningContent, displayMode);
+            return;
+        }
         const separator = icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length);
         console.log('');
         console.log(`${indent}${colors.border(separator)}`);
@@ -588,7 +1269,7 @@ export class InteractiveSession {
                 console.log('');
                 console.log(`${indent}${colors.textDim(reasoningContent.replace(/^/gm, indent))}`);
                 break;
-            case 'compact':
+            case 'compact': {
                 // Compact display, truncate partial content
                 const maxLength = 500;
                 const truncatedContent = reasoningContent.length > maxLength
@@ -599,6 +1280,7 @@ export class InteractiveSession {
                 console.log(`${indent}${colors.textDim(truncatedContent.replace(/^/gm, indent))}`);
                 console.log(`${indent}${colors.textDim(`[${reasoningContent.length} chars total]`)}`);
                 break;
+            }
             case 'indicator':
                 // Show indicator only
                 console.log(`${indent}${colors.textDim(`${icons.brain} Thinking process completed`)}`);
@@ -615,34 +1297,69 @@ export class InteractiveSession {
     /**
      * Check and compress conversation context
      */
-    async checkAndCompressContext(lastUserMessage) {
+    async checkAndCompressContext() {
         const compressionConfig = this.configManager.getContextCompressionConfig();
         if (!compressionConfig.enabled) {
             return;
         }
-        const { needsCompression, reason } = this.contextCompressor.needsCompression(this.conversation, compressionConfig);
-        if (needsCompression) {
-            const indent = this.getIndent();
+        const indent = this.getIndent();
+        const _currentTokens = this.contextCompressor.estimateContextTokens(this.conversation);
+        const currentMessages = this.conversation.length;
+        const { needsCompression, reason, tokenCount } = this.contextCompressor.needsCompression(this.conversation, compressionConfig);
+        if (!needsCompression) {
+            return;
+        }
+        // Extract threshold and contextWindow from reason
+        const thresholdMatch = reason.match(/budget\s*\((\d+)/);
+        const contextWindowMatch = reason.match(/contextWindow:\s*(\d+)/);
+        const threshold = thresholdMatch ? parseInt(thresholdMatch[1], 10) : 0;
+        const contextWindow = contextWindowMatch ? parseInt(contextWindowMatch[1], 10) : 0;
+        if (this.isSdkMode && this.sdkOutputAdapter) {
+            this.sdkOutputAdapter.outputContextCompressionTriggered(reason);
+        }
+        else {
             console.log('');
-            console.log(`${indent}${colors.warning(`${icons.brain} Context compression triggered: ${reason}`)}`);
-            const toolRegistry = getToolRegistry();
-            const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
-            const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
-            const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
-            const result = await this.contextCompressor.compressContext(this.conversation, enhancedSystemPrompt, compressionConfig);
-            if (result.wasCompressed) {
-                this.conversation = result.compressedMessages;
-                // console.log(`${indent}${colors.success(`✓ Compressed ${result.originalMessageCount} messages to ${result.compressedMessageCount} messages`)}`);
-                console.log(`${indent}${colors.textMuted(`✓ Size: ${result.originalSize} → ${result.compressedSize} chars (${Math.round((1 - result.compressedSize / result.originalSize) * 100)}% reduction)`)}`);
-                // Display compressed summary content
-                const summaryMessage = result.compressedMessages.find(m => m.role === 'assistant');
-                if (summaryMessage && summaryMessage.content) {
-                    const maxPreviewLength = 800;
-                    let summaryContent = summaryMessage.content;
-                    const isTruncated = summaryContent.length > maxPreviewLength;
-                    if (isTruncated) {
-                        summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
-                    }
+            console.log(`${indent}${colors.success(`${icons.sparkles} Compressing context (${currentMessages} msgs, ${tokenCount.toLocaleString()} > ${threshold.toLocaleString()}/${contextWindow.toLocaleString()} tokens, ${Math.round((tokenCount / contextWindow) * 100)}% of context window)...`)}`);
+        }
+        const toolRegistry = getToolRegistry();
+        const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
+        const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+        const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
+        const result = await this.contextCompressor.compressContext(this.conversation, enhancedSystemPrompt, compressionConfig);
+        if (result.wasCompressed) {
+            this.conversation = result.compressedMessages;
+            const reductionPercent = Math.round((1 - result.compressedSize / result.originalSize) * 100);
+            if (this.isSdkMode && this.sdkOutputAdapter) {
+                this.sdkOutputAdapter.outputContextCompressionResult(result.originalSize, result.compressedSize, reductionPercent, result.originalMessageCount, result.compressedMessageCount);
+            }
+            else {
+                console.log(`${indent}${colors.success(`${icons.success} Compressed ${result.originalMessageCount} → ${result.compressedMessageCount} messages (${reductionPercent}% smaller)`)}`);
+            }
+            // Summary is embedded in first user message, look for it
+            // The format is: "[Conversation Summary - X messages compressed]\n\n${summary}"
+            let summaryMessage = result.compressedMessages.find((m) => m.role === 'user' && m.content.includes('[Conversation Summary'));
+            if (summaryMessage) {
+                // Extract summary content after the header
+                const match = summaryMessage.content.match(/\[Conversation Summary.*?\]:\n\n(.+)/s);
+                if (match) {
+                    summaryMessage = {
+                        role: 'assistant',
+                        content: match[1],
+                        timestamp: summaryMessage.timestamp,
+                    };
+                }
+            }
+            if (summaryMessage && summaryMessage.content) {
+                const maxPreviewLength = 800;
+                let summaryContent = summaryMessage.content;
+                const isTruncated = summaryContent.length > maxPreviewLength;
+                if (isTruncated) {
+                    summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
+                }
+                if (this.isSdkMode && this.sdkOutputAdapter) {
+                    this.sdkOutputAdapter.outputContextCompressionSummary('Conversation compressed successfully', summaryContent, isTruncated, summaryMessage.content.length);
+                }
+                else {
                     console.log('');
                     console.log(`${indent}${theme.predefinedStyles.title(`${icons.sparkles} Conversation Summary`)}`);
                     const separator = icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length * 2);
@@ -654,13 +1371,9 @@ export class InteractiveSession {
                     }
                     console.log(`${indent}${colors.border(separator)}`);
                 }
-                // Restore user messages after compression, ensuring user message exists for API calls
-                if (lastUserMessage) {
-                    this.conversation.push(lastUserMessage);
-                }
-                // Sync compressed conversation history to slashCommandHandler
-                this.slashCommandHandler.setConversationHistory(this.conversation);
             }
+            // Sync compressed conversation history to slashCommandHandler
+            this.slashCommandHandler.setConversationHistory(this.conversation);
         }
     }
     async executeShellCommand(command) {
@@ -683,15 +1396,15 @@ export class InteractiveSession {
                 tool: 'Bash',
                 params: { command },
                 result,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             };
-            this.toolCalls.push(toolCall);
+            this.tool_calls.push(toolCall);
             // Record command execution to session manager
             await this.sessionManager.addInput({
                 type: 'command',
                 content: command,
                 rawInput: command,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
             await this.sessionManager.addOutput({
                 role: 'tool',
@@ -699,7 +1412,7 @@ export class InteractiveSession {
                 toolName: 'Bash',
                 toolParams: { command },
                 toolResult: result,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
         }
         catch (error) {
@@ -724,11 +1437,22 @@ export class InteractiveSession {
     /**
      * Create remote mode LLM caller
      */
-    createRemoteCaller(taskId, status) {
+    createRemoteCaller(taskId, _status) {
         const client = this.remoteAIClient;
         return {
-            chatCompletion: (messages, options) => client.chatCompletion(messages, { ...options, taskId, status }),
-            isRemote: true
+            chatCompletion: (messages, options) => {
+                // Must fetch authConfig inside the closure, otherwise it captures stale config
+                const authConfig = this.configManager.getAuthConfig();
+                logger.debug(`[DEBUG] createRemoteCaller: llmModelName=${authConfig.remote_llmModelName}, vlmModelName=${authConfig.remote_vlmModelName}`);
+                return client.chatCompletion(messages, {
+                    ...options,
+                    taskId,
+                    status: options.isFirstApiCall ? 'begin' : 'continue',
+                    llmModelName: authConfig.remote_llmModelName,
+                    vlmModelName: authConfig.remote_vlmModelName
+                });
+            },
+            isRemote: true,
         };
     }
     /**
@@ -738,47 +1462,43 @@ export class InteractiveSession {
         const client = this.aiClient;
         return {
             chatCompletion: (messages, options) => client.chatCompletion(messages, options),
-            isRemote: false
+            isRemote: false,
         };
     }
-    async generateResponse(thinkingTokens = 0, customAIClient, existingTaskId) {
+    async generateResponse(thinkingTokens = 0, _customAIClient, existingTaskId) {
         // Use existing taskId or create new one for this user interaction
         // If taskId already exists (e.g., from tool calls), reuse it
         const taskId = existingTaskId || this.currentTaskId || crypto.randomUUID();
         this.currentTaskId = taskId;
-        this.isFirstApiCall = true;
-        // Determine status based on whether this is the first API call
+        // isFirstApiCall is reset in generateRemoteResponse for new tasks
+        // For continuation calls (existingTaskId provided), keep previous value
+        // Use unified LLM Caller with taskId (automatically selects local or remote mode)
         const status = this.isFirstApiCall ? 'begin' : 'continue';
-        // Use custom AI client if provided, otherwise use default logic
-        let chatCompletion;
-        let isRemote = false;
-        if (customAIClient) {
-            // Custom client (used by remote mode) - pass taskId and status
-            chatCompletion = (messages, options) => customAIClient.chatCompletion(messages, { ...options, taskId, status });
-            isRemote = true;
-        }
-        else {
-            // Use unified LLM Caller with taskId (automatically selects local or remote mode)
-            const caller = this.createLLMCaller(taskId, status);
-            chatCompletion = caller.chatCompletion;
-            isRemote = caller.isRemote;
-        }
-        if (!isRemote && !this.aiClient && !customAIClient) {
+        const caller = this.createLLMCaller(taskId, status);
+        const chatCompletion = caller.chatCompletion;
+        const isRemote = caller.isRemote;
+        if (!isRemote && !this.aiClient) {
             console.log(colors.error('AI client not initialized'));
             return;
         }
         // Mark that an operation is in progress
         this._isOperationInProgress = true;
-        const indent = this.getIndent();
         const thinkingText = colors.textMuted(`Thinking... (Press ESC to cancel)`);
         const icon = colors.primary(icons.brain);
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let frameIndex = 0;
+        // SDK 模式下不显示 spinner
+        const showThinkingSpinner = !this.isSdkMode;
+        let spinnerInterval = null;
         // Custom spinner: only icon rotates, text stays static
-        const spinnerInterval = setInterval(() => {
-            process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${icon} ${thinkingText}`);
-            frameIndex = (frameIndex + 1) % frames.length;
-        }, 120);
+        if (showThinkingSpinner) {
+            spinnerInterval = setInterval(() => {
+                process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${icon} ${thinkingText}`);
+                frameIndex = (frameIndex + 1) % frames.length;
+            }, 120);
+        }
+        let content = '';
+        let reasoningContent = '';
         try {
             const memory = await this.memoryManager.loadMemory();
             const toolRegistry = getToolRegistry();
@@ -790,81 +1510,94 @@ export class InteractiveSession {
             const toolDefinitions = toolRegistry.getToolDefinitions();
             // Available tools for this session
             const availableTools = this.executionMode !== ExecutionMode.DEFAULT && allowedToolNames.length > 0
-                ? toolDefinitions.filter((tool) => allowedToolNames.includes(tool.function.name))
+                ? toolDefinitions.filter((tool) => typeof tool.function?.name === 'string' &&
+                    allowedToolNames.includes(tool.function.name))
                 : toolDefinitions;
-            const baseSystemPrompt = this.currentAgent?.systemPrompt;
+            const baseSystemPrompt = this.currentAgent?.systemPrompt ?? '';
             const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
             const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
             const messages = [
                 { role: 'system', content: `${enhancedSystemPrompt}\n\n${memory}`, timestamp: Date.now() },
-                ...this.conversation
+                ...this.conversation,
             ];
             const operationId = `ai-response-${Date.now()}`;
             const response = await this.cancellationManager.withCancellation(chatCompletion(messages, {
                 tools: availableTools,
                 toolChoice: availableTools.length > 0 ? 'auto' : 'none',
-                thinkingTokens
+                thinkingTokens,
+                isFirstApiCall: this.isFirstApiCall,
             }), operationId);
             // Mark that first API call is complete
             this.isFirstApiCall = false;
-            clearInterval(spinnerInterval);
+            if (spinnerInterval)
+                clearInterval(spinnerInterval);
             process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r'); // Clear spinner line
             const assistantMessage = response.choices[0].message;
-            const content = typeof assistantMessage.content === 'string'
-                ? assistantMessage.content
-                : '';
-            const reasoningContent = assistantMessage.reasoning_content || '';
+            content = typeof assistantMessage.content === 'string' ? assistantMessage.content : '';
+            reasoningContent = assistantMessage.reasoning_content || '';
             // Display reasoning content if available and thinking mode is enabled
             if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
                 this.displayThinkingContent(reasoningContent);
             }
-            console.log('');
-            console.log(`${indent}${colors.primaryBright(`${icons.robot} Assistant:`)}`);
-            console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
-            console.log('');
-            const renderedContent = renderMarkdown(content, (process.stdout.columns || 80) - indent.length * 2);
-            console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
-            console.log('');
+            // Output assistant response
+            this.outputAssistant(content, reasoningContent);
             this.conversation.push({
                 role: 'assistant',
                 content,
                 timestamp: Date.now(),
-                reasoningContent,
-                toolCalls: assistantMessage.tool_calls
+                reasoning_content: reasoningContent,
+                tool_calls: assistantMessage.tool_calls,
             });
             // Record output to session manager
             await this.sessionManager.addOutput({
                 role: 'assistant',
                 content,
                 timestamp: Date.now(),
-                reasoningContent,
-                toolCalls: assistantMessage.tool_calls
+                reasoning_content: reasoningContent,
+                tool_calls: assistantMessage.tool_calls,
             });
             if (assistantMessage.tool_calls) {
                 await this.handleToolCalls(assistantMessage.tool_calls);
             }
+            else {
+                await this.checkAndCompressContext();
+            }
             if (this.checkpointManager.isEnabled()) {
-                await this.checkpointManager.createCheckpoint(`Response generated at ${new Date().toLocaleString()}`, [...this.conversation], [...this.toolCalls]);
+                await this.checkpointManager.createCheckpoint(`Response generated at ${new Date().toLocaleString()}`, [...this.conversation], [...this.tool_calls]);
+            }
+            // Signal request completion to SDK (no tools to execute)
+            if (this.isSdkMode && this.sdkOutputAdapter && this._currentRequestId) {
+                this.sdkOutputAdapter.outputRequestDone(this._currentRequestId, 'success');
+                this._currentRequestId = null;
             }
             // Operation completed successfully, clear the flag
             this._isOperationInProgress = false;
         }
         catch (error) {
-            clearInterval(spinnerInterval);
+            if (spinnerInterval)
+                clearInterval(spinnerInterval);
             process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
             // Clear the operation flag
             this._isOperationInProgress = false;
+            // Signal request completion to SDK
+            if (this.isSdkMode && this.sdkOutputAdapter && this._currentRequestId) {
+                const status = error.message === 'Operation cancelled by user' ? 'cancelled' : 'error';
+                this.sdkOutputAdapter.outputRequestDone(this._currentRequestId, status);
+                this._currentRequestId = null;
+            }
             if (error.message === 'Operation cancelled by user') {
-                // Mark task as cancelled
+                // Notify backend to cancel the task
                 if (this.remoteAIClient && this.currentTaskId) {
-                    await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => { });
+                    await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => { });
                 }
                 return;
             }
-            // Mark task as cancelled when error occurs (发送 status: 'cancel')
-            logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}`);
+            // Distinguish error types: timeout vs other failures
+            const isTimeout = error.message.includes('timeout') || error.message.includes('Timeout');
+            const failureReason = isTimeout ? 'timeout' : 'failure';
+            logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}, reason: ${failureReason}`);
             if (this.remoteAIClient && this.currentTaskId) {
-                await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => { });
+                await this.remoteAIClient.failTask?.(this.currentTaskId, failureReason).catch(() => { });
             }
             console.log(colors.error(`Error: ${error.message}`));
         }
@@ -881,12 +1614,10 @@ export class InteractiveSession {
         const taskId = existingTaskId || crypto.randomUUID();
         this.currentTaskId = taskId;
         logger.debug(`[Session] generateRemoteResponse: taskId=${taskId}, existingTaskId=${!!existingTaskId}`);
-        // Reset isFirstApiCall for new task, keep true for continuation
-        if (!existingTaskId) {
-            this.isFirstApiCall = true;
-        }
-        // Determine status based on whether this is the first API call
-        const status = this.isFirstApiCall ? 'begin' : 'continue';
+        // Each new user message is a fresh task - always set isFirstApiCall = true
+        // This ensures status is 'begin' for every user message
+        this.isFirstApiCall = true;
+        const status = 'begin';
         logger.debug(`[Session] Status for this call: ${status}, isFirstApiCall=${this.isFirstApiCall}`);
         // Check if remote client is available
         if (!this.remoteAIClient) {
@@ -894,18 +1625,23 @@ export class InteractiveSession {
             return;
         }
         try {
-            // Reuse generateResponse with remote client, pass taskId to avoid generating new one
-            await this.generateResponse(thinkingTokens, this.remoteAIClient, taskId);
+            // Use unified generateResponse without passing customAIClient,
+            // let createLLMCaller handle remote/local selection
+            await this.generateResponse(thinkingTokens, undefined, taskId);
             // Mark task as completed (发送 status: 'end')
             logger.debug(`[Session] Task completed: taskId=${this.currentTaskId}`);
-            if (this.currentTaskId) {
-                await this.remoteAIClient.completeTask(this.currentTaskId);
+            if (this.remoteAIClient && this.currentTaskId) {
+                await this.remoteAIClient.completeTask?.(this.currentTaskId);
             }
         }
         catch (error) {
             // Clear the operation flag
             this._isOperationInProgress = false;
             if (error.message === 'Operation cancelled by user') {
+                // Notify backend to cancel the task
+                if (this.remoteAIClient && this.currentTaskId) {
+                    await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => { });
+                }
                 return;
             }
             // Handle token invalid error - trigger re-authentication
@@ -915,46 +1651,48 @@ export class InteractiveSession {
                 console.log(colors.info('Your browser session has been logged out. Please log in again.'));
                 console.log('');
                 // Clear invalid credentials and persist
-                await this.configManager.set('apiKey', '');
-                await this.configManager.set('refreshToken', '');
-                await this.configManager.save('global');
+                this.configManager.set('apiKey', '');
+                this.configManager.set('refreshToken', '');
+                this.configManager.save('global');
                 logger.debug('[DEBUG generateRemoteResponse] Cleared invalid credentials, starting re-authentication...');
                 // Re-authenticate
                 await this.setupAuthentication();
                 // Reload config to ensure we have the latest authConfig
-                logger.debug('[DEBUG generateRemoteResponse] Re-authentication completed, reloading config...');
-                await this.configManager.load();
+                this.configManager.load();
                 const authConfig = this.configManager.getAuthConfig();
                 logger.debug('[DEBUG generateRemoteResponse] After re-auth:');
-                logger.debug('  - authConfig.apiKey exists:', !!authConfig.apiKey ? 'true' : 'false');
-                // Recreate readline interface after inquirer
+                logger.debug('  - authConfig.apiKey exists:', authConfig.apiKey ? 'true' : 'false');
+                // Recreate readline interface after interactive prompt
                 this.rl.close();
                 this.rl = readline.createInterface({
                     input: process.stdin,
-                    output: process.stdout
+                    output: process.stdout,
                 });
                 this.rl.on('close', () => {
                     logger.debug('DEBUG: readline interface closed');
                 });
                 // Reinitialize RemoteAIClient with new token
                 if (authConfig.apiKey) {
-                    const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
                     logger.debug('[DEBUG generateRemoteResponse] Reinitializing RemoteAIClient with new token');
-                    this.remoteAIClient = new RemoteAIClient(authConfig.apiKey, webBaseUrl, authConfig.showAIDebugInfo);
+                    this.remoteAIClient = createAIClient(authConfig);
                 }
                 else {
                     logger.debug('[DEBUG generateRemoteResponse] WARNING: No apiKey after re-authentication!');
                 }
+                // Sync remoteAIClient reference to slashCommandHandler for /provider command
+                this.slashCommandHandler.setRemoteAIClient(this.remoteAIClient);
                 // Retry the current operation
                 console.log('');
                 console.log(colors.info('Retrying with new authentication...'));
                 console.log('');
                 return this.generateRemoteResponse(thinkingTokens);
             }
-            // Mark task as cancelled when error occurs (发送 status: 'cancel')
-            logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}`);
+            // Distinguish error types: timeout vs other failures
+            const isTimeout = error.message.includes('timeout') || error.message.includes('Timeout');
+            const failureReason = isTimeout ? 'timeout' : 'failure';
+            logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}, reason: ${failureReason}`);
             if (this.remoteAIClient && this.currentTaskId) {
-                await this.remoteAIClient.cancelTask(this.currentTaskId).catch(() => { });
+                await this.remoteAIClient.failTask?.(this.currentTaskId, failureReason).catch(() => { });
             }
             console.log(colors.error(`Error: ${error.message}`));
             return;
@@ -973,238 +1711,284 @@ export class InteractiveSession {
             try {
                 parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
             }
-            catch (e) {
+            catch {
                 parsedParams = params;
             }
             return { name, params: parsedParams, index, id: toolCall.id };
         });
         // Display all tool calls info
         for (const { name, params } of preparedToolCalls) {
-            if (showToolDetails) {
-                console.log('');
-                console.log(`${indent}${colors.warning(`${icons.tool} Tool Call: ${name}`)}`);
-                console.log(`${indent}${colors.textDim(JSON.stringify(params, null, 2))}`);
+            // SDK mode: use adapter output
+            if (this.isSdkMode && this.sdkOutputAdapter) {
+                this.sdkOutputAdapter.outputToolStart(name, params);
             }
             else {
-                const toolDescription = this.getToolDescription(name, params);
-                console.log(`${indent}${colors.textMuted(`${icons.loading} ${toolDescription}`)}`);
+                // Normal mode: console output
+                if (showToolDetails) {
+                    console.log('');
+                    console.log(`${indent}${colors.warning(`${icons.tool} Tool Call: ${name}`)}`);
+                    console.log(`${indent}${colors.textDim(JSON.stringify(params, null, 2))}`);
+                }
+                else {
+                    const toolDescription = this.getToolDescription(name, params);
+                    console.log(`${indent}${colors.textMuted(`${icons.loading} ${toolDescription}`)}`);
+                }
             }
         }
         // Execute all tools in parallel
-        const results = await toolRegistry.executeAll(preparedToolCalls.map(tc => ({ name: tc.name, params: tc.params })), this.executionMode);
-        // Process results and maintain order
-        let hasError = false;
-        for (const { tool, result, error } of results) {
-            const toolCall = preparedToolCalls.find(tc => tc.name === tool);
-            if (!toolCall)
-                continue;
-            const { params } = toolCall;
+        const results = await toolRegistry.executeAll(preparedToolCalls.map((tc) => ({ name: tc.name, params: tc.params })), this.executionMode);
+        // Create a map to store results by tool call index to maintain original order
+        const resultsByIndex = new Map();
+        const usedIndices = new Set();
+        for (const result of results) {
+            // Find the first unused original index in preparedToolCalls that matches the tool name
+            const originalIndex = preparedToolCalls.findIndex((tc, idx) => tc.name === result.tool && !usedIndices.has(idx));
+            if (originalIndex !== -1) {
+                usedIndices.add(originalIndex);
+                resultsByIndex.set(originalIndex, result);
+            }
+        }
+        // Process results in the original tool_calls order (critical for Anthropic format APIs)
+        let _hasError = false;
+        for (let i = 0; i < preparedToolCalls.length; i++) {
+            const toolCall = preparedToolCalls[i];
+            const { name: tool, params } = toolCall;
+            const resultData = resultsByIndex.get(i);
+            const result = resultData?.result;
+            const error = resultData?.error;
             if (error) {
                 if (error === 'Operation cancelled by user') {
+                    // Notify backend to cancel the task
+                    if (this.remoteAIClient && this.currentTaskId) {
+                        await this.remoteAIClient.cancelTask?.(this.currentTaskId).catch(() => { });
+                    }
+                    // 清理 conversation 中未完成的 tool_call
+                    this.cleanupIncompleteToolCalls();
                     this._isOperationInProgress = false;
                     return;
                 }
-                hasError = true;
-                console.log('');
-                console.log(`${indent}${colors.error(`${icons.cross} Tool Error: ${tool} - ${error}`)}`);
-                // 添加详细的错误信息，包含工具名称和参数，便于 AI 理解和修正
+                _hasError = true;
+                // SDK mode: use adapter output
+                if (this.isSdkMode && this.sdkOutputAdapter) {
+                    this.sdkOutputAdapter.outputToolError(tool, error);
+                }
+                else {
+                    // Normal mode: console output
+                    console.log('');
+                    console.log(`${indent}${colors.error(`${icons.cross} Tool Error: ${tool} - ${error}`)}`);
+                }
+                // Add detailed error info including tool name and params for AI understanding and correction
                 this.conversation.push({
                     role: 'tool',
                     content: JSON.stringify({
                         name: tool,
                         parameters: params,
-                        error: error
+                        error: error,
                     }),
                     tool_call_id: toolCall.id,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
             }
             else {
+                // SDK mode: output tool result via adapter
+                if (this.isSdkMode && this.sdkOutputAdapter) {
+                    this.sdkOutputAdapter.outputToolResult(tool, result);
+                }
                 // Use correct indent for gui-subagent tasks
                 const isGuiSubagent = tool === 'task' && params?.subagent_type === 'gui-subagent';
                 const displayIndent = isGuiSubagent ? indent + '  ' : indent;
-                // Always show details for todo tools so users can see their task lists
-                const isTodoTool = tool === 'todo_write' || tool === 'todo_read';
-                // Special handling for edit tool with diff
-                const isEditTool = tool === 'Edit';
-                const hasDiff = isEditTool && result?.diff;
-                // Special handling for Write tool with file preview
-                const isWriteTool = tool === 'Write';
-                const hasFilePreview = isWriteTool && result?.preview;
-                // Special handling for DeleteFile tool
-                const isDeleteTool = tool === 'DeleteFile';
-                const hasDeleteInfo = isDeleteTool && result?.filePath;
-                // Special handling for task tool (subagent)
-                const isTaskTool = tool === 'task' && params?.subagent_type;
-                // Check if tool is an MCP wrapper tool by looking up in tool registry
-                const { getToolRegistry } = await import('./tools.js');
-                const toolRegistry = getToolRegistry();
-                const toolDef = toolRegistry.get(tool);
-                const isMcpTool = toolDef && toolDef._isMcpTool === true;
-                if (isTodoTool) {
-                    console.log('');
-                    console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
-                    console.log(this.renderTodoList(result?.todos || [], displayIndent));
-                    // Show summary if available
-                    if (result?.message) {
-                        console.log(`${displayIndent}${colors.textDim(result.message)}`);
-                    }
-                }
-                else if (hasDiff) {
-                    // Show edit result with diff
-                    console.log('');
-                    const diffOutput = renderDiff(result.diff);
-                    const indentedDiff = diffOutput.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
-                    console.log(`${indentedDiff}`);
-                }
-                else if (hasFilePreview) {
-                    // Show new file content in diff-like style
-                    console.log('');
-                    console.log(`${displayIndent}${colors.success(`${icons.file} ${result.filePath}`)}`);
-                    console.log(`${displayIndent}${colors.textDim(`  ${result.lineCount} lines`)}`);
-                    console.log('');
-                    console.log(renderLines(result.preview, { maxLines: 10, indent: displayIndent + '  ' }));
-                }
-                else if (hasDeleteInfo) {
-                    // Show DeleteFile result
-                    console.log('');
-                    console.log(`${displayIndent}${colors.success(`${icons.check} Deleted: ${result.filePath}`)}`);
-                }
-                else if (isTaskTool) {
-                    // Special handling for task tool (subagent) - show friendly summary
-                    console.log('');
-                    const subagentType = params.subagent_type;
-                    const subagentName = params.description || (params.prompt ? params.prompt.substring(0, 50).replace(/\n/g, ' ') : 'Unknown task');
-                    if (result?.success) {
-                        console.log(`${displayIndent}${colors.success(`${icons.check} ${subagentType}: Completed`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
-                        if (result.message) {
-                            console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+                // Normal mode: console output (SDK mode already output via adapter above)
+                if (!this.isSdkMode || !this.sdkOutputAdapter) {
+                    // Always show details for todo tools so users can see their task lists
+                    const isTodoTool = tool === 'todo_write' || tool === 'todo_read';
+                    // Special handling for edit tool with diff
+                    const isEditTool = tool === 'Edit';
+                    const hasDiff = isEditTool && result?.diff;
+                    // Special handling for Write tool with file preview
+                    const isWriteTool = tool === 'Write';
+                    const hasFilePreview = isWriteTool && result?.preview;
+                    // Special handling for DeleteFile tool
+                    const isDeleteTool = tool === 'DeleteFile';
+                    const hasDeleteInfo = isDeleteTool && result?.filePath;
+                    // Special handling for task tool (subagent)
+                    const isTaskTool = tool === 'task' && params?.subagent_type;
+                    // Check if tool is an MCP wrapper tool by looking up in tool registry
+                    const { getToolRegistry } = await import('./tools.js');
+                    const toolRegistry = getToolRegistry();
+                    const toolDef = toolRegistry.get(tool);
+                    const isMcpTool = toolDef && toolDef._isMcpTool === true;
+                    if (isTodoTool) {
+                        console.log('');
+                        console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
+                        console.log(this.renderTodoList(result?.todos || [], displayIndent));
+                        // Show summary if available
+                        if (result?.message) {
+                            console.log(`${displayIndent}${colors.textDim(result.message)}`);
                         }
                     }
-                    else if (result?.cancelled) {
-                        console.log(`${displayIndent}${colors.warning(`${icons.cross} ${subagentType}: Cancelled`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
+                    else if (hasDiff) {
+                        // Show edit result with diff
+                        console.log('');
+                        const diffOutput = renderDiff(result.diff);
+                        const indentedDiff = diffOutput
+                            .split('\n')
+                            .map((line) => `${displayIndent}  ${line}`)
+                            .join('\n');
+                        console.log(`${indentedDiff}`);
                     }
-                    else {
-                        console.log(`${displayIndent}${colors.error(`${icons.cross} ${subagentType}: Failed`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
-                        if (result?.message) {
-                            console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
-                        }
+                    else if (hasFilePreview) {
+                        // Show new file content in diff-like style
+                        console.log('');
+                        console.log(`${displayIndent}${colors.success(`${icons.file} ${result.filePath}`)}`);
+                        console.log(`${displayIndent}${colors.textDim(`  ${result.lineCount} lines`)}`);
+                        console.log('');
+                        console.log(renderLines(result.preview, { maxLines: 10, indent: displayIndent + '  ' }));
                     }
-                }
-                else if (isMcpTool) {
-                    // Special handling for MCP tools - show friendly summary
-                    console.log('');
-                    // Extract server name and tool name from tool name (format: serverName__toolName)
-                    let serverName = 'MCP';
-                    let toolDisplayName = tool;
-                    if (tool.includes('__')) {
-                        const parts = tool.split('__');
-                        serverName = parts[0];
-                        toolDisplayName = parts.slice(1).join('__');
+                    else if (hasDeleteInfo) {
+                        // Show DeleteFile result
+                        console.log('');
+                        console.log(`${displayIndent}${colors.success(`${icons.check} Deleted: ${result.filePath}`)}`);
                     }
-                    // Try to extract meaningful content from MCP result
-                    let summary = '';
-                    if (result?.content && Array.isArray(result.content) && result.content.length > 0) {
-                        const firstBlock = result.content[0];
-                        if (firstBlock?.type === 'text' && firstBlock?.text) {
-                            const text = firstBlock.text;
-                            if (typeof text === 'string') {
-                                // Detect HTML content
-                                if (text.trim().startsWith('<!DOCTYPE') || text.trim().startsWith('<html')) {
-                                    summary = '[HTML content fetched]';
-                                }
-                                else {
-                                    // Try to parse if it's JSON
-                                    try {
-                                        const parsed = JSON.parse(text);
-                                        if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.title) {
-                                            // Search results format
-                                            summary = `Found ${parsed.length} result(s)`;
-                                        }
-                                        else if (parsed?.message) {
-                                            summary = parsed.message;
+                    else if (isTaskTool) {
+                        // Special handling for task tool (subagent) - show friendly summary
+                        console.log('');
+                        const subagentType = params.subagent_type;
+                        const subagentName = params.description ||
+                            (params.prompt ? params.prompt.substring(0, 50).replace(/\n/g, ' ') : 'Unknown task');
+                        if (result?.success) {
+                            console.log(`${displayIndent}${colors.success(`${icons.check} ${subagentType}: Completed`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
+                            if (result.message) {
+                                console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+                            }
+                        }
+                        else if (result?.cancelled) {
+                            console.log(`${displayIndent}${colors.warning(`${icons.cross} ${subagentType}: Cancelled`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
+                        }
+                        else {
+                            console.log(`${displayIndent}${colors.error(`${icons.cross} ${subagentType}: Failed`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Task: ${subagentName}`)}`);
+                            if (result?.message) {
+                                console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+                            }
+                        }
+                    }
+                    else if (isMcpTool) {
+                        // Special handling for MCP tools - show friendly summary
+                        console.log('');
+                        // Extract server name and tool name from tool name (format: serverName__toolName)
+                        let serverName = 'MCP';
+                        let toolDisplayName = tool;
+                        if (tool.includes('__')) {
+                            const parts = tool.split('__');
+                            serverName = parts[0];
+                            toolDisplayName = parts.slice(1).join('__');
+                        }
+                        // Try to extract meaningful content from MCP result
+                        let summary = '';
+                        if (result?.content && Array.isArray(result.content) && result.content.length > 0) {
+                            const firstBlock = result.content[0];
+                            if (firstBlock?.type === 'text' && firstBlock?.text) {
+                                const text = firstBlock.text;
+                                if (typeof text === 'string') {
+                                    // Detect HTML content
+                                    if (text.trim().startsWith('<!DOCTYPE') || text.trim().startsWith('<html')) {
+                                        summary = '[HTML content fetched]';
+                                    }
+                                    else {
+                                        // Try to parse if it's JSON
+                                        try {
+                                            const parsed = JSON.parse(text);
+                                            if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.title) {
+                                                // Search results format
+                                                summary = `Found ${parsed.length} result(s)`;
+                                            }
+                                            else if (parsed?.message) {
+                                                summary = parsed.message;
+                                            }
+                                            else if (typeof parsed === 'string') {
+                                                summary = parsed.substring(0, 100);
+                                            }
                                         }
-                                        else if (typeof parsed === 'string') {
-                                            summary = parsed.substring(0, 100);
+                                        catch {
+                                            // Not JSON, use as-is with truncation
+                                            summary = text.substring(0, 100);
                                         }
                                     }
-                                    catch {
-                                        // Not JSON, use as-is with truncation
-                                        summary = text.substring(0, 100);
-                                    }
                                 }
                             }
                         }
-                    }
-                    else if (result?.message) {
-                        summary = result.message;
-                    }
-                    if (result?.success !== false) {
-                        console.log(`${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
-                        if (summary) {
-                            console.log(`${displayIndent}${colors.textDim(`  ${summary}`)}`);
+                        else if (result?.message) {
+                            summary = result.message;
                         }
-                    }
-                    else {
-                        console.log(`${displayIndent}${colors.error(`${icons.cross} ${serverName}: Failed`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
-                        if (result?.message || result?.error) {
-                            console.log(`${displayIndent}${colors.textDim(`  ${result?.message || result?.error}`)}`);
+                        if (result?.success !== false) {
+                            console.log(`${displayIndent}${colors.success(`${icons.check} ${serverName}: Success`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
+                            if (summary) {
+                                console.log(`${displayIndent}${colors.textDim(`  ${summary}`)}`);
+                            }
+                        }
+                        else {
+                            console.log(`${displayIndent}${colors.error(`${icons.cross} ${serverName}: Failed`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Tool: ${toolDisplayName}`)}`);
+                            if (result?.message || result?.error) {
+                                console.log(`${displayIndent}${colors.textDim(`  ${result?.message || result?.error}`)}`);
+                            }
                         }
                     }
-                }
-                else if (tool === 'InvokeSkill') {
-                    // Special handling for InvokeSkill - show friendly summary
-                    console.log('');
-                    const skillName = params?.skillId || 'Unknown skill';
-                    const taskDesc = params?.taskDescription || '';
-                    if (result?.success) {
-                        console.log(`${displayIndent}${colors.success(`${icons.check} Skill: Completed`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
-                        if (taskDesc) {
-                            const truncatedTask = taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
-                            console.log(`${displayIndent}${colors.textDim(`  Task: ${truncatedTask}`)}`);
+                    else if (tool === 'InvokeSkill') {
+                        // Special handling for InvokeSkill - show friendly summary
+                        console.log('');
+                        const skillName = params?.skillId || 'Unknown skill';
+                        const taskDesc = params?.taskDescription || '';
+                        if (result?.success) {
+                            console.log(`${displayIndent}${colors.success(`${icons.check} Skill: Completed`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
+                            if (taskDesc) {
+                                const truncatedTask = taskDesc.length > 60 ? taskDesc.substring(0, 60) + '...' : taskDesc;
+                                console.log(`${displayIndent}${colors.textDim(`  Task: ${truncatedTask}`)}`);
+                            }
                         }
+                        else {
+                            console.log(`${displayIndent}${colors.error(`${icons.cross} Skill: Failed`)}`);
+                            console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
+                            if (result?.message) {
+                                console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
+                            }
+                        }
+                    }
+                    else if (showToolDetails) {
+                        console.log('');
+                        console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
+                        console.log(`${displayIndent}${colors.textDim(JSON.stringify(result, null, 2))}`);
+                    }
+                    else if (result && result.success === false) {
+                        // GUI task or other tool failed
+                        console.log(`${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`);
+                    }
+                    else if (result) {
+                        // Show brief preview by default (consistent with subagent behavior)
+                        const resultPreview = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+                        const truncatedPreview = resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
+                        // Indent the preview
+                        const indentedPreview = truncatedPreview
+                            .split('\n')
+                            .map((line) => `${displayIndent}  ${line}`)
+                            .join('\n');
+                        console.log(`${indentedPreview}`);
                     }
                     else {
-                        console.log(`${displayIndent}${colors.error(`${icons.cross} Skill: Failed`)}`);
-                        console.log(`${displayIndent}${colors.textDim(`  Skill: ${skillName}`)}`);
-                        if (result?.message) {
-                            console.log(`${displayIndent}${colors.textDim(`  ${result.message}`)}`);
-                        }
+                        console.log(`${displayIndent}${colors.textDim('(no result)')}`);
                     }
                 }
-                else if (showToolDetails) {
-                    console.log('');
-                    console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
-                    console.log(`${displayIndent}${colors.textDim(JSON.stringify(result, null, 2))}`);
-                }
-                else if (result && result.success === false) {
-                    // GUI task or other tool failed
-                    console.log(`${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`);
-                }
-                else if (result) {
-                    // Show brief preview by default (consistent with subagent behavior)
-                    const resultPreview = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
-                    const truncatedPreview = resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
-                    // Indent the preview
-                    const indentedPreview = truncatedPreview.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
-                    console.log(`${indentedPreview}`);
-                }
-                else {
-                    console.log(`${displayIndent}${colors.textDim('(no result)')}`);
-                }
                 const toolCallRecord = {
                     tool,
                     params,
                     result,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 };
-                this.toolCalls.push(toolCallRecord);
+                this.tool_calls.push(toolCallRecord);
                 // Record tool output to session manager
                 await this.sessionManager.addOutput({
                     role: 'tool',
@@ -1212,77 +1996,104 @@ export class InteractiveSession {
                     toolName: tool,
                     toolParams: params,
                     toolResult: result,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
-                // 统一消息格式，包含工具名称和参数
+                // Unified message format with tool name and params
+                // Format: OpenAI-compatible tool result with plain text content
                 this.conversation.push({
                     role: 'tool',
-                    content: JSON.stringify({
-                        name: tool,
-                        parameters: params,
-                        result: result
-                    }),
+                    content: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
                     tool_call_id: toolCall.id,
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 });
             }
         }
         // Logic: Only skip returning results to main agent when user explicitly cancelled (ESC)
         // For all other cases (success, failure, errors), always return results for further processing
-        const guiSubagentCancelled = preparedToolCalls.some(tc => tc.name === 'task' && tc.params?.subagent_type === 'gui-subagent' && results.some(r => r.tool === 'task' && r.result?.cancelled === true));
+        const guiSubagentCancelled = preparedToolCalls.some((tc) => tc.name === 'task' &&
+            tc.params?.subagent_type === 'gui-subagent' &&
+            results.some((r) => r.tool === 'task' && r.result?.cancelled === true));
         // If GUI agent was cancelled by user, don't continue generating response
         // This avoids wasting API calls and tokens on cancelled tasks
         if (guiSubagentCancelled) {
-            console.log('');
-            console.log(`${indent}${colors.textMuted('GUI task cancelled by user')}`);
             this._isOperationInProgress = false;
             return;
         }
-        // Handle errors and completion based on whether onComplete callback is provided
-        if (hasError) {
-            this._isOperationInProgress = false;
-            // 不再抛出异常，而是将错误结果返回给 AI，让 AI 决定如何处理
-            // 这样可以避免工具错误导致程序退出
-        }
-        // Continue based on mode - 统一处理，无论是否有错误
+        // Continue based on mode - unified handling for both success and error cases
         if (onComplete) {
+            await this.checkAndCompressContext();
             // Remote mode: use provided callback
             await onComplete();
         }
         else {
+            await this.checkAndCompressContext();
             // Local mode: default behavior - continue with generateResponse
             await this.generateResponse();
         }
     }
+    /**
+     * Clean up incomplete tool calls from conversation after cancellation
+     * This removes assistant messages with tool_calls that don't have corresponding tool_results
+     */
+    async cleanupIncompleteToolCalls() {
+        // 从后往前找到包含 tool_calls 的 assistant 消息
+        for (let i = this.conversation.length - 1; i >= 0; i--) {
+            const msg = this.conversation[i];
+            if (msg.role === 'assistant' && msg.tool_calls?.length) {
+                // 收集所有 tool_call IDs
+                const allToolCallIds = new Set(msg.tool_calls.map((tc) => tc.id));
+                // 找出哪些 tool_call IDs 已经有对应的 tool_result
+                const completedToolCallIds = new Set();
+                for (let k = i + 1; k < this.conversation.length; k++) {
+                    const resultMsg = this.conversation[k];
+                    if (resultMsg.role === 'tool' && resultMsg.tool_call_id) {
+                        completedToolCallIds.add(resultMsg.tool_call_id);
+                    }
+                    else if (resultMsg.role === 'user' || resultMsg.role === 'assistant') {
+                        break; // 遇到下一个角色消息就停止
+                    }
+                }
+                // 找出未完成的 tool_call IDs
+                const incompleteToolCallIds = [...allToolCallIds].filter(id => !completedToolCallIds.has(id));
+                // 如果所有 tool_call 都已完成，不需要清理
+                if (incompleteToolCallIds.length === 0) {
+                    break;
+                }
+                // 只移除未完成的 tool_call，不移除已完成的 tool_result
+                msg.tool_calls = msg.tool_calls.filter((tc) => !incompleteToolCallIds.includes(tc.id));
+                break;
+            }
+        }
+    }
     /**
      * Get user-friendly description for tool
      */
     getToolDescription(toolName, params) {
         const descriptions = {
-            'Read': (p) => `Read file: ${this.truncatePath(p.filePath)}`,
-            'Write': (p) => `Write file: ${this.truncatePath(p.filePath)}`,
-            'Grep': (p) => `Search text: "${p.pattern}"`,
-            'Bash': (p) => `Execute command: ${this.truncateCommand(p.command)}`,
-            'ListDirectory': (p) => `List directory: ${this.truncatePath(p.path || '.')}`,
-            'SearchFiles': (p) => `Search files: ${p.pattern}`,
-            'DeleteFile': (p) => `Delete file: ${this.truncatePath(p.filePath)}`,
-            'CreateDirectory': (p) => `Create directory: ${this.truncatePath(p.dirPath)}`,
-            'Edit': (p) => `Edit text: ${this.truncatePath(p.file_path)}`,
-            'web_search': (p) => `Web search: "${p.query}"`,
-            'todo_write': () => `Update todo list`,
-            'todo_read': () => `Read todo list`,
-            'task': (p) => `Launch subtask: ${p.description}`,
-            'ReadBashOutput': (p) => `Read task output: ${p.task_id}`,
-            'web_fetch': () => `Fetch web content`,
-            'ask_user_question': () => `Ask user`,
-            'save_memory': () => `Save memory`,
-            'exit_plan_mode': () => `Complete plan`,
-            'xml_escape': (p) => `XML escape: ${this.truncatePath(p.file_path)}`,
-            'image_read': (p) => `Read image: ${this.truncatePath(p.image_input)}`,
+            Read: (p) => `Read file: ${this.truncatePath(p.filePath)}`,
+            Write: (p) => `Write file: ${this.truncatePath(p.filePath)}`,
+            Grep: (p) => `Search text: "${p.pattern}"`,
+            Bash: (p) => `Execute command: ${this.truncateCommand(p.command)}`,
+            ListDirectory: (p) => `List directory: ${this.truncatePath(p.path || '.')}`,
+            SearchFiles: (p) => `Search files: ${p.pattern}`,
+            DeleteFile: (p) => `Delete file: ${this.truncatePath(p.filePath)}`,
+            CreateDirectory: (p) => `Create directory: ${this.truncatePath(p.dirPath)}`,
+            Edit: (p) => `Edit text: ${this.truncatePath(p.file_path)}`,
+            web_search: (p) => `Web search: "${p.query}"`,
+            todo_write: () => `Update todo list`,
+            todo_read: () => `Read todo list`,
+            task: (p) => `Launch subtask: ${p.description}`,
+            ReadBashOutput: (p) => `Read task output: ${p.task_id}`,
+            web_fetch: () => `Fetch web content`,
+            ask_user_question: () => `Ask user`,
+            save_memory: () => `Save memory`,
+            exit_plan_mode: () => `Complete plan`,
+            xml_escape: (p) => `XML escape: ${this.truncatePath(p.file_path)}`,
+            image_read: (p) => `Read image: ${this.truncatePath(p.image_input)}`,
             // 'Skill': (p) => `Execute skill: ${p.skill}`,
             // 'ListSkills': () => `List available skills`,
             // 'GetSkillDetails': (p) => `Get skill details: ${p.skill}`,
-            'InvokeSkill': (p) => `Invoke skill: ${p.skillId} - ${this.truncatePath(p.taskDescription || '', 40)}`
+            InvokeSkill: (p) => `Invoke skill: ${p.skillId} - ${this.truncatePath(p.taskDescription || '', 40)}`,
         };
         const getDescription = descriptions[toolName];
         return getDescription ? getDescription(params) : `Execute tool: ${toolName}`;
@@ -1315,10 +2126,10 @@ export class InteractiveSession {
             return `${indent}${colors.textMuted('No tasks')}`;
         }
         const statusConfig = {
-            'pending': { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
-            'in_progress': { icon: icons.loading, color: colors.warning, label: 'In Progress' },
-            'completed': { icon: icons.success, color: colors.success, label: 'Completed' },
-            'failed': { icon: icons.error, color: colors.error, label: 'Failed' }
+            pending: { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
+            in_progress: { icon: icons.loading, color: colors.warning, label: 'In Progress' },
+            completed: { icon: icons.success, color: colors.success, label: 'Completed' },
+            failed: { icon: icons.error, color: colors.error, label: 'Failed' },
         };
         const lines = [];
         for (const todo of todos) {
@@ -1431,7 +2242,155 @@ export class InteractiveSession {
         return this.currentTaskId;
     }
 }
+/**
+ * Clean up stale temporary workspaces from previous sessions.
+ * Called at startup to ensure no leftover temp files accumulate.
+ */
+async function cleanupStaleWorkspaces() {
+    try {
+        const configManager = getConfigManager();
+        const workspacePath = configManager.getWorkspacePath();
+        // Use default workspace path if workspacePath is empty or undefined
+        const effectiveWorkspacePath = (workspacePath && workspacePath.trim())
+            ? workspacePath
+            : os.homedir();
+        const baseWorkspaceDir = path.join(effectiveWorkspacePath, '.xagent', 'workspace');
+        // First, verify the workspace directory exists before attempting cleanup
+        try {
+            const stats = await fsPromises.stat(baseWorkspaceDir);
+            if (!stats.isDirectory()) {
+                return; // Not a directory, skip cleanup
+            }
+        }
+        catch {
+            // Directory doesn't exist - nothing to clean
+            return;
+        }
+        try {
+            const entries = await fsPromises.readdir(baseWorkspaceDir, { withFileTypes: true });
+            let cleanedCount = 0;
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const fullPath = path.join(baseWorkspaceDir, entry.name);
+                    try {
+                        await fsPromises.rm(fullPath, { recursive: true, force: true });
+                        cleanedCount++;
+                    }
+                    catch {
+                        // Skip directories that can't be removed (in use or permission issues)
+                    }
+                }
+            }
+            if (cleanedCount > 0) {
+                console.log(colors.textDim(`🧹 Cleaned up ${cleanedCount} stale workspace(s)`));
+            }
+        }
+        catch {
+            // Can't read directory - skip cleanup
+        }
+    }
+    catch {
+        // Config not available - skip cleanup
+    }
+}
+/**
+ * Initialize built-in skills on first run.
+ * Checks if user skills directory is empty or doesn't exist,
+ * then copies all built-in skills including the protected find-skills.
+ * @returns Number of skills initialized, or 0 if no initialization was needed.
+ */
+async function initializeSkillsOnDemand() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    // Get user skills directory (respects OS-specific paths)
+    const configManager = getConfigManager();
+    const userSkillsPath = configManager.getUserSkillsPath() || path.join(os.homedir(), '.xagent', 'skills');
+    // Check if user skills directory exists and has skills
+    let hasSkills = false;
+    try {
+        const entries = await fsPromises.readdir(userSkillsPath, { withFileTypes: true });
+        hasSkills = entries.some(e => e.isDirectory());
+    }
+    catch {
+        hasSkills = false;
+    }
+    // If skills already exist, skip initialization
+    if (hasSkills) {
+        return 0;
+    }
+    // Ensure user skills directory exists
+    await fsPromises.mkdir(userSkillsPath, { recursive: true });
+    // Define skill source directories
+    const builtinSkillsDir = path.join(__dirname, '..', 'skills', 'skills');
+    const findSkillsDir = path.join(__dirname, '..', 'find-skills');
+    const skillsToInstall = [];
+    // Add find-skills from root directory
+    if (fs.existsSync(findSkillsDir) && fs.existsSync(path.join(findSkillsDir, 'SKILL.md'))) {
+        skillsToInstall.push({ source: findSkillsDir, name: 'find-skills' });
+    }
+    // Add skills from skills/skills directory
+    if (fs.existsSync(builtinSkillsDir)) {
+        const entries = fs.readdirSync(builtinSkillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(builtinSkillsDir, entry.name);
+                if (fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+                    skillsToInstall.push({ source: skillPath, name: entry.name });
+                }
+            }
+        }
+    }
+    if (skillsToInstall.length === 0) {
+        return 0;
+    }
+    // Create user skills directory (already done above, but ensure it exists)
+    await fsPromises.mkdir(userSkillsPath, { recursive: true });
+    // Copy all skills
+    for (const { source, name } of skillsToInstall) {
+        const destPath = path.join(userSkillsPath, name);
+        if (!fs.existsSync(destPath)) {
+            await copyDirectoryRecursiveAsync(source, destPath);
+        }
+    }
+    return skillsToInstall.length;
+}
+// Synchronous version (kept for backwards compatibility)
+function _copyDirectoryRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            _copyDirectoryRecursive(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+// Asynchronous version for concurrent-safe initialization
+async function copyDirectoryRecursiveAsync(src, dest) {
+    await fsPromises.mkdir(dest, { recursive: true });
+    const entries = await fsPromises.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectoryRecursiveAsync(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            await fsPromises.copyFile(srcPath, destPath);
+        }
+    }
+}
 export async function startInteractiveSession() {
+    // Clean up any leftover temp workspaces from previous sessions
+    await cleanupStaleWorkspaces();
+    // Initialize built-in skills on first run (silent, returns count)
+    const initializedCount = await initializeSkillsOnDemand();
     const session = new InteractiveSession();
     // Flag to control shutdown
     session._isShuttingDown = false;
@@ -1467,6 +2426,15 @@ export async function startInteractiveSession() {
         // Force exit
         process.exit(0);
     });
+    await session.start(initializedCount);
+    // Check for updates on startup
+    try {
+        const { checkUpdatesOnStartup } = await import('./update.js');
+        await checkUpdatesOnStartup();
+    }
+    catch {
+        // Silently ignore update check failures
+    }
     await session.start();
 }
 // Singleton session instance for access from other modules