@xagent-ai/cli 1.0.1 → 1.1.1

package/dist/session.js

@@ -1,8 +1,15 @@
 import readline from 'readline';
 import chalk from 'chalk';
+import https from 'https';
+import axios from 'axios';
+import crypto from 'crypto';
 import ora from 'ora';
+import { createRequire } from 'module';
+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 { getConfigManager } from './config.js';
 import { AuthService, selectAuthType } from './auth.js';
 import { getToolRegistry } from './tools.js';
@@ -17,12 +24,14 @@ import { SystemPromptGenerator } from './system-prompt-generator.js';
 import { theme, icons, colors, styleHelpers, renderMarkdown } from './theme.js';
 import { getCancellationManager } from './cancellation.js';
 import { getContextCompressor } from './context-compressor.js';
+import { getLogger } from './logger.js';
+const logger = getLogger();
 export class InteractiveSession {
     conversationManager;
     sessionManager;
     contextCompressor;
-    rl;
     aiClient = null;
+    remoteAIClient = null;
     conversation = [];
     toolCalls = [];
     executionMode;
@@ -33,9 +42,14 @@ export class InteractiveSession {
     mcpManager;
     checkpointManager;
     currentAgent = null;
+    rl;
     cancellationManager;
     indentLevel;
     indentString;
+    remoteConversationId = null;
+    currentTaskId = null;
+    taskCompleted = false;
+    isFirstApiCall = true;
     constructor(indentLevel = 0) {
         this.rl = readline.createInterface({
             input: process.stdin,
@@ -49,18 +63,18 @@ export class InteractiveSession {
         this.conversationManager = getConversationManager();
         this.sessionManager = getSessionManager(process.cwd());
         this.slashCommandHandler = new SlashCommandHandler();
-        // 注册 /clear 回调，清除对话时同步清空本地 conversation
+        // Register /clear callback, clear local conversation when clearing dialogue
         this.slashCommandHandler.setClearCallback(() => {
             this.conversation = [];
         });
-        // 注册 MCP 更新回调，更新系统提示
+        // Register MCP update callback, update system prompt
         this.slashCommandHandler.setSystemPromptUpdateCallback(async () => {
             await this.updateSystemPrompt();
         });
         this.executionMode = ExecutionMode.DEFAULT;
         this.cancellationManager = getCancellationManager();
         this.indentLevel = indentLevel;
-        this.indentString = '  '.repeat(indentLevel);
+        this.indentString = ' '.repeat(indentLevel);
         this.contextCompressor = getContextCompressor();
     }
     getIndent() {
@@ -77,7 +91,7 @@ export class InteractiveSession {
      */
     async updateSystemPrompt() {
         const toolRegistry = getToolRegistry();
-        const promptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+        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);
@@ -95,13 +109,17 @@ export class InteractiveSession {
         this.currentAgent = agent;
     }
     async start() {
+        // Set this session as the singleton for access from other modules
+        setSingletonSession(this);
+        // Initialize taskId for GUI operations
+        this.currentTaskId = crypto.randomUUID();
         const separator = icons.separator.repeat(60);
         console.log('');
         console.log(colors.gradient('╔════════════════════════════════════════════════════════════╗'));
-        console.log(colors.gradient('║') + ' '.repeat(56) + colors.gradient('║'));
-        console.log(' '.repeat(12) + colors.gradient('🤖 XAGENT CLI') + ' '.repeat(37) + colors.gradient('║'));
-        console.log(' '.repeat(14) + colors.textMuted('v1.0.0') + ' '.repeat(40) + colors.gradient('║'));
-        console.log(colors.gradient('║') + ' '.repeat(56) + colors.gradient('║'));
+        console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
+        console.log(' '.repeat(14) + '🤖 ' + colors.gradient('XAGENT CLI') + ' '.repeat(32) + colors.gradient('  ║'));
+        console.log(' '.repeat(17) + colors.textMuted(`v${packageJson.version}`) + ' '.repeat(36) + colors.gradient('  ║'));
+        console.log(colors.gradient('║') + ' '.repeat(58) + colors.gradient('  ║'));
         console.log(colors.gradient('╚════════════════════════════════════════════════════════════╝'));
         console.log(colors.textMuted('  AI-powered command-line assistant'));
         console.log('');
@@ -125,42 +143,63 @@ export class InteractiveSession {
         });
     }
     async initialize() {
+        logger.debug('\n[SESSION] ========== initialize() 开始 ==========\n');
         try {
-            const spinner = ora({
-                text: colors.textMuted('Initializing XAGENT CLI...'),
-                spinner: 'dots',
-                color: 'cyan'
-            }).start();
+            // Custom spinner for initialization (like Thinking...)
+            const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+            let frameIndex = 0;
+            const validatingText = colors.textMuted('Validating authentication...');
+            const spinnerInterval = setInterval(() => {
+                process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${validatingText}`);
+                frameIndex = (frameIndex + 1) % frames.length;
+            }, 120);
+            logger.debug('[SESSION] 调用 configManager.load()...');
             await this.configManager.load();
+            logger.debug('[SESSION] Config loaded');
             let authConfig = this.configManager.getAuthConfig();
-            // If there's an API key, validate it with the backend
-            if (authConfig.apiKey) {
-                spinner.text = colors.textMuted('Validating authentication...');
-                const baseUrl = authConfig.xagentApiBaseUrl || 'http://xagent-colife.net:3000';
+            let selectedAuthType = this.configManager.get('selectedAuthType');
+            logger.debug('[SESSION] authConfig.apiKey exists:', String(!!authConfig.apiKey));
+            logger.debug('[SESSION] selectedAuthType (initial):', String(selectedAuthType));
+            logger.debug('[SESSION] AuthType.OAUTH_XAGENT:', String(AuthType.OAUTH_XAGENT));
+            logger.debug('[SESSION] AuthType.OPENAI_COMPATIBLE:', String(AuthType.OPENAI_COMPATIBLE));
+            logger.debug('[SESSION] Will validate OAuth:', String(!!(authConfig.apiKey && selectedAuthType === AuthType.OAUTH_XAGENT)));
+            // Only validate OAuth tokens, skip validation for third-party API keys
+            if (authConfig.apiKey && selectedAuthType === AuthType.OAUTH_XAGENT) {
+                clearInterval(spinnerInterval);
+                process.stdout.write('\r' + ' '.repeat(50) + '\r'); // Clear the line
+                const baseUrl = authConfig.xagentApiBaseUrl || 'https://154.8.140.52:443';
                 let isValid = await this.validateToken(baseUrl, authConfig.apiKey);
                 // Try refresh token if validation failed
                 if (!isValid && authConfig.refreshToken) {
-                    console.log(colors.info(`[DEBUG] Token expired, trying to refresh...`));
-                    spinner.text = colors.textMuted('Refreshing authentication...');
+                    const refreshingText = colors.textMuted('Refreshing authentication...');
+                    frameIndex = 0;
+                    const refreshInterval = setInterval(() => {
+                        process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${refreshingText}`);
+                        frameIndex = (frameIndex + 1) % frames.length;
+                    }, 120);
                     const newToken = await this.refreshToken(baseUrl, authConfig.refreshToken);
+                    clearInterval(refreshInterval);
+                    process.stdout.write('\r' + ' '.repeat(50) + '\r');
                     if (newToken) {
-                        // Save new token
+                        // Save new token and persist
                         await this.configManager.set('apiKey', newToken);
+                        await this.configManager.save('global');
                         authConfig.apiKey = newToken;
                         isValid = true;
-                        console.log(colors.success(`[DEBUG] Token refreshed successfully!`));
                     }
                 }
                 if (!isValid) {
-                    spinner.stop();
                     console.log('');
                     console.log(colors.warning('⚠️  Authentication expired or invalid'));
                     console.log(colors.info('Please log in again to continue.'));
                     console.log('');
-                    // Clear invalid credentials
+                    // 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.set('selectedAuthType', AuthType.OAUTH_XAGENT);
+                    await this.configManager.save('global');
+                    await this.configManager.load();
+                    authConfig = this.configManager.getAuthConfig();
                     await this.setupAuthentication();
                     authConfig = this.configManager.getAuthConfig();
                     // Recreate readline interface after inquirer
@@ -170,15 +209,18 @@ export class InteractiveSession {
                         output: process.stdout
                     });
                     this.rl.on('close', () => {
-                        console.error('DEBUG: readline interface closed');
+                        // readline closed
                     });
-                    spinner.start();
                 }
             }
-            else {
-                spinner.stop();
+            else if (!authConfig.apiKey) {
+                // No API key configured, need to set up authentication
+                clearInterval(spinnerInterval);
+                process.stdout.write('\r' + ' '.repeat(50) + '\r');
                 await this.setupAuthentication();
                 authConfig = this.configManager.getAuthConfig();
+                selectedAuthType = this.configManager.get('selectedAuthType');
+                logger.debug('[SESSION] selectedAuthType (after setup):', String(selectedAuthType));
                 // Recreate readline interface after inquirer
                 this.rl.close();
                 this.rl = readline.createInterface({
@@ -186,12 +228,28 @@ export class InteractiveSession {
                     output: process.stdout
                 });
                 this.rl.on('close', () => {
-                    console.error('DEBUG: readline interface closed');
+                    // readline closed
                 });
-                spinner.start();
             }
+            else {
+                clearInterval(spinnerInterval);
+                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));
+            if (selectedAuthType === AuthType.OAUTH_XAGENT) {
+                const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://154.8.140.52:443';
+                // 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);
+                logger.debug('[DEBUG Initialize] RemoteAIClient created successfully');
+            }
+            else {
+                logger.debug('[DEBUG Initialize] RemoteAIClient NOT created (not OAuth XAGENT mode)');
+            }
             this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
             await this.agentManager.loadAgents();
             await this.memoryManager.loadMemory();
@@ -200,10 +258,9 @@ export class InteractiveSession {
             // Create a new conversation and session for this interactive session
             const conversation = await this.conversationManager.createConversation();
             await this.sessionManager.createSession(conversation.id, this.currentAgent?.name || 'general-purpose', this.executionMode);
-            // 同步对话历史到 slashCommandHandler
+            // Sync conversation history to slashCommandHandler
             this.slashCommandHandler.setConversationHistory(this.conversation);
             const mcpServers = this.configManager.getMcpServers();
-            console.log(`📋 Loading ${Object.keys(mcpServers).length} MCP servers from config`);
             Object.entries(mcpServers).forEach(([name, config]) => {
                 console.log(`📝 Registering MCP server: ${name} (${config.transport})`);
                 this.mcpManager.registerServer(name, config);
@@ -231,7 +288,7 @@ export class InteractiveSession {
                 await this.checkpointManager.initialize();
             }
             this.currentAgent = this.agentManager.getAgent('general-purpose');
-            spinner.succeed(colors.success('Initialization complete'));
+            console.log(colors.success('✔ Initialization complete'));
         }
         catch (error) {
             const spinner = ora({ text: '', spinner: 'dots', color: 'red' }).start();
@@ -244,49 +301,52 @@ export class InteractiveSession {
      * Returns true if token is valid, false otherwise
      */
     async validateToken(baseUrl, apiKey) {
+        logger.debug('[SESSION] validateToken called with baseUrl:', baseUrl);
+        logger.debug('[SESSION] apiKey exists:', apiKey ? 'yes' : 'no');
         try {
             // For OAuth XAGENT auth, use /api/auth/me endpoint
             const url = `${baseUrl}/api/auth/me`;
-            console.log(colors.info(`[DEBUG] Validating token with: ${url}`));
-            const response = await fetch(url, {
-                method: 'GET',
+            const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+            logger.debug('[SESSION] Sending validation request to:', url);
+            const response = await axios.get(url, {
                 headers: {
                     'Authorization': `Bearer ${apiKey}`,
                     'Content-Type': 'application/json'
-                }
+                },
+                httpsAgent,
+                timeout: 10000
             });
-            console.log(colors.info(`[DEBUG] Response status: ${response.status}`));
-            return response.ok;
+            logger.debug('[SESSION] Validation response status:', String(response.status));
+            return response.status === 200;
         }
         catch (error) {
-            console.log(colors.warning(`[DEBUG] Network error: ${error}`));
-            // Network error - could be server down, consider token invalid
+            // Network error - log details but still consider token may be invalid
+            logger.debug('[SESSION] Error:', error.message);
+            if (error.response) {
+                logger.debug('[SESSION] Response status:', error.response.status);
+            }
+            // For network errors, we still return false to trigger re-authentication
+            // This ensures security but the user can retry
             return false;
         }
     }
     async refreshToken(baseUrl, refreshToken) {
         try {
             const url = `${baseUrl}/api/auth/refresh`;
-            console.log(colors.info(`[DEBUG] Refreshing token with: ${url}`));
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({ refreshToken })
+            const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+            const response = await axios.post(url, { refreshToken }, {
+                httpsAgent,
+                timeout: 10000
             });
-            if (response.ok) {
-                const data = await response.json();
-                console.log(colors.success(`[DEBUG] Token refreshed successfully`));
+            if (response.status === 200) {
+                const data = response.data;
                 return data.token || null;
             }
             else {
-                console.log(colors.warning(`[DEBUG] Token refresh failed: ${response.status}`));
                 return null;
             }
         }
         catch (error) {
-            console.log(colors.warning(`[DEBUG] Token refresh error: ${error}`));
             return null;
         }
     }
@@ -377,7 +437,7 @@ export class InteractiveSession {
         if (this._isShuttingDown) {
             return;
         }
-        // Recreate readline interface
+        // Recreate readline interface for input
         if (this.rl) {
             this.rl.close();
         }
@@ -414,7 +474,7 @@ export class InteractiveSession {
             const handled = await this.slashCommandHandler.handleCommand(trimmedInput);
             if (handled) {
                 this.executionMode = this.configManager.getApprovalMode() || this.configManager.getExecutionMode();
-                // 同步对话历史到 slashCommandHandler
+                // Sync conversation history to slashCommandHandler
                 this.slashCommandHandler.setConversationHistory(this.conversation);
             }
             return;
@@ -490,9 +550,21 @@ export class InteractiveSession {
         const lastUserMessage = userMessage;
         this.conversation.push(userMessage);
         await this.conversationManager.addMessage(userMessage);
-        // 检查是否需要压缩上下文
+        // Check if context compression is needed
         await this.checkAndCompressContext(lastUserMessage);
-        await this.generateResponse(thinkingTokens);
+        // 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));
+        if (this.remoteAIClient) {
+            logger.debug('[DEBUG processUserMessage] Using generateRemoteResponse');
+            await this.generateRemoteResponse(thinkingTokens);
+        }
+        else {
+            logger.debug('[DEBUG processUserMessage] Using generateResponse (local mode)');
+            await this.generateResponse(thinkingTokens);
+        }
     }
     displayThinkingContent(reasoningContent) {
         const indent = this.getIndent();
@@ -533,7 +605,7 @@ export class InteractiveSession {
         console.log('');
     }
     /**
-     * 检查并压缩对话上下文
+     * Check and compress conversation context
      */
     async checkAndCompressContext(lastUserMessage) {
         const compressionConfig = this.configManager.getContextCompressionConfig();
@@ -554,7 +626,7 @@ export class InteractiveSession {
                 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;
@@ -574,11 +646,11 @@ export class InteractiveSession {
                     }
                     console.log(`${indent}${colors.border(separator)}`);
                 }
-                // 压缩后恢复用户消息，确保 API 调用时有 user 消息
+                // Restore user messages after compression, ensuring user message exists for API calls
                 if (lastUserMessage) {
                     this.conversation.push(lastUserMessage);
                 }
-                // 同步压缩后的对话历史到 slashCommandHandler
+                // Sync compressed conversation history to slashCommandHandler
                 this.slashCommandHandler.setConversationHistory(this.conversation);
             }
         }
@@ -626,8 +698,51 @@ export class InteractiveSession {
             console.log(`${indent}${colors.error(`Command execution failed: ${error.message}`)}`);
         }
     }
-    async generateResponse(thinkingTokens = 0) {
+    /**
+     * Create unified LLM Caller
+     * Implement transparency: caller doesn't need to care about remote vs local mode
+     */
+    createLLMCaller(taskId, status) {
+        // Remote mode: use RemoteAIClient
+        if (this.remoteAIClient) {
+            return this.createRemoteCaller(taskId, status);
+        }
+        // Local mode: use AIClient
         if (!this.aiClient) {
+            throw new Error('AI client not initialized');
+        }
+        return this.createLocalCaller();
+    }
+    /**
+     * Create remote mode LLM caller
+     */
+    createRemoteCaller(taskId, status) {
+        const client = this.remoteAIClient;
+        return {
+            chatCompletion: (messages, options) => client.chatCompletion(messages, { ...options, taskId, status }),
+            isRemote: true
+        };
+    }
+    /**
+     * Create local mode LLM caller
+     */
+    createLocalCaller() {
+        const client = this.aiClient;
+        return {
+            chatCompletion: (messages, options) => client.chatCompletion(messages, options),
+            isRemote: false
+        };
+    }
+    async generateResponse(thinkingTokens = 0) {
+        // Create taskId for this user interaction (for remote mode tracking)
+        const taskId = crypto.randomUUID();
+        this.currentTaskId = taskId;
+        this.isFirstApiCall = true;
+        // Determine status based on whether this is the first API call
+        const status = this.isFirstApiCall ? 'begin' : 'continue';
+        // Use unified LLM Caller with taskId (automatically selects local or remote mode)
+        const { chatCompletion, isRemote } = this.createLLMCaller(taskId, status);
+        if (!isRemote && !this.aiClient) {
             console.log(colors.error('AI client not initialized'));
             return;
         }
@@ -650,66 +765,38 @@ export class InteractiveSession {
                 ? this.agentManager.getAvailableToolsForAgent(this.currentAgent, this.executionMode)
                 : [];
             // MCP servers are already connected during initialization (eager mode)
-            const allLocalToolDefinitions = toolRegistry.getToolDefinitions();
-            const mcpToolDefinitions = this.mcpManager.getToolDefinitions();
-            // Merge local tools and MCP tools
-            const allToolDefinitions = [...allLocalToolDefinitions, ...mcpToolDefinitions];
+            // MCP tools are already registered as local tools via registerMCPTools
+            const toolDefinitions = toolRegistry.getToolDefinitions();
+            // Available tools for this session
             const availableTools = this.executionMode !== ExecutionMode.DEFAULT && allowedToolNames.length > 0
-                ? allToolDefinitions.filter((tool) => allowedToolNames.includes(tool.function.name))
-                : allToolDefinitions;
+                ? toolDefinitions.filter((tool) => allowedToolNames.includes(tool.function.name))
+                : toolDefinitions;
             const baseSystemPrompt = this.currentAgent?.systemPrompt;
-            const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+            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}` },
+                { role: 'system', content: `${enhancedSystemPrompt}\n\n${memory}`, timestamp: Date.now() },
                 ...this.conversation.map(msg => ({
                     role: msg.role,
-                    content: msg.content
+                    content: msg.content,
+                    timestamp: msg.timestamp
                 }))
             ];
-            // Debug: 打印完整的 prompt 信息
-            // const logger = new Logger({ minLevel: LogLevel.DEBUG });
-            // logger.debug('[DEBUG] 即将发送给 AI 的完整 Prompt:');
-            // console.log('\n' + '='.repeat(60));
-            // console.log('【SYSTEM PROMPT】');
-            // console.log('-'.repeat(60));
-            // console.log(messages[0]?.content || '(无)');
-            // console.log('='.repeat(60));
-            // console.log('【CONVERSATION】');
-            // console.log('-'.repeat(60));
-            // messages.slice(1).forEach((msg, idx) => {
-            //   const contentStr = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
-            //   console.log(`[${idx + 1}] [${msg.role}]: ${contentStr.substring(0, 200)}${contentStr.length > 200 ? '...' : ''}`);
-            // });
-            // console.log('='.repeat(60));
-            // console.log(`【AVAILABLE TOOLS】: ${availableTools.length} 个工具`);
-            // availableTools.forEach((tool: any) => {
-            //   console.log(`  - ${tool.function.name}`);
-            // });      // console.log('='.repeat(60) + '\n');
-            // Debug: 打印AI输入信息 (已移至 ai-client.ts)
-            // if (this.configManager.get('showAIDebugInfo')) {
-            //   this.displayAIDebugInfo('INPUT', messages, availableTools);
-            // }
             const operationId = `ai-response-${Date.now()}`;
-            const responsePromise = this.aiClient.chatCompletion(messages, {
+            const response = await this.cancellationManager.withCancellation(chatCompletion(messages, {
                 tools: availableTools,
                 toolChoice: availableTools.length > 0 ? 'auto' : 'none',
                 thinkingTokens
-            });
-            const response = await this.cancellationManager.withCancellation(responsePromise, operationId);
+            }), 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;
-            // Debug: 打印AI输出信息 (已移至 ai-client.ts)
-            // if (this.configManager.get('showAIDebugInfo')) {
-            //   this.displayAIDebugInfo('OUTPUT', response, assistantMessage);
-            // }
             const content = typeof assistantMessage.content === 'string'
                 ? assistantMessage.content
                 : '';
             const reasoningContent = assistantMessage.reasoning_content || '';
-            // console.error('[SESSION DEBUG] assistantMessage:', JSON.stringify(assistantMessage).substring(0, 200));
-            // console.error('[SESSION DEBUG] content:', content);
             // Display reasoning content if available and thinking mode is enabled
             if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
                 this.displayThinkingContent(reasoningContent);
@@ -751,10 +838,216 @@ export class InteractiveSession {
             // Clear the operation flag
             this._isOperationInProgress = false;
             if (error.message === 'Operation cancelled by user') {
-                // Message is already logged by CancellationManager
+                // Mark task as cancelled
+                if (this.remoteAIClient && this.currentTaskId) {
+                    await this.remoteAIClient.cancelTask(this.currentTaskId);
+                }
                 return;
             }
+            // Mark task as cancelled when error occurs (发送 status: 'cancel')
+            logger.debug(`[Session] Task failed: taskId=${this.currentTaskId}, error: ${error.message}`);
+            if (this.remoteAIClient && this.currentTaskId) {
+                await this.remoteAIClient.cancelTask(this.currentTaskId);
+            }
+            console.log(colors.error(`Error: ${error.message}`));
+        }
+    }
+    /**
+     * Generate response using remote AI service（OAuth XAGENT 模式）
+     * Support full tool calling loop
+     * 与本地模式 generateResponse 保持一致
+     * @param thinkingTokens - Optional thinking tokens config
+     * @param existingTaskId - Optional existing taskId to reuse (for tool call continuation)
+     */
+    async generateRemoteResponse(thinkingTokens = 0, existingTaskId) {
+        // Reuse existing taskId or create new one for this user interaction
+        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';
+        logger.debug(`[Session] Status for this call: ${status}, isFirstApiCall=${this.isFirstApiCall}`);
+        // 使用统一的 LLM Caller
+        const { chatCompletion, isRemote } = this.createLLMCaller(taskId, status);
+        if (!isRemote) {
+            // 如果不是远程模式，回退到本地模式
+            return this.generateResponse(thinkingTokens);
+        }
+        const indent = this.getIndent();
+        const thinkingText = colors.textMuted(`Thinking... (Press ESC to cancel)`);
+        const icon = colors.primary(icons.brain);
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let frameIndex = 0;
+        // Mark that an operation is in progress
+        this._isOperationInProgress = true;
+        // Custom spinner: only icon rotates, text stays static
+        const spinnerInterval = setInterval(() => {
+            process.stdout.write(`\r${colors.primary(frames[frameIndex])} ${icon} ${thinkingText}`);
+            frameIndex = (frameIndex + 1) % frames.length;
+        }, 120);
+        try {
+            // Load memory (与本地模式一致)
+            const memory = await this.memoryManager.loadMemory();
+            // Get tool definitions
+            const toolRegistry = getToolRegistry();
+            const allowedToolNames = this.currentAgent
+                ? this.agentManager.getAvailableToolsForAgent(this.currentAgent, this.executionMode)
+                : [];
+            const allToolDefinitions = toolRegistry.getToolDefinitions();
+            const availableTools = this.executionMode !== ExecutionMode.DEFAULT && allowedToolNames.length > 0
+                ? allToolDefinitions.filter((tool) => allowedToolNames.includes(tool.function.name))
+                : allToolDefinitions;
+            // Convert to the format expected by backend (与本地模式一致使用 availableTools)
+            const tools = availableTools.map((tool) => ({
+                type: 'function',
+                function: {
+                    name: tool.function.name,
+                    description: tool.function.description || '',
+                    parameters: tool.function.parameters || {
+                        type: 'object',
+                        properties: {}
+                    }
+                }
+            }));
+            // Generate system prompt (与本地模式一致)
+            const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
+            const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+            const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
+            // Build messages with system prompt (与本地模式一致)
+            const messages = [
+                { role: 'system', content: `${enhancedSystemPrompt}\n\n${memory}`, timestamp: Date.now() },
+                ...this.conversation.map(msg => ({
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: msg.timestamp
+                }))
+            ];
+            // Call unified LLM API with cancellation support
+            const operationId = `remote-ai-response-${Date.now()}`;
+            const response = await this.cancellationManager.withCancellation(chatCompletion(messages, {
+                tools,
+                toolChoice: tools.length > 0 ? 'auto' : 'none',
+                thinkingTokens
+            }), operationId);
+            // Mark that first API call is complete
+            this.isFirstApiCall = false;
+            clearInterval(spinnerInterval);
+            process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+            console.log('');
+            // 使用统一的响应格式（与本地模式一致）
+            const assistantMessage = response.choices[0].message;
+            const content = typeof assistantMessage.content === 'string'
+                ? assistantMessage.content
+                : '';
+            const reasoningContent = assistantMessage.reasoning_content || '';
+            const toolCalls = assistantMessage.tool_calls || [];
+            // Display reasoning content if available and thinking mode is enabled (与本地模式一致)
+            if (reasoningContent && this.configManager.getThinkingConfig().enabled) {
+                this.displayThinkingContent(reasoningContent);
+            }
+            console.log(`${indent}${colors.primaryBright(`${icons.robot} Assistant:`)}`);
+            console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
+            console.log('');
+            const renderedContent = renderMarkdown(content, (process.stdout.columns || 80) - indent.length * 2);
+            console.log(`${indent}${renderedContent.replace(/^/gm, indent)}`);
+            console.log('');
+            // Add assistant message to conversation (consistent with local mode, including reasoningContent)
+            this.conversation.push({
+                role: 'assistant',
+                content,
+                timestamp: Date.now(),
+                reasoningContent,
+                toolCalls: toolCalls
+            });
+            // Record output to session manager (consistent with local mode, including reasoningContent and toolCalls)
+            await this.sessionManager.addOutput({
+                role: 'assistant',
+                content,
+                timestamp: Date.now(),
+                reasoningContent,
+                toolCalls
+            });
+            // Handle tool calls
+            if (toolCalls.length > 0) {
+                await this.handleRemoteToolCalls(toolCalls);
+            }
+            // Checkpoint support (consistent with local mode)
+            if (this.checkpointManager.isEnabled()) {
+                await this.checkpointManager.createCheckpoint(`Response generated at ${new Date().toLocaleString()}`, [...this.conversation], [...this.toolCalls]);
+            }
+            // Operation completed successfully
+            this._isOperationInProgress = false;
+            // Mark task as completed (发送 status: 'end')
+            logger.debug(`[Session] Task completed: taskId=${this.currentTaskId}`);
+            if (this.remoteAIClient && this.currentTaskId) {
+                await this.remoteAIClient.completeTask(this.currentTaskId);
+            }
+        }
+        catch (error) {
+            clearInterval(spinnerInterval);
+            process.stdout.write('\r' + ' '.repeat(process.stdout.columns || 80) + '\r');
+            // Clear the operation flag
+            this._isOperationInProgress = false;
+            if (error.message === 'Operation cancelled by user') {
+                return;
+            }
+            // Handle token invalid error - trigger re-authentication
+            if (error instanceof TokenInvalidError) {
+                console.log('');
+                console.log(colors.warning('⚠️  Authentication expired or invalid'));
+                console.log(colors.info('Your browser session has been logged out. Please log in again.'));
+                console.log('');
+                // Clear invalid credentials and persist
+                // Note: Do NOT overwrite selectedAuthType - preserve user's chosen auth method
+                await this.configManager.set('apiKey', '');
+                await this.configManager.set('refreshToken', '');
+                await 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();
+                const authConfig = this.configManager.getAuthConfig();
+                logger.debug('[DEBUG generateRemoteResponse] After re-auth:');
+                logger.debug('  - authConfig.apiKey exists:', !!authConfig.apiKey ? 'true' : 'false');
+                logger.debug('  - authConfig.apiKey prefix:', authConfig.apiKey ? authConfig.apiKey.substring(0, 20) + '...' : 'empty');
+                // Recreate readline interface after inquirer
+                this.rl.close();
+                this.rl = readline.createInterface({
+                    input: process.stdin,
+                    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://154.8.140.52:443';
+                    logger.debug('[DEBUG generateRemoteResponse] Reinitializing RemoteAIClient with new token');
+                    const newWebBaseUrl = authConfig.xagentApiBaseUrl || 'https://154.8.140.52:443';
+                    this.remoteAIClient = new RemoteAIClient(authConfig.apiKey, newWebBaseUrl, authConfig.showAIDebugInfo);
+                }
+                else {
+                    logger.debug('[DEBUG generateRemoteResponse] WARNING: No apiKey after re-authentication!');
+                }
+                // 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}`);
+            if (this.remoteAIClient && this.currentTaskId) {
+                await this.remoteAIClient.cancelTask(this.currentTaskId);
+            }
             console.log(colors.error(`Error: ${error.message}`));
+            return;
         }
     }
     async handleToolCalls(toolCalls) {
@@ -819,9 +1112,9 @@ export class InteractiveSession {
                 if (isTodoTool) {
                     console.log('');
                     console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
-                    console.log(this.renderTodoList(result.todos || result.todos, displayIndent));
+                    console.log(this.renderTodoList(result?.todos || [], displayIndent));
                     // Show summary if available
-                    if (result.message) {
+                    if (result?.message) {
                         console.log(`${displayIndent}${colors.textDim(result.message)}`);
                     }
                 }
@@ -830,13 +1123,16 @@ export class InteractiveSession {
                     console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
                     console.log(`${displayIndent}${colors.textDim(JSON.stringify(result, null, 2))}`);
                 }
-                else if (result.success === false) {
+                else if (result && result.success === false) {
                     // GUI task or other tool failed
                     console.log(`${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`);
                 }
-                else {
+                else if (result) {
                     console.log(`${displayIndent}${colors.success(`${icons.check} Completed`)}`);
                 }
+                else {
+                    console.log(`${displayIndent}${colors.textDim('(no result)')}`);
+                }
                 const toolCallRecord = {
                     tool,
                     params,
@@ -909,6 +1205,136 @@ export class InteractiveSession {
         const getDescription = descriptions[toolName];
         return getDescription ? getDescription(params) : `Execute tool: ${toolName}`;
     }
+    /**
+     * Handle tool calls for remote AI mode
+     * Executes tools and then continues the conversation with results
+     */
+    async handleRemoteToolCalls(toolCalls) {
+        // Mark that tool execution is in progress
+        this._isOperationInProgress = true;
+        const toolRegistry = getToolRegistry();
+        const showToolDetails = this.configManager.get('showToolDetails') || false;
+        const indent = this.getIndent();
+        // Prepare all tool calls
+        const preparedToolCalls = toolCalls.map((toolCall, index) => {
+            const { name, arguments: params } = toolCall.function;
+            let parsedParams;
+            try {
+                parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
+            }
+            catch (e) {
+                parsedParams = params;
+            }
+            return { name, params: parsedParams, index };
+        });
+        // Display all tool calls info
+        for (const { name, params } of preparedToolCalls) {
+            if (showToolDetails) {
+                console.log('');
+                console.log(`${indent}${colors.warning(`${icons.tool} Tool Call: ${name}`)}`);
+                console.log(`${indent}${colors.textDim(JSON.stringify(params, null, 2))}`);
+            }
+            else {
+                const toolDescription = this.getToolDescription(name, params);
+                console.log('');
+                console.log(`${indent}${colors.textMuted(`${icons.loading} ${toolDescription}`)}`);
+            }
+        }
+        // Execute all tools in parallel
+        const results = await toolRegistry.executeAll(preparedToolCalls.map(tc => ({ name: tc.name, params: tc.params })), this.executionMode);
+        // Process results and maintain order
+        let hasError = false;
+        for (const { tool, result, error } of results) {
+            const toolCall = preparedToolCalls.find(tc => tc.name === tool);
+            if (!toolCall)
+                continue;
+            const { params } = toolCall;
+            if (error) {
+                // Clear the operation flag
+                this._isOperationInProgress = false;
+                if (error === 'Operation cancelled by user') {
+                    return;
+                }
+                hasError = true;
+                console.log('');
+                console.log(`${indent}${colors.error(`${icons.cross} Tool Error: ${error}`)}`);
+                this.conversation.push({
+                    role: 'tool',
+                    content: JSON.stringify({ error }),
+                    timestamp: Date.now()
+                });
+            }
+            else {
+                // Use correct indent for gui-subagent tasks
+                const isGuiSubagent = tool === 'task' && params?.subagent_type === 'gui-subagent';
+                const displayIndent = isGuiSubagent ? indent + '  ' : indent;
+                // Always show details for todo tools so users can see their task lists
+                const isTodoTool = tool === 'todo_write' || tool === 'todo_read';
+                if (isTodoTool) {
+                    console.log('');
+                    console.log(`${displayIndent}${colors.success(`${icons.check} Todo List:`)}`);
+                    console.log(this.renderTodoList(result.todos || result.todos, displayIndent));
+                    // Show summary if available
+                    if (result.message) {
+                        console.log(`${displayIndent}${colors.textDim(result.message)}`);
+                    }
+                }
+                else if (showToolDetails) {
+                    console.log('');
+                    console.log(`${displayIndent}${colors.success(`${icons.check} Tool Result:`)}`);
+                    console.log(`${displayIndent}${colors.textDim(JSON.stringify(result, null, 2))}`);
+                }
+                else if (result.success === false) {
+                    // GUI task or other tool failed
+                    console.log(`${displayIndent}${colors.error(`${icons.cross} ${result.message || 'Failed'}`)}`);
+                }
+                else {
+                    console.log(`${displayIndent}${colors.success(`${icons.check} Completed`)}`);
+                }
+                const toolCallRecord = {
+                    tool,
+                    params,
+                    result,
+                    timestamp: Date.now()
+                };
+                this.toolCalls.push(toolCallRecord);
+                // Record tool output to session manager
+                await this.sessionManager.addOutput({
+                    role: 'tool',
+                    content: JSON.stringify(result),
+                    toolName: tool,
+                    toolParams: params,
+                    toolResult: result,
+                    timestamp: Date.now()
+                });
+                this.conversation.push({
+                    role: 'tool',
+                    content: JSON.stringify(result),
+                    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 guiSubagentFailed = preparedToolCalls.some(tc => tc.name === 'task' && tc.params?.subagent_type === 'gui-subagent');
+        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;
+        }
+        // If any tool call failed, throw error to mark task as cancelled
+        if (hasError) {
+            throw new Error('Tool execution failed');
+        }
+        // For all other cases (GUI success/failure, other tool errors), return results to main agent
+        // This allows main agent to decide how to handle failures (retry, fallback, user notification, etc.)
+        // Reuse existing taskId instead of generating new one
+        await this.generateRemoteResponse(0, this.currentTaskId || undefined);
+    }
     /**
      * Truncate path for display
      */
@@ -953,7 +1379,7 @@ export class InteractiveSession {
     /**
      * Display AI debug information (input or output)
      */
-    // AI 调试信息已移至 ai-client.ts 实现
+    // AI debug info moved to ai-client.ts implementation
     // private displayAIDebugInfo(type: 'INPUT' | 'OUTPUT', data: any, extra?: any): void {
     //   const indent = this.getIndent();
     //   const boxChar = {
@@ -978,16 +1404,15 @@ export class InteractiveSession {
     //     // System prompt
     //     const systemMsg = messages.find((m: any) => m.role === 'system');
     //     console.log(colors.border(`${boxChar.vertical}`) + ' 🟫 SYSTEM: ' +
-    //       colors.textMuted(systemMsg?.content?.toString().substring(0, 50) || '(无)') + ' '.repeat(3) + colors.border(boxChar.vertical));
+    //       colors.textMuted(systemMsg?.content?.toString().substring(0, 50) || '(none)') + ' '.repeat(3) + colors.border(boxChar.vertical));
     //
     //     // Messages count
     //     console.log(colors.border(`${boxChar.vertical}`) + ' 💬 MESSAGES: ' +
-    //       colors.text(messages.length.toString()) + ' 条' + ' '.repeat(40) + colors.border(boxChar.vertical));
+    //       colors.text(messages.length.toString()) + ' items' + ' '.repeat(40) + colors.border(boxChar.vertical));
     //
     //     // Tools count
     //     console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOLS: ' +
-    //       colors.text((tools?.length || 0).toString()) + ' 个' + ' '.repeat(43) + colors.border(boxChar.vertical));
-    //
+    //       colors.text((tools?.length || 0).toString()) + '' + ' '.repeat(43) + colors.border(boxChar.vertical));  //
     //     // Show last 2 messages
     //     const recentMessages = messages.slice(-2);
     //     for (const msg of recentMessages) {
@@ -1011,8 +1436,8 @@ export class InteractiveSession {
     //       colors.text(`Prompt: ${response.usage?.prompt_tokens || '?'}, Completion: ${response.usage?.completion_tokens || '?'}`) +
     //       ' '.repeat(15) + colors.border(boxChar.vertical));
     //
-    //     console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOL_CALLS: ' +
-    //       colors.text((message.tool_calls?.length || 0).toString()) + ' 个' + ' '.repeat(37) + colors.border(boxChar.vertical));
+    // console.log(colors.border(`${boxChar.vertical}`) + ' 🔧 TOOL_CALLS: ' +
+    //   colors.text((message.tool_calls?.length || 0).toString()) + '' + ' '.repeat(37) + colors.border(boxChar.vertical));
     //
     //     // Content preview
     //     const contentStr = typeof message.content === 'string'
@@ -1028,8 +1453,8 @@ export class InteractiveSession {
     // }
     shutdown() {
         this.rl.close();
-        this.mcpManager.disconnectAllServers();
         this.cancellationManager.cleanup();
+        this.mcpManager.disconnectAllServers();
         // End the current session
         this.sessionManager.completeCurrentSession();
         const separator = icons.separator.repeat(40);
@@ -1039,6 +1464,20 @@ export class InteractiveSession {
         console.log(colors.border(separator));
         console.log('');
     }
+    /**
+     * Get the RemoteAIClient instance
+     * Used by tools.ts to access the remote AI client for GUI operations
+     */
+    getRemoteAIClient() {
+        return this.remoteAIClient;
+    }
+    /**
+     * Get the current taskId for this user interaction
+     * Used by GUI operations to track the same task
+     */
+    getTaskId() {
+        return this.currentTaskId;
+    }
 }
 export async function startInteractiveSession() {
     const session = new InteractiveSession();
@@ -1078,4 +1517,12 @@ export async function startInteractiveSession() {
     });
     await session.start();
 }
+// Singleton session instance for access from other modules
+let singletonSession = null;
+export function setSingletonSession(session) {
+    singletonSession = session;
+}
+export function getSingletonSession() {
+    return singletonSession;
+}
 //# sourceMappingURL=session.js.map