@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{request-B7hEkBGq.js → .setup/request-D2L0zMrq.mjs}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as withTimeout, t as withAbortableTimeout } from "./timeout-BVw8aaM1.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as withTimeout, o as CodexAppServerRpcError, r as withAbortableTimeout } from "./timeout-C910MdAB.mjs";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -8,26 +8,56 @@ var request_exports = /* @__PURE__ */ __exportAll({
 	requestCodexAppServerJson: () => requestCodexAppServerJson,
 	withCodexAppServerJsonClient: () => withCodexAppServerJsonClient
 });
+function observeControlPhase(observation, phase) {
+	try {
+		observation?.phase(phase);
+	} catch {}
+}
+function observeControlFailure(observation, phase, error, deadlineObserved = false) {
+	if (!observation) return;
+	try {
+		const category = deadlineObserved ? "deadline-observed" : error instanceof CodexAppServerScopedRequestRejectedError ? "scoped-rejection" : error instanceof CodexAppServerRpcError ? error.code === -32601 ? "rpc-method-unavailable" : "rpc-error" : "other";
+		observation.failed({
+			phase,
+			category
+		});
+	} catch {}
+}
 /** Sends one guarded request over a client lease owned by the caller. */
 async function requestCodexAppServerClientJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
-	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-		method: params.method,
-		requestParams: params.requestParams,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId
-	});
-	if (sandboxBlock) throw new Error(sandboxBlock);
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	return await withTimeout(params.client.request(params.method, params.requestParams, {
-		timeoutMs,
-		signal: params.signal,
-		...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
-	}), timeoutMs, `codex app-server ${params.method} timed out`);
+	let phase = "prepare";
+	observeControlPhase(params.controlObservation, phase);
+	try {
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
+		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+			method: params.method,
+			requestParams: params.requestParams,
+			config: params.config,
+			sessionKey: params.sessionKey,
+			sessionId: params.sessionId
+		});
+		if (sandboxBlock) throw new Error(sandboxBlock);
+		const timeoutMs = params.timeoutMs ?? 6e4;
+		const method = params.method;
+		const requestParams = params.requestParams;
+		const attemptWaiterFinished = method === "thread/list" ? params.controlObservation?.attemptWaiterFinished : void 0;
+		const options = {
+			timeoutMs,
+			signal: params.signal,
+			...attemptWaiterFinished ? { attemptWaiterFinished } : {},
+			...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
+		};
+		phase = "client-request";
+		observeControlPhase(params.controlObservation, phase);
+		return await withTimeout(params.client.request(method, requestParams, options), timeoutMs, `codex app-server ${params.method} timed out`);
+	} catch (error) {
+		observeControlFailure(params.controlObservation, phase, error);
+		throw error;
+	}
 }
 async function requestCodexAppServerJson(params) {
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
+	observeControlPhase(params.controlObservation, "prepare");
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -51,6 +81,15 @@ var CodexAppServerScopedRequestRejectedError = class extends Error {
 		this.name = "CodexAppServerScopedRequestRejectedError";
 	}
 };
+function createScopeCleanupError(message) {
+	const stackTraceLimit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = 0;
+		return new CodexAppServerScopedRequestRejectedError(message);
+	} finally {
+		Error.stackTraceLimit = stackTraceLimit;
+	}
+}
 function assertRequestOwnerCurrent(assertCurrent) {
 	try {
 		assertCurrent?.();
@@ -66,14 +105,18 @@ const CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS = 4e3;
 const CODEX_USAGE_DEADLINE_RESERVE_MS = CODEX_USAGE_ISOLATED_SHUTDOWN.forceKillDelayMs + CODEX_USAGE_ISOLATED_SHUTDOWN.exitTimeoutMs + 250;
 /** Reads rate limits and best-effort account identity from one isolated app-server session. */
 async function readCodexAppServerUsage(options) {
-	const deadline = Date.now() + options.timeoutMs;
+	const deadline = performance.now() + options.timeoutMs;
 	return await withCodexAppServerJsonClient({
 		timeoutMs: options.timeoutMs,
+		signal: options.signal,
 		timeoutMessage: "codex app-server usage read timed out",
 		agentDir: options.agentDir,
 		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
 		config: options.config,
 		startOptions: options.startOptions,
+		preparedAuth: options.preparedAuth,
+		authRequirement: options.authRequirement,
+		assertCurrent: options.assertCurrent,
 		isolated: true,
 		isolatedShutdown: CODEX_USAGE_ISOLATED_SHUTDOWN
 	}, async (request) => {
@@ -85,20 +128,13 @@ async function readCodexAppServerUsage(options) {
 		};
 	});
 }
-function extractCodexAccountEmail(value) {
-	if (!value || typeof value !== "object") return;
-	const record = value;
-	const account = record.account && typeof record.account === "object" ? record.account : record;
-	const email = account.email ?? account.accountEmail;
-	return typeof email === "string" && email.trim() ? email.trim() : void 0;
-}
 async function readCodexAccountEmailBestEffort(request, deadline) {
-	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - Date.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
+	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - performance.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
 	if (boundMs <= 0) return;
 	const read = request({
 		method: "account/read",
 		requestParams: {}
-	}).then((account) => extractCodexAccountEmail(account), () => void 0);
+	}).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);
@@ -118,28 +154,39 @@ 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";
+	let activePhase = "prepare";
+	let errorPhase;
+	observeControlPhase(params.controlObservation, activePhase);
 	const timeoutController = new AbortController();
