@openclaw/codex 2026.9.3 → 2026.9.5

package/dist/{rate-limits-Bqnx1N4z.js → .setup/rate-limits-DOEGYRNs.mjs}

@@ -1,5 +1,6 @@
-import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
-import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { z } from "zod";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
@@ -19,6 +20,49 @@ const WEEKLY_WINDOW_MINUTES = 7 * DAY_WINDOW_MINUTES;
 const WEEKLY_RESET_GAP_MS = 3 * ONE_DAY_MS;
 const CODEX_USAGE_LIMIT_MESSAGE_PREFIX = "You've reached your Codex subscription usage limit.";
 const CODEX_USAGE_LIMIT_STATE_MISMATCH_MESSAGE = "Codex rejected the request with a usage-limit error, but its current account usage does not report an exhausted limit.";
+const optionalNumber = z.number().optional().catch(void 0);
+const optionalBoolean = z.boolean().optional().catch(void 0);
+const rateLimitWindowSchema = z.object({
+	usedPercent: optionalNumber,
+	used_percent: optionalNumber,
+	resetsAt: optionalNumber,
+	resets_at: optionalNumber,
+	windowDurationMins: optionalNumber,
+	window_duration_mins: optionalNumber,
+	windowMinutes: optionalNumber,
+	window_minutes: optionalNumber
+}).transform((window) => {
+	const resetsAt = window.resetsAt ?? window.resets_at;
+	return {
+		usedPercent: window.usedPercent ?? window.used_percent,
+		resetsAt,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		windowDurationMins: window.windowDurationMins ?? window.window_duration_mins ?? window.windowMinutes ?? window.window_minutes
+	};
+}).optional().catch(void 0);
+const creditsSchema = z.object({
+	hasCredits: optionalBoolean,
+	has_credits: optionalBoolean,
+	unlimited: optionalBoolean,
+	balance: z.preprocess(parseStrictFiniteNumber, optionalNumber)
+}).transform((credits) => ({
+	hasCredits: credits.hasCredits ?? credits.has_credits,
+	unlimited: credits.unlimited,
+	balance: credits.balance
+})).optional().catch(void 0);
+const rateLimitSnapshotSchema = z.looseObject({
+	primary: rateLimitWindowSchema,
+	secondary: rateLimitWindowSchema,
+	credits: creditsSchema
+}).transform((snapshot) => ({
+	primary: snapshot.primary,
+	secondary: snapshot.secondary,
+	credits: snapshot.credits,
+	limitId: normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id),
+	limitName: normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name),
+	planType: normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type),
+	rateLimitReachedType: normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)
+}));
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeOptionalString(params.message);
@@ -98,16 +142,39 @@ function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	};
 }
 /** Converts Codex app-server rate-limit payloads into OpenAI/Codex usage windows. */
