@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/{thread-resume-BkNpj9Pz.mjs → thread-resume-DIBXwOpE.mjs}

@@ -1,9 +1,9 @@
-import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, y as assertCodexThreadResumeResponse } from "./client-vXs2929Q.mjs";
-import { i as CodexAppServerRpcError } from "./timeout-DZF05XrR.mjs";
-import { r as publishCodexCatalogResume } from "./session-catalog-events-jMcYfQyd.mjs";
-import { t as CodexAppServerScopedRequestRejectedError } from "./request-BioXJLYa.mjs";
-import { F as forgetCodexWorkspaceReferences, rt as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-BpTtuLQ5.mjs";
-import { f as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-BpYKdTA0.mjs";
+import { r as publishCodexCatalogResume } from "./session-catalog-events-Bj6j94E_.mjs";
+import { o as CodexAppServerRpcError } from "./timeout-C910MdAB.mjs";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-D2L0zMrq.mjs";
+import { F as forgetCodexWorkspaceReferences, rt as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-DA4VR4Eb.mjs";
+import { b as assertCodexThreadResumeResponse, l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError } from "./client-Cs08OXVQ.mjs";
+import { i as assertCodexThreadResumeSubscription, p as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-CEv1cKwF.mjs";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/codex/src/app-server/thread-resume.ts
 /** Owns Codex thread/resume subscription safety. */

package/dist/.setup/{timeout-DZF05XrR.mjs → timeout-C910MdAB.mjs}

@@ -1,4 +1,4 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
 import { withTimeout } from "openclaw/plugin-sdk/time-runtime";
 //#region extensions/codex/src/app-server/rpc-error.ts
 const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
@@ -59,5 +59,22 @@ async function withAbortableTimeout(params) {
 		removeAbortListener?.();
 	}
 }
+async function waitForPromiseOrAbort(promise, signal) {
+	if (signal.aborted) return false;
+	let removeAbort;
+	try {
+		return await Promise.race([promise.then(() => true), new Promise((resolve) => {
+			const onAbort = () => resolve(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAbort = () => signal.removeEventListener("abort", onAbort);
+			if (signal.aborted) onAbort();
+		})]);
+	} finally {
+		removeAbort?.();
+	}
+}
+function abortReason(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "codex app-server thread route aborted"));
+}
 //#endregion
-export { isCodexThreadReadMissingError as a, CodexAppServerRpcError as i, withTimeout$1 as n, CODEX_APP_SERVER_OVERLOADED_ERROR_CODE as r, withAbortableTimeout as t };
+export { CODEX_APP_SERVER_OVERLOADED_ERROR_CODE as a, withTimeout$1 as i, waitForPromiseOrAbort as n, CodexAppServerRpcError as o, withAbortableTimeout as r, isCodexThreadReadMissingError as s, abortReason as t };

package/dist/.setup/{transcript-history-projection-DHNBDhCU.mjs → transcript-history-projection-ZZpkFkJ_.mjs}

@@ -1,5 +1,5 @@
 import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.mjs";
-import { c as itemName, l as itemStatus, t as auditNativeToolName } from "./event-projector-items-DyTQ_XqL.mjs";
+import { b as readCodexProviderRefusal, c as itemName, g as codexProviderRefusalDetails, l as itemStatus, t as auditNativeToolName } from "./event-projector-items-C6L_5ZiT.mjs";
 import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf8Prefix } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -26,6 +26,22 @@ const CODEX_HISTORY_ZERO_USAGE = {
 		total: 0
 	}
 };
