@jingyi0605/codingns 0.5.1 → 0.6.0

package/node_modules/@codingns/session-sync-core/dist/runtime/codex-runtime.js

@@ -12,6 +12,7 @@ import { buildApplyPatchFromFileChangeList, extractApplyPatchTargetPathsFromTool
 import { loadDatabaseSync } from "../sqlite/node-sqlite.js";
 import { createCodexThreadPermissionOptions } from "./codex-permissions.js";
 const CODEX_RUNTIME_DEBUG_ENABLED = /^(1|true|yes)$/i.test(process.env.CODINGNS_PERF_DEBUG?.trim() ?? "");
+const CODEX_APP_SERVER_REQUEST_TIMEOUT_MS = 20_000;
 function logCodexRuntimeStep(scope, startedAtMs, detail = {}) {
     if (!CODEX_RUNTIME_DEBUG_ENABLED) {
         return;
@@ -61,123 +62,115 @@ export class CodexRuntimeAdapter {
         const transport = this.options.transportFactory
             ? this.options.transportFactory()
             : createCodexAppServerTransport(this.options);
-        const initializeStartedAtMs = performance.now();
-        await transport.initialize();
-        logCodexRuntimeStep("start_session.initialize", initializeStartedAtMs, {
-            sessionId: request.sessionId,
-            workspacePath: request.workspacePath
-        });
-        const abortController = new AbortController();
-        const eventQueue = createAsyncEventQueue();
-        const resumedSyntheticSession = await this.resumeSyntheticThreadFromHistory(transport, request);
-        const startedSession = resumedSyntheticSession ??
-            await (async () => {
-                const startThreadStartedAtMs = performance.now();
-                const started = await transport.startThread(request);
-                logCodexRuntimeStep("start_session.thread_start", startThreadStartedAtMs, {
-                    sessionId: request.sessionId,
-                    providerSessionId: started.providerSessionId
-                });
-                return started;
-            })();
-        const providerSessionId = startedSession.providerSessionId;
-        const syntheticRawStoreRef = buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
-        const rawStoreRef = pickAvailableCodexRawStoreRef(providerSessionId, resumedSyntheticSession
-            ? [resumedSyntheticSession.rawStoreRef]
-            : [startedSession.rawStoreRef, request.rawStoreRef], syntheticRawStoreRef);
-        logCodexRuntimeStep("start_session.raw_store_ref_ready", launchPerfStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId,
-            synthetic: isSyntheticRawStoreRef(rawStoreRef),
-            hasProviderRawStoreRef: Boolean(startedSession.rawStoreRef),
-            providerRawStoreRefExists: Boolean(startedSession.rawStoreRef && existsSync(startedSession.rawStoreRef))
-        });
-        sink.updateSessionBinding({
-            providerSessionId,
-            rawStoreRef
-        });
-        let firstNotificationLogged = false;
-        transport.setNotificationHandler(async (notification) => {
-            if (!firstNotificationLogged) {
-                firstNotificationLogged = true;
-                logCodexRuntimeStep("start_session.first_notification", launchPerfStartedAtMs, {
+        try {
+            const initializeStartedAtMs = performance.now();
+            await transport.initialize();
+            logCodexRuntimeStep("start_session.initialize", initializeStartedAtMs, {
+                sessionId: request.sessionId,
+                workspacePath: request.workspacePath
+            });
+            const abortController = new AbortController();
+            const eventQueue = createAsyncEventQueue();
+            const translateNotification = createCodexAppServerNotificationTranslator();
+            const forwardTranslatedNotification = createCodexTranslatedNotificationForwarder(eventQueue);
+            const resumedSyntheticSession = await this.resumeSyntheticThreadFromHistory(transport, request);
+            const startedSession = resumedSyntheticSession ??
+                await (async () => {
+                    const startThreadStartedAtMs = performance.now();
+                    const started = await transport.startThread(request);
+                    logCodexRuntimeStep("start_session.thread_start", startThreadStartedAtMs, {
+                        sessionId: request.sessionId,
+                        providerSessionId: started.providerSessionId
+                    });
+                    return started;
+                })();
+            const providerSessionId = startedSession.providerSessionId;
+            const syntheticRawStoreRef = buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
+            const rawStoreRef = pickAvailableCodexRawStoreRef(providerSessionId, resumedSyntheticSession
+                ? [resumedSyntheticSession.rawStoreRef]
+                : [startedSession.rawStoreRef, request.rawStoreRef], syntheticRawStoreRef);
+            logCodexRuntimeStep("start_session.raw_store_ref_ready", launchPerfStartedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId,
+                synthetic: isSyntheticRawStoreRef(rawStoreRef),
+                hasProviderRawStoreRef: Boolean(startedSession.rawStoreRef),
+                providerRawStoreRefExists: Boolean(startedSession.rawStoreRef && existsSync(startedSession.rawStoreRef))
+            });
+            sink.updateSessionBinding({
+                providerSessionId,
+                rawStoreRef
+            });
+            let firstNotificationLogged = false;
+            transport.setNotificationHandler(async (notification) => {
+                if (!firstNotificationLogged) {
+                    firstNotificationLogged = true;
+                    logCodexRuntimeStep("start_session.first_notification", launchPerfStartedAtMs, {
+                        sessionId: request.sessionId,
+                        providerSessionId,
+                        method: ensureText(notification.method).trim() || null
+                    });
+                }
+                const translated = translateNotification(notification);
+                forwardTranslatedNotification(translated);
+            });
+            transport.setServerRequestHandler(async (serverRequest) => {
+                if (!this.options.handleServerRequest) {
+                    throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+                }
+                return this.options.handleServerRequest({
                     sessionId: request.sessionId,
                     providerSessionId,
-                    method: ensureText(notification.method).trim() || null
+                    request: serverRequest
                 });
-            }
-            const translated = translateCodexAppServerNotification(notification);
-            if (translated.turnId) {
-                eventQueue.setTurnId(translated.turnId);
-            }
-            for (const event of translated.events) {
-                eventQueue.push(event);
-            }
-            if (translated.terminal) {
+            });
+            transport.setOnClose((error) => {
+                if (error) {
+                    eventQueue.push({
+                        type: "turn.failed",
+                        timestamp: nextTimestamp(),
+                        error: error.message
+                    });
+                }
                 eventQueue.close();
-            }
-        });
-        transport.setServerRequestHandler(async (serverRequest) => {
-            if (!this.options.handleServerRequest) {
-                throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
-            }
-            return this.options.handleServerRequest({
+            });
+            const startTurnStartedAtMs = performance.now();
+            const startTurnResult = await transport.startTurn(request, providerSessionId);
+            const startTurnNotification = startTurnResult?.notification ?? null;
+            if (startTurnNotification) {
+                const translated = translateNotification(startTurnNotification);
+                forwardTranslatedNotification(translated);
+            }
+            logCodexRuntimeStep("start_session.turn_start", startTurnStartedAtMs, {
                 sessionId: request.sessionId,
-                providerSessionId,
-                request: serverRequest
+                providerSessionId
             });
-        });
-        transport.setOnClose((error) => {
-            if (error) {
-                eventQueue.push({
-                    type: "turn.failed",
-                    timestamp: nextTimestamp(),
-                    error: error.message
-                });
-            }
-            eventQueue.close();
-        });
-        const startTurnStartedAtMs = performance.now();
-        const startTurnResult = await transport.startTurn(request, providerSessionId);
-        const startTurnNotification = startTurnResult?.notification ?? null;
-        if (startTurnNotification) {
-            const translated = translateCodexAppServerNotification(startTurnNotification);
-            if (translated.turnId) {
-                eventQueue.setTurnId(translated.turnId);
-            }
-            for (const event of translated.events) {
-                eventQueue.push(event);
-            }
-            if (translated.terminal) {
-                eventQueue.close();
-            }
+            logCodexRuntimeStep("start_session.ready", launchPerfStartedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId
+            });
+            return {
+                providerSessionId,
+                rawStoreRef,
+                submitDuringRun: async (options) => {
+                    await transport.steerTurn(options);
+                },
+                interrupt: async () => {
+                    abortController.abort();
+                    await transport.interruptTurn().catch(() => {
+                        return;
+                    });
+                    transport.close();
+                },
+                isAlive: () => transport.isClosed() === false,
+                completed: this.runTurn(null, request, sink, providerSessionId, rawStoreRef, abortController, eventQueue.iterator, [], launchedAtMs, launchPerfStartedAtMs).finally(() => {
+                    transport.close();
+                })
+            };
+        }
+        catch (error) {
+            transport.close();
+            throw error;
         }
-        logCodexRuntimeStep("start_session.turn_start", startTurnStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId
-        });
-        logCodexRuntimeStep("start_session.ready", launchPerfStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId
-        });
-        return {
-            providerSessionId,
-            rawStoreRef,
-            submitDuringRun: async (options) => {
-                await transport.steerTurn(options);
-            },
-            interrupt: async () => {
-                abortController.abort();
-                await transport.interruptTurn().catch(() => {
-                    return;
-                });
-                transport.close();
-            },
-            isAlive: () => transport.isClosed() === false,
-            completed: this.runTurn(null, request, sink, providerSessionId, rawStoreRef, abortController, eventQueue.iterator, [], launchedAtMs, launchPerfStartedAtMs).finally(() => {
-                transport.close();
-            })
-        };
     }
     async resumeSyntheticThreadFromHistory(transport, request) {
         const history = buildSyntheticResumeHistory(request.rawStoreRef);
@@ -206,152 +199,144 @@ export class CodexRuntimeAdapter {
         const transport = this.options.transportFactory
             ? this.options.transportFactory()
             : createCodexAppServerTransport(this.options);
-        const runtimeStartedAtMs = performance.now();
-        const initializeStartedAtMs = performance.now();
-        await transport.initialize();
-        logCodexRuntimeStep("continue_session.initialize", initializeStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId
-        });
-        const syntheticRawStoreRef = buildRuntimeRawStoreRef(providerSessionId);
-        let resolvedSessionId = providerSessionId;
-        let resolvedFallbackHistoryRawStoreRef = null;
-        const resumeThreadStartedAtMs = performance.now();
-        let resumed;
         try {
-            resumed = await transport.resumeThread(request, resolvedSessionId);
-            logCodexRuntimeStep("continue_session.thread_resume", resumeThreadStartedAtMs, {
+            const runtimeStartedAtMs = performance.now();
+            const initializeStartedAtMs = performance.now();
+            await transport.initialize();
+            logCodexRuntimeStep("continue_session.initialize", initializeStartedAtMs, {
                 sessionId: request.sessionId,
-                providerSessionId: resolvedSessionId,
-                fallback: false
-            });
-        }
-        catch (error) {
-            const fallbackHistorySource = await this.resolveContinueFallbackHistorySource({
-                providerSessionId,
-                rawStoreRef: request.rawStoreRef,
-                workspacePath: request.workspacePath
-            });
-            const resumeHistory = fallbackHistorySource?.history ?? [];
-            if (!shouldFallbackCodexContinueFromHistory(error, resumeHistory)) {
-                throw error;
-            }
-            resolvedFallbackHistoryRawStoreRef = fallbackHistorySource?.rawStoreRef ?? null;
-            const resumeFallbackStartedAtMs = performance.now();
-            resumed = await transport.resumeThreadFromHistory({
-                providerSessionId: null,
-                workspacePath: request.workspacePath,
-                history: resumeHistory,
-                model: request.options.model
-            });
-            resolvedSessionId = resumed.providerSessionId;
-            logCodexRuntimeStep("continue_session.thread_resume_from_history_fallback", resumeFallbackStartedAtMs, {
-                sessionId: request.sessionId,
-                requestedProviderSessionId: providerSessionId,
-                providerSessionId: resolvedSessionId,
-                historyLength: resumeHistory.length
+                providerSessionId
             });
-        }
-        const pickedRawStoreRef = pickAvailableCodexRawStoreRef(resolvedSessionId, [resolvedFallbackHistoryRawStoreRef, request.rawStoreRef, resumed.rawStoreRef], syntheticRawStoreRef);
-        const rawStoreRef = !resumed.rawStoreRef?.trim() && resolvedFallbackHistoryRawStoreRef
-            ? resolvedFallbackHistoryRawStoreRef
-            : pickedRawStoreRef;
-        const abortController = new AbortController();
-        const eventQueue = createAsyncEventQueue();
-        logCodexRuntimeStep("continue_session.raw_store_ref_ready", runtimeStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId: resolvedSessionId,
-            synthetic: isSyntheticRawStoreRef(rawStoreRef),
-            hasResumedRawStoreRef: Boolean(resumed.rawStoreRef),
-            hasRequestRawStoreRef: Boolean(request.rawStoreRef),
-            resumedRawStoreRefExists: Boolean(resumed.rawStoreRef && existsSync(resumed.rawStoreRef))
-        });
-        sink.updateSessionBinding({
-            providerSessionId: resolvedSessionId,
-            rawStoreRef
-        });
-        let firstNotificationLogged = false;
-        transport.setNotificationHandler(async (notification) => {
-            if (!firstNotificationLogged) {
-                firstNotificationLogged = true;
-                logCodexRuntimeStep("continue_session.first_notification", runtimeStartedAtMs, {
+            const syntheticRawStoreRef = buildRuntimeRawStoreRef(providerSessionId);
+            let resolvedSessionId = providerSessionId;
+            let resolvedFallbackHistoryRawStoreRef = null;
+            const resumeThreadStartedAtMs = performance.now();
+            let resumed;
+            try {
+                resumed = await transport.resumeThread(request, resolvedSessionId);
+                logCodexRuntimeStep("continue_session.thread_resume", resumeThreadStartedAtMs, {
                     sessionId: request.sessionId,
                     providerSessionId: resolvedSessionId,
-                    method: ensureText(notification.method).trim() || null
+                    fallback: false
                 });
             }
-            const translated = translateCodexAppServerNotification(notification);
-            if (translated.turnId) {
-                eventQueue.setTurnId(translated.turnId);
-            }
-            for (const event of translated.events) {
-                eventQueue.push(event);
-            }
-            if (translated.terminal) {
-                eventQueue.close();
-            }
-        });
-        transport.setServerRequestHandler(async (serverRequest) => {
-            if (!this.options.handleServerRequest) {
-                throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+            catch (error) {
+                const fallbackHistorySource = await this.resolveContinueFallbackHistorySource({
+                    providerSessionId,
+                    rawStoreRef: request.rawStoreRef,
+                    workspacePath: request.workspacePath
+                });
+                const resumeHistory = fallbackHistorySource?.history ?? [];
+                if (!shouldFallbackCodexContinueFromHistory(error, resumeHistory)) {
+                    throw error;
+                }
+                resolvedFallbackHistoryRawStoreRef = fallbackHistorySource?.rawStoreRef ?? null;
+                const resumeFallbackStartedAtMs = performance.now();
+                resumed = await transport.resumeThreadFromHistory({
+                    providerSessionId: null,
+                    workspacePath: request.workspacePath,
+                    history: resumeHistory,
+                    model: request.options.model
+                });
+                resolvedSessionId = resumed.providerSessionId;
+                logCodexRuntimeStep("continue_session.thread_resume_from_history_fallback", resumeFallbackStartedAtMs, {
+                    sessionId: request.sessionId,
+                    requestedProviderSessionId: providerSessionId,
+                    providerSessionId: resolvedSessionId,
+                    historyLength: resumeHistory.length
+                });
             }
-            return this.options.handleServerRequest({
+            const pickedRawStoreRef = pickAvailableCodexRawStoreRef(resolvedSessionId, [resolvedFallbackHistoryRawStoreRef, request.rawStoreRef, resumed.rawStoreRef], syntheticRawStoreRef);
+            const rawStoreRef = !resumed.rawStoreRef?.trim() && resolvedFallbackHistoryRawStoreRef
+                ? resolvedFallbackHistoryRawStoreRef
+                : pickedRawStoreRef;
+            const abortController = new AbortController();
+            const eventQueue = createAsyncEventQueue();
+            const translateNotification = createCodexAppServerNotificationTranslator();
+            const forwardTranslatedNotification = createCodexTranslatedNotificationForwarder(eventQueue);
+            logCodexRuntimeStep("continue_session.raw_store_ref_ready", runtimeStartedAtMs, {
                 sessionId: request.sessionId,
                 providerSessionId: resolvedSessionId,
-                request: serverRequest
+                synthetic: isSyntheticRawStoreRef(rawStoreRef),
+                hasResumedRawStoreRef: Boolean(resumed.rawStoreRef),
+                hasRequestRawStoreRef: Boolean(request.rawStoreRef),
+                resumedRawStoreRefExists: Boolean(resumed.rawStoreRef && existsSync(resumed.rawStoreRef))
             });
-        });
-        transport.setOnClose((error) => {
-            if (error) {
-                eventQueue.push({
-                    type: "turn.failed",
-                    timestamp: nextTimestamp(),
-                    error: error.message
+            sink.updateSessionBinding({
+                providerSessionId: resolvedSessionId,
+                rawStoreRef
+            });
+            let firstNotificationLogged = false;
+            transport.setNotificationHandler(async (notification) => {
+                if (!firstNotificationLogged) {
+                    firstNotificationLogged = true;
+                    logCodexRuntimeStep("continue_session.first_notification", runtimeStartedAtMs, {
+                        sessionId: request.sessionId,
+                        providerSessionId: resolvedSessionId,
+                        method: ensureText(notification.method).trim() || null
+                    });
+                }
+                const translated = translateNotification(notification);
+                forwardTranslatedNotification(translated);
+            });
+            transport.setServerRequestHandler(async (serverRequest) => {
+                if (!this.options.handleServerRequest) {
+                    throw new Error("CODEX_APP_SERVER_REQUEST_NOT_SUPPORTED");
+                }
+                return this.options.handleServerRequest({
+                    sessionId: request.sessionId,
+                    providerSessionId: resolvedSessionId,
+                    request: serverRequest
                 });
-            }
-            eventQueue.close();
-        });
-        const startTurnStartedAtMs = performance.now();
-        const startTurnResult = await transport.startTurn(request, resolvedSessionId);
-        const startTurnNotification = startTurnResult?.notification ?? null;
-        if (startTurnNotification) {
-            const translated = translateCodexAppServerNotification(startTurnNotification);
-            if (translated.turnId) {
-                eventQueue.setTurnId(translated.turnId);
-            }
-            for (const event of translated.events) {
-                eventQueue.push(event);
-            }
-            if (translated.terminal) {
+            });
+            transport.setOnClose((error) => {
+                if (error) {
+                    eventQueue.push({
+                        type: "turn.failed",
+                        timestamp: nextTimestamp(),
+                        error: error.message
+                    });
+                }
                 eventQueue.close();
-            }
+            });
+            const startTurnStartedAtMs = performance.now();
+            const startTurnResult = await transport.startTurn(request, resolvedSessionId);
+            const startTurnNotification = startTurnResult?.notification ?? null;
+            if (startTurnNotification) {
+                const translated = translateNotification(startTurnNotification);
+                forwardTranslatedNotification(translated);
+            }
+            logCodexRuntimeStep("continue_session.turn_start", startTurnStartedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId: resolvedSessionId
+            });
+            logCodexRuntimeStep("continue_session.ready", runtimeStartedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId: resolvedSessionId
+            });
+            return {
+                providerSessionId: resolvedSessionId,
+                rawStoreRef,
+                submitDuringRun: async (options) => {
+                    await transport.steerTurn(options);
+                },
+                interrupt: async () => {
+                    abortController.abort();
+                    await transport.interruptTurn().catch(() => {
+                        return;
+                    });
+                    transport.close();
+                },
+                isAlive: () => transport.isClosed() === false,
+                completed: this.runTurn(null, request, sink, resolvedSessionId, rawStoreRef, abortController, eventQueue.iterator, [], Date.now()).finally(() => {
+                    transport.close();
+                })
+            };
+        }
+        catch (error) {
+            transport.close();
+            throw error;
         }
-        logCodexRuntimeStep("continue_session.turn_start", startTurnStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId: resolvedSessionId
-        });
-        logCodexRuntimeStep("continue_session.ready", runtimeStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId: resolvedSessionId
-        });
-        return {
-            providerSessionId: resolvedSessionId,
-            rawStoreRef,
-            submitDuringRun: async (options) => {
-                await transport.steerTurn(options);
-            },
-            interrupt: async () => {
-                abortController.abort();
-                await transport.interruptTurn().catch(() => {
-                    return;
-                });
-                transport.close();
-            },
-            isAlive: () => transport.isClosed() === false,
-            completed: this.runTurn(null, request, sink, resolvedSessionId, rawStoreRef, abortController, eventQueue.iterator, [], Date.now()).finally(() => {
-                transport.close();
-            })
-        };
     }
     async resolveContinueFallbackHistorySource(input) {
         const candidates = [];
@@ -1188,110 +1173,357 @@ function createAsyncEventQueue() {
         }
     };
 }
-function translateCodexAppServerNotification(notification) {
-    const method = ensureText(notification.method).trim();
-    const params = toRecord(notification.params) ?? {};
-    if (method === "turn/started") {
-        return {
-            events: [],
-            terminal: false,
-            turnId: ensureText(readProp(readProp(params, "turn"), "id")).trim() || null
-        };
-    }
-    if (method === "turn/completed") {
-        const turn = toRecord(params.turn);
-        const status = ensureText(turn?.status).trim();
-        const itemEvents = translateCodexAppServerTurnItems(turn, "item.completed");
-        if (status === "failed") {
-            return {
-                events: [
-                    ...itemEvents,
-                    {
-                        type: "turn.failed",
-                        timestamp: nextTimestamp(),
-                        error: ensureText(readProp(turn?.error, "message")).trim() || "codex turn failed"
+function createCodexTranslatedNotificationForwarder(eventQueue) {
+    const seenReplayKeys = new Set();
+    return (translated) => {
+        if (translated.turnId) {
+            eventQueue.setTurnId(translated.turnId);
+        }
+        for (const event of translated.events) {
+            const replayKey = buildCodexTranslatedReplayKey(event);
+            if (replayKey) {
+                if (seenReplayKeys.has(replayKey)) {
+                    continue;
+                }
+                seenReplayKeys.add(replayKey);
+                while (seenReplayKeys.size > 1024) {
+                    const oldest = seenReplayKeys.keys().next().value;
+                    if (typeof oldest !== "string") {
+                        break;
                     }
-                ],
-                terminal: true,
-                turnId: ensureText(turn?.id).trim() || null
-            };
+                    seenReplayKeys.delete(oldest);
+                }
+            }
+            eventQueue.push(event);
+        }
+        if (translated.terminal) {
+            eventQueue.close();
+        }
+    };
+}
+function buildCodexTranslatedReplayKey(event) {
+    const eventType = ensureText(event.type).trim();
+    if (!eventType) {
+        return null;
+    }
+    if (eventType === "turn.completed" || eventType === "turn.failed" || eventType === "turn.interrupted") {
+        return `${eventType}:${ensureText(readProp(event, "turnId")).trim() || ""}`;
+    }
+    if (!eventType.startsWith("item.")) {
+        return null;
+    }
+    const item = toRecord(readProp(event, "item"));
+    if (!item) {
+        return null;
+    }
+    return JSON.stringify({
+        eventType,
+        itemType: ensureText(item.type).trim(),
+        id: ensureText(item.id).trim(),
+        status: ensureText(item.status).trim(),
+        text: ensureText(item.text).trim(),
+        summary: normalizeReplayKeyText(readProp(item, "summary")),
+        content: normalizeReplayKeyText(readProp(item, "content")),
+        command: normalizeReplayKeyText(readProp(item, "command")),
+        result: normalizeReplayKeyText(readProp(item, "result")),
+        output: normalizeReplayKeyText(readProp(item, "output")),
+        aggregatedOutput: normalizeReplayKeyText(readProp(item, "aggregated_output")),
+        error: normalizeReplayKeyText(readProp(item, "error"))
+    });
+}
+function normalizeReplayKeyText(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeReplayKeyText(entry)).join("\n");
+    }
+    if (value && typeof value === "object") {
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return ensureText(value).trim();
+}
+function createCodexAppServerNotificationTranslator() {
+    const agentMessageTextById = new Map();
+    const reasoningSummaryPartsById = new Map();
+    const reasoningContentPartsById = new Map();
+    const resetStreamState = () => {
+        agentMessageTextById.clear();
+        reasoningSummaryPartsById.clear();
+        reasoningContentPartsById.clear();
+    };
+    const ensureIndexedTextPart = (store, itemId, index) => {
+        if (!itemId || !Number.isInteger(index) || index < 0) {
+            return null;
         }
-        if (status === "interrupted") {
+        const existing = store.get(itemId) ?? [];
+        while (existing.length <= index) {
+            existing.push("");
+        }
+        store.set(itemId, existing);
+        return existing;
+    };
+    const buildReasoningSyntheticItem = (itemId) => {
+        // 这里必须复制一份快照，不能把可变数组引用直接塞进事件队列。
+        // 否则后续 delta 继续追加时，前一帧事件里的 summary/content 也会被同步改掉，
+        // 最终所有帧都会看起来像“最后一帧”，下游稳定消息去重就会把中间增量吃掉。
+        const summary = [...(reasoningSummaryPartsById.get(itemId) ?? [])];
+        const content = [...(reasoningContentPartsById.get(itemId) ?? [])];
+        return {
+            type: "reasoning",
+            id: itemId,
+            summary,
+            content
+        };
+    };
+    const translateAgentMessageDelta = (params) => {
+        const itemId = ensureText(params.itemId).trim();
+        const delta = ensureText(params.delta);
+        if (!itemId || delta.length === 0) {
             return {
-                events: [
-                    ...itemEvents,
-                    {
-                        type: "turn.interrupted",
-                        timestamp: nextTimestamp()
-                    }
-                ],
-                terminal: true,
-                turnId: ensureText(turn?.id).trim() || null
+                events: [],
+                terminal: false,
+                turnId: ensureText(params.turnId).trim() || null
             };
         }
+        const nextText = `${agentMessageTextById.get(itemId) ?? ""}${delta}`;
+        agentMessageTextById.set(itemId, nextText);
         return {
             events: [
-                ...itemEvents,
                 {
-                    type: "turn.completed",
+                    type: "item.updated",
+                    item: {
+                        type: "agent_message",
+                        id: itemId,
+                        text: nextText
+                    },
                     timestamp: nextTimestamp()
                 }
             ],
-            terminal: true,
-            turnId: ensureText(turn?.id).trim() || null
+            terminal: false,
+            turnId: ensureText(params.turnId).trim() || null
         };
-    }
-    if (method === "error") {
-        const error = toRecord(params.error);
-        const detail = buildCodexAppServerErrorDetail(error);
-        if (params.willRetry === true) {
+    };
+    const translateReasoningSummaryPartAdded = (params) => {
+        const itemId = ensureText(params.itemId).trim();
+        const summaryIndex = Math.trunc(Number(params.summaryIndex));
+        ensureIndexedTextPart(reasoningSummaryPartsById, itemId, summaryIndex);
+        return {
+            events: [],
+            terminal: false,
+            turnId: ensureText(params.turnId).trim() || null
+        };
+    };
+    const translateReasoningSummaryTextDelta = (params) => {
+        const itemId = ensureText(params.itemId).trim();
+        const summaryIndex = Math.trunc(Number(params.summaryIndex));
+        const delta = ensureText(params.delta);
+        const parts = ensureIndexedTextPart(reasoningSummaryPartsById, itemId, summaryIndex);
+        if (!parts || delta.length === 0) {
             return {
                 events: [],
                 terminal: false,
                 turnId: ensureText(params.turnId).trim() || null
             };
         }
+        parts[summaryIndex] = `${parts[summaryIndex] ?? ""}${delta}`;
         return {
             events: [
                 {
-                    type: "turn.failed",
-                    timestamp: nextTimestamp(),
-                    error: detail
+                    type: "item.updated",
+                    item: buildReasoningSyntheticItem(itemId),
+                    timestamp: nextTimestamp()
                 }
             ],
-            terminal: true,
+            terminal: false,
             turnId: ensureText(params.turnId).trim() || null
         };
-    }
-    if (method === "item/started" || method === "item/updated" || method === "item/completed") {
-        const item = translateCodexAppServerItem(toRecord(params.item));
-        if (!item) {
+    };
+    const translateReasoningTextDelta = (params) => {
+        const itemId = ensureText(params.itemId).trim();
+        const contentIndex = Math.trunc(Number(params.contentIndex));
+        const delta = ensureText(params.delta);
+        const parts = ensureIndexedTextPart(reasoningContentPartsById, itemId, contentIndex);
+        if (!parts || delta.length === 0) {
             return {
                 events: [],
                 terminal: false,
-                turnId: null
+                turnId: ensureText(params.turnId).trim() || null
             };
         }
+        parts[contentIndex] = `${parts[contentIndex] ?? ""}${delta}`;
         return {
             events: [
                 {
-                    type: method === "item/started"
-                        ? "item.started"
-                        : method === "item/updated"
-                            ? "item.updated"
-                            : "item.completed",
-                    item,
+                    type: "item.updated",
+                    item: buildReasoningSyntheticItem(itemId),
                     timestamp: nextTimestamp()
                 }
             ],
             terminal: false,
+            turnId: ensureText(params.turnId).trim() || null
+        };
+    };
+    return (notification) => {
+        const method = ensureText(notification.method).trim();
+        const params = toRecord(notification.params) ?? {};
+        if (method === "turn/started") {
+            return {
+                events: [],
+                terminal: false,
+                turnId: ensureText(readProp(readProp(params, "turn"), "id")).trim() || null
+            };
+        }
+        if (method === "turn/completed") {
+            const turn = toRecord(params.turn);
+            const status = ensureText(turn?.status).trim();
+            const itemEvents = translateCodexAppServerTurnItems(turn, "item.completed");
+            resetStreamState();
+            if (status === "failed") {
+                return {
+                    events: [
+                        ...itemEvents,
+                        {
+                            type: "turn.failed",
+                            timestamp: nextTimestamp(),
+                            error: ensureText(readProp(turn?.error, "message")).trim() || "codex turn failed"
+                        }
+                    ],
+                    terminal: true,
+                    turnId: ensureText(turn?.id).trim() || null
+                };
+            }
+            if (status === "interrupted") {
+                return {
+                    events: [
+                        ...itemEvents,
+                        {
+                            type: "turn.interrupted",
+                            timestamp: nextTimestamp()
+                        }
+                    ],
+                    terminal: true,
+                    turnId: ensureText(turn?.id).trim() || null
+                };
+            }
+            return {
+                events: [
+                    ...itemEvents,
+                    {
+                        type: "turn.completed",
+                        timestamp: nextTimestamp()
+                    }
+                ],
+                terminal: true,
+                turnId: ensureText(turn?.id).trim() || null
+            };
+        }
+        if (method === "error") {
+            const error = toRecord(params.error);
+            const detail = buildCodexAppServerErrorDetail(error);
+            if (params.willRetry === true) {
+                return {
+                    events: [],
+                    terminal: false,
+                    turnId: ensureText(params.turnId).trim() || null
+                };
+            }
+            resetStreamState();
+            return {
+                events: [
+                    {
+                        type: "turn.failed",
+                        timestamp: nextTimestamp(),
+                        error: detail
+                    }
+                ],
+                terminal: true,
+                turnId: ensureText(params.turnId).trim() || null
+            };
+        }
+        if (method === "item/agentMessage/delta") {
+            return translateAgentMessageDelta(params);
+        }
+        if (method === "item/reasoning/summaryPartAdded") {
+            return translateReasoningSummaryPartAdded(params);
+        }
+        if (method === "item/reasoning/summaryTextDelta") {
+            return translateReasoningSummaryTextDelta(params);
+        }
+        if (method === "item/reasoning/textDelta") {
+            return translateReasoningTextDelta(params);
+        }
+        if (method === "item/started" || method === "item/updated" || method === "item/completed") {
+            const item = translateCodexAppServerItem(toRecord(params.item));
+            if (!item) {
+                return {
+                    events: [],
+                    terminal: false,
+                    turnId: null
+                };
+            }
+            if (ensureText(item.type).trim() === "agent_message") {
+                const itemId = ensureText(item.id).trim();
+                const itemText = ensureText(item.text);
+                if (itemId) {
+                    if (itemText.length > 0) {
+                        agentMessageTextById.set(itemId, itemText);
+                    }
+                    else if (method === "item/completed") {
+                        agentMessageTextById.delete(itemId);
+                    }
+                }
+            }
+            if (ensureText(item.type).trim() === "reasoning") {
+                const itemId = ensureText(item.id).trim();
+                if (itemId) {
+                    const summary = Array.isArray(item.summary)
+                        ? item.summary.map((entry) => ensureText(entry))
+                        : ensureText(item.summary).trim()
+                            ? [ensureText(item.summary)]
+                            : [];
+                    const content = Array.isArray(item.content)
+                        ? item.content.map((entry) => ensureText(entry))
+                        : ensureText(item.text).trim()
+                            ? [ensureText(item.text)]
+                            : [];
+                    if (summary.length > 0) {
+                        reasoningSummaryPartsById.set(itemId, summary);
+                    }
+                    else if (method === "item/completed") {
+                        reasoningSummaryPartsById.delete(itemId);
+                    }
+                    if (content.length > 0) {
+                        reasoningContentPartsById.set(itemId, content);
+                    }
+                    else if (method === "item/completed") {
+                        reasoningContentPartsById.delete(itemId);
+                    }
+                }
+            }
+            return {
+                events: [
+                    {
+                        type: method === "item/started"
+                            ? "item.started"
+                            : method === "item/updated"
+                                ? "item.updated"
+                                : "item.completed",
+                        item,
+                        timestamp: nextTimestamp()
+                    }
+                ],
+                terminal: false,
+                turnId: null
+            };
+        }
+        return {
+            events: [],
+            terminal: false,
             turnId: null
         };
-    }
-    return {
-        events: [],
-        terminal: false,
-        turnId: null
     };
 }
 function translateCodexAppServerTurnItems(turn, eventType) {
@@ -1754,7 +1986,20 @@ function writeJsonRpcMessage(child, payload) {
 function sendJsonRpcRequest(child, pendingResponses, createRequestId, input) {
     const id = createRequestId();
     return new Promise((resolve, reject) => {
-        pendingResponses.set(id, { resolve, reject });
+        const timeout = setTimeout(() => {
+            pendingResponses.delete(id);
+            reject(new Error("SERVER_TIMEOUT"));
+        }, CODEX_APP_SERVER_REQUEST_TIMEOUT_MS);
+        pendingResponses.set(id, {
+            resolve: (value) => {
+                clearTimeout(timeout);
+                resolve(value);
+            },
+            reject: (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
         try {
             writeJsonRpcMessage(child, {
                 jsonrpc: "2.0",
@@ -1764,6 +2009,7 @@ function sendJsonRpcRequest(child, pendingResponses, createRequestId, input) {
             });
         }
         catch (error) {
+            clearTimeout(timeout);
             pendingResponses.delete(id);
             reject(error instanceof Error ? error : new Error("CODEX_APP_SERVER_REQUEST_WRITE_FAILED"));
         }
@@ -1801,7 +2047,7 @@ function shouldFallbackCodexContinueFromHistory(error, history) {
     if (history.length === 0) {
         return false;
     }
-    return isCodexThreadLoadError(error);
+    return isCodexThreadLoadError(error) || isCodexRequestTimeoutError(error);
 }
 function isCodexThreadLoadError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -1809,6 +2055,9 @@ function isCodexThreadLoadError(error) {
     return (normalized.includes("thread not loaded") ||
         normalized.includes("no rollout found for thread id"));
 }
+function isCodexRequestTimeoutError(error) {
+    return error instanceof Error && error.message === "SERVER_TIMEOUT";
+}
 function readProp(value, key) {
     if (!value || typeof value !== "object") {
         return null;