-function buildCodexAppServerUsageSnapshot(value) {
-	const snapshot = selectCodexProviderUsageSnapshot(value);
+function buildCodexAppServerUsageSnapshot(value, options = {}) {
+	const snapshots = collectCodexRateLimitSnapshots(value);
+	const snapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const entries = snapshot ? readWindowEntries(snapshot) : [];
 	const windows = entries.map((entry) => readProviderUsageWindow(entry, entries)).filter((window) => Boolean(window));
-	return {
+	const result = {
 		provider: "openai",
 		displayName: PROVIDER_LABELS.openai,
 		windows,
 		...snapshot ? { plan: resolveCodexProviderUsagePlan(snapshot) } : {}
 	};
+	if (options.accountDetails && snapshot) {
+		result.plan = snapshot.planType;
+		for (const extra of snapshots) {
+			if (extra === snapshot) continue;
+			const extraEntries = readWindowEntries(extra);
+			for (const entry of extraEntries) {
+				const window = readProviderUsageWindow(entry, extraEntries);
+				if (window) windows.push({
+					...window,
+					groupLabel: formatLimitLabel(extra)
+				});
+			}
+		}
+		const credits = snapshot.credits;
+		const balance = credits?.balance;
+		if (balance !== void 0 && balance >= 0 && credits?.unlimited !== true) result.billing = [{
+			type: "balance",
+			amount: balance,
+			unit: "credits"
+		}];
+	}
+	return result;
 }
 function isCodexUsageLimitError(codexErrorInfo) {
 	if (codexErrorInfo === "usageLimitExceeded") return true;
@@ -117,7 +184,7 @@ function isCodexUsageLimitError(codexErrorInfo) {
 	return false;
 }
 function selectNextRateLimitReset(value, nowMs) {
-	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => readRateLimitWindow(snapshot, key) ?? [])).filter((window) => window.resetsAtMs > nowMs);
+	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
@@ -130,10 +197,10 @@ function selectBlockingRateLimitReset(value, nowMs) {
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
 	const windows = LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [formatRateLimitWindow(key, window, nowMs)] : [];
 	});
-	const reachedType = normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type);
+	const reachedType = snapshot.rateLimitReachedType;
 	const suffix = reachedType ? ` (${formatReachedType(reachedType)})` : "";
 	if (windows.length > 0) return `${label}: ${windows.join(" · ")}${suffix}`;
 	if (reachedType) return `${label}: ${formatReachedType(reachedType)}`;
@@ -150,7 +217,7 @@ function collectRateLimitSnapshots(value, snapshots, seen) {
 	}
 	if (!isJsonObject(value)) return;
 	if (isRateLimitSnapshot(value)) {
-		addRateLimitSnapshot(value, snapshots, seen);
+		addRateLimitSnapshot(rateLimitSnapshotSchema.parse(value), snapshots, seen);
 		return;
 	}
 	const byLimitId = value.rateLimitsByLimitId;
@@ -171,8 +238,8 @@ function sortedRateLimitKeys(keys) {
 }
 function addRateLimitSnapshot(snapshot, snapshots, seen) {
 	const signature = [
-		normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id) ?? "",
-		normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? "",
+		snapshot.limitId ?? "",
+		snapshot.limitName ?? "",
 		formatWindowSignature(snapshot.primary),
 		formatWindowSignature(snapshot.secondary)
 	].join("|");
