@jingyi0605/codingns 0.1.4 → 0.2.0

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

@@ -2,12 +2,51 @@ import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
+import { performance } from "node:perf_hooks";
 import { basename, dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import { DatabaseSync } from "node:sqlite";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { appendJsonLine, createRawRef, ensureDirectory, extractTextBlocks, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath } from "../providers/utils.js";
+import { appendJsonLine, createRawRef, ensureDirectory, extractTextBlocks, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, readJsonLines } from "../providers/utils.js";
+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() ?? "");
+function logCodexRuntimeStep(scope, startedAtMs, detail = {}) {
+    if (!CODEX_RUNTIME_DEBUG_ENABLED) {
+        return;
+    }
+    const durationMs = Math.round(performance.now() - startedAtMs);
+    const suffix = formatCodexRuntimeDebugDetail(detail);
+    console.info(`[perf][codex-runtime] ${scope} ${durationMs}ms${suffix ? ` ${suffix}` : ""}`);
+}
+function formatCodexRuntimeDebugDetail(detail) {
+    const entries = Object.entries(detail).filter(([, value]) => value !== undefined);
+    if (entries.length === 0) {
+        return "";
+    }
+    return entries
+        .map(([key, value]) => `${key}=${formatCodexRuntimeDebugValue(value)}`)
+        .join(" ");
+}
+function formatCodexRuntimeDebugValue(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? String(Math.round(value)) : String(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 export class CodexRuntimeAdapter {
     options;
     providerId = "codex";
@@ -16,24 +55,55 @@ export class CodexRuntimeAdapter {
     }
     async startSession(request, sink) {
         const launchedAtMs = Date.now();
+        const launchPerfStartedAtMs = performance.now();
         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 startedSession = await transport.startThread(request);
+        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 fallbackRawStoreRef = startedSession.rawStoreRef ??
-            request.rawStoreRef ??
-            buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
-        const resolvedBinding = await this.resolveExistingSessionBinding(providerSessionId, fallbackRawStoreRef, request.workspacePath);
-        const rawStoreRef = resolvedBinding?.rawStoreRef ?? fallbackRawStoreRef;
+        const syntheticRawStoreRef = buildRuntimeRawStoreRef(resolveRuntimeStoreKey(providerSessionId, request.sessionId));
+        const rawStoreRef = pickAvailableCodexRawStoreRef(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 = translateCodexAppServerNotification(notification);
             if (translated.turnId) {
                 eventQueue.setTurnId(translated.turnId);
@@ -65,7 +135,16 @@ export class CodexRuntimeAdapter {
             }
             eventQueue.close();
         });
+        const startTurnStartedAtMs = performance.now();
         await transport.startTurn(request, providerSessionId);
+        logCodexRuntimeStep("start_session.turn_start", startTurnStartedAtMs, {
+            sessionId: request.sessionId,
+            providerSessionId
+        });
+        logCodexRuntimeStep("start_session.ready", launchPerfStartedAtMs, {
+            sessionId: request.sessionId,
+            providerSessionId
+        });
         return {
             providerSessionId,
             rawStoreRef,
@@ -77,11 +156,30 @@ export class CodexRuntimeAdapter {
                 transport.close();
             },
             isAlive: () => transport.isClosed() === false,
-            completed: this.runTurn(null, request, sink, providerSessionId, rawStoreRef, abortController, eventQueue.iterator, [], launchedAtMs).finally(() => {
+            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);
+        if (history.length === 0) {
+            return null;
+        }
+        const resumeStartedAtMs = performance.now();
+        const resumed = await transport.resumeThreadFromHistory({
+            providerSessionId: null,
+            workspacePath: request.workspacePath,
+            history,
+            model: request.options.model
+        });
+        logCodexRuntimeStep("start_session.thread_resume_from_history", resumeStartedAtMs, {
+            sessionId: request.sessionId,
+            providerSessionId: resumed.providerSessionId,
+            messageCount: history.length
+        });
+        return resumed;
+    }
     async continueSession(request, sink) {
         const providerSessionId = resolveResumeThreadId(request.providerSessionId, request.rawStoreRef);
         if (!providerSessionId) {
@@ -90,19 +188,46 @@ 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();
-        const fallbackRawStoreRef = request.rawStoreRef ?? buildRuntimeRawStoreRef(providerSessionId);
-        const resolvedBinding = await this.resolveExistingSessionBinding(providerSessionId, fallbackRawStoreRef, request.workspacePath);
-        const resolvedSessionId = resolvedBinding?.providerSessionId ?? providerSessionId;
+        logCodexRuntimeStep("continue_session.initialize", initializeStartedAtMs, {
+            sessionId: request.sessionId,
+            providerSessionId
+        });
+        const syntheticRawStoreRef = buildRuntimeRawStoreRef(providerSessionId);
+        const resolvedSessionId = providerSessionId;
+        const resumeThreadStartedAtMs = performance.now();
         const resumed = await transport.resumeThread(request, resolvedSessionId);
-        const rawStoreRef = resolvedBinding?.rawStoreRef ?? resumed.rawStoreRef ?? fallbackRawStoreRef;
+        logCodexRuntimeStep("continue_session.thread_resume", resumeThreadStartedAtMs, {
+            sessionId: request.sessionId,
+            providerSessionId: resolvedSessionId
+        });
+        const rawStoreRef = pickAvailableCodexRawStoreRef([request.rawStoreRef, resumed.rawStoreRef], syntheticRawStoreRef);
         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, {
+                    sessionId: request.sessionId,
+                    providerSessionId: resolvedSessionId,
+                    method: ensureText(notification.method).trim() || null
+                });
+            }
             const translated = translateCodexAppServerNotification(notification);
             if (translated.turnId) {
                 eventQueue.setTurnId(translated.turnId);
@@ -134,7 +259,16 @@ export class CodexRuntimeAdapter {
             }
             eventQueue.close();
         });
+        const startTurnStartedAtMs = performance.now();
         await transport.startTurn(request, resolvedSessionId);
+        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,
@@ -151,7 +285,7 @@ export class CodexRuntimeAdapter {
             })
         };
     }
-    async runTurn(thread, request, sink, providerSessionId, rawStoreRef, abortController, preparedEvents, bufferedEvents = [], launchedAtMs = Date.now()) {
+    async runTurn(thread, request, sink, providerSessionId, rawStoreRef, abortController, preparedEvents, bufferedEvents = [], launchedAtMs = Date.now(), launchPerfStartedAtMs = performance.now()) {
         const context = {
             providerSessionId,
             rawStoreRef,
@@ -159,10 +293,13 @@ export class CodexRuntimeAdapter {
             // 否则前端会把新 assistant/tool 消息排到旧消息前面，表现成用户消息一直挂在底部。
             sequence: Math.max(0, request.sequenceBase ?? 0),
             toolNameByCallId: new Map(),
+            stableMessageRefByIdentity: new Map(),
+            lastSignatureByIdentity: new Map(),
             sink,
             workspacePath: request.workspacePath,
             firstUserMessage: request.options.content,
-            launchedAtMs
+            launchedAtMs,
+            launchPerfStartedAtMs
         };
         try {
             await this.refreshSessionBindingIfNeeded(context);
@@ -219,6 +356,13 @@ export class CodexRuntimeAdapter {
         if (eventType.length === 0) {
             return;
         }
+        if (context.lastSignatureByIdentity.size === 0 && eventType.startsWith("item.")) {
+            logCodexRuntimeStep("turn.first_item_event", context.launchPerfStartedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId: context.providerSessionId,
+                eventType
+            });
+        }
         if (eventType === "turn.completed") {
             await context.sink.emit({
                 type: "complete",
@@ -265,36 +409,30 @@ export class CodexRuntimeAdapter {
         if (itemType.length === 0) {
             return;
         }
-        if (itemType === "agent_message" && eventType === "item.completed") {
+        if (itemType === "agent_message" &&
+            (eventType === "item.updated" || eventType === "item.completed")) {
             const content = pickFirstNonEmpty(ensureText(readProp(item, "text")).trim(), extractTextBlocks(readProp(item, "content")).trim());
             if (content.length > 0) {
-                await context.sink.emit({
-                    type: "message",
-                    message: this.buildMessage(request, context, {
-                        role: "assistant",
-                        kind: "text",
-                        content
-                    }),
-                    providerSessionId: context.providerSessionId,
-                    rawStoreRef: context.rawStoreRef,
-                    timestamp: pickTimestamp(item, event)
+                await this.emitStableMessage(context, {
+                    identity: `assistant:text:${ensureText(readProp(item, "id")).trim() || "default"}`,
+                    timestamp: pickTimestamp(item, event),
+                    role: "assistant",
+                    kind: "text",
+                    content
                 });
             }
             return;
         }
-        if (itemType === "reasoning" && eventType === "item.completed") {
+        if (itemType === "reasoning" &&
+            (eventType === "item.updated" || eventType === "item.completed")) {
             const content = pickFirstNonEmpty(ensureText(readProp(item, "text")).trim(), extractTextBlocks(readProp(item, "summary")).trim(), extractTextBlocks(readProp(item, "content")).trim());
             if (content.length > 0) {
-                await context.sink.emit({
-                    type: "message",
-                    message: this.buildMessage(request, context, {
-                        role: "assistant",
-                        kind: "thinking",
-                        content
-                    }),
-                    providerSessionId: context.providerSessionId,
-                    rawStoreRef: context.rawStoreRef,
-                    timestamp: pickTimestamp(item, event)
+                await this.emitStableMessage(context, {
+                    identity: `assistant:thinking:${ensureText(readProp(item, "id")).trim() || "default"}`,
+                    timestamp: pickTimestamp(item, event),
+                    role: "assistant",
+                    kind: "thinking",
+                    content
                 });
             }
             return;
@@ -315,17 +453,37 @@ export class CodexRuntimeAdapter {
                 status: "running"
             };
             context.toolNameByCallId.set(callId, name);
-            await context.sink.emit({
-                type: "message",
-                message: this.buildMessage(request, context, {
-                    role: "tool",
-                    kind: "tool_call",
-                    content: input,
-                    toolCall
-                }),
-                providerSessionId: context.providerSessionId,
-                rawStoreRef: context.rawStoreRef,
-                timestamp: pickTimestamp(item, event)
+            await this.emitStableMessage(context, {
+                identity: `tool:call:${callId}`,
+                timestamp: pickTimestamp(item, event),
+                role: "tool",
+                kind: "tool_call",
+                content: input,
+                toolCall
+            });
+            return;
+        }
+        if (eventType === "item.updated") {
+            const output = pickFirstNonEmpty(extractTextBlocks(readProp(item, "result")).trim(), extractTextBlocks(readProp(item, "output")).trim(), extractTextBlocks(readProp(item, "aggregated_output")).trim(), extractTextBlocks(readProp(item, "error")).trim());
+            if (output.length === 0) {
+                return;
+            }
+            const knownName = context.toolNameByCallId.get(callId) ?? name;
+            context.toolNameByCallId.set(callId, knownName);
+            await this.emitStableMessage(context, {
+                identity: `tool:result:${callId}`,
+                timestamp: pickTimestamp(item, event),
+                role: "tool",
+                kind: "tool_result",
+                content: output,
+                toolCall: {
+                    callId,
+                    name: knownName,
+                    input: "",
+                    output,
+                    error: null,
+                    status: "running"
+                }
             });
             return;
         }
@@ -341,26 +499,44 @@ export class CodexRuntimeAdapter {
                 error: success ? null : output,
                 status: success ? "completed" : "failed"
             };
-            await context.sink.emit({
-                type: "message",
-                message: this.buildMessage(request, context, {
-                    role: "tool",
-                    kind: "tool_result",
-                    content: output,
-                    toolCall
-                }),
-                providerSessionId: context.providerSessionId,
-                rawStoreRef: context.rawStoreRef,
-                timestamp: pickTimestamp(item, event)
+            await this.emitStableMessage(context, {
+                identity: `tool:result:${callId}`,
+                timestamp: pickTimestamp(item, event),
+                role: "tool",
+                kind: "tool_result",
+                content: output,
+                toolCall
             });
         }
     }
+    async emitStableMessage(context, input) {
+        const message = this.buildMessage(context, {
+            role: input.role,
+            kind: input.kind,
+            content: input.content,
+            toolCall: input.toolCall ?? null,
+            stableIdentity: input.identity
+        });
+        const signature = buildCodexMessageSignature(message);
+        if (context.lastSignatureByIdentity.get(input.identity) === signature) {
+            return;
+        }
+        context.lastSignatureByIdentity.set(input.identity, signature);
+        await context.sink.emit({
+            type: "message",
+            message,
+            providerSessionId: context.providerSessionId,
+            rawStoreRef: context.rawStoreRef,
+            timestamp: input.timestamp,
+            rawEventRef: message.rawRef
+        });
+    }
     async refreshSessionBindingIfNeeded(context) {
         if (!isSyntheticRawStoreRef(context.rawStoreRef)) {
             return;
         }
-        const resolved = await this.resolveExistingSessionBinding(context.providerSessionId, context.rawStoreRef, context.workspacePath) ??
-            await this.resolveLaunchedSessionBinding(context.workspacePath, context.firstUserMessage, context.launchedAtMs);
+        const resolved = await this.resolveLaunchedSessionBinding(context.workspacePath, context.firstUserMessage, context.launchedAtMs) ??
+            await this.resolveExistingSessionBinding(context.providerSessionId, context.rawStoreRef, context.workspacePath);
         if (!resolved ||
             (resolved.providerSessionId === context.providerSessionId &&
                 resolved.rawStoreRef === context.rawStoreRef)) {
@@ -465,6 +641,7 @@ export class CodexRuntimeAdapter {
         if (!dbPath) {
             return null;
         }
+        const DatabaseSync = loadDatabaseSync();
         let db = null;
         try {
             db = new DatabaseSync(dbPath, { open: true, readOnly: true });
@@ -499,11 +676,14 @@ export class CodexRuntimeAdapter {
     getCodexHomeDir() {
         return this.options.homeDir?.trim() || process.env.CODINGNS_CODEX_HOME || join(homedir(), ".codex");
     }
-    buildMessage(request, context, input) {
-        context.sequence += 1;
-        const rawRef = createRawRef(this.providerId, context.rawStoreRef, context.sequence);
+    buildMessage(context, input) {
+        const stableRef = this.resolveStableMessageRef(context, input.stableIdentity ?? null);
+        const rawRef = stableRef?.rawRef ??
+            createRawRef(this.providerId, context.rawStoreRef, ++context.sequence);
+        const sequence = stableRef?.sequence ?? context.sequence;
+        const messageId = stableRef?.messageId ?? messageIdFromRawRef(rawRef);
         return {
-            messageId: messageIdFromRawRef(rawRef),
+            messageId,
             provider: this.providerId,
             providerSessionId: context.providerSessionId,
             role: input.role,
@@ -511,10 +691,28 @@ export class CodexRuntimeAdapter {
             content: input.content,
             toolCall: input.toolCall ?? null,
             timestamp: nextTimestamp(),
-            sequence: context.sequence,
+            sequence,
             rawRef
         };
     }
+    resolveStableMessageRef(context, stableIdentity) {
+        if (!stableIdentity) {
+            return null;
+        }
+        const existing = context.stableMessageRefByIdentity.get(stableIdentity);
+        if (existing) {
+            return existing;
+        }
+        context.sequence += 1;
+        const rawRef = createRawRef(this.providerId, context.rawStoreRef, context.sequence);
+        const created = {
+            sequence: context.sequence,
+            rawRef,
+            messageId: messageIdFromRawRef(rawRef)
+        };
+        context.stableMessageRefByIdentity.set(stableIdentity, created);
+        return created;
+    }
     async awaitThreadStarted(thread, events, workspacePath, firstUserMessage, launchedAtMs) {
         const bufferedEvents = [];
         while (true) {
@@ -658,6 +856,7 @@ function createCodexAppServerTransport(options) {
     });
     return {
         async initialize() {
+            const startedAtMs = performance.now();
             await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("initialize", () => ++requestSequence), {
                 method: "initialize",
                 params: {
@@ -673,8 +872,10 @@ function createCodexAppServerTransport(options) {
                 method: "initialized",
                 params: {}
             });
+            logCodexRuntimeStep("transport.initialize", startedAtMs);
         },
         async startThread(request) {
+            const startedAtMs = performance.now();
             const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("thread-start", () => ++requestSequence), {
                 method: "thread/start",
                 params: createThreadStartParams(request)
@@ -685,29 +886,64 @@ function createCodexAppServerTransport(options) {
                 throw new Error("CODEX_APP_SERVER_THREAD_ID_MISSING");
             }
             activeThreadId = providerSessionId;
+            logCodexRuntimeStep("transport.thread_start", startedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId
+            });
             return {
                 providerSessionId,
                 rawStoreRef: normalizeText(thread?.path) || null
             };
         },
         async resumeThread(request, providerSessionId) {
+            const startedAtMs = performance.now();
             const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("thread-resume", () => ++requestSequence), {
                 method: "thread/resume",
                 params: createThreadResumeParams(request, providerSessionId)
             });
             const thread = toRecord(result.thread);
             activeThreadId = ensureText(thread?.id).trim() || providerSessionId;
+            logCodexRuntimeStep("transport.thread_resume", startedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId: activeThreadId
+            });
             return {
                 providerSessionId: activeThreadId,
                 rawStoreRef: normalizeText(thread?.path) || null
             };
         },
+        async resumeThreadFromHistory(input) {
+            const startedAtMs = performance.now();
+            const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("thread-resume-history", () => ++requestSequence), {
+                method: "thread/resume",
+                params: createThreadResumeWithHistoryParams(input)
+            });
+            const thread = toRecord(result.thread);
+            const providerSessionId = ensureText(thread?.id).trim();
+            if (!providerSessionId) {
+                throw new Error("CODEX_APP_SERVER_THREAD_ID_MISSING");
+            }
+            activeThreadId = providerSessionId;
+            logCodexRuntimeStep("transport.thread_resume_from_history", startedAtMs, {
+                providerSessionId
+            });
+            return {
+                providerSessionId,
+                rawStoreRef: normalizeText(thread?.path) || null
+            };
+        },
         async startTurn(request, providerSessionId) {
+            const startedAtMs = performance.now();
             const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("turn-start", () => ++requestSequence), {
                 method: "turn/start",
                 params: createTurnStartParams(request, providerSessionId)
             });
             activeTurnId = ensureText(readProp(readProp(result, "turn"), "id")).trim() || activeTurnId;
+            logCodexRuntimeStep("transport.turn_start", startedAtMs, {
+                sessionId: request.sessionId,
+                providerSessionId,
+                turnId: activeTurnId
+            });
         },
         async interruptTurn() {
             if (!activeThreadId || !activeTurnId) {
@@ -849,7 +1085,27 @@ function translateCodexAppServerNotification(notification) {
             turnId: ensureText(turn?.id).trim() || null
         };
     }
-    if (method === "item/started" || method === "item/completed") {
+    if (method === "error") {
+        const error = toRecord(params.error);
+        const detail = buildCodexAppServerErrorDetail(error);
+        if (params.willRetry === true) {
+            return {
+                event: null,
+                terminal: false,
+                turnId: ensureText(params.turnId).trim() || null
+            };
+        }
+        return {
+            event: {
+                type: "turn.failed",
+                timestamp: nextTimestamp(),
+                error: detail
+            },
+            terminal: true,
+            turnId: ensureText(params.turnId).trim() || null
+        };
+    }
+    if (method === "item/started" || method === "item/updated" || method === "item/completed") {
         const item = translateCodexAppServerItem(toRecord(params.item));
         if (!item) {
             return {
@@ -860,7 +1116,11 @@ function translateCodexAppServerNotification(notification) {
         }
         return {
             event: {
-                type: method === "item/started" ? "item.started" : "item.completed",
+                type: method === "item/started"
+                    ? "item.started"
+                    : method === "item/updated"
+                        ? "item.updated"
+                        : "item.completed",
                 item,
                 timestamp: nextTimestamp()
             },
@@ -874,6 +1134,31 @@ function translateCodexAppServerNotification(notification) {
         turnId: null
     };
 }
+function buildCodexAppServerErrorDetail(error) {
+    const message = ensureText(error?.message).trim();
+    const additionalDetails = ensureText(error?.additionalDetails).trim();
+    if (message && additionalDetails && !message.includes(additionalDetails)) {
+        return `${message}\n${additionalDetails}`;
+    }
+    return message || additionalDetails || "codex app-server error";
+}
+function buildCodexMessageSignature(message) {
+    return JSON.stringify({
+        role: message.role,
+        kind: message.kind,
+        content: message.content,
+        toolCall: message.toolCall
+            ? {
+                callId: message.toolCall.callId,
+                name: message.toolCall.name,
+                input: message.toolCall.input,
+                output: message.toolCall.output,
+                error: message.toolCall.error,
+                status: message.toolCall.status
+            }
+            : null
+    });
+}
 function translateCodexAppServerItem(item) {
     if (!item) {
         return null;
@@ -886,15 +1171,15 @@ function translateCodexAppServerItem(item) {
         return {
             type: "agent_message",
             id: item.id,
-            text: item.text
+            text: ensureText(item.text).trim()
         };
     }
     if (itemType === "reasoning") {
         return {
             type: "reasoning",
             id: item.id,
-            text: Array.isArray(item.content) ? item.content.join("\n") : "",
-            summary: Array.isArray(item.summary) ? item.summary.join("\n") : ""
+            text: Array.isArray(item.content) ? item.content.join("\n") : ensureText(item.text).trim(),
+            summary: Array.isArray(item.summary) ? item.summary.join("\n") : ensureText(item.summary).trim()
         };
     }
     if (itemType === "commandExecution") {
@@ -999,6 +1284,20 @@ function createThreadResumeParams(request, providerSessionId) {
     }
     return params;
 }
+function createThreadResumeWithHistoryParams(input) {
+    const params = {
+        threadId: input.providerSessionId && input.providerSessionId.trim().length > 0
+            ? input.providerSessionId.trim()
+            : "__history_resume__",
+        cwd: input.workspacePath,
+        history: input.history,
+        approvalsReviewer: "user"
+    };
+    if (input.model) {
+        params.model = input.model;
+    }
+    return params;
+}
 function createTurnStartParams(request, providerSessionId) {
     const permissionOptions = createCodexThreadPermissionOptions(request.options.permissionMode ?? "default");
     const params = {
@@ -1116,6 +1415,18 @@ function resolveNodeModulesCandidate(currentDirectory, relativeSegments) {
 function buildRuntimeRawStoreRef(providerSessionId) {
     return resolve(process.cwd(), "runtime", "codex", `${providerSessionId}.stream`);
 }
+function pickAvailableCodexRawStoreRef(candidates, fallbackRawStoreRef) {
+    for (const candidate of candidates) {
+        const normalized = candidate?.trim();
+        if (!normalized) {
+            continue;
+        }
+        if (existsSync(normalized)) {
+            return normalized;
+        }
+    }
+    return fallbackRawStoreRef;
+}
 function resolveRuntimeStoreKey(providerSessionId, sessionId) {
     return providerSessionId.trim() || sessionId;
 }
@@ -1204,6 +1515,66 @@ function resolveResumeThreadId(providerSessionId, rawStoreRef) {
     }
     return null;
 }
+function buildSyntheticResumeHistory(rawStoreRef) {
+    const filePath = ensureText(rawStoreRef).trim();
+    if (!filePath || !existsSync(filePath)) {
+        return [];
+    }
+    const threadId = readThreadIdFromRawStore(filePath);
+    if (!threadId || looksLikeCodexThreadId(threadId)) {
+        return [];
+    }
+    const history = [];
+    for (const recordEntry of readJsonLines(filePath)) {
+        const record = toRecord(recordEntry.data) ?? {};
+        const recordType = ensureText(record.type).trim();
+        if (recordType === "event_msg") {
+            const payload = toRecord(record.payload) ?? {};
+            const eventType = ensureText(payload.type).trim();
+            const content = ensureText(payload.message).trim();
+            if (content.length === 0) {
+                continue;
+            }
+            if (eventType === "user_message") {
+                history.push(createResumeHistoryMessage("user", content));
+                continue;
+            }
+            if (eventType === "agent_message") {
+                history.push(createResumeHistoryMessage("assistant", content));
+            }
+            continue;
+        }
+        if (recordType !== "response_item") {
+            continue;
+        }
+        const payload = toRecord(record.payload) ?? {};
+        if (ensureText(payload.type).trim() !== "message") {
+            continue;
+        }
+        const role = ensureText(payload.role).trim();
+        if (role !== "user" && role !== "assistant") {
+            continue;
+        }
+        const content = extractTextBlocks(payload.content).trim();
+        if (content.length === 0) {
+            continue;
+        }
+        history.push(createResumeHistoryMessage(role, content));
+    }
+    return history;
+}
+function createResumeHistoryMessage(role, content) {
+    return {
+        type: "message",
+        role,
+        content: [
+            {
+                type: role === "user" ? "input_text" : "output_text",
+                text: content
+            }
+        ]
+    };
+}
 function readProp(value, key) {
     if (!value || typeof value !== "object") {
         return null;