@xagent-ai/cli 1.2.2 → 1.3.0

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;
@@ -53,7 +61,7 @@ export class InteractiveSession {
     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 +74,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 +84,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,6 +100,32 @@ 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;
     }
@@ -95,25 +133,68 @@ export class InteractiveSession {
      * 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;
+        // 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();
+                        console.log(colors.textMuted('  🔄 Skills updated from CLI'));
+                    }
+                }
+            }
+            catch (error) {
+                // 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
@@ -122,25 +203,43 @@ export class InteractiveSession {
         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(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();
+        // 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 +258,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 +285,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 +296,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 +322,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 +337,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();
@@ -292,7 +409,7 @@ export class InteractiveSession {
                 this.checkpointManager = getCheckpointManager(process.cwd(), checkpointingConfig.enabled, checkpointingConfig.maxCheckpoints);
                 await this.checkpointManager.initialize();
             }
-            this.currentAgent = this.agentManager.getAgent('general-purpose');
+            this.currentAgent = this.agentManager.getAgent('general-purpose') ?? null;
             console.log(colors.success('✔ Initialization complete'));
         }
         catch (error) {
@@ -315,11 +432,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 +458,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;
@@ -363,11 +480,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,16 +497,29 @@ 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(colors.info(`You can configure it later using the /model command if needed.`));
             console.log('');
         }
-        // Save LLM config only, skip VLM for now
-        await this.configManager.setAuthConfig(authConfig);
+        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');
+        }
     }
     showWelcomeMessage() {
         const language = this.configManager.getLanguage();
@@ -410,28 +543,28 @@ export class InteractiveSession {
             [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;
@@ -439,6 +572,26 @@ export class InteractiveSession {
         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 (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() {
         // Check if we're shutting down
@@ -449,15 +602,12 @@ export class InteractiveSession {
         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) => {
@@ -481,7 +631,8 @@ export class InteractiveSession {
         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);
             }
@@ -513,9 +664,9 @@ export class InteractiveSession {
     }
     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');
+        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 +689,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 +703,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);
         }
     }
@@ -615,52 +760,68 @@ 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();
-            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('');
-                    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);
-                    console.log(`${indent}${colors.border(separator)}`);
-                    const renderedSummary = renderMarkdown(summaryContent, (process.stdout.columns || 80) - indent.length * 4);
-                    console.log(`${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`);
-                    if (isTruncated) {
-                        console.log(`${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`);
-                    }
-                    console.log(`${indent}${colors.border(separator)}`);
+        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;
+        console.log('');
+        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);
+            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,
+                    };
                 }
-                // Restore user messages after compression, ensuring user message exists for API calls
-                if (lastUserMessage) {
-                    this.conversation.push(lastUserMessage);
+            }
+            if (summaryMessage && summaryMessage.content) {
+                const maxPreviewLength = 800;
+                let summaryContent = summaryMessage.content;
+                const isTruncated = summaryContent.length > maxPreviewLength;
+                if (isTruncated) {
+                    summaryContent = summaryContent.substring(0, maxPreviewLength) + '\n...';
                 }
-                // Sync compressed conversation history to slashCommandHandler
-                this.slashCommandHandler.setConversationHistory(this.conversation);
+                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);
+                console.log(`${indent}${colors.border(separator)}`);
+                const renderedSummary = renderMarkdown(summaryContent, (process.stdout.columns || 80) - indent.length * 4);
+                console.log(`${indent}${theme.predefinedStyles.dim(renderedSummary).replace(/^/gm, indent)}`);
+                if (isTruncated) {
+                    console.log(`${indent}${colors.textMuted(`(... ${summaryMessage.content.length - maxPreviewLength} more chars hidden)`)}`);
+                }
+                console.log(`${indent}${colors.border(separator)}`);
             }
+            // Sync compressed conversation history to slashCommandHandler
+            this.slashCommandHandler.setConversationHistory(this.conversation);
         }
     }
     async executeShellCommand(command) {
@@ -683,15 +844,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 +860,7 @@ export class InteractiveSession {
                 toolName: 'Bash',
                 toolParams: { command },
                 toolResult: result,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
         }
         catch (error) {
@@ -727,8 +888,19 @@ export class InteractiveSession {
     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,32 +910,22 @@ 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;
         }
@@ -790,29 +952,29 @@ 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);
             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 content = typeof assistantMessage.content === 'string' ? assistantMessage.content : '';
             const reasoningContent = assistantMessage.reasoning_content || '';
             // Display reasoning content if available and thinking mode is enabled
             if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
@@ -829,22 +991,25 @@ export class InteractiveSession {
                 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]);
             }
             // Operation completed successfully, clear the flag
             this._isOperationInProgress = false;
@@ -855,16 +1020,18 @@ export class InteractiveSession {
             // Clear the operation flag
             this._isOperationInProgress = false;
             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 +1048,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 +1059,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 +1085,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
+                // 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;
@@ -991,32 +1163,50 @@ export class InteractiveSession {
             }
         }
         // 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
+        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 (const { tool, result, error } of results) {
-            const toolCall = preparedToolCalls.find(tc => tc.name === tool);
-            if (!toolCall)
-                continue;
-            const { params } = toolCall;
+        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 理解和修正
+                // 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 {
@@ -1054,7 +1244,10 @@ export class InteractiveSession {
                     // Show edit result with diff
                     console.log('');
                     const diffOutput = renderDiff(result.diff);
-                    const indentedDiff = diffOutput.split('\n').map(line => `${displayIndent}  ${line}`).join('\n');
+                    const indentedDiff = diffOutput
+                        .split('\n')
+                        .map((line) => `${displayIndent}  ${line}`)
+                        .join('\n');
                     console.log(`${indentedDiff}`);
                 }
                 else if (hasFilePreview) {
@@ -1074,7 +1267,8 @@ export class InteractiveSession {
                     // 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');
+                    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}`)}`);
@@ -1192,7 +1386,10 @@ export class InteractiveSession {
                     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');
+                    const indentedPreview = truncatedPreview
+                        .split('\n')
+                        .map((line) => `${displayIndent}  ${line}`)
+                        .join('\n');
                     console.log(`${indentedPreview}`);
                 }
                 else {
@@ -1202,9 +1399,9 @@ export class InteractiveSession {
                     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 +1409,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 +1539,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 +1655,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 +1839,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 (error) {
+        // Silently ignore update check failures
+    }
     await session.start();
 }
 // Singleton session instance for access from other modules