@@ -183,24 +250,8 @@ function addRateLimitSnapshot(snapshot, snapshots, seen) {
 function isRateLimitSnapshot(value) {
 	return isJsonObject(value.primary) || isJsonObject(value.secondary) || value.rateLimitReachedType !== void 0 || value.rate_limit_reached_type !== void 0 || value.limitId !== void 0 || value.limit_id !== void 0 || value.limitName !== void 0 || value.limit_name !== void 0;
 }
-function readRateLimitWindow(snapshot, key) {
-	const window = snapshot[key];
-	if (!isJsonObject(window)) return;
-	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
-	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
-		...readOptionalNumberField(window, "usedPercent", "used_percent"),
-		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
-	};
-}
 function snapshotHasDisplayableData(snapshot) {
-	if (normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type)) return true;
-	return readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
-}
-function readOptionalNumberField(record, ...keys) {
-	const value = keys.map((key) => asFiniteNumber(record[key])).find((entry) => entry !== void 0);
-	if (value === void 0) return {};
-	return keys.some((key) => key.toLowerCase().includes("window")) ? { windowDurationMins: value } : { usedPercent: value };
+	return Boolean(snapshot.rateLimitReachedType) || readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 || entry.window.resetsAtMs > 0);
 }
 function formatRateLimitWindow(key, window, nowMs) {
 	return `${key} ${formatRateLimitWindowDetails(window, nowMs)}`;
@@ -209,7 +260,7 @@ function formatRateLimitWindowDetails(window, nowMs) {
 	return `${window.usedPercent === void 0 ? "usage unknown" : `${Math.max(0, 100 - Math.round(window.usedPercent))}% left`}${window.resetsAtMs > nowMs ? ` ⏱${formatResetDuration(window.resetsAtMs, nowMs)}` : ""}`;
 }
 function formatLimitLabel(snapshot) {
-	const label = normalizeOptionalString(snapshot.limitName) ?? normalizeOptionalString(snapshot.limit_name) ?? normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
+	const label = snapshot.limitName ?? snapshot.limitId;
 	if (!label || label === CODEX_LIMIT_ID) return "Codex";
 	return label.replace(/[_-]+/gu, " ").replace(/\s+/gu, " ").trim();
 }
@@ -223,15 +274,10 @@ function formatAccountResetTime(resetsAtMs, nowMs) {
 	return `${formatCalendarResetTime(resetsAtMs, nowMs)} (in ${formatRelativeDuration(resetsAtMs - nowMs)})`;
 }
 function snapshotHasLimitBlock(snapshot) {
-	return Boolean(normalizeOptionalString(snapshot.rateLimitReachedType) ?? normalizeOptionalString(snapshot.rate_limit_reached_type) ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
+	return Boolean(snapshot.rateLimitReachedType ?? readWindowEntries(snapshot).some((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100));
 }
 function isCodexLimitSnapshot(snapshot) {
-	const id = normalizeOptionalString(snapshot.limitId) ?? normalizeOptionalString(snapshot.limit_id);
-	return !id || id === CODEX_LIMIT_ID;
-}
-function selectCodexProviderUsageSnapshot(value) {
-	const snapshots = collectCodexRateLimitSnapshots(value);
-	return snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	return !snapshot.limitId || snapshot.limitId === CODEX_LIMIT_ID;
 }
 function readProviderUsageWindow(entry, entries) {
 	const { window } = entry;
@@ -252,16 +298,15 @@ function formatProviderUsageWindowLabel(entry, entries) {
 	return entry.key === "primary" ? "Short" : "Long";
 }
 function resolveCodexProviderUsagePlan(snapshot) {
-	const plan = normalizeOptionalString(snapshot.planType) ?? normalizeOptionalString(snapshot.plan_type);
-	const creditSummary = formatCodexCreditSummary(isJsonObject(snapshot.credits) ? snapshot.credits : void 0);
+	const plan = snapshot.planType;
+	const creditSummary = formatCodexCreditSummary(snapshot.credits);
 	if (!creditSummary) return plan;
 	return plan ? `${plan} (${creditSummary})` : creditSummary;
 }
 function formatCodexCreditSummary(credits) {
-	if (!credits) return;
-	if ((asBoolean(credits.hasCredits) ?? asBoolean(credits.has_credits)) === false) return;
-	if (asBoolean(credits.unlimited)) return "Unlimited credits";
-	const balance = typeof credits.balance === "string" ? parseStrictFiniteNumber(credits.balance) : asFiniteNumber(credits.balance);
+	if (!credits || credits.hasCredits === false) return;
+	if (credits.unlimited) return "Unlimited credits";
+	const balance = credits.balance;
 	if (balance === void 0 || balance <= 0) return;
 	const roundedBalance = Math.round(balance);
 	return roundedBalance > 0 ? `${roundedBalance} credits` : void 0;
@@ -285,7 +330,7 @@ function selectBlockingWindowEntry(entries, nowMs) {
 }
 function readWindowEntries(snapshot) {
 	return LIMIT_WINDOW_KEYS.flatMap((key) => {
-		const window = readRateLimitWindow(snapshot, key);
+		const window = snapshot[key];
 		return window ? [{
 			key,
 			window
@@ -370,9 +415,8 @@ function formatResetDuration(resetsAtMs, nowMs) {
 	if (minutes > 0) return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
 	return `${seconds}s`;
 }
-function formatWindowSignature(value) {
-	if (!isJsonObject(value)) return "";
-	return `${asFiniteNumber(value.usedPercent) ?? asFiniteNumber(value.used_percent) ?? ""}:${asFiniteNumber(value.resetsAt) ?? asFiniteNumber(value.resets_at) ?? ""}`;
+function formatWindowSignature(window) {
+	return window ? `${window.usedPercent ?? ""}:${window.resetsAt ?? ""}` : "";
 }
 function extractCodexRetryHint(message) {
 	if (!message) return;

package/dist/.setup/request-BioXJLYa.mjs

@@ -0,0 +1,292 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as CodexAppServerRpcError, n as withTimeout, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
+//#region extensions/codex/src/app-server/request.ts
+var request_exports = /* @__PURE__ */ __exportAll({
+	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
+	readCodexAppServerUsage: () => readCodexAppServerUsage,
+	requestCodexAppServerClientJson: () => requestCodexAppServerClientJson,
+	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) {
+	let phase = "prepare";
+	observeControlPhase(params.controlObservation, phase);
+	try {
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.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) {
+	observeControlPhase(params.controlObservation, "prepare");
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.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);
+	return await withCodexAppServerJsonClient({
+		...params,
+		timeoutMessage: `codex app-server ${params.method} timed out`
+	}, async (request) => await request({
+		method: params.method,
+		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 assertRequestOwnerCurrent(assertCurrent) {
+	try {
+		assertCurrent?.();
+	} catch (cause) {
+		throw new CodexAppServerScopedRequestRejectedError(cause instanceof Error ? cause.message : String(cause), { cause });
+	}
+}
+const CODEX_USAGE_ISOLATED_SHUTDOWN = {
+	forceKillDelayMs: 200,
+	exitTimeoutMs: 300
+};
+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 = performance.now() + options.timeoutMs;
+	return await withCodexAppServerJsonClient({
+		timeoutMs: options.timeoutMs,
+		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) => {
+		const rateLimits = await request({ method: "account/rateLimits/read" });
+		const accountEmail = await readCodexAccountEmailBestEffort(request, deadline);
+		return {
+			rateLimits,
+			...accountEmail ? { accountEmail } : {}
+		};
+	});
+}
+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 - performance.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
+	if (boundMs <= 0) return;
+	const read = request({
+		method: "account/read",
+		requestParams: {}
+	}).then((account) => extractCodexAccountEmail(account), () => 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);
+	}
+}
+/**
+* Runs several guarded requests over one acquired client (shared lease or
+* isolated child) so related reads see the same app-server session. The whole
+* callback re-runs once when the client's start selection changed underneath it.
+*/
+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 ? 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 - performance.now());
+	};
+	try {
+		return await withAbortableTimeout({
+			signal: timeoutController.signal,
+			timeoutMs,
+			timeoutMessage,
+			promise: (async () => {
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
+				for (let attempt = 0; attempt < 2; attempt += 1) {
+					errorPhase = void 0;
+					activePhase = "prepare";
+					observeControlPhase(params.controlObservation, activePhase);
+					throwIfAbandoned();
+					const acquireClient = params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient;
+					const acquireOptions = {
+						startOptions: params.startOptions,
+						pluginConfig: params.pluginConfig,
+						timeoutMs: remainingTimeoutMs(),
+						authProfileId: params.authProfileId,
+						authProfileStore: params.authProfileStore,
+						authBindingFingerprint: params.authBindingFingerprint,
+						preparedAuth: params.preparedAuth,
+						authRequirement: params.authRequirement,
+						agentDir: params.agentDir,
+						config: params.config,
+						abandonSignal: timeoutController.signal,
+						assertCurrent: params.assertCurrent
+					};
+					activePhase = "acquire-client";
+					observeControlPhase(params.controlObservation, activePhase);
+					const client = await acquireClient(acquireOptions);
+					let scopeActive = true;
+					const assertCurrent = () => {
+						throwIfAbandoned();
+						if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
+						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,
+								config: params.config,
+								sessionKey: params.sessionKey,
+								sessionId: params.sessionId
+							});
+							if (sandboxBlock) throw new CodexAppServerScopedRequestRejectedError(sandboxBlock);
+							assertCurrent();
+							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 && method === "thread/list" ? {
+									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,
+							abort: (reason) => {
+								if (scopeActive) timeoutController.abort(reason);
+							}
+						});
+					} catch (error) {
+						errorPhase = activePhase;
+						if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+						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) {
+		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));
+	}
+}
+//#endregion
+export { request_exports as a, requestCodexAppServerJson as i, readCodexAppServerUsage as n, withCodexAppServerJsonClient as o, requestCodexAppServerClientJson as r, CodexAppServerScopedRequestRejectedError as t };

package/dist/.setup/run-attempt-lifecycle-B7JbY4-F.mjs

@@ -0,0 +1,71 @@
+import { t as attemptTerminal } from "./attempt-terminal-gZrxQ35N.mjs";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { awaitAgentEndSideEffects, embeddedAgentLog, emitAgentEvent, runAgentEndSideEffects } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/workspace-dir-cache.ts
+/** Process-local cache of Codex workspaces already created by the run loop. */
+const codexWorkspaceDirCache = /* @__PURE__ */ new Set();
+//#endregion
+//#region extensions/codex/src/app-server/run-attempt-lifecycle.ts
+const CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN = 4;
+function shouldKeepCodexSharedAbortOpen(params) {
+	const terminal = attemptTerminal.project(params.result.terminal);
+	if (params.explicitCancellationObserved || terminal.aborted || terminal.externalAbort) return false;
+	return params.trigger === "memory" || !params.attemptSucceeded;
+}
+function withCodexAppServerFastModeServiceTier(appServer, params) {
+	const fastMode = typeof params.fastMode === "function" ? params.fastMode() : params.fastMode;
+	const serviceTier = fastMode === void 0 ? appServer.serviceTier : fastMode ? "priority" : void 0;
+	if (serviceTier === appServer.serviceTier) return appServer;
+	if (serviceTier) return {
+		...appServer,
+		serviceTier
+	};
+	return {
+		...appServer,
+		serviceTier: null
+	};
+}
+function estimateCodexAppServerProjectedTurnTokens(params) {
+	const inputChars = params.prompt.length + (params.developerInstructions?.length ?? 0);
+	return Math.max(1, Math.ceil(inputChars / CODEX_APP_SERVER_PROJECTED_CHARS_PER_TOKEN));
+}
+async function ensureCodexWorkspaceDirOnce(workspaceDir) {
+	const normalized = path.resolve(workspaceDir);
+	if (codexWorkspaceDirCache.has(normalized)) return;
+	await fs.mkdir(normalized, { recursive: true });
+	codexWorkspaceDirCache.add(normalized);
+}
+async function emitCodexAppServerEvent(params, event) {
+	try {
+		emitAgentEvent({
+			runId: params.runId,
+			stream: event.stream,
+			data: event.data,
+			...params.sessionKey ? { sessionKey: params.sessionKey } : {}
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server global agent event emit failed", { error });
+	}
+	try {
+		await params.onAgentEvent?.(event);
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server agent event handler threw", { error });
+	}
+}
+async function runCodexAgentEndHook(params, hookParams) {
+	const sideEffectParams = {
+		...hookParams,
+		ctx: {
+			...hookParams.ctx,
+			config: params.config
+		}
+	};
+	if (!params.messageChannel && !params.messageProvider) {
+		await awaitAgentEndSideEffects(sideEffectParams);
+		return;
+	}
+	runAgentEndSideEffects(sideEffectParams);
+}
+//#endregion
+export { shouldKeepCodexSharedAbortOpen as a, runCodexAgentEndHook as i, ensureCodexWorkspaceDirOnce as n, withCodexAppServerFastModeServiceTier as o, estimateCodexAppServerProjectedTurnTokens as r, emitCodexAppServerEvent as t };