@xagent-ai/cli 1.2.2 → 1.3.1

package/src/tools.ts

@@ -1,21 +1,22 @@
 import fs from 'fs/promises';
+import { select, text } from '@clack/prompts';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import readline from 'readline';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
+import { spawn } from 'child_process';
 import { glob } from 'glob';
 import axios from 'axios';
-import inquirer from 'inquirer';
 import { Tool, ExecutionMode, AuthType } from './types.js';
-import type { Message, ToolDefinition } from './ai-client.js';
-import { colors, icons, styleHelpers } from './theme.js';
+import type { Message, ToolDefinition } from './ai-client/types.js';
+import { colors, icons } from './theme.js';
 import { getLogger } from './logger.js';
 import { getCancellationManager } from './cancellation.js';
 import { SystemPromptGenerator } from './system-prompt-generator.js';
-import { InteractiveSession } from './session.js';
-
-const execAsync = promisify(exec);
+import { getSingletonSession } from './session.js';
+import { ripgrep, fdFind } from './ripgrep.js';
+import { getShellConfig, killProcessTree, quoteShellCommand } from './shell.js';
+import { truncateTail, buildTruncationNotice } from './truncate.js';
+import { createAIClient } from './ai-client-factory.js';
 
 //
 // Tool Description Pattern
