activo 0.4.4 → 0.5.0

package/dist/core/agent.js

@@ -1,12 +1,34 @@
-import * as fs from "fs";
 import { selectTools, executeTool } from "./tools/index.js";
+import { detectAndExecuteIntent, compressAnalysisResult } from "./intentRouter.js";
+// Extract a unique signature from a tool call for loop detection
+function toolSignature(tc) {
+    // 모든 인자를 포함하여 false positive 방지
+    // (같은 도구를 다른 profile/pattern/args으로 호출하는 것은 반복이 아님)
+    const sortedArgs = Object.keys(tc.arguments)
+        .sort()
+        .map((key) => `${key}=${String(tc.arguments[key])}`)
+        .join(",");
+    return `${tc.name}:${sortedArgs}`;
+}
 const BASE_SYSTEM_PROMPT = `You are ACTIVO, a code quality analyzer. You MUST call tools to perform tasks.
 
 ## RULES
 1. Call tool IMMEDIATELY when user requests an action
 2. NEVER fabricate results - only report actual tool output
 3. After tool returns, summarize in user's language (Korean if user speaks Korean)
-4. Use analyze_all for broad code analysis`;
+4. Use analyze_all for broad code analysis
+5. When all tools have completed, STOP calling tools and provide a final summary
+
+## WORKFLOWS
+- PDF→규칙: import_pdf_standards → generate_apex_rules (do NOT read_file individually)
+- 코드분석: recommend_profile → mcp_apex_analyze_code → analyze_patterns
+- 리포트: mcp_apex_analyze_code → generate_report (Excel 자동 포함)
+- 엑셀출력: mcp_apex_analyze_code → mcp_apex_export_excel (analyze_code 후 즉시 엑셀 생성 가능)
+- 전체보고서: mcp_apex_analyze_code → generate_report → generate_improvement_report`;
+// System prompt for summary-only mode (no tool calling)
+const SUMMARY_SYSTEM_PROMPT = `You are ACTIVO, a code quality analyzer.
+You are summarizing tool results. Do NOT call any tools. Do NOT output XML or tool_use tags.
+Just provide a clear, helpful summary in the user's language (Korean if user speaks Korean).`;
 // Build system prompt with optional context
 function buildSystemPrompt(contextSummary) {
     if (!contextSummary) {
@@ -21,353 +43,6 @@ ${contextSummary}
 ---
 위 내용은 이전 세션에서의 대화 요약입니다. 필요시 참고하세요.`;
 }
-// Intent patterns: keyword groups → tool + args builder
-const INTENT_PATTERNS = [
-    // Single file analysis (must come before directory patterns)
-    {
-        keywords: ["분석", "analyze", "검사", "check"],
-        tool: "_single_file", // special marker - resolved at match time
-        buildArgs: (path) => ({ filepath: path }),
-    },
-    // analyze_all with Java filter
-    {
-        keywords: ["자바", "java"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["java"] }),
-    },
-    // Spring patterns
-    {
-        keywords: ["spring", "스프링"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["java"] }),
-    },
-    // Dependency analysis
-    {
-        keywords: ["의존성", "dependency", "dependencies", "취약점"],
-        tool: "dependency_check",
-        buildArgs: (path) => ({ path }),
-    },
-    // Complexity
-    {
-        keywords: ["복잡도", "complexity"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path }),
-    },
-    // Python
-    {
-        keywords: ["python", "파이썬", ".py"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["py"] }),
-    },
-    // Frontend
-    {
-        keywords: ["react", "리액트", "vue", "뷰", "프론트엔드", "frontend"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["js", "ts", "jsx", "tsx", "vue"] }),
-    },
-    // CSS
-    {
-        keywords: ["css", "scss", "less", "스타일"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["css"] }),
-    },
-    // HTML
-    {
-        keywords: ["html", "jsp", "접근성", "a11y", "seo"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["html"] }),
-    },
-    // SQL / MyBatis
-    {
-        keywords: ["sql", "mybatis", "마이바티스", "쿼리"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path, include: ["java", "xml"] }),
-    },
-    // Broad analysis (catch-all, must be last)
-    {
-        keywords: ["전체분석", "전체 분석", "분석해", "코드품질", "코드 품질", "analyze", "분석", "검사", "check"],
-        tool: "analyze_all",
-        buildArgs: (path) => ({ path }),
-    },
-];
-// File extension → single-file tool mapping
-const FILE_TOOL_MAP = {
-    ".java": "java_analyze",
-    ".js": "ast_analyze",
-    ".ts": "ast_analyze",
-    ".jsx": "react_check",
-    ".tsx": "react_check",
-    ".vue": "vue_check",
-    ".py": "python_check",
-    ".css": "css_check",
-    ".scss": "css_check",
-    ".less": "css_check",
-    ".html": "html_check",
-    ".htm": "html_check",
-    ".jsp": "html_check",
-};
-/**
- * Extract filesystem paths from user message.
- * Handles quoted paths (with spaces), simple paths, and greedy path expansion.
- */
-function extractPaths(message) {
-    const paths = [];
-    // 1. Quoted paths: '...' or "..."
-    const quotedMatches = message.match(/['"]([/\\][^'"]+)['"]/g);
-    if (quotedMatches) {
-        for (const m of quotedMatches) {
-            paths.push(m.slice(1, -1)); // strip quotes
-        }
-    }
-    // 2. Simple paths (no spaces) - Unix & Windows
-    const unixMatches = message.match(/(?:^|\s)(\/[^\s,;:'"]+)/g);
-    if (unixMatches) {
-        for (const m of unixMatches) {
-            paths.push(m.trim());
-        }
-    }
-    const winMatches = message.match(/(?:^|\s)([A-Z]:\\[^\s,;:'"]+)/gi);
-    if (winMatches) {
-        for (const m of winMatches) {
-            paths.push(m.trim());
-        }
-    }
-    // 3. Greedy path expansion: if simple match doesn't exist,
-    //    try extending with subsequent words until path is valid
-    if (paths.length === 0 || !paths.some((p) => { try {
-        return fs.existsSync(p);
-    }
-    catch {
-        return false;
-    } })) {
-        const words = message.split(/\s+/);
-        for (let i = 0; i < words.length; i++) {
-            if (words[i].startsWith("/") || /^[A-Z]:\\/i.test(words[i])) {
-                // Found a path start, try extending
-                let candidate = words[i];
-                let bestPath = "";
-                // Check initial segment
-                try {
-                    if (fs.existsSync(candidate))
-                        bestPath = candidate;
-                }
-                catch { /* */ }
-                // Extend with subsequent words
-                for (let j = i + 1; j < words.length; j++) {
-                    const extended = candidate + " " + words[j];
-                    try {
-                        if (fs.existsSync(extended)) {
-                            bestPath = extended;
-                            candidate = extended;
-                        }
-                        else {
-                            // No more valid extensions - stop
-                            break;
-                        }
-                    }
-                    catch {
-                        break;
-                    }
-                }
-                if (bestPath) {
-                    paths.push(bestPath);
-                }
-            }
-        }
-    }
-    // Filter to actually existing paths, deduplicate
-    const seen = new Set();
-    return paths.filter((p) => {
-        if (seen.has(p))
-            return false;
-        seen.add(p);
-        try {
-            return fs.existsSync(p);
-        }
-        catch {
-            return false;
-        }
-    });
-}
-/**
- * Determine if a path is a single file (not a directory).
- */
-function isSingleFile(p) {
-    try {
-        return fs.statSync(p).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Resolve the correct tool for a single file based on extension.
- */
-function resolveFileAnalysisTool(filepath) {
-    const ext = filepath.substring(filepath.lastIndexOf(".")).toLowerCase();
-    const toolName = FILE_TOOL_MAP[ext];
-    if (!toolName)
-        return null;
-    // Some tools use 'filepath', others use 'path'
-    const argKey = ["python_check", "css_check", "html_check"].includes(toolName) ? "path" : "filepath";
-    return { tool: toolName, args: { [argKey]: filepath } };
-}
-/**
- * Detect user intent from the message and automatically execute the appropriate tool.
- * Returns IntentResult with handled=true if a tool was executed, false otherwise.
- */
-async function detectAndExecuteIntent(userMessage, onEvent) {
-    const msg = userMessage.toLowerCase();
-    const paths = extractPaths(userMessage);
-    // No path found → can't auto-route
-    if (paths.length === 0) {
-        return { handled: false };
-    }
-    const targetPath = paths[0];
-    // Check if path is a single file
-    if (isSingleFile(targetPath)) {
-        const fileInfo = resolveFileAnalysisTool(targetPath);
-        if (fileInfo) {
-            return await executeIntentTool(fileInfo.tool, fileInfo.args, onEvent);
-        }
-        // Unknown file type → fall back to LLM
-        return { handled: false };
-    }
-    // Path is a directory → match intent patterns
-    for (const pattern of INTENT_PATTERNS) {
-        // Skip the single-file marker for directories
-        if (pattern.tool === "_single_file")
-            continue;
-        if (pattern.keywords.some((kw) => msg.includes(kw))) {
-            const args = pattern.buildArgs(targetPath, userMessage);
-            return await executeIntentTool(pattern.tool, args, onEvent);
-        }
-    }
-    // Has a directory path but no matching keyword → default to analyze_all
-    // (user likely wants some kind of analysis if they provided a path)
-    const hasAnalysisHint = /분석|검사|확인|체크|check|analyze|review|scan|report/i.test(msg);
-    if (hasAnalysisHint) {
-        return await executeIntentTool("analyze_all", { path: targetPath }, onEvent);
-    }
-    return { handled: false };
-}
-/**
- * Execute a tool by name and return an IntentResult with the summary prompt.
- */
-async function executeIntentTool(toolName, toolArgs, onEvent) {
-    const toolCall = {
-        id: `intent_${Date.now()}_${Math.random().toString(36).slice(2)}`,
-        name: toolName,
-        arguments: toolArgs,
-    };
-    // Emit tool_use start event
-    onEvent?.({
-        type: "tool_use",
-        tool: toolName,
-        status: "start",
-        args: toolArgs,
-    });
-    const result = await executeTool(toolCall);
-    // Emit tool_result event
-    onEvent?.({
-        type: "tool_result",
-        tool: toolName,
-        status: result.success ? "complete" : "error",
-        result,
-    });
-    if (!result.success) {
-        return {
-            handled: true,
-            toolName,
-            toolArgs,
-            toolResult: result,
-            summaryPrompt: `도구 "${toolName}" 실행 중 오류가 발생했습니다: ${result.error}\n사용자에게 오류 내용을 설명해주세요.`,
-        };
-    }
-    // Compress result to fit in context window
-    const compressed = compressAnalysisResult(result.content);
-    return {
-        handled: true,
-        toolName,
-        toolArgs,
-        toolResult: result,
-        summaryPrompt: `아래는 "${toolName}" 도구의 실행 결과입니다. 사용자에게 한국어로 핵심 내용을 요약해주세요.\n\n${compressed}`,
-    };
-}
-/**
- * Compress analysis result JSON to fit within LLM context window.
- * Extracts only key metrics, removing verbose raw data.
- */
-function compressAnalysisResult(resultContent, maxChars = 2000) {
-    try {
-        const parsed = JSON.parse(resultContent);
-        // analyze_all result
-        if (parsed.path && parsed.fileStats) {
-            const compact = {
-                path: parsed.path,
-                totalFiles: parsed.totalFiles,
-                fileStats: parsed.fileStats,
-                analysesRun: parsed.analysesRun,
-                successful: parsed.successful,
-                failed: parsed.failed,
-            };
-            // Extract issue summaries (compact)
-            if (parsed.issuesSummary?.length > 0) {
-                compact.issues = parsed.issuesSummary.map((is) => ({
-                    tool: is.tool,
-                    issues: is.issues.slice(0, 5),
-                }));
-            }
-            // Extract per-tool summaries (key metrics only)
-            if (parsed.details?.length > 0) {
-                compact.analyses = parsed.details.map((d) => {
-                    const s = d.summary;
-                    const brief = { tool: d.tool };
-                    // Extract numeric/small fields only
-                    for (const [k, v] of Object.entries(s)) {
-                        if (typeof v === "number" || typeof v === "boolean") {
-                            brief[k] = v;
-                        }
-                        else if (typeof v === "string" && v.length < 100) {
-                            brief[k] = v;
-                        }
-                        // Skip arrays/objects (raw data) to save space
-                    }
-                    // Include issues from samples (java_analyze etc.)
-                    if (Array.isArray(s.samples)) {
-                        const allIssues = [];
-                        for (const sample of s.samples) {
-                            if (Array.isArray(sample.result?.issues)) {
-                                allIssues.push(...sample.result.issues.slice(0, 3));
-                            }
-                        }
-                        if (allIssues.length > 0) {
-                            brief.issues = allIssues.slice(0, 10);
-                        }
-                    }
-                    return brief;
-                });
-            }
-            if (parsed.errors?.length > 0) {
-                compact.errors = parsed.errors;
-            }
-            const result = JSON.stringify(compact, null, 1);
-            return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
-        }
-        // java_analyze or other single-file results
-        if (parsed.file || parsed.filepath || parsed.classes || parsed.functions) {
-            const result = JSON.stringify(parsed, null, 1);
-            return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
-        }
-        // Generic: just truncate
-        const result = JSON.stringify(parsed, null, 1);
-        return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
-    }
-    catch {
-        // Not valid JSON, return truncated raw text
-        return resultContent.length > maxChars ? resultContent.slice(0, maxChars) + "..." : resultContent;
-    }
-}
 // ─── Main processing functions ───
 export async function processMessage(userMessage, history, client, config, onEvent, contextSummary) {
     // Try intent router first
@@ -376,7 +51,7 @@ export async function processMessage(userMessage, history, client, config, onEve
         // Tool already executed → ask LLM to summarize only (no tools = VRAM savings)
         onEvent?.({ type: "thinking" });
         const summaryMessages = [
-            { role: "system", content: BASE_SYSTEM_PROMPT },
+            { role: "system", content: SUMMARY_SYSTEM_PROMPT },
             { role: "user", content: intent.summaryPrompt },
         ];
         const response = await client.chat(summaryMessages); // No tools!
@@ -400,17 +75,51 @@ export async function processMessage(userMessage, history, client, config, onEve
     const toolCallResults = [];
     let finalContent = "";
     let iterations = 0;
-    const maxIterations = 10;
+    const maxIterations = 30;
+    const recentSignatures = [];
     while (iterations < maxIterations) {
         iterations++;
         onEvent?.({ type: "thinking" });
         const response = await client.chat(messages, tools);
         messages.push(response);
-        // If no tool calls, we're done
+        // If no tool calls, we're done — but check if final answer is empty
         if (!response.toolCalls?.length) {
             finalContent = response.content;
+            // 도구를 실행했는데 최종 응답이 비어있으면 → LLM에게 요약 강제 요청
+            if (!finalContent && toolCallResults.length > 0) {
+                messages.push({
+                    role: "user",
+                    content: "도구 실행이 완료되었습니다. 결과를 요약하고, 생성된 파일이 있다면 경로를 알려주세요.",
+                });
+                try {
+                    const summaryResponse = await client.chat(messages); // No tools
+                    finalContent = summaryResponse.content;
+                }
+                catch {
+                    finalContent = toolCallResults
+                        .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.result.success ? "✓" : "✗"}`)
+                        .join("\n");
+                    finalContent = `수행된 작업:\n${finalContent}`;
+                }
+                onEvent?.({ type: "content", content: finalContent });
+            }
             break;
         }
