@openclaw/codex 2026.7.1 → 2026.7.2-beta.2

package/dist/{provider-zjPfx5Fs.js → rate-limits-DyXaYAxU.js}

@@ -1,12 +1,7 @@
-import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "./provider-catalog.js";
-import { r as isJsonObject } from "./protocol-2POPqAY4.js";
-import { d as resolveCodexAppServerRuntimeOptions, u as readCodexPluginConfig } from "./config-CYEDnLJ2.js";
-import { resolveCodexSystemPromptContribution } from "./prompt-overlay.js";
-import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { Z as isJsonObject } from "./shared-client-JiAnW6pc.js";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { asFiniteNumber, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { normalizeModelCompat } from "openclaw/plugin-sdk/provider-model-shared";
-import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { PROVIDER_LABELS, clampPercent } from "openclaw/plugin-sdk/provider-usage";
 //#region extensions/codex/src/app-server/rate-limits.ts
 /**
@@ -22,14 +17,15 @@ const ONE_DAY_MS = 24 * ONE_HOUR_MS;
 const DAY_WINDOW_MINUTES = 1440;
 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.";
 /** Enriches Codex usage-limit failures with reset timing and recovery guidance. */
 function formatCodexUsageLimitErrorMessage(params) {
 	const message = normalizeText(params.message);
-	if (!isCodexUsageLimitError(params.codexErrorInfo, message)) return;
+	if (!isCodexUsageLimitError(params.codexErrorInfo)) return;
 	const nowMs = params.nowMs ?? Date.now();
 	const usageSummary = summarizeCodexAccountUsage(params.rateLimits, nowMs);
 	const nextReset = selectBlockingRateLimitReset(params.rateLimits, nowMs) ?? (usageSummary?.blocked ? void 0 : selectNextRateLimitReset(params.rateLimits, nowMs));
-	const parts = ["You've reached your Codex subscription usage limit."];
+	const parts = [CODEX_USAGE_LIMIT_MESSAGE_PREFIX];
 	let recoveryAction = "Wait until Codex becomes available";
 	if (nextReset) {
 		parts.push(`Next reset ${formatResetTime(nextReset.resetsAtMs, nowMs)}.`);
@@ -50,7 +46,7 @@ function formatCodexUsageLimitErrorMessage(params) {
 /** Detects usage-limit messages that need a fresh rate-limit query before display. */
 function shouldRefreshCodexRateLimitsForUsageLimitMessage(message) {
 	const text = normalizeText(message);
-	return Boolean(text?.includes("You've reached your Codex subscription usage limit.") && !text.includes("Next reset "));
+	return Boolean(text?.startsWith(CODEX_USAGE_LIMIT_MESSAGE_PREFIX) && !text.includes("Next reset "));
 }
 /** Formats compact summaries for raw Codex rate-limit snapshot payloads. */
 function summarizeCodexRateLimits(value, nowMs = Date.now()) {
@@ -78,7 +74,7 @@ function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
 function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasDisplayableData);
 	if (snapshots.length === 0) return;
-	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? expectDefined(snapshots[0], "displayable Codex rate-limit snapshot");
 	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
 	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
 	const blockingEntries = blockingSnapshot ? readWindowEntries(blockingSnapshot) : [];
@@ -111,12 +107,12 @@ function buildCodexAppServerUsageSnapshot(value) {
 		...snapshot ? { plan: resolveCodexProviderUsagePlan(snapshot) } : {}
 	};
 }
-function isCodexUsageLimitError(codexErrorInfo, message) {
+function isCodexUsageLimitError(codexErrorInfo) {
 	if (codexErrorInfo === "usageLimitExceeded") return true;
 	if (typeof codexErrorInfo === "string") {
 		if (codexErrorInfo.replace(/[_\s-]/gu, "").toLowerCase() === "usagelimitexceeded") return true;
 	}
-	return Boolean(message?.toLowerCase().includes("usage limit"));
+	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);
@@ -400,256 +396,4 @@ function normalizeText(value) {
 	return text ? text : void 0;
 }
 //#endregion
-//#region extensions/codex/provider.ts
-/**
-* Codex provider plugin and live app-server model catalog discovery.
-*/
-const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
-const LIVE_DISCOVERY_ENV = "OPENCLAW_CODEX_DISCOVERY_LIVE";
-const MODEL_DISCOVERY_PAGE_LIMIT = 100;
-const CODEX_APP_SERVER_SETUP_METHOD_ID = "app-server";
-const CODEX_DEFAULT_MODEL_REF = `${CODEX_PROVIDER_ID}/${FALLBACK_CODEX_MODELS[0].id}`;
-const codexCatalogLog = createSubsystemLogger("codex/catalog");
-const CODEX_REASONING_EFFORTS = [
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-	"ultra"
-];
-const GPT_56_MAX_REASONING_EFFORTS = [
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-];
-const GPT_56_ULTRA_REASONING_EFFORTS = [...GPT_56_MAX_REASONING_EFFORTS, "ultra"];
-const GPT_56_ULTRA_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.6-sol", "gpt-5.6-terra"]);
-const GPT_56_MAX_MODEL_IDS = /* @__PURE__ */ new Set([...GPT_56_ULTRA_MODEL_IDS, "gpt-5.6-luna"]);
-const GPT_56_DEFAULT_REASONING_EFFORTS = /* @__PURE__ */ new Map([
-	["gpt-5.6-sol", "low"],
-	["gpt-5.6-terra", "medium"],
-	["gpt-5.6-luna", "medium"]
-]);
-const GPT_5_PRO_REASONING_EFFORTS = [
-	"medium",
-	"high",
-	"xhigh"
-];
-/**
-* Builds the Codex provider plugin, including setup metadata, catalog discovery,
-* dynamic model resolution, and prompt/thinking hooks.
-*/
-function buildCodexProvider(options = {}) {
-	return {
-		id: CODEX_PROVIDER_ID,
-		label: "Codex",
-		docsPath: "/providers/models",
-		auth: [{
-			id: CODEX_APP_SERVER_SETUP_METHOD_ID,
-			label: "Codex app-server",
-			hint: "Use the Codex app-server runtime and managed model catalog.",
-			kind: "custom",
-			wizard: {
-				choiceId: CODEX_PROVIDER_ID,
-				choiceLabel: "Codex app-server",
-				choiceHint: "Use the Codex app-server runtime and managed model catalog.",
-				assistantPriority: -40,
-				groupId: CODEX_PROVIDER_ID,
-				groupLabel: "Codex",
-				groupHint: "Codex app-server model provider",
-				onboardingScopes: ["text-inference"]
-			},
-			run: async () => ({
-				profiles: [],
-				defaultModel: CODEX_DEFAULT_MODEL_REF
-			})
-		}],
-		catalog: {
-			order: "late",
-			run: async (ctx) => {
-				const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
-				return await buildCodexProviderCatalog({
-					env: ctx.env,
-					pluginConfig,
-					listModels: options.listModels
-				});
-			}
-		},
-		staticCatalog: {
-			order: "late",
-			run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
-		},
-		resolveDynamicModel: (ctx) => resolveCodexDynamicModel(ctx.modelId),
-		resolveSyntheticAuth: () => ({
-			apiKey: CODEX_APP_SERVER_AUTH_MARKER,
-			source: "codex-app-server",
-			mode: "token"
-		}),
-		fetchUsageSnapshot: async (ctx) => {
-			if (ctx.token !== "codex-app-server") return null;
-			const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig) });
-			return buildCodexAppServerUsageSnapshot(await (options.readRateLimits ?? requestCodexAppServerRateLimitsLazy)({
-				timeoutMs: ctx.timeoutMs,
-				agentDir: ctx.agentDir,
-				...ctx.authProfileId ? { authProfileId: ctx.authProfileId } : {},
-				config: ctx.config,
-				startOptions: appServer.start
-			}));
-		},
-		resolveThinkingProfile: ({ modelId, compat }) => {
-			const efforts = resolveCodexThinkingEfforts({
-				modelId,
-				supportedReasoningEfforts: readCodexSupportedReasoningEfforts(compat)
-			});
-			const defaultLevel = GPT_56_DEFAULT_REASONING_EFFORTS.get(modelId.trim().toLowerCase());
-			return {
-				levels: [{ id: "off" }, ...efforts.map((id) => ({ id }))],
-				...defaultLevel && efforts.includes(defaultLevel) ? { defaultLevel } : {}
-			};
-		},
-		resolveSystemPromptContribution: ({ config, modelId }) => resolveCodexSystemPromptContribution({
-			config,
-			modelId
-		}),
-		isModernModelRef: ({ modelId }) => isModernCodexModel(modelId)
-	};
-}
-/**
-* Builds the Codex model catalog from live app-server discovery, falling back
-* to built-in model records when discovery is disabled or unavailable.
-*/
-async function buildCodexProviderCatalog(options = {}) {
-	const config = readCodexPluginConfig(options.pluginConfig);
-	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
-	let discovered = [];
-	if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) discovered = await listModelsBestEffort({
-		listModels: options.listModels ?? listCodexAppServerModelsLazy,
-		timeoutMs,
-		startOptions: appServer.start,
-		onDiscoveryFailure: options.onDiscoveryFailure
-	});
-	return { provider: buildCodexProviderConfig(discovered.length > 0 ? discovered : FALLBACK_CODEX_MODELS) };
-}
-function resolveCodexDynamicModel(modelId) {
-	const id = modelId.trim();
-	if (!id) return;
-	const fallbackModel = FALLBACK_CODEX_MODELS.find((model) => model.id === id);
-	return normalizeModelCompat({
-		...buildCodexModelDefinition({
-			id,
-			model: id,
-			inputModalities: fallbackModel?.inputModalities ?? ["text"],
-			supportedReasoningEfforts: fallbackModel?.supportedReasoningEfforts
-		}),
-		provider: CODEX_PROVIDER_ID,
-		baseUrl: CODEX_BASE_URL
-	});
-}
-async function listModelsBestEffort(params) {
-	try {
-		const models = [];
-		let cursor;
-		do {
-			const result = await params.listModels({
-				timeoutMs: params.timeoutMs,
-				limit: MODEL_DISCOVERY_PAGE_LIMIT,
-				cursor,
-				startOptions: params.startOptions,
-				sharedClient: false
-			});
-			models.push(...result.models.filter((model) => !model.hidden));
-			cursor = result.nextCursor;
-		} while (cursor);
-		return models;
-	} catch (error) {
-		params.onDiscoveryFailure?.(error);
-		codexCatalogLog.debug("codex model discovery failed; using fallback catalog", { error: error instanceof Error ? error.message : String(error) });
-		return [];
-	}
-}
-async function listCodexAppServerModelsLazy(options) {
-	const { listCodexAppServerModels } = await import("./models-DDmO1zwd.js").then((n) => n.r);
-	return listCodexAppServerModels(options);
-}
-async function requestCodexAppServerRateLimitsLazy(options) {
-	const { requestCodexAppServerJson } = await import("./request-BcJyl8KL.js").then((n) => n.n);
-	return await requestCodexAppServerJson({
-		method: "account/rateLimits/read",
-		timeoutMs: options.timeoutMs,
-		agentDir: options.agentDir,
-		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
-		config: options.config,
-		startOptions: options.startOptions,
-		isolated: true
-	});
-}
-function normalizeTimeoutMs(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_DISCOVERY_TIMEOUT_MS;
-}
-function shouldSkipLiveDiscovery(env = process.env) {
-	const override = env[LIVE_DISCOVERY_ENV]?.trim().toLowerCase();
-	if (override === "0" || override === "false") return true;
-	return Boolean(env.VITEST) && override !== "1";
-}
-function isKnownXHighCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
-}
-function normalizeCodexReasoningEfforts(efforts) {
-	if (!efforts) return [];
-	const supported = new Set(efforts.map((effort) => effort.trim().toLowerCase()));
-	return CODEX_REASONING_EFFORTS.filter((effort) => supported.has(effort));
-}
-/** Read app-server reasoning metadata from a runtime model compat union. */
-function readCodexSupportedReasoningEfforts(compat) {
-	if (!compat || typeof compat !== "object" || Array.isArray(compat)) return;
-	const efforts = compat.supportedReasoningEfforts;
-	if (!Array.isArray(efforts)) return;
-	const strings = efforts.filter((effort) => typeof effort === "string");
-	return strings.some((effort) => effort.trim().toLowerCase() === "none") ? void 0 : strings;
-}
-function resolveCodexThinkingEfforts(params) {
-	if (params.supportedReasoningEfforts) return normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
-	const fallbackEfforts = resolveCodexFallbackReasoningEfforts(params.modelId);
-	if (fallbackEfforts) return [...fallbackEfforts];
-	return [
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		...isKnownXHighCodexModel(params.modelId) ? ["xhigh"] : [],
-		...isMaxReasoningCodexModel(params.modelId) ? ["max"] : []
-	];
-}
-/** Map a requested effort onto the authoritative app-server model contract. */
-function resolveCodexSupportedReasoningEffort(params) {
-	const supported = normalizeCodexReasoningEfforts(params.supportedReasoningEfforts);
-	if (supported.includes(params.requested)) return params.requested;
-	const fallbackEfforts = params.requested === "ultra" ? supported : supported.filter((effort) => effort !== "ultra");
-	const requestedRank = CODEX_REASONING_EFFORTS.indexOf(params.requested);
-	return fallbackEfforts.find((effort) => CODEX_REASONING_EFFORTS.indexOf(effort) >= requestedRank) ?? fallbackEfforts.at(-1);
-}
-/** Return the known effort contract when app-server model metadata is unavailable. */
-function resolveCodexFallbackReasoningEfforts(modelId) {
-	const normalized = modelId.trim().toLowerCase();
-	if (GPT_56_ULTRA_MODEL_IDS.has(normalized)) return GPT_56_ULTRA_REASONING_EFFORTS;
-	if (normalized === "gpt-5.6-luna") return GPT_56_MAX_REASONING_EFFORTS;
-	if (normalized === "gpt-5.5-pro" || normalized === "gpt-5.4-pro") return GPT_5_PRO_REASONING_EFFORTS;
-}
-/** Return whether the model uses the modern Codex reasoning profile. */
-function isModernCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return GPT_56_MAX_MODEL_IDS.has(lower) || lower === "gpt-5.5" || lower === "gpt-5.5-pro" || lower === "gpt-5.4" || lower === "gpt-5.4-pro" || lower === "gpt-5.4-mini" || lower === "gpt-5.3-codex-spark";
-}
-/** Return whether Codex accepts the preview GPT-5.6 `max` reasoning effort. */
-function isMaxReasoningCodexModel(modelId) {
-	const lower = modelId.trim().toLowerCase();
-	return GPT_56_MAX_MODEL_IDS.has(lower);
-}
-//#endregion
-export { readCodexSupportedReasoningEfforts as a, formatCodexUsageLimitErrorMessage as c, shouldRefreshCodexRateLimitsForUsageLimitMessage as d, summarizeCodexAccountRateLimits as f, isModernCodexModel as i, hasCodexRateLimitSnapshots as l, summarizeCodexRateLimits as m, buildCodexProviderCatalog as n, resolveCodexFallbackReasoningEfforts as o, summarizeCodexAccountUsage as p, isMaxReasoningCodexModel as r, resolveCodexSupportedReasoningEffort as s, buildCodexProvider as t, resolveCodexUsageLimitResetAtMs as u };
+export { shouldRefreshCodexRateLimitsForUsageLimitMessage as a, summarizeCodexRateLimits as c, resolveCodexUsageLimitResetAtMs as i, formatCodexUsageLimitErrorMessage as n, summarizeCodexAccountRateLimits as o, hasCodexRateLimitSnapshots as r, summarizeCodexAccountUsage as s, buildCodexAppServerUsageSnapshot as t };

