@junctionpanel/server 0.1.41 → 0.1.42

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

@@ -695,6 +695,60 @@ function formatProposedPlanChunk(text, options) {
     }
     return parts.join("");
 }
+function buildCompletedCodexTimelineItem(item, options) {
+    const timelineItem = threadItemToTimeline(item, {
+        includeUserMessage: false,
+        cwd: options.cwd ?? null,
+    });
+    if (!timelineItem) {
+        return null;
+    }
+    const normalizedItemType = normalizeCodexThreadItemType(typeof item.type === "string" ? item.type : undefined);
+    const itemId = item.id;
+    if (timelineItem.type === "tool_call" && normalizedItemType === "commandExecution") {
+        const callId = timelineItem.callId || itemId;
+        if (callId && options.state.emittedExecCommandCompletedCallIds.has(callId)) {
+            return null;
+        }
+    }
+    if (itemId && options.state.emittedItemCompletedIds.has(itemId)) {
+        return null;
+    }
+    if (timelineItem.type === "assistant_message" && itemId) {
+        const buffered = options.state.pendingAgentMessages.get(itemId);
+        if (buffered && buffered.length > 0) {
+            timelineItem.text = buffered;
+        }
+    }
+    if (timelineItem.type === "assistant_message" && normalizedItemType === "plan" && itemId) {
+        const bufferedPlanText = options.state.pendingPlanTexts.get(itemId) ?? "";
+        const finalPlanText = typeof item.text === "string" ? item.text : "";
+        if (bufferedPlanText.length > 0) {
+            const trailingText = finalPlanText.startsWith(bufferedPlanText)
+                ? finalPlanText.slice(bufferedPlanText.length)
+                : "";
+            timelineItem.text = formatProposedPlanChunk(trailingText, {
+                close: true,
+            });
+        }
+        else if (finalPlanText.trim().length > 0) {
+            timelineItem.text = formatProposedPlanBlock(finalPlanText);
+        }
+    }
+    if (timelineItem.type === "reasoning" && itemId) {
+        const buffered = options.state.pendingReasoning.get(itemId);
+        if (buffered && buffered.length > 0) {
+            timelineItem.text = buffered.join("");
+        }
+    }
+    if (itemId) {
+        options.state.emittedItemCompletedIds.add(itemId);
+        options.state.pendingAgentMessages.delete(itemId);
+        options.state.pendingReasoning.delete(itemId);
+        options.state.pendingPlanTexts.delete(itemId);
+    }
+    return timelineItem;
+}
 function planStepsToTodoItems(steps) {
     return steps.map((entry) => ({
         text: entry.step,
@@ -1492,6 +1546,8 @@ export const __codexAppServerInternals = {
     shouldRetryInitializeWithoutExperimentalApi,
     shouldRetryTurnStartWithoutCollaborationMode,
     formatProposedPlanBlock,
+    formatProposedPlanChunk,
+    buildCompletedCodexTimelineItem,
     normalizeCodexQuestionDescriptors,
     parseUpdatedQuestionAnswers,
     buildCodexPermissionsResponse,
@@ -1536,6 +1592,7 @@ class CodexAppServerAgentSession {
         this.nativePlanModeSupported = null;
         this.pendingPlanTexts = new Map();
         this.cachedSkills = [];
+        this.turnCompletionInFlight = false;
         this.logger = logger.child({ module: "agent", provider: CODEX_PROVIDER });
         if (config.modeId === undefined) {
             throw new Error("Codex agent requires modeId to be specified");
@@ -2269,12 +2326,171 @@ class CodexAppServerAgentSession {
         return await codexAppServerTurnInputFromPrompt(blocks, this.logger);
     }
     emitEvent(event) {
-        if (event.type === "timeline") {
-            if (event.item.type === "assistant_message") {
-                this.pendingAgentMessages.clear();
+        this.eventQueue?.push(event);
+    }
+    clearTurnState() {
+        this.currentTurnId = null;
+        this.emittedItemStartedIds.clear();
+        this.emittedItemCompletedIds.clear();
+        this.emittedExecCommandStartedCallIds.clear();
+        this.emittedExecCommandCompletedCallIds.clear();
+        this.pendingAgentMessages.clear();
+        this.pendingReasoning.clear();
+        this.pendingCommandOutputDeltas.clear();
+        this.pendingFileChangeOutputDeltas.clear();
+        this.pendingPlanTexts.clear();
+        this.warnedIncompleteEditToolCallIds.clear();
+        this.turnCompletionInFlight = false;
+    }
+    hasPendingBufferedCompletionContent() {
+        return (this.pendingAgentMessages.size > 0 ||
+            this.pendingReasoning.size > 0 ||
+            this.pendingPlanTexts.size > 0);
+    }
+    emitCompletedThreadItem(item, source) {
+        const timelineItem = buildCompletedCodexTimelineItem(item, {
+            cwd: this.config.cwd ?? null,
+            state: {
+                pendingAgentMessages: this.pendingAgentMessages,
+                pendingReasoning: this.pendingReasoning,
+                pendingPlanTexts: this.pendingPlanTexts,
+                emittedExecCommandCompletedCallIds: this.emittedExecCommandCompletedCallIds,
+                emittedItemCompletedIds: this.emittedItemCompletedIds,
+            },
+        });
+        if (!timelineItem) {
+            return false;
+        }
+        const itemId = item.id;
+        if (timelineItem.type === "tool_call") {
+            this.warnOnIncompleteEditToolCall(timelineItem, source, item);
+        }
+        this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
+        if (itemId) {
+            this.emittedItemStartedIds.delete(itemId);
+            this.pendingCommandOutputDeltas.delete(itemId);
+            this.pendingFileChangeOutputDeltas.delete(itemId);
+        }
+        return true;
+    }
+    async reconcileTurnCompletionFromThreadRead() {
+        if (!this.client || !this.currentThreadId) {
+            return 0;
+        }
+        const response = (await this.client.request("thread/read", {
+            threadId: this.currentThreadId,
+            includeTurns: true,
+        }));
+        const turns = Array.isArray(response?.thread?.turns) ? response.thread.turns : [];
+        const lastTurn = turns[turns.length - 1];
+        const items = Array.isArray(lastTurn?.items) ? lastTurn.items : [];
+        let emitted = 0;
+        for (const item of items) {
+            if (this.emitCompletedThreadItem(item, "thread_read_completion")) {
+                emitted += 1;
+            }
+        }
+        return emitted;
+    }
+    flushPendingCompletionFallback() {
+        let emitted = 0;
+        for (const [itemId, chunks] of Array.from(this.pendingReasoning.entries())) {
+            const text = chunks.join("");
+            if (text.length === 0) {
+                this.pendingReasoning.delete(itemId);
+                continue;
             }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: { type: "reasoning", text },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingReasoning.delete(itemId);
+            emitted += 1;
+        }
+        for (const [itemId, text] of Array.from(this.pendingAgentMessages.entries())) {
+            if (text.length === 0) {
+                this.pendingAgentMessages.delete(itemId);
+                continue;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: { type: "assistant_message", text },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingAgentMessages.delete(itemId);
+            emitted += 1;
+        }
+        for (const [itemId, text] of Array.from(this.pendingPlanTexts.entries())) {
+            if (text.trim().length === 0) {
+                this.pendingPlanTexts.delete(itemId);
+                continue;
+            }
+            this.emitEvent({
+                type: "timeline",
+                provider: CODEX_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: formatProposedPlanChunk("", { close: true }),
+                },
+            });
+            this.emittedItemCompletedIds.add(itemId);
+            this.pendingPlanTexts.delete(itemId);
+            emitted += 1;
+        }
+        return emitted;
+    }
+    emitTerminalTurnEvent(parsed) {
+        if (parsed.status === "failed") {
+            this.emitEvent({
+                type: "turn_failed",
+                provider: CODEX_PROVIDER,
+                error: parsed.errorMessage ?? "Codex turn failed",
+            });
+            return;
+        }
+        if (parsed.status === "interrupted") {
+            this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
+            return;
+        }
+        this.emitEvent({ type: "turn_completed", provider: CODEX_PROVIDER, usage: this.latestUsage });
+    }
+    async finalizeTurnCompletion(parsed) {
+        let terminalEventEmitted = false;
+        try {
+            if (parsed.status === "completed" && this.hasPendingBufferedCompletionContent()) {
+                this.logger.trace({
+                    pendingAgentMessages: this.pendingAgentMessages.size,
+                    pendingReasoning: this.pendingReasoning.size,
+                    pendingPlanTexts: this.pendingPlanTexts.size,
+                    threadId: this.currentThreadId,
+                    turnId: this.currentTurnId,
+                }, "Codex turn completed with buffered items still pending; reconciling before closing stream");
+                try {
+                    const emitted = await this.reconcileTurnCompletionFromThreadRead();
+                    this.logger.trace({ emitted, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Reconciled Codex turn completion from thread/read");
+                }
+                catch (error) {
+                    this.logger.warn({ error, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Failed to reconcile Codex turn completion from thread/read");
+                }
+                const fallbackEmitted = this.flushPendingCompletionFallback();
+                if (fallbackEmitted > 0) {
+                    this.logger.warn({ fallbackEmitted, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Flushed buffered Codex completion items without canonical item/completed notifications");
+                }
+            }
+            this.emitTerminalTurnEvent(parsed);
+            terminalEventEmitted = true;
+        }
+        finally {
+            if (!terminalEventEmitted) {
+                this.logger.warn({ status: parsed.status, threadId: this.currentThreadId, turnId: this.currentTurnId }, "Codex turn completion exited before emitting a terminal event; emitting fallback terminal event");
+                this.emitTerminalTurnEvent(parsed);
+            }
+            this.clearTurnState();
+            this.eventQueue?.end();
         }
-        this.eventQueue?.push(event);
     }
     handleNotification(method, params) {
         const parsed = CodexNotificationSchema.parse({ method, params });
@@ -2284,40 +2500,17 @@ class CodexAppServerAgentSession {
             return;
         }
         if (parsed.kind === "turn_started") {
+            this.clearTurnState();
             this.currentTurnId = parsed.turnId;
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
             this.emitEvent({ type: "turn_started", provider: CODEX_PROVIDER });
             return;
         }
         if (parsed.kind === "turn_completed") {
-            if (parsed.status === "failed") {
-                this.emitEvent({
-                    type: "turn_failed",
-                    provider: CODEX_PROVIDER,
-                    error: parsed.errorMessage ?? "Codex turn failed",
-                });
-            }
-            else if (parsed.status === "interrupted") {
-                this.emitEvent({ type: "turn_canceled", provider: CODEX_PROVIDER, reason: "interrupted" });
+            if (this.turnCompletionInFlight) {
+                return;
             }
-            else {
-                this.emitEvent({ type: "turn_completed", provider: CODEX_PROVIDER, usage: this.latestUsage });
-            }
-            this.emittedItemStartedIds.clear();
-            this.emittedItemCompletedIds.clear();
-            this.emittedExecCommandStartedCallIds.clear();
-            this.emittedExecCommandCompletedCallIds.clear();
-            this.pendingCommandOutputDeltas.clear();
-            this.pendingFileChangeOutputDeltas.clear();
-            this.pendingPlanTexts.clear();
-            this.warnedIncompleteEditToolCallIds.clear();
-            this.eventQueue?.end();
+            this.turnCompletionInFlight = true;
+            void this.finalizeTurnCompletion(parsed);
             return;
         }
         if (parsed.kind === "plan_updated") {
@@ -2473,67 +2666,7 @@ class CodexAppServerAgentSession {
             if (parsed.source === "codex_event") {
                 return;
             }
-            const timelineItem = threadItemToTimeline(parsed.item, {
-                includeUserMessage: false,
-                cwd: this.config.cwd ?? null,
-            });
-            if (timelineItem) {
-                const normalizedItemType = normalizeCodexThreadItemType(typeof parsed.item.type === "string" ? parsed.item.type : undefined);
-                const itemId = parsed.item.id;
-                // For commandExecution items, codex/event/exec_command_* is authoritative.
-                // Keep item/completed as fallback only when no exec_command completion was seen.
-                if (timelineItem.type === "tool_call" &&
-                    normalizedItemType === "commandExecution") {
-                    const callId = timelineItem.callId || itemId;
-                    if (callId && this.emittedExecCommandCompletedCallIds.has(callId)) {
-                        return;
-                    }
-                }
-                if (itemId && this.emittedItemCompletedIds.has(itemId)) {
-                    return;
-                }
-                if (timelineItem.type === "assistant_message" && itemId) {
-                    const buffered = this.pendingAgentMessages.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered;
-                    }
-                }
-                if (timelineItem.type === "assistant_message" &&
-                    normalizedItemType === "plan" &&
-                    itemId) {
-                    const bufferedPlanText = this.pendingPlanTexts.get(itemId) ?? "";
-                    const finalPlanText = typeof parsed.item.text === "string" ? parsed.item.text : "";
-                    if (bufferedPlanText.length > 0) {
-                        const trailingText = finalPlanText.startsWith(bufferedPlanText)
-                            ? finalPlanText.slice(bufferedPlanText.length)
-                            : "";
-                        timelineItem.text = formatProposedPlanChunk(trailingText, {
-                            close: true,
-                        });
-                        this.pendingPlanTexts.delete(itemId);
-                    }
-                    else if (finalPlanText.trim().length > 0) {
-                        timelineItem.text = formatProposedPlanBlock(finalPlanText);
-                    }
-                }
-                if (timelineItem.type === "reasoning" && itemId) {
-                    const buffered = this.pendingReasoning.get(itemId);
-                    if (buffered && buffered.length > 0) {
-                        timelineItem.text = buffered.join("");
-                    }
-                }
-                if (timelineItem.type === "tool_call") {
-                    this.warnOnIncompleteEditToolCall(timelineItem, "item_completed", parsed.item);
-                }
-                this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
-                if (itemId) {
-                    this.emittedItemCompletedIds.add(itemId);
-                    this.emittedItemStartedIds.delete(itemId);
-                    this.pendingCommandOutputDeltas.delete(itemId);
-                    this.pendingFileChangeOutputDeltas.delete(itemId);
-                    this.pendingPlanTexts.delete(itemId);
-                }
-            }
+            this.emitCompletedThreadItem(parsed.item, "item_completed");
             return;
         }
         if (parsed.kind === "item_started") {