-	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
-	const isPastDeadline = () => deadline !== void 0 && Date.now() >= deadline;
+	const abort = () => timeoutController.abort(params.signal?.reason);
+	params.signal?.addEventListener("abort", abort, { once: true });
+	if (params.signal?.aborted) abort();
+	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? performance.now() + timeoutMs : void 0;
+	const isPastDeadline = () => deadline !== void 0 && performance.now() >= deadline;
 	const throwIfAbandoned = () => {
 		if (timeoutController.signal.aborted && timeoutController.signal.reason instanceof Error) throw timeoutController.signal.reason;
 		if (timeoutController.signal.aborted || isPastDeadline()) throw new CodexAppServerScopedRequestRejectedError(timeoutMessage);
 	};
 	const remainingTimeoutMs = () => {
 		throwIfAbandoned();
-		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
+		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - performance.now());
 	};
 	try {
+		throwIfAbandoned();
 		return await withAbortableTimeout({
 			signal: timeoutController.signal,
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BxgyoM8M.js").then((n) => n.r);
-				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-CscigXXL.js").then((n) => n.y);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-C2sRMOEY.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DA4VR4Eb.mjs").then((n) => n.y);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
+					errorPhase = void 0;
+					activePhase = "prepare";
+					observeControlPhase(params.controlObservation, activePhase);
 					throwIfAbandoned();
-					const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
+					const acquireClient = params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient;
+					const acquireOptions = {
 						startOptions: params.startOptions,
 						pluginConfig: params.pluginConfig,
 						timeoutMs: remainingTimeoutMs(),
@@ -150,8 +197,12 @@ async function withCodexAppServerJsonClient(params, run) {
 						authRequirement: params.authRequirement,
 						agentDir: params.agentDir,
 						config: params.config,
-						abandonSignal: timeoutController.signal
-					});
+						abandonSignal: timeoutController.signal,
+						assertCurrent: params.assertCurrent
+					};
+					activePhase = "acquire-client";
+					observeControlPhase(params.controlObservation, activePhase);
+					const client = await acquireClient(acquireOptions);
 					let scopeActive = true;
 					const assertCurrent = () => {
 						throwIfAbandoned();
@@ -159,8 +210,12 @@ async function withCodexAppServerJsonClient(params, run) {
 						assertRequestOwnerCurrent(params.assertCurrent);
 					};
 					try {
+						activePhase = "prepare";
+						observeControlPhase(params.controlObservation, activePhase);
 						assertCurrent();
 						const scopedRequest = async (request) => {
+							activePhase = "prepare";
+							observeControlPhase(params.controlObservation, activePhase);
 							const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 								method: request.method,
 								requestParams: request.requestParams,
@@ -170,14 +225,26 @@ async function withCodexAppServerJsonClient(params, run) {
 							});
 							if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
 							assertCurrent();
-							return await client.request(request.method, request.requestParams, {
+							const method = request.method;
+							const requestParams = request.requestParams;
+							const attemptWaiterFinished = method === "thread/list" ? params.controlObservation?.attemptWaiterFinished : void 0;
+							const requestOptions = {
 								timeoutMs: remainingTimeoutMs(),
 								signal: timeoutController.signal,
+								...attemptWaiterFinished ? { attemptWaiterFinished } : {},
+								...params.catalogPreview ? {
+									catalogPreview: true,
+									catalogPreviewCache: params.catalogPreviewCache,
+									catalogRows: params.catalogRows
+								} : {},
 								assertCurrent: () => {
 									assertCurrent();
 									request.assertCurrent?.();
 								}
-							});
+							};
+							activePhase = "client-request";
+							observeControlPhase(params.controlObservation, activePhase);
+							return await client.request(method, requestParams, requestOptions);
 						};
 						return await run(scopedRequest, client, {
 							assertCurrent,
@@ -186,26 +253,47 @@ async function withCodexAppServerJsonClient(params, run) {
 							}
 						});
 					} catch (error) {
+						errorPhase = activePhase;
 						if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-						if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
-						throwIfAbandoned();
+						errorPhase = void 0;
+						try {
+							if (!params.isolated) {
+								activePhase = "release-client";
+								observeControlPhase(params.controlObservation, activePhase);
+								retireSharedCodexAppServerClientIfCurrent(client);
+							}
+							activePhase = "prepare";
+							observeControlPhase(params.controlObservation, activePhase);
+							throwIfAbandoned();
+						} catch (retryError) {
+							errorPhase = activePhase;
+							throw retryError;
+						}
 					} finally {
 						scopeActive = false;
+						activePhase = "release-client";
+						observeControlPhase(params.controlObservation, activePhase);
+						const requestErrorPhase = errorPhase;
+						errorPhase = activePhase;
 						if (params.isolated) await client.closeAndWait({
 							exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
 							forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
 						});
 						else releaseLeasedSharedCodexAppServerClient(client);
+						errorPhase = requestErrorPhase;
 					}
 				}
 				throw new Error("Codex app-server selection retry loop exited unexpectedly");
 			})()
 		});
 	} catch (error) {
-		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
+		const deadlineObserved = isPastDeadline();
+		observeControlFailure(params.controlObservation, deadlineObserved ? activePhase : errorPhase ?? activePhase, error, deadlineObserved);
+		if (deadlineObserved) throw new Error(timeoutMessage, { cause: error });
 		throw error;
 	} finally {
-		timeoutController.abort(new CodexAppServerScopedRequestRejectedError(timeoutMessage));
+		params.signal?.removeEventListener("abort", abort);
+		timeoutController.abort(createScopeCleanupError(timeoutMessage));
 	}
 }
 //#endregion