@junctionpanel/server 0.1.42 → 0.1.43

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -11,6 +11,7 @@ import { buildCodexRuntimeExtra, DEFAULT_CODEX_MODE_ID, isCodexPlanModeEnabled,
 import { writeImageAttachment } from "./image-attachments.js";
 const DEFAULT_TIMEOUT_MS = 14 * 24 * 60 * 60 * 1000;
 const TURN_START_TIMEOUT_MS = 90 * 1000;
+const TURN_COMPLETION_SETTLE_DELAY_MS = 75;
 const CODEX_PROVIDER = "codex";
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
@@ -1593,6 +1594,7 @@ class CodexAppServerAgentSession {
         this.pendingPlanTexts = new Map();
         this.cachedSkills = [];
         this.turnCompletionInFlight = false;
+        this.deferredTurnCompletion = null;
         this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
@@ -2115,6 +2117,7 @@ class CodexAppServerAgentSession {
                         ? "cancel"
                         : "decline");
             pending.resolve({ decision });
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "file") {
@@ -2125,14 +2128,17 @@ class CodexAppServerAgentSession {
                         ? "cancel"
                         : "decline");
             pending.resolve({ decision });
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "permissions") {
             pending.resolve(buildCodexPermissionsResponse(response, pending.permissions));
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         if (pending.kind === "elicitation") {
             pending.resolve(buildCodexElicitationResponse(response));
+            this.scheduleDeferredTurnCompletionAfterPermissionResponse();
             return;
         }
         // tool/requestUserInput
@@ -2161,6 +2167,7 @@ class CodexAppServerAgentSession {
             answers["default"] = { answers: fallbackAnswers && fallbackAnswers.length > 0 ? fallbackAnswers : [decision] };
         }
         pending.resolve({ answers });
+        this.scheduleDeferredTurnCompletionAfterPermissionResponse();
     }
     describePersistence() {
         if (!this.currentThreadId)
@@ -2204,6 +2211,7 @@ class CodexAppServerAgentSession {
         this.pendingPermissionHandlers.clear();
         this.pendingPermissions.clear();
         this.resolvedPermissionRequests.clear();
+        this.clearDeferredTurnCompletion();
         this.eventQueue?.end();
         this.eventQueue = null;
         if (this.client) {
@@ -2328,7 +2336,84 @@ class CodexAppServerAgentSession {
     emitEvent(event) {
         this.eventQueue?.push(event);
     }
+    hasOutstandingPermissionRequests() {
+        return this.pendingPermissionHandlers.size > 0;
+    }
+    clearDeferredTurnCompletion() {
+        if (this.deferredTurnCompletion?.timer) {
+            clearTimeout(this.deferredTurnCompletion.timer);
+        }
+        this.deferredTurnCompletion = null;
+    }
+    scheduleDeferredTurnCompletion(parsed, options) {
+        const waitingOnPermission = options?.waitingOnPermission ??
+            this.deferredTurnCompletion?.waitingOnPermission ??
+            this.hasOutstandingPermissionRequests();
+        this.clearDeferredTurnCompletion();
+        this.turnCompletionInFlight = true;
+        const deferred = {
+            parsed,
+            turnId: this.currentTurnId,
+            waitingOnPermission,
+            timer: null,
+        };
+        deferred.timer = setTimeout(() => {
+            void this.flushDeferredTurnCompletion(deferred.turnId);
+        }, TURN_COMPLETION_SETTLE_DELAY_MS);
+        this.deferredTurnCompletion = deferred;
+    }
+    markDeferredTurnCompletionAwaitingPermissions() {
+        if (!this.deferredTurnCompletion) {
+            return;
+        }
+        this.scheduleDeferredTurnCompletion(this.deferredTurnCompletion.parsed, {
+            waitingOnPermission: true,
+        });
+    }
+    discardDeferredTurnCompletion(reason) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred) {
+            return;
+        }
+        this.logger.trace({
+            reason,
+            threadId: this.currentThreadId,
+            turnId: deferred.turnId,
+        }, "Discarding deferred Codex turn completion after resumed activity");
+        this.clearDeferredTurnCompletion();
+        this.turnCompletionInFlight = false;
+    }
+    noteTurnActivityAfterPermission(activity) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred || !deferred.waitingOnPermission || this.hasOutstandingPermissionRequests()) {
+            return;
+        }
+        this.discardDeferredTurnCompletion(activity);
+    }
+    async flushDeferredTurnCompletion(turnId) {
+        const deferred = this.deferredTurnCompletion;
+        if (!deferred || deferred.turnId !== turnId) {
+            return;
+        }
+        if (this.hasOutstandingPermissionRequests()) {
+            this.scheduleDeferredTurnCompletion(deferred.parsed, {
+                waitingOnPermission: true,
+            });
+            return;
+        }
+        this.clearDeferredTurnCompletion();
+        await this.finalizeTurnCompletion(deferred.parsed);
+    }
+    scheduleDeferredTurnCompletionAfterPermissionResponse() {
+        if (!this.deferredTurnCompletion || this.hasOutstandingPermissionRequests()) {
+            return;
+        }
+        this.scheduleDeferredTurnCompletion(this.deferredTurnCompletion.parsed, {
+            waitingOnPermission: true,
+        });
+    }
     clearTurnState() {
+        this.clearDeferredTurnCompletion();
         this.currentTurnId = null;
         this.emittedItemStartedIds.clear();
         this.emittedItemCompletedIds.clear();
@@ -2506,7 +2591,24 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "turn_completed") {
+            // A later failed/interrupted terminal status must replace a deferred
+            // "completed" status so we do not hide a real terminal error behind
+            // the settle window.
             if (this.turnCompletionInFlight) {
+                if (parsed.status === "completed") {
+                    this.scheduleDeferredTurnCompletion(parsed);
+                    return;
+                }
+                if (this.deferredTurnCompletion) {
+                    this.clearDeferredTurnCompletion();
+                    this.turnCompletionInFlight = false;
+                }
+                else {
+                    return;
+                }
+            }
+            if (parsed.status === "completed") {
+                this.scheduleDeferredTurnCompletion(parsed);
                 return;
             }
             this.turnCompletionInFlight = true;
@@ -2514,6 +2616,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "plan_updated") {
+            this.noteTurnActivityAfterPermission("plan_updated");
             const items = planStepsToTodoItems(parsed.plan.map((entry) => ({
                 step: entry.step ?? "",
                 status: entry.status ?? "pending",
@@ -2526,6 +2629,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "plan_delta") {
+            this.noteTurnActivityAfterPermission("plan_delta");
             const previous = this.pendingPlanTexts.get(parsed.itemId) ?? "";
             const next = previous + parsed.delta;
             this.pendingPlanTexts.set(parsed.itemId, next);
@@ -2567,25 +2671,30 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "agent_message_delta") {
+            this.noteTurnActivityAfterPermission("agent_message_delta");
             const prev = this.pendingAgentMessages.get(parsed.itemId) ?? "";
             this.pendingAgentMessages.set(parsed.itemId, prev + parsed.delta);
             return;
         }
         if (parsed.kind === "reasoning_delta") {
+            this.noteTurnActivityAfterPermission("reasoning_delta");
             const prev = this.pendingReasoning.get(parsed.itemId) ?? [];
             prev.push(parsed.delta);
             this.pendingReasoning.set(parsed.itemId, prev);
             return;
         }
         if (parsed.kind === "exec_command_output_delta") {
+            this.noteTurnActivityAfterPermission("exec_command_output_delta");
             this.appendOutputDeltaChunk(this.pendingCommandOutputDeltas, parsed.callId, parsed.chunk, { decodeBase64: true });
             return;
         }
         if (parsed.kind === "file_change_output_delta") {
+            this.noteTurnActivityAfterPermission("file_change_output_delta");
             this.appendOutputDeltaChunk(this.pendingFileChangeOutputDeltas, parsed.itemId, parsed.delta);
             return;
         }
         if (parsed.kind === "exec_command_started") {
+            this.noteTurnActivityAfterPermission("exec_command_started");
             if (parsed.callId) {
                 this.emittedExecCommandStartedCallIds.add(parsed.callId);
                 this.pendingCommandOutputDeltas.delete(parsed.callId);
@@ -2602,6 +2711,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "exec_command_completed") {
+            this.noteTurnActivityAfterPermission("exec_command_completed");
             const bufferedOutput = this.consumeOutputDelta(this.pendingCommandOutputDeltas, parsed.callId);
             const timelineItem = mapCodexExecNotificationToToolCall({
                 callId: parsed.callId,
@@ -2620,6 +2730,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_started") {
+            this.noteTurnActivityAfterPermission("patch_apply_started");
             if (parsed.callId) {
                 this.pendingFileChangeOutputDeltas.delete(parsed.callId);
             }
@@ -2639,6 +2750,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "patch_apply_completed") {
+            this.noteTurnActivityAfterPermission("patch_apply_completed");
             const bufferedOutput = this.consumeOutputDelta(this.pendingFileChangeOutputDeltas, parsed.callId);
             const timelineItem = mapCodexPatchNotificationToToolCall({
                 callId: parsed.callId,
@@ -2660,6 +2772,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "item_completed") {
+            this.noteTurnActivityAfterPermission("item_completed");
             // Codex emits mirrored lifecycle notifications via both `codex/event/item_*`
             // and canonical `item/*`. We render only the canonical channel to avoid
             // duplicated assistant/reasoning rows.
@@ -2670,6 +2783,7 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "item_started") {
+            this.noteTurnActivityAfterPermission("item_started");
             if (parsed.source === "codex_event") {
                 return;
             }
@@ -2775,6 +2889,7 @@ class CodexAppServerAgentSession {
             : parsed.networkApprovalContext
                 ? "Allow network access"
                 : "Run command";
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2818,6 +2933,7 @@ class CodexAppServerAgentSession {
     handleFileChangeApprovalRequest(requestMethod, params, rawRequestId) {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2851,6 +2967,7 @@ class CodexAppServerAgentSession {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
         const questions = normalizeCodexQuestionDescriptors(parsed.questions);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2889,6 +3006,7 @@ class CodexAppServerAgentSession {
     handlePermissionsApprovalRequest(requestMethod, params, rawRequestId) {
         const parsed = params;
         const requestId = toPendingPermissionId(rawRequestId ?? parsed.itemId);
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2936,6 +3054,7 @@ class CodexAppServerAgentSession {
             : parsed.serverName
                 ? `Respond to ${parsed.serverName}`
                 : "Respond to MCP server";
+        this.markDeferredTurnCompletionAwaitingPermissions();
         const request = {
             id: requestId,
             provider: CODEX_PROVIDER,
@@ -2985,6 +3104,12 @@ class CodexAppServerAgentSession {
         });
     }
 }
+Object.assign(__codexAppServerInternals, {
+    TURN_COMPLETION_SETTLE_DELAY_MS,
+    createTestSession(config, resumeHandle, logger, spawnAppServer) {
+        return new CodexAppServerAgentSession(config, resumeHandle, logger, spawnAppServer);
+    },
+});
 export class CodexAppServerAgentClient {
     constructor(logger, runtimeSettings) {
         this.logger = logger;