aiexecode 1.0.72 → 1.0.74

package/src/ai_based/completion_judge.js

@@ -1,9 +1,10 @@
 import dotenv from "dotenv";
-import { request, isContextWindowError, getModelForProvider } from "../system/ai_request.js";
+import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
 import { getOrchestratorConversation } from "./orchestrator.js";
 import { createSystemMessage } from "../util/prompt_loader.js";
 import { createDebugLogger } from "../util/debug_log.js";
 import { getCurrentTodos } from "../system/session_memory.js";
+import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
 
 dotenv.config({ quiet: true });
 
@@ -116,16 +117,7 @@ function syncOrchestratorConversation() {
     debugLog(`[syncOrchestratorConversation] END`);
 }
 
-function trimCompletionJudgeConversation() {
-    for (let i = 1; i < completionJudgeConversation.length - 1; i++) {
-        const candidate = completionJudgeConversation[i];
-        if (candidate?.role !== "system") {
-            completionJudgeConversation.splice(i, 1);
-            return true;
-        }
-    }
-    return false;
-}
+// 대화 cleanup 및 trim 함수는 conversation_trimmer 모듈에서 가져옴
 
 async function dispatchCompletionJudgeRequest(options) {
     debugLog(`[dispatchCompletionJudgeRequest] START`);
@@ -140,9 +132,10 @@ async function dispatchCompletionJudgeRequest(options) {
     let attemptCount = 0;
     while (true) {
         attemptCount++;
-        debugLog(`[dispatchCompletionJudgeRequest] Attempt ${attemptCount}`);
+        debugLog(`[dispatchCompletionJudgeRequest] Attempt ${attemptCount} - starting cleanup...`);
+        cleanupOrphanOutputs(completionJudgeConversation);
 
-        const { model, isGpt5Model, taskName } = options;
+        debugLog(`[dispatchCompletionJudgeRequest] Conversation has ${completionJudgeConversation.length} entries`);
 
         // Conversation 구조 분석
         const conversationTypes = {};
@@ -151,7 +144,16 @@ async function dispatchCompletionJudgeRequest(options) {
             conversationTypes[type] = (conversationTypes[type] || 0) + 1;
         });
         debugLog(`[dispatchCompletionJudgeRequest] Conversation structure: ${JSON.stringify(conversationTypes)}`);
-        debugLog(`[dispatchCompletionJudgeRequest] Total conversation entries: ${completionJudgeConversation.length}`);
+
+        // function_call_output 항목들 확인
+        const functionCallOutputs = completionJudgeConversation.filter(item => item.type === 'function_call_output');
+        debugLog(`[dispatchCompletionJudgeRequest] Found ${functionCallOutputs.length} function_call_output entries`);
+
+        functionCallOutputs.forEach((item, index) => {
+            debugLog(`[dispatchCompletionJudgeRequest] function_call_output[${index}] - call_id: ${item.call_id}, output length: ${item.output?.length || 0}, output preview: ${item.output?.substring(0, 200)}`);
+        });
+
+        const { model, isGpt5Model, taskName } = options;
 
         const requestPayload = {
             model,
@@ -197,13 +199,13 @@ async function dispatchCompletionJudgeRequest(options) {
                 throw error;
             }
 
-            if (!isContextWindowError(error)) {
-                debugLog(`[dispatchCompletionJudgeRequest] Not a context window error, re-throwing`);
+            if (!shouldRetryWithTrim(error)) {
+                debugLog(`[dispatchCompletionJudgeRequest] Not recoverable by trimming, re-throwing`);
                 throw error;
             }
 
-            debugLog(`[dispatchCompletionJudgeRequest] Context window error detected, attempting to trim...`);
-            const trimmed = trimCompletionJudgeConversation();
+            debugLog(`[dispatchCompletionJudgeRequest] Recoverable error detected, attempting to trim...`);
+            const trimmed = trimConversation(completionJudgeConversation);
             debugLog(`[dispatchCompletionJudgeRequest] Trim result: ${trimmed}, new conversation length: ${completionJudgeConversation.length}`);
             if (!trimmed) {
                 debugLog(`[dispatchCompletionJudgeRequest] Cannot trim further, re-throwing error`);

package/src/ai_based/orchestrator.js

@@ -3,7 +3,8 @@ import dotenv from "dotenv";
 import path from 'path';
 import { truncateWithOmit } from "../util/text_formatter.js";
 import { createSystemMessage } from "../util/prompt_loader.js";
-import { request, isContextWindowError, getModelForProvider } from "../system/ai_request.js";
+import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
+import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
 import { runPythonCodeSchema, bashSchema } from "../system/code_executer.js";
 import { readFileSchema, readFileRangeSchema } from "../tools/file_reader.js";
 import { writeFileSchema, editFileRangeSchema, editFileReplaceSchema } from "../tools/code_editor.js";
@@ -120,18 +121,6 @@ export function recordOrchestratorToolResult({ toolCallId, toolName = '', argume
         return null;
     }
 
-    if (toolName === 'read_file') {
-        const filePath = toolArguments.filePath || '';
-        const absolutePath = path.isAbsolute(filePath)
-            ? filePath
-            : path.join(process.cwd(), filePath);
-
-        stdout = JSON.stringify({
-            absolute_file_path: absolutePath,
-            content: stdout
-        });
-    }
-
     const payload = {
         tool: toolName || null,
         call_id: toolCallId,
@@ -154,146 +143,7 @@ export function recordOrchestratorToolResult({ toolCallId, toolName = '', argume
     return toolResult;
 }
 
-function extractCallIdsFromItem(item) {
-    if (!item || typeof item !== 'object') {
-        return [];
-    }
-
-    const callIds = new Set();
-
-    const maybeIds = [item.call_id, item.tool_call_id, item.id];
-    for (const id of maybeIds) {
-        if (typeof id === 'string' && id.trim().length) {
-            callIds.add(id);
-        }
-    }
-
-    if (item.function && typeof item.function === 'object') {
-        const fnIds = [item.function.call_id, item.function.id];
-        for (const id of fnIds) {
-            if (typeof id === 'string' && id.trim().length) {
-                callIds.add(id);
-            }
-        }
-    }
-
-    if (Array.isArray(item.tool_calls)) {
-        for (const toolCall of item.tool_calls) {
-            extractCallIdsFromItem(toolCall).forEach(id => callIds.add(id));
-        }
-    }
-
-    return Array.from(callIds);
-}
-
-function removeConversationEntriesByCallIds(callIds) {
-    if (!Array.isArray(callIds) || callIds.length === 0) {
-        return;
-    }
-
-    const callIdSet = new Set(callIds.filter(id => typeof id === 'string' && id.trim().length));
-    if (!callIdSet.size) {
-        return;
-    }
-
-    for (let index = orchestratorConversation.length - 1; index >= 0; index--) {
-        const entry = orchestratorConversation[index];
-        if (!entry || typeof entry !== 'object') {
-            continue;
-        }
-
-        if (entry.type === 'function_call_output') {
-            if (callIdSet.has(entry.call_id)) {
-                orchestratorConversation.splice(index, 1);
-            }
-            continue;
-        }
-
-        if (Array.isArray(entry.tool_calls) && entry.tool_calls.length) {
-            const filteredToolCalls = entry.tool_calls.filter(toolCall => {
-                const ids = extractCallIdsFromItem(toolCall);
-                return !ids.some(id => callIdSet.has(id));
-            });
-
-            if (filteredToolCalls.length !== entry.tool_calls.length) {
-                if (filteredToolCalls.length === 0 && (!entry.content || entry.content.length === 0)) {
-                    orchestratorConversation.splice(index, 1);
-                } else {
-                    entry.tool_calls = filteredToolCalls;
-                }
-                continue;
-            }
-        }
-
-        const entryCallIds = extractCallIdsFromItem(entry);
-        if (entryCallIds.some(id => callIdSet.has(id))) {
-            orchestratorConversation.splice(index, 1);
-        }
-    }
-}
-
-function cleanupOrchestratorConversation() {
-    debugLog(`[cleanupOrchestratorConversation] Starting cleanup, conversation length: ${orchestratorConversation.length}`);
-
-    const validCallIds = new Set();
-
-    for (const entry of orchestratorConversation) {
-        if (!entry || typeof entry !== 'object') {
-            continue;
-        }
-
-        if (entry.type === 'function_call') {
-            const ids = extractCallIdsFromItem(entry);
-            debugLog(`[cleanupOrchestratorConversation] Found function_call with call_ids: ${ids.join(', ')}`);
-            ids.forEach(id => validCallIds.add(id));
-        }
-
-        if (Array.isArray(entry.tool_calls)) {
-            for (const toolCall of entry.tool_calls) {
-                const ids = extractCallIdsFromItem(toolCall);
-                debugLog(`[cleanupOrchestratorConversation] Found tool_call with call_ids: ${ids.join(', ')}`);
-                ids.forEach(id => validCallIds.add(id));
-            }
-        }
-    }
-
-    debugLog(`[cleanupOrchestratorConversation] Valid call IDs: ${Array.from(validCallIds).join(', ')}`);
-
-    for (let index = orchestratorConversation.length - 1; index >= 0; index--) {
-        const entry = orchestratorConversation[index];
-        if (entry?.type === 'function_call_output') {
-            const callId = entry.call_id;
-            if (!callId || !validCallIds.has(callId)) {
-                debugLog(`[cleanupOrchestratorConversation] REMOVING function_call_output at index ${index} with call_id: ${callId} (not in validCallIds)`);
-                orchestratorConversation.splice(index, 1);
-            } else {
-                debugLog(`[cleanupOrchestratorConversation] KEEPING function_call_output at index ${index} with call_id: ${callId}, output length: ${entry.output?.length || 0}`);
-            }
-        }
-    }
-
-    debugLog(`[cleanupOrchestratorConversation] Finished cleanup, conversation length: ${orchestratorConversation.length}`);
-}
-
-function trimOrchestratorConversation() {
-    if (orchestratorConversation.length <= 2) {
-        return false;
-    }
-
-    for (let i = 1; i < orchestratorConversation.length - 1; i++) {
-        const target = orchestratorConversation[i];
-        const callIds = extractCallIdsFromItem(target);
-
-        orchestratorConversation.splice(i, 1);
-
-        if (callIds.length) {
-            removeConversationEntriesByCallIds(callIds);
-        }
-
-        return true;
-    }
-    return false;
-}
+// 대화 cleanup 및 trim 함수는 conversation_trimmer 모듈에서 가져옴
 
 async function dispatchOrchestratorRequest({ toolChoice }) {
     debugLog(`[dispatchOrchestratorRequest] START - toolChoice: ${toolChoice}`);
@@ -309,7 +159,7 @@ async function dispatchOrchestratorRequest({ toolChoice }) {
     while (true) {
         attemptCount++;
         debugLog(`[dispatchOrchestratorRequest] Attempt ${attemptCount} - starting cleanup...`);
-        cleanupOrchestratorConversation();
+        cleanupOrphanOutputs(orchestratorConversation);
 
         debugLog(`[dispatchOrchestratorRequest] Conversation has ${orchestratorConversation.length} entries`);
 
@@ -370,15 +220,21 @@ async function dispatchOrchestratorRequest({ toolChoice }) {
             return response;
         } catch (error) {
             debugLog(`[dispatchOrchestratorRequest] API request failed: ${error.message}`);
-            debugLog(`[dispatchOrchestratorRequest] Error type: ${error?.constructor?.name}, code: ${error?.code}, status: ${error?.status}`);
+            debugLog(`[dispatchOrchestratorRequest] Error name: ${error.name}, type: ${error?.constructor?.name}`);
+
+            // AbortError는 즉시 전파 (세션 중단)
+            if (error.name === 'AbortError') {
+                debugLog(`[dispatchOrchestratorRequest] Request aborted by user, propagating AbortError`);
+                throw error;
+            }
 
-            if (!isContextWindowError(error)) {
-                debugLog(`[dispatchOrchestratorRequest] Not a context window error, re-throwing`);
+            if (!shouldRetryWithTrim(error)) {
+                debugLog(`[dispatchOrchestratorRequest] Not recoverable by trimming, re-throwing`);
                 throw error;
             }
 
-            debugLog(`[dispatchOrchestratorRequest] Context window error detected, attempting to trim conversation...`);
-            const trimmed = trimOrchestratorConversation();
+            debugLog(`[dispatchOrchestratorRequest] Recoverable error detected, attempting to trim conversation...`);
+            const trimmed = trimConversation(orchestratorConversation);
             debugLog(`[dispatchOrchestratorRequest] Trim result: ${trimmed}, new conversation length: ${orchestratorConversation.length}`);
             if (!trimmed) {
                 debugLog(`[dispatchOrchestratorRequest] Cannot trim further, re-throwing error`);

package/src/system/ai_request.js

@@ -193,10 +193,36 @@ export async function request(taskName, requestPayload) {
     }
 
     debugLog(`[request] Starting payload transformation...`);
+    const isValidJSON = (json) => {
+        if (typeof json !== 'string') return false;
+        try {
+            JSON.parse(json);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+    if (true && payloadCopy.input && Array.isArray(payloadCopy.input)) {
+        for (let i = payloadCopy.input.length - 1; i >= 0; i--) {
+            const msg = payloadCopy.input[i];
+            const { type, call_id, output } = msg;
+            if (type !== 'function_call_output') continue;
+            const parsedOutput = JSON.parse(output);
+            if (!isValidJSON(parsedOutput.stdout)) {
+                msg.output = parsedOutput.stdout;
+            } else {
+                parsedOutput.stdout = JSON.parse(parsedOutput.stdout);
+                if (parsedOutput.original_result) {
+                    parsedOutput.stdout = ({ ...parsedOutput.original_result, ...(parsedOutput.stdout) });
+                    delete parsedOutput.original_result;
+                }
+                msg.output = parsedOutput;
+            }
+        }
+    }
     if (payloadCopy.input && Array.isArray(payloadCopy.input)) {
         const marker = {};
         const remove_call_id = {};//[];
-        const response_message_call_id = {};
 
         debugLog(`[request] Processing ${payloadCopy.input.length} input messages for deduplication and formatting`);
         let processedCount = 0;
@@ -207,105 +233,182 @@ export async function request(taskName, requestPayload) {
             if (type !== 'function_call_output') continue;
             processedCount++;
 
-            debugLog(`[ai_request] Processing function_call_output, call_id: ${call_id}, output length: ${output?.length || 0}`);
+            if ((typeof output) === 'string') continue;
+            const { tool, stdout, stderr, exit_code, original_result } = output;
 
-            const parsedOutput = JSON.parse(output);
-            const { tool, stdout, stderr, exit_code } = parsedOutput;
-
-            debugLog(`[ai_request] Parsed output - tool: ${tool}, stdout: ${stdout?.length || 0} bytes, stderr: ${stderr?.length || 0} bytes`);
-
-            if (tool === 'edit_file_range') {
-                const parsedStdout = JSON.parse(stdout);
-                if (!parsedStdout.absolute_file_path) continue;
-                let abolute_path = toAbsolutePath(parsedStdout.absolute_file_path)
-                const updated_content = parsedStdout.file_stats?.updated_content;
-                delete parsedStdout.absolute_file_path;
-                delete parsedStdout.file_stats;
-                if (marker[abolute_path]) {
-                    parsedStdout.target_file_path;
-                } else {
-                    if (updated_content) {
-                        parsedStdout.updated_content = formatReadFileStdout({ file_lines: updated_content.split('\n') });
-                    }
-                }
-                marker[abolute_path] = true;
-                msg.output = JSON.stringify(parsedStdout, null, 2);
-                debugLog(`[ai_request] edit_file_range - new output length: ${msg.output.length}`);
-            }
-            else if (tool === 'edit_file_replace') {
-                const parsedStdout = JSON.parse(stdout);
-                if (!parsedStdout.absolute_file_path) continue;
-                let abolute_path = toAbsolutePath(parsedStdout.absolute_file_path)
-                const updated_content = parsedStdout.file_stats?.updated_content;
-                delete parsedStdout.absolute_file_path;
-                delete parsedStdout.file_stats;
-                if (marker[abolute_path]) {
-                    parsedStdout.target_file_path;
-                } else {
-                    if (updated_content) {
-                        parsedStdout.updated_content = formatReadFileStdout({ file_lines: updated_content.split('\n') });
-                    }
-                }
+            if (stdout?.operation_successful?.constructor === Boolean && !stdout.operation_successful) continue;
+            if (tool === 'edit_file_range' || tool === 'edit_file_replace') {
+                let abolute_path = toAbsolutePath(stdout.target_file_path);
+                const updated_content = stdout.file_stats?.updated_content;
+                delete stdout.file_stats;
+                if (!marker[abolute_path] && updated_content) stdout.updated_content = updated_content.split('\n');
                 marker[abolute_path] = true;
-                msg.output = JSON.stringify(parsedStdout, null, 2);
-                debugLog(`[ai_request] edit_file_replace - new output length: ${msg.output.length}`);
             }
             else if (tool === 'read_file') {
-                const parsedStdout = JSON.parse(stdout);
-                if (!parsedStdout.absolute_file_path) continue;
-                let abolute_path = toAbsolutePath(parsedStdout.absolute_file_path)
-                const content = parsedStdout.content;
+                let abolute_path = toAbsolutePath(stdout.target_file_path);
                 if (marker[abolute_path]) {
-                    remove_call_id[call_id] = true;//.push(call_id);
-                    msg.output = '(표시하지 않음)';
-                } else {
-                    msg.output = content;
+                    remove_call_id[call_id] = true;
+                    stdout.file_content = '(Not displayed)';
                 }
                 marker[abolute_path] = true;
-                debugLog(`[ai_request] read_file - new output length: ${msg.output.length}`);
-                // msg.output = 'FG';
-            } else {
-                debugLog(`[ai_request] OTHER TOOL (${tool}) - BEFORE: output is full JSON with stderr`);
-                // run_python_code, bash 등의 경우 stdout과 stderr를 모두 포함
-                let combinedOutput = '';
-                if (stdout && stderr) {
-                    combinedOutput = `stdout:\n${stdout}\n\nstderr:\n${stderr}`;
-                } else if (stdout) {
-                    combinedOutput = stdout;
-                } else if (stderr) {
-                    combinedOutput = `stderr:\n${stderr}`;
-                }
-                msg.output = combinedOutput;
-                debugLog(`[ai_request] OTHER TOOL (${tool}) - AFTER: output length: ${msg.output.length} bytes (stdout: ${stdout?.length || 0}, stderr: ${stderr?.length || 0})`);
+            }
+            else {
+                // debugLog(`[ai_request] OTHER TOOL (${tool}) - BEFORE: output is full JSON with stderr`);
+                // // run_python_code, bash 등의 경우 stdout과 stderr를 모두 포함
+                // let combinedOutput = '';
+                // if (stdout && stderr) {
+                //     combinedOutput = `stdout:\n${stdout}\n\nstderr:\n${stderr}`;
+                // } else if (stdout) {
+                //     combinedOutput = stdout;
+                // } else if (stderr) {
+                //     combinedOutput = `stderr:\n${stderr}`;
+                // }
+                // msg.output = combinedOutput;
+                // debugLog(`[ai_request] OTHER TOOL (${tool}) - AFTER: output length: ${msg.output.length} bytes (stdout: ${stdout?.length || 0}, stderr: ${stderr?.length || 0})`);
             }
         }
 
         debugLog(`[request] Processed ${processedCount} function_call_output entries`);
         debugLog(`[request] Marked files for deduplication: ${Object.keys(marker).length}`);
 
-        let responseMessageCount = 0;
+    }
+    if (true && payloadCopy.input && Array.isArray(payloadCopy.input)) {
+        const response_message_call_id = {};
         for (let i = payloadCopy.input.length - 1; i >= 0; i--) {
             const msg = payloadCopy.input[i];
             const { type, call_id, name } = msg;
             if (type !== 'function_call') continue;
             if (name !== 'response_message') continue;
             response_message_call_id[call_id] = true;
-            responseMessageCount++;
         }
-        debugLog(`[request] Found ${responseMessageCount} response_message function calls`);
-
-        let simplifiedResponseMessages = 0;
         for (let i = payloadCopy.input.length - 1; i >= 0; i--) {
             const msg = payloadCopy.input[i];
             const { type, call_id } = msg;
             if (type !== 'function_call_output') continue;
             if (!response_message_call_id[call_id]) continue;
-            msg.output = JSON.stringify({ message_displayed: true });
-            simplifiedResponseMessages++;
+            msg.output = {
+                tool: 'response_message',
+                stdout: { message_displayed: true }
+            };
         }
-        debugLog(`[request] Simplified ${simplifiedResponseMessages} response_message outputs`);
     }
+    // Formatting
+    if (true && payloadCopy.input && Array.isArray(payloadCopy.input)) {
+        for (let i = payloadCopy.input.length - 1; i >= 0; i--) {
+            const msg = payloadCopy.input[i];
+            const { type, call_id, output } = msg;
+
+            if (type !== 'function_call_output') continue;
+            if (typeof output === 'string') continue;
+            const { tool, stdout, stderr, exit_code, original_result } = output;
+            if (false) await safeWriteFile('./__stdout/' + tool + '.' + (call_id) + '.json', JSON.stringify(stdout, null, 2));
+
+            // read_file
+            if (tool === 'read_file') {
+                if (!stdout.operation_successful) {
+                    msg.output = stdout.error_message;
+                }
+                else {
+                    if (stdout.file_content.includes('\n')) {
+                        msg.output = formatReadFileStdout(stdout.file_content);
+                    } else {
+                        msg.output = (stdout.file_content);
+                    }
+                }
+                continue;
+            }
+
+            // read_file_range
+            if (tool === 'read_file_range') {
+                if (!stdout.operation_successful) {
+                    msg.output = stdout.error_message;
+                }
+                else {
+                    msg.output = formatReadFileStdout(stdout.file_content, stdout.actual_range.start_line);
+                }
+                continue;
+            }
+
+            // write_file
+            if (tool === 'write_file') {
+                if (!stdout.operation_successful) {
+                    msg.output = stdout.error_message;
+                } else {
+                    msg.output = `File written successfully: ${stdout.target_file_path}`;
+                }
+                continue;
+            }
 
+            // edit_file_replace
+            if (tool === 'edit_file_replace') {
+                if (!stdout.operation_successful) {
+                    msg.output = stdout.error_message;
+                } else {
+                    // const isString = stdout?.updated_content?.constructor === String;
+                    const newObj = {
+                        unified_diff_patch: stdout.diff_info.unified_diff_patch,
+                        operation_successful: stdout.operation_successful,
+                        updated_content: formatReadFileStdout(stdout?.updated_content?.join('\n')),
+                    };
+                    if (!(stdout?.updated_content)) delete newObj.updated_content;
+                    // if (!isString) delete newObj.updated_content;
+                    msg.output = JSON.stringify(newObj, null, 2);
+                }
+                continue;
+            }
+
+            // edit_file_range
+            if (tool === 'edit_file_range') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // ripgrep
+            if (tool === 'ripgrep') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // glob_search
+            if (tool === 'glob_search') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // fetch_web_page
+            if (tool === 'fetch_web_page') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // response_message
+            if (tool === 'response_message') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // todo_write
+            if (tool === 'todo_write') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // bash (from code_executer.js)
+            if (tool === 'bash') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // run_python_code (from code_executer.js)
+            if (tool === 'run_python_code') {
+                msg.output = JSON.stringify(stdout, null, 2);
+                continue;
+            }
+
+            // Default case for unknown tools
+            msg.output = JSON.stringify(stdout, null, 2);
+        }
+    }
     debugLog(`[request] Payload transformation complete`);
     let response;
     let originalRequest;
@@ -424,37 +527,38 @@ export async function request(taskName, requestPayload) {
 }
 
 /**
- * OpenAI API의 컨텍스트 윈도우 초과 에러인지 확인합니다.
+ * API 에러가 대화 trim 후 재시도로 복구 가능한지 확인합니다.
  *
- * 이 함수는 OpenAI API의 공식 에러 코드만을 신뢰하며,
- * 에러 메시지 문자열 매칭은 사용하지 않습니다.
+ * 처리 대상:
+ * - context_length_exceeded: 컨텍스트 윈도우 초과
+ * - 400 error: 잘못된 요청 (대화가 너무 길어서 발생 가능)
  *
  * @param {Error | Object} error - 확인할 에러 객체
- * @returns {boolean} 컨텍스트 윈도우 초과 에러 여부
+ * @returns {boolean} trim 후 재시도 가능 여부
  *
  * @see https://platform.openai.com/docs/guides/error-codes
  */
-export function isContextWindowError(error) {
+export function shouldRetryWithTrim(error) {
     if (!error) return false;
 
     // OpenAI SDK의 공식 에러 코드 확인
-    // error.code 또는 error.error.code에서 확인
     const errorCode = error?.code || error?.error?.code;
 
     if (errorCode === 'context_length_exceeded') {
-        debugLog('[isContextWindowError] Detected: context_length_exceeded');
+        debugLog('[shouldRetryWithTrim] Detected: context_length_exceeded');
         return true;
     }
 
-    // 감지되지 않은 에러 - 디버깅을 위해 로그 남김
+    // 400 에러도 trim 후 재시도 대상
     if (error?.status === 400 || error?.response?.status === 400) {
         const errorType = error?.type || error?.error?.type;
         const errorMessage = error?.message || error?.error?.message || '';
         debugLog(
-            `[isContextWindowError] Not detected - ` +
-            `Status: 400, Type: ${errorType}, Code: ${errorCode}, ` +
+            `[shouldRetryWithTrim] Detected 400 error - ` +
+            `Type: ${errorType}, Code: ${errorCode}, ` +
             `Message: ${errorMessage.substring(0, 200)}`
         );
+        return true;
     }
 
     return false;