package/dist/request-B_oQsCXy.js

@@ -0,0 +1,157 @@
+import { a as getLeasedSharedCodexAppServerClient, c as releaseLeasedSharedCodexAppServerClient, d as retireSharedCodexAppServerClientIfCurrent, i as createIsolatedCodexAppServerClient, m as withTimeout, o as isCodexAppServerStartSelectionChangedError } from "./shared-client-JiAnW6pc.js";
+import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-D1Wky__S.js";
+//#region extensions/codex/src/app-server/request.ts
+/** Sends one guarded request over a client lease owned by the caller. */
+async function requestCodexAppServerClientJson(params) {
+	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 }), timeoutMs, `codex app-server ${params.method} timed out`);
+}
+async function requestCodexAppServerJson(params) {
+	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
+	}));
+}
+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 = Date.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,
+		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 - Date.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";
+	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 throwIfAbandoned = () => {
+		if (timeoutController.signal.aborted || isPastDeadline()) throw new Error(timeoutMessage);
+	};
+	const remainingTimeoutMs = () => {
+		throwIfAbandoned();
+		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
+	};
+	try {
+		return await withTimeout((async () => {
+			for (let attempt = 0; attempt < 2; attempt += 1) {
+				throwIfAbandoned();
+				const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
+					startOptions: params.startOptions,
+					pluginConfig: params.pluginConfig,
+					timeoutMs: remainingTimeoutMs(),
+					authProfileId: params.authProfileId,
+					agentDir: params.agentDir,
+					config: params.config,
+					abandonSignal: timeoutController.signal
+				});
+				try {
+					throwIfAbandoned();
+					const scopedRequest = async (request) => {
+						const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
+							method: request.method,
+							requestParams: request.requestParams,
+							config: params.config,
+							sessionKey: params.sessionKey,
+							sessionId: params.sessionId
+						});
+						if (sandboxBlock) throw new Error(sandboxBlock);
+						throwIfAbandoned();
+						return await client.request(request.method, request.requestParams, {
+							timeoutMs: remainingTimeoutMs(),
+							signal: timeoutController.signal
+						});
+					};
+					return await run(scopedRequest);
+				} catch (error) {
+					if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+					if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
+					throwIfAbandoned();
+				} finally {
+					if (params.isolated) await client.closeAndWait({
+						exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
+						forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
+					});
+					else releaseLeasedSharedCodexAppServerClient(client);
+				}
+			}
+			throw new Error("Codex app-server selection retry loop exited unexpectedly");
+		})(), timeoutMs, timeoutMessage);
+	} catch (error) {
+		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
+		throw error;
+	} finally {
+		timeoutController.abort();
+	}
+}
+//#endregion
+export { requestCodexAppServerClientJson as n, requestCodexAppServerJson as r, readCodexAppServerUsage as t };