develop -> main

src/main/java/gg/agit/konect/infrastructure/claude/client/ClaudeClient.java

@@ -122,13 +122,58 @@ public ClaudeClient(RestClient.Builder restClientBuilder,
         this.objectMapper = objectMapper;
     }
 
-    /**
-     * Process user query with tool use support.
-     * Supports multi-turn tool calls for schema discovery and query execution.
-     *
-     * @param userMessage User's question
-     * @return AI response
-     */
+    public String chat(List<Map<String, Object>> initialMessages) {
+        try {
+            List<Map<String, Object>> messages = new ArrayList<>(initialMessages);
+
+            for (int i = 0; i < MAX_TOOL_ITERATIONS; i++) {
+                Map<String, Object> request = buildRequest(messages);
+                String response = callClaudeApi(request);
+
+                if (response == null) {
+                    log.error("Claude API returned null response");
+                    throw new ClaudeException("Claude API returned null response", null);
+                }
+
+                JsonNode responseNode = objectMapper.readTree(response);
+                String stopReason = responseNode.path("stop_reason").asText();
+                JsonNode content = responseNode.path("content");
+
+                if ("end_turn".equals(stopReason)) {
+                    return extractTextResponse(content);
+                }
+
+                if ("tool_use".equals(stopReason)) {
+                    List<Map<String, Object>> toolResults = processToolCalls(content);
+
+                    if (toolResults.isEmpty()) {
+                        log.warn("stop_reason is tool_use but no tool_use blocks found");
+                        return extractTextResponse(content);
+                    }
+
+                    messages.add(Map.of(
+                        "role", "assistant",
+                        "content", objectMapper.convertValue(content, List.class)
+                    ));
+                    messages.add(Map.of(
+                        "role", "user",
+                        "content", toolResults
+                    ));
+                } else {
+                    log.warn("Unexpected stop_reason: {}", stopReason);
+                    return extractTextResponse(content);
+                }
+            }
+
+            log.warn("Maximum tool iterations reached");
+            throw new ClaudeException("Maximum tool iterations reached", null);
+
+        } catch (JsonProcessingException e) {
+            log.error("Failed to parse Claude API response", e);
+            throw new ClaudeException("Failed to parse Claude API response", e);
+        }
+    }
+
     public String chat(String userMessage) {
         try {
             List<Map<String, Object>> messages = new ArrayList<>();
@@ -144,7 +189,6 @@ public String chat(String userMessage) {
                 }
 
                 JsonNode responseNode = objectMapper.readTree(response);
-
                 String stopReason = responseNode.path("stop_reason").asText();
                 JsonNode content = responseNode.path("content");
 
@@ -153,26 +197,22 @@ public String chat(String userMessage) {
                 }
 
                 if ("tool_use".equals(stopReason)) {
-                    // Process tool calls and add results
                     List<Map<String, Object>> toolResults = processToolCalls(content);
 
                     if (toolResults.isEmpty()) {
                         log.warn("stop_reason is tool_use but no tool_use blocks found");
                         return extractTextResponse(content);
                     }
 
-                    // Add assistant's response to messages
                     messages.add(Map.of(
                         "role", "assistant",
                         "content", objectMapper.convertValue(content, List.class)
                     ));
-
                     messages.add(Map.of(
                         "role", "user",
                         "content", toolResults
                     ));
                 } else {
-                    // Unexpected stop reason
                     log.warn("Unexpected stop_reason: {}", stopReason);
                     return extractTextResponse(content);
                 }

src/main/java/gg/agit/konect/infrastructure/slack/ai/SlackAIService.java

@@ -1,5 +1,9 @@
 package gg.agit.konect.infrastructure.slack.ai;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -8,7 +12,6 @@
 
 import gg.agit.konect.infrastructure.claude.client.ClaudeClient;
 import gg.agit.konect.infrastructure.slack.client.SlackClient;
-import gg.agit.konect.infrastructure.slack.config.SlackProperties;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
@@ -19,10 +22,15 @@ public class SlackAIService {
 
     private static final Pattern AI_PREFIX_PATTERN = Pattern.compile("^[Aa][Ii]\\)\\s*(.+)$");
     private static final Pattern MENTION_PATTERN = Pattern.compile("^<@[^>]+>\\s*");
+    private static final String AI_RESPONSE_PREFIX = ":robot_face: *AI 응답*\n";
+    private static final int MAX_HISTORY_MESSAGES = 10;
+    private static final String EMPTY_QUERY_MESSAGE =
+        "질문 내용이 비어있습니다. 예: `AI) 가입자 수 알려줘` 또는 `@봇이름 동아리 수는?`";
+    private static final String ERROR_MESSAGE =
+        ":warning: 죄송합니다. 요청을 처리하는 중 오류가 발생했습니다.";
 
     private final ClaudeClient claudeClient;
     private final SlackClient slackClient;
-    private final SlackProperties slackProperties;
 
     public boolean isAIQuery(String text) {
         if (text == null) {
@@ -31,6 +39,13 @@ public boolean isAIQuery(String text) {
         return AI_PREFIX_PATTERN.matcher(text.trim()).matches();
     }
 
+    public boolean isAppMention(String text) {
+        if (text == null) {
+            return false;
+        }
+        return MENTION_PATTERN.matcher(text.trim()).find();
+    }
+
     public String extractQuery(String text) {
         Matcher matcher = AI_PREFIX_PATTERN.matcher(text.trim());
         if (matcher.matches()) {
@@ -46,37 +61,112 @@ public String normalizeAppMentionText(String text) {
         return MENTION_PATTERN.matcher(text).replaceFirst("").trim();
     }
 
+    public List<Map<String, Object>> fetchAIThreadReplies(String channelId, String threadTs) {
+        List<Map<String, Object>> replies = slackClient.getThreadReplies(channelId, threadTs);
+        if (replies.isEmpty()) {
+            return new ArrayList<>();
+        }
+        Map<String, Object> rootMessage = replies.get(0);
+        String rootText = (String)rootMessage.get("text");
+        if (rootText != null && isAIQuery(rootText)) {
+            return replies;
+        }
+        if (replies.stream().anyMatch(r -> r.get("bot_id") != null)) {
+            return replies;
+        }
+        return new ArrayList<>();
+    }
+
     @Async
-    public void processAIQuery(String text) {
+    public void processAIQuery(String text, String channelId, String threadTs,
+            List<Map<String, Object>> cachedReplies) {
         try {
             String userQuery = extractQuery(text);
 
-            // 빈 질문은 처리하지 않음
             if (userQuery == null || userQuery.isBlank()) {
                 log.debug("빈 질문으로 처리 중단");
-                String guidanceMessage = formatSlackResponse(
-                    "질문 내용이 비어있습니다. 예: `AI) 가입자 수 알려줘` 또는 `@봇이름 동아리 수는?`"
-                );
-                slackClient.sendMessage(guidanceMessage, slackProperties.webhooks().event());
+                slackClient.postThreadReply(channelId, threadTs,
+                    formatSlackResponse(EMPTY_QUERY_MESSAGE));
                 return;
             }
 
             log.debug("AI 질문 처리 시작: {}", userQuery);
 
-            // ClaudeClient가 MCP를 통해 자동으로 SQL 결정 및 실행
-            String response = claudeClient.chat(userQuery);
+            List<Map<String, Object>> replies =
+                cachedReplies != null ? cachedReplies : new ArrayList<>();
+            List<Map<String, Object>> messages = buildConversationHistory(replies);
+
+            if (messages.isEmpty()) {
+                messages = new ArrayList<>();
+                messages.add(Map.of("role", "user", "content", userQuery));
+            }
+
+            String response = claudeClient.chat(messages);
 
             log.debug("AI 응답 생성 완료");
 
-            // Slack에 응답 전송
-            String slackMessage = formatSlackResponse(response);
-            slackClient.sendMessage(slackMessage, slackProperties.webhooks().event());
+            slackClient.postThreadReply(channelId, threadTs, formatSlackResponse(response));
 
         } catch (Exception e) {
             log.error("AI 질문 처리 중 오류 발생", e);
-            String errorMessage = ":warning: 죄송합니다. 요청을 처리하는 중 오류가 발생했습니다.";
-            slackClient.sendMessage(errorMessage, slackProperties.webhooks().event());
+            slackClient.postThreadReply(channelId, threadTs, ERROR_MESSAGE);
+        }
+    }
+
+    private List<Map<String, Object>> buildConversationHistory(List<Map<String, Object>> replies) {
+        if (replies.isEmpty()) {
+            return new ArrayList<>();
+        }
+
+        List<Map<String, Object>> messages = new ArrayList<>();
+        for (Map<String, Object> reply : replies) {
+            String replyText = (String)reply.get("text");
+
+            if (replyText == null) {
+                continue;
+            }
+
+            if (reply.get("bot_id") != null) {
+                String content = replyText.startsWith(AI_RESPONSE_PREFIX)
+                    ? replyText.substring(AI_RESPONSE_PREFIX.length())
+                    : replyText;
+                messages.add(Map.of("role", "assistant", "content", content));
+            } else {
+                String normalizedText = normalizeAppMentionText(replyText);
+                String userText = isAIQuery(normalizedText)
+                    ? extractQuery(normalizedText)
+                    : normalizedText;
+                messages.add(Map.of("role", "user", "content", userText));
+            }
+        }
+
+        List<Map<String, Object>> merged = mergeConsecutiveRoles(messages);
+
+        if (!merged.isEmpty() && "assistant".equals(merged.get(0).get("role"))) {
+            merged = new ArrayList<>(merged.subList(1, merged.size()));
+        }
+
+        if (merged.size() > MAX_HISTORY_MESSAGES) {
+            merged = new ArrayList<>(
+                merged.subList(merged.size() - MAX_HISTORY_MESSAGES, merged.size())
+            );
+        }
+        return merged;
+    }
+
+    private List<Map<String, Object>> mergeConsecutiveRoles(List<Map<String, Object>> messages) {
+        List<Map<String, Object>> merged = new ArrayList<>();
+        for (Map<String, Object> msg : messages) {
+            if (!merged.isEmpty()
+                    && merged.get(merged.size() - 1).get("role").equals(msg.get("role"))) {
+                Map<String, Object> last = new HashMap<>(merged.get(merged.size() - 1));
+                last.put("content", last.get("content") + "\n" + msg.get("content"));
+                merged.set(merged.size() - 1, last);
+            } else {
+                merged.add(msg);
+            }
         }
+        return merged;
     }
 
     private String formatSlackResponse(String response) {

src/main/java/gg/agit/konect/infrastructure/slack/ai/SlackEventController.java

@@ -1,6 +1,9 @@
 package gg.agit.konect.infrastructure.slack.ai;
 
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -28,6 +31,9 @@ public class SlackEventController {
 
     private static final String SLACK_TIMESTAMP_HEADER = "X-Slack-Request-Timestamp";
     private static final String SLACK_SIGNATURE_HEADER = "X-Slack-Signature";
+    private static final int EVENT_CACHE_MAX_SIZE = 500;
+
+    private final Set<String> processedEventIds = ConcurrentHashMap.newKeySet();
 
     private final SlackAIService slackAIService;
     private final SlackSignatureVerifier signatureVerifier;
@@ -48,30 +54,34 @@ public ResponseEntity<Object> handleSlackEvent(
 
         String type = (String)payload.get("type");
 
-        // URL 검증은 서명 검증 없이 처리 (최초 설정 시)
         if ("url_verification".equals(type)) {
             String challenge = (String)payload.get("challenge");
             log.info("Slack URL 검증 요청 처리");
             return ResponseEntity.ok(Map.of("challenge", challenge));
         }
 
-        // 서명 검증 - 원본 요청 본문 사용
         if (!signatureVerifier.isValidRequest(timestamp, signature, rawBody)) {
             log.warn("Slack 서명 검증 실패");
             return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
         }
 
         log.debug("Slack 이벤트 수신: type={}", type);
 
-        // 이벤트 콜백 처리
         if ("event_callback".equals(type)) {
+            String eventId = (String)payload.get("event_id");
+            if (eventId != null && !processedEventIds.add(eventId)) {
+                log.debug("중복 이벤트 무시: event_id={}", eventId);
+                return ResponseEntity.ok().build();
+            }
+            if (processedEventIds.size() > EVENT_CACHE_MAX_SIZE) {
+                processedEventIds.remove(processedEventIds.iterator().next());
+            }
             Map<String, Object> event = (Map<String, Object>)payload.get("event");
             if (event != null) {
                 handleEvent(event);
             }
         }
 
-        // Slack은 3초 내 응답을 기대하므로 빠르게 200 반환
         return ResponseEntity.ok().build();
     }
 
@@ -89,27 +99,37 @@ private void handleEvent(Map<String, Object> event) {
         String eventType = (String)event.get("type");
         String text = (String)event.get("text");
         String subtype = (String)event.get("subtype");
+        String channelId = (String)event.get("channel");
+        String ts = (String)event.get("ts");
+        String threadTs = (String)event.get("thread_ts");
 
         log.debug("이벤트 처리: eventType={}", eventType);
 
-        // bot 메시지나 변경 이벤트는 무시
         if (subtype != null) {
             return;
         }
 
-        // 메시지 이벤트 처리
+        String effectiveThreadTs = threadTs != null ? threadTs : ts;
+
         if ("message".equals(eventType) && text != null) {
             if (slackAIService.isAIQuery(text)) {
                 log.debug("AI 질문 감지");
-                slackAIService.processAIQuery(text);
+                slackAIService.processAIQuery(text, channelId, effectiveThreadTs, null);
+            } else if (threadTs != null && slackAIService.isAppMention(text)) {
+                List<Map<String, Object>> aiReplies =
+                    slackAIService.fetchAIThreadReplies(channelId, threadTs);
+                if (!aiReplies.isEmpty()) {
+                    log.debug("AI 스레드 내 후속 질문 감지");
+                    slackAIService.processAIQuery(
+                        text, channelId, effectiveThreadTs, aiReplies);
+                }
             }
         }
 
-        // 앱 멘션 이벤트 처리
         if ("app_mention".equals(eventType) && text != null) {
             String normalizedText = slackAIService.normalizeAppMentionText(text);
             log.debug("앱 멘션 감지");
-            slackAIService.processAIQuery(normalizedText);
+            slackAIService.processAIQuery(normalizedText, channelId, effectiveThreadTs, null);
         }
     }
 }