@openclaw/codex 2026.9.8 → 2026.10.1-beta.1

package/dist/.setup/{request-BZOfsSXW.mjs → request-BH3FvYUE.mjs}

@@ -1,9 +1,155 @@
-import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
-import { i as withTimeout, r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
-import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
+import { i as CodexAppServerScopedRequestRejectedError, r as CodexAppServerRpcError } from "./rpc-error-hmWM21RB.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-kQntafj_.mjs";
+import { i as withTimeout$1, r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BrdV95Fg.mjs";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
+import { areDiagnosticsEnabledForProcess } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
+//#region extensions/codex/src/app-server/request-diagnostics.ts
+const DIAGNOSTIC_METHODS = /* @__PURE__ */ new Set([
+	...Object.values(CODEX_CONTROL_METHODS),
+	"model/list",
+	"thread/start",
+	"plugin/installed",
+	"plugin/read",
+	"config/read",
+	"config/value/write",
+	"config/batchWrite",
+	"configRequirements/read",
+	"experimentalFeature/list"
+]);
+const MAX_METHODS = 8;
+function readInitializeSnapshot(read, beforeClose = false) {
+	try {
+		return read?.(beforeClose);
+	} catch {
+		return;
+	}
+}
+/** Counts awaited APIs, not native execution or proof that a request was written. */
+function createCodexRequestTimeoutDiagnostics(timeoutMs) {
+	if (!areDiagnosticsEnabledForProcess() || !embeddedAgentLog.isEnabled("warn")) return;
+	const startedAt = performance.now();
+	let attempt = createAttempt(0);
+	function createAttempt(ordinal) {
+		return {
+			ordinal,
+			phase: "prepare",
+			clientInstanceId: void 0,
+			acquireLastObservedBoundary: void 0,
+			acquireBoundaryBeforeCleanup: void 0,
+			acquireStartup: void 0,
+			lastStartedClientInstanceId: void 0,
+			lastStartedTransportIdentity: void 0,
+			initializeSnapshot: void 0,
+			initializeBeforeCleanup: void 0,
+			initializeBeforeCleanupSource: void 0,
+			started: 0,
+			pending: 0,
+			methods: /* @__PURE__ */ new Map()
+		};
+	}
+	return {
+		beginAttempt(ordinal) {
+			attempt = createAttempt(ordinal);
+			attempt.phase = "acquire-client";
+			const current = attempt;
+			return {
+				onAcquireObservation(observation) {
+					if (attempt !== current || current.phase !== "acquire-client") return;
+					if (observation.boundary === "cleanup") {
+						if (current.acquireLastObservedBoundary !== "cleanup") {
+							current.acquireBoundaryBeforeCleanup = current.acquireLastObservedBoundary;
+							const snapshot = readInitializeSnapshot(current.initializeSnapshot);
+							current.initializeBeforeCleanup = snapshot?.clientClosed ? readInitializeSnapshot(current.initializeSnapshot, true) : snapshot;
+							current.initializeBeforeCleanupSource = current.initializeBeforeCleanup ? snapshot?.clientClosed ? "before-client-close" : "at-cleanup" : void 0;
+						}
+					} else {
+						current.acquireBoundaryBeforeCleanup = void 0;
+						current.initializeBeforeCleanup = void 0;
+						current.initializeBeforeCleanupSource = void 0;
+					}
+					current.acquireLastObservedBoundary = observation.boundary;
+					if (observation.startup) current.acquireStartup = observation.startup;
+				},
+				onStartedClient(client) {
+					if (attempt !== current || current.phase !== "acquire-client") return;
+					current.lastStartedClientInstanceId = void 0;
+					current.lastStartedTransportIdentity = void 0;
+					current.initializeSnapshot = void 0;
+					current.initializeBeforeCleanup = void 0;
+					current.initializeBeforeCleanupSource = void 0;
+					try {
+						current.lastStartedClientInstanceId = client.getInstanceId();
+						current.initializeSnapshot = (beforeClose) => client.getInitializeDiagnostic(beforeClose);
+					} catch {}
+					try {
+						const identity = client.getRegisteredTransportIdentity();
+						current.lastStartedTransportIdentity = identity ? {
+							pid: identity.pid,
+							startedAt: identity.startedAt
+						} : void 0;
+					} catch {}
+				}
+			};
+		},
+		acquired(client) {
+			attempt.phase = "callback";
+			try {
+				attempt.clientInstanceId = client.getInstanceId();
+			} catch {}
+		},
+		request(method) {
+			const current = attempt;
+			const label = DIAGNOSTIC_METHODS.has(method) ? method : "other";
+			current.started++;
+			current.pending++;
+			current.methods.set(label, (current.methods.get(label) ?? 0) + 1);
+			return () => {
+				current.pending--;
+				const remaining = (current.methods.get(label) ?? 1) - 1;
+				if (remaining === 0) current.methods.delete(label);
+				else current.methods.set(label, remaining);
+			};
+		},
+		release() {
+			attempt.phase = "release-client";
+		},
+		timeout() {
+			try {
+				if (!areDiagnosticsEnabledForProcess() || !embeddedAgentLog.isEnabled("warn")) return;
+				const methods = [...attempt.methods].toSorted(([a], [b]) => a.localeCompare(b));
+				const initialize = readInitializeSnapshot(attempt.initializeSnapshot);
+				embeddedAgentLog.warn("codex app-server scope timed out", {
+					phase: attempt.phase === "callback" && attempt.pending > 0 ? "client-request" : attempt.phase,
+					timeoutMs,
+					elapsedMs: Math.round(performance.now() - startedAt),
+					scopeAttemptOrdinal: attempt.ordinal,
+					...attempt.acquireLastObservedBoundary ? { acquireLastObservedBoundary: attempt.acquireLastObservedBoundary } : {},
+					...attempt.acquireStartup ? { acquireStartup: attempt.acquireStartup } : {},
+					...attempt.acquireBoundaryBeforeCleanup ? { acquireBoundaryBeforeCleanup: attempt.acquireBoundaryBeforeCleanup } : {},
+					...attempt.lastStartedClientInstanceId ? {
+						lastStartedClientInstanceId: attempt.lastStartedClientInstanceId,
+						lastStartedTransportIdentity: attempt.lastStartedTransportIdentity ? JSON.stringify(attempt.lastStartedTransportIdentity) : "unavailable"
+					} : {},
+					...attempt.clientInstanceId ? { clientInstanceId: attempt.clientInstanceId } : {},
+					...initialize ? { initializeSnapshot: JSON.stringify(initialize) } : {},
+					...attempt.initializeBeforeCleanup ? {
+						initializeBeforeCleanup: JSON.stringify(attempt.initializeBeforeCleanup),
+						initializeBeforeCleanupSource: attempt.initializeBeforeCleanupSource
+					} : {},
+					requestStartedCount: attempt.started,
+					currentRequestCount: attempt.pending,
+					currentMethods: JSON.stringify(methods.slice(0, MAX_METHODS)),
+					omittedMethodCount: Math.max(0, methods.length - MAX_METHODS)
+				});
+			} catch {}
+		}
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
-	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
 	readCodexAppServerUsage: () => readCodexAppServerUsage,
 	requestCodexAppServerClientJson: () => requestCodexAppServerClientJson,
 	requestCodexAppServerJson: () => requestCodexAppServerJson,
@@ -29,7 +175,7 @@ async function requestCodexAppServerClientJson(params) {
 	let phase = "prepare";
 	observeControlPhase(params.controlObservation, phase);
 	try {
-		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-WqE8yPge.mjs").then((n) => n.r);
 		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 			method: params.method,
 			requestParams: params.requestParams,
@@ -45,12 +191,13 @@ async function requestCodexAppServerClientJson(params) {
 		const options = {
 			timeoutMs,
 			signal: params.signal,
-			...attemptWaiterFinished ? { attemptWaiterFinished } : {},
-			...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
+			withCurrent: params.withCurrent,
+			assertCurrent: params.assertCurrent,
+			...attemptWaiterFinished ? { attemptWaiterFinished } : {}
 		};
 		phase = "client-request";
 		observeControlPhase(params.controlObservation, phase);
-		return await withTimeout(params.client.request(method, requestParams, options), timeoutMs, `codex app-server ${params.method} timed out`);
+		return await withTimeout$1(params.client.request(method, requestParams, options), timeoutMs, `codex app-server ${params.method} timed out`);
 	} catch (error) {
 		observeControlFailure(params.controlObservation, phase, error);
 		throw error;
@@ -58,7 +205,7 @@ async function requestCodexAppServerClientJson(params) {
 }
 async function requestCodexAppServerJson(params) {
 	observeControlPhase(params.controlObservation, "prepare");
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-WqE8yPge.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -75,13 +222,6 @@ async function requestCodexAppServerJson(params) {
 		requestParams: params.requestParams
 	}));
 }
-/** A scoped guard rejected the request before a physical write. */
-var CodexAppServerScopedRequestRejectedError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "CodexAppServerScopedRequestRejectedError";
-	}
-};
 function createScopeCleanupError(message) {
 	const stackTraceLimit = Error.stackTraceLimit;
 	try {
@@ -136,16 +276,7 @@ async function readCodexAccountEmailBestEffort(request, deadline) {
 		method: "account/read",
 		requestParams: {}
 	}).then(({ account }) => account?.type === "chatgpt" ? account.email?.trim() || void 0 : void 0, () => void 0);
-	let timer;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(void 0), boundMs);
-		timer.unref?.();
-	});
-	try {
-		return await Promise.race([read, timeout]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
+	return await raceWithTimeout(read, boundMs, () => void 0, { ref: false });
 }
 /**
 * Runs several guarded requests over one acquired client (shared lease or
@@ -155,9 +286,14 @@ async function readCodexAccountEmailBestEffort(request, deadline) {
 async function withCodexAppServerJsonClient(params, run) {
 	const timeoutMs = params.timeoutMs ?? 6e4;
 	const timeoutMessage = params.timeoutMessage ?? "codex app-server request timed out";
+	const timeoutDiagnostics = createCodexRequestTimeoutDiagnostics(timeoutMs);
 	let activePhase = "prepare";
 	let errorPhase;
-	observeControlPhase(params.controlObservation, activePhase);
+	const setPhase = (phase) => {
+		activePhase = phase;
+		observeControlPhase(params.controlObservation, phase);
+	};
+	setPhase("prepare");
 	const timeoutController = new AbortController();
 	const abort = () => timeoutController.abort(params.signal?.reason);
 	params.signal?.addEventListener("abort", abort, { once: true });
@@ -179,14 +315,14 @@ async function withCodexAppServerJsonClient(params, run) {
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
-				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-CJCTeFpQ.mjs").then((n) => n.v);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-WqE8yPge.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DJJ3ljH2.mjs").then((n) => n.v);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
 					errorPhase = void 0;
-					activePhase = "prepare";
-					observeControlPhase(params.controlObservation, activePhase);
+					setPhase("prepare");
 					throwIfAbandoned();
 					const acquireClient = params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient;
+					const acquireObservation = timeoutDiagnostics?.beginAttempt(attempt + 1);
 					const acquireOptions = {
 						startOptions: params.startOptions,
 						pluginConfig: params.pluginConfig,
@@ -199,11 +335,12 @@ async function withCodexAppServerJsonClient(params, run) {
 						agentDir: params.agentDir,
 						config: params.config,
 						abandonSignal: timeoutController.signal,
-						assertCurrent: params.assertCurrent
+						assertCurrent: params.assertCurrent,
+						...acquireObservation
 					};
-					activePhase = "acquire-client";
-					observeControlPhase(params.controlObservation, activePhase);
+					setPhase("acquire-client");
 					const client = await acquireClient(acquireOptions);
+					timeoutDiagnostics?.acquired(client);
 					let scopeActive = true;
 					const assertCurrent = () => {
 						throwIfAbandoned();
@@ -211,12 +348,10 @@ async function withCodexAppServerJsonClient(params, run) {
 						assertRequestOwnerCurrent(params.assertCurrent);
 					};
 					try {
-						activePhase = "prepare";
-						observeControlPhase(params.controlObservation, activePhase);
+						setPhase("prepare");
 						assertCurrent();
 						const scopedRequest = async (request) => {
-							activePhase = "prepare";
-							observeControlPhase(params.controlObservation, activePhase);
+							setPhase("prepare");
 							const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 								method: request.method,
 								requestParams: request.requestParams,
@@ -243,9 +378,13 @@ async function withCodexAppServerJsonClient(params, run) {
 									request.assertCurrent?.();
 								}
 							};
-							activePhase = "client-request";
-							observeControlPhase(params.controlObservation, activePhase);
-							return await client.request(method, requestParams, requestOptions);
+							setPhase("client-request");
+							const settled = timeoutDiagnostics?.request(method);
+							try {
+								return await client.request(method, requestParams, requestOptions);
+							} finally {
+								settled?.();
+							}
 						};
 						return await run(scopedRequest, client, {
 							assertCurrent,
@@ -259,12 +398,10 @@ async function withCodexAppServerJsonClient(params, run) {
 						errorPhase = void 0;
 						try {
 							if (!params.isolated) {
-								activePhase = "release-client";
-								observeControlPhase(params.controlObservation, activePhase);
+								setPhase("release-client");
 								retireSharedCodexAppServerClientIfCurrent(client);
 							}
-							activePhase = "prepare";
-							observeControlPhase(params.controlObservation, activePhase);
+							setPhase("prepare");
 							throwIfAbandoned();
 						} catch (retryError) {
 							errorPhase = activePhase;
@@ -272,8 +409,8 @@ async function withCodexAppServerJsonClient(params, run) {
 						}
 					} finally {
 						scopeActive = false;
-						activePhase = "release-client";
-						observeControlPhase(params.controlObservation, activePhase);
+						setPhase("release-client");
+						timeoutDiagnostics?.release();
 						const requestErrorPhase = errorPhase;
 						errorPhase = activePhase;
 						if (params.isolated) await client.closeAndWait({
@@ -290,7 +427,10 @@ async function withCodexAppServerJsonClient(params, run) {
 	} catch (error) {
 		const deadlineObserved = isPastDeadline();
 		observeControlFailure(params.controlObservation, deadlineObserved ? activePhase : errorPhase ?? activePhase, error, deadlineObserved);
-		if (deadlineObserved) throw new Error(timeoutMessage, { cause: error });
+		if (deadlineObserved) {
+			timeoutDiagnostics?.timeout();
+			throw new Error(timeoutMessage, { cause: error });
+		}
 		throw error;
 	} finally {
 		params.signal?.removeEventListener("abort", abort);
@@ -298,4 +438,4 @@ async function withCodexAppServerJsonClient(params, run) {
 	}
 }
 //#endregion
-export { request_exports as a, requestCodexAppServerJson as i, readCodexAppServerUsage as n, withCodexAppServerJsonClient as o, requestCodexAppServerClientJson as r, CodexAppServerScopedRequestRejectedError as t };
+export { withCodexAppServerJsonClient as a, request_exports as i, requestCodexAppServerClientJson as n, requestCodexAppServerJson as r, readCodexAppServerUsage as t };

package/dist/.setup/rpc-error-hmWM21RB.mjs

@@ -0,0 +1,57 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { coerceErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+//#region extensions/codex/src/app-server/rpc-error.ts
+const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
+/** A scoped guard rejected the request before a physical write. */
+var CodexAppServerScopedRequestRejectedError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CodexAppServerScopedRequestRejectedError";
+	}
+};
+/** Only definite pre-write rejection permits recovering the original startup cause. */
+function codexPrewriteRejectionCause(error) {
+	return error instanceof CodexAppServerScopedRequestRejectedError && error.cause !== void 0 ? error.cause : error;
+}
+/** 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;
+}
+var CodexAppServerLocalRequestCancellationError = class extends Error {
+	constructor(method, reason, mayHaveWritten, cause) {
+		const detail = cause instanceof Error || typeof cause === "string" ? coerceErrorMessage(cause) : void 0;
+		super(`${method} ${reason}${detail ? `: ${detail}` : ""}`, { cause });
+		this.reason = reason;
+		this.mayHaveWritten = mayHaveWritten;
+		this.code = "CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED";
+		this.name = "CodexAppServerLocalRequestCancellationError";
+	}
+};
+/** Codex rejects this exact code before enqueueing, including mutating requests. */
+function isCodexAppServerOverloadError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === -32001;
+}
+//#endregion
+export { codexPrewriteRejectionCause as a, CodexAppServerScopedRequestRejectedError as i, CodexAppServerLocalRequestCancellationError as n, isCodexAppServerOverloadError as o, CodexAppServerRpcError as r, isCodexThreadReadMissingError as s, CODEX_APP_SERVER_OVERLOADED_ERROR_CODE as t };