@openclaw/codex 2026.9.4 → 2026.9.6

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

@@ -1,8 +1,10 @@
-import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, y as assertCodexThreadResumeResponse } from "./client-B57KWPQx.js";
-import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
-import { t as CodexAppServerScopedRequestRejectedError } from "./request-B7hEkBGq.js";
-import { B as forgetCodexWorkspaceReferences, N as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
-import { d as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DKHzbwt5.js";
+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. */
 /** Resumes one thread, releasing or isolating every possible native subscription. */
@@ -46,6 +48,7 @@ async function resumeCodexAppServerThread(params) {
 		if (error instanceof CodexAppServerUnsafeSubscriptionError) throw error;
 		throw new CodexAppServerUnsafeSubscriptionError(error instanceof Error ? error.message : `Codex thread/resume outcome is indeterminate for ${threadId}`, { cause: error });
 	}
+	await publishCodexCatalogResume(params.client, response, sanitizeTerminalText);
 	return response;
 }
 //#endregion

package/dist/.setup/timeout-C910MdAB.mjs

@@ -0,0 +1,80 @@
+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;
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
+	}
+};
+function isCodexThreadReadMissingError(error, threadId) {
+	return error instanceof CodexAppServerRpcError && error.method === "thread/read" && error.code === -32600 && error.message === `thread not loaded: ${threadId}`;
+}
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+//#endregion
+//#region extensions/codex/src/app-server/timeout.ts
+/**
+* Thin Codex app-server timeout adapter around OpenClaw's shared timeout helper.
+*/
+function resolveAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
+}
+/** Awaits a promise with a Codex-specific timeout error message. */
+async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
+	return await withTimeout(promise, timeoutMs, {
+		message: timeoutMessage,
+		...createError ? { createError } : {}
+	});
+}
+/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
+async function withAbortableTimeout(params) {
+	const signal = params.signal;
+	if (signal?.aborted) throw resolveAbortError(signal);
+	let removeAbortListener;
+	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
+		const onAbort = () => reject(resolveAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+	})]) : params.promise;
+	try {
+		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
+	} finally {
+		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 { 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/{transcript-history-projection-v17wXgdK.js → .setup/transcript-history-projection-ZZpkFkJ_.mjs}

@@ -1,5 +1,6 @@
-import { c as itemName, l as itemStatus, t as auditNativeToolName } from "./event-projector-items-5VhsECCO.js";
-import { t as attachCodexMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { t as readCodexAsyncQuestions } from "./async-questions-DdhOCwGi.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";
 import { Buffer } from "node:buffer";
@@ -25,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();
@@ -70,51 +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 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 } } : {},
-			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;
 }
@@ -124,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();
 }
@@ -136,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);
@@ -149,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);
 }