@xagent-ai/cli 1.2.2 → 1.3.1

package/dist/slash-commands.js

@@ -1,9 +1,10 @@
-import inquirer from 'inquirer';
+import { select, confirm, text } from '@clack/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 import fs from 'fs/promises';
 import path from 'path';
 import { ExecutionMode, AuthType } from './types.js';
+import { fetchDefaultModels } from './ai-client/providers/remote.js';
 import { getToolRegistry } from './tools.js';
 import { getAgentManager } from './agents.js';
 import { getMemoryManager } from './memory.js';
@@ -11,10 +12,11 @@ import { getMCPManager } from './mcp.js';
 import { getCheckpointManager } from './checkpoint.js';
 import { getConfigManager } from './config.js';
 import { getLogger } from './logger.js';
-import { getContextCompressor } from './context-compressor.js';
+import { getContextCompressor, } from './context-compressor.js';
 import { getConversationManager } from './conversation.js';
 import { icons, colors } from './theme.js';
-import { AuthService } from './auth.js';
+import { ensureTtySane } from './terminal.js';
+import { AuthService, selectAuthType, THIRD_PARTY_PROVIDERS, VLM_PROVIDERS } from './auth.js';
 const logger = getLogger();
 export class SlashCommandHandler {
     configManager;
@@ -27,6 +29,8 @@ export class SlashCommandHandler {
     conversationHistory = [];
     onClearCallback = null;
     onSystemPromptUpdate = null;
+    onConfigUpdate = null;
+    remoteAIClient = null; // Reference to InteractiveSession's remoteAIClient
     constructor() {
         this.configManager = getConfigManager(process.cwd());
         this.agentManager = getAgentManager(process.cwd());
@@ -36,6 +40,12 @@ export class SlashCommandHandler {
         this.contextCompressor = getContextCompressor();
         this.conversationManager = getConversationManager();
     }
+    /**
+     * Set remote AI client reference (called from InteractiveSession)
+     */
+    setRemoteAIClient(client) {
+        this.remoteAIClient = client;
+    }
     /**
      * Set callback for clearing conversation
      */
@@ -48,6 +58,12 @@ export class SlashCommandHandler {
     setSystemPromptUpdateCallback(callback) {
         this.onSystemPromptUpdate = callback;
     }
+    /**
+     * Set callback for config update (called after /auth changes config)
+     */
+    setConfigUpdateCallback(callback) {
+        this.onConfigUpdate = callback;
+    }
     /**
      * Set current conversation history (includes all user/assistant/tool messages)
      */
@@ -91,8 +107,11 @@ export class SlashCommandHandler {
             case 'mcp':
                 await this.handleMcp(args);
                 break;
-            case 'vlm':
-                await this.handleVlm();
+            case 'skill':
+                await this.handleSkill(args);
+                break;
+            case 'model':
+                await this.handleModel();
                 break;
             case 'memory':
                 await this.handleMemory(args);
@@ -118,9 +137,14 @@ export class SlashCommandHandler {
             case 'compress':
                 await this.handleCompress(args);
                 break;
+            case 'update':
+                await this.handleUpdate();
+                break;
             default:
                 logger.warn(`Unknown command: /${command}`, 'Type /help for available commands');
         }
+        // Ensure stdin is in raw mode for proper input handling after @clack/prompts usage
+        ensureTtySane();
         return true;
     }
     async showHelp() {
@@ -128,7 +152,10 @@ export class SlashCommandHandler {
         console.log('');
         console.log(colors.primaryBright('╔════════════════════════════════════════════════════════════╗'));
         console.log(colors.primaryBright('║') + ' '.repeat(56) + colors.primaryBright('║'));
-        console.log(' '.repeat(14) + colors.gradient('📚 XAGENT CLI Help') + ' '.repeat(31) + colors.primaryBright('║'));
+        console.log(' '.repeat(14) +
+            colors.gradient('📚 XAGENT CLI Help') +
+            ' '.repeat(31) +
+            colors.primaryBright('║'));
         console.log(colors.primaryBright('║') + ' '.repeat(56) + colors.primaryBright('║'));
         console.log(colors.primaryBright('╚════════════════════════════════════════════════════════════╝'));
         console.log('');
@@ -146,20 +173,20 @@ export class SlashCommandHandler {
                 cmd: '/help [command]',
                 desc: 'Show help information',
                 detail: 'View all available commands or detailed description of specific command',
-                example: '/help\n/help mode'
+                example: '/help\n/help mode',
             },
             {
                 cmd: '/clear',
                 desc: 'Clear conversation history',
                 detail: 'Clear all conversation records of current session, start new conversation',
-                example: '/clear'
+                example: '/clear',
             },
             {
                 cmd: '/exit',
                 desc: 'Exit program',
                 detail: 'Safely exit XAGENT CLI',
-                example: '/exit'
-            }
+                example: '/exit',
+            },
         ]);
         // Project Management
         this.showHelpCategory('Project Management', [
@@ -167,14 +194,14 @@ export class SlashCommandHandler {
                 cmd: '/init',
                 desc: 'Initialize project context',
                 detail: 'Create XAGENT.md file in current directory, used to store project context information',
-                example: '/init'
+                example: '/init',
             },
             {
                 cmd: '/memory [show|clear]',
                 desc: 'Manage project memory',
                 detail: 'View or clear memory (global, current, all, or filename)',
-                example: '/memory show\n/memory clear\n/memory clear global\n/memory clear all'
-            }
+                example: '/memory show\n/memory clear\n/memory clear global\n/memory clear all',
+            },
         ]);
         // Authentication & Configuration
         this.showHelpCategory('Authentication & Configuration', [
@@ -182,7 +209,7 @@ export class SlashCommandHandler {
                 cmd: '/auth',
                 desc: 'Configure authentication information',
                 detail: 'Change or view current authentication configuration',
-                example: '/auth'
+                example: '/auth',
             },
             {
                 cmd: '/mode [mode]',
@@ -194,14 +221,14 @@ export class SlashCommandHandler {
                     'accept_edits - Automatically accept edit operations',
                     'plan - Plan before executing',
                     'default - Safe execution, requires confirmation',
-                    'smart - Smart approval (recommended)'
-                ]
+                    'smart - Smart approval (recommended)',
+                ],
             },
             {
                 cmd: '/think [on|off|display]',
                 desc: 'Control thinking mode',
                 detail: 'Enable/disable AI thinking process display',
-                example: '/think on\n/think off\n/think display compact'
+                example: '/think on\n/think off\n/think display compact',
             },
             // {
             //   cmd: '/language [zh|en]',
@@ -213,8 +240,8 @@ export class SlashCommandHandler {
                 cmd: '/theme',
                 desc: 'Switch theme',
                 detail: 'Change UI theme style',
-                example: '/theme'
-            }
+                example: '/theme',
+            },
         ]);
         // Feature Extensions
         this.showHelpCategory('Feature Extensions', [
@@ -222,13 +249,19 @@ export class SlashCommandHandler {
                 cmd: '/agents [list|online|install|remove]',
                 desc: 'Manage sub-agents',
                 detail: 'View, install or remove specialized AI sub-agents',
-                example: '/agents list\n/agents online\n/agents install explore-agent'
+                example: '/agents list\n/agents online\n/agents install explore-agent',
             },
             {
                 cmd: '/mcp [list|add|remove|refresh]',
                 desc: 'Manage MCP servers',
                 detail: 'Manage Model Context Protocol servers',
-                example: '/mcp list\n/mcp add server-name'
+                example: '/mcp list\n/mcp add server-name',
+            },
+            {
+                cmd: '/skill [list|add|remove]',
+                desc: 'Manage skills',
+                detail: 'Install, list, or remove skills from ~/.xagent/skills',
+                example: '/skill list\n/skill add ./my-skill\n/skill add owner/repo\n/skill remove my-skill'
             },
             {
                 cmd: '/vlm',
@@ -236,12 +269,18 @@ export class SlashCommandHandler {
                 detail: 'Configure Vision-Language Model for browser/desktop automation',
                 example: '/vlm'
             },
+            {
+                cmd: '/model',
+                desc: 'Configure LLM/VLM models',
+                detail: 'Configure or switch LLM and VLM models for remote mode',
+                example: '/model',
+            },
             {
                 cmd: '/tools [verbose|simple]',
                 desc: 'Manage tool display',
                 detail: 'View available tools or switch tool call display mode',
-                example: '/tools\n/tools verbose\n/tools simple'
-            }
+                example: '/tools\n/tools verbose\n/tools simple',
+            },
         ]);
         // Advanced Features
         this.showHelpCategory('Advanced Features', [
@@ -249,26 +288,32 @@ export class SlashCommandHandler {
                 cmd: '/restore',
                 desc: 'Restore from checkpoint',
                 detail: 'Restore conversation state from historical checkpoints',
-                example: '/restore'
+                example: '/restore',
             },
             {
                 cmd: '/compress [on|off|max_message|max_token|exec]',
                 desc: 'Manage context compression',
                 detail: 'Configure compression settings or execute compression manually',
-                example: '/compress\n/compress exec\n/compress on\n/compress max_message 50\n/compress max_token 1500000'
+                example: '/compress\n/compress exec\n/compress on\n/compress max_message 50\n/compress max_token 1500000',
             },
             {
                 cmd: '/stats',
                 desc: 'Show session statistics',
                 detail: 'View statistics information of current session',
-                example: '/stats'
+                example: '/stats',
             },
             {
                 cmd: '/about',
                 desc: 'Show version information',
                 detail: 'View version and related information of XAGENT CLI',
-                example: '/about'
-            }
+                example: '/about',
+            },
+            {
+                cmd: '/update',
+                desc: 'Check for updates',
+                detail: 'Check for new versions and update xAgent CLI',
+                example: '/update',
+            },
         ]);
         // Keyboard Shortcuts
         console.log('');
