@jingyi0605/codingns 0.3.6 → 0.5.0

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

@@ -6,7 +6,8 @@ import { performance } from "node:perf_hooks";
 import { basename, dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { appendJsonLine, createRawRef, ensureDirectory, extractTextBlocks, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, readJsonLines } from "../providers/utils.js";
+import { appendJsonLine, createRawRef, ensureDirectory, extractTextBlocks, messageIdFromStableKey, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath } from "../providers/utils.js";
+import { buildCodexResumeHistoryFromRawStore } from "../codex-resume-history.js";
 import { buildApplyPatchFromFileChangeList, extractApplyPatchTargetPathsFromToolOutput, normalizeApplyPatchText } from "../patch-builder.js";
 import { loadDatabaseSync } from "../sqlite/node-sqlite.js";
 import { createCodexThreadPermissionOptions } from "./codex-permissions.js";
@@ -162,6 +163,9 @@ export class CodexRuntimeAdapter {
         return {
             providerSessionId,
             rawStoreRef,
+            submitDuringRun: async (options) => {
+                await transport.steerTurn(options);
+            },
             interrupt: async () => {
                 abortController.abort();
                 await transport.interruptTurn().catch(() => {
@@ -210,14 +214,48 @@ export class CodexRuntimeAdapter {
             providerSessionId
         });
         const syntheticRawStoreRef = buildRuntimeRawStoreRef(providerSessionId);
-        const resolvedSessionId = providerSessionId;
+        let resolvedSessionId = providerSessionId;
+        let resolvedFallbackHistoryRawStoreRef = null;
         const resumeThreadStartedAtMs = performance.now();
-        const resumed = await transport.resumeThread(request, resolvedSessionId);
-        logCodexRuntimeStep("continue_session.thread_resume", resumeThreadStartedAtMs, {
-            sessionId: request.sessionId,
-            providerSessionId: resolvedSessionId
-        });
-        const rawStoreRef = pickAvailableCodexRawStoreRef(resolvedSessionId, [request.rawStoreRef, resumed.rawStoreRef], syntheticRawStoreRef);
+        let resumed;
+        try {
+            resumed = await transport.resumeThread(request, resolvedSessionId);
+            logCodexRuntimeStep("continue_session.thread_resume", resumeThreadStartedAtMs, {
+                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
+            });
+        }
+        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, {
@@ -299,6 +337,9 @@ export class CodexRuntimeAdapter {
         return {
             providerSessionId: resolvedSessionId,
             rawStoreRef,
+            submitDuringRun: async (options) => {
+                await transport.steerTurn(options);
+            },
             interrupt: async () => {
                 abortController.abort();
                 await transport.interruptTurn().catch(() => {
@@ -312,6 +353,41 @@ export class CodexRuntimeAdapter {
             })
         };
     }
+    async resolveContinueFallbackHistorySource(input) {
+        const candidates = [];
+        const seen = new Set();
+        const pushCandidate = (candidate) => {
+            const normalized = candidate?.trim();
+            if (!normalized || seen.has(normalized) || !existsSync(normalized)) {
+                return;
+            }
+            seen.add(normalized);
+            candidates.push(normalized);
+        };
+        pushCandidate(input.rawStoreRef);
+        // 旧会话的 binding 可能只剩 synthetic stream，或者已经指到了父线程 transcript。
+        // 继续会话失败时，额外按真实 thread id 扫一次本地 transcript，尽量把历史恢复链路救回来。
+        pushCandidate(await this.resolveRealRawStoreRef(input.providerSessionId.trim(), input.workspacePath));
+        let fallbackMatch = null;
+        for (const candidate of candidates) {
+            const history = buildCodexResumeHistoryFromRawStore(candidate);
+            if (history.length === 0) {
+                continue;
+            }
+            const meta = readSessionMeta(candidate);
+            if (meta?.threadId === input.providerSessionId.trim()) {
+                return {
+                    rawStoreRef: candidate,
+                    history
+                };
+            }
+            fallbackMatch ??= {
+                rawStoreRef: candidate,
+                history
+            };
+        }
+        return fallbackMatch;
+    }
     async runTurn(thread, request, sink, providerSessionId, rawStoreRef, abortController, preparedEvents, bufferedEvents = [], launchedAtMs = Date.now(), launchPerfStartedAtMs = performance.now()) {
         const context = {
             providerSessionId,
@@ -542,6 +618,7 @@ export class CodexRuntimeAdapter {
     }
     async emitStableMessage(context, input) {
         const message = this.buildMessage(context, {
+            timestamp: input.timestamp,
             role: input.role,
             kind: input.kind,
             content: input.content,
@@ -721,7 +798,7 @@ export class CodexRuntimeAdapter {
             kind: input.kind,
             content: input.content,
             toolCall: input.toolCall ?? null,
-            timestamp: nextTimestamp(),
+            timestamp: input.timestamp,
             sequence,
             rawRef
         };
@@ -739,7 +816,7 @@ export class CodexRuntimeAdapter {
         const created = {
             sequence: context.sequence,
             rawRef,
-            messageId: messageIdFromRawRef(rawRef)
+            messageId: messageIdFromStableKey(buildCodexStableMessageKey(context.providerSessionId, stableIdentity))
         };
         context.stableMessageRefByIdentity.set(stableIdentity, created);
         return created;
@@ -980,6 +1057,27 @@ function createCodexAppServerTransport(options) {
                 notification: buildCodexTurnCompletionNotification(turn, providerSessionId)
             };
         },
+        async steerTurn(options) {
+            if (!activeThreadId || !activeTurnId) {
+                throw new Error("SESSION_NOT_RUNNING");
+            }
+            try {
+                const result = await sendJsonRpcRequest(child, pendingResponses, () => nextJsonRpcId("turn-steer", () => ++requestSequence), {
+                    method: "turn/steer",
+                    params: createTurnSteerParams(activeThreadId, activeTurnId, options)
+                });
+                const turnId = ensureText(readProp(result, "turnId")).trim();
+                if (turnId) {
+                    activeTurnId = turnId;
+                }
+                return {
+                    turnId: turnId || activeTurnId
+                };
+            }
+            catch (error) {
+                throw normalizeCodexTurnSteerError(error);
+            }
+        },
         async interruptTurn() {
             if (!activeThreadId || !activeTurnId) {
                 return;
@@ -1425,6 +1523,13 @@ function createTurnStartParams(request, providerSessionId) {
     }
     return params;
 }
+function createTurnSteerParams(providerSessionId, activeTurnId, options) {
+    return {
+        threadId: providerSessionId,
+        expectedTurnId: activeTurnId,
+        input: createCodexAppServerInputFromOptions(options)
+    };
+}
 function normalizeCodexReasoningEffort(value) {
     const normalized = value?.trim().toLowerCase() ?? null;
     if (!normalized) {
@@ -1466,15 +1571,18 @@ function createCodexInput(request) {
     return input;
 }
 function createCodexAppServerInput(request) {
+    return createCodexAppServerInputFromOptions(request.options);
+}
+function createCodexAppServerInputFromOptions(options) {
     const input = [];
-    const promptText = (request.options.providerPrompt ?? request.options.content).trim();
+    const promptText = (options.providerPrompt ?? options.content).trim();
     if (promptText.length > 0) {
         input.push({
             type: "text",
             text: promptText
         });
     }
-    for (const attachment of request.options.attachments) {
+    for (const attachment of options.attachments) {
         if (attachment.kind !== "image") {
             continue;
         }
@@ -1485,6 +1593,23 @@ function createCodexAppServerInput(request) {
     }
     return input;
 }
+function normalizeCodexTurnSteerError(error) {
+    const detail = error instanceof Error ? error.message.trim() : String(error).trim();
+    const normalized = detail.toLowerCase();
+    if (normalized.includes("method not found")
+        || (normalized.includes("turn/steer") && normalized.includes("not found"))
+        || normalized.includes("unknown method")) {
+        return new Error("IN_RUN_INPUT_NOT_SUPPORTED");
+    }
+    if (normalized.includes("expectedturnid")
+        || normalized.includes("active turn")
+        || normalized.includes("turn mismatch")
+        || normalized.includes("no active turn")
+        || normalized.includes("not running")) {
+        return new Error("SESSION_NOT_RUNNING");
+    }
+    return error instanceof Error ? error : new Error(detail || "CODEX_TURN_STEER_FAILED");
+}
 async function loadCodexClient() {
     const moduleName = "@openai/codex-sdk";
     const runtimeImport = new Function("name", "return import(name);");
@@ -1670,56 +1795,19 @@ function buildSyntheticResumeHistory(rawStoreRef) {
     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 buildCodexResumeHistoryFromRawStore(filePath);
+}
+function shouldFallbackCodexContinueFromHistory(error, history) {
+    if (history.length === 0) {
+        return false;
     }
-    return history;
+    return isCodexThreadLoadError(error);
 }
-function createResumeHistoryMessage(role, content) {
-    return {
-        type: "message",
-        role,
-        content: [
-            {
-                type: role === "user" ? "input_text" : "output_text",
-                text: content
-            }
-        ]
-    };
+function isCodexThreadLoadError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = message.trim().toLowerCase();
+    return (normalized.includes("thread not loaded") ||
+        normalized.includes("no rollout found for thread id"));
 }
 function readProp(value, key) {
     if (!value || typeof value !== "object") {
@@ -2037,6 +2125,7 @@ function toSyntheticRuntimeRecord(event, providerSessionId) {
                 type: "event_msg",
                 payload: {
                     type: "agent_message",
+                    id: ensureText(readProp(item, "id")).trim() || undefined,
                     message: content
                 }
             }
@@ -2054,6 +2143,7 @@ function toSyntheticRuntimeRecord(event, providerSessionId) {
                 type: "event_msg",
                 payload: {
                     type: "agent_reasoning",
+                    id: ensureText(readProp(item, "id")).trim() || undefined,
                     text: content
                 }
             }
@@ -2106,6 +2196,9 @@ function mapToolStartItemType(itemType) {
 function mapToolResultItemType(itemType) {
     return itemType === "custom_tool_call" ? "custom_tool_call_output" : "function_call_output";
 }
+function buildCodexStableMessageKey(providerSessionId, stableIdentity) {
+    return `codex:${providerSessionId}:${stableIdentity}`;
+}
 function normalizeCodexItemStatus(value) {
     const normalized = ensureText(value).trim();
     if (!normalized) {