@@ -70,9 +71,17 @@ export class ReadTool implements Tool {
 - Combine with ListDirectory to explore project structure first
 - Don't re-read files unnecessarily`;
 
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: { filePath: string; offset?: number; limit?: number }): Promise<string> {
+    if (!params || typeof params.filePath !== 'string') {
+      throw new Error('filePath is required and must be a string');
+    }
     const { filePath, offset = 0, limit } = params;
 
     try {
@@ -89,13 +98,24 @@ export class ReadTool implements Tool {
       }
       const absolutePath = path.resolve(resolvedPath);
       const content = await fs.readFile(absolutePath, 'utf-8');
-      
+
       const lines = content.split('\n');
+      const totalLines = lines.length;
       const startLine = Math.max(0, offset);
-      const endLine = limit !== undefined ? Math.min(lines.length, startLine + limit) : lines.length;
+      const endLine = limit !== undefined ? Math.min(totalLines, startLine + limit) : totalLines;
       const selectedLines = lines.slice(startLine, endLine);
-      
-      return selectedLines.join('\n');
+      const result = selectedLines.join('\n');
+
+      // Add truncation notice if content is limited
+      if (limit !== undefined && endLine < totalLines) {
+        const remaining = totalLines - endLine;
+        const nextOffset = endLine;
+        return (
+          result + `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue]`
+        );
+      }
+
+      return result;
     } catch (error: any) {
       // Show user-friendly path in error message
       let displayPath = filePath;
@@ -142,7 +162,16 @@ export class WriteTool implements Tool {
 - For partial edits, use Edit tool instead`;
   allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
 
-  async execute(params: { filePath: string; content: string }): Promise<{ success: boolean; message: string; filePath: string; lineCount: number; preview?: string }> {
+  async execute(params: {
+    filePath: string;
+    content: string;
+  }): Promise<{
+    success: boolean;
+    message: string;
+    filePath: string;
+    lineCount: number;
+    preview?: string;
+  }> {
     const { filePath, content } = params;
 
     try {
@@ -161,7 +190,7 @@ export class WriteTool implements Tool {
         message: `Successfully wrote to ${filePath}`,
         filePath,
         lineCount,
-        preview: isTruncated ? preview + '\n...' : preview
+        preview: isTruncated ? preview + '\n...' : preview,
       };
     } catch (error: any) {
       throw new Error(`Failed to write file ${filePath}: ${error.message}`);
@@ -171,7 +200,7 @@ export class WriteTool implements Tool {
 
 export class GrepTool implements Tool {
   name = 'Grep';
-  description = `Search for text patterns within files using regex or literal string matching. This is your PRIMARY tool for finding specific code, functions, or content.
+  description = `Search for text patterns within files using ripgrep. This is your PRIMARY tool for finding specific code, functions, or content.
 
 # When to Use
 - Finding specific function definitions or calls
@@ -188,122 +217,60 @@ export class GrepTool implements Tool {
 # Parameters
 - \`pattern\`: Regex or literal string to search for
 - \`path\`: (Optional) Directory to search in, default: "."
-- \`include\`: (Optional) File glob pattern to include
-- \`exclude\`: (Optional) File glob pattern to exclude
-- \`case_sensitive\`: (Optional) Case-sensitive search, default: false
-- \`fixed_strings\`: (Optional) Treat pattern as literal string, default: false
+- \`glob\`: (Optional) File glob pattern to include (e.g., "*.ts", "**/*.js")
+- \`ignoreCase\`: (Optional) Case-insensitive search, default: false
+- \`literal\`: (Optional) Treat pattern as literal string, default: false
 - \`context\`: (Optional) Lines of context before/after matches
-- \`no_ignore\`: (Optional) Don't ignore node_modules/.git, default: false
 
 # Examples
 - Find function: Grep(pattern="function myFunction")
 - Find with context: Grep(pattern="TODO", context=3)
-- TypeScript only: Grep(pattern="interface", include="*.ts")
+- TypeScript only: Grep(pattern="interface", glob="*.ts")
+- Case-insensitive: Grep(pattern="error", ignoreCase=true)
 
 # Best Practices
-- Use case_sensitive=true for short patterns to reduce false positives
-- Use fixed_strings=true if your pattern has special regex characters
+- Use ignoreCase=true for short patterns to reduce false positives
+- Use literal=true if your pattern has special regex characters
 - Use context to see the surrounding code for each match
-- Combine with include/exclude to narrow down file types`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+- Combine with glob to narrow down file types`;
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: {
     pattern: string;
     path?: string;
-    include?: string;
-    exclude?: string;
-    case_sensitive?: boolean;
-    fixed_strings?: boolean;
+    glob?: string;
+    ignoreCase?: boolean;
+    literal?: boolean;
     context?: number;
-    after?: number;
-    before?: number;
-    no_ignore?: boolean;
+    limit?: number;
   }): Promise<string[]> {
     const {
       pattern,
       path: searchPath = '.',
-      include,
-      exclude,
-      case_sensitive = false,
-      fixed_strings = false,
+      glob: includeGlob,
+      ignoreCase = false,
+      literal = false,
       context,
-      after,
-      before,
-      no_ignore = false
+      limit,
     } = params;
-    
+
     try {
-      const ignorePatterns = no_ignore ? [] : ['node_modules/**', '.git/**', 'dist/**', 'build/**'];
-      if (exclude) {
-        ignorePatterns.push(exclude);
-      }
-      
-      const absolutePath = path.resolve(searchPath);
-      const files = await glob('**/*', {
-        cwd: absolutePath,
-        nodir: true,
-        ignore: ignorePatterns
+      const result = await ripgrep({
+        pattern,
+        path: searchPath,
+        glob: includeGlob,
+        ignoreCase,
+        literal,
+        context,
+        limit,
       });
 
-      const results: string[] = [];
-      
-      for (const file of files) {
-        const fullPath = path.join(absolutePath, file);
-        if (include && !file.match(include)) {
-          continue;
-        }
-        
-        try {
-          const content = await fs.readFile(fullPath, 'utf-8');
-          const lines = content.split('\n');
-          
-          lines.forEach((line, index) => {
-            let matches = false;
-            
-            if (fixed_strings) {
-              matches = case_sensitive 
-                ? line.includes(pattern)
-                : line.toLowerCase().includes(pattern.toLowerCase());
-            } else {
-              try {
-                const flags = case_sensitive ? 'g' : 'gi';
-                const regex = new RegExp(pattern, flags);
-                matches = regex.test(line);
-              } catch (e) {
-                matches = case_sensitive 
-                  ? line.includes(pattern)
-                  : line.toLowerCase().includes(pattern.toLowerCase());
-              }
-            }
-            
-            if (matches) {
-              const contextLines: string[] = [];
-              
-              if (before || context) {
-                const beforeCount = before || context || 0;
-                for (let i = Math.max(0, index - beforeCount); i < index; i++) {
-                  contextLines.push(`${fullPath}:${i + 1}:${lines[i].trim()}`);
-                }
-              }
-              
-              contextLines.push(`${fullPath}:${index + 1}:${line.trim()}`);
-              
-              if (after || context) {
-                const afterCount = after || context || 0;
-                for (let i = index + 1; i < Math.min(lines.length, index + 1 + afterCount); i++) {
-                  contextLines.push(`${fullPath}:${i + 1}:${lines[i].trim()}`);
-                }
-              }
-              
-              results.push(...contextLines);
-            }
-          });
-        } catch (error) {
-          continue;
-        }
-      }
-      
-      return results;
+      return result.split('\n').filter((line) => line.trim());
     } catch (error: any) {
       throw new Error(`Grep failed: ${error.message}`);
     }
@@ -335,13 +302,23 @@ export class BashTool implements Tool {
 - \`description\`: (Optional) Description of what the command does
 - \`timeout\`: (Optional) Timeout in seconds, default: 120
 - \`run_in_bg\`: (Optional) Run in background, default: false
+- \`skillPath\`: (Optional) Skill directory path - when provided, NODE_PATH will include the skill's node_modules for dependency resolution
 
 # Examples
 - Install dependencies: Bash(command="npm install", description="Install npm dependencies")
+- Run in skill directory with local deps: Bash(command="npm install docx", skillPath="~/.xagent/skills/docx")
+
+# NODE_PATH Resolution
+When \`skillPath\` is provided, the command will have access to:
+- \`<skillPath>/node_modules\` (skill's local dependencies)
+- xAgent's global node_modules
+
+This is useful when working with skills that have local dependencies.
 - Run tests: Bash(command="npm test", description="Run unit tests")
 - Build project: Bash(command="npm run build", description="Build the project")
 
 # Best Practices
+- To install npm packages that persist across sessions, use: \`XAGENT_USER_NPM=1 npm install <package>\`
 - Always provide a description for context
 - Set appropriate timeout for long-running commands
 - Use run_in_bg=true for commands that take a long time
@@ -355,14 +332,25 @@ export class BashTool implements Tool {
     description?: string;
     timeout?: number;
     run_in_bg?: boolean;
-  }): Promise<{ stdout: string; stderr: string; exitCode: number; taskId?: string }> {
-    const { command, cwd, description, timeout = 120, run_in_bg = false } = params;
-    
+    skillPath?: string;  // Skill directory path for NODE_PATH resolution
+  }): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    taskId?: string;
+    truncated?: boolean;
+    truncationNotice?: string;
+    skillPath?: string;
+  }> {
+    const { command, cwd, description, timeout = 120, run_in_bg = false, skillPath } = params;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    void description;
+
     // Determine effective working directory
     // Only use cwd if the command doesn't contain 'cd' (let LLM control directory)
     let effectiveCwd: string | undefined;
     const hasCdCommand = /cd\s+["']?[^"&|;]+["']?/.test(command);
-    
+
     if (cwd && !hasCdCommand) {
       // Command doesn't control its own directory, use provided cwd
       effectiveCwd = cwd;
@@ -373,82 +361,270 @@ export class BashTool implements Tool {
       // No cwd provided, use default
       effectiveCwd = undefined;
     }
-    
-    // Set up environment with NODE_PATH only for node commands
-    const nodeModulesPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'node_modules');
-    const env = {
+
+    // Resolve actual working directory
+    const actualCwd = effectiveCwd || process.cwd();
+
+    // Set up environment with NODE_PATH for node commands
+    const builtinNodeModulesPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'node_modules');
+
+    // Get user skills path from config (unified path: ~/.xagent/skills)
+    const { getConfigManager } = await import('./config.js');
+    const configManager = getConfigManager();
+    const userSkillsPath = configManager.getUserSkillsPath();
+
+    // Skill deps path: ~/.xagent/skills/{skillName}/node_modules
+    const builtinDepsPath = userSkillsPath ? path.join(userSkillsPath, 'builtin-deps') : null;
+
+    // Determine which node_modules to use
+    let skillNodeModulesPath: string | null = null;
+
+    // Priority 1: skillPath parameter (workspace scenario - LLM works in workspace, not skill dir)
+    if (skillPath) {
+      if (skillPath.includes('/builtin-deps/')) {
+        // Skill with deps in builtin-deps directory
+        const match = skillPath.match(/\/builtin-deps\/([^/]+)/);
+        if (match) {
+          skillNodeModulesPath = path.join(builtinDepsPath!, match[1], 'node_modules');
+        }
+      } else {
+        // Regular skill
+        skillNodeModulesPath = path.join(skillPath, 'node_modules');
+      }
+    }
+    // Priority 2: Check if we're inside a skill directory
+    else if (userSkillsPath && userSkillsPath.trim() && actualCwd.startsWith(userSkillsPath)) {
+      const relativePath = actualCwd.substring(userSkillsPath.length);
+      const pathParts = relativePath.split(path.sep).filter(Boolean);
+
+      if (pathParts.length > 0) {
+        if (pathParts[0] === 'builtin-deps' && pathParts.length > 1) {
+          // Skill with local deps in builtin-deps
+          const skillName = pathParts[1];
+          skillNodeModulesPath = path.join(builtinDepsPath!, skillName, 'node_modules');
+        } else {
+          // Regular skill
+          const skillName = pathParts[0];
+          const skillRoot = path.join(userSkillsPath, skillName);
+          try {
+            const skillMdPath = path.join(skillRoot, 'SKILL.md');
+            await fs.access(skillMdPath);
+            skillNodeModulesPath = path.join(skillRoot, 'node_modules');
+          } catch {
+            // Not a skill directory, skip
+          }
+        }
+      }
+    }
+
+    // Build NODE_PATH - skill's node_modules takes precedence (last-wins)
+    let nodePath: string;
+    if (skillNodeModulesPath) {
+      nodePath = `${skillNodeModulesPath}${path.delimiter}${builtinNodeModulesPath}`;
+    } else {
+      nodePath = builtinNodeModulesPath;
+    }
+
+    const env: Record<string, string> = {
       ...process.env,
-      NODE_PATH: nodeModulesPath
+      NODE_PATH: nodePath
     };
-    
-    // Only add NODE_PATH prefix for node commands
-    const isNodeCommand = /\bnode\b/.test(command);
-    const finalCommand = isNodeCommand 
-      ? `set NODE_PATH=${nodeModulesPath} && ${command}`
-      : command;
-    
+
+    // Handle npm install commands
+    const isNpmInstall = /\bnpm\s+install\b/i.test(command);
+    let finalCommand = command;
+
+    if (isNpmInstall && skillNodeModulesPath) {
+      // Install to skill's own node_modules
+      await fs.mkdir(skillNodeModulesPath, { recursive: true }).catch(() => {});
+      finalCommand = command.replace(/\bnpm\s+install\b/i, `npm install --prefix "${skillNodeModulesPath}"`);
+    }
+
+    // Get shell configuration (Windows Git Bash detection, etc.)
+    const { shell, args } = getShellConfig();
+
+    // Set up cross-platform encoding environment for command execution
+    if (process.platform === 'win32') {
+      // Windows: set code page to UTF-8 and ensure console output encoding
+      // chcp 65001 sets the console code page to UTF-8
+      // Use *>$null to suppress output (PowerShell-style, not CMD-style)
+      finalCommand = `chcp 65001 *>$null; [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${finalCommand}`;
+    } else {
+      // Unix/macOS: set locale to UTF-8 for proper encoding handling
+      finalCommand = `export LC_ALL=C.UTF-8; export LANG=C.UTF-8; export PYTHONIOENCODING=utf-8; ${finalCommand}`;
+    }
+
+    const shellArgs = [...args, quoteShellCommand(finalCommand)];
+
     try {
       if (run_in_bg) {
         const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        
-        const childProcess = spawn(finalCommand, {
+
+        const spawnOptions: any = {
           cwd: effectiveCwd || process.cwd(),
-          shell: true,
-          detached: true,
-          env
-        });
-        
+          env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        };
+
+        // On Windows, don't use detached mode for PowerShell as it breaks output piping
+        if (process.platform !== 'win32') {
+          spawnOptions.detached = true;
+        }
+
+        const childProcess = spawn(shell, shellArgs, spawnOptions);
+
         const output: string[] = [];
-        
+
         childProcess.stdout?.on('data', (data: Buffer) => {
           const text = data.toString();
           output.push(text);
         });
-        
+
         childProcess.stderr?.on('data', (data: Buffer) => {
           const text = data.toString();
           output.push(text);
         });
-        
-        childProcess.on('close', (code: number) => {
-          console.log(`Background task ${taskId} exited with code ${code}`);
+
+        childProcess.on('close', (_code: number) => {
+          // Silent cleanup - don't log to avoid noise during normal operation
+          // Note: On Windows with PowerShell, the shell process exits after
+          // the command completes
         });
-        
+
         const toolRegistry = getToolRegistry();
         (toolRegistry as any).addBackgroundTask(taskId, {
           process: childProcess,
           startTime: Date.now(),
-          output
+          output,
         });
-        
+
         return {
           stdout: '',
           stderr: '',
           exitCode: 0,
-          taskId
+          taskId,
         };
       } else {
-        const { stdout, stderr } = await execAsync(finalCommand, {
+        // Execute command with spawn for better control
+        const result = await this.spawnWithTimeout(shell, shellArgs, {
           cwd: effectiveCwd || process.cwd(),
-          maxBuffer: 1024 * 1024 * 10,
-          timeout: timeout * 1000,
-          env
+          env,
+          timeout,
         });
 
+        // Apply truncation to stdout and stderr separately
+        const stdoutResult = truncateTail(result.stdout);
+        const stderrResult = truncateTail(result.stderr);
+
+        const stdout = stdoutResult.content;
+        const stderr = stderrResult.content;
+        let truncationNotice = '';
+
+        if (stdoutResult.truncated) {
+          truncationNotice += buildTruncationNotice(stdoutResult) + '\n';
+        }
+        if (stderrResult.truncated) {
+          truncationNotice += buildTruncationNotice(stderrResult) + '\n';
+        }
+
         return {
           stdout,
           stderr,
-          exitCode: 0
+          exitCode: result.exitCode,
+          truncated: stdoutResult.truncated || stderrResult.truncated,
+          truncationNotice: truncationNotice || undefined,
         };
       }
     } catch (error: any) {
+      // Check if this was a timeout
+      if (error.message === 'timeout') {
+        return {
+          stdout: '',
+          stderr: 'Command timed out',
+          exitCode: -1,
+          truncated: false,
+        };
+      }
       return {
         stdout: error.stdout || '',
         stderr: error.stderr || error.message,
-        exitCode: error.code || 1
+        exitCode: error.code || 1,
       };
     }
   }
+
+  /**
+   * Execute a command with timeout support and proper process termination.
+   */
+  private spawnWithTimeout(
+    shell: string,
+    args: string[],
+    options: { cwd: string; env: NodeJS.ProcessEnv; timeout: number }
+  ): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    return new Promise((resolve, reject) => {
+      const { cwd, env, timeout } = options;
+      let timedOut = false;
+      let timeoutHandle: NodeJS.Timeout | undefined;
+
+      const spawnOptions: any = {
+        cwd,
+        env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      };
+
+      // On Windows, don't use detached mode for PowerShell as it breaks output piping
+      if (process.platform !== 'win32') {
+        spawnOptions.detached = true;
+      }
+
+      const child = spawn(shell, args, spawnOptions);
+
+      const stdoutChunks: Buffer[] = [];
+      const stderrChunks: Buffer[] = [];
+
+      // Set timeout if provided
+      if (timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          timedOut = true;
+          if (child.pid) {
+            killProcessTree(child.pid);
+          }
+        }, timeout * 1000);
+      }
+
+      // Stream stdout
+      child.stdout?.on('data', (data: Buffer) => {
+        stdoutChunks.push(data);
+      });
+
+      // Stream stderr
+      child.stderr?.on('data', (data: Buffer) => {
+        stderrChunks.push(data);
+      });
+
+      // Handle process exit
+      child.on('close', (code: number) => {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+
+        if (timedOut) {
+          reject(new Error('timeout'));
+          return;
+        }
+
+        resolve({
+          stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
+          stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+          exitCode: code ?? -1,
+        });
+      });
+
+      // Handle spawn errors
+      child.on('error', (err) => {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+        reject(err);
+      });
+    });
+  }
 }
 
 export class ListDirectoryTool implements Tool {
@@ -481,27 +657,32 @@ export class ListDirectoryTool implements Tool {
 - Results are absolute paths
 - Ignores node_modules and .git by default
 - Combine with Read to examine file contents`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: { path?: string; recursive?: boolean }): Promise<string[]> {
     const { path: dirPath = '.', recursive = false } = params;
-    
+
     try {
       const absolutePath = path.resolve(dirPath);
-      
+
       const stats = await fs.stat(absolutePath).catch(() => null);
       if (!stats || !stats.isDirectory()) {
         throw new Error(`Directory does not exist: ${dirPath}`);
       }
-      
+
       const pattern = recursive ? '**/*' : '*';
       const files = await glob(pattern, {
         cwd: absolutePath,
         nodir: false,
-        ignore: ['node_modules/**', '.git/**']
+        ignore: ['node_modules/**', '.git/**'],
       });
 
-      return files.map(file => path.join(absolutePath, file));
+      return files.map((file) => path.join(absolutePath, file));
     } catch (error: any) {
       throw new Error(`Failed to list directory: ${error.message}`);
     }
@@ -519,7 +700,7 @@ export interface SearchFilesResult {
 
 export class SearchFilesTool implements Tool {
   name = 'SearchFiles';
-  description = `Search for files matching a glob pattern. This is your PRIMARY tool for finding files by name or extension.
+  description = `Search for files matching a glob pattern using fd. This is your PRIMARY tool for finding files by name or extension.
 
 # When to Use
 - Finding all files of a certain type (*.ts, *.json, *.md)
@@ -554,17 +735,37 @@ export class SearchFilesTool implements Tool {
 - Combine with path parameter to search specific directories
 - Use limit parameter to avoid huge result sets
 - Results are file paths, not content (use Grep on results if needed)`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
-  async execute(params: { pattern: string; path?: string; limit?: number }): Promise<SearchFilesResult> {
+  async execute(params: {
+    pattern: string;
+    path?: string;
+    limit?: number;
+  }): Promise<SearchFilesResult> {
     const { pattern, path: searchPath = '.', limit = 1000 } = params;
 
     try {
-      const files = await glob(pattern, {
-        cwd: searchPath,
-        ignore: ['node_modules/**', '.git/**', 'dist/**', 'build/**']
+      const output = await fdFind({
+        pattern,
+        path: searchPath,
+        limit,
       });
 
+      if (output === 'No files found') {
+        return {
+          files: [],
+          total: 0,
+          truncated: false,
+        };
+      }
+
+      const files = output.split('\n').filter((line) => line.trim());
+
       const total = files.length;
       const truncated = total > limit;
       const result = truncated ? files.slice(0, limit) : files;
@@ -572,7 +773,7 @@ export class SearchFilesTool implements Tool {
       return {
         files: result,
         total,
-        truncated
+        truncated,
       };
     } catch (error: any) {
       throw new Error(`Search failed: ${error.message}`);
@@ -608,7 +809,9 @@ export class DeleteFileTool implements Tool {
 - This action is irreversible - be certain before executing`;
   allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
 
-  async execute(params: { filePath: string }): Promise<{ success: boolean; message: string; filePath: string }> {
+  async execute(params: {
+    filePath: string;
+  }): Promise<{ success: boolean; message: string; filePath: string }> {
     const { filePath } = params;
 
     try {
@@ -618,7 +821,7 @@ export class DeleteFileTool implements Tool {
       return {
         success: true,
         message: `Successfully deleted ${filePath}`,
-        filePath
+        filePath,
       };
     } catch (error: any) {
       throw new Error(`Failed to delete file ${filePath}: ${error.message}`);
@@ -654,16 +857,19 @@ export class CreateDirectoryTool implements Tool {
 - Consider the overall project structure before creating`;
   allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
 
-  async execute(params: { dirPath: string; recursive?: boolean }): Promise<{ success: boolean; message: string }> {
+  async execute(params: {
+    dirPath: string;
+    recursive?: boolean;
+  }): Promise<{ success: boolean; message: string }> {
     const { dirPath, recursive = true } = params;
-    
+
     try {
       const absolutePath = path.resolve(dirPath);
       await fs.mkdir(absolutePath, { recursive });
-      
+
       return {
         success: true,
-        message: `Successfully created directory ${dirPath}`
+        message: `Successfully created directory ${dirPath}`,
       };
     } catch (error: any) {
       throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
@@ -672,165 +878,169 @@ export class CreateDirectoryTool implements Tool {
 }
 
 // 编辑工具辅助函数
-function detectLineEnding(content: string): "\r\n" | "\n" {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1) return "\n";
-	if (crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
+function detectLineEnding(content: string): '\r\n' | '\n' {
+  const crlfIdx = content.indexOf('\r\n');
+  const lfIdx = content.indexOf('\n');
+  if (lfIdx === -1) return '\n';
+  if (crlfIdx === -1) return '\n';
+  return crlfIdx < lfIdx ? '\r\n' : '\n';
 }
 
 function normalizeToLF(text: string): string {
-	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
 }
 
-function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string {
-	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+function restoreLineEndings(text: string, ending: '\r\n' | '\n'): string {
+  return ending === '\r\n' ? text.replace(/\n/g, '\r\n') : text;
 }
 
 function normalizeForFuzzyMatch(text: string): string {
-	return (
-		text
-			.split("\n")
-			.map((line) => line.trimEnd())
-			.join("\n")
-			.replace(/['‘’""]/g, "'")
-			.replace(/["""]/g, '"')
-			.replace(/[—–‑−]/g, "-")
-			.replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ")
-	);
+  return text
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n')
+    .replace(/['‘’""]/g, "'")
+    .replace(/["""]/g, '"')
+    .replace(/[—–‑−]/g, '-')
+    .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, ' ');
 }
 
 interface FuzzyMatchResult {
-	found: boolean;
-	index: number;
-	matchLength: number;
-	usedFuzzyMatch: boolean;
-	contentForReplacement: string;
+  found: boolean;
+  index: number;
+  matchLength: number;
+  usedFuzzyMatch: boolean;
+  contentForReplacement: string;
 }
 
 function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult {
-	const exactIndex = content.indexOf(oldText);
-	if (exactIndex !== -1) {
-		return {
-			found: true,
-			index: exactIndex,
-			matchLength: oldText.length,
-			usedFuzzyMatch: false,
-			contentForReplacement: content,
-		};
-	}
-
-	const fuzzyContent = normalizeForFuzzyMatch(content);
-	const fuzzyOldText = normalizeForFuzzyMatch(oldText);
-	const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
-
-	if (fuzzyIndex === -1) {
-		return {
-			found: false,
-			index: -1,
-			matchLength: 0,
-			usedFuzzyMatch: false,
-			contentForReplacement: content,
-		};
-	}
-
-	return {
-		found: true,
-		index: fuzzyIndex,
-		matchLength: fuzzyOldText.length,
-		usedFuzzyMatch: true,
-		contentForReplacement: fuzzyContent,
-	};
+  const exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1) {
+    return {
+      found: true,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: false,
+      contentForReplacement: content,
+    };
+  }
+
+  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+
+  if (fuzzyIndex === -1) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content,
+    };
+  }
+
+  return {
+    found: true,
+    index: fuzzyIndex,
+    matchLength: fuzzyOldText.length,
+    usedFuzzyMatch: true,
+    contentForReplacement: fuzzyContent,
+  };
 }
 
 function stripBom(content: string): { bom: string; text: string } {
-	return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+  return content.startsWith('\uFEFF')
+    ? { bom: '\uFEFF', text: content.slice(1) }
+    : { bom: '', text: content };
 }
 
-async function generateDiffString(oldContent: string, newContent: string, contextLines = 4): Promise<{ diff: string; firstChangedLine: number | undefined }> {
-	const diffModule = await import("diff");
-	const parts = diffModule.diffLines(oldContent, newContent);
-	const output: string[] = [];
-
-	const oldLines = oldContent.split("\n");
-	const newLines = newContent.split("\n");
-	const maxLineNum = Math.max(oldLines.length, newLines.length);
-	const lineNumWidth = String(maxLineNum).length;
-
-	let oldLineNum = 1;
-	let newLineNum = 1;
-	let lastWasChange = false;
-	let firstChangedLine: number | undefined;
-
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		const raw = part.value.split("\n");
-		if (raw[raw.length - 1] === "") {
-			raw.pop();
-		}
-
-		if (part.added || part.removed) {
-			if (firstChangedLine === undefined) {
-				firstChangedLine = newLineNum;
-			}
-
-			for (const line of raw) {
-				if (part.added) {
-					const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
-					output.push(`+${lineNum} ${line}`);
-					newLineNum++;
-				} else {
-					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
-					output.push(`-${lineNum} ${line}`);
-					oldLineNum++;
-				}
-			}
-			lastWasChange = true;
-		} else {
-			const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
-
-			if (lastWasChange || nextPartIsChange) {
-				let linesToShow = raw;
-				let skipStart = 0;
-				let skipEnd = 0;
-
-				if (!lastWasChange) {
-					skipStart = Math.max(0, raw.length - contextLines);
-					linesToShow = raw.slice(skipStart);
-				}
-
-				if (!nextPartIsChange && linesToShow.length > contextLines) {
-					skipEnd = linesToShow.length - contextLines;
-					linesToShow = linesToShow.slice(0, contextLines);
-				}
-
-				if (skipStart > 0) {
-					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-					oldLineNum += skipStart;
-					newLineNum += skipStart;
-				}
-
-				for (const line of linesToShow) {
-					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
-					output.push(` ${lineNum} ${line}`);
-					oldLineNum++;
-					newLineNum++;
-				}
-
-				if (skipEnd > 0) {
-					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-				}
-			} else {
-				oldLineNum += raw.length;
-				newLineNum += raw.length;
-			}
-
-			lastWasChange = false;
-		}
-	}
-
-	return { diff: output.join("\n"), firstChangedLine };
+async function generateDiffString(
+  oldContent: string,
+  newContent: string,
+  contextLines = 4
+): Promise<{ diff: string; firstChangedLine: number | undefined }> {
+  const diffModule = await import('diff');
+  const parts = diffModule.diffLines(oldContent, newContent);
+  const output: string[] = [];
+
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+  const maxLineNum = Math.max(oldLines.length, newLines.length);
+  const lineNumWidth = String(maxLineNum).length;
+
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine: number | undefined;
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split('\n');
+    if (raw[raw.length - 1] === '') {
+      raw.pop();
+    }
+
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined) {
+        firstChangedLine = newLineNum;
+      }
+
+      for (const line of raw) {
+        if (part.added) {
+          const lineNum = String(newLineNum).padStart(lineNumWidth, ' ');
+          output.push(`+${lineNum} ${line}`);
+          newLineNum++;
+        } else {
+          const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
+          output.push(`-${lineNum} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
+    } else {
+      const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+
+      if (lastWasChange || nextPartIsChange) {
+        let linesToShow = raw;
+        let skipStart = 0;
+        let skipEnd = 0;
+
+        if (!lastWasChange) {
+          skipStart = Math.max(0, raw.length - contextLines);
+          linesToShow = raw.slice(skipStart);
+        }
+
+        if (!nextPartIsChange && linesToShow.length > contextLines) {
+          skipEnd = linesToShow.length - contextLines;
+          linesToShow = linesToShow.slice(0, contextLines);
+        }
+
+        if (skipStart > 0) {
+          output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
+          oldLineNum += skipStart;
+          newLineNum += skipStart;
+        }
+
+        for (const line of linesToShow) {
+          const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
+          output.push(` ${lineNum} ${line}`);
+          oldLineNum++;
+          newLineNum++;
+        }
+
+        if (skipEnd > 0) {
+          output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
+        }
+      } else {
+        oldLineNum += raw.length;
+        newLineNum += raw.length;
+      }
+
+      lastWasChange = false;
+    }
+  }
+
+  return { diff: output.join('\n'), firstChangedLine };
 }
 
 export class EditTool implements Tool {
@@ -888,10 +1098,12 @@ edit(
     new_string: string;
   }): Promise<{ success: boolean; message: string; diff?: string; firstChangedLine?: number }> {
     const { file_path, instruction, old_string, new_string } = params;
-    
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    void instruction;
+
     try {
       const absolutePath = path.resolve(file_path);
-      
+
       // Check if file exists
       try {
         await fs.access(absolutePath);
@@ -904,7 +1116,7 @@ edit(
 
       // Read the file
       const buffer = await fs.readFile(absolutePath);
-      const rawContent = buffer.toString("utf-8");
+      const rawContent = buffer.toString('utf-8');
 
       // Strip BOM before matching
       const { bom, text: content } = stripBom(rawContent);
@@ -952,7 +1164,7 @@ edit(
       }
 
       const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-      await fs.writeFile(absolutePath, finalContent, "utf-8");
+      await fs.writeFile(absolutePath, finalContent, 'utf-8');
 
       const diffResult = await generateDiffString(baseContent, newContent);
 
@@ -1000,38 +1212,43 @@ export class WebSearchTool implements Tool {
 - Combine with web_fetch to get full content from relevant URLs
 - Use quotes for exact phrase matching
 - Consider adding context like year or version in query`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: { query: string }): Promise<{ results: any[]; message: string }> {
     const { query } = params;
-    
+
     try {
       const configManager = await import('./config.js');
       const { getConfigManager } = configManager;
       const config = getConfigManager();
-      
+
       const searchApiKey = config.get('searchApiKey');
       const baseUrl = config.get('baseUrl') || 'https://apis.xagent.cn/v1';
-      
+
       if (!searchApiKey) {
         throw new Error('Search API key not configured. Please set searchApiKey in settings.');
       }
-      
+
       const response = await axios.post(
         `${baseUrl}/search`,
         { query },
         {
           headers: {
-            'Authorization': `Bearer ${searchApiKey}`,
-            'Content-Type': 'application/json'
+            Authorization: `Bearer ${searchApiKey}`,
+            'Content-Type': 'application/json',
           },
-          timeout: 30000
+          timeout: 30000,
         }
       );
-      
+
       return {
         results: response.data.results || [],
-        message: `Found ${response.data.results?.length || 0} results for "${query}"`
+        message: `Found ${response.data.results?.length || 0} results for "${query}"`,
       };
     } catch (error: any) {
       throw new Error(`Web search failed: ${error.message}`);
@@ -1087,29 +1304,44 @@ Each task needs:
 - Don't batch multiple completions - update as you go
 - Keep task descriptions clear and actionable
 - Use appropriate priority levels to indicate urgency`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
-
-  private todoList: Array<{ id: string; task: string; status: 'pending' | 'in_progress' | 'completed' | 'failed'; priority: 'high' | 'medium' | 'low' }> = [];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
+
+  private todoList: Array<{
+    id: string;
+    task: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed';
+    priority: 'high' | 'medium' | 'low';
+  }> = [];
 
   async execute(params: {
-    todos: Array<{ id: string; task: string; status: 'pending' | 'in_progress' | 'completed' | 'failed'; priority: 'high' | 'medium' | 'low' }>;
+    todos: Array<{
+      id: string;
+      task: string;
+      status: 'pending' | 'in_progress' | 'completed' | 'failed';
+      priority: 'high' | 'medium' | 'low';
+    }>;
   }): Promise<{ success: boolean; message: string; todos: any[] }> {
     const { todos } = params;
-    
+
     try {
       this.todoList = todos;
-      
+
       const summary = {
-        pending: todos.filter(t => t.status === 'pending').length,
-        in_progress: todos.filter(t => t.status === 'in_progress').length,
-        completed: todos.filter(t => t.status === 'completed').length,
-        failed: todos.filter(t => t.status === 'failed').length
+        pending: todos.filter((t) => t.status === 'pending').length,
+        in_progress: todos.filter((t) => t.status === 'in_progress').length,
+        completed: todos.filter((t) => t.status === 'completed').length,
+        failed: todos.filter((t) => t.status === 'failed').length,
       };
-      
+
       return {
         success: true,
         message: `Updated todo list: ${summary.pending} pending, ${summary.in_progress} in progress, ${summary.completed} completed, ${summary.failed} failed`,
-        todos: this.todoList
+        todos: this.todoList,
       };
     } catch (error: any) {
       throw new Error(`Failed to update todo list: ${error.message}`);
@@ -1142,7 +1374,12 @@ export class TodoReadTool implements Tool {
 # Best Practices
 - Use todo_write to modify the list, not todo_read
 - Check todo_read after todo_write to verify updates`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   private todoWriteTool: TodoWriteTool;
 
@@ -1153,18 +1390,18 @@ export class TodoReadTool implements Tool {
   async execute(): Promise<{ todos: any[]; summary: any }> {
     try {
       const todos = this.todoWriteTool.getTodos();
-      
+
       const summary = {
         total: todos.length,
-        pending: todos.filter(t => t.status === 'pending').length,
-        in_progress: todos.filter(t => t.status === 'in_progress').length,
-        completed: todos.filter(t => t.status === 'completed').length,
-        failed: todos.filter(t => t.status === 'failed').length
+        pending: todos.filter((t) => t.status === 'pending').length,
+        in_progress: todos.filter((t) => t.status === 'in_progress').length,
+        completed: todos.filter((t) => t.status === 'completed').length,
+        failed: todos.filter((t) => t.status === 'failed').length,
       };
-      
+
       return {
         todos,
-        summary
+        summary,
       };
     } catch (error: any) {
       throw new Error(`Failed to read todo list: ${error.message}`);
@@ -1175,7 +1412,15 @@ export class TodoReadTool implements Tool {
 export interface SubAgentTask {
   description: string;
   prompt: string;
-  subagent_type: 'general-purpose' | 'plan-agent' | 'explore-agent' | 'frontend-tester' | 'code-reviewer' | 'frontend-developer' | 'backend-developer' | 'gui-subagent';
+  subagent_type:
+    | 'general-purpose'
+    | 'plan-agent'
+    | 'explore-agent'
+    | 'frontend-tester'
+    | 'code-reviewer'
+    | 'frontend-developer'
+    | 'backend-developer'
+    | 'gui-subagent';
   useContext?: boolean;
   outputFormat?: string;
   constraints?: string[];
@@ -1225,39 +1470,52 @@ export class TaskTool implements Tool {
 - Include relevant context (file paths, requirements, constraints)
 - Set appropriate executionMode if needed
 - For parallel execution, ensure tasks are truly independent`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
-
-  async execute(params: {
-    description: string;
-    prompt?: string;
-    query?: string;  // Support both prompt and query (tool definition uses query)
-    subagent_type?: 'general-purpose' | 'plan-agent' | 'explore-agent' | 'frontend-tester' | 'code-reviewer' | 'frontend-developer' | 'backend-developer' | 'gui-subagent';
-    agents?: SubAgentTask[];
-    useContext?: boolean;
-    outputFormat?: string;
-    constraints?: string[];
-    executionMode?: ExecutionMode;
-    parallel?: boolean;
-  }, _executionMode?: ExecutionMode): Promise<{ success: boolean; message: string; result?: any }> {
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
+
+  async execute(
+    params: {
+      description: string;
+      prompt?: string;
+      query?: string; // Support both prompt and query (tool definition uses query)
+      subagent_type?:
+        | 'general-purpose'
+        | 'plan-agent'
+        | 'explore-agent'
+        | 'frontend-tester'
+        | 'code-reviewer'
+        | 'frontend-developer'
+        | 'backend-developer'
+        | 'gui-subagent';
+      agents?: SubAgentTask[];
+      useContext?: boolean;
+      outputFormat?: string;
+      constraints?: string[];
+      executionMode?: ExecutionMode;
+      parallel?: boolean;
+    },
+    _executionMode?: ExecutionMode
+  ): Promise<{ success: boolean; message: string; result?: any }> {
     const mode = params.executionMode || _executionMode || ExecutionMode.YOLO;
-    
+
     try {
       const { getAgentManager } = await import('./agents.js');
       const agentManager = getAgentManager(process.cwd());
-      
+
       const { getConfigManager } = await import('./config.js');
       const config = getConfigManager();
-      
-      const { AIClient } = await import('./ai-client.js');
-      const aiClient = new AIClient({
-        type: AuthType.OPENAI_COMPATIBLE,
-        apiKey: config.get('apiKey'),
-        baseUrl: config.get('baseUrl'),
-        modelName: config.get('modelName') || 'Qwen3-Coder'
-      });
-      
+
+      const authConfig = config.getAuthConfig();
+      // aiClient is created for future use when executeParallelAgents supports it
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const _aiClient = createAIClient(authConfig);
+
       const toolRegistry = getToolRegistry();
-      
+
       if (params.agents && params.agents.length > 0) {
         return await this.executeParallelAgents(
           params.agents,
@@ -1265,10 +1523,10 @@ export class TaskTool implements Tool {
           mode,
           agentManager,
           toolRegistry,
-          aiClient
+          config
         );
       }
-      
+
       if (!params.subagent_type) {
         throw new Error('subagent_type is required for Task tool');
       }
@@ -1276,13 +1534,16 @@ export class TaskTool implements Tool {
       // Support both 'prompt' and 'query' parameter names (tool definition uses 'query')
       const prompt = params.prompt || params.query;
       if (!prompt) {
-        throw new Error('Task query/prompt is required. Received params: ' + JSON.stringify({
-          subagent_type: params.subagent_type,
-          prompt: params.prompt,
-          query: params.query,
-          description: params.description,
-          agents: params.agents?.length
-        }));
+        throw new Error(
+          'Task query/prompt is required. Received params: ' +
+            JSON.stringify({
+              subagent_type: params.subagent_type,
+              prompt: params.prompt,
+              query: params.query,
+              description: params.description,
+              agents: params.agents?.length,
+            })
+        );
       }
 
       const result = await this.executeSingleAgent(
@@ -1294,10 +1555,9 @@ export class TaskTool implements Tool {
         mode,
         agentManager,
         toolRegistry,
-        aiClient,
         config
       );
-      
+
       return result;
     } catch (error: any) {
       throw new Error(`Task execution failed: ${error.message}`);
@@ -1308,16 +1568,27 @@ export class TaskTool implements Tool {
    * Create unified VLM caller
    * Uses remote VLM if remoteAIClient is provided, otherwise uses local VLM
    * Both modes receive full messages array for consistent behavior
+   * @param remoteAIClient - Remote AI client for VLM calls
+   * @param taskId - Task identifier for backend tracking
+   * @param localConfig - Local VLM configuration
+   * @param isFirstVlmCallRef - Reference to boolean tracking if this is the first VLM call
+   * @param signal - Abort signal for cancellation
    */
   private createRemoteVlmCaller(
     remoteAIClient: any,
     taskId: string | null,
     localConfig: { baseUrl: string; apiKey: string; modelName: string },
+    isFirstVlmCallRef: { current: boolean },
     signal?: AbortSignal
-  ): (messages: any[], systemPrompt: string) => Promise<string> {
+  ): (
+    messages: any[],
+    systemPrompt: string,
+    taskId: string,
+    isFirstVlmCallRef: { current: boolean }
+  ) => Promise<string> {
     // Remote mode: use RemoteAIClient
     if (remoteAIClient) {
-      return this.createRemoteVLMCaller(remoteAIClient, taskId, signal);
+      return this.createRemoteVLMCaller(remoteAIClient, taskId, isFirstVlmCallRef, signal);
     }
 
     // Local mode: use local API
@@ -1327,11 +1598,39 @@ export class TaskTool implements Tool {
   /**
    * Create remote VLM caller using RemoteAIClient
    * Now receives full messages array for consistent behavior with local mode
+   * @param remoteAIClient - Remote AI client
+   * @param taskId - Task identifier for backend tracking
+   * @param isFirstVlmCallRef - Reference to boolean tracking if this is the first VLM call
+   * @param signal - Abort signal for cancellation
    */
-  private createRemoteVLMCaller(remoteAIClient: any, taskId: string | null, signal?: AbortSignal) {
-    return async (messages: any[], systemPrompt: string): Promise<string> => {
+  private createRemoteVLMCaller(
+    remoteAIClient: any,
+    taskId: string | null,
+    isFirstVlmCallRef: { current: boolean },
+    signal?: AbortSignal
+  ): (
+    messages: any[],
+    systemPrompt: string,
+    taskId: string,
+    isFirstVlmCallRef: { current: boolean }
+  ) => Promise<string> {
+    return async (
+      messages: any[],
+      systemPrompt: string,
+      _taskId: string,
+      _isFirstVlmCallRef: { current: boolean }
+    ): Promise<string> => {
       try {
-        return await remoteAIClient.invokeVLM(messages, systemPrompt, { signal, taskId });
+        // Use the ref to track first call status for the backend
+        const status = isFirstVlmCallRef.current ? 'begin' : 'continue';
+        const result = await remoteAIClient.invokeVLM(messages, systemPrompt, {
+          signal,
+          taskId,
+          status,
+        });
+        // Update ref after call so subsequent calls use 'continue'
+        isFirstVlmCallRef.current = false;
+        return result;
       } catch (error: any) {
         throw new Error(`Remote VLM call failed: ${error.message}`);
       }
@@ -1368,7 +1667,7 @@ export class TaskTool implements Tool {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Authorization': `Bearer ${apiKey}`,
+          Authorization: `Bearer ${apiKey}`,
         },
         body: JSON.stringify(requestBody),
         signal: abortSignal,
@@ -1379,7 +1678,9 @@ export class TaskTool implements Tool {
         throw new Error(`VLM API error: ${errorText}`);
       }
 
-      const result = await response.json() as { choices?: Array<{ message?: { content?: string } }> };
+      const result = (await response.json()) as {
+        choices?: Array<{ message?: { content?: string } }>;
+      };
       return result.choices?.[0]?.message?.content || '';
     };
   }
@@ -1399,32 +1700,65 @@ export class TaskTool implements Tool {
   ): Promise<{ success: boolean; cancelled?: boolean; message: string; result?: any }> {
     const indent = '  '.repeat(indentLevel);
 
-    console.log(`${indent}${colors.primaryBright(`${icons.robot} GUI Agent`)}: ${description}`);
-    console.log(`${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`);
-    console.log('');
+    // Get SDK adapter from session for SDK mode output
+    let sdkOutputAdapter: any = null;
+    let isSdkMode = false;
+    try {
+      const { getSingletonSession } = await import('./session.js');
+      const session = getSingletonSession();
+      if (session) {
+        isSdkMode = (session as any).isSdkMode;
+        sdkOutputAdapter = (session as any).sdkOutputAdapter;
+      }
+    } catch {
+      // Session not available
+    }
 
-    // Get VLM configuration (used for local mode fallback)
-    const baseUrl = config.get('guiSubagentBaseUrl') || config.get('baseUrl') || '';
-    const apiKey = config.get('guiSubagentApiKey') || config.get('apiKey') || '';
-    const modelName = config.get('guiSubagentModel') || config.get('modelName') || '';
+    // SDK mode: use adapter output (guiAgent.run() handles SDK output internally)
+    // Only output console messages in non-SDK mode
+    if (!isSdkMode) {
+      console.log(`${indent}${colors.primaryBright(`${icons.robot} GUI Agent`)}: ${description}`);
+      console.log(
+        `${indent}${colors.border(icons.separator.repeat(Math.min(60, process.stdout.columns || 80) - indent.length))}`
+      );
+      console.log('');
+    }
+
+    // Get VLM configuration for local mode
+    // NOTE: guiSubagentBaseUrl must be explicitly configured, NOT fallback to baseUrl
+    const baseUrl = config.get('guiSubagentBaseUrl') || '';
+    const apiKey = config.get('guiSubagentApiKey') || '';
+    const modelName = config.get('guiSubagentModel') || '';
 
     // Determine mode: remote if remoteAIClient exists, otherwise local
     const isRemoteMode = !!remoteAIClient;
 
     // Log mode information
     if (isRemoteMode) {
-      console.log(`${indent}${colors.info(`${icons.brain} Using remote VLM service`)}`);
+      if (isSdkMode && sdkOutputAdapter) {
+        // SDK mode: use adapter output
+        sdkOutputAdapter.outputInfo('Using remote VLM service');
+      } else {
+        // Normal mode: console output
+        console.log(`${indent}${colors.info(`${icons.brain} Using remote VLM service`)}`);
+      }
     } else {
-      console.log(`${indent}${colors.info(`${icons.brain} Using local VLM configuration`)}`);
-      // Local mode requires configuration check
-      if (!baseUrl) {
-        return {
-          success: false,
-          message: `GUI task "${description}" failed: No valid API URL configured`
-        };
+      if (isSdkMode && sdkOutputAdapter) {
+        // SDK mode: use adapter output
+        sdkOutputAdapter.outputInfo('Using local VLM configuration');
+      } else {
+        // Normal mode: console output
+        console.log(`${indent}${colors.info(`${icons.brain} Using local VLM configuration`)}`);
+        // Local mode requires explicit VLM configuration
+        if (!baseUrl || !apiKey || !modelName) {
+          return {
+            success: false,
+            message: `GUI task "${description}" failed: VLM not configured. Please run /model to configure Vision-Language Model first.`,
+          };
+        }
+        console.log(`${indent}${colors.textMuted(`  Model: ${modelName}`)}`);
+        console.log(`${indent}${colors.textMuted(`  Base URL: ${baseUrl}`)}`);
       }
-      console.log(`${indent}${colors.textMuted(`  Model: ${modelName}`)}`);
-      console.log(`${indent}${colors.textMuted(`  Base URL: ${baseUrl}`)}`);
     }
     console.log('');
 
@@ -1435,13 +1769,21 @@ export class TaskTool implements Tool {
         const { getSingletonSession } = await import('./session.js');
         const session = getSingletonSession();
         taskId = session?.getTaskId() || null;
-      } catch (e) {
+      } catch {
         taskId = null;
       }
     }
 
+    // Track first VLM call for proper status management
+    const isFirstVlmCallRef = { current: true };
+
     // Create remoteVlmCaller using the unified method (handles both local and remote modes)
-    const remoteVlmCaller = this.createRemoteVlmCaller(remoteAIClient, taskId, { baseUrl, apiKey, modelName });
+    const remoteVlmCaller = this.createRemoteVlmCaller(
+      remoteAIClient,
+      taskId,
+      { baseUrl, apiKey, modelName },
+      isFirstVlmCallRef
+    );
 
     // Set up stdin polling for ESC cancellation
     let rawModeEnabled = false;
@@ -1450,14 +1792,16 @@ export class TaskTool implements Tool {
     const logger = getLogger();
 
     const setupStdinPolling = () => {
+      logger.debug(`[GUIAgent ESC] setupStdinPolling called, process.stdin.isTTY: ${process.stdin.isTTY}`);
       if (process.stdin.isTTY) {
         try {
           process.stdin.setRawMode(true);
           rawModeEnabled = true;
           process.stdin.resume();
           readline.emitKeypressEvents(process.stdin);
-        } catch (e) {
-          logger.debug(`[GUIAgent] Could not set raw mode: ${e}`);
+          logger.debug(`[GUIAgent ESC] Raw mode enabled successfully`);
+        } catch (e: any) {
+          logger.debug(`[GUIAgent ESC] Could not set raw mode: ${e.message}`);
         }
 
         stdinPollingInterval = setInterval(() => {
@@ -1466,13 +1810,20 @@ export class TaskTool implements Tool {
               const chunk = process.stdin.read(1);
               if (chunk && chunk.length > 0) {
                 const code = chunk[0];
-                if (code === 0x1B) { // ESC
-                  logger.debug('[GUIAgent] ESC detected!');
+                if (code === 0x1b) {
+                  // ESC
+                  logger.debug('[GUIAgent ESC Polling] ESC detected! Code: 0x1b');
                   cancellationManager.cancel();
+                } else {
+                  // Log other key codes for debugging
+                  logger.debug(`[GUIAgent ESC Polling] Key code: 0x${code.toString(16)}`);
                 }
               }
+            } else {
+              logger.debug('[GUIAgent ESC Polling] rawModeEnabled is false');
             }
-          } catch (e) {
+          } catch (e: any) {
+            logger.debug(`[GUIAgent ESC Polling] Error: ${e.message}`);
             // Ignore polling errors
           }
         }, 10);
@@ -1494,7 +1845,9 @@ export class TaskTool implements Tool {
     cancellationManager.on('cancelled', cancelHandler);
 
     // Start polling for ESC
+    logger.debug(`[GUIAgent ESC] About to call setupStdinPolling`);
     setupStdinPolling();
+    logger.debug(`[GUIAgent ESC] setupStdinPolling called`);
 
     try {
       // Import and create GUIAgent
@@ -1504,11 +1857,15 @@ export class TaskTool implements Tool {
         model: !isRemoteMode ? modelName : undefined,
         modelBaseUrl: !isRemoteMode ? baseUrl : undefined,
         modelApiKey: !isRemoteMode ? apiKey : undefined,
+        taskId: taskId || undefined,
+        isFirstVlmCallRef,
         remoteVlmCaller,
         isLocalMode: !isRemoteMode,
-        maxLoopCount: 30,
+        maxLoopCount: 100,
         loopIntervalInMs: 500,
         showAIDebugInfo: config.get('showAIDebugInfo') || false,
+        indentLevel: indentLevel,
+        sdkOutputAdapter: isSdkMode ? sdkOutputAdapter : null,
       });
 
       // Add constraints to prompt if any
@@ -1528,9 +1885,9 @@ export class TaskTool implements Tool {
         process.stdout.write('\n');
         return {
           success: true,
-          cancelled: true,  // Mark as cancelled so main agent won't continue
+          cancelled: true, // Mark as cancelled so main agent won't continue
           message: `GUI task "${description}" cancelled by user`,
-          result: 'Task cancelled'
+          result: 'Task cancelled',
         };
       }
 
@@ -1541,26 +1898,106 @@ export class TaskTool implements Tool {
       process.stdout.write('\n');
 
       // Return result based on GUIAgent status
+      // Always return all info except screenshots (base64) to avoid huge payload
+      const conversationsWithoutScreenshots = result.conversations.map((conv: any) => ({
+        ...conv,
+        screenshotBase64: undefined, // Remove screenshots to avoid huge payload
+      }));
+
       if (result.status === 'end') {
-        const iterations = result.conversations.filter(c => c.from === 'human' && c.screenshotBase64).length;
-        console.log(`${indent}${colors.success(`${icons.check} GUI task completed in ${iterations} iterations`)}`);
+        const iterations = conversationsWithoutScreenshots.filter(
+          (c: any) => c.from === 'human' && c.screenshotContext
+        ).length;
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentComplete(description, iterations);
+        } else {
+          // Normal mode: console output
+          console.log(
+            `${indent}${colors.success(`${icons.check} GUI task completed in ${iterations} iterations`)}`
+          );
+        }
         return {
           success: true,
           message: `GUI task "${description}" completed`,
-          result: `Completed in ${iterations} iterations`
+          result: {
+            status: result.status,
+            iterations,
+            actions: conversationsWithoutScreenshots
+              .filter((c: any) => c.from === 'assistant' && c.actionType)
+              .map((c: any) => c.actionType),
+            conversations: conversationsWithoutScreenshots,
+            error: result.error,
+          },
+        };
+      } else if (result.status === 'call_llm') {
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentStatus('call_llm', conversationsWithoutScreenshots.filter(
+            (c: any) => c.from === 'human' && c.screenshotContext
+          ).length);
+        } else {
+          // Normal mode: console output
+          console.log(
+            `${indent}${colors.warning(`${icons.warning} GUI agent returned to main agent for LLM decision`)}`
+          );
+        }
+        return {
+          success: true,
+          message: `GUI task "${description}" returned for LLM decision`,
+          result: {
+            status: result.status,
+            iterations: conversationsWithoutScreenshots.filter(
+              (c: any) => c.from === 'human' && c.screenshotContext
+            ).length,
+            actions: conversationsWithoutScreenshots
+              .filter((c: any) => c.from === 'assistant' && c.actionType)
+              .map((c: any) => c.actionType),
+            conversations: conversationsWithoutScreenshots,
+            error: result.error,
+          },
         };
       } else if (result.status === 'user_stopped') {
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentCancelled(description);
+        }
         return {
           success: true,
           message: `GUI task "${description}" stopped by user`,
-          result: 'User stopped'
+          result: {
+            status: result.status,
+            iterations: conversationsWithoutScreenshots.filter(
+              (c: any) => c.from === 'human' && c.screenshotContext
+            ).length,
+            actions: conversationsWithoutScreenshots
+              .filter((c: any) => c.from === 'assistant' && c.actionType)
+              .map((c: any) => c.actionType),
+            conversations: conversationsWithoutScreenshots,
+            stopped: true,
+          },
         };
       } else {
         // status is 'error' or other non-success status
         const errorMsg = result.error || 'Unknown error';
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentError(description, errorMsg);
+        }
         return {
           success: false,
-          message: `GUI task "${description}" failed: ${errorMsg}`
+          message: `GUI task "${description}" failed: ${errorMsg}`,
+          result: {
+            status: result.status,
+            iterations: conversationsWithoutScreenshots.filter(
+              (c: any) => c.from === 'human' && c.screenshotContext
+            ).length,
+            actions: conversationsWithoutScreenshots
+              .filter((c: any) => c.from === 'assistant' && c.actionType)
+              .map((c: any) => c.actionType),
+            conversations: conversationsWithoutScreenshots,
+            error: result.error,
+          },
         };
       }
     } catch (error: any) {
@@ -1573,26 +2010,38 @@ export class TaskTool implements Tool {
       // If the user cancelled the task, ignore any API errors (like 429)
       // and return cancelled status instead
       if (cancelled || cancellationManager.isOperationCancelled()) {
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentCancelled(description);
+        }
         return {
           success: true,
-          cancelled: true,  // Mark as cancelled so main agent won't continue
+          cancelled: true, // Mark as cancelled so main agent won't continue
           message: `GUI task "${description}" cancelled by user`,
-          result: 'Task cancelled'
+          result: 'Task cancelled',
         };
       }
 
       if (error.message === 'Operation cancelled by user') {
+        // SDK mode: use adapter output
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputGUIAgentCancelled(description);
+        }
         return {
           success: true,
           message: `GUI task "${description}" cancelled by user`,
-          result: 'Task cancelled'
+          result: 'Task cancelled',
         };
       }
 
       // Return failure without throwing - let the main agent handle it
+      // SDK mode: use adapter output
+      if (isSdkMode && sdkOutputAdapter) {
+        sdkOutputAdapter.outputGUIAgentError(description, error.message);
+      }
       return {
         success: false,
-        message: `GUI task "${description}" failed: ${error.message}`
+        message: `GUI task "${description}" failed: ${error.message}`,
       };
     }
   }
@@ -1606,7 +2055,6 @@ export class TaskTool implements Tool {
     mode: ExecutionMode,
     agentManager: any,
     toolRegistry: any,
-    aiClient: any,
     config: any,
     indentLevel: number = 1
   ): Promise<{ success: boolean; message: string; result?: any }> {
@@ -1616,6 +2064,20 @@ export class TaskTool implements Tool {
       throw new Error(`Agent ${subagent_type} not found`);
     }
 
+    // Get SDK adapter from session for subagent output
+    let sdkOutputAdapter: any = null;
+    let isSdkMode = false;
+    try {
+      const { getSingletonSession } = await import('./session.js');
+      const session = getSingletonSession();
+      if (session) {
+        isSdkMode = (session as any).isSdkMode;
+        sdkOutputAdapter = (session as any).sdkOutputAdapter;
+      }
+    } catch {
+      // Session not available
+    }
+
     // Special handling for gui-subagent: directly call GUIAgent.run() instead of subagent message loop
     if (subagent_type === 'gui-subagent') {
       // Get RemoteAIClient instance from session (if available)
@@ -1626,7 +2088,7 @@ export class TaskTool implements Tool {
         if (session) {
           remoteAIClient = session.getRemoteAIClient();
         }
-      } catch (e) {
+      } catch {
         // Session not available, keep undefined
         remoteAIClient = undefined;
       }
@@ -1646,7 +2108,7 @@ export class TaskTool implements Tool {
     let modelName = config.get('modelName') || 'Qwen3-Coder';
     let baseUrl = config.get('baseUrl') || 'https://apis.xagent.cn/v1';
     let apiKey = config.get('apiKey') || '';
-    
+
     if (agent.model) {
       // If agent has a model field, it can be a model name or a config reference like 'guiSubagentModel'
       if (typeof agent.model === 'string' && agent.model.endsWith('Model')) {
@@ -1666,41 +2128,71 @@ export class TaskTool implements Tool {
       }
     }
 
-    // Create a new AIClient for this subagent with its specific model
-    const { AIClient: SubAgentAIClient } = await import('./ai-client.js');
-    const subAgentClient = new SubAgentAIClient({
-      type: AuthType.OPENAI_COMPATIBLE,
-      apiKey: apiKey,
-      baseUrl: baseUrl,
-      modelName: modelName,
-      showAIDebugInfo: config.get('showAIDebugInfo') || false
-    });
-    
+    // Create AI client for this subagent - each subagent gets its own independent client
+    let subAgentClient;
+    let isRemoteMode = false;
+    let mainTaskId: string | null = null;
+    const authConfig = config.getAuthConfig();
+
+    if (authConfig.type === AuthType.OAUTH_XAGENT) {
+      // Remote mode: create independent RemoteAIClient for each subagent
+      // This prevents message queue conflicts when multiple subagents run in parallel
+      const session = getSingletonSession();
+      const remoteAIClient = session?.getRemoteAIClient();
+
+      if (remoteAIClient) {
+        // Clone or create independent client for this subagent
+        // RemoteAIClient should be designed to handle concurrent requests
+        subAgentClient = remoteAIClient;
+        isRemoteMode = true;
+        mainTaskId = session?.getTaskId() || null;
+      } else {
+        subAgentClient = createAIClient(authConfig);
+      }
+    } else {
+      // Local mode: create client with subagent-specific model config
+      const subAuthConfig = {
+        ...authConfig,
+        type: AuthType.OPENAI_COMPATIBLE,
+        apiKey: apiKey,
+        baseUrl: baseUrl,
+        modelName: modelName,
+        showAIDebugInfo: config.get('showAIDebugInfo') || false,
+      };
+      subAgentClient = createAIClient(subAuthConfig);
+    }
+
     const indent = '  '.repeat(indentLevel);
-    const indentNext = '  '.repeat(indentLevel + 1);
+    const _indentNext = '  '.repeat(indentLevel + 1);
     const agentName = agent.name || subagent_type;
 
     // Track execution history for better reporting to main agent
     const executionHistory: Array<{
       tool: string;
       status: 'success' | 'error';
-      params: any;              // 工具调用参数
-      result?: any;             // 工具执行结果（成功时）
-      error?: string;           // 错误信息（失败时）
+      params: any; // 工具调用参数
+      result?: any; // 工具执行结果（成功时）
+      error?: string; // 错误信息（失败时）
       timestamp: string;
     }> = [];
 
     // Helper function to indent multi-line content
     const indentMultiline = (content: string, baseIndent: string): string => {
-      return content.split('\n').map(line => `${baseIndent}  ${line}`).join('\n');
+      return content
+        .split('\n')
+        .map((line) => `${baseIndent}  ${line}`)
+        .join('\n');
     };
-    
+
     const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, mode, agent);
-    const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(agent.systemPrompt);
-    
-    const fullPrompt = constraints.length > 0
-      ? `${prompt}\n\nConstraints:\n${constraints.map(c => `- ${c}`).join('\n')}`
-      : prompt;
+    const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(
+      agent.systemPrompt
+    );
+
+    const fullPrompt =
+      constraints.length > 0
+        ? `${prompt}\n\nConstraints:\n${constraints.map((c) => `- ${c}`).join('\n')}`
+        : prompt;
 
     // Set up raw mode and stdin polling for ESC detection
     const cancellationManager = getCancellationManager();
@@ -1728,13 +2220,14 @@ export class TaskTool implements Tool {
               const chunk = process.stdin.read(1);
               if (chunk && chunk.length > 0) {
                 const code = chunk[0];
-                if (code === 0x1B) { // ESC
+                if (code === 0x1b) {
+                  // ESC
                   logger.debug('[TaskTool] ESC detected via polling!');
                   cancellationManager.cancel();
                 }
               }
             }
-          } catch (e) {
+          } catch {
             // Ignore polling errors
           }
         }, 10);
@@ -1765,15 +2258,15 @@ export class TaskTool implements Tool {
         throw new Error('Operation cancelled by user');
       }
     };
-    
-    let messages: Message[] = [
+
+    const messages: Message[] = [
       { role: 'system', content: enhancedSystemPrompt },
-      { role: 'user', content: fullPrompt }
+      { role: 'user', content: fullPrompt },
     ];
-    
+
     const availableTools = agentManager.getAvailableToolsForAgent(agent, mode);
     const allToolDefinitions = toolRegistry.getToolDefinitions();
-    
+
     const toolDefinitions: ToolDefinition[] = availableTools.map((toolName: string) => {
       const fullDef = allToolDefinitions.find((def: any) => def.function.name === toolName);
       if (fullDef) {
@@ -1784,28 +2277,43 @@ export class TaskTool implements Tool {
         function: {
           name: toolName,
           description: `Tool: ${toolName}`,
-          parameters: { type: 'object', properties: {}, required: [] }
-        }
+          parameters: { type: 'object', properties: {}, required: [] },
+        },
       };
     });
 
     let iteration = 0;
-    const maxIterations = 10;
+    let lastContentStr = ''; // Track last content for final result
 
-    while (iteration < maxIterations) {
+    // Main agent style loop: continue until AI returns no more tool_calls
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
       iteration++;
-      
+
       // Check for cancellation before each iteration
       checkCancellation();
-      
+
+      // Prepare chat options with taskId and model names for remote mode
+      const chatOptions: any = {
+        tools: toolDefinitions,
+        temperature: 0.7,
+      };
+
+      // Pass taskId, status, and model names for remote mode subagent calls
+      // Subagent shares the same taskId as the main task
+      if (isRemoteMode && mainTaskId) {
+        chatOptions.taskId = mainTaskId;
+        chatOptions.status = iteration === 1 ? 'begin' : 'continue';
+        // Pass model names to ensure subagent uses the same models as main task
+        chatOptions.llmModelName = config.get('remote_llmModelName');
+        chatOptions.vlmModelName = config.get('remote_vlmModelName');
+      }
+
       // Use withCancellation to make API call cancellable
-      const result = await cancellationManager.withCancellation(
-        subAgentClient.chatCompletion(messages, {
-          tools: toolDefinitions,
-          temperature: 0.7
-        }),
+      const result = (await cancellationManager.withCancellation(
+        subAgentClient.chatCompletion(messages, chatOptions),
         `api-${subagent_type}-${iteration}`
-      ) as any;
+      )) as any;
 
       // Check for cancellation after API call
       checkCancellation();
@@ -1827,8 +2335,8 @@ export class TaskTool implements Tool {
         hasValidContent = messageContent.trim() !== '';
       } else if (Array.isArray(messageContent)) {
         const textParts = messageContent
-          .filter(item => typeof item?.text === 'string' && item.text.trim() !== '')
-          .map(item => item.text);
+          .filter((item) => typeof item?.text === 'string' && item.text.trim() !== '')
+          .map((item) => item.text);
         contentStr = textParts.join('');
         hasValidContent = textParts.length > 0;
       } else {
@@ -1846,143 +2354,87 @@ export class TaskTool implements Tool {
         throw new Error(`Sub-agent ${subagent_type} response truncated due to length limits`);
       }
 
-      // Add assistant message to conversation
-      messages.push({ role: 'assistant', content: contentStr });
+      // Add assistant message to conversation (必须包含 tool_calls，否则 tool_result 无法匹配)
+      const assistantMessage: any = { role: 'assistant', content: contentStr };
+      if (toolCalls && toolCalls.length > 0) {
+        assistantMessage.tool_calls = toolCalls;
+      }
+      if (reasoningContent) {
+        assistantMessage.reasoning_content = reasoningContent;
+      }
+      messages.push(assistantMessage as Message);
 
       // Display reasoning content if present
       if (reasoningContent) {
-        console.log(`\n${indent}${colors.textDim(`${icons.brain} Thinking Process:`)}`);
-        const truncatedReasoning = reasoningContent.length > 500 ? reasoningContent.substring(0, 500) + '...' : reasoningContent;
-        const indentedReasoning = indentMultiline(truncatedReasoning, indent);
-        console.log(`${indentedReasoning}\n`);
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputThinking(reasoningContent, 'compact');
+        } else {
+          console.log(`\n${indent}${colors.textDim(`${icons.brain} Thinking Process:`)}`);
+          const truncatedReasoning =
+            reasoningContent.length > 500
+              ? reasoningContent.substring(0, 500) + '...'
+              : reasoningContent;
+          const indentedReasoning = indentMultiline(truncatedReasoning, indent);
+          console.log(`${indentedReasoning}\n`);
+        }
       }
 
       // Display assistant response (if there's any text content) with proper indentation
       if (contentStr) {
-        console.log(`\n${indent}${colors.primaryBright(agentName)}: ${description}`);
-        const truncatedContent = contentStr.length > 500 ? contentStr.substring(0, 500) + '...' : contentStr;
-        const indentedContent = indentMultiline(truncatedContent, indent);
-        console.log(`${indentedContent}\n`);
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputAssistant(contentStr);
+        } else {
+          console.log(`\n${indent}${colors.primaryBright(agentName)}: ${description}`);
+          const truncatedContent =
+            contentStr.length > 500 ? contentStr.substring(0, 500) + '...' : contentStr;
+          const indentedContent = indentMultiline(truncatedContent, indent);
+          console.log(`${indentedContent}\n`);
+        }
       }
 
-      // Process tool calls with proper indentation
+      // Process tool calls in parallel (照搬 session 的实现)
       if (toolCalls && toolCalls.length > 0) {
-        for (const toolCall of toolCalls) {
+        // Prepare all tool calls with their indices
+        const preparedToolCalls = toolCalls.map((toolCall: any, index: number) => {
           const { name, arguments: params } = toolCall.function;
-
           let parsedParams: any;
           try {
             parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
-          } catch (e) {
+          } catch {
             parsedParams = params;
           }
+          return { name, params: parsedParams, id: toolCall.id, index };
+        });
 
-          console.log(`${indent}${colors.textMuted(`${icons.loading} Tool: ${name}`)}`);
+        // Display all tool call info first
+        for (const tc of preparedToolCalls as Array<{ name: string; params: any; id: string }>) {
+          if (isSdkMode && sdkOutputAdapter) {
+            sdkOutputAdapter.outputToolStart(tc.name, tc.params);
+          } else {
+            console.log(`${indent}${colors.textMuted(`${icons.loading} Tool: ${tc.name}`)}`);
+          }
+        }
 
+        // Execute all tool calls in parallel
+        const executePromises = preparedToolCalls.map(async (tc: { name: string; params: any; id: string; index: number }) => {
           try {
             // Check cancellation before tool execution
             checkCancellation();
-            
+
             const toolResult: any = await cancellationManager.withCancellation(
-              toolRegistry.execute(name, parsedParams, mode, indent),
-              `subagent-${subagent_type}-${name}-${iteration}`
+              toolRegistry.execute(tc.name, tc.params, mode, indent),
+              `subagent-${subagent_type}-${tc.name}-${iteration}`
             );
-
-            // Get showToolDetails config to control result display
-            const showToolDetails = config.get('showToolDetails') || false;
-
-            // Prepare result preview for history
-            const resultPreview = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult, null, 2);
-            const truncatedPreview = resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
-
-            // Special handling for different tools (consistent with session.ts display logic)
-            const isTodoTool = name === 'todo_write' || name === 'todo_read';
-            const isEditTool = name === 'Edit';
-            const isWriteTool = name === 'Write';
-            const isDeleteTool = name === 'DeleteFile';
-            const hasDiff = isEditTool && toolResult?.diff;
-            const hasFilePreview = isWriteTool && toolResult?.preview;
-            const hasDeleteInfo = isDeleteTool && toolResult?.filePath;
-
-            // Import render functions for consistent display
-            const { renderDiff, renderLines } = await import('./theme.js');
-
-            if (isTodoTool) {
-              // Display todo list
-              console.log(`${indent}${colors.success(`${icons.check} Todo List:`)}`);
-              const todos = toolResult?.todos || [];
-              if (todos.length === 0) {
-                console.log(`${indent}  ${colors.textMuted('No tasks')}`);
-              } else {
-                const statusConfig: Record<string, { icon: string; color: (text: string) => string; label: string }> = {
-                  'pending': { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
-                  'in_progress': { icon: icons.loading, color: colors.warning, label: 'In Progress' },
-                  'completed': { icon: icons.success, color: colors.success, label: 'Completed' },
-                  'failed': { icon: icons.error, color: colors.error, label: 'Failed' }
-                };
-                for (const todo of todos) {
-                  const status = statusConfig[todo.status] || statusConfig['pending'];
-                  console.log(`${indent}  ${status.color(status.icon)} ${status.color(status.label)}: ${colors.text(todo.task)}`);
-                }
-              }
-              if (toolResult?.message) {
-                console.log(`${indent}${colors.textDim(toolResult.message)}`);
-              }
-              console.log('');
-            } else if (hasDiff) {
-              // Display edit result with diff
-              console.log('');
-              const diffOutput = renderDiff(toolResult.diff);
-              const indentedDiff = diffOutput.split('\n').map(line => `${indent}  ${line}`).join('\n');
-              console.log(`${indentedDiff}\n`);
-            } else if (hasFilePreview) {
-              // Display new file content in preview style
-              console.log('');
-              console.log(`${indent}${colors.success(`${icons.file} ${toolResult.filePath}`)}`);
-              console.log(`${indent}${colors.textDim(`  ${toolResult.lineCount} lines`)}`);
-              console.log('');
-              console.log(renderLines(toolResult.preview, { maxLines: 10, indent: indent + '  ' }));
-              console.log('');
-            } else if (hasDeleteInfo) {
-              // Display DeleteFile result
-              console.log('');
-              console.log(`${indent}${colors.success(`${icons.check} Deleted: ${toolResult.filePath}`)}`);
-              console.log('');
-            } else if (showToolDetails) {
-              // Show full result details
-              const indentedPreview = indentMultiline(resultPreview, indent);
-              console.log(`${indent}${colors.success(`${icons.check} Tool Result:`)}\n${indentedPreview}\n`);
-            } else if (toolResult && toolResult.success === false) {
-              // Tool failed
-              console.log(`${indent}${colors.error(`${icons.cross} ${toolResult.message || 'Failed'}`)}\n`);
-            } else if (toolResult) {
-              // Show brief preview by default
-              const indentedPreview = indentMultiline(truncatedPreview, indent);
-              console.log(`${indent}${colors.success(`${icons.check} Completed`)}\n${indentedPreview}\n`);
-            } else {
-              console.log(`${indent}${colors.textDim('(no result)')}\n`);
-            }
-
-            // Record successful tool execution in history (use truncated preview to save memory)
-            executionHistory.push({
-              tool: name,
-              status: 'success',
-              params: parsedParams,
-              result: truncatedPreview,
-              timestamp: new Date().toISOString()
-            });
-
-            messages.push({
-              role: 'tool',
-              content: JSON.stringify(toolResult),
-              tool_call_id: toolCall.id
-            });
+            return { ...tc, toolResult, error: undefined };
           } catch (error: any) {
             if (error.message === 'Operation cancelled by user') {
-              console.log(`${indent}${colors.warning(`⚠️  Operation cancelled`)}\n`);
+              if (!isSdkMode || !sdkOutputAdapter) {
+                console.log(`${indent}${colors.warning(`⚠️  Operation cancelled`)}\n`);
+              }
               cancellationManager.off('cancelled', cancelHandler);
               cleanupStdinPolling();
-              const summaryPreview = contentStr.length > 300 ? contentStr.substring(0, 300) + '...' : contentStr;
+              const summaryPreview =
+                contentStr.length > 300 ? contentStr.substring(0, 300) + '...' : contentStr;
               return {
                 success: false,
                 message: `Task "${description}" cancelled by user`,
@@ -1991,92 +2443,232 @@ export class TaskTool implements Tool {
                   executionHistory: {
                     totalIterations: iteration,
                     toolsExecuted: executionHistory.length,
-                    successfulTools: executionHistory.filter(t => t.status === 'success').length,
-                    failedTools: executionHistory.filter(t => t.status === 'error').length,
+                    successfulTools: executionHistory.filter((t) => t.status === 'success').length,
+                    failedTools: executionHistory.filter((t) => t.status === 'error').length,
                     history: executionHistory,
-                    cancelled: true
+                    cancelled: true,
+                  },
+                },
+              };
+            }
+            return { ...tc, toolResult: undefined, error: error.message };
+          }
+        });
+
+        const settledResults = await Promise.all(executePromises);
+
+        // Check for cancellation in results
+        const cancellationResult = settledResults.find(
+          (r): r is { success: boolean; message: string; result: any } =>
+            'success' in r && r.success === false
+        );
+        if (cancellationResult) {
+          return cancellationResult;
+        }
+
+        // Create a map to store results by tool call index to maintain original order (match session implementation)
+        type ToolResultType = { name: string; params: any; toolResult: any; error?: string; id: string; index: number };
+        const resultsByIndex = new Map<number, ToolResultType>();
+        const usedIndices = new Set<number>();
+
+        for (const result of settledResults as unknown as ToolResultType[]) {
+          // Find the first unused original index that matches the tool name
+          const originalIndex = preparedToolCalls.findIndex((tc: { name: string }, idx: number) =>
+            tc.name === result.name && !usedIndices.has(idx)
+          );
+          if (originalIndex !== -1) {
+            usedIndices.add(originalIndex);
+            resultsByIndex.set(originalIndex, result);
+          }
+        }
+
+        // Import render functions for consistent display
+        const { renderDiff, renderLines } = await import('./theme.js');
+
+        // Process results in the original tool_calls order
+        for (let i = 0; i < preparedToolCalls.length; i++) {
+          const result = resultsByIndex.get(i);
+          if (!result) continue;
+
+          const { name, params: parsedParams, toolResult, error } = result;
+
+          // Get showToolDetails config to control result display
+          const showToolDetails = config.get('showToolDetails') || false;
+
+          // Prepare result preview for history
+          const resultPreview =
+            typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult, null, 2);
+          const truncatedPreview =
+            resultPreview.length > 200 ? resultPreview.substring(0, 200) + '...' : resultPreview;
+
+          if (error) {
+            // Handle error case
+            if (isSdkMode && sdkOutputAdapter) {
+              sdkOutputAdapter.outputToolError(name, error);
+            } else {
+              console.log(`${indent}${colors.error(`${icons.cross} Error:`)} ${error}\n`);
+            }
+
+            // Record failed tool execution in history
+            executionHistory.push({
+              tool: name,
+              status: 'error',
+              params: parsedParams,
+              error,
+              timestamp: new Date().toISOString(),
+            });
+
+            messages.push({
+              role: 'tool',
+              content: JSON.stringify({ error }),
+              tool_call_id: result.id,
+            });
+          } else {
+            // Handle success case - display result
+            // SDK mode: output tool result via adapter
+            if (isSdkMode && sdkOutputAdapter) {
+              sdkOutputAdapter.outputToolResult(name, toolResult);
+            }
+            // Normal mode: console output (SDK mode already output via adapter above)
+            if (!isSdkMode || !sdkOutputAdapter) {
+              // Special handling for different tools (consistent with session.ts display logic)
+              const isTodoTool = name === 'todo_write' || name === 'todo_read';
+              const isEditTool = name === 'Edit';
+              const isWriteTool = name === 'Write';
+              const isDeleteTool = name === 'DeleteFile';
+              const hasDiff = isEditTool && toolResult?.diff;
+              const hasFilePreview = isWriteTool && toolResult?.preview;
+              const hasDeleteInfo = isDeleteTool && toolResult?.filePath;
+
+              if (isTodoTool) {
+                // Display todo list
+                console.log(`${indent}${colors.success(`${icons.check} Todo List:`)}`);
+                const todos = toolResult?.todos || [];
+                if (todos.length === 0) {
+                  console.log(`${indent}  ${colors.textMuted('No tasks')}`);
+                } else {
+                  const statusConfig: Record<
+                    string,
+                    { icon: string; color: (text: string) => string; label: string }
+                  > = {
+                    pending: { icon: icons.circle, color: colors.textMuted, label: 'Pending' },
+                    in_progress: { icon: icons.loading, color: colors.warning, label: 'In Progress' },
+                    completed: { icon: icons.success, color: colors.success, label: 'Completed' },
+                    failed: { icon: icons.error, color: colors.error, label: 'Failed' },
+                  };
+                  for (const todo of todos) {
+                    const status = statusConfig[todo.status] || statusConfig['pending'];
+                    console.log(
+                      `${indent}  ${status.color(status.icon)} ${status.color(status.label)}: ${colors.text(todo.task)}`
+                    );
                   }
                 }
-              };
+                if (toolResult?.message) {
+                  console.log(`${indent}${colors.textDim(toolResult.message)}`);
+                }
+                console.log('');
+              } else if (hasDiff) {
+                // Display edit result with diff
+                console.log('');
+                const diffOutput = renderDiff(toolResult.diff);
+                const indentedDiff = diffOutput
+                  .split('\n')
+                  .map((line) => `${indent}  ${line}`)
+                  .join('\n');
+                console.log(`${indentedDiff}\n`);
+              } else if (hasFilePreview) {
+                // Display new file content in preview style
+                console.log('');
+                console.log(`${indent}${colors.success(`${icons.file} ${toolResult.filePath}`)}`);
+                console.log(`${indent}${colors.textDim(`  ${toolResult.lineCount} lines`)}`);
+                console.log('');
+                console.log(renderLines(toolResult.preview, { maxLines: 10, indent: indent + '  ' }));
+                console.log('');
+              } else if (hasDeleteInfo) {
+                // Display DeleteFile result
+                console.log('');
+                console.log(
+                  `${indent}${colors.success(`${icons.check} Deleted: ${toolResult.filePath}`)}`
+                );
+                console.log('');
+              } else if (showToolDetails) {
+                // Show full result details
+                const indentedPreview = indentMultiline(resultPreview, indent);
+                console.log(
+                  `${indent}${colors.success(`${icons.check} Tool Result:`)}\n${indentedPreview}\n`
+                );
+              } else if (toolResult && toolResult.success === false) {
+                // Tool failed
+                console.log(
+                  `${indent}${colors.error(`${icons.cross} ${toolResult.message || 'Failed'}`)}\n`
+                );
+              } else if (toolResult) {
+                // Show brief preview by default
+                const indentedPreview = indentMultiline(truncatedPreview, indent);
+                console.log(
+                  `${indent}${colors.success(`${icons.check} Completed`)}\n${indentedPreview}\n`
+                );
+              } else {
+                console.log(`${indent}${colors.textDim('(no result)')}\n`);
+              }
             }
-            console.log(`${indent}${colors.error(`${icons.cross} Error:`)} ${error.message}\n`);
 
-            // Record failed tool execution in history
+            // Record successful tool execution in history (use truncated preview to save memory)
             executionHistory.push({
               tool: name,
-              status: 'error',
+              status: 'success',
               params: parsedParams,
-              error: error.message,
-              timestamp: new Date().toISOString()
+              result: truncatedPreview,
+              timestamp: new Date().toISOString(),
             });
 
             messages.push({
               role: 'tool',
-              content: JSON.stringify({ error: error.message }),
-              tool_call_id: toolCall.id
+              content: JSON.stringify(toolResult),
+              tool_call_id: result.id,
             });
           }
         }
-        console.log('');
+        if (!isSdkMode || !sdkOutputAdapter) {
+          console.log('');
+        }
         continue; // Continue to next iteration to get final response
       }
 
-      // No more tool calls, return the result with execution history
-      cancellationManager.off('cancelled', cancelHandler);
-      cleanupStdinPolling();
-
-      const summaryPreview = contentStr.length > 300 ? contentStr.substring(0, 300) + '...' : contentStr;
-      return {
-        success: true,
-        message: `Task "${description}" completed by ${subagent_type}`,
-        result: {
-          summary: summaryPreview,
-          executionHistory: {
-            totalIterations: iteration,
-            toolsExecuted: executionHistory.length,
-            successfulTools: executionHistory.filter(t => t.status === 'success').length,
-            failedTools: executionHistory.filter(t => t.status === 'error').length,
-            history: executionHistory
-          }
-        }
-      };
+      // No more tool calls - break loop (same as main agent)
+      lastContentStr = contentStr || '';
+      break;
     }
 
-    // Max iterations reached - return accumulated results instead of throwing error
-    // Get the last assistant message content
-    const lastAssistantMsg = messages.filter(m => m.role === 'assistant').pop();
-    const lastContentStr = typeof lastAssistantMsg?.content === 'string'
-      ? lastAssistantMsg.content
-      : JSON.stringify(lastAssistantMsg?.content || '');
-
+    // Loop ended - return result (same as main agent pattern)
     cancellationManager.off('cancelled', cancelHandler);
     cleanupStdinPolling();
 
-    const summaryPreview = lastContentStr.length > 300 ? lastContentStr.substring(0, 300) + '...' : lastContentStr;
+    const summaryPreview =
+      lastContentStr.length > 300 ? lastContentStr.substring(0, 300) + '...' : lastContentStr;
     return {
       success: true,
-      message: `Task "${description}" completed (max iterations reached) by ${subagent_type}`,
+      message: `Task "${description}" completed by ${subagent_type}`,
       result: {
         summary: summaryPreview,
         executionHistory: {
           totalIterations: iteration,
           toolsExecuted: executionHistory.length,
-          successfulTools: executionHistory.filter(t => t.status === 'success').length,
-          failedTools: executionHistory.filter(t => t.status === 'error').length,
+          successfulTools: executionHistory.filter((t) => t.status === 'success').length,
+          failedTools: executionHistory.filter((t) => t.status === 'error').length,
           history: executionHistory,
-          maxIterationsReached: true
-        }
-      }
+        },
+      },
     };
   }
-  
+
   private async executeParallelAgents(
     agents: SubAgentTask[],
     description: string,
     mode: ExecutionMode,
     agentManager: any,
     toolRegistry: any,
-    aiClient: any,
+    config: any,
     indentLevel: number = 1
   ): Promise<{ success: boolean; message: string; results: any[]; errors: any[] }> {
     const indent = '  '.repeat(indentLevel);
@@ -2105,13 +2697,14 @@ export class TaskTool implements Tool {
               const chunk = process.stdin.read(1);
               if (chunk && chunk.length > 0) {
                 const code = chunk[0];
-                if (code === 0x1B) { // ESC
+                if (code === 0x1b) {
+                  // ESC
                   logger.debug('[ParallelAgents] ESC detected via polling!');
                   cancellationManager.cancel();
                 }
               }
             }
-          } catch (e) {
+          } catch {
             // Ignore polling errors
           }
         }, 10);
@@ -2135,18 +2728,20 @@ export class TaskTool implements Tool {
     };
     cancellationManager.on('cancelled', cancelHandler);
 
-    console.log(`\n${indent}${colors.accent('◆')} ${colors.primaryBright('Parallel Agents')}: ${agents.length} running...`);
+    console.log(
+      `\n${indent}${colors.accent('◆')} ${colors.primaryBright('Parallel Agents')}: ${agents.length} running...`
+    );
 
     const startTime = Date.now();
 
-    const agentPromises = agents.map(async (agentTask, index) => {
+    const agentPromises = agents.map(async (agentTask, _index) => {
       // Check if cancelled
       if (cancelled || cancellationManager.isOperationCancelled()) {
         return {
           success: false,
           agent: agentTask.subagent_type,
           description: agentTask.description,
-          error: 'Operation cancelled by user'
+          error: 'Operation cancelled by user',
         };
       }
 
@@ -2160,35 +2755,39 @@ export class TaskTool implements Tool {
           mode,
           agentManager,
           toolRegistry,
-          aiClient,
+          config,
           indentLevel + 1
         );
-        
+
         return {
           success: true,
           agent: agentTask.subagent_type,
           description: agentTask.description,
-          result: result.result
+          result: result.result,
         };
       } catch (error: any) {
         return {
           success: false,
           agent: agentTask.subagent_type,
           description: agentTask.description,
-          error: error.message
+          error: error.message,
         };
       }
     });
-    
+
     const results = await Promise.all(agentPromises);
-    
+
     const duration = Date.now() - startTime;
-    
-    const successfulAgents = results.filter(r => r.success);
-    const failedAgents = results.filter(r => !r.success);
-    
-    console.log(`${indent}${colors.success('✔')} Parallel task completed in ${colors.textMuted(duration + 'ms')}`);
-    console.log(`${indent}${colors.info('ℹ')} Success: ${successfulAgents.length}/${agents.length} agents\n`);
+
+    const successfulAgents = results.filter((r) => r.success);
+    const failedAgents = results.filter((r) => !r.success);
+
+    console.log(
+      `${indent}${colors.success('✔')} Parallel task completed in ${colors.textMuted(duration + 'ms')}`
+    );
+    console.log(
+      `${indent}${colors.info('ℹ')} Success: ${successfulAgents.length}/${agents.length} agents\n`
+    );
 
     if (failedAgents.length > 0) {
       console.log(`${indent}${colors.error('✖')} Failed agents:`);
@@ -2205,16 +2804,16 @@ export class TaskTool implements Tool {
     return {
       success: failedAgents.length === 0,
       message: `Parallel task "${description}" completed: ${successfulAgents.length}/${agents.length} successful`,
-      results: successfulAgents.map(r => ({
+      results: successfulAgents.map((r) => ({
         agent: r.agent,
         description: r.description,
-        result: r.result
+        result: r.result,
       })),
-      errors: failedAgents.map(r => ({
+      errors: failedAgents.map((r) => ({
         agent: r.agent,
         description: r.description,
-        error: r.error
-      }))
+        error: r.error,
+      })),
     };
   }
 }
@@ -2247,34 +2846,39 @@ export class ReadBashOutputTool implements Tool {
 - Use appropriate poll_interval based on expected task duration
 - Check status to see if task is still running or completed
 - Combine with todo_write to track background task progress`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: {
     task_id: string;
     poll_interval?: number;
   }): Promise<{ taskId: string; output: string; status: string; duration: number }> {
     const { task_id, poll_interval = 10 } = params;
-    
+
     try {
       const toolRegistry = getToolRegistry();
       const task = (toolRegistry as any).getBackgroundTask(task_id);
-      
+
       if (!task) {
         throw new Error(`Task ${task_id} not found`);
       }
-      
+
       const interval = Math.min(Math.max(poll_interval, 1), 120);
-      await new Promise(resolve => setTimeout(resolve, interval * 1000));
-      
+      await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+
       const duration = Date.now() - task.startTime;
       const output = task.output.join('');
       const status = task.process.exitCode === null ? 'running' : 'completed';
-      
+
       return {
         taskId: task_id,
         output,
         status,
-        duration: Math.floor(duration / 1000)
+        duration: Math.floor(duration / 1000),
       };
     } catch (error: any) {
       throw new Error(`Failed to read bash output: ${error.message}`);
@@ -2310,36 +2914,43 @@ export class WebFetchTool implements Tool {
 - Use specific prompts to extract relevant information
 - Check if the page is accessible if you get errors
 - Large pages may be truncated due to size limits`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
-  async execute(params: { prompt: string }): Promise<{ content: string; url: string; status: number }> {
+  async execute(params: {
+    prompt: string;
+  }): Promise<{ content: string; url: string; status: number }> {
     const { prompt } = params;
-    
+
     try {
       const urlMatch = prompt.match(/https?:\/\/[^\s]+/i);
-      
+
       if (!urlMatch) {
         throw new Error('No URL found in prompt');
       }
-      
+
       const url = urlMatch[0];
-      
+
       const response = await axios.get(url, {
         timeout: 30000,
         maxContentLength: 10 * 1024 * 1024,
-        validateStatus: () => true
+        validateStatus: () => true,
       });
-      
+
       let content = response.data;
-      
+
       if (typeof content === 'object') {
         content = JSON.stringify(content, null, 2);
       }
-      
+
       return {
         content,
         url,
-        status: response.status
+        status: response.status,
       };
     } catch (error: any) {
       throw new Error(`Failed to fetch URL: ${error.message}`);
@@ -2380,7 +2991,12 @@ export class AskUserQuestionTool implements Tool {
 - Provide options when possible for faster response
 - Use multiSelect=true when multiple answers are valid
 - Be clear and concise in question wording`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: {
     questions: Array<{
@@ -2389,47 +3005,110 @@ export class AskUserQuestionTool implements Tool {
       options?: string[];
       multiSelect?: boolean;
     }>;
+  }): Promise<{ answers: string[] }> {
+    // Check if in SDK mode
+    const sdkMode = (this as any)._sdkMode;
+    const sdkAdapter = (this as any)._sdkOutputAdapter;
+
+    if (sdkMode && sdkAdapter) {
+      return this.executeSdk(params, sdkAdapter);
+    }
+
+    // Regular TUI mode
+    return this.executeTui(params);
+  }
+
+  /**
+   * Execute in TUI mode using @clack/prompts
+   */
+  private async executeTui(params: {
+    questions: Array<{
+      question: string;
+      header?: string;
+      options?: string[];
+      multiSelect?: boolean;
+    }>;
   }): Promise<{ answers: string[] }> {
     const { questions } = params;
-    
+
     try {
       if (questions.length === 0 || questions.length > 4) {
         throw new Error('Must provide 1-4 questions');
       }
-      
+
       const answers: string[] = [];
-      
+
       for (const q of questions) {
         if (q.options && q.options.length > 0) {
-          const result = await inquirer.prompt([
-            {
-              type: q.multiSelect ? 'checkbox' : 'list',
-              name: 'answer',
-              message: q.question,
-              choices: q.options,
-              default: q.multiSelect ? [] : q.options[0]
-            }
-          ]);
-          
-          answers.push(Array.isArray(result.answer) ? result.answer.join(', ') : result.answer);
+          const options = q.options.map((opt) => ({ value: opt, label: opt }));
+          const result = await select({
+            message: q.question,
+            options,
+          });
+
+          answers.push(result as string);
         } else {
-          const result = await inquirer.prompt([
-            {
-              type: 'input',
-              name: 'answer',
-              message: q.question
-            }
-          ]);
-          
-          answers.push(result.answer);
+          const result = (await text({
+            message: q.question,
+          })) as string;
+
+          answers.push(result);
         }
       }
-      
+
       return { answers };
     } catch (error: any) {
       throw new Error(`Failed to ask user questions: ${error.message}`);
     }
   }
+
+  /**
+   * Execute in SDK mode - output question request and wait for response
+   */
+  private async executeSdk(
+    params: {
+      questions: Array<{
+        question: string;
+        header?: string;
+        options?: string[];
+        multiSelect?: boolean;
+      }>;
+    },
+    sdkAdapter: any
+  ): Promise<{ answers: string[] }> {
+    const { questions } = params;
+
+    if (questions.length === 0 || questions.length > 4) {
+      throw new Error('Must provide 1-4 questions');
+    }
+
+    const requestId = `question_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Output question request through SDK adapter
+    sdkAdapter.outputQuestionRequest({
+      requestId,
+      questions
+    });
+
+    // Wait for SDK question response
+    // The response will be handled by session.ts which has access to the SDK input
+    // For now, we use a polling mechanism or wait for a specific event
+
+    try {
+      // Import the session to get response handling
+      const { getSingletonSession } = await import('./session.js');
+      const session = getSingletonSession();
+      if (!session) {
+        throw new Error('SDK session not available');
+      }
+      const answers = await session.waitForQuestionResponse(requestId);
+
+      sdkAdapter.outputQuestionResponse(requestId, answers);
+      return { answers };
+    } catch (error: any) {
+      throw new Error(`Failed to get SDK question response: ${error.message}`);
+    }
+  }
 }
 
 export class SaveMemoryTool implements Tool {
@@ -2461,20 +3140,25 @@ export class SaveMemoryTool implements Tool {
 - Keep facts concise and specific
 - Remember project-specific conventions for consistency
 - This persists across sessions (global memory)`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: { fact: string }): Promise<{ success: boolean; message: string }> {
     const { fact } = params;
-    
+
     try {
       const { getMemoryManager } = await import('./memory.js');
       const memoryManager = getMemoryManager(process.cwd());
-      
+
       await memoryManager.saveMemory(fact, 'global');
-      
+
       return {
         success: true,
-        message: `Successfully saved fact to memory`
+        message: `Successfully saved fact to memory`,
       };
     } catch (error: any) {
       throw new Error(`Failed to save memory: ${error.message}`);
@@ -2510,16 +3194,23 @@ export class ExitPlanModeTool implements Tool {
 - Include all necessary steps and considerations
 - The plan will be saved for reference during execution
 - Use this only when truly ready to start coding`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
-  async execute(params: { plan: string }): Promise<{ success: boolean; message: string; plan: string }> {
+  async execute(params: {
+    plan: string;
+  }): Promise<{ success: boolean; message: string; plan: string }> {
     const { plan } = params;
-    
+
     try {
       return {
         success: true,
         message: 'Plan completed and ready for execution',
-        plan
+        plan,
       };
     } catch (error: any) {
       throw new Error(`Failed to exit plan mode: ${error.message}`);
@@ -2559,21 +3250,21 @@ export class XmlEscapeTool implements Tool {
     escape_all?: boolean;
   }): Promise<{ success: boolean; message: string; changes: number }> {
     const { file_path, escape_all = false } = params;
-    
+
     try {
       const absolutePath = path.resolve(file_path);
       let content = await fs.readFile(absolutePath, 'utf-8');
-      
+
       const specialChars = [
         { char: '&', replacement: '&amp;' },
         { char: '<', replacement: '&lt;' },
         { char: '>', replacement: '&gt;' },
         { char: '"', replacement: '&quot;' },
-        { char: "'", replacement: '&apos;' }
+        { char: "'", replacement: '&apos;' },
       ];
-      
+
       let changes = 0;
-      
+
       for (const { char, replacement } of specialChars) {
         const regex = new RegExp(this.escapeRegExp(char), 'g');
         const matches = content.match(regex);
@@ -2582,14 +3273,14 @@ export class XmlEscapeTool implements Tool {
           content = content.replace(regex, replacement);
         }
       }
-      
+
       if (escape_all) {
         const additionalChars = [
           { char: '©', replacement: '&copy;' },
           { char: '®', replacement: '&reg;' },
-          { char: '€', replacement: '&euro;' }
+          { char: '€', replacement: '&euro;' },
         ];
-        
+
         for (const { char, replacement } of additionalChars) {
           const regex = new RegExp(this.escapeRegExp(char), 'g');
           const matches = content.match(regex);
@@ -2599,13 +3290,13 @@ export class XmlEscapeTool implements Tool {
           }
         }
       }
-      
+
       await fs.writeFile(absolutePath, content, 'utf-8');
-      
+
       return {
         success: true,
         message: `Successfully escaped ${changes} character(s) in ${file_path}`,
-        changes
+        changes,
       };
     } catch (error: any) {
       throw new Error(`Failed to escape XML/HTML in file ${file_path}: ${error.message}`);
@@ -2646,7 +3337,12 @@ export class ImageReadTool implements Tool {
 - Provide clear prompts for what to look for
 - Use task_brief for context
 - Supports PNG, JPG, GIF, WEBP, SVG, BMP`;
-  allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.PLAN, ExecutionMode.SMART];
+  allowedModes = [
+    ExecutionMode.YOLO,
+    ExecutionMode.ACCEPT_EDITS,
+    ExecutionMode.PLAN,
+    ExecutionMode.SMART,
+  ];
 
   async execute(params: {
     image_input: string;
@@ -2656,10 +3352,10 @@ export class ImageReadTool implements Tool {
     mime_type?: string;
   }): Promise<{ analysis: string; image_info: any }> {
     const { image_input, prompt, task_brief, input_type = 'file_path', mime_type } = params;
-    
+
     try {
       let imageData: string;
-      
+
       if (input_type === 'file_path') {
         const absolutePath = path.resolve(image_input);
         const imageBuffer = await fs.readFile(absolutePath);
@@ -2667,19 +3363,14 @@ export class ImageReadTool implements Tool {
       } else {
         imageData = image_input;
       }
-      
-      const { AIClient } = await import('./ai-client.js');
+
       const configManager = await import('./config.js');
       const { getConfigManager } = configManager;
       const config = getConfigManager();
-      
-      const aiClient = new AIClient({
-        type: AuthType.OPENAI_COMPATIBLE,
-        apiKey: config.get('apiKey'),
-        baseUrl: config.get('baseUrl'),
-        modelName: config.get('modelName') || 'Qwen3-Coder'
-      });
-      
+      const authConfig = config.getAuthConfig();
+
+      const aiClient = createAIClient(authConfig);
+
       const textContent = task_brief ? `${task_brief}\n\n${prompt}` : prompt;
       const messages: Message[] = [
         {
@@ -2687,32 +3378,32 @@ export class ImageReadTool implements Tool {
           content: [
             {
               type: 'text',
-              text: textContent
+              text: textContent,
             },
             {
               type: 'image_url' as const,
               image_url: {
-                url: `data:${mime_type || 'image/jpeg'};base64,${imageData}`
-              }
-            }
-          ]
-        }
+                url: `data:${mime_type || 'image/jpeg'};base64,${imageData}`,
+              },
+            },
+          ],
+        },
       ];
-      
+
       const result = await aiClient.chatCompletion(messages, {
-        temperature: 0.7
+        temperature: 0.7,
       });
-      
+
       const messageContent = result.choices[0]?.message?.content;
       const analysis = typeof messageContent === 'string' ? messageContent : '';
-      
+
       return {
         analysis,
         image_info: {
           input_type,
           prompt,
-          task_brief
-        }
+          task_brief,
+        },
       };
     } catch (error: any) {
       throw new Error(`Failed to read image: ${error.message}`);
@@ -2802,13 +3493,16 @@ export class InvokeSkillTool implements Tool {
 - Skills will guide you through their specific workflows`;
   allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
 
-  async execute(params: {
-    skillId: string;
-    taskDescription: string;
-    inputFile?: string;
-    outputFile?: string;
-    options?: Record<string, any>;
-  }, _executionMode?: ExecutionMode): Promise<{
+  async execute(
+    params: {
+      skillId: string;
+      taskDescription: string;
+      inputFile?: string;
+      outputFile?: string;
+      options?: Record<string, any>;
+    },
+    _executionMode?: ExecutionMode
+  ): Promise<{
     success: boolean;
     message: string;
     skill: string;
@@ -2825,12 +3519,13 @@ export class InvokeSkillTool implements Tool {
       reason: string;
     }>;
     guidance?: string;
+    /** Skill directory path for dependency management */
+    skillPath?: string;
   }> {
     const { skillId, taskDescription, inputFile, outputFile, options } = params;
 
     try {
       const { getSkillInvoker } = await import('./skill-invoker.js');
-      const { SkillExecutionParams } = await import('./skill-invoker.js') as any;
       const skillInvoker = getSkillInvoker();
 
       await skillInvoker.initialize();
@@ -2847,7 +3542,7 @@ export class InvokeSkillTool implements Tool {
             taskDescription,
             inputFile,
             outputFile,
-            options
+            options,
           });
 
           if (result.success) {
@@ -2858,7 +3553,7 @@ export class InvokeSkillTool implements Tool {
               task: taskDescription,
               result: result.output,
               files: result.files,
-              nextSteps: result.nextSteps
+              nextSteps: result.nextSteps,
             };
           } else {
             throw new Error(result.error || 'Failed to execute matched skill');
@@ -2872,7 +3567,7 @@ export class InvokeSkillTool implements Tool {
         taskDescription,
         inputFile,
         outputFile,
-        options
+        options,
       });
 
       if (result.success) {
@@ -2883,7 +3578,8 @@ export class InvokeSkillTool implements Tool {
           task: taskDescription,
           result: result.output,
           files: result.files,
-          nextSteps: result.nextSteps
+          nextSteps: result.nextSteps,
+          skillPath: result.skillPath
         };
       } else {
         throw new Error(result.error);
@@ -2943,7 +3639,7 @@ export class InvokeSkillTool implements Tool {
 
 //   async execute(params: { skill: string }): Promise<{ success: boolean; details: any }> {
 //     const { skill } = params;
-    
+
 //     if (!skill) {
 //       throw new Error('Skill parameter is required');
 //     }
@@ -2976,7 +3672,10 @@ export class InvokeSkillTool implements Tool {
 export class ToolRegistry {
   private tools: Map<string, Tool> = new Map();
   private todoWriteTool: TodoWriteTool;
-  private backgroundTasks: Map<string, { process: any; startTime: number; output: string[] }> = new Map();
+  private backgroundTasks: Map<string, { process: any; startTime: number; output: string[] }> =
+    new Map();
+  private _isSdkMode: boolean = false;
+  private _sdkOutputAdapter: any = null;
 
   constructor() {
     this.todoWriteTool = new TodoWriteTool();
@@ -2989,7 +3688,7 @@ export class ToolRegistry {
     this.register(new GrepTool());
     this.register(new BashTool());
     this.register(new ListDirectoryTool());
-    this.register(new SearchFilesTool());    
+    this.register(new SearchFilesTool());
     this.register(new DeleteFileTool());
     this.register(new CreateDirectoryTool());
     this.register(new EditTool());
@@ -3027,23 +3726,21 @@ export class ToolRegistry {
   registerMCPTools(mcpTools: Map<string, any>): void {
     let registeredCount = 0;
 
-        for (const [fullName, tool] of mcpTools) {
-
-          const firstUnderscoreIndex = fullName.indexOf('__');
-
-          if (firstUnderscoreIndex === -1 || firstUnderscoreIndex === 0 || 
-
-              firstUnderscoreIndex === fullName.length - 2) continue;
-
-          
+    for (const [fullName, tool] of mcpTools) {
+      const firstUnderscoreIndex = fullName.indexOf('__');
 
-          const serverName = fullName.substring(0, firstUnderscoreIndex);
+      if (
+        firstUnderscoreIndex === -1 ||
+        firstUnderscoreIndex === 0 ||
+        firstUnderscoreIndex === fullName.length - 2
+      )
+        continue;
 
-          const originalName = fullName.substring(firstUnderscoreIndex + 2);
+      const serverName = fullName.substring(0, firstUnderscoreIndex);
 
-    
+      const originalName = fullName.substring(firstUnderscoreIndex + 2);
 
-          if (!originalName || originalName.trim() === '') continue;
+      if (!originalName || originalName.trim() === '') continue;
 
       // Auto-rename if conflict, ensure unique name
       let toolName = originalName;
@@ -3077,19 +3774,45 @@ export class ToolRegistry {
             const { getMCPManager } = await import('./mcp.js');
             const mcpManager = getMCPManager();
             return await mcpManager.callTool(fullName, params);
-          }
+          },
         };
         this.tools.set(toolName, mcpTool);
         registeredCount++;
 
         if (toolName !== originalName) {
-          console.log(`[MCP] Tool '${originalName}' renamed to '${toolName}' to avoid conflict`);
+          // 在 SDK 模式下不输出重命名信息
+          if (!this._isSdkMode) {
+            console.log(`[MCP] Tool '${originalName}' renamed to '${toolName}' to avoid conflict`);
+          }
         }
       }
     }
 
     if (registeredCount > 0) {
-      console.log(`[MCP] Registered ${registeredCount} tool(s)`);
+      // 在 SDK 模式下不输出注册信息（MCP 相关输出已在 session 中处理）
+      if (!this._isSdkMode) {
+        console.log(`[MCP] Registered ${registeredCount} tool(s)`);
+      }
+    }
+  }
+
+  /**
+   * Set SDK mode for the tool registry.
+   * In SDK mode, tool execution output is sent to the SDK output adapter.
+   */
+  async setSdkMode(enabled: boolean, adapter: any): Promise<void> {
+    this._isSdkMode = enabled;
+    this._sdkOutputAdapter = adapter;
+    // Mark all tools as SDK mode enabled
+    for (const [, tool] of this.tools) {
+      (tool as any)._sdkMode = enabled;
+      (tool as any)._sdkOutputAdapter = adapter;
+    }
+
+    // Initialize SDK mode for TaskTool specifically
+    const taskTool = this.tools.get('task') as any;
+    if (taskTool) {
+      await taskTool.setSdkMode?.(enabled, adapter);
     }
   }
 
@@ -3118,11 +3841,16 @@ export class ToolRegistry {
     return Array.from(this.tools.values());
   }
 
-  addBackgroundTask(taskId: string, task: { process: any; startTime: number; output: string[] }): void {
+  addBackgroundTask(
+    taskId: string,
+    task: { process: any; startTime: number; output: string[] }
+  ): void {
     this.backgroundTasks.set(taskId, task);
   }
 
-  getBackgroundTask(taskId: string): { process: any; startTime: number; output: string[] } | undefined {
+  getBackgroundTask(
+    taskId: string
+  ): { process: any; startTime: number; output: string[] } | undefined {
     return this.backgroundTasks.get(taskId);
   }
 
@@ -3131,11 +3859,11 @@ export class ToolRegistry {
   }
 
   getToolDefinitions(): any[] {
-    return Array.from(this.tools.values()).map(tool => {
+    return Array.from(this.tools.values()).map((tool) => {
       let parameters: any = {
         type: 'object',
         properties: {},
-        required: []
+        required: [],
       };
 
       // Define specific parameters for each tool
@@ -3146,18 +3874,18 @@ export class ToolRegistry {
             properties: {
               filePath: {
                 type: 'string',
-                description: 'The absolute path to the file to read'
+                description: 'The absolute path to the file to read',
               },
               offset: {
                 type: 'number',
-                description: 'Optional: Line number to start reading from (0-based)'
+                description: 'Optional: Line number to start reading from (0-based)',
               },
               limit: {
                 type: 'number',
-                description: 'Optional: Maximum number of lines to read'
-              }
+                description: 'Optional: Maximum number of lines to read',
+              },
             },
-            required: ['filePath']
+            required: ['filePath'],
           };
           break;
 
@@ -3167,14 +3895,14 @@ export class ToolRegistry {
             properties: {
               filePath: {
                 type: 'string',
-                description: 'The absolute path to the file to write'
+                description: 'The absolute path to the file to write',
               },
               content: {
                 type: 'string',
-                description: 'The content to write to the file'
-              }
+                description: 'The content to write to the file',
+              },
             },
-            required: ['filePath', 'content']
+            required: ['filePath', 'content'],
           };
           break;
 
@@ -3184,26 +3912,34 @@ export class ToolRegistry {
             properties: {
               pattern: {
                 type: 'string',
-                description: 'The regex pattern to search for'
+                description: 'The regex pattern or literal string to search for',
               },
               path: {
                 type: 'string',
-                description: 'Optional: The path to search in (default: current directory)'
+                description: 'Optional: The path to search in (default: current directory)',
               },
-              include: {
+              glob: {
                 type: 'string',
-                description: 'Optional: Glob pattern to filter files'
+                description: 'Optional: Glob pattern to filter files (e.g., "*.ts", "**/*.js")',
+              },
+              ignoreCase: {
+                type: 'boolean',
+                description: 'Optional: Case-insensitive search (default: false)',
               },
-              case_sensitive: {
+              literal: {
                 type: 'boolean',
-                description: 'Optional: Case-sensitive search (default: false)'
+                description: 'Optional: Treat pattern as literal string (default: false)',
               },
               context: {
                 type: 'number',
-                description: 'Optional: Number of context lines to show'
-              }
+                description: 'Optional: Number of context lines to show before and after',
+              },
+              limit: {
+                type: 'number',
+                description: 'Optional: Maximum number of matches to return',
+              },
             },
-            required: ['pattern']
+            required: ['pattern'],
           };
           break;
 
@@ -3213,26 +3949,26 @@ export class ToolRegistry {
             properties: {
               command: {
                 type: 'string',
-                description: 'The shell command to execute'
+                description: 'The shell command to execute',
               },
               cwd: {
                 type: 'string',
-                description: 'Optional: Working directory'
+                description: 'Optional: Working directory',
               },
               description: {
                 type: 'string',
-                description: 'Optional: Brief description of the command'
+                description: 'Optional: Brief description of the command',
               },
               timeout: {
                 type: 'number',
-                description: 'Optional: Timeout in seconds (default: 120)'
+                description: 'Optional: Timeout in seconds (default: 120)',
               },
               run_in_bg: {
                 type: 'boolean',
-                description: 'Optional: Run in background (default: false)'
-              }
+                description: 'Optional: Run in background (default: false)',
+              },
             },
-            required: ['command']
+            required: ['command'],
           };
           break;
 
@@ -3242,14 +3978,14 @@ export class ToolRegistry {
             properties: {
               path: {
                 type: 'string',
-                description: 'Optional: The directory path to list (default: current directory)'
+                description: 'Optional: The directory path to list (default: current directory)',
               },
               recursive: {
                 type: 'boolean',
-                description: 'Optional: List recursively (default: false)'
-              }
+                description: 'Optional: List recursively (default: false)',
+              },
             },
-            required: []
+            required: [],
           };
           break;
 
@@ -3259,18 +3995,18 @@ export class ToolRegistry {
             properties: {
               pattern: {
                 type: 'string',
-                description: 'The glob pattern to match files'
+                description: 'The glob pattern to match files',
               },
               path: {
                 type: 'string',
-                description: 'Optional: The path to search in (default: current directory)'
+                description: 'Optional: The path to search in (default: current directory)',
               },
               limit: {
                 type: 'integer',
-                description: 'Optional: Maximum number of results to return (default: 1000)'
-              }
+                description: 'Optional: Maximum number of results to return (default: 1000)',
+              },
             },
-            required: ['pattern']
+            required: ['pattern'],
           };
           break;
 
@@ -3280,10 +4016,10 @@ export class ToolRegistry {
             properties: {
               filePath: {
                 type: 'string',
-                description: 'The path to the file to delete'
-              }
+                description: 'The path to the file to delete',
+              },
             },
-            required: ['filePath']
+            required: ['filePath'],
           };
           break;
 
@@ -3293,14 +4029,14 @@ export class ToolRegistry {
             properties: {
               dirPath: {
                 type: 'string',
-                description: 'The directory path to create'
+                description: 'The directory path to create',
               },
               recursive: {
                 type: 'boolean',
-                description: 'Optional: Create parent directories (default: true)'
-              }
+                description: 'Optional: Create parent directories (default: true)',
+              },
             },
-            required: ['dirPath']
+            required: ['dirPath'],
           };
           break;
 
@@ -3310,22 +4046,22 @@ export class ToolRegistry {
             properties: {
               file_path: {
                 type: 'string',
-                description: 'The absolute path to the file to edit'
+                description: 'The absolute path to the file to edit',
               },
               instruction: {
                 type: 'string',
-                description: 'Description of what needs to be changed'
+                description: 'Description of what needs to be changed',
               },
               old_string: {
                 type: 'string',
-                description: 'The exact text to replace (supports fuzzy matching)'
+                description: 'The exact text to replace (supports fuzzy matching)',
               },
               new_string: {
                 type: 'string',
-                description: 'The new text to replace with'
-              }
+                description: 'The new text to replace with',
+              },
             },
-            required: ['file_path', 'instruction', 'old_string', 'new_string']
+            required: ['file_path', 'instruction', 'old_string', 'new_string'],
           };
           break;
 
@@ -3335,10 +4071,10 @@ export class ToolRegistry {
             properties: {
               query: {
                 type: 'string',
-                description: 'The search query'
-              }
+                description: 'The search query',
+              },
             },
-            required: ['query']
+            required: ['query'],
           };
           break;
 
@@ -3354,14 +4090,17 @@ export class ToolRegistry {
                   properties: {
                     id: { type: 'string' },
                     task: { type: 'string' },
-                    status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'failed'] },
-                    priority: { type: 'string', enum: ['high', 'medium', 'low'] }
+                    status: {
+                      type: 'string',
+                      enum: ['pending', 'in_progress', 'completed', 'failed'],
+                    },
+                    priority: { type: 'string', enum: ['high', 'medium', 'low'] },
                   },
-                  required: ['id', 'task', 'status']
-                }
-              }
+                  required: ['id', 'task', 'status'],
+                },
+              },
             },
-            required: ['todos']
+            required: ['todos'],
           };
           break;
 
@@ -3369,7 +4108,7 @@ export class ToolRegistry {
           parameters = {
             type: 'object',
             properties: {},
-            required: []
+            required: [],
           };
           break;
 
@@ -3379,60 +4118,79 @@ export class ToolRegistry {
             properties: {
               description: {
                 type: 'string',
-                description: 'Brief description of the task (3-5 words)'
+                description: 'Brief description of the task (3-5 words)',
               },
               agents: {
                 type: 'array',
-                description: 'Optional: Array of agents to run in parallel for comprehensive analysis',
+                description:
+                  'Optional: Array of agents to run in parallel for comprehensive analysis',
                 items: {
                   type: 'object',
                   properties: {
                     description: {
                       type: 'string',
-                      description: 'Brief description of the sub-agent task'
+                      description: 'Brief description of the sub-agent task',
                     },
                     prompt: {
                       type: 'string',
-                      description: 'The task for the sub-agent to perform'
+                      description: 'The task for the sub-agent to perform',
                     },
                     subagent_type: {
                       type: 'string',
-                      enum: ['general-purpose', 'plan-agent', 'explore-agent', 'frontend-tester', 'code-reviewer', 'frontend-developer', 'backend-developer'],
-                      description: 'The type of specialized agent'
+                      enum: [
+                        'general-purpose',
+                        'plan-agent',
+                        'explore-agent',
+                        'frontend-tester',
+                        'code-reviewer',
+                        'frontend-developer',
+                        'backend-developer',
+                      ],
+                      description: 'The type of specialized agent',
                     },
                     constraints: {
                       type: 'array',
                       items: { type: 'string' },
-                      description: 'Optional: Constraints or limitations'
-                    }
+                      description: 'Optional: Constraints or limitations',
+                    },
                   },
-                  required: ['description', 'prompt', 'subagent_type']
-                }
+                  required: ['description', 'prompt', 'subagent_type'],
+                },
               },
               prompt: {
                 type: 'string',
-                description: 'Optional: The task for the agent to perform (use agents for parallel execution)'
+                description:
+                  'Optional: The task for the agent to perform (use agents for parallel execution)',
               },
               subagent_type: {
                 type: 'string',
-                enum: ['general-purpose', 'plan-agent', 'explore-agent', 'frontend-tester', 'code-reviewer', 'frontend-developer', 'backend-developer'],
-                description: 'Optional: The type of specialized agent (use agents for parallel execution)'
+                enum: [
+                  'general-purpose',
+                  'plan-agent',
+                  'explore-agent',
+                  'frontend-tester',
+                  'code-reviewer',
+                  'frontend-developer',
+                  'backend-developer',
+                ],
+                description:
+                  'Optional: The type of specialized agent (use agents for parallel execution)',
               },
               useContext: {
                 type: 'boolean',
-                description: 'Optional: Include main agent context'
+                description: 'Optional: Include main agent context',
               },
               outputFormat: {
                 type: 'string',
-                description: 'Optional: Output format template'
+                description: 'Optional: Output format template',
               },
               constraints: {
                 type: 'array',
                 items: { type: 'string' },
-                description: 'Optional: Constraints or limitations'
-              }
+                description: 'Optional: Constraints or limitations',
+              },
             },
-            required: ['description']
+            required: ['description'],
           };
           break;
 
@@ -3442,14 +4200,14 @@ export class ToolRegistry {
             properties: {
               task_id: {
                 type: 'string',
-                description: 'The ID of the task'
+                description: 'The ID of the task',
               },
               poll_interval: {
                 type: 'number',
-                description: 'Optional: Polling interval in seconds (default: 10)'
-              }
+                description: 'Optional: Polling interval in seconds (default: 10)',
+              },
             },
-            required: ['task_id']
+            required: ['task_id'],
           };
           break;
 
@@ -3459,10 +4217,10 @@ export class ToolRegistry {
             properties: {
               prompt: {
                 type: 'string',
-                description: 'Prompt containing URL(s) and processing instructions'
-              }
+                description: 'Prompt containing URL(s) and processing instructions',
+              },
             },
-            required: ['prompt']
+            required: ['prompt'],
           };
           break;
 
@@ -3481,15 +4239,15 @@ export class ToolRegistry {
                     options: {
                       type: 'array',
                       items: { type: 'string' },
-                      description: 'Available choices (2-4 options)'
+                      description: 'Available choices (2-4 options)',
                     },
-                    multiSelect: { type: 'boolean' }
+                    multiSelect: { type: 'boolean' },
                   },
-                  required: ['question', 'header', 'options', 'multiSelect']
-                }
-              }
+                  required: ['question', 'header', 'options', 'multiSelect'],
+                },
+              },
             },
-            required: ['questions']
+            required: ['questions'],
           };
           break;
 
@@ -3499,10 +4257,10 @@ export class ToolRegistry {
             properties: {
               fact: {
                 type: 'string',
-                description: 'The specific fact to remember'
-              }
+                description: 'The specific fact to remember',
+              },
             },
-            required: ['fact']
+            required: ['fact'],
           };
           break;
 
@@ -3512,10 +4270,10 @@ export class ToolRegistry {
             properties: {
               plan: {
                 type: 'string',
-                description: 'The plan to present'
-              }
+                description: 'The plan to present',
+              },
             },
-            required: ['plan']
+            required: ['plan'],
           };
           break;
 
@@ -3525,14 +4283,14 @@ export class ToolRegistry {
             properties: {
               file_path: {
                 type: 'string',
-                description: 'The absolute path to the XML/HTML file'
+                description: 'The absolute path to the XML/HTML file',
               },
               escape_all: {
                 type: 'boolean',
-                description: 'Optional: Escape all special characters (default: false)'
-              }
+                description: 'Optional: Escape all special characters (default: false)',
+              },
             },
-            required: ['file_path']
+            required: ['file_path'],
           };
           break;
 
@@ -3542,27 +4300,27 @@ export class ToolRegistry {
             properties: {
               image_input: {
                 type: 'string',
-                description: 'Image file path or base64 data'
+                description: 'Image file path or base64 data',
               },
               prompt: {
                 type: 'string',
-                description: 'Comprehensive VLM instruction'
+                description: 'Comprehensive VLM instruction',
               },
               task_brief: {
                 type: 'string',
-                description: 'Brief task description (max 15 words)'
+                description: 'Brief task description (max 15 words)',
               },
               input_type: {
                 type: 'string',
                 enum: ['file_path', 'base64'],
-                description: 'Input type (default: file_path)'
+                description: 'Input type (default: file_path)',
               },
               mime_type: {
                 type: 'string',
-                description: 'Optional: MIME type for base64 input'
-              }
+                description: 'Optional: MIME type for base64 input',
+              },
             },
-            required: ['image_input', 'prompt']
+            required: ['image_input', 'prompt'],
           };
           break;
 
@@ -3572,10 +4330,10 @@ export class ToolRegistry {
             properties: {
               skill: {
                 type: 'string',
-                description: 'The skill name to execute'
-              }
+                description: 'The skill name to execute',
+              },
             },
-            required: ['skill']
+            required: ['skill'],
           };
           break;
 
@@ -3583,7 +4341,7 @@ export class ToolRegistry {
           parameters = {
             type: 'object',
             properties: {},
-            required: []
+            required: [],
           };
           break;
 
@@ -3593,14 +4351,14 @@ export class ToolRegistry {
             properties: {
               skill: {
                 type: 'string',
-                description: 'The skill name/id to get details for'
-              }
+                description: 'The skill name/id to get details for',
+              },
             },
-            required: ['skill']
+            required: ['skill'],
           };
           break;
 
-        default:
+        default: {
           // For MCP tools, use their inputSchema; for other unknown tools, keep empty schema
           const mcpTool = tool as any;
           if (mcpTool._isMcpTool && mcpTool.inputSchema) {
@@ -3608,13 +4366,15 @@ export class ToolRegistry {
             parameters = {
               type: 'object',
               properties: {},
-              required: []
+              required: [],
             };
             if (mcpTool.inputSchema.properties) {
-              for (const [paramName, paramDef] of Object.entries<any>(mcpTool.inputSchema.properties)) {
+              for (const [paramName, paramDef] of Object.entries<any>(
+                mcpTool.inputSchema.properties
+              )) {
                 parameters.properties[paramName] = {
                   type: paramDef.type || 'string',
-                  description: paramDef.description || ''
+                  description: paramDef.description || '',
                 };
               }
             }
@@ -3625,9 +4385,10 @@ export class ToolRegistry {
             parameters = {
               type: 'object',
               properties: {},
-              required: []
+              required: [],
             };
           }
+        }
       }
 
       return {
@@ -3635,13 +4396,18 @@ export class ToolRegistry {
         function: {
           name: tool.name,
           description: tool.description,
-          parameters
-        }
+          parameters,
+        },
       };
     });
   }
 
-  async execute(toolName: string, params: any, executionMode: ExecutionMode, indent: string = ''): Promise<any> {
+  async execute(
+    toolName: string,
+    params: any,
+    executionMode: ExecutionMode,
+    indent: string = ''
+  ): Promise<any> {
     // First try to execute as local tool
     const localTool = this.tools.get(toolName);
     if (localTool) {
@@ -3659,13 +4425,13 @@ export class ToolRegistry {
     }
 
     // Try to find MCP tool with just the tool name (try each server)
-    for (const [fullName, tool] of allMcpTools) {
+    for (const [fullName, _tool] of allMcpTools) {
       // Split only on the first __ to preserve underscores in tool names
       const firstUnderscoreIndex = fullName.indexOf('__');
       if (firstUnderscoreIndex === -1) continue;
-      const [serverName, actualToolName] = [
+      const [_serverName, actualToolName] = [
         fullName.substring(0, firstUnderscoreIndex),
-        fullName.substring(firstUnderscoreIndex + 2)
+        fullName.substring(firstUnderscoreIndex + 2),
       ];
       if (actualToolName === toolName) {
         return await this.executeMCPTool(fullName, params, executionMode, indent);
@@ -3679,7 +4445,12 @@ export class ToolRegistry {
   /**
    * Execute local tool (extracted for reuse)
    */
-  private async executeLocalTool(toolName: string, params: any, executionMode: ExecutionMode, indent: string): Promise<any> {
+  private async executeLocalTool(
+    toolName: string,
+    params: any,
+    executionMode: ExecutionMode,
+    indent: string
+  ): Promise<any> {
     const tool = this.get(toolName);
     const cancellationManager = getCancellationManager();
 
@@ -3688,11 +4459,12 @@ export class ToolRegistry {
     }
 
     if (!tool.allowedModes.includes(executionMode)) {
-      throw new Error(
-        `Tool ${toolName} is not allowed in ${executionMode} mode`
-      );
+      throw new Error(`Tool ${toolName} is not allowed in ${executionMode} mode`);
     }
 
+    const isSdkMode = this._isSdkMode;
+    const sdkOutputAdapter = this._sdkOutputAdapter;
+
     // Smart approval mode
     if (executionMode === ExecutionMode.SMART) {
       const debugMode = process.env.DEBUG === 'smart-approval';
@@ -3702,7 +4474,9 @@ export class ToolRegistry {
         if (debugMode) {
           const { getLogger } = await import('./logger.js');
           const logger = getLogger();
-          logger.debug(`[SmartApprovalEngine] Tool '${toolName}' bypassed smart approval completely`);
+          logger.debug(
+            `[SmartApprovalEngine] Tool '${toolName}' bypassed smart approval completely`
+          );
         }
         return await cancellationManager.withCancellation(
           tool.execute(params, executionMode),
@@ -3718,8 +4492,15 @@ export class ToolRegistry {
       const isRemoteMode = authConfig.type === AuthType.OAUTH_XAGENT;
       if (isRemoteMode && toolName === 'InvokeSkill') {
         console.log('');
-        console.log(`${indent}${colors.success(`✅ [Smart Mode] Remote mode: tool '${toolName}' auto-approved (remote LLM already approved)`)}`);
-        console.log('');
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputInfo(`[Smart Mode] Remote mode: tool '${toolName}' auto-approved (remote LLM already approved)`);
+        } else {
+          console.log('');
+          console.log(
+            `${indent}${colors.success(`✅ [Smart Mode] Remote mode: tool '${toolName}' auto-approved (remote LLM already approved)`)}`
+          );
+          console.log('');
+        }
         return await cancellationManager.withCancellation(
           tool.execute(params, executionMode),
           `tool-${toolName}`
@@ -3730,49 +4511,81 @@ export class ToolRegistry {
 
       const approvalEngine = getSmartApprovalEngine(debugMode);
 
+      // Set SDK mode for approval engine if in SDK mode
+      if (isSdkMode && sdkOutputAdapter) {
+        approvalEngine.setSdkMode(true, sdkOutputAdapter);
+      }
+
       // Evaluate tool call
       const result = await approvalEngine.evaluate({
         toolName,
         params,
-        timestamp: Date.now()
+        timestamp: Date.now(),
       });
 
       // Decide whether to execute based on approval result
       if (result.decision === 'approved') {
         // Whitelist or AI approval passed, execute directly
-        console.log('');
-        console.log(`${indent}${colors.success(`✅ [Smart Mode] Tool '${toolName}' passed approval, executing directly`)}`);
-        console.log(`${indent}${colors.textDim(`  Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}`)}`);
-        console.log(`${indent}${colors.textDim(`  Latency: ${result.latency}ms`)}`);
-        console.log('');
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputInfo(`[Smart Mode] Tool '${toolName}' passed approval, executing directly`);
+          sdkOutputAdapter.outputInfo(`Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}, Latency: ${result.latency}ms`);
+        } else {
+          console.log('');
+          console.log(
+            `${indent}${colors.success(`✅ [Smart Mode] Tool '${toolName}' passed approval, executing directly`)}`
+          );
+          console.log(
+            `${indent}${colors.textDim(`  Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}`)}`
+          );
+          console.log(`${indent}${colors.textDim(`  Latency: ${result.latency}ms`)}`);
+          console.log('');
+        }
         return await cancellationManager.withCancellation(
           tool.execute(params, executionMode),
           `tool-${toolName}`
         );
       } else if (result.decision === 'requires_confirmation') {
         // Requires user confirmation
-        const confirmed = await approvalEngine.requestConfirmation(result);
+        const confirmed = await approvalEngine.requestConfirmation(result, toolName, params);
 
         if (confirmed) {
-          console.log('');
-          console.log(`${indent}${colors.success(`✅ [Smart Mode] User confirmed execution of tool '${toolName}'`)}`);
-          console.log('');
+          if (isSdkMode && sdkOutputAdapter) {
+            sdkOutputAdapter.outputInfo(`[Smart Mode] User confirmed execution of tool '${toolName}'`);
+          } else {
+            console.log('');
+            console.log(
+              `${indent}${colors.success(`✅ [Smart Mode] User confirmed execution of tool '${toolName}'`)}`
+            );
+            console.log('');
+          }
           return await cancellationManager.withCancellation(
             tool.execute(params, executionMode),
             `tool-${toolName}`
           );
         } else {
-          console.log('');
-          console.log(`${indent}${colors.warning(`⚠️  [Smart Mode] User cancelled execution of tool '${toolName}'`)}`);
-          console.log('');
+          if (isSdkMode && sdkOutputAdapter) {
+            sdkOutputAdapter.outputWarning(`[Smart Mode] User cancelled execution of tool '${toolName}'`);
+          } else {
+            console.log('');
+            console.log(
+              `${indent}${colors.warning(`⚠️  [Smart Mode] User cancelled execution of tool '${toolName}'`)}`
+            );
+            console.log('');
+          }
           throw new Error(`Tool execution cancelled by user: ${toolName}`);
         }
       } else {
         // Rejected execution
-        console.log('');
-        console.log(`${indent}${colors.error(`❌ [Smart Mode] Tool '${toolName}' execution rejected`)}`);
-        console.log(`${indent}${colors.textDim(`  Reason: ${result.description}`)}`);
-        console.log('');
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputError(`[Smart Mode] Tool '${toolName}' execution rejected`, { reason: result.description });
+        } else {
+          console.log('');
+          console.log(
+            `${indent}${colors.error(`❌ [Smart Mode] Tool '${toolName}' execution rejected`)}`
+          );
+          console.log(`${indent}${colors.textDim(`  Reason: ${result.description}`)}`);
+          console.log('');
+        }
         throw new Error(`Tool execution rejected: ${toolName}`);
       }
     }
@@ -3787,7 +4600,12 @@ export class ToolRegistry {
   /**
    * Execute an MCP tool call
    */
-  private async executeMCPTool(toolName: string, params: any, executionMode: ExecutionMode, indent: string = ''): Promise<any> {
+  private async executeMCPTool(
+    toolName: string,
+    params: any,
+    executionMode: ExecutionMode,
+    indent: string = ''
+  ): Promise<any> {
     const { getMCPManager } = await import('./mcp.js');
     const mcpManager = getMCPManager();
     const cancellationManager = getCancellationManager();
@@ -3796,14 +4614,21 @@ export class ToolRegistry {
     const firstUnderscoreIndex = toolName.indexOf('__');
     const serverName = toolName.substring(0, firstUnderscoreIndex);
     const actualToolName = toolName.substring(firstUnderscoreIndex + 2);
-    
+
     // Get server info for display
     const server = mcpManager.getServer(serverName);
-    const serverTools = server?.getToolNames() || [];
-    
+    const _serverTools = server?.getToolNames() || [];
+
+    const isSdkMode = this._isSdkMode;
+    const sdkOutputAdapter = this._sdkOutputAdapter;
+
     // Display tool call info
-    console.log('');
-    console.log(`${indent}${colors.warning(`${icons.tool} MCP Tool Call: ${serverName}::${actualToolName}`)}`);
+    if (!isSdkMode || !sdkOutputAdapter) {
+      console.log('');
+      console.log(
+        `${indent}${colors.warning(`${icons.tool} MCP Tool Call: ${serverName}::${actualToolName}`)}`
+      );
+    }
 
     // Smart approval mode for MCP tools
     if (executionMode === ExecutionMode.SMART) {
@@ -3816,29 +4641,63 @@ export class ToolRegistry {
 
       // Remote mode: remote LLM has already approved the tool, auto-approve
       if (isRemoteMode) {
-        console.log(`${indent}${colors.success(`✅ [Smart Mode] Remote mode: MCP tool '${serverName}::${actualToolName}' auto-approved`)}`);
+        if (isSdkMode && sdkOutputAdapter) {
+          sdkOutputAdapter.outputInfo(`[Smart Mode] Remote mode: MCP tool '${serverName}::${actualToolName}' auto-approved`);
+        } else {
+          console.log(
+            `${indent}${colors.success(`✅ [Smart Mode] Remote mode: MCP tool '${serverName}::${actualToolName}' auto-approved`)}`
+          );
+        }
       } else {
         const approvalEngine = getSmartApprovalEngine(debugMode);
 
+        // Set SDK mode for approval engine if in SDK mode
+        if (isSdkMode && sdkOutputAdapter) {
+          approvalEngine.setSdkMode(true, sdkOutputAdapter);
+        }
+
         // Evaluate MCP tool call
         const result = await approvalEngine.evaluate({
           toolName: `MCP[${serverName}]::${actualToolName}`,
           params,
-          timestamp: Date.now()
+          timestamp: Date.now(),
         });
 
         if (result.decision === 'approved') {
-          console.log(`${indent}${colors.success(`✅ [Smart Mode] MCP tool '${serverName}::${actualToolName}' passed approval`)}`);
-          console.log(`${indent}${colors.textDim(`  Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}`)}`);
+          if (isSdkMode && sdkOutputAdapter) {
+            sdkOutputAdapter.outputInfo(`[Smart Mode] MCP tool '${serverName}::${actualToolName}' passed approval`);
+            sdkOutputAdapter.outputInfo(`Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}`);
+          } else {
+            console.log(
+              `${indent}${colors.success(`✅ [Smart Mode] MCP tool '${serverName}::${actualToolName}' passed approval`)}`
+            );
+            console.log(
+              `${indent}${colors.textDim(`  Detection method: ${result.detectionMethod === 'whitelist' ? 'Whitelist' : 'AI Review'}`)}`
+            );
+          }
         } else if (result.decision === 'requires_confirmation') {
-          const confirmed = await approvalEngine.requestConfirmation(result);
+          const confirmed = await approvalEngine.requestConfirmation(
+            result,
+            `MCP[${serverName}]::${actualToolName}`,
+            params
+          );
           if (!confirmed) {
-            console.log(`${indent}${colors.warning(`⚠️  [Smart Mode] User cancelled MCP tool execution`)}`);
+            if (isSdkMode && sdkOutputAdapter) {
+              sdkOutputAdapter.outputWarning(`[Smart Mode] User cancelled MCP tool execution`);
+            } else {
+              console.log(
+                `${indent}${colors.warning(`⚠️  [Smart Mode] User cancelled MCP tool execution`)}`
+              );
+            }
             throw new Error(`Tool execution cancelled by user: ${toolName}`);
           }
         } else {
-          console.log(`${indent}${colors.error(`❌ [Smart Mode] MCP tool execution rejected`)}`);
-          console.log(`${indent}${colors.textDim(`  Reason: ${result.description}`)}`);
+          if (isSdkMode && sdkOutputAdapter) {
+            sdkOutputAdapter.outputError(`[Smart Mode] MCP tool execution rejected`, { reason: result.description });
+          } else {
+            console.log(`${indent}${colors.error(`❌ [Smart Mode] MCP tool execution rejected`)}`);
+            console.log(`${indent}${colors.textDim(`  Reason: ${result.description}`)}`);
+          }
           throw new Error(`Tool execution rejected: ${toolName}`);
         }
       }