@xagent-ai/cli 1.2.2 → 1.3.1

package/dist/tools.js

@@ -1,18 +1,21 @@
 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 { ExecutionMode, AuthType } from './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';
-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
 //
@@ -64,8 +67,16 @@ export class ReadTool {
 - Use offset and limit for large files to avoid loading entire content
 - 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) {
+        if (!params || typeof params.filePath !== 'string') {
+            throw new Error('filePath is required and must be a string');
+        }
         const { filePath, offset = 0, limit } = params;
         try {
             // Handle ~ (user home directory) in file paths
@@ -82,10 +93,18 @@ export class ReadTool {
             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) {
             // Show user-friendly path in error message
@@ -146,7 +165,7 @@ export class WriteTool {
                 message: `Successfully wrote to ${filePath}`,
                 filePath,
                 lineCount,
-                preview: isTruncated ? preview + '\n...' : preview
+                preview: isTruncated ? preview + '\n...' : preview,
             };
         }
         catch (error) {
@@ -156,7 +175,7 @@ export class WriteTool {
 }
 export class GrepTool {
     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
@@ -173,89 +192,41 @@ export class GrepTool {
 # 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) {
-        const { pattern, path: searchPath = '.', include, exclude, case_sensitive = false, fixed_strings = false, context, after, before, no_ignore = false } = params;
+        const { pattern, path: searchPath = '.', glob: includeGlob, ignoreCase = false, literal = false, context, 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 = [];
-            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 = [];
-                            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) {
             throw new Error(`Grep failed: ${error.message}`);
@@ -287,13 +258,23 @@ export class BashTool {
 - \`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
@@ -301,7 +282,9 @@ export class BashTool {
 - Use absolute paths or paths relative to project root`;
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
-        const { command, cwd, description, timeout = 120, run_in_bg = false } = params;
+        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;
@@ -318,26 +301,104 @@ export class BashTool {
             // 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');
+        // 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 = 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;
+        if (skillNodeModulesPath) {
+            nodePath = `${skillNodeModulesPath}${path.delimiter}${builtinNodeModulesPath}`;
+        }
+        else {
+            nodePath = builtinNodeModulesPath;
+        }
         const env = {
             ...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 = {
                     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 = [];
                 childProcess.stdout?.on('data', (data) => {
                     const text = data.toString();
@@ -347,44 +408,128 @@ export class BashTool {
                     const text = data.toString();
                     output.push(text);
                 });
-                childProcess.on('close', (code) => {
-                    console.log(`Background task ${taskId} exited with code ${code}`);
+                childProcess.on('close', (_code) => {
+                    // 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.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) {
+            // 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.
+     */
+    spawnWithTimeout(shell, args, options) {
+        return new Promise((resolve, reject) => {
+            const { cwd, env, timeout } = options;
+            let timedOut = false;
+            let timeoutHandle;
+            const spawnOptions = {
+                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 = [];
+            const stderrChunks = [];
+            // 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) => {
+                stdoutChunks.push(data);
+            });
+            // Stream stderr
+            child.stderr?.on('data', (data) => {
+                stderrChunks.push(data);
+            });
+            // Handle process exit
+            child.on('close', (code) => {
+                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 {
     name = 'ListDirectory';
@@ -416,7 +561,12 @@ export class ListDirectoryTool {
 - 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) {
         const { path: dirPath = '.', recursive = false } = params;
         try {
@@ -429,9 +579,9 @@ export class ListDirectoryTool {
             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) {
             throw new Error(`Failed to list directory: ${error.message}`);
@@ -440,7 +590,7 @@ export class ListDirectoryTool {
 }
 export class SearchFilesTool {
     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)
@@ -475,21 +625,35 @@ export class SearchFilesTool {
 - 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) {
         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;
             return {
                 files: result,
                 total,
-                truncated
+                truncated,
             };
         }
         catch (error) {
@@ -532,7 +696,7 @@ export class DeleteFileTool {
             return {
                 success: true,
                 message: `Successfully deleted ${filePath}`,
-                filePath
+                filePath,
             };
         }
         catch (error) {
@@ -574,7 +738,7 @@ export class CreateDirectoryTool {
             await fs.mkdir(absolutePath, { recursive });
             return {
                 success: true,
-                message: `Successfully created directory ${dirPath}`
+                message: `Successfully created directory ${dirPath}`,
             };
         }
         catch (error) {
@@ -584,29 +748,29 @@ export class CreateDirectoryTool {
 }
 // 编辑工具辅助函数
 function detectLineEnding(content) {
-    const crlfIdx = content.indexOf("\r\n");
-    const lfIdx = content.indexOf("\n");
+    const crlfIdx = content.indexOf('\r\n');
+    const lfIdx = content.indexOf('\n');
     if (lfIdx === -1)
-        return "\n";
+        return '\n';
     if (crlfIdx === -1)
-        return "\n";
-    return crlfIdx < lfIdx ? "\r\n" : "\n";
+        return '\n';
+    return crlfIdx < lfIdx ? '\r\n' : '\n';
 }
 function normalizeToLF(text) {
-    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, ending) {
-    return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
+    return ending === '\r\n' ? text.replace(/\n/g, '\r\n') : text;
 }
 function normalizeForFuzzyMatch(text) {
-    return (text
-        .split("\n")
+    return text
+        .split('\n')
         .map((line) => line.trimEnd())
-        .join("\n")
+        .join('\n')
         .replace(/['‘’""]/g, "'")
         .replace(/["""]/g, '"')
-        .replace(/[—–‑−]/g, "-")
-        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " "));
+        .replace(/[—–‑−]/g, '-')
+        .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, ' ');
 }
 function fuzzyFindText(content, oldText) {
     const exactIndex = content.indexOf(oldText);
@@ -640,14 +804,16 @@ function fuzzyFindText(content, oldText) {
     };
 }
 function stripBom(content) {
-    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, newContent, contextLines = 4) {
-    const diffModule = await import("diff");
+    const diffModule = await import('diff');
     const parts = diffModule.diffLines(oldContent, newContent);
     const output = [];
-    const oldLines = oldContent.split("\n");
-    const newLines = newContent.split("\n");
+    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;
@@ -656,8 +822,8 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
     let firstChangedLine;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
-        const raw = part.value.split("\n");
-        if (raw[raw.length - 1] === "") {
+        const raw = part.value.split('\n');
+        if (raw[raw.length - 1] === '') {
             raw.pop();
         }
         if (part.added || part.removed) {
@@ -666,12 +832,12 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
             }
             for (const line of raw) {
                 if (part.added) {
-                    const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(newLineNum).padStart(lineNumWidth, ' ');
                     output.push(`+${lineNum} ${line}`);
                     newLineNum++;
                 }
                 else {
-                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
                     output.push(`-${lineNum} ${line}`);
                     oldLineNum++;
                 }
@@ -693,18 +859,18 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
                     linesToShow = linesToShow.slice(0, contextLines);
                 }
                 if (skipStart > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
                     oldLineNum += skipStart;
                     newLineNum += skipStart;
                 }
                 for (const line of linesToShow) {
-                    const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+                    const lineNum = String(oldLineNum).padStart(lineNumWidth, ' ');
                     output.push(` ${lineNum} ${line}`);
                     oldLineNum++;
                     newLineNum++;
                 }
                 if (skipEnd > 0) {
-                    output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+                    output.push(` ${''.padStart(lineNumWidth, ' ')} ...`);
                 }
             }
             else {
@@ -714,7 +880,7 @@ async function generateDiffString(oldContent, newContent, contextLines = 4) {
             lastWasChange = false;
         }
     }
-    return { diff: output.join("\n"), firstChangedLine };
+    return { diff: output.join('\n'), firstChangedLine };
 }
 export class EditTool {
     name = 'Edit';
@@ -765,6 +931,8 @@ edit(
     allowedModes = [ExecutionMode.YOLO, ExecutionMode.ACCEPT_EDITS, ExecutionMode.SMART];
     async execute(params) {
         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
@@ -779,7 +947,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);
             const originalEnding = detectLineEnding(content);
@@ -817,7 +985,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);
             return {
                 success: true,
@@ -863,7 +1031,12 @@ export class WebSearchTool {
 - 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) {
         const { query } = params;
         try {
@@ -877,14 +1050,14 @@ export class WebSearchTool {
             }
             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) {
@@ -940,22 +1113,27 @@ 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];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     todoList = [];
     async execute(params) {
         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) {
@@ -987,7 +1165,12 @@ export class TodoReadTool {
 # 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,
+    ];
     todoWriteTool;
     constructor(todoWriteTool) {
         this.todoWriteTool = todoWriteTool;
@@ -997,14 +1180,14 @@ export class TodoReadTool {
             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) {
@@ -1051,7 +1234,12 @@ export class TaskTool {
 - 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];
+    allowedModes = [
+        ExecutionMode.YOLO,
+        ExecutionMode.ACCEPT_EDITS,
+        ExecutionMode.PLAN,
+        ExecutionMode.SMART,
+    ];
     async execute(params, _executionMode) {
         const mode = params.executionMode || _executionMode || ExecutionMode.YOLO;
         try {
@@ -1059,16 +1247,13 @@ export class TaskTool {
             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, params.description, mode, agentManager, toolRegistry, aiClient);
+                return await this.executeParallelAgents(params.agents, params.description, mode, agentManager, toolRegistry, config);
             }
             if (!params.subagent_type) {
                 throw new Error('subagent_type is required for Task tool');
@@ -1076,15 +1261,16 @@ export class TaskTool {
             // 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
-                }));
-            }
-            const result = await this.executeSingleAgent(params.subagent_type, prompt, params.description, params.useContext ?? true, params.constraints || [], mode, agentManager, toolRegistry, aiClient, config);
+                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(params.subagent_type, prompt, params.description, params.useContext ?? true, params.constraints || [], mode, agentManager, toolRegistry, config);
             return result;
         }
         catch (error) {
@@ -1095,11 +1281,16 @@ export class TaskTool {
      * 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
      */
-    createRemoteVlmCaller(remoteAIClient, taskId, localConfig, signal) {
+    createRemoteVlmCaller(remoteAIClient, taskId, localConfig, isFirstVlmCallRef, signal) {
         // Remote mode: use RemoteAIClient
         if (remoteAIClient) {
-            return this.createRemoteVLMCaller(remoteAIClient, taskId, signal);
+            return this.createRemoteVLMCaller(remoteAIClient, taskId, isFirstVlmCallRef, signal);
         }
         // Local mode: use local API
         return this.createLocalVLMCaller(localConfig, signal);
@@ -1107,11 +1298,24 @@ export class TaskTool {
     /**
      * 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
      */
-    createRemoteVLMCaller(remoteAIClient, taskId, signal) {
-        return async (messages, systemPrompt) => {
+    createRemoteVLMCaller(remoteAIClient, taskId, isFirstVlmCallRef, signal) {
+        return async (messages, systemPrompt, _taskId, _isFirstVlmCallRef) => {
             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) {
                 throw new Error(`Remote VLM call failed: ${error.message}`);
@@ -1141,7 +1345,7 @@ export class TaskTool {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${apiKey}`,
+                    Authorization: `Bearer ${apiKey}`,
                 },
                 body: JSON.stringify(requestBody),
                 signal: abortSignal,
@@ -1150,7 +1354,7 @@ export class TaskTool {
                 const errorText = await response.text();
                 throw new Error(`VLM API error: ${errorText}`);
             }
-            const result = await response.json();
+            const result = (await response.json());
             return result.choices?.[0]?.message?.content || '';
         };
     }
@@ -1160,30 +1364,63 @@ export class TaskTool {
      */
     async executeGUIAgent(prompt, description, agent, mode, config, indentLevel = 1, remoteAIClient) {
         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 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') || '';
+        // Get SDK adapter from session for SDK mode output
+        let sdkOutputAdapter = null;
+        let isSdkMode = false;
+        try {
+            const { getSingletonSession } = await import('./session.js');
+            const session = getSingletonSession();
+            if (session) {
+                isSdkMode = session.isSdkMode;
+                sdkOutputAdapter = session.sdkOutputAdapter;
+            }
+        }
+        catch {
+            // Session not available
+        }
+        // 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('');
         // Get taskId from session for tracking (remote mode only)
@@ -1194,27 +1431,31 @@ export class TaskTool {
                 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;
         let stdinPollingInterval = null;
         const cancellationManager = getCancellationManager();
         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);
+                    logger.debug(`[GUIAgent ESC] Raw mode enabled successfully`);
                 }
                 catch (e) {
-                    logger.debug(`[GUIAgent] Could not set raw mode: ${e}`);
+                    logger.debug(`[GUIAgent ESC] Could not set raw mode: ${e.message}`);
                 }
                 stdinPollingInterval = setInterval(() => {
                     try {
@@ -1222,14 +1463,23 @@ export class TaskTool {
                             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) {
+                        logger.debug(`[GUIAgent ESC Polling] Error: ${e.message}`);
                         // Ignore polling errors
                     }
                 }, 10);
@@ -1248,7 +1498,9 @@ export class TaskTool {
         };
         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
             const { createGUISubAgent } = await import('./gui-subagent/index.js');
@@ -1256,11 +1508,15 @@ export class TaskTool {
                 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
             const fullPrompt = prompt;
@@ -1278,7 +1534,7 @@ export class TaskTool {
                     success: true,
                     cancelled: true, // Mark as cancelled so main agent won't continue
                     message: `GUI task "${description}" cancelled by user`,
-                    result: 'Task cancelled'
+                    result: 'Task cancelled',
                 };
             }
             cleanupStdinPolling();
@@ -1286,28 +1542,96 @@ export class TaskTool {
             // Flush stdout to ensure all output is displayed before returning
             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) => ({
+                ...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) => 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) => c.from === 'assistant' && c.actionType)
+                            .map((c) => 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) => 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) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => 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) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => 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) => c.from === 'human' && c.screenshotContext).length,
+                        actions: conversationsWithoutScreenshots
+                            .filter((c) => c.from === 'assistant' && c.actionType)
+                            .map((c) => c.actionType),
+                        conversations: conversationsWithoutScreenshots,
+                        error: result.error,
+                    },
                 };
             }
         }
@@ -1319,32 +1643,58 @@ export class TaskTool {
             // 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
                     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}`,
             };
         }
     }
-    async executeSingleAgent(subagent_type, prompt, description, useContext, constraints, mode, agentManager, toolRegistry, aiClient, config, indentLevel = 1) {
+    async executeSingleAgent(subagent_type, prompt, description, useContext, constraints, mode, agentManager, toolRegistry, config, indentLevel = 1) {
         const agent = agentManager.getAgent(subagent_type);
         if (!agent) {
             throw new Error(`Agent ${subagent_type} not found`);
         }
+        // Get SDK adapter from session for subagent output
+        let sdkOutputAdapter = null;
+        let isSdkMode = false;
+        try {
+            const { getSingletonSession } = await import('./session.js');
+            const session = getSingletonSession();
+            if (session) {
+                isSdkMode = session.isSdkMode;
+                sdkOutputAdapter = session.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)
@@ -1356,7 +1706,7 @@ export class TaskTool {
                     remoteAIClient = session.getRemoteAIClient();
                 }
             }
-            catch (e) {
+            catch {
                 // Session not available, keep undefined
                 remoteAIClient = undefined;
             }
@@ -1385,28 +1735,55 @@ export class TaskTool {
                 modelName = agent.model;
             }
         }
-        // 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 = 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 = [];
         // Helper function to indent multi-line content
         const indentMultiline = (content, baseIndent) => {
-            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}\n\nConstraints:\n${constraints.map((c) => `- ${c}`).join('\n')}`
             : prompt;
         // Set up raw mode and stdin polling for ESC detection
         const cancellationManager = getCancellationManager();
@@ -1432,14 +1809,15 @@ export class TaskTool {
                             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);
@@ -1466,9 +1844,9 @@ export class TaskTool {
                 throw new Error('Operation cancelled by user');
             }
         };
-        let messages = [
+        const messages = [
             { role: 'system', content: enhancedSystemPrompt },
-            { role: 'user', content: fullPrompt }
+            { role: 'user', content: fullPrompt },
         ];
         const availableTools = agentManager.getAvailableToolsForAgent(agent, mode);
         const allToolDefinitions = toolRegistry.getToolDefinitions();
@@ -1482,21 +1860,34 @@ export class TaskTool {
                 function: {
                     name: toolName,
                     description: `Tool: ${toolName}`,
-                    parameters: { type: 'object', properties: {}, required: [] }
-                }
+                    parameters: { type: 'object', properties: {}, required: [] },
+                },
             };
         });
         let iteration = 0;
-        const maxIterations = 10;
-        while (iteration < maxIterations) {
+        let lastContentStr = ''; // Track last content for final result
+        // 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();
-            // Use withCancellation to make API call cancellable
-            const result = await cancellationManager.withCancellation(subAgentClient.chatCompletion(messages, {
+            // Prepare chat options with taskId and model names for remote mode
+            const chatOptions = {
                 tools: toolDefinitions,
-                temperature: 0.7
-            }), `api-${subagent_type}-${iteration}`);
+                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, chatOptions), `api-${subagent_type}-${iteration}`));
             // Check for cancellation after API call
             checkCancellation();
             if (!result || !result.choices || result.choices.length === 0) {
@@ -1514,8 +1905,8 @@ export class TaskTool {
             }
             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;
             }
@@ -1531,133 +1922,77 @@ export class TaskTool {
             if (choice.finish_reason === 'length') {
                 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 = { role: 'assistant', content: contentStr };
+            if (toolCalls && toolCalls.length > 0) {
+                assistantMessage.tool_calls = toolCalls;
+            }
+            if (reasoningContent) {
+                assistantMessage.reasoning_content = reasoningContent;
+            }
+            messages.push(assistantMessage);
             // 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, index) => {
                     const { name, arguments: params } = toolCall.function;
                     let parsedParams;
                     try {
                         parsedParams = typeof params === 'string' ? JSON.parse(params) : params;
                     }
-                    catch (e) {
+                    catch {
                         parsedParams = params;
                     }
-                    console.log(`${indent}${colors.textMuted(`${icons.loading} Tool: ${name}`)}`);
+                    return { name, params: parsedParams, id: toolCall.id, index };
+                });
+                // Display all tool call info first
+                for (const tc of preparedToolCalls) {
+                    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) => {
                     try {
                         // Check cancellation before tool execution
                         checkCancellation();
-                        const toolResult = await cancellationManager.withCancellation(toolRegistry.execute(name, parsedParams, mode, indent), `subagent-${subagent_type}-${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 = {
-                                    '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
-                        });
+                        const toolResult = await cancellationManager.withCancellation(toolRegistry.execute(tc.name, tc.params, mode, indent), `subagent-${subagent_type}-${tc.name}-${iteration}`);
+                        return { ...tc, toolResult, error: undefined };
                     }
                     catch (error) {
                         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;
@@ -1669,78 +2004,195 @@ export class TaskTool {
                                     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,
+                                    },
+                                },
                             };
                         }
-                        console.log(`${indent}${colors.error(`${icons.cross} Error:`)} ${error.message}\n`);
+                        return { ...tc, toolResult: undefined, error: error.message };
+                    }
+                });
+                const settledResults = await Promise.all(executePromises);
+                // Check for cancellation in results
+                const cancellationResult = settledResults.find((r) => 'success' in r && r.success === false);
+                if (cancellationResult) {
+                    return cancellationResult;
+                }
+                const resultsByIndex = new Map();
+                const usedIndices = new Set();
+                for (const result of settledResults) {
+                    // Find the first unused original index that matches the tool name
+                    const originalIndex = preparedToolCalls.findIndex((tc, idx) => 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: error.message,
-                            timestamp: new Date().toISOString()
+                            error,
+                            timestamp: new Date().toISOString(),
                         });
                         messages.push({
                             role: 'tool',
-                            content: JSON.stringify({ error: error.message }),
-                            tool_call_id: toolCall.id
+                            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 = {
+                                        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: 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;
         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
-                }
-            }
+                },
+            },
         };
     }
-    async executeParallelAgents(agents, description, mode, agentManager, toolRegistry, aiClient, indentLevel = 1) {
+    async executeParallelAgents(agents, description, mode, agentManager, toolRegistry, config, indentLevel = 1) {
         const indent = '  '.repeat(indentLevel);
         const indentNext = '  '.repeat(indentLevel + 1);
         const cancellationManager = getCancellationManager();
@@ -1765,14 +2217,15 @@ export class TaskTool {
                             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);
@@ -1794,23 +2247,23 @@ export class TaskTool {
         cancellationManager.on('cancelled', cancelHandler);
         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',
                 };
             }
             try {
-                const result = await this.executeSingleAgent(agentTask.subagent_type, agentTask.prompt, agentTask.description, agentTask.useContext ?? true, agentTask.constraints || [], mode, agentManager, toolRegistry, aiClient, indentLevel + 1);
+                const result = await this.executeSingleAgent(agentTask.subagent_type, agentTask.prompt, agentTask.description, agentTask.useContext ?? true, agentTask.constraints || [], mode, agentManager, toolRegistry, config, indentLevel + 1);
                 return {
                     success: true,
                     agent: agentTask.subagent_type,
                     description: agentTask.description,
-                    result: result.result
+                    result: result.result,
                 };
             }
             catch (error) {
@@ -1818,14 +2271,14 @@ export class TaskTool {
                     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);
+        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) {
@@ -1841,16 +2294,16 @@ export class TaskTool {
         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,
+            })),
         };
     }
 }
@@ -1882,7 +2335,12 @@ export class ReadBashOutputTool {
 - 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) {
         const { task_id, poll_interval = 10 } = params;
         try {
@@ -1892,7 +2350,7 @@ export class ReadBashOutputTool {
                 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';
@@ -1900,7 +2358,7 @@ export class ReadBashOutputTool {
                 taskId: task_id,
                 output,
                 status,
-                duration: Math.floor(duration / 1000)
+                duration: Math.floor(duration / 1000),
             };
         }
         catch (error) {
@@ -1936,7 +2394,12 @@ export class WebFetchTool {
 - 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) {
         const { prompt } = params;
         try {
@@ -1948,7 +2411,7 @@ export class WebFetchTool {
             const response = await axios.get(url, {
                 timeout: 30000,
                 maxContentLength: 10 * 1024 * 1024,
-                validateStatus: () => true
+                validateStatus: () => true,
             });
             let content = response.data;
             if (typeof content === 'object') {
@@ -1957,7 +2420,7 @@ export class WebFetchTool {
             return {
                 content,
                 url,
-                status: response.status
+                status: response.status,
             };
         }
         catch (error) {
@@ -1998,8 +2461,26 @@ export class AskUserQuestionTool {
 - 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) {
+        // Check if in SDK mode
+        const sdkMode = this._sdkMode;
+        const sdkAdapter = this._sdkOutputAdapter;
+        if (sdkMode && sdkAdapter) {
+            return this.executeSdk(params, sdkAdapter);
+        }
+        // Regular TUI mode
+        return this.executeTui(params);
+    }
+    /**
+     * Execute in TUI mode using @clack/prompts
+     */
+    async executeTui(params) {
         const { questions } = params;
         try {
             if (questions.length === 0 || questions.length > 4) {
@@ -2008,26 +2489,18 @@ export class AskUserQuestionTool {
             const answers = [];
             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);
                 }
                 else {
-                    const result = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'answer',
-                            message: q.question
-                        }
-                    ]);
-                    answers.push(result.answer);
+                    const result = (await text({
+                        message: q.question,
+                    }));
+                    answers.push(result);
                 }
             }
             return { answers };
@@ -2036,6 +2509,38 @@ export class AskUserQuestionTool {
             throw new Error(`Failed to ask user questions: ${error.message}`);
         }
     }
+    /**
+     * Execute in SDK mode - output question request and wait for response
+     */
+    async executeSdk(params, sdkAdapter) {
+        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) {
+            throw new Error(`Failed to get SDK question response: ${error.message}`);
+        }
+    }
 }
 export class SaveMemoryTool {
     name = 'save_memory';
@@ -2066,7 +2571,12 @@ export class SaveMemoryTool {
 - 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) {
         const { fact } = params;
         try {
@@ -2075,7 +2585,7 @@ export class SaveMemoryTool {
             await memoryManager.saveMemory(fact, 'global');
             return {
                 success: true,
-                message: `Successfully saved fact to memory`
+                message: `Successfully saved fact to memory`,
             };
         }
         catch (error) {
@@ -2111,14 +2621,19 @@ export class ExitPlanModeTool {
 - 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) {
         const { plan } = params;
         try {
             return {
                 success: true,
                 message: 'Plan completed and ready for execution',
-                plan
+                plan,
             };
         }
         catch (error) {
@@ -2162,7 +2677,7 @@ export class XmlEscapeTool {
                 { char: '<', replacement: '&lt;' },
                 { char: '>', replacement: '&gt;' },
                 { char: '"', replacement: '&quot;' },
-                { char: "'", replacement: '&apos;' }
+                { char: "'", replacement: '&apos;' },
             ];
             let changes = 0;
             for (const { char, replacement } of specialChars) {
@@ -2177,7 +2692,7 @@ export class XmlEscapeTool {
                 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');
@@ -2192,7 +2707,7 @@ export class XmlEscapeTool {
             return {
                 success: true,
                 message: `Successfully escaped ${changes} character(s) in ${file_path}`,
-                changes
+                changes,
             };
         }
         catch (error) {
@@ -2232,7 +2747,12 @@ export class ImageReadTool {
 - 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) {
         const { image_input, prompt, task_brief, input_type = 'file_path', mime_type } = params;
         try {
@@ -2245,16 +2765,11 @@ export class ImageReadTool {
             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 = [
                 {
@@ -2262,19 +2777,19 @@ export class ImageReadTool {
                     content: [
                         {
                             type: 'text',
-                            text: textContent
+                            text: textContent,
                         },
                         {
                             type: 'image_url',
                             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 : '';
@@ -2283,8 +2798,8 @@ export class ImageReadTool {
                 image_info: {
                     input_type,
                     prompt,
-                    task_brief
-                }
+                    task_brief,
+                },
             };
         }
         catch (error) {
@@ -2365,7 +2880,6 @@ export class InvokeSkillTool {
         const { skillId, taskDescription, inputFile, outputFile, options } = params;
         try {
             const { getSkillInvoker } = await import('./skill-invoker.js');
-            const { SkillExecutionParams } = await import('./skill-invoker.js');
             const skillInvoker = getSkillInvoker();
             await skillInvoker.initialize();
             // Verify skill exists
@@ -2380,7 +2894,7 @@ export class InvokeSkillTool {
                         taskDescription,
                         inputFile,
                         outputFile,
-                        options
+                        options,
                     });
                     if (result.success) {
                         return {
@@ -2390,7 +2904,7 @@ export class InvokeSkillTool {
                             task: taskDescription,
                             result: result.output,
                             files: result.files,
-                            nextSteps: result.nextSteps
+                            nextSteps: result.nextSteps,
                         };
                     }
                     else {
@@ -2404,7 +2918,7 @@ export class InvokeSkillTool {
                 taskDescription,
                 inputFile,
                 outputFile,
-                options
+                options,
             });
             if (result.success) {
                 return {
@@ -2414,7 +2928,8 @@ export class InvokeSkillTool {
                     task: taskDescription,
                     result: result.output,
                     files: result.files,
-                    nextSteps: result.nextSteps
+                    nextSteps: result.nextSteps,
+                    skillPath: result.skillPath
                 };
             }
             else {
@@ -2495,6 +3010,8 @@ export class ToolRegistry {
     tools = new Map();
     todoWriteTool;
     backgroundTasks = new Map();
+    _isSdkMode = false;
+    _sdkOutputAdapter = null;
     constructor() {
         this.todoWriteTool = new TodoWriteTool();
         this.registerDefaultTools();
@@ -2542,7 +3059,8 @@ export class ToolRegistry {
         let registeredCount = 0;
         for (const [fullName, tool] of mcpTools) {
             const firstUnderscoreIndex = fullName.indexOf('__');
-            if (firstUnderscoreIndex === -1 || firstUnderscoreIndex === 0 ||
+            if (firstUnderscoreIndex === -1 ||
+                firstUnderscoreIndex === 0 ||
                 firstUnderscoreIndex === fullName.length - 2)
                 continue;
             const serverName = fullName.substring(0, firstUnderscoreIndex);
@@ -2577,17 +3095,41 @@ 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, adapter) {
+        this._isSdkMode = enabled;
+        this._sdkOutputAdapter = adapter;
+        // Mark all tools as SDK mode enabled
+        for (const [, tool] of this.tools) {
+            tool._sdkMode = enabled;
+            tool._sdkOutputAdapter = adapter;
+        }
+        // Initialize SDK mode for TaskTool specifically
+        const taskTool = this.tools.get('task');
+        if (taskTool) {
+            await taskTool.setSdkMode?.(enabled, adapter);
         }
     }
     /**
@@ -2621,11 +3163,11 @@ export class ToolRegistry {
         this.backgroundTasks.delete(taskId);
     }
     getToolDefinitions() {
-        return Array.from(this.tools.values()).map(tool => {
+        return Array.from(this.tools.values()).map((tool) => {
             let parameters = {
                 type: 'object',
                 properties: {},
-                required: []
+                required: [],
             };
             // Define specific parameters for each tool
             switch (tool.name) {
@@ -2635,18 +3177,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;
                 case 'Write':
@@ -2655,14 +3197,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;
                 case 'Grep':
@@ -2671,26 +3213,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")',
                             },
-                            case_sensitive: {
+                            ignoreCase: {
                                 type: 'boolean',
-                                description: 'Optional: Case-sensitive search (default: false)'
+                                description: 'Optional: Case-insensitive search (default: false)',
+                            },
+                            literal: {
+                                type: 'boolean',
+                                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;
                 case 'Bash':
@@ -2699,26 +3249,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;
                 case 'ListDirectory':
@@ -2727,14 +3277,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;
                 case 'SearchFiles':
@@ -2743,18 +3293,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;
                 case 'DeleteFile':
@@ -2763,10 +3313,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;
                 case 'CreateDirectory':
@@ -2775,14 +3325,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;
                 case 'Edit':
@@ -2791,22 +3341,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;
                 case 'web_search':
@@ -2815,10 +3365,10 @@ export class ToolRegistry {
                         properties: {
                             query: {
                                 type: 'string',
-                                description: 'The search query'
-                            }
+                                description: 'The search query',
+                            },
                         },
-                        required: ['query']
+                        required: ['query'],
                     };
                     break;
                 case 'todo_write':
@@ -2833,21 +3383,24 @@ 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;
                 case 'todo_read':
                     parameters = {
                         type: 'object',
                         properties: {},
-                        required: []
+                        required: [],
                     };
                     break;
                 case 'task':
@@ -2856,7 +3409,7 @@ 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',
@@ -2866,50 +3419,66 @@ export class ToolRegistry {
                                     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;
                 case 'ReadBashOutput':
@@ -2918,14 +3487,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;
                 case 'web_fetch':
@@ -2934,10 +3503,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;
                 case 'ask_user_question':
@@ -2955,15 +3524,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;
                 case 'save_memory':
@@ -2972,10 +3541,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;
                 case 'exit_plan_mode':
@@ -2984,10 +3553,10 @@ export class ToolRegistry {
                         properties: {
                             plan: {
                                 type: 'string',
-                                description: 'The plan to present'
-                            }
+                                description: 'The plan to present',
+                            },
                         },
-                        required: ['plan']
+                        required: ['plan'],
                     };
                     break;
                 case 'xml_escape':
@@ -2996,14 +3565,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;
                 case 'image_read':
@@ -3012,27 +3581,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;
                 case 'Skill':
@@ -3041,17 +3610,17 @@ export class ToolRegistry {
                         properties: {
                             skill: {
                                 type: 'string',
-                                description: 'The skill name to execute'
-                            }
+                                description: 'The skill name to execute',
+                            },
                         },
-                        required: ['skill']
+                        required: ['skill'],
                     };
                     break;
                 case 'ListSkills':
                     parameters = {
                         type: 'object',
                         properties: {},
-                        required: []
+                        required: [],
                     };
                     break;
                 case 'GetSkillDetails':
@@ -3060,13 +3629,13 @@ 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;
                     if (mcpTool._isMcpTool && mcpTool.inputSchema) {
@@ -3074,13 +3643,13 @@ export class ToolRegistry {
                         parameters = {
                             type: 'object',
                             properties: {},
-                            required: []
+                            required: [],
                         };
                         if (mcpTool.inputSchema.properties) {
                             for (const [paramName, paramDef] of Object.entries(mcpTool.inputSchema.properties)) {
                                 parameters.properties[paramName] = {
                                     type: paramDef.type || 'string',
-                                    description: paramDef.description || ''
+                                    description: paramDef.description || '',
                                 };
                             }
                         }
@@ -3092,17 +3661,18 @@ export class ToolRegistry {
                         parameters = {
                             type: 'object',
                             properties: {},
-                            required: []
+                            required: [],
                         };
                     }
+                }
             }
             return {
                 type: 'function',
                 function: {
                     name: tool.name,
                     description: tool.description,
-                    parameters
-                }
+                    parameters,
+                },
             };
         });
     }
@@ -3121,14 +3691,14 @@ export class ToolRegistry {
             return await this.executeMCPTool(toolName, params, executionMode, indent);
         }
         // 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);
@@ -3149,6 +3719,8 @@ export class ToolRegistry {
         if (!tool.allowedModes.includes(executionMode)) {
             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';
@@ -3169,50 +3741,81 @@ 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}`);
             }
             const { getSmartApprovalEngine } = await import('./smart-approval.js');
             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}`);
             }
         }
@@ -3232,10 +3835,14 @@ export class ToolRegistry {
         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) {
             const debugMode = process.env.DEBUG === 'smart-approval';
@@ -3246,30 +3853,55 @@ export class ToolRegistry {
             const isRemoteMode = authConfig.type === AuthType.OAUTH_XAGENT;
             // 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}`);
                 }
             }