+        // Detect true loops: same tool + same args 3+ times consecutively
+        for (const tc of response.toolCalls) {
+            recentSignatures.push(toolSignature(tc));
+        }
+        if (recentSignatures.length >= 3) {
+            const last3 = recentSignatures.slice(-3);
+            if (last3.every((s) => s === last3[0])) {
+                const toolSummary = toolCallResults
+                    .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.result.success ? "✓" : "✗"}`)
+                    .join("\n");
+                finalContent = `동일한 작업이 반복되어 중단합니다.\n\n수행된 작업:\n${toolSummary}`;
+                onEvent?.({ type: "content", content: finalContent });
+                break;
+            }
+        }
         // Process tool calls
         for (const toolCall of response.toolCalls) {
             onEvent?.({
@@ -431,18 +140,45 @@ export async function processMessage(userMessage, history, client, config, onEve
                 args: toolCall.arguments,
                 result,
             });
-            // Add tool result to messages
+            // Add tool result to messages (compressed to avoid context overflow)
+            const toolContent = result.success
+                ? compressAnalysisResult(result.content, 8000)
+                : `Error: ${result.error}`;
             messages.push({
                 role: "tool",
-                content: result.success ? result.content : `Error: ${result.error}`,
+                content: toolContent,
                 toolCallId: toolCall.id,
             });
         }
         // Continue the conversation with tool results
         onEvent?.({ type: "content", content: response.content });
     }
+    // 도구는 실행됐지만 최종 content가 비어있는 경우 → 요약 표시
+    if (!finalContent && toolCallResults.length > 0 && iterations < maxIterations) {
+        finalContent = toolCallResults
+            .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.result.success ? "✓" : "✗"}`)
+            .join("\n");
+        finalContent = `수행된 작업:\n${finalContent}`;
+        onEvent?.({ type: "content", content: finalContent });
+    }
     if (iterations >= maxIterations) {
-        onEvent?.({ type: "error", error: "Maximum iterations reached" });
+        // Force LLM to generate final answer without tools
+        messages.push({
+            role: "user",
+            content: "지금까지 수행된 작업 결과를 바탕으로 최종 답변을 작성해주세요. 더 이상 도구를 호출하지 마세요.",
+        });
+        try {
+            const finalResponse = await client.chat(messages); // No tools!
+            finalContent = finalResponse.content;
+            onEvent?.({ type: "content", content: finalContent });
+        }
+        catch {
+            const toolSummary = toolCallResults
+                .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.result.success ? "✓" : "✗"}`)
+                .join("\n");
+            finalContent = `작업이 최대 반복 횟수에 도달했습니다.\n\n수행된 작업:\n${toolSummary}`;
+            onEvent?.({ type: "content", content: finalContent });
+        }
     }
     onEvent?.({ type: "done" });
     return {
@@ -451,26 +187,15 @@ export async function processMessage(userMessage, history, client, config, onEve
     };
 }
 export async function* streamProcessMessage(userMessage, history, client, config, abortSignal, contextSummary) {
-    // Try intent router first
+    // Try intent router first — collect events from pipeline for later emission
+    const collectedEvents = [];
     const intent = await detectAndExecuteIntent(userMessage, (event) => {
-        // Events are yielded by the caller, we collect them via callback
-        // But generators can't yield from callbacks, so we handle this differently
+        collectedEvents.push(event);
     });
     if (intent.handled) {
-        // Emit the tool events that happened during intent detection
-        if (intent.toolName) {
-            yield {
-                type: "tool_use",
-                tool: intent.toolName,
-                status: "start",
-                args: intent.toolArgs,
-            };
-            yield {
-                type: "tool_result",
-                tool: intent.toolName,
-                status: intent.toolResult?.success ? "complete" : "error",
-                result: intent.toolResult,
-            };
+        // Emit all events that happened during intent detection (pipeline steps)
+        for (const event of collectedEvents) {
+            yield event;
         }
         if (intent.summaryPrompt) {
             if (abortSignal?.aborted) {
@@ -480,7 +205,7 @@ export async function* streamProcessMessage(userMessage, history, client, config
             yield { type: "thinking" };
             // Stream the LLM summary (no tools = streaming mode in ollama client)
             const summaryMessages = [
-                { role: "system", content: BASE_SYSTEM_PROMPT },
+                { role: "system", content: SUMMARY_SYSTEM_PROMPT },
                 { role: "user", content: intent.summaryPrompt },
             ];
             for await (const event of client.streamChat(summaryMessages, undefined, abortSignal)) {
@@ -509,7 +234,10 @@ export async function* streamProcessMessage(userMessage, history, client, config
         { role: "user", content: userMessage },
     ];
     let iterations = 0;
-    const maxIterations = 10;
+    const maxIterations = 30;
+    const recentSignatures = [];
+    const completedToolCalls = [];
+    let contentYielded = false;
     while (iterations < maxIterations) {
         // Check if aborted
         if (abortSignal?.aborted) {
@@ -528,7 +256,6 @@ export async function* streamProcessMessage(userMessage, history, client, config
             }
             if (event.type === "content" && event.content) {
                 fullContent += event.content;
-                // Don't yield content yet - wait to see if there are tool calls
             }
             else if (event.type === "tool_call" && event.toolCall) {
                 pendingToolCalls.push(event.toolCall);
@@ -538,19 +265,67 @@ export async function* streamProcessMessage(userMessage, history, client, config
                 return;
             }
         }
-        // Only yield content if NO tool calls (avoid hallucinated pre-tool text)
-        if (pendingToolCalls.length === 0 && fullContent) {
+        // content가 있으면 항상 yield (tool call 유무 무관)
+        if (fullContent) {
             yield { type: "content", content: fullContent };
+            contentYielded = true;
         }
-        else if (pendingToolCalls.length > 0) {
-            // Clear content when tool calls exist
-            fullContent = "";
-        }
-        messages.push({ role: "assistant", content: fullContent, toolCalls: pendingToolCalls.length > 0 ? pendingToolCalls : undefined });
-        // If no tool calls, we're done
+        // message history에 content 항상 보존
+        messages.push({
+            role: "assistant",
+            content: fullContent,
+            toolCalls: pendingToolCalls.length > 0 ? pendingToolCalls : undefined,
+        });
+        // If no tool calls, we're done — but check if final answer is empty
         if (pendingToolCalls.length === 0) {
+            // 도구를 실행했는데 최종 응답이 비어있으면 → LLM에게 요약 강제 요청
+            if (!fullContent && completedToolCalls.length > 0) {
+                let summaryYielded = false;
+                messages.push({
+                    role: "user",
+                    content: "도구 실행이 완료되었습니다. 결과를 요약하고, 생성된 파일이 있다면 경로를 알려주세요.",
+                });
+                try {
+                    for await (const event of client.streamChat(messages, undefined, abortSignal)) {
+                        if (abortSignal?.aborted)
+                            break;
+                        if (event.type === "content" && event.content) {
+                            yield { type: "content", content: event.content };
+                            summaryYielded = true;
+                            contentYielded = true;
+                        }
+                    }
+                }
+                catch {
+                    // API 에러 시 fallback
+                }
+                if (!summaryYielded) {
+                    const toolSummary = completedToolCalls
+                        .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.success ? "✓" : "✗"}`)
+                        .join("\n");
+                    yield { type: "content", content: `수행된 작업:\n${toolSummary}` };
+                    contentYielded = true;
+                }
+            }
             break;
         }