+function projectCodexHistoryMessage(message, text) {
+	const phase = message.role === "assistant" && "phase" in message && (message.phase === "commentary" || message.phase === "final_answer") ? message.phase : void 0;
+	return {
+		message,
+		responseItem: {
+			type: "message",
+			role: message.role,
+			content: [{
+				type: message.role === "assistant" ? "output_text" : "input_text",
+				text
+			}],
+			...phase ? { phase } : {}
+		},
+		messageBytes: Buffer.byteLength(text, "utf8") + (message.role === "assistant" ? Buffer.byteLength(message.errorMessage ?? "", "utf8") + (message.diagnostics ? Buffer.byteLength(JSON.stringify(message.diagnostics), "utf8") : 0) : 0)
+	};
+}
 function normalizeImportedHistoryText(value) {
 	if (typeof value !== "string") return;
 	const text = value.trim();
@@ -71,55 +87,79 @@ function projectCodexThreadHistory(params) {
 	const projected = [];
 	const threadTimestamp = typeof params.thread.createdAt === "number" && Number.isFinite(params.thread.createdAt) ? params.thread.createdAt * 1e3 : params.importedAt;
 	let itemOffset = 0;
-	for (const turn of params.turns) for (const value of turn.items) {
-		const item = value;
-		const itemId = normalizeOptionalString(item.id);
-		const identity = `${turn.id}:${itemId ?? itemOffset}`;
-		const timestampSeconds = item.type === "agentMessage" ? turn.completedAt ?? turn.startedAt : turn.startedAt ?? turn.completedAt;
-		const timestamp = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 + itemOffset : threadTimestamp + itemOffset;
-		const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.type === "agentMessage" ? normalizeImportedHistoryText(item.text) : void 0;
-		const role = item.type === "userMessage" ? "user" : item.type === "agentMessage" ? "assistant" : void 0;
-		itemOffset += 1;
-		if (!text || !role) continue;
-		const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
-		const asyncDelivery = item.delivery === "async";
-		const questions = asyncDelivery ? readCodexAsyncQuestions(item.questions) : void 0;
-		const message = role === "assistant" ? attachCodexMirrorIdentity({
-			role,
-			content: [{
-				type: "text",
-				text
-			}],
-			api: CODEX_HISTORY_ASSISTANT_API,
-			provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
-			model: CODEX_HISTORY_ASSISTANT_MODEL,
-			usage: CODEX_HISTORY_ZERO_USAGE,
-			stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop",
-			...turn.status === "failed" && turn.error?.message ? { errorMessage: turn.error.message } : {},
-			...phase ? { phase } : {},
-			...asyncDelivery && itemId ? { openclawAsyncDelivery: {
-				itemId,
-				...questions ? { questions } : {}
-			} } : {},
-			timestamp
-		}, identity) : attachCodexMirrorIdentity({
-			role,
-			content: text,
-			timestamp
-		}, identity);
-		projected.push({
-			message,
-			responseItem: {
-				type: "message",
+	for (const turn of params.turns) {
+		const refusal = turn.status === "failed" ? readCodexProviderRefusal(turn.error?.message, turn.error?.codexErrorInfo, {
+			misalignment: turn.error?.misalignment,
+			nativeThreadId: params.thread.id,
+			nativeTurnId: turn.id
+		}) : void 0;
+		let hasAssistantMessage = false;
+		for (const value of turn.items) {
+			const item = value;
+			const itemId = normalizeOptionalString(item.id);
+			const identity = `${turn.id}:${itemId ?? itemOffset}`;
+			const timestampSeconds = item.type === "agentMessage" ? turn.completedAt ?? turn.startedAt : turn.startedAt ?? turn.completedAt;
+			const timestamp = typeof timestampSeconds === "number" && Number.isFinite(timestampSeconds) ? timestampSeconds * 1e3 + itemOffset : threadTimestamp + itemOffset;
+			const text = item.type === "userMessage" ? projectCodexUserItemText(item) : item.type === "agentMessage" ? normalizeImportedHistoryText(item.text) : void 0;
+			const role = item.type === "userMessage" ? "user" : item.type === "agentMessage" ? "assistant" : void 0;
+			itemOffset += 1;
+			if (!text || !role) continue;
+			const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
+			const asyncDelivery = item.delivery === "async";
+			const terminalAssistant = role === "assistant" && phase !== "commentary" && !asyncDelivery;
+			hasAssistantMessage ||= terminalAssistant;
+			const questions = asyncDelivery ? readCodexAsyncQuestions(item.questions) : void 0;
+			const message = role === "assistant" ? attachCodexMirrorIdentity({
 				role,
 				content: [{
-					type: role === "assistant" ? "output_text" : "input_text",
+					type: "text",
 					text
 				}],
-				...role === "assistant" && phase ? { phase } : {}
-			},
-			textBytes: Buffer.byteLength(text, "utf8")
-		});
+				api: CODEX_HISTORY_ASSISTANT_API,
+				provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
+				model: CODEX_HISTORY_ASSISTANT_MODEL,
+				usage: CODEX_HISTORY_ZERO_USAGE,
+				stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop",
+				...turn.status === "failed" && turn.error?.message ? { errorMessage: turn.error.message } : {},
+				...refusal && terminalAssistant ? { diagnostics: [{
+					type: "provider_refusal",
+					timestamp,
+					details: codexProviderRefusalDetails(refusal)
+				}] } : {},
+				...phase ? { phase } : {},
+				...asyncDelivery && itemId ? { openclawAsyncDelivery: {
+					itemId,
+					...questions ? { questions } : {}
+				} } : {},
+				timestamp
+			}, identity) : attachCodexMirrorIdentity({
+				role,
+				content: text,
+				timestamp
+			}, identity);
+			projected.push(projectCodexHistoryMessage(message, text));
+		}
+		if (params.includeErrorOnlyTurns && !hasAssistantMessage && turn.status === "failed" && turn.error?.message) {
+			const timestamp = (turn.completedAt ?? turn.startedAt ?? threadTimestamp / 1e3) * 1e3;
+			const text = normalizeImportedHistoryText(turn.error.message) ?? "Codex turn failed.";
+			const message = attachCodexMirrorIdentity({
+				role: "assistant",
+				content: [],
+				api: CODEX_HISTORY_ASSISTANT_API,
+				provider: normalizeOptionalString(params.modelProvider) ?? normalizeOptionalString(params.thread.modelProvider) ?? CODEX_HISTORY_ASSISTANT_PROVIDER,
+				model: CODEX_HISTORY_ASSISTANT_MODEL,
+				usage: CODEX_HISTORY_ZERO_USAGE,
+				stopReason: "error",
+				errorMessage: text,
+				...refusal ? { diagnostics: [{
+					type: "provider_refusal",
+					timestamp,
+					details: codexProviderRefusalDetails(refusal)
+				}] } : {},
+				timestamp
+			}, `${turn.id}:assistant`);
+			projected.push(projectCodexHistoryMessage(message, ""));
+		}
 	}
 	return projected;
 }
@@ -129,9 +169,9 @@ function selectBoundedCodexHistoryTail(projected) {
 	for (let index = projected.length - 1; index >= 0; index -= 1) {
 		const candidate = projected[index];
 		if (!candidate) continue;
-		if (selected.length >= CODEX_HISTORY_IMPORT_MAX_MESSAGES || selectedBytes + candidate.textBytes > CODEX_HISTORY_IMPORT_MAX_BYTES) break;
+		if (selected.length >= CODEX_HISTORY_IMPORT_MAX_MESSAGES || selectedBytes + candidate.messageBytes > CODEX_HISTORY_IMPORT_MAX_BYTES) break;
 		selected.push(candidate);
-		selectedBytes += candidate.textBytes;
+		selectedBytes += candidate.messageBytes;
 	}
 	return selected.toReversed();
 }
@@ -141,6 +181,7 @@ function projectBoundedCodexThreadHistory(params) {
 		thread: params.thread,
 		turns: selectTurnsThroughBoundary(params.thread, params.throughTurnId),
 		importedAt: params.importedAt,
+		includeErrorOnlyTurns: true,
 		...params.modelProvider ? { modelProvider: params.modelProvider } : {}
 	});
 	const selected = selectBoundedCodexHistoryTail(projected);
@@ -154,24 +195,13 @@ function projectBoundedCodexThreadHistory(params) {
 /** Projects only visible local user/assistant messages through the same bounded history policy. */
 function projectBoundedCodexVisibleSessionHistory(entries) {
 	const projected = [];
-	for (const entry of entries) {
-		if (entry.role !== "user" && entry.role !== "assistant" || !("content" in entry.message)) continue;
-		if (entry.role === "assistant" && ("stopReason" in entry.message && (entry.message.stopReason === "aborted" || entry.message.stopReason === "error") || "openclawAsyncDelivery" in entry.message)) continue;
-		const content = entry.message.content;
+	for (const { message } of entries) {
+		if (message.role !== "user" && message.role !== "assistant" || !("content" in message)) continue;
+		if (message.role === "assistant" && (message.stopReason === "aborted" || message.stopReason === "error" || "openclawAsyncDelivery" in message)) continue;
+		const content = message.content;
 		const text = normalizeImportedHistoryText(typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? [part.text] : []).join("\n") : void 0);
 		if (!text) continue;
-		projected.push({
-			message: entry.message,
-			responseItem: {
-				type: "message",
-				role: entry.role,
-				content: [{
-					type: entry.role === "assistant" ? "output_text" : "input_text",
-					text
-				}]
-			},
-			textBytes: Buffer.byteLength(text, "utf8")
-		});
+		projected.push(projectCodexHistoryMessage(message, text));
 	}
 	return selectBoundedCodexHistoryTail(projected).map(({ responseItem }) => responseItem);
 }