@@ -287,18 +332,18 @@ export class SlashCommandHandler {
         console.log(colors.primaryBright(title));
         console.log(colors.border(separator));
         console.log('');
-        commands.forEach(cmd => {
+        commands.forEach((cmd) => {
             console.log(colors.primaryBright(`  ${cmd.cmd}`));
             console.log(colors.textDim(`    ${cmd.desc}`));
             console.log(colors.textMuted(`    ${cmd.detail}`));
             if (cmd.modes) {
                 console.log(colors.textDim(`    Available modes:`));
-                cmd.modes.forEach(mode => {
+                cmd.modes.forEach((mode) => {
                     console.log(colors.textDim(`      • ${mode}`));
                 });
             }
             console.log(colors.accent(`    Examples:`));
-            cmd.example.split('\n').forEach(ex => {
+            cmd.example.split('\n').forEach((ex) => {
                 console.log(colors.codeText(`      ${ex}`));
             });
             console.log('');
@@ -317,9 +362,9 @@ export class SlashCommandHandler {
     async handleClear() {
         // Clear local conversation history
         this.conversationHistory = [];
-        // Clear ConversationManager 中的当前对话
+        // Clear current conversation in ConversationManager
         await this.conversationManager.clearCurrentConversation();
-        // Call callback to notify InteractiveSession 清空对话
+        // Call callback to notify InteractiveSession to clear conversation
         if (this.onClearCallback) {
             this.onClearCallback();
         }
@@ -331,37 +376,131 @@ export class SlashCommandHandler {
     }
     async handleAuth() {
         logger.section('Authentication Management');
-        const { action } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'action',
-                message: 'Select action:',
-                choices: [
-                    { name: 'Change authentication method', value: 'change' },
-                    { name: 'Show current auth config', value: 'show' },
-                    { name: 'Back', value: 'back' }
-                ]
-            }
-        ]);
+        // Show current authentication configuration
+        const authConfig = this.configManager.getAuthConfig();
+        const isRemote = authConfig.type === AuthType.OAUTH_XAGENT;
+        const currentType = isRemote ? 'xAgent (Remote)' : 'Third-party API (Local)';
+        console.log(chalk.cyan('\n📋 Current Authentication Configuration:\n'));
+        console.log(`  ${chalk.yellow('Mode:')} ${currentType}`);
+        if (isRemote) {
+            // Remote mode: show remote_llmModelName and remote_vlmModelName
+            const llmModel = authConfig.remote_llmModelName || 'Not set';
+            const vlmModel = authConfig.remote_vlmModelName || 'Not set';
+            console.log(`  ${chalk.yellow('LLM Model:')} ${llmModel}`);
+            console.log(`  ${chalk.yellow('VLM Model:')} ${vlmModel}`);
+        }
+        else {
+            // Local mode: show modelName (LLM) and guiSubagentModel (VLM)
+            const llmModel = authConfig.modelName || 'Not set';
+            const vlmModel = this.configManager.get('guiSubagentModel') || 'Not set';
+            console.log(`  ${chalk.yellow('LLM Model:')} ${llmModel}`);
+            console.log(`  ${chalk.yellow('VLM Model:')} ${vlmModel}`);
+        }
+        console.log('');
+        const action = await select({
+            message: 'Select action:',
+            options: [
+                { value: 'switch', label: 'Switch authentication method' },
+                { value: 'back', label: 'Back' },
+            ],
+        });
         if (action === 'back') {
             return;
         }
-        if (action === 'show') {
-            const authConfig = this.configManager.getAuthConfig();
-            logger.subsection('Current Authentication Configuration');
-            console.log(JSON.stringify(authConfig, null, 2));
-        }
-        else if (action === 'change') {
-            const { selectAuthType } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'selectAuthType',
-                    message: 'Do you want to change authentication type?',
-                    default: false
+        if (action === 'switch') {
+            // Use the same selection UI as initial setup
+            const confirmSwitch = await confirm({
+                message: `Switch from "${currentType}" to another authentication method?`,
+            });
+            if (confirmSwitch === false || confirmSwitch === undefined) {
+                return;
+            }
+            // Select authentication type (same as initial setup)
+            const authType = await selectAuthType();
+            if (authType === AuthType.OAUTH_XAGENT) {
+                // Switch to xAgent (Remote mode)
+                const authService = new AuthService({
+                    type: AuthType.OAUTH_XAGENT,
+                    apiKey: '',
+                    baseUrl: '',
+                    xagentApiBaseUrl: authConfig.xagentApiBaseUrl,
+                });
+                const success = await authService.authenticate();
+                if (success) {
+                    const newAuthConfig = authService.getAuthConfig();
+                    this.configManager.setAuthConfig({
+                        selectedAuthType: newAuthConfig.type,
+                        apiKey: newAuthConfig.apiKey,
+                        refreshToken: newAuthConfig.refreshToken,
+                        baseUrl: newAuthConfig.baseUrl,
+                        modelName: '',
+                        xagentApiBaseUrl: newAuthConfig.xagentApiBaseUrl,
+                        guiSubagentModel: '',
+                        guiSubagentBaseUrl: 'https://www.xagent-colife.net/v3',
+                        guiSubagentApiKey: '',
+                    });
+                    // Set default remote model settings if not already set
+                    // Fetch default models from /models/default endpoint
+                    const webBaseUrl = newAuthConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
+                    let defaultLlmName = '';
+                    let defaultVlmName = '';
+                    try {
+                        console.log(chalk.cyan('\n📊 Fetching default models from remote server...'));
+                        const defaults = await fetchDefaultModels(newAuthConfig.apiKey || '', webBaseUrl);
+                        if (defaults.llm?.name) {
+                            defaultLlmName = defaults.llm.name;
+                            console.log(chalk.cyan(`   LLM Model: ${defaults.llm.name}`));
+                        }
+                        if (defaults.vlm?.name) {
+                            defaultVlmName = defaults.vlm.name;
+                            console.log(chalk.cyan(`   VLM Model: ${defaults.vlm.name}`));
+                        }
+                    }
+                    catch (error) {
+                        console.log(chalk.yellow(`   ⚠️  Failed to fetch default models: ${error.message}`));
+                        console.log(chalk.yellow('   ⚠️  Use /model command to select models manually.'));
+                    }
+                    console.log('');
+                    this.configManager.set('remote_llmModelName', defaultLlmName);
+                    this.configManager.set('remote_vlmModelName', defaultVlmName);
+                    this.configManager.save('global');
+                    // Notify InteractiveSession to update aiClient config
+                    if (this.onConfigUpdate) {
+                        this.onConfigUpdate();
+                    }
+                    console.log(chalk.green('\n✅ Authentication switched to xAgent (Remote mode)!'));
+                    // Removed: logging partial token for security
+                }
+            }
+            else {
+                // Switch to Third-party API (Local mode)
+                const authService = new AuthService({
+                    type: AuthType.OPENAI_COMPATIBLE,
+                    apiKey: '',
+                    baseUrl: '',
+                    modelName: '',
+                });
+                const success = await authService.authenticate();
+                if (success) {
+                    const newAuthConfig = authService.getAuthConfig();
+                    this.configManager.setAuthConfig({
+                        selectedAuthType: newAuthConfig.type,
+                        apiKey: newAuthConfig.apiKey,
+                        baseUrl: newAuthConfig.baseUrl,
+                        modelName: newAuthConfig.modelName,
+                        xagentApiBaseUrl: '',
+                        refreshToken: '',
+                        guiSubagentModel: '',
+                        guiSubagentBaseUrl: '',
+                        guiSubagentApiKey: '',
+                    });
+                    this.configManager.save('global');
+                    // Notify InteractiveSession to update aiClient config
+                    if (this.onConfigUpdate) {
+                        this.onConfigUpdate();
+                    }
+                    console.log(chalk.green('\n✅ Authentication switched to Third-party API (Local mode)!'));
                 }
-            ]);
-            if (selectAuthType) {
-                logger.warn('Please restart xAgent CLI and run /auth again', 'Authentication changes require restart');
             }
         }
     }
@@ -371,39 +510,36 @@ export class SlashCommandHandler {
         const currentAuthType = authConfig.type;
         if (currentAuthType !== AuthType.OAUTH_XAGENT) {
             console.log(chalk.yellow('\n⚠️  Current authentication type is not OAuth xAgent.'));
-            const { proceed } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'proceed',
-                    message: 'Do you want to switch to OAuth xAgent authentication?',
-                    default: false
-                }
-            ]);
-            if (!proceed) {
+            const proceed = await confirm({
+                message: 'Do you want to switch to OAuth xAgent authentication?',
+            });
+            if (proceed === false || proceed === undefined) {
                 return;
             }
             // Switch to OAuth xAgent
-            await this.configManager.setAuthConfig({
+            this.configManager.setAuthConfig({
                 selectedAuthType: AuthType.OAUTH_XAGENT,
                 apiKey: '',
                 refreshToken: '',
-                baseUrl: ''
+                baseUrl: '',
             });
-            await this.configManager.save('global');
+            this.configManager.save('global');
             console.log(chalk.green('✅ Switched to OAuth xAgent authentication.'));
         }
         console.log(chalk.cyan('\n🔐 Starting OAuth xAgent login...'));
         console.log(chalk.gray('   A browser will open for you to complete authentication.\n'));
         try {
+            // Get xagentApiBaseUrl from config (respects XAGENT_BASE_URL env var)
+            const config = this.configManager.getAuthConfig();
             const authService = new AuthService({
                 type: AuthType.OAUTH_XAGENT,
                 apiKey: '',
                 baseUrl: '',
-                refreshToken: ''
+                refreshToken: '',
+                xagentApiBaseUrl: config.xagentApiBaseUrl,
             });
             const success = await authService.authenticate();
             if (success) {
-                const newConfig = this.configManager.getAuthConfig();
                 console.log(chalk.green('\n✅ Login successful!'));
                 console.log(chalk.cyan(`   Token saved to: ~/.xagent/settings.json`));
                 console.log(chalk.gray('   You can now use xAgent CLI with remote AI services.\n'));
@@ -416,75 +552,320 @@ export class SlashCommandHandler {
             console.log(chalk.red(`\n❌ Login error: ${error.message || 'Unknown error'}`));
         }
     }
-    async handleVlm() {
-        logger.section('VLM Configuration for GUI Agent');
-        // Show current VLM config
-        const currentVlmConfig = {
-            model: this.configManager.get('guiSubagentModel'),
-            baseUrl: this.configManager.get('guiSubagentBaseUrl'),
-            apiKey: this.configManager.get('guiSubagentApiKey') ? '***' : ''
-        };
-        console.log(chalk.cyan('\n📊 Current VLM Configuration:\n'));
-        console.log(`  Model: ${chalk.yellow(currentVlmConfig.model || 'Not configured')}`);
-        console.log(`  Base URL: ${chalk.yellow(currentVlmConfig.baseUrl || 'Not configured')}`);
-        console.log(`  API Key: ${chalk.yellow(currentVlmConfig.apiKey || 'Not configured')}`);
-        console.log();
-        const { action } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'action',
-                message: 'Select action:',
-                choices: [
-                    { name: 'Configure VLM', value: 'configure' },
-                    { name: 'Remove VLM configuration', value: 'remove' },
-                    { name: 'Back', value: 'back' }
-                ]
-            }
-        ]);
-        if (action === 'back') {
-            return;
+    /**
+     * Handle /model command - Configure LLM/VLM models
+     * Supports both remote mode (xAgent) and local mode (third-party API)
+     */
+    async handleModel() {
+        const authConfig = this.configManager.getAuthConfig();
+        // Determine mode and show appropriate UI
+        if (authConfig.type === AuthType.OAUTH_XAGENT) {
+            // Remote mode - use backend models
+            await this.handleRemoteModel();
         }
-        if (action === 'remove') {
-            const { confirm } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: 'Are you sure you want to remove VLM configuration?',
-                    default: false
+        else {
+            // Local mode - configure third-party API directly
+            await this.handleLocalModel();
+        }
+    }
+    /**
+     * Handle /model command for remote mode - Configure models from backend
+     */
+    async handleRemoteModel() {
+        const authConfig = this.configManager.getAuthConfig();
+        // Auto-fetch default models if not set
+        let currentLlm = authConfig.remote_llmModelName;
+        let currentVlm = authConfig.remote_vlmModelName;
+        if (!currentLlm || !currentVlm) {
+            console.log(chalk.cyan('\n📊 Fetching default models from remote server...'));
+            // Try to use RemoteAIClient first, otherwise fetch directly
+            let defaults = null;
+            if (this.remoteAIClient) {
+                try {
+                    defaults = await this.remoteAIClient.getDefaultModels();
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`   ⚠️  Failed to get defaults from RemoteAIClient: ${error.message}`));
+                }
+            }
+            // If RemoteAIClient failed or not available, fetch directly
+            if (!defaults) {
+                try {
+                    const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
+                    defaults = await fetchDefaultModels(authConfig.apiKey || '', webBaseUrl);
+                }
+                catch (error) {
+                    console.log(chalk.yellow(`   ⚠️  Failed to fetch default models: ${error.message}`));
+                }
+            }
+            if (defaults) {
+                if (!currentLlm && defaults.llm?.name) {
+                    currentLlm = defaults.llm.name;
+                    this.configManager.set('remote_llmModelName', currentLlm);
+                    console.log(chalk.cyan(`   Default LLM: ${defaults.llm.displayName || currentLlm}`));
+                }
+                if (!currentVlm && defaults.vlm?.name) {
+                    currentVlm = defaults.vlm.name;
+                    this.configManager.set('remote_vlmModelName', currentVlm);
+                    console.log(chalk.cyan(`   Default VLM: ${defaults.vlm.displayName || currentVlm}`));
                 }
-            ]);
-            if (confirm) {
-                await this.configManager.set('guiSubagentModel', '');
-                await this.configManager.set('guiSubagentBaseUrl', '');
-                await this.configManager.set('guiSubagentApiKey', '');
-                await this.configManager.save('global');
-                console.log(chalk.green('✅ VLM configuration removed successfully!'));
+                this.configManager.save('global');
             }
+            else {
+                console.log(chalk.yellow('   ⚠️  Use /auth to configure remote mode first.'));
+                return;
+            }
+        }
+        // Get RemoteAIClient instance (from InteractiveSession) for model selection
+        const remoteClient = this.remoteAIClient;
+        // Display current configuration
+        console.log(chalk.cyan('\n📊 Current Model Configuration:\n'));
+        console.log(`  ${chalk.yellow('LLM Model:')} ${currentLlm || 'Not set'}`);
+        console.log(`  ${chalk.yellow('VLM Model:')} ${currentVlm || 'Not set'}`);
+        console.log('');
+        // Main menu
+        const action = await select({
+            message: 'Select action:',
+            options: [
+                { value: 'llm', label: 'Change LLM model' },
+                { value: 'vlm', label: 'Change VLM model' },
+                { value: 'back', label: 'Back' },
+            ],
+        });
+        if (action === 'back' || typeof action === 'symbol') {
             return;
         }
-        if (action === 'configure') {
-            // Use AuthService to configure VLM
-            const authService = new AuthService({
-                type: 'openai_compatible',
-                apiKey: '',
-                baseUrl: '',
-                modelName: ''
+        // Restore stdin raw mode after @clack/prompts interaction
+        ensureTtySane();
+        // Get and display provider list
+        try {
+            const models = await remoteClient.getRemoteModels();
+            const modelList = action === 'llm' ? models.llm : models.vlm;
+            if (modelList.length === 0) {
+                console.log(chalk.yellow('\n⚠️  No models available.'));
+                return;
+            }
+            // Build choice list
+            const choices = modelList.map((m) => ({
+                name: `${m.displayName} (${m.name})`,
+                value: m.name
+            }));
+            const selectedModel = await select({
+                message: action === 'llm' ? 'Select LLM Model:' : 'Select VLM Model:',
+                options: choices
             });
-            const vlmConfig = await authService.configureAndValidateVLM();
-            if (vlmConfig) {
-                // Save VLM configuration
-                await this.configManager.set('guiSubagentModel', vlmConfig.model);
-                await this.configManager.set('guiSubagentBaseUrl', vlmConfig.baseUrl);
-                await this.configManager.set('guiSubagentApiKey', vlmConfig.apiKey);
-                await this.configManager.save('global');
-                console.log(chalk.green('✅ VLM configuration saved successfully!'));
-                console.log(chalk.cyan(`   Model: ${vlmConfig.model}`));
-                console.log(chalk.cyan(`   Base URL: ${vlmConfig.baseUrl}`));
+            if (typeof selectedModel !== 'string') {
+                return;
+            }
+            const configKey = action === 'llm' ? 'remote_llmModelName' : 'remote_vlmModelName';
+            this.configManager.set(configKey, selectedModel);
+            this.configManager.save('global');
+            // Clear conversation history to avoid tool call ID conflicts between providers
+            if (this.onClearCallback) {
+                this.onClearCallback();
+                console.log(chalk.cyan('   Conversation cleared to avoid tool call ID conflicts between models.'));
+            }
+            // Notify InteractiveSession to update aiClient config
+            if (this.onConfigUpdate) {
+                this.onConfigUpdate();
+            }
+            console.log(chalk.green('\n✅ Model updated successfully!'));
+            console.log(`   ${action === 'llm' ? 'LLM' : 'VLM'}: ${selectedModel}`);
+        }
+        catch (error) {
+            console.log(chalk.red(`\n❌ Failed to get models: ${error.message}`));
+        }
+    }
+    /**
+     * Handle /model command for local mode - Configure third-party API directly
+     * Reuses code from initial setup flow (authenticateWithOpenAICompatible and configureAndValidateVLM)
+     */
+    async handleLocalModel() {
+        // Display current configuration
+        const currentLlmModel = this.configManager.get('modelName') || this.configManager.getAuthConfig().modelName;
+        const currentVlmModel = this.configManager.get('guiSubagentModel');
+        console.log(chalk.cyan('\n📊 Current Local Model Configuration:\n'));
+        console.log(`  ${chalk.yellow('LLM Model:')} ${currentLlmModel || 'Not set'}`);
+        console.log(`  ${chalk.yellow('VLM Model:')} ${currentVlmModel || 'Not set'}`);
+        console.log('');
+        // Main menu - choose to configure LLM or VLM
+        const action = await select({
+            message: 'Select action:',
+            options: [
+                { value: 'llm', label: 'Change LLM (select provider and API)' },
+                { value: 'vlm', label: 'Change VLM (for GUI automation)' },
+                { value: 'back', label: 'Back' },
+            ],
+        });
+        if (action === 'back' || typeof action === 'symbol') {
+            return;
+        }
+        if (action === 'llm') {
+            await this.configureLocalLLM();
+        }
+        else if (action === 'vlm') {
+            await this.configureLocalVLM();
+        }
+    }
+    /**
+     * Configure LLM for local mode - Reuses authenticateWithOpenAICompatible logic
+     */
+    async configureLocalLLM() {
+        // THIRD_PARTY_PROVIDERS already imported at top level
+        const provider = await select({
+            message: 'Select third-party model provider:',
+            options: THIRD_PARTY_PROVIDERS.map((p) => ({
+                value: p,
+                label: `${p.name} - ${p.description}`,
+            })),
+        });
+        if (typeof provider === 'symbol') {
+            return;
+        }
+        const selectedProvider = provider;
+        let baseUrl = selectedProvider.baseUrl;
+        let modelName = selectedProvider.defaultModel;
+        if (selectedProvider.name === 'Custom') {
+            baseUrl = (await import('@clack/prompts').then(m => m.text({
+                message: 'Enter API Base URL:',
+                defaultValue: 'https://api.openai.com/v1',
+                validate: (value) => {
+                    if (!value || value.trim().length === 0) {
+                        return 'Base URL cannot be empty';
+                    }
+                    return undefined;
+                },
+            })));
+            modelName = (await import('@clack/prompts').then(m => m.text({
+                message: 'Enter model name:',
+                defaultValue: 'gpt-4',
+                validate: (value) => {
+                    if (!value || value.trim().length === 0) {
+                        return 'Model name cannot be empty';
+                    }
+                    return undefined;
+                },
+            })));
+            baseUrl = baseUrl.trim();
+            modelName = modelName.trim();
+        }
+        else {
+            console.log(chalk.cyan(`\nSelected: ${selectedProvider.name}`));
+            console.log(chalk.cyan(`API URL: ${baseUrl}`));
+            if (selectedProvider.models && selectedProvider.models.length > 0) {
+                console.log(chalk.cyan(`Available models: ${selectedProvider.models.join(', ')}`));
+                const selectedModel = await select({
+                    message: 'Select model:',
+                    options: selectedProvider.models.map((model) => ({
+                        value: model,
+                        label: model === selectedProvider.defaultModel ? `${model} (default)` : model,
+                    })),
+                });
+                if (typeof selectedModel === 'symbol') {
+                    return;
+                }
+                modelName = selectedModel;
             }
             else {
-                console.log(chalk.red('❌ VLM configuration failed or cancelled'));
+                console.log(chalk.cyan(`Default model: ${modelName}`));
+                const confirmModel = (await import('@clack/prompts').then(m => m.text({
+                    message: `Enter model name (press Enter to use default value ${modelName}):`,
+                    defaultValue: modelName,
+                    validate: (value) => {
+                        if (!value || value.trim().length === 0) {
+                            return 'Model name cannot be empty';
+                        }
+                        return undefined;
+                    },
+                })));
+                modelName = confirmModel.trim();
             }
         }
+        const apiKey = (await import('@clack/prompts').then(m => m.password({
+            message: `Enter ${selectedProvider.name} API Key:`,
+            validate: (value) => {
+                if (!value || value.trim().length === 0) {
+                    return 'API Key cannot be empty';
+                }
+                return undefined;
+            },
+        })));
+        // Update config
+        this.configManager.set('baseUrl', baseUrl);
+        this.configManager.set('apiKey', apiKey.trim());
+        this.configManager.set('modelName', modelName);
+        this.configManager.save('global');
+        console.log(chalk.green('\n✅ LLM configuration updated successfully!'));
+        console.log(chalk.cyan(`   Provider: ${selectedProvider.name}`));
+        console.log(chalk.cyan(`   Model: ${modelName}`));
+        console.log(chalk.cyan(`   API URL: ${baseUrl}`));
+        // Clear conversation and notify config update
+        if (this.onClearCallback) {
+            this.onClearCallback();
+        }
+        if (this.onConfigUpdate) {
+            this.onConfigUpdate();
+        }
+    }
+    /**
+     * Configure VLM for local mode - Select provider and modelName (baseUrl from VLM_PROVIDERS)
+     */
+    async configureLocalVLM() {
+        // Get current VLM config
+        const currentModel = this.configManager.get('guiSubagentModel');
+        const currentBaseUrl = this.configManager.get('guiSubagentBaseUrl');
+        console.log(chalk.cyan('\n📊 Current VLM Configuration:\n'));
+        console.log(`  ${chalk.yellow('Model:')} ${currentModel || 'Not set'}`);
+        console.log(`  ${chalk.yellow('Base URL:')} ${currentBaseUrl || 'Not set'}`);
+        console.log('');
+        // Step 1: Select VLM provider
+        const provider = await select({
+            message: 'Select VLM provider:',
+            options: VLM_PROVIDERS.map((p) => ({
+                value: p,
+                label: `${p.name} - ${p.defaultModel}`,
+            })),
+        });
+        // User cancelled
+        if (typeof provider === 'symbol') {
+            return;
+        }
+        const selectedProvider = provider;
+        // Step 2: Select model from provider's models list
+        const model = await select({
+            message: 'Select VLM Model:',
+            options: selectedProvider.models.map((m) => ({
+                value: m,
+                label: m,
+            })),
+        });
+        // User cancelled
+        if (typeof model === 'symbol') {
+            return;
+        }
+        // Step 3: Get API Key
+        const apiKey = (await text({
+            message: `Enter ${selectedProvider.name} API Key:`,
+            validate: (value) => {
+                if (!value || value.trim().length === 0) {
+                    return 'API Key cannot be empty';
+                }
+                return undefined;
+            },
+        }));
+        // Save configuration
+        this.configManager.set('guiSubagentModel', model);
+        this.configManager.set('guiSubagentBaseUrl', selectedProvider.baseUrl);
+        this.configManager.set('guiSubagentApiKey', apiKey);
+        this.configManager.save('global');
+        console.log(chalk.green('\n✅ VLM configuration updated successfully!'));
+        console.log(chalk.cyan(`   Provider: ${selectedProvider.name}`));
+        console.log(chalk.cyan(`   Model: ${model}`));
+        console.log(chalk.cyan(`   Base URL: ${selectedProvider.baseUrl}`));
+        // Notify config update
+        if (this.onConfigUpdate) {
+            this.onConfigUpdate();
+        }
     }
     async handleMode(args) {
         const modes = Object.values(ExecutionMode);
@@ -493,7 +874,7 @@ export class SlashCommandHandler {
             const newMode = args[0].toLowerCase();
             if (modes.includes(newMode)) {
                 this.configManager.setApprovalMode(newMode);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 console.log(chalk.green(`✅ Approval mode changed to: ${newMode}`));
             }
             else {
@@ -509,7 +890,7 @@ export class SlashCommandHandler {
                 { mode: 'accept_edits', desc: 'Accept all edits automatically' },
                 { mode: 'plan', desc: 'Plan before executing' },
                 { mode: 'default', desc: 'Safe execution with confirmations' },
-                { mode: 'smart', desc: 'Smart approval with intelligent security checks' }
+                { mode: 'smart', desc: 'Smart approval with intelligent security checks' },
             ];
             descriptions.forEach(({ mode, desc }) => {
                 const current = mode === currentMode ? chalk.green(' [current]') : '';
@@ -526,13 +907,13 @@ export class SlashCommandHandler {
             if (action === 'on' || action === 'true' || action === '1') {
                 thinkingConfig.enabled = true;
                 this.configManager.setThinkingConfig(thinkingConfig);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 console.log(chalk.green('✅ Thinking mode enabled'));
             }
             else if (action === 'off' || action === 'false' || action === '0') {
                 thinkingConfig.enabled = false;
                 this.configManager.setThinkingConfig(thinkingConfig);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 console.log(chalk.green('✅ Thinking mode disabled'));
             }
             else if (action === 'display' && args[1]) {
@@ -540,9 +921,9 @@ export class SlashCommandHandler {
                 const validModes = ['full', 'compact', 'indicator'];
                 if (validModes.includes(displayMode)) {
                     thinkingConfig.displayMode = displayMode;
-                    thinkingConfig.enabled = true; // Auto-enable when setting display mode
+                    thinkingConfig.enabled = true;
                     this.configManager.setThinkingConfig(thinkingConfig);
-                    await this.configManager.save('global');
+                    this.configManager.save('global');
                     console.log(chalk.green(`✅ Thinking display mode set to: ${displayMode}`));
                 }
                 else {
@@ -650,7 +1031,9 @@ export class SlashCommandHandler {
             const status = isConnected ? chalk.green('✓ Connected') : chalk.red('✗ Disconnected');
             const tools = server?.getToolNames() || [];
             const transport = serverConfig?.transport || serverConfig?.type || 'unknown';
-            const command = serverConfig?.command ? `${serverConfig.command} ${(serverConfig.args || []).join(' ')}` : serverConfig?.url || 'N/A';
+            const command = serverConfig?.command
+                ? `${serverConfig.command} ${(serverConfig.args || []).join(' ')}`
+                : serverConfig?.url || 'N/A';
             console.log('');
             console.log(`  ${chalk.cyan(serverName)} ${status}`);
             console.log(`    Transport: ${transport}`);
@@ -661,80 +1044,87 @@ export class SlashCommandHandler {
         logger.info(`Total: ${serverConfigs.length} server(s)`);
     }
     async addMcpServerInteractive(serverName) {
-        const { name, command, args: serverArgs, transport, url, authToken, headers } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'name',
-                message: 'Enter MCP server name:',
-                default: serverName,
-                validate: (input) => {
-                    if (!input.trim()) {
-                        return 'Server name is required';
-                    }
-                    const servers = this.mcpManager.getAllServers();
-                    if (servers.some((s) => s.config?.name === input)) {
-                        return 'Server with this name already exists';
-                    }
-                    return true;
+        const name = (await text({
+            message: 'Enter MCP server name:',
+            defaultValue: serverName,
+            validate: (value) => {
+                if (!value || !value.trim()) {
+                    return 'Server name is required';
                 }
+                if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+                    return 'Server name must contain only alphanumeric characters, hyphens, and underscores';
+                }
+                const servers = this.mcpManager.getAllServers();
+                if (servers.some((s) => s.config?.name === value)) {
+                    return 'Server with this name already exists';
+                }
+                return undefined;
             },
-            {
-                type: 'list',
-                name: 'transport',
-                message: 'Select transport type:',
-                choices: [
-                    { name: 'Stdio (stdin/stdout)', value: 'stdio' },
-                    { name: 'HTTP/SSE', value: 'sse' },
-                    { name: 'HTTP (POST)', value: 'http' }
-                ],
-                default: 'stdio'
-            },
-            {
-                type: 'input',
-                name: 'command',
+        }));
+        const transport = await select({
+            message: 'Select transport type:',
+            options: [
+                { value: 'stdio', label: 'Stdio (stdin/stdout)' },
+                { value: 'sse', label: 'HTTP/SSE' },
+                { value: 'http', label: 'HTTP (POST)' },
+            ],
+        });
+        if (typeof transport === 'symbol') {
+            return;
+        }
+        let command = '';
+        let serverArgs = [];
+        let url = '';
+        let authToken = '';
+        let headers;
+        if (transport === 'stdio') {
+            command = (await text({
                 message: 'Enter command (for stdio transport):',
-                when: (answers) => answers.transport === 'stdio',
-                validate: (input) => input.trim() ? true : 'Command is required'
-            },
-            {
-                type: 'input',
-                name: 'args',
+                validate: (value) => value && value.trim() ? undefined : 'Command is required',
+            }));
+            const argsInput = (await text({
                 message: 'Enter arguments (comma-separated, for stdio transport):',
-                when: (answers) => answers.transport === 'stdio',
-                filter: (input) => input ? input.split(',').map((a) => a.trim()) : []
-            },
-            {
-                type: 'input',
-                name: 'url',
+                defaultValue: '',
+            }));
+            if (argsInput.trim()) {
+                serverArgs = argsInput.split(',').map((a) => a.trim());
+            }
+        }
+        else {
+            url = (await text({
                 message: 'Enter server URL (for HTTP/SSE/HTTP transport):',
-                when: (answers) => answers.transport === 'sse' || answers.transport === 'http',
-                validate: (input) => input.trim() ? true : 'URL is required'
-            },
-            {
-                type: 'password',
-                name: 'authToken',
-                message: 'Enter authentication token (optional):',
-                when: (answers) => answers.transport === 'sse' || answers.transport === 'http'
-            },
-            {
-                type: 'input',
-                name: 'headers',
-                message: 'Enter custom headers as JSON (optional, e.g., {"Authorization": "Bearer token"}):',
-                when: (answers) => answers.transport === 'sse' || answers.transport === 'http',
-                filter: (input) => {
-                    if (!input.trim())
-                        return undefined;
+                validate: (value) => {
+                    if (!value || !value.trim()) {
+                        return 'URL is required';
+                    }
                     try {
-                        return JSON.parse(input);
+                        new URL(value);
+                        return undefined;
                     }
                     catch {
-                        return undefined;
+                        return 'Invalid URL format (e.g., https://example.com)';
                     }
+                },
+            }));
+            authToken = (await text({
+                message: 'Enter authentication token (optional):',
+                defaultValue: '',
+            }));
+            const headersInput = (await text({
+                message: 'Enter custom headers as JSON (optional, e.g., {"Authorization": "Bearer token"}):',
+                defaultValue: '',
+            }));
+            if (headersInput.trim()) {
+                try {
+                    headers = JSON.parse(headersInput);
+                }
+                catch {
+                    headers = undefined;
                 }
             }
-        ]);
+        }
         const config = {
-            transport: transport
+            transport: transport,
         };
         if (transport === 'stdio') {
             config.command = command;
@@ -744,30 +1134,37 @@ export class SlashCommandHandler {
         }
         else {
             config.url = url;
-            if (authToken) {
-                config.authToken = authToken;
+            // Handle user input that mistakenly puts Bearer token in headers field
+            // Detect pattern: headers looks like "Bearer xxx.yyy.zzz" (JWT token)
+            let resolvedAuthToken = authToken;
+            let resolvedHeaders = headers;
+            if (headers && typeof headers === 'string' && !authToken) {
+                const trimmedHeaders = headers.trim();
+                if (trimmedHeaders.startsWith('Bearer ') && trimmedHeaders.split('.').length === 3) {
+                    // User mistakenly put token in headers field - extract it
+                    resolvedAuthToken = trimmedHeaders;
+                    resolvedHeaders = undefined;
+                    console.log('[MCP] Note: Detected Bearer token in headers field, moved to authToken');
+                }
             }
-            if (headers) {
-                config.headers = headers;
+            if (resolvedAuthToken) {
+                config.authToken = resolvedAuthToken;
+            }
+            if (resolvedHeaders) {
+                config.headers = resolvedHeaders;
             }
         }
         try {
-            // Save to config file
             this.configManager.addMcpServer(name, config);
-            await this.configManager.save('global');
-            // Register to MCP Manager
+            this.configManager.save('global');
             this.mcpManager.registerServer(name, config);
-            // Connect to server (with error handling)
-            let connected = false;
             try {
                 await this.mcpManager.connectServer(name);
-                connected = true;
             }
             catch (error) {
-                // Connection failed - cleanup
                 this.mcpManager.disconnectServer(name);
                 this.configManager.removeMcpServer(name);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 throw new Error(`Connection failed: ${error.message}`);
             }
             // Register MCP tools with simple names
@@ -790,30 +1187,25 @@ export class SlashCommandHandler {
             logger.warn('No MCP servers configured', 'Use /mcp add to add servers');
             return;
         }
-        const serverNames = servers.map((s) => {
+        const serverOptions = servers.map((s) => {
             const tools = s.getToolNames();
             const status = s.isServerConnected() ? '✓' : '✗';
             return {
-                name: `${status} ${s.config?.name || 'unknown'} (${tools.length} tools)`,
-                value: s.config?.name
+                value: s.config?.name,
+                label: `${status} ${s.config?.name || 'unknown'} (${tools.length} tools)`,
             };
         });
-        const { serverName } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'serverName',
-                message: 'Select MCP server to remove:',
-                choices: serverNames
-            }
-        ]);
+        const serverName = (await select({
+            message: 'Select MCP server to remove:',
+            options: serverOptions,
+        }));
+        if (typeof serverName === 'symbol') {
+            return;
+        }
         await this.removeMcpServer(serverName);
     }
     async removeMcpServer(serverName) {
         try {
-            // Get server info before disconnecting to notify LLM
-            const server = this.mcpManager.getServer(serverName);
-            const removedTools = server ? server.getToolNames() : [];
-            const removedToolNames = removedTools.map((t) => `${serverName}__${t}`).join(', ');
             // Disconnect
             this.mcpManager.disconnectServer(serverName);
             // Unregister MCP tools for this server
@@ -821,7 +1213,7 @@ export class SlashCommandHandler {
             toolRegistry.unregisterMCPTools(serverName);
             // Remove from config
             this.configManager.removeMcpServer(serverName);
-            await this.configManager.save('global');
+            this.configManager.save('global');
             // Update system prompt to reflect removed MCP tools
             if (this.onSystemPromptUpdate) {
                 await this.onSystemPromptUpdate();
@@ -914,8 +1306,7 @@ export class SlashCommandHandler {
             return;
         }
         // Clear specific file by filename or path
-        const targetMemory = memoryFiles.find((m) => path.basename(m.path) === target ||
-            m.path === target);
+        const targetMemory = memoryFiles.find((m) => path.basename(m.path) === target || m.path === target);
         if (targetMemory) {
             try {
                 await fs.unlink(targetMemory.path);
@@ -949,22 +1340,20 @@ export class SlashCommandHandler {
         logger.info(`Directory: ${memoriesDir}`);
         console.log('');
         memoryFiles.forEach((file) => {
-            const level = file.level === 'global' ? chalk.blue('[global]') :
-                file.level === 'project' ? chalk.green('[project]') :
-                    chalk.yellow('[subdirectory]');
+            const level = file.level === 'global'
+                ? chalk.blue('[global]')
+                : file.level === 'project'
+                    ? chalk.green('[project]')
+                    : chalk.yellow('[subdirectory]');
             logger.info(`  ${level} ${path.basename(file.path)}`);
         });
         console.log('');
         // logger.info('Usage: /memory clear [global|current|all|<filename>]');
     }
     async addMemory() {
-        const { entry } = await inquirer.prompt([
-            {
-                type: 'editor',
-                name: 'entry',
-                message: 'Enter memory entry (opens editor):'
-            }
-        ]);
+        const entry = (await text({
+            message: 'Enter memory entry (opens editor):',
+        }));
         if (entry && entry.trim()) {
             await this.memoryManager.addMemoryEntry(entry.trim());
             console.log(chalk.green('✅ Memory entry added'));
@@ -1001,18 +1390,17 @@ export class SlashCommandHandler {
             }
         }
         else {
-            const choices = checkpoints.map((cp) => ({
-                name: `${new Date(cp.timestamp).toLocaleString()} - ${cp.description}`,
-                value: cp.id
+            const checkpointOptions = checkpoints.map((cp) => ({
+                value: cp.id,
+                label: `${new Date(cp.timestamp).toLocaleString()} - ${cp.description}`,
             }));
-            const { checkpointId } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'checkpointId',
-                    message: 'Select checkpoint to restore:',
-                    choices
-                }
-            ]);
+            const checkpointId = await select({
+                message: 'Select checkpoint to restore:',
+                options: checkpointOptions,
+            });
+            if (typeof checkpointId === 'symbol') {
+                return;
+            }
             try {
                 await this.checkpointManager.restoreCheckpoint(checkpointId);
                 logger.success(`Checkpoint ${checkpointId} restored successfully!`);
@@ -1026,7 +1414,7 @@ export class SlashCommandHandler {
         const toolRegistry = getToolRegistry();
         const tools = toolRegistry.getAll();
         logger.section('Available Tools');
-        tools.forEach(tool => {
+        tools.forEach((tool) => {
             logger.info(`  ${tool.name}`);
             logger.info(`    ${tool.description}`);
         });
@@ -1045,12 +1433,12 @@ export class SlashCommandHandler {
         const mode = args[0].toLowerCase();
         if (mode === 'verbose' || mode === 'detail' || mode === 'true' || mode === 'on') {
             this.configManager.set('showToolDetails', true);
-            await this.configManager.save('global');
+            this.configManager.save('global');
             logger.success('Tool display mode switched to verbose mode', 'Will show complete tool call information');
         }
         else if (mode === 'simple' || mode === 'concise' || mode === 'false' || mode === 'off') {
             this.configManager.set('showToolDetails', false);
-            await this.configManager.save('global');
+            this.configManager.save('global');
             logger.success('Tool display mode switched to simple mode', 'Only show tool execution status');
         }
         else {
@@ -1059,6 +1447,8 @@ export class SlashCommandHandler {
     }
     async handleStats() {
         logger.section('Session Statistics');
+        const authConfig = this.configManager.getAuthConfig();
+        logger.info(`  Base URL: ${authConfig.baseUrl}`);
         logger.info(`  Execution Mode: ${this.configManager.getExecutionMode()}`);
         logger.info(`  Language: ${this.configManager.getLanguage()}`);
         logger.info(`  Checkpointing: ${this.checkpointManager.isEnabled() ? 'Enabled' : 'Disabled'}`);
@@ -1069,17 +1459,16 @@ export class SlashCommandHandler {
         logger.warn('Theme switching not implemented yet', 'Check back later for updates');
     }
     async handleLanguage() {
-        const { language } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'language',
-                message: 'Select language:',
-                choices: [
-                    { name: 'Chinese', value: 'zh' },
-                    { name: 'English', value: 'en' }
-                ]
-            }
-        ]);
+        const language = (await select({
+            message: 'Select language:',
+            options: [
+                { value: 'zh', label: 'Chinese' },
+                { value: 'en', label: 'English' },
+            ],
+        }));
+        if (typeof language === 'symbol') {
+            return;
+        }
         this.configManager.setLanguage(language);
         logger.success(`Language changed to: ${language === 'zh' ? 'Chinese' : 'English'}`, 'Restart CLI to apply changes');
     }
@@ -1091,6 +1480,45 @@ export class SlashCommandHandler {
         logger.link('Documentation', 'https://platform.xagent.cn/');
         logger.link('GitHub', 'https://github.com/xagent-ai/xagent-cli');
     }
+    async handleUpdate() {
+        const separator = icons.separator.repeat(Math.min(40, process.stdout.columns || 80));
+        console.log('');
+        console.log(colors.primaryBright(`${icons.rocket} Update Check`));
+        console.log(colors.border(separator));
+        console.log('');
+        try {
+            const { getUpdateManager } = await import('./update.js');
+            const updateManager = getUpdateManager();
+            const versionInfo = await updateManager.checkForUpdates();
+            console.log(`  ${icons.info}  ${colors.textMuted('Current version:')} ${colors.primaryBright(versionInfo.currentVersion)}`);
+            console.log(`  ${icons.code} ${colors.textMuted('Latest version:')} ${colors.primaryBright(versionInfo.latestVersion)}`);
+            console.log('');
+            if (versionInfo.updateAvailable) {
+                console.log(colors.success(`  📦 A new version is available!`));
+                console.log('');
+                if (versionInfo.releaseNotes) {
+                    console.log(colors.textMuted('  Release Notes:'));
+                    console.log(colors.textDim(`  ${versionInfo.releaseNotes}`));
+                    console.log('');
+                }
+                const shouldUpdate = await confirm({
+                    message: 'Do you want to update now?',
+                });
+                if (shouldUpdate === true) {
+                    console.log('');
+                    await updateManager.autoUpdate();
+                }
+            }
+            else {
+                console.log(colors.success(`  ✅ You are using the latest version`));
+                console.log('');
+            }
+        }
+        catch (error) {
+            console.log(colors.error(`  ❌ Failed to check for updates: ${error.message}`));
+            console.log('');
+        }
+    }
     async handleCompress(args) {
         const config = this.configManager.getContextCompressionConfig();
         // If there are arguments, process config or execute
@@ -1106,15 +1534,11 @@ export class SlashCommandHandler {
         // Display current configuration
         console.log(chalk.cyan('\n📦 Context Compression:\n'));
         console.log(`  Status: ${config.enabled ? chalk.green('Enabled') : chalk.red('Disabled')}`);
-        console.log(`  Max Messages: ${chalk.yellow(config.maxMessages.toString())}`);
-        console.log(`  Max Tokens: ${chalk.yellow(config.maxContextSize.toString())}`);
         console.log('');
         console.log(chalk.gray('Usage:'));
         console.log(chalk.gray('  /compress                 - Show current configuration'));
         console.log(chalk.gray('  /compress exec            - Execute compression now'));
         console.log(chalk.gray('  /compress on|off          - Enable/disable compression'));
-        console.log(chalk.gray('  /compress max_message <n> - Set max messages before compression'));
-        console.log(chalk.gray('  /compress max_token <n>   - Set max tokens before compression'));
         console.log('');
     }
     async executeCompression(config) {
@@ -1133,7 +1557,7 @@ export class SlashCommandHandler {
         const spinner = ora({
             text: 'Compressing context...',
             spinner: 'dots',
-            color: 'cyan'
+            color: 'cyan',
         }).start();
         try {
             const result = await this.contextCompressor.compressContext(messages, 'You are a helpful AI assistant.', config);
@@ -1159,56 +1583,241 @@ export class SlashCommandHandler {
             case 'on':
                 config.enabled = true;
                 this.configManager.setContextCompressionConfig(config);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 console.log(chalk.green('✅ Context compression enabled'));
                 break;
             case 'off':
                 config.enabled = false;
                 this.configManager.setContextCompressionConfig(config);
-                await this.configManager.save('global');
+                this.configManager.save('global');
                 console.log(chalk.green('✅ Context compression disabled'));
                 break;
-            case 'max_message':
-                if (args[1]) {
-                    const maxMessages = parseInt(args[1], 10);
-                    if (isNaN(maxMessages) || maxMessages < 1) {
-                        console.log(chalk.red('❌ Invalid value for max_message. Must be a positive number.'));
-                        return;
-                    }
-                    config.maxMessages = maxMessages;
-                    this.configManager.setContextCompressionConfig(config);
-                    await this.configManager.save('global');
-                    console.log(chalk.green(`✅ Max messages set to: ${maxMessages}`));
+            default:
+                console.log(chalk.red(`❌ Unknown action: ${action}`));
+                console.log(chalk.gray('Available actions: on, off, exec'));
+        }
+    }
+    async handleSkill(args) {
+        const os = await import('os');
+        const path = await import('path');
+        const { promises: fs } = await import('fs');
+        const action = args[0] || 'list';
+        const userSkillsPath = this.configManager.getUserSkillsPath() || path.join(os.homedir(), '.xagent', 'skills');
+        switch (action) {
+            case 'list':
+                await this.listUserSkills(userSkillsPath, fs, path);
+                break;
+            case 'add':
+                await this.addSkill(args[1], userSkillsPath, fs, path);
+                break;
+            case 'remove':
+                await this.removeSkill(args[1], userSkillsPath, fs, path);
+                break;
+            default:
+                console.log(chalk.cyan('\n🔧 Skills:\n'));
+                console.log(`  Skills directory: ${chalk.yellow(userSkillsPath)}\n`);
+                console.log(chalk.gray('Available commands:'));
+                console.log(chalk.gray('  /skill list                   - List installed skills'));
+                console.log(chalk.gray('  /skill add <source>           - Add a skill (local path or remote URL)'));
+                console.log(chalk.gray('  /skill remove <name>          - Remove a user-installed skill'));
+                console.log();
+                console.log(chalk.gray('Examples:'));
+                console.log(chalk.gray('  /skill add ./my-skill                    - Local path'));
+                console.log(chalk.gray('  /skill add owner/repo                     - GitHub shorthand'));
+                console.log(chalk.gray('  /skill add https://github.com/owner/repo  - GitHub URL'));
+                console.log();
+        }
+    }
+    async listUserSkills(userSkillsPath, fs, path) {
+        console.log(chalk.cyan('\n🔧 Skills:\n'));
+        try {
+            const entries = await fs.readdir(userSkillsPath, { withFileTypes: true });
+            const skills = entries.filter((e) => e.isDirectory());
+            if (skills.length === 0) {
+                console.log(chalk.gray('  No skills installed'));
+                console.log(chalk.cyan('\n  To add a skill, use:'));
+                console.log(chalk.cyan('    /skill add <path-to-skill>\n'));
+                return;
+            }
+            for (const skill of skills) {
+                const skillPath = path.join(userSkillsPath, skill.name);
+                const skillMdPath = path.join(skillPath, 'SKILL.md');
+                try {
+                    const content = await fs.readFile(skillMdPath, 'utf-8');
+                    const nameMatch = content.match(/^name:\s*(.+)$/m);
+                    const descMatch = content.match(/^description:\s*(.+)$/m);
+                    const name = nameMatch ? nameMatch[1].trim() : skill.name;
+                    const description = descMatch ? descMatch[1].trim() : 'No description';
+                    console.log(`  ${chalk.cyan('•')} ${chalk.yellow(name)}`);
+                    console.log(`    ${chalk.gray(description)}`);
+                    console.log();
+                }
+                catch {
+                    console.log(`  ${chalk.cyan('•')} ${chalk.yellow(skill.name)}`);
+                    console.log(`    ${chalk.gray('(Missing SKILL.md)')}`);
+                    console.log();
+                }
+            }
+            console.log(chalk.gray(`  Skills directory: ${userSkillsPath}`));
+            console.log();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.log(chalk.gray('  No skills installed'));
+                console.log(chalk.cyan('\n  To add a skill, use:'));
+                console.log(chalk.cyan('    /skill add <path-to-skill>\n'));
+            }
+            else {
+                console.log(chalk.red(`  Error: ${error.message}`));
+            }
+        }
+    }
+    async addSkill(source, userSkillsPath, fs, path) {
+        if (!source) {
+            console.log(chalk.yellow('\n⚠️  Please specify a skill source'));
+            console.log(chalk.cyan('  Usage: /skill add <source>\n'));
+            console.log(chalk.gray('  Examples:'));
+            console.log(chalk.gray('    /skill add ./my-skill           - Local path'));
+            console.log(chalk.gray('    /skill add owner/repo            - GitHub shorthand'));
+            console.log(chalk.gray('    /skill add https://github.com/owner/repo'));
+            console.log();
+            return;
+        }
+        const { parseSource, installSkill } = await import('./skill-installer.js');
+        const parsed = parseSource(source.trim());
+        const isLocal = parsed.type === 'local';
+        if (isLocal) {
+            // Local installation
+            const resolvedPath = path.resolve(source);
+            const skillName = path.basename(resolvedPath);
+            const destPath = path.join(userSkillsPath, skillName);
+            try {
+                // Check if source exists
+                await fs.access(resolvedPath);
+                // Check if SKILL.md exists
+                const skillMdPath = path.join(resolvedPath, 'SKILL.md');
+                try {
+                    await fs.access(skillMdPath);
+                }
+                catch {
+                    console.log(chalk.red(`\n❌ SKILL.md not found in ${resolvedPath}`));
+                    console.log(chalk.gray('  Each skill must have a SKILL.md file\n'));
+                    return;
+                }
+                // Check if skill already exists
+                try {
+                    await fs.access(destPath);
+                    console.log(chalk.yellow(`\n⚠️  Skill "${skillName}" already installed`));
+                    console.log(chalk.cyan(`  Use: /skill remove ${skillName} to remove it first\n`));
+                    return;
+                }
+                catch {
+                    // Doesn't exist, proceed
+                }
+                // Ensure skills directory exists
+                await fs.mkdir(userSkillsPath, { recursive: true });
+                // Copy the skill
+                await this.copyDirectory(resolvedPath, destPath);
+                console.log(chalk.green('\n✅ Skill installed successfully'));
+                console.log(chalk.gray(`  Name: ${skillName}`));
+                console.log(chalk.gray(`  Location: ${destPath}`));
+                console.log(chalk.gray(`  Type: Local`));
+                console.log();
+                // Trigger system prompt update
+                this.onSystemPromptUpdate?.();
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    console.log(chalk.red(`\n❌ Skill not found: ${source}\n`));
                 }
                 else {
-                    console.log(chalk.gray('Usage: /compress max_message <number>'));
+                    console.log(chalk.red(`\n❌ Error installing skill: ${error.message}\n`));
                 }
-                break;
-            case 'max_token':
-                if (args[1]) {
-                    const maxContextSize = parseInt(args[1], 10);
-                    if (isNaN(maxContextSize) || maxContextSize < 1000) {
-                        console.log(chalk.red('❌ Invalid value for max_token. Must be at least 1000.'));
-                        return;
-                    }
-                    config.maxContextSize = maxContextSize;
-                    this.configManager.setContextCompressionConfig(config);
-                    await this.configManager.save('global');
-                    console.log(chalk.green(`✅ Max tokens set to: ${maxContextSize}`));
+            }
+        }
+        else {
+            // Remote installation
+            console.log(chalk.cyan('\n📦 Installing skill from remote source...\n'));
+            console.log(chalk.gray(`  Source: ${source}`));
+            console.log(chalk.gray(`  Type: Remote`));
+            console.log();
+            try {
+                const result = await installSkill(source);
+                if (result.success) {
+                    console.log(chalk.green('✅ Skill installed successfully'));
+                    console.log(chalk.gray(`  Name: ${result.skillName}`));
+                    console.log(chalk.gray(`  Location: ${result.skillPath}`));
+                    console.log(chalk.gray('  Type: Remote'));
+                    console.log();
+                    // Trigger system prompt update - skill is immediately available
+                    this.onSystemPromptUpdate?.();
                 }
                 else {
-                    console.log(chalk.gray('Usage: /compress max_token <number>'));
+                    console.log(chalk.red(`\n❌ Failed to install skill: ${result.error}\n`));
                 }
-                break;
-            default:
-                console.log(chalk.red(`❌ Unknown action: ${action}`));
-                console.log(chalk.gray('Available actions: on, off, max_message, max_token, exec'));
+            }
+            catch (error) {
+                console.log(chalk.red(`\n❌ Error installing skill: ${error.message}\n`));
+            }
+        }
+    }
+    async removeSkill(skillName, userSkillsPath, fs, path) {
+        if (!skillName) {
+            console.log(chalk.yellow('\n⚠️  Please specify a skill name'));
+            console.log(chalk.cyan('  Usage: /skill remove <skill-name>\n'));
+            return;
+        }
+        // Protect find-skills from deletion
+        if (skillName === 'find-skills') {
+            console.log(chalk.red('\n❌ Cannot remove protected skill: find-skills'));
+            console.log(chalk.gray('  find-skills is a built-in skill that helps you discover and install other skills.\n'));
+            return;
+        }
+        const skillPath = path.join(userSkillsPath, skillName);
+        try {
+            await fs.access(skillPath);
+            // Verify it's in skills path
+            if (!skillPath.startsWith(userSkillsPath)) {
+                console.log(chalk.red(`\n❌ Cannot remove skill outside user directory\n`));
+                return;
+            }
+            // Remove the skill directory
+            await fs.rm(skillPath, { recursive: true, force: true });
+            console.log(chalk.green('\n✅ Skill removed successfully'));
+            console.log();
+            // Trigger system prompt update
+            this.onSystemPromptUpdate?.();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' || error.code === 'ENOENT') {
+                console.log(chalk.yellow(`\n⚠️  Skill not found: ${skillName}\n`));
+            }
+            else {
+                console.log(chalk.red(`\n❌ Error removing skill: ${error.message}\n`));
+            }
+        }
+    }
+    async copyDirectory(src, dest) {
+        const entries = await fs.readdir(src, { withFileTypes: true });
+        await fs.mkdir(dest, { recursive: true });
+        for (const entry of entries) {
+            // Skip node_modules to keep dependencies isolated
+            // if (entry.name === 'node_modules') continue;
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, destPath);
+            }
+            else if (entry.isFile()) {
+                await fs.copyFile(srcPath, destPath);
+            }
         }
     }
 }
-export function parseInput(input) {
+export async function parseInput(input) {
     const inputs = [];
     let remaining = input;
+    // Match @ followed by any non-whitespace sequence
     const fileRefRegex = /@([^\s]+)/g;
     let match;
     while ((match = fileRefRegex.exec(remaining)) !== null) {
@@ -1218,7 +1827,15 @@ export function parseInput(input) {
         if (beforeMatch.trim()) {
             inputs.push({ type: 'text', content: beforeMatch.trim() });
         }
-        inputs.push({ type: 'file', content: filePath });
+        // Only treat as file reference if the file actually exists
+        const exists = await fileExists(filePath);
+        if (exists) {
+            inputs.push({ type: 'file', content: filePath });
+        }
+        else {
+            // Not a file, treat as regular text (preserving the @ symbol)
+            inputs.push({ type: 'text', content: '@' + filePath });
+        }
         remaining = afterMatch;
     }
     if (remaining.trim()) {
@@ -1231,6 +1848,18 @@ export function parseInput(input) {
     }
     return inputs;
 }
+// Helper function to check if a file path exists
+async function fileExists(filePath) {
+    try {
+        // Resolve to absolute path
+        const absolutePath = path.resolve(filePath);
+        await fs.access(absolutePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function detectImageInput(input) {
     return input.includes('[Pasted image') || input.includes('<image');
 }