aiexecode 1.0.57 → 1.0.58

package/src/ai_based/completion_judge.js

@@ -0,0 +1,247 @@
+import dotenv from "dotenv";
+import { request, isContextWindowError, 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";
+
+dotenv.config({ quiet: true });
+
+const debugLog = createDebugLogger('completion_judge.log', 'completion_judge');
+
+export const completionJudgmentSchema = {
+    name: "completion_judgment",
+    schema: {
+        type: "object",
+        properties: {
+            should_complete: {
+                type: "boolean",
+                description: "Whether the mission is truly complete (true) or should continue (false). If whatUserShouldSay is hard to determine, set this to true."
+            },
+            reason: {
+                type: "string",
+                description: "Brief explanation in 1-2 sentences for the decision",
+                minLength: 1
+            },
+            whatUserShouldSay: {
+                type: "string",
+                description: "The most appropriate thing the user should say next, as if you (the assistant) were the user observing the current situation. Put yourself in the user's shoes and determine what would be the most natural and helpful thing to say to guide the agent forward. MUST be a single, clear, decisive instruction without hedging words like 'maybe', 'perhaps', 'consider', 'you could', or offering multiple options. Pick the MOST important next step and state it with strong conviction. Empty string if mission is complete or if it's genuinely unclear what the user should say."
+            }
+        },
+        required: ["should_complete", "reason", "whatUserShouldSay"],
+        additionalProperties: false
+    },
+    strict: true
+};
+
+// systemMessage는 judgeMissionCompletion 호출 시 동적으로 생성됨
+
+const completionJudgeConversation = [];
+let lastOrchestratorSnapshotLength = 0;
+
+function cloneMessage(message) {
+    return JSON.parse(JSON.stringify(message));
+}
+
+
+async function createCompletionJudgeRequestOptions() {
+    const model = await getModelForProvider();
+    return {
+        taskName: 'completion_judge',
+        model,
+        isGpt5Model: model.startsWith("gpt-5")
+    };
+}
+
+/**
+ * Completion judge conversation을 초기화하거나 시스템 프롬프트를 업데이트합니다.
+ * 매 요청마다 프롬프트 파일을 새로 읽어서 변경사항을 즉시 반영합니다.
+ */
+async function ensureCompletionJudgeConversationInitialized(templateVars = {}) {
+    // 매번 최신 시스템 프롬프트를 로드
+    const systemMessage = await createSystemMessage("completion_judge.txt", templateVars);
+
+    const systemMessageEntry = {
+        role: "system",
+        content: [
+            {
+                type: "input_text",
+                text: systemMessage.content
+            }
+        ]
+    };
+
+    // conversation이 비어있으면 새로 추가
+    if (!completionJudgeConversation.length) {
+        completionJudgeConversation.push(systemMessageEntry);
+    } else {
+        // conversation이 있으면 첫 번째 system 메시지를 업데이트
+        if (completionJudgeConversation[0]?.role === "system") {
+            completionJudgeConversation[0] = systemMessageEntry;
+        } else {
+            // system 메시지가 맨 앞에 없으면 추가
+            completionJudgeConversation.unshift(systemMessageEntry);
+        }
+    }
+}
+
+function syncOrchestratorConversation() {
+    const sourceConversation = getOrchestratorConversation();
+    if (!Array.isArray(sourceConversation) || !sourceConversation.length) {
+        return;
+    }
+
+    for (let i = lastOrchestratorSnapshotLength; i < sourceConversation.length; i++) {
+        const entry = sourceConversation[i];
+        if (!entry) continue;
+
+        // Completion judge는 자체 system 메시지를 유지하므로, Orchestrator의 system 메시지는 제외
+        if (entry.role === "system") continue;
+
+        // reasoning과 message를 모두 그대로 복사
+        // ai_request.js에서 이미 reasoning-message 쌍이 유지되고 있음
+        completionJudgeConversation.push(cloneMessage(entry));
+    }
+
+    lastOrchestratorSnapshotLength = sourceConversation.length;
+}
+
+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;
+}
+
+async function dispatchCompletionJudgeRequest(options) {
+    if (!options) {
+        throw new Error('Completion judge request options not initialized.');
+    }
+
+    while (true) {
+        const { model, isGpt5Model, taskName } = options;
+        const requestPayload = {
+            model,
+            input: completionJudgeConversation,
+            text: {
+                format: {
+                    type: "json_schema",
+                    name: completionJudgmentSchema.name,
+                    strict: completionJudgmentSchema.strict,
+                    schema: completionJudgmentSchema.schema
+                }
+            },
+            reasoning: {},
+            tool_choice: "none",
+            tools: [],
+            top_p: 1,
+            store: true
+        };
+
+        if (!isGpt5Model) {
+            requestPayload.temperature = 0;
+        }
+
+        try {
+            return await request(taskName, requestPayload);
+        } catch (error) {
+            // AbortError는 즉시 전파 (세션 중단)
+            if (error.name === 'AbortError') {
+                debugLog(`[dispatchCompletionJudgeRequest] Request aborted by user`);
+                throw error;
+            }
+
+            if (!isContextWindowError(error)) {
+                throw error;
+            }
+
+            const trimmed = trimCompletionJudgeConversation();
+            if (!trimmed) {
+                throw error;
+            }
+        }
+    }
+}
+
+export function resetCompletionJudgeConversation() {
+    completionJudgeConversation.length = 0;
+    lastOrchestratorSnapshotLength = 0;
+}
+
+export function getCompletionJudgeConversation() {
+    return completionJudgeConversation;
+}
+
+export function restoreCompletionJudgeConversation(savedConversation, savedSnapshotLength = 0) {
+    completionJudgeConversation.length = 0;
+    if (Array.isArray(savedConversation)) {
+        completionJudgeConversation.push(...savedConversation);
+    }
+    lastOrchestratorSnapshotLength = savedSnapshotLength;
+}
+
+/**
+ * Orchestrator가 function call 없이 message만 반환했을 때,
+ * 실제로 미션이 완료되었는지 판단하는 함수
+ *
+ * @param {Object} templateVars - 시스템 프롬프트 템플릿 변수 (예: mission)
+ * @returns {Promise<{shouldComplete: boolean, reason: string}>}
+ */
+export async function judgeMissionCompletion(templateVars = {}) {
+    debugLog(`[judgeMissionCompletion] Called with templateVars: ${JSON.stringify(Object.keys(templateVars))}`);
+
+    try {
+        const requestOptions = await createCompletionJudgeRequestOptions();
+
+        // Completion judge 자체 system 메시지 초기화 (템플릿 변수 전달)
+        await ensureCompletionJudgeConversationInitialized(templateVars);
+        // Orchestrator의 대화 내용 동기화 (system 메시지 제외)
+        syncOrchestratorConversation();
+
+        debugLog(`[judgeMissionCompletion] Sending request with ${completionJudgeConversation.length} conversation entries`);
+
+        const response = await dispatchCompletionJudgeRequest(requestOptions);
+
+        debugLog(`[judgeMissionCompletion] Received response, parsing output_text`);
+
+        // Completion judge 자신의 응답은 히스토리에 추가하지 않음 (Orchestrator와 동일한 히스토리 유지)
+        // 대화 기록 초기화 (다음 판단을 위해)
+        resetCompletionJudgeConversation();
+
+        try {
+            const judgment = JSON.parse(response.output_text);
+            debugLog(`[judgeMissionCompletion] Parsed judgment: ${JSON.stringify(judgment)}`);
+
+            return {
+                shouldComplete: judgment.should_complete === true,
+                reason: judgment.reason || "No reason provided",
+                whatUserShouldSay: judgment.whatUserShouldSay || ""
+            };
+        } catch (parseError) {
+            debugLog(`[judgeMissionCompletion] Parse error: ${parseError.message}`);
+            throw new Error('Completion judge response did not include valid JSON output_text.');
+        }
+
+    } catch (error) {
+        debugLog(`[judgeMissionCompletion] ERROR: ${error.message}, error.name: ${error.name}`);
+
+        // 에러 발생 시 대화 기록 초기화
+        resetCompletionJudgeConversation();
+
+        // AbortError는 즉시 전파 (세션 중단)
+        if (error.name === 'AbortError') {
+            debugLog(`[judgeMissionCompletion] AbortError detected, propagating to caller`);
+            throw error;
+        }
+
+        // 다른 에러 발생 시 안전하게 계속 진행
+        return {
+            shouldComplete: false,
+            reason: `Error during judgment: ${error.message} - continuing to be safe`,
+            whatUserShouldSay: ""
+        };
+    }
+}

