aiexecode 1.0.84 → 1.0.89

package/src/frontend/App.js

@@ -803,7 +803,7 @@ export function App({ onSubmit, onClearScreen, onExit, commands = [], model, ver
                 nextItem
             });
         })
-    , []);
+        , []);
 
     const renderHistoryItem = useCallback((item, index, prefix = 'history', allItems = []) => {
         const nextItem = allItems[index + 1];
@@ -1027,16 +1027,66 @@ export function App({ onSubmit, onClearScreen, onExit, commands = [], model, ver
         );
     }
 
-    return React.createElement(Box, { flexDirection: "column", padding: 1 },
+    return React.createElement(Box, { flexDirection: "column", padding: 0 },
         // History area (grows to fill available space, shrinks when needed)
         React.createElement(Box, {
             flexDirection: "column",
             flexGrow: 1,
             flexShrink: 1,
-            overflow: 'hidden'  // Prevent history from pushing out fixed elements
+            overflow: 'hidden',  // Prevent history from pushing out fixed elements
+            gap: 0  // No gap between children
         },
+            // React.createElement(BlankLine, {
+            //     reason: 'separator between static and dynamic',
+            //     afterType: 'static_area',
+            //     beforeType: 'dynamic_area',
+            //     content: '---DYNAMIC1---'
+            // }),
+
+            // ===== Static 영역 시작 =====
             // Static items: Header와 히스토리 포함
-            React.createElement(Static, { items: staticItems }, (item) => item)
+            React.createElement(Box, { marginBottom: 0, paddingBottom: 0 },
+                React.createElement(Static, { items: staticItems }, (item) => item)
+            ),
+            // ===== Static 영역 끝 =====
+
+            // Static과 Dynamic 사이 구분선
+            // React.createElement(BlankLine, {
+            //     reason: 'separator between static and dynamic',
+            //     afterType: 'static_area',
+            //     beforeType: 'dynamic_area',
+            //     content: '---DYNAMIC2---'
+            // }),
+
+            // ===== Dynamic 영역 시작 =====
+            // Dynamic pending items: 실행 중인 도구들을 즉시 표시
+            pendingHistory.length > 0 && pendingHistory.flatMap((item, index) => {
+                const nextItem = pendingHistory[index + 1];
+                const elements = [
+                    React.createElement(ConversationItem, {
+                        key: `pending-${index}`,
+                        item,
+                        terminalWidth,
+                        nextItem,
+                        isPending: true  // Pending 상태 전달
+                    })
+                ];
+
+                // 각 pending 아이템 뒤에 BlankLine 추가
+                elements.push(
+                    React.createElement(BlankLine, {
+                        key: `pending-blank-${index}`,
+                        reason: 'after pending item',
+                        afterType: item.type,
+                        afterToolName: item.toolName,
+                        beforeType: nextItem ? nextItem.type : null,
+                        content: '　'
+                    })
+                );
+
+                return elements;
+            })
+            // ===== Dynamic 영역 끝 =====
         ),
 
         // Fixed input/control area (does not shrink, stays at bottom)

package/src/frontend/components/BlankLine.js

@@ -47,14 +47,16 @@ import { createDebugLogger } from '../../util/debug_log.js';
 
 const debugLog = createDebugLogger('ui_components.log', 'BlankLine');
 
-export function BlankLine({ reason, afterType, afterToolName, beforeType }) {
+export function BlankLine({ reason, afterType, afterToolName, beforeType, content = '　' }) {
+    // if (content === '　') content = 'aaaaa';
     // 디버그 모드에서만 빈 줄 정보 로깅
     React.useEffect(() => {
-        debugLog(`[BlankLine] Rendered - reason: ${reason}, after: ${afterType}${afterToolName ? `(${afterToolName})` : ''}, before: ${beforeType || 'N/A'}`);
+        debugLog(`[BlankLine] Rendered - reason: ${reason}, after: ${afterType}${afterToolName ? `(${afterToolName})` : ''}, before: ${beforeType || 'N/A'}, content: ${content}`);
     }, []);
 
     // 빈 줄은 공백 문자를 포함한 Text로 렌더링
     // Ink의 flexDirection: 'column'에서 각 컴포넌트는 한 줄씩 차지하므로
     // Text(' ')는 한 줄의 빈 줄로 렌더링됨
-    return React.createElement(Text, null, '　');
+    // content prop으로 표시할 내용을 커스터마이징 가능
+    return React.createElement(Text, null, content);
 }

package/src/frontend/components/ConversationItem.js

@@ -79,11 +79,11 @@ const TYPE_CONFIG = {
     assistant_progress: { icon: '  ', color: theme.text.secondary, bold: false },  // 중간 안내 메시지
     system: { icon: '* ', color: theme.text.secondary, bold: false },
     error: { icon: '✗ ', color: theme.status.error, bold: true },
-    tool: { icon: '⚙ ', color: theme.status.success, bold: false },
-    tool_start: { icon: '⚙ ', color: theme.status.success, bold: true },
+    tool: { icon: '• ', color: theme.status.success, bold: false },
+    tool_start: { icon: '• ', color: theme.status.success, bold: true },
     tool_result: { icon: '  ㄴ', color: theme.text.secondary, bold: false },
     thinking: { icon: '◇ ', color: theme.text.link, bold: false },
-    code_execution: { icon: '▶ ', color: theme.status.warning, bold: false },
+    code_execution: { icon: '• ', color: theme.status.warning, bold: false },
     code_result: { icon: '◀ ', color: theme.status.success, bold: false },
     default: { icon: '• ', color: theme.text.primary, bold: false }
 };
@@ -92,7 +92,7 @@ function getTypeConfig(type) {
     return TYPE_CONFIG[type] || TYPE_CONFIG.default;
 }
 
-function CodeExecutionDisplay({ item, hasFollowingResult, nextItem }) {
+function CodeExecutionDisplay({ item, hasFollowingResult, nextItem, isPending }) {
     const config = getTypeConfig(item.type);
 
     const languageName = item.language.charAt(0).toUpperCase() + item.language.slice(1);
@@ -101,6 +101,19 @@ function CodeExecutionDisplay({ item, hasFollowingResult, nextItem }) {
     const resultStderr = item.result?.stderr || nextItem?.stderr;
     const isDenied = resultStderr?.includes('User denied code execution');
 
+    // Blinking icon for pending state
+    const [showIcon, setShowIcon] = useState(true);
+    useEffect(() => {
+        if (isPending) {
+            const interval = setInterval(() => {
+                setShowIcon(prev => !prev);
+            }, 500); // 0.5초 간격으로 깜빡임
+            return () => clearInterval(interval);
+        } else {
+            setShowIcon(true);
+        }
+    }, [isPending]);
+
     /**
      * 간격: marginBottom 항상 0
      * 빈 줄은 BlankLine 컴포넌트로 관리됨
@@ -109,10 +122,13 @@ function CodeExecutionDisplay({ item, hasFollowingResult, nextItem }) {
      */
     const marginBottom = 0;
 
+    // Pending 상태일 때는 회색, 아니면 기본 색상
+    const iconColor = isPending ? theme.text.secondary : config.color;
+
     if (isDenied) {
         return React.createElement(Box, { flexDirection: "column", marginBottom, marginLeft: 2 },
             React.createElement(Box, { flexDirection: "row", marginBottom: 0 },
-                React.createElement(Text, { color: config.color, bold: true }, config.icon),
+                React.createElement(Text, { color: iconColor, bold: true }, showIcon ? config.icon : '  '),
                 React.createElement(Text, { color: theme.text.primary }, 'Executing '),
                 React.createElement(Text, { color: theme.status.warning, bold: true }, languageName)
             ),
@@ -124,7 +140,7 @@ function CodeExecutionDisplay({ item, hasFollowingResult, nextItem }) {
 
     return React.createElement(Box, { flexDirection: "column", marginBottom, marginLeft: 2 },
         React.createElement(Box, { flexDirection: "row", marginBottom: 0 },
-            React.createElement(Text, { color: config.color, bold: true }, config.icon),
+            React.createElement(Text, { color: iconColor, bold: true }, showIcon ? config.icon : '  '),
             React.createElement(Text, { color: theme.text.primary }, 'Executing '),
             React.createElement(Text, { color: theme.status.warning, bold: true }, languageName),
             // React.createElement(Text, { color: theme.text.primary }, ' code:')
@@ -177,6 +193,19 @@ function StandardDisplay({ item, isPending, hasFollowingResult, nextItem, isLast
     const { type, text, operations = [], toolName, toolInput, args } = item;
     const config = getTypeConfig(type);
 
+    // Blinking icon for pending tool_start
+    const [showIcon, setShowIcon] = useState(true);
+    useEffect(() => {
+        if (isPending && type === 'tool_start') {
+            const interval = setInterval(() => {
+                setShowIcon(prev => !prev);
+            }, 500); // 0.5초 간격으로 깜빡임
+            return () => clearInterval(interval);
+        } else {
+            setShowIcon(true);
+        }
+    }, [isPending, type]);
+
     debugLog('---------- StandardDisplay START ----------');
     debugLog(`type: ${type}, toolName: ${toolName || 'N/A'}`);
     debugLog(`text: ${typeof text === 'string' ? text?.substring(0, 100) : JSON.stringify(text)?.substring(0, 100) || 'N/A'}...`);
@@ -727,13 +756,17 @@ function StandardDisplay({ item, isPending, hasFollowingResult, nextItem, isLast
 
         // Check if this tool was denied by user
         const originalResult = item.result?.originalResult || nextItem?.result?.originalResult;
-        const isDenied = originalResult?.operation_successful === false && 
+        const isDenied = originalResult?.operation_successful === false &&
                         originalResult?.error_message === 'User denied tool execution';
 
+        // Pending 상태일 때는 회색, 아니면 기본 색상
+        const iconColor = isPending ? theme.text.secondary : config.color;
+        const displayIcon = showIcon ? config.icon : '  ';
+
         if (isDenied) {
             return React.createElement(Box, { flexDirection: "column", marginBottom, marginTop, marginLeft: 2 },
                 React.createElement(Box, { flexDirection: "row" },
-                    React.createElement(Text, { color: config.color, bold: config.bold }, config.icon),
+                    React.createElement(Text, { color: iconColor, bold: config.bold }, displayIcon),
                     React.createElement(Text, { color: 'white', bold: true }, displayName)
                 ),
                 React.createElement(Box, { marginLeft: 2, marginTop: 0 },
@@ -744,7 +777,7 @@ function StandardDisplay({ item, isPending, hasFollowingResult, nextItem, isLast
 
         return React.createElement(Box, { flexDirection: "column", marginBottom, marginTop, marginLeft: 2 },
             React.createElement(Box, { flexDirection: "row" },
-                React.createElement(Text, { color: config.color, bold: config.bold }, config.icon),
+                React.createElement(Text, { color: iconColor, bold: config.bold }, displayIcon),
                 React.createElement(Text, {
                     color: 'white',
                     bold: true
@@ -824,7 +857,7 @@ export function ConversationItem({ item, isPending = false, terminalWidth, nextI
     if (item.type === 'code_execution' && item.code && item.language) {
         const hasFollowingResult = nextItem && nextItem.type === 'code_result';
         debugLog('Rendering CodeExecutionDisplay');
-        return React.createElement(CodeExecutionDisplay, { item, hasFollowingResult, nextItem });
+        return React.createElement(CodeExecutionDisplay, { item, hasFollowingResult, nextItem, isPending });
     }
 
     if (item.type === 'code_result') {

package/src/system/code_executer.js

@@ -225,6 +225,9 @@ export async function execPythonCode(python_code, args = [], timeoutMs = 1200000
     debugLog(`[execPythonCode] Args: ${JSON.stringify(args)}`);
     debugLog(`[execPythonCode] Timeout: ${timeoutMs}ms`);
 
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     debugLog(`[execPythonCode] Creating/checking virtual environment...`);
     const venvPath = await makePythonVirtualEnv(process.env.PYTHON_VENV_PATH || "venv");
 
@@ -329,6 +332,9 @@ export async function execShellScript(script, timeoutMs = 1200000) {
     debugLog(`[execShellScript] Script preview (first 200 chars): ${script.substring(0, 200)}${script.length > 200 ? '...' : ''}`);
     debugLog(`[execShellScript] Timeout: ${timeoutMs}ms`);
 
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     debugLog(`[execShellScript] Finding shell executable...`);
     let shellPath = await whichCommand("bash") || await whichCommand("sh");
     if (!shellPath) {

package/src/system/mcp_integration.js

@@ -15,8 +15,7 @@ const debugLog = createDebugLogger('mcp_integration.log', 'mcp_integration');
  */
 
 export class MCPIntegration {
-  constructor(projectRoot = process.cwd()) {
-    this.projectRoot = projectRoot;
+  constructor() {
     this.mcpAgent = null;
     this.isInitialized = false;
     this.mcpTools = new Map(); // toolName -> { server, schema, execute }
@@ -27,61 +26,84 @@ export class MCPIntegration {
    */
   async initialize() {
     try {
-      debugLog('MCP Integration initializing...');
+      debugLog('[MCP] Integration initializing...');
 
-      // 전역 설정 로드
+      // MCP 서버 설정 파일(~/.aiexe/mcp_config.json)에서 전역 설정 로드
+      debugLog('[MCP] Loading MCP config from ~/.aiexe/mcp_config.json');
       const mergedServers = await loadMergedMcpConfig();
 
-      // Skip if no MCP servers are configured
+      // MCP 서버가 설정되지 않은 경우 초기화 중단
       if (Object.keys(mergedServers).length === 0) {
-        debugLog('No MCP servers configured.');
-        debugLog('   Use "aiexecode mcp add" to configure servers.');
+        debugLog('[MCP] No MCP servers configured.');
+        debugLog('[MCP]   Use "aiexecode mcp add" to configure servers.');
         return { success: false, reason: 'no_servers' };
       }
 
-      // 환경 변수 확장
+      debugLog(`[MCP] Found ${Object.keys(mergedServers).length} server(s) in config: ${Object.keys(mergedServers).join(', ')}`);
+
+      // 각 서버 설정의 환경 변수 확장 (${VAR} 형식을 실제 값으로 치환)
+      debugLog('[MCP] Expanding environment variables in server configs...');
       const servers = {};
       for (const [name, config] of Object.entries(mergedServers)) {
         try {
+          debugLog(`[MCP]   Processing server '${name}' (type: ${config.type})`);
           servers[name] = expandEnvVars(config);
+          debugLog(`[MCP]   ✓ Server '${name}' config ready`);
         } catch (error) {
-          debugLog(`Error expanding env vars for server '${name}': ${error.message}`);
-          debugLog(`   Skipping server '${name}'`);
+          debugLog(`[MCP]   ✗ Error expanding env vars for server '${name}': ${error.message}`);
+          debugLog(`[MCP]   Skipping server '${name}'`);
           continue;
         }
       }
 
       if (Object.keys(servers).length === 0) {
-        debugLog('No valid MCP servers after configuration processing.');
+        debugLog('[MCP] No valid MCP servers after configuration processing.');
         return { success: false, reason: 'no_valid_servers' };
       }
 
-      // MCP 설정 객체 생성
+      debugLog(`[MCP] ${Object.keys(servers).length} server(s) ready for connection`);
+
+      // mcp-agent-lib에 전달할 설정 객체 생성
       const config = {
         mcpServers: servers
       };
 
-      // mcp-agent-lib를 사용하여 MCP Agent 생성
+      // mcp-agent-lib의 createMCPAgent()를 호출하여 MCP Agent 인스턴스 생성
+      // MCP Agent는 여러 MCP 서버와의 연결 및 통신을 관리하는 핵심 객체
+      debugLog('[MCP] Creating MCP Agent instance via mcp-agent-lib...');
+      const logLevel = process.env.MCP_LOG_LEVEL || 'info';
+      const consoleDebug = process.env.MCP_DEBUG === 'true';
+      debugLog(`[MCP]   Log level: ${logLevel}, Console debug: ${consoleDebug}`);
+
       this.mcpAgent = await createMCPAgent({
-        logLevel: process.env.MCP_LOG_LEVEL || 'info',
-        enableConsoleDebug: process.env.MCP_DEBUG === 'true'
+        logLevel: logLevel,
+        enableConsoleDebug: consoleDebug
       });
+      debugLog('[MCP] MCP Agent instance created');
 
-      // MCP Agent 초기화 (서버 연결)
+      // MCP Agent 초기화: 설정된 모든 MCP 서버에 연결 시도
+      // stdio, http, sse 등 다양한 전송 방식을 지원
+      debugLog('[MCP] Initializing MCP Agent and connecting to servers...');
       await this.mcpAgent.initialize(config);
+      debugLog('[MCP] MCP Agent initialization complete');
 
-      // 사용 가능한 도구 목록 가져오기
+      // 연결된 모든 MCP 서버로부터 사용 가능한 도구(tool) 목록 조회
+      debugLog('[MCP] Fetching available tools from connected servers...');
       const availableTools = this.mcpAgent.getAvailableTools();
 
-      debugLog(`MCP Agent initialization complete: ${availableTools.length} tool(s) available`);
+      debugLog(`[MCP] Found ${availableTools.length} tool(s) across all servers`);
 
-      // 도구 정보를 맵에 저장
+      // 각 도구를 내부 맵에 저장하고 AI Agent 시스템에 등록
+      debugLog('[MCP] Registering tools to AI Agent system...');
       for (const tool of availableTools) {
-        // Description에 서버 정보를 명확하게 표시 (AI가 서버를 식별할 수 있도록)
+        debugLog(`[MCP]   Registering tool '${tool.name}' from server '${tool.server}'`);
+
+        // AI가 도구의 출처 서버를 명확히 인식할 수 있도록 설명에 서버 이름 추가
         const enhancedDescription = tool.description
           ? `[${tool.server} MCP] - ${tool.description}`
           : `MCP tool from ${tool.server}`;
 
+        // 도구 정보를 mcpTools Map에 저장 (toolName -> { server, schema, execute })
         this.mcpTools.set(tool.name, {
           server: tool.server,
           schema: {
@@ -93,46 +115,66 @@ export class MCPIntegration {
               required: []
             }
           },
+          // 도구 실행 함수: MCP Agent를 통해 실제 MCP 서버에 도구 실행 요청 전송
           execute: async (args) => {
-            return await this.mcpAgent.executeTool(tool.name, args);
+            debugLog(`[MCP] Executing tool '${tool.name}' on server '${tool.server}'`);
+            debugLog(`[MCP]   Args: ${JSON.stringify(args).substring(0, 200)}`);
+            const result = await this.mcpAgent.executeTool(tool.name, args);
+            debugLog(`[MCP]   Result: success=${result.success}`);
+            return result;
           }
         });
 
-        // UI 표시 설정 등록
+        // UI 시스템에 MCP 도구 표시 정보 등록
         registerMCPToolDisplay(tool.name, tool.server);
 
-        // 승인 시스템에 MCP 도구 등록
+        // 도구 승인 시스템에 MCP 도구 등록 (사용자 승인 필요 시 처리)
         registerMCPTool(tool.name, tool.server, tool.description || '');
 
-        debugLog(`  - ${tool.name} (from ${tool.server})`);
+        debugLog(`[MCP]   ✓ Tool '${tool.name}' registered`);
       }
 
       this.isInitialized = true;
+
+      const serverList = Array.from(this.mcpAgent.servers.keys());
+      debugLog(`[MCP] ========================================`);
+      debugLog(`[MCP] Integration initialized successfully!`);
+      debugLog(`[MCP]   Servers: ${serverList.join(', ')}`);
+      debugLog(`[MCP]   Tools: ${availableTools.length}`);
+      debugLog(`[MCP] ========================================`);
+
       return {
         success: true,
         toolCount: availableTools.length,
-        servers: Array.from(this.mcpAgent.servers.keys())
+        servers: serverList
       };
 
     } catch (error) {
-      debugLog(`MCP Integration initialization failed: ${error.message}`);
-      debugLog('   Continuing without MCP functionality.');
+      debugLog(`[MCP] ========================================`);
+      debugLog(`[MCP] Integration initialization FAILED`);
+      debugLog(`[MCP]   Error: ${error.message}`);
+      debugLog(`[MCP]   Stack: ${error.stack}`);
+      debugLog(`[MCP]   Continuing without MCP functionality.`);
+      debugLog(`[MCP] ========================================`);
       return { success: false, reason: 'initialization_error', error: error.message };
     }
   }
 
   /**
-   * MCP 도구 목록 반환 (기존 toolMap에 통합하기 위한 형식)
+   * MCP 도구 목록을 실행 가능한 함수 형태로 반환
+   * AI Agent의 기존 toolMap에 통합하기 위한 형식
    */
   getToolFunctions() {
     const toolFunctions = {};
 
     for (const [toolName, toolInfo] of this.mcpTools) {
+      // 각 도구에 대한 실행 함수 생성
       toolFunctions[toolName] = async (args) => {
         try {
+          // MCP Agent를 통해 도구 실행 (MCP 프로토콜로 서버와 통신)
           const result = await toolInfo.execute(args);
 
-          // MCP 결과를 기존 시스템 형식으로 변환
+          // MCP 서버의 응답을 AI Agent 시스템의 표준 형식으로 변환
           if (result.success) {
             return {
               operation_successful: true,
@@ -164,20 +206,21 @@ export class MCPIntegration {
   }
 
   /**
-   * MCP 도구 스키마 목록 반환 (Orchestrator에 전달하기 위한 형식)
+   * MCP 도구 스키마 목록을 OpenAI API 형식으로 반환
+   * Orchestrator가 AI 모델에게 사용 가능한 도구 목록을 전달할 때 사용
    */
   getToolSchemas() {
     const schemas = [];
 
     for (const [toolName, toolInfo] of this.mcpTools) {
-      // OpenAI API strict mode 요구사항에 맞게 스키마 변환
+      // MCP 서버가 제공한 inputSchema를 OpenAI function calling 형식으로 변환
       const inputSchema = toolInfo.schema.inputSchema || {};
       const properties = inputSchema.properties || {};
       const originalRequired = inputSchema.required || [];
 
-      // strict: true일 때는 required에 모든 properties 키가 포함되어야 함
-      // 하지만 이는 너무 엄격하므로, strict: false로 설정하거나
-      // additionalProperties: false를 추가하되 required는 원본 유지
+      // OpenAI API의 function calling 스키마 형식으로 변환
+      // strict: true는 모든 properties가 required에 포함되어야 하는 제약이 있어
+      // MCP 도구의 유연성을 위해 strict: false로 설정
       const cleanedSchema = {
         name: toolInfo.schema.name,
         description: toolInfo.schema.description,
@@ -219,21 +262,29 @@ export class MCPIntegration {
   }
 
   /**
-   * MCP Agent 정리 (프로그램 종료 시 호출)
+   * MCP Agent 정리 및 모든 서버 연결 종료
+   * 프로그램 종료 시 호출되어 리소스를 정리
    */
   async cleanup() {
     if (this.mcpAgent) {
       try {
-        // mcp-agent-lib는 cleanup() 메서드를 사용
+        debugLog('[MCP] Starting cleanup process...');
+        // mcp-agent-lib 버전에 따라 cleanup() 또는 disconnect() 메서드 호출
+        // 모든 MCP 서버와의 연결을 정상적으로 종료
         if (typeof this.mcpAgent.cleanup === 'function') {
+          debugLog('[MCP] Calling mcpAgent.cleanup()...');
           await this.mcpAgent.cleanup();
         } else if (typeof this.mcpAgent.disconnect === 'function') {
+          debugLog('[MCP] Calling mcpAgent.disconnect()...');
           await this.mcpAgent.disconnect();
         }
-        debugLog('MCP Agent connection terminated');
+        debugLog('[MCP] All MCP server connections terminated successfully');
       } catch (error) {
-        debugLog(`Error during MCP Agent termination: ${error.message}`);
+        debugLog(`[MCP] Error during cleanup: ${error.message}`);
+        debugLog(`[MCP]   Stack: ${error.stack}`);
       }
+    } else {
+      debugLog('[MCP] No MCP Agent to cleanup (never initialized)');
     }
   }
 }
@@ -241,10 +292,13 @@ export class MCPIntegration {
 /**
  * 전역 MCP Integration 인스턴스 생성 헬퍼
  */
-export async function initializeMCPIntegration(projectRoot = process.cwd()) {
-  const integration = new MCPIntegration(projectRoot);
+export async function initializeMCPIntegration() {
+  debugLog('[MCP] initializeMCPIntegration() called');
+  const integration = new MCPIntegration();
   const result = await integration.initialize();
 
+  debugLog(`[MCP] initializeMCPIntegration() complete - success: ${result?.success}, reason: ${result?.reason || 'N/A'}`);
+
   // 서버가 없어도 객체는 반환 (빈 서버 목록으로 동작)
   return integration;
 }

package/src/tools/file_reader.js

@@ -32,6 +32,9 @@ export async function read_file({ filePath }) {
     debugLog(`  - filePath starts with '../': ${filePath?.startsWith('../') || false}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     try {
         // 경로를 절대경로로 정규화
         const absolutePath = resolve(filePath);
@@ -169,6 +172,9 @@ export async function read_file_range({ filePath, startLine, endLine }) {
     debugLog(`  endLine: ${endLine}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     try {
         // 경로를 절대경로로 정규화
         const absolutePath = resolve(filePath);

package/src/tools/glob.js

@@ -40,6 +40,9 @@ export async function globSearch({
     debugLog(`  maxResults: ${maxResults}`);
     debugLog(`  - Current Working Directory: ${process.cwd()}`);
 
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     try {
         if (typeof pattern !== 'string' || !pattern.trim()) {
             debugLog(`ERROR: Invalid pattern`);

package/src/tools/ripgrep.js

@@ -332,6 +332,8 @@ export async function ripgrep({
     head_limit: headLimit = null,
     includeHidden = false
 }) {
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
 
     if (typeof pattern !== 'string' || !pattern.trim()) {
         return {

package/src/tools/web_downloader.js

@@ -19,6 +19,9 @@ import { theme } from '../frontend/design/themeColors.js';
  * @returns {Promise<{operation_successful: boolean, url: string, content: string, error_message: string|null}>} 결과 객체
  */
 export async function fetch_web_page({ url }) {
+    // Intentional delay for testing pending state
+    await new Promise(resolve => setTimeout(resolve, 13));
+
     const timeout = 30;
     const user_agent = 'Mozilla/5.0 (compatible; WebFetcher/1.0)';
     const encoding = 'utf-8';