+        // Detect true loops: same tool + same args 3+ times consecutively
+        for (const tc of pendingToolCalls) {
+            recentSignatures.push(toolSignature(tc));
+        }
+        if (recentSignatures.length >= 3) {
+            const last3 = recentSignatures.slice(-3);
+            if (last3.every((s) => s === last3[0])) {
+                const toolSummary = completedToolCalls
+                    .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.success ? "✓" : "✗"}`)
+                    .join("\n");
+                yield {
+                    type: "content",
+                    content: `\n\n동일한 작업이 반복되어 중단합니다.\n\n수행된 작업:\n${toolSummary}`,
+                };
+                break;
+            }
+        }
         // Process tool calls
         for (const toolCall of pendingToolCalls) {
             // Check if aborted before each tool call
@@ -576,13 +351,57 @@ export async function* streamProcessMessage(userMessage, history, client, config
                 status: result.success ? "complete" : "error",
                 result,
             };
+            completedToolCalls.push({
+                tool: toolCall.name,
+                args: toolCall.arguments,
+                success: result.success,
+            });
+            // Compress tool result to avoid context overflow (especially for Anthropic 200k limit)
+            const toolContent = result.success
+                ? compressAnalysisResult(result.content, 8000)
+                : `Error: ${result.error}`;
             messages.push({
                 role: "tool",
-                content: result.success ? result.content : `Error: ${result.error}`,
+                content: toolContent,
                 toolCallId: toolCall.id,
             });
         }
     }
+    // 도구는 실행됐지만 content가 한 번도 yield 안 된 경우 → 요약 표시
+    if (!contentYielded && completedToolCalls.length > 0 && iterations < maxIterations) {
+        const toolSummary = completedToolCalls
+            .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.success ? "✓" : "✗"}`)
+            .join("\n");
+        yield { type: "content", content: `수행된 작업:\n${toolSummary}` };
+    }
+    // If maxIterations reached, force LLM to generate final answer
+    if (iterations >= maxIterations) {
+        // Add a nudge message asking LLM to summarize
+        messages.push({
+            role: "user",
+            content: "지금까지 수행된 작업 결과를 바탕으로 최종 답변을 작성해주세요. 더 이상 도구를 호출하지 마세요.",
+        });
+        try {
+            // One final LLM call WITHOUT tools to force a text response
+            for await (const event of client.streamChat(messages, undefined, abortSignal)) {
+                if (abortSignal?.aborted)
+                    break;
+                if (event.type === "content" && event.content) {
+                    yield { type: "content", content: event.content };
+                }
+            }
+        }
+        catch {
+            // Fallback: show tool summary if final LLM call fails
+            const toolSummary = completedToolCalls
+                .map((tc) => `- ${tc.tool}(${Object.values(tc.args)[0] || ""}): ${tc.success ? "✓" : "✗"}`)
+                .join("\n");
+            yield {
+                type: "content",
+                content: `\n\n작업이 최대 반복 횟수에 도달했습니다.\n\n수행된 작업:\n${toolSummary}`,
+            };
+        }
+    }
     yield { type: "done" };
 }
 //# sourceMappingURL=agent.js.map