package/src/ai_based/orchestrator.js

@@ -351,10 +351,16 @@ export async function continueOrchestratorConversation() {
 
 
 // 탐색 기반으로 현재 상황을 분석하고, 다음에 취할 행동을 AI에게 결정받습니다.
-export async function orchestrateMission({ improvement_points = '', mcpToolSchemas = [] }) {
+export async function orchestrateMission({ improvement_points = '', mcpToolSchemas = [], isAutoGenerated = false }) {
     const taskName = 'orchestrator';
 
+    debugLog(`[orchestrateMission] Called with improvement_points: "${improvement_points?.substring(0, 100) || '(empty)'}", isAutoGenerated: ${isAutoGenerated}`);
     const improvementPointsText = typeof improvement_points === 'string' && improvement_points.trim().length ? improvement_points : '';
+    debugLog(`[orchestrateMission] improvementPointsText after processing: "${improvementPointsText.substring(0, 100) || '(empty)'}"`);
+    if (isAutoGenerated) {
+        debugLog(`[orchestrateMission] This is an auto-generated user message (from completion_judge)`);
+    }
+
 
     // Python 사용 가능 여부 확인
     const hasPython = process.app_custom?.systemInfo?.commands?.hasPython || false;
@@ -411,8 +417,8 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
 
     await ensureConversationInitialized();
 
-
-    orchestratorConversation.push({
+    debugLog(`[orchestrateMission] Adding user message to conversation: "${improvementPointsText.substring(0, 100)}"`);
+    const userMessage = {
         role: "user",
         content: [
             {
@@ -420,9 +426,19 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
                 text: improvementPointsText
             }
         ]
-    });
+    };
+
+    // Auto-generated user message인 경우 _internal_only 플래그 추가
+    if (isAutoGenerated) {
+        userMessage._internal_only = true;
+        debugLog(`[_internal_only] Marked user message as internal-only (auto-generated from completion_judge)`);
+    }
+
+    orchestratorConversation.push(userMessage);
+    debugLog(`[orchestrateMission] Conversation length after adding user message: ${orchestratorConversation.length}`);
 
     const response = await dispatchOrchestratorRequest({ toolChoice: "required" });
     appendResponseToConversation(response);
+    debugLog(`[orchestrateMission] Conversation length after response: ${orchestratorConversation.length}`);
     return response;
 }

package/src/system/ai_request.js

@@ -494,6 +494,15 @@ export async function request(taskName, requestPayload) {
     // requestPayload를 deep copy하여 원본 보호
     let payloadCopy = JSON.parse(JSON.stringify(requestPayload));
 
+    // _internal_only 속성 제거 (API 요청에 무효한 속성)
+    if (payloadCopy.input && Array.isArray(payloadCopy.input)) {
+        for (const msg of payloadCopy.input) {
+            if (msg._internal_only) {
+                delete msg._internal_only;
+            }
+        }
+    }
+
     // function_call_output의 output에서 original_result 제거
     if (false && payloadCopy.input && Array.isArray(payloadCopy.input)) {
         for (const msg of payloadCopy.input) {