@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{protocol-validators-B4F7L8Rf.js → protocol-validators-Bg5rpNxk.js}

@@ -89,6 +89,10 @@ var definitions = {
 		"required": ["id"],
 		"type": "object"
 	},
+	"AgentMessageDelivery": {
+		"enum": ["async"],
+		"type": "string"
+	},
 	"AgentPath": { "type": "string" },
 	"ApprovalsReviewer": {
 		"description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `auto_review` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request. The legacy value `guardian_subagent` is accepted for compatibility.",
@@ -228,8 +232,10 @@ var definitions = {
 					"contextWindowExceeded",
 					"sessionBudgetExceeded",
 					"usageLimitExceeded",
+					"rateLimitExceeded",
 					"serverOverloaded",
 					"cyberPolicy",
+					"misalignmentPolicyViolation",
 					"internalServerError",
 					"unauthorized",
 					"badRequest",
@@ -267,7 +273,11 @@ var definitions = {
 			"sendInput",
 			"resumeAgent",
 			"wait",
-			"closeAgent"
+			"closeAgent",
+			"sendMessage",
+			"followupTask",
+			"interruptAgent",
+			"listAgents"
 		],
 		"type": "string"
 	},
@@ -275,7 +285,8 @@ var definitions = {
 		"enum": [
 			"inProgress",
 			"completed",
-			"failed"
+			"failed",
+			"interrupted"
 		],
 		"type": "string"
 	},
@@ -423,6 +434,68 @@ var definitions = {
 		],
 		"type": "object"
 	},
+	"FunctionCallOutputBody": { "anyOf": [{
+		"items": { "$ref": "#/definitions/FunctionCallOutputContentItem" },
+		"type": "array"
+	}, { "type": "string" }] },
+	"FunctionCallOutputContentItem": {
+		"description": "Responses API compatible content items that can be returned by a tool call. This is a subset of ContentItem with the types we support as function call outputs.",
+		"oneOf": [
+			{
+				"properties": {
+					"text": { "type": "string" },
+					"type": {
+						"enum": ["input_text"],
+						"title": "InputTextFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["text", "type"],
+				"title": "InputTextFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"detail": { "anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }] },
+					"image_url": { "type": "string" },
+					"type": {
+						"enum": ["input_image"],
+						"title": "InputImageFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["image_url", "type"],
+				"title": "InputImageFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"audio_url": { "type": "string" },
+					"type": {
+						"enum": ["input_audio"],
+						"title": "InputAudioFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["audio_url", "type"],
+				"title": "InputAudioFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"encrypted_content": { "type": "string" },
+					"type": {
+						"enum": ["encrypted_content"],
+						"title": "EncryptedContentFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["encrypted_content", "type"],
+				"title": "EncryptedContentFunctionCallOutputContentItem",
+				"type": "object"
+			}
+		]
+	},
 	"GitInfo": {
 		"properties": {
 			"branch": { "type": ["string", "null"] },
@@ -448,6 +521,23 @@ var definitions = {
 		],
 		"type": "string"
 	},
+	"ImageGenerationFailure": { "oneOf": [{
+		"properties": {
+			"limitId": { "type": "string" },
+			"resetsAt": {
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"type": {
+				"enum": ["usageLimitExceeded"],
+				"title": "UsageLimitExceededImageGenerationFailureType",
+				"type": "string"
+			}
+		},
+		"required": ["limitId", "type"],
+		"title": "UsageLimitExceededImageGenerationFailure",
+		"type": "object"
+	}] },
 	"InputModality": {
 		"description": "Canonical user-input modality tags advertised by a model.",
 		"oneOf": [
@@ -554,6 +644,28 @@ var definitions = {
 			"type": "string"
 		}]
 	},
+	"MisalignmentErrorDetails": {
+		"properties": {
+			"detailedExplanation": {
+				"description": "A substantive localized explanation is required before offering continuation.",
+				"type": ["string", "null"]
+			},
+			"errorType": {
+				"description": "Open-ended classification; clients must accept categories added by Responses.",
+				"type": ["string", "null"]
+			},
+			"steer": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentSteer" }, { "type": "null" }],
+				"description": "Instruction to submit as the next turn's user input if continuation is confirmed."
+			}
+		},
+		"type": "object"
+	},
+	"MisalignmentSteer": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
 	"Model": {
 		"properties": {
 			"additionalSpeedTiers": {
@@ -584,6 +696,10 @@ var definitions = {
 				"default": null,
 				"type": ["string", "null"]
 			},
+			"multiAgentVersion": {
+				"anyOf": [{ "$ref": "#/definitions/MultiAgentVersion" }, { "type": "null" }],
+				"description": "Multi-agent runtime declared by this model, when available."
+			},
 			"serviceTiers": {
 				"default": [],
 				"items": { "$ref": "#/definitions/ModelServiceTier" },
@@ -635,6 +751,11 @@ var definitions = {
 			"migrationMarkdown": { "type": ["string", "null"] },
 			"model": { "type": "string" },
 			"modelLink": { "type": ["string", "null"] },
+			"retirementAt": {
+				"description": "Informational Unix timestamp for this upgrade's scheduled retirement, if known.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
 			"upgradeCopy": { "type": ["string", "null"] }
 		},
 		"required": ["model"],
@@ -653,6 +774,15 @@ var definitions = {
 			"type": "string"
 		}]
 	},
+	"MultiAgentVersion": {
+		"description": "Multi-agent runtime supported by a model.",
+		"enum": [
+			"disabled",
+			"v1",
+			"v2"
+		],
+		"type": "string"
+	},
 	"NetworkAccess": {
 		"enum": ["restricted", "enabled"],
 		"type": "string"
@@ -721,6 +851,8 @@ var definitions = {
 			"enterprise_cbp_usage_based",
 			"enterprise",
 			"edu",
+			"edu_plus",
+			"edu_pro",
 			"unknown"
 		],
 		"type": "string"
@@ -841,7 +973,8 @@ var definitions = {
 		"enum": [
 			"started",
 			"interacted",
-			"interrupted"
+			"interrupted",
+			"completed"
 		],
 		"type": "string"
 	},
@@ -977,6 +1110,10 @@ var definitions = {
 				"description": "Usually the first user message in the thread, if available.",
 				"type": "string"
 			},
+			"projectId": {
+				"description": "Canonical project assignment owned by app-server, if any.",
+				"type": ["string", "null"]
+			},
 			"recencyAt": {
 				"description": "Unix timestamp (in seconds) used for thread recency ordering.",
 				"format": "int64",
@@ -1028,6 +1165,7 @@ var definitions = {
 			"id",
 			"modelProvider",
 			"preview",
+			"projectId",
 			"sessionId",
 			"source",
 			"status",
@@ -1095,6 +1233,10 @@ var definitions = {
 		},
 		{
 			"properties": {
+				"delivery": {
+					"anyOf": [{ "$ref": "#/definitions/AgentMessageDelivery" }, { "type": "null" }],
+					"default": null
+				},
 				"id": { "type": "string" },
 				"memoryCitation": {
 					"anyOf": [{ "$ref": "#/definitions/MemoryCitation" }, { "type": "null" }],
@@ -1119,6 +1261,27 @@ var definitions = {
 			"title": "AgentMessageThreadItem",
 			"type": "object"
 		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"name": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"output": { "$ref": "#/definitions/FunctionCallOutputBody" },
+				"type": {
+					"enum": ["functionCallOutput"],
+					"title": "FunctionCallOutputThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"name",
+				"output",
+				"type"
+			],
+			"title": "FunctionCallOutputThreadItem",
+			"type": "object"
+		},
 		{
 			"description": "EXPERIMENTAL - proposed plan item content. The completed plan item is authoritative and may not match the concatenation of `PlanDelta` text.",
 			"properties": {
@@ -1469,6 +1632,10 @@ var definitions = {
 		},
 		{
 			"properties": {
+				"failure": {
+					"anyOf": [{ "$ref": "#/definitions/ImageGenerationFailure" }, { "type": "null" }],
+					"default": null
+				},
 				"id": { "type": "string" },
 				"result": { "type": "string" },
 				"revisedPrompt": { "type": ["string", "null"] },
@@ -1546,6 +1713,11 @@ var definitions = {
 	"ThreadSection": {
 		"description": "An independently persisted, user-visible thread section.",
 		"properties": {
+			"appearance": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSectionAppearance" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional appearance synchronized across clients."
+			},
 			"id": {
 				"description": "Opaque UUIDv7 identity that remains stable when the section is renamed.",
 				"type": "string"
@@ -1558,6 +1730,14 @@ var definitions = {
 		"required": ["id", "name"],
 		"type": "object"
 	},
+	"ThreadSectionAppearance": {
+		"description": "Extensible visual presentation for a custom thread section.",
+		"properties": {
+			"color": { "type": ["string", "null"] },
+			"icon": { "type": ["string", "null"] }
+		},
+		"type": "object"
+	},
 	"ThreadSource": { "type": "string" },
 	"ThreadStatus": { "oneOf": [
 		{
@@ -1658,7 +1838,12 @@ var definitions = {
 				"type": ["string", "null"]
 			},
 			"codexErrorInfo": { "anyOf": [{ "$ref": "#/definitions/CodexErrorInfo" }, { "type": "null" }] },
-			"message": { "type": "string" }
+			"message": { "type": "string" },
+			"misalignment": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentErrorDetails" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional public explanation and continuation instruction for a misalignment block."
+			}
 		},
 		"required": ["message"],
 		"type": "object"
@@ -1941,7 +2126,7 @@ var ThreadResumeResponse_default = {
 		},
 		"itemsBackwardsCursor": {
 			"default": null,
-			"description": "Opaque head cursor for hydrating paginated items backwards.\n\nPass this as `cursor` to `thread/items/list` with `sortDirection: \"desc\"`. The first page includes the cursor's head item.",
+			"description": "Opaque cursor for hydrating paginated items backwards.\n\nPass this as `cursor` to `thread/items/list` with `sortDirection: \"desc\"`. The first page includes the item identified by the cursor.",
 			"type": ["string", "null"]
 		},
 		"model": { "type": "string" },
@@ -1966,7 +2151,7 @@ var ThreadResumeResponse_default = {
 		"thread": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Thread" },
 		"turnsBackwardsCursor": {
 			"default": null,
-			"description": "Opaque head cursor for hydrating paginated turns backwards.\n\nPass this as `cursor` to `thread/turns/list` with `sortDirection: \"desc\"`. The first page includes the cursor's head turn.",
+			"description": "Opaque cursor for hydrating paginated turns backwards.\n\nPass this as `cursor` to `thread/turns/list` with `sortDirection: \"desc\"`. The first page includes the turn identified by the cursor.",
 			"type": ["string", "null"]
 		}
 	},
@@ -2248,6 +2433,16 @@ function assertCodexThreadResumeResponse(value) {
 	const normalized = normalizeWithDefaults(threadResumeResponseSchema, value);
 	return assertCodexShape(validateThreadResumeResponse, normalized, "thread/resume response");
 }
+var CodexThreadDirectInputError = class extends Error {
+	constructor(threadId) {
+		super(`Codex thread ${threadId} is controlled by its parent and cannot accept direct input. Continue its parent thread, or use /new for a separate OpenClaw session.`);
+		this.name = "CodexThreadDirectInputError";
+	}
+};
+/** Native V2 children allow observation, but only their parent may supply turn input. */
+function assertCodexThreadAcceptsDirectInput(thread) {
+	if (thread.canAcceptDirectInput === false) throw new CodexThreadDirectInputError(thread.id);
+}
 /** Asserts and normalizes a Codex turn/start response. */
 function assertCodexTurnStartResponse(value) {
 	const normalized = normalizeWithDefaults(turnStartResponseSchema, normalizeTurnStartResponse(value));
@@ -2296,6 +2491,7 @@ function normalizeThreadItem(value) {
 	switch (value.type) {
 		case "agentMessage": return {
 			phase: null,
+			delivery: null,
 			memoryCitation: null,
 			...value
 		};
@@ -2343,4 +2539,4 @@ function formatValidationErrors(validate, value) {
 	}).join("; ");
 }
 //#endregion
-export { assertCodexThreadStartResponse as a, readCodexErrorNotification as c, assertCodexThreadResumeResponse as i, readCodexTurn as l, assertCodexThreadForkParams as n, assertCodexTurnStartResponse as o, assertCodexThreadForkResponse as r, readCodexDynamicToolCallParams as s, assertCodexModelListResponse as t, readCodexTurnCompletedNotification as u };
+export { assertCodexThreadForkResponse as a, assertCodexTurnStartResponse as c, readCodexTurn as d, readCodexTurnCompletedNotification as f, assertCodexThreadForkParams as i, readCodexDynamicToolCallParams as l, assertCodexModelListResponse as n, assertCodexThreadResumeResponse as o, assertCodexThreadAcceptsDirectInput as r, assertCodexThreadStartResponse as s, CodexThreadDirectInputError as t, readCodexErrorNotification as u };

package/dist/{rate-limits-DZXmOL8-.js → rate-limits-hFtzt2Up.js}

@@ -1,4 +1,4 @@
-import { ct as isJsonObject } from "./shared-client-kIBbGjk4.js";
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
 import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";

package/dist/{sandbox-guard-Cmwc9eIk.js → request-CCm4LaED.js}

@@ -1,6 +1,9 @@
-import { C as isCodexRemoteExecPlacementSandbox } from "./session-binding-DPxIvMgE.js";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { C as isCodexRemoteExecPlacementSandbox } from "./config-Cxw3Cl3k.js";
+import { Et as withTimeout, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-kNkljY-R.js";
+import { resolveAgentConfig, tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
+import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/codex/src/app-server/native-execution-policy.ts
 /** Projects node execution ownership into the runtime tool factory options. */
@@ -21,23 +24,26 @@ function resolveCodexNativeExecutionPolicy(params) {
 		sessionKey,
 		agentId: params.agentId
 	});
-	const canReadSessionEntry = params.readRuntimeSessionEntry && shouldReadRuntimeSessionEntry({
+	const canReadSessionEntry = Boolean(agentId) && params.readRuntimeSessionEntry && shouldReadRuntimeSessionEntry({
 		config,
 		sessionKey,
-		agentId: params.agentId
+		agentId
 	});
-	const sessionEntry = params.sessionEntry ?? (canReadSessionEntry && sessionKey ? readRuntimeSessionEntryBestEffort({
+	const sessionEntry = params.sessionEntry ?? (canReadSessionEntry && sessionKey && agentId ? readRuntimeSessionEntryBestEffort({
 		sessionKey,
 		agentId
 	}) : void 0);
-	const sandboxAvailable = params.sandboxAvailable ?? (sessionKey ? resolveSandboxRuntimeStatus({
+	const sandboxAgentId = parseAgentSessionKey(sessionKey)?.agentId ?? agentId;
+	const sandboxAvailable = params.sandboxAvailable ?? (sessionKey && sandboxAgentId ? resolveSandboxRuntimeStatus({
 		cfg: config,
-		sessionKey
+		sessionKey,
+		agentId: sandboxAgentId,
+		classificationAgentId: sandboxAgentId
 	}).sandboxed : false);
-	const agentExec = resolvePolicyAgentExec({
+	const agentExec = agentId ? resolvePolicyAgentExec({
 		config,
 		agentId
-	});
+	}) : void 0;
 	const globalExec = config.tools?.exec;
 	const requestedExecHost = normalizeExecTarget(params.execOverrides?.host) ?? normalizeExecTarget(sessionEntry?.execHost) ?? normalizeExecTarget(agentExec?.host) ?? normalizeExecTarget(globalExec?.host) ?? "auto";
 	const effectiveExecHost = resolveEffectiveExecHost({
@@ -72,13 +78,10 @@ function resolvePolicyAgentId(params) {
 	if (explicitAgentId) return explicitAgentId;
 	const sessionAgentId = parseAgentIdFromSessionKey(params.sessionKey);
 	if (sessionAgentId) return sessionAgentId;
-	return resolveDefaultPolicyAgentId(listAgentEntries(params.config));
+	return tryResolveDefaultAgentId(params.config);
 }
 function resolvePolicyAgentExec(params) {
-	return listAgentEntries(params.config).find((entry) => normalizeAgentId(entry?.id) === params.agentId)?.tools?.exec;
-}
-function listAgentEntries(config) {
-	return (config.agents?.list ?? []).filter((entry) => entry !== null && typeof entry === "object");
+	return resolveAgentConfig(params.config, params.agentId)?.tools?.exec;
 }
 function parseAgentIdFromSessionKey(sessionKey) {
 	const raw = sessionKey?.trim();
@@ -99,10 +102,7 @@ function shouldReadRuntimeSessionEntry(params) {
 	return sessionAgentId === explicitAgentId;
 }
 function isDefaultAgentSessionKeyForAgent(params) {
-	return normalizeAgentId(params.agentId) === resolveDefaultPolicyAgentId(listAgentEntries(params.config));
-}
-function resolveDefaultPolicyAgentId(agents) {
-	return normalizeAgentId((agents.find((entry) => entry?.default) ?? agents[0])?.id);
+	return normalizeAgentId(params.agentId) === tryResolveDefaultAgentId(params.config);
 }
 function normalizeAgentIdOrDefault(value) {
 	const normalized = normalizeAgentId(value);
@@ -129,6 +129,10 @@ function readRuntimeSessionEntryBestEffort(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/sandbox-guard.ts
+/**
+* Blocks direct Codex app-server requests that would bypass OpenClaw sandbox or
+* node-exec routing guarantees.
+*/
 const DIRECT_METHOD_POLICIES = /* @__PURE__ */ new Map([
 	["account/rateLimits/read", "allowed-control-plane"],
 	["account/read", "allowed-control-plane"],
@@ -230,9 +234,13 @@ function resolveCodexNativeSandboxBlock(params) {
 	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
 	if (!sessionKey) return;
 	if (isCodexRemoteExecPlacementSandbox(params.sandbox) || params.sandbox?.enabled === true) return formatCodexNativeSandboxBlock({ surface: params.surface });
+	const sandboxAgentId = parseAgentSessionKey(sessionKey)?.agentId ?? params.agentId ?? tryResolveDefaultAgentId(params.config ?? {});
+	if (!sandboxAgentId) return;
 	if (!resolveSandboxRuntimeStatus({
 		cfg: params.config,
-		sessionKey
+		sessionKey,
+		agentId: sandboxAgentId,
+		classificationAgentId: sandboxAgentId
 	}).sandboxed) return;
 	return formatCodexNativeSandboxBlock({ surface: params.surface });
 }
@@ -273,4 +281,183 @@ function resolveCodexNativeNodeExecBlock(params) {
 	});
 }
 //#endregion
-export { resolveCodexNodeExecToolOverrides as a, resolveCodexNativeExecutionPolicy as i, resolveCodexNativeExecutionBlock as n, resolveCodexNativeSandboxBlock as r, resolveCodexAppServerDirectSandboxBypassBlock as t };
+//#region extensions/codex/src/app-server/request.ts
+var request_exports = /* @__PURE__ */ __exportAll({
+	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
+	readCodexAppServerUsage: () => readCodexAppServerUsage,
+	requestCodexAppServerClientJson: () => requestCodexAppServerClientJson,
+	requestCodexAppServerJson: () => requestCodexAppServerJson,
+	withCodexAppServerJsonClient: () => withCodexAppServerJsonClient
+});
+/** 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
+	}));
+}
+/** A scoped guard rejected the request before it reached the physical client. */
+var CodexAppServerScopedRequestRejectedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodexAppServerScopedRequestRejectedError";
+	}
+};
+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 CodexAppServerScopedRequestRejectedError(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,
+					authProfileStore: params.authProfileStore,
+					authBindingFingerprint: params.authBindingFingerprint,
+					preparedAuth: params.preparedAuth,
+					authRequirement: params.authRequirement,
+					agentDir: params.agentDir,
+					config: params.config,
+					abandonSignal: timeoutController.signal
+				});
+				let scopeActive = true;
+				const assertCurrent = () => {
+					throwIfAbandoned();
+					if (!scopeActive) throw new CodexAppServerScopedRequestRejectedError("Codex app-server request scope is closed");
+				};
+				try {
+					assertCurrent();
+					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 CodexAppServerScopedRequestRejectedError(sandboxBlock);
+						assertCurrent();
+						return await client.request(request.method, request.requestParams, {
+							timeoutMs: remainingTimeoutMs(),
+							signal: timeoutController.signal,
+							assertCurrent
+						});
+					};
+					return await run(scopedRequest, client, { assertCurrent });
+				} catch (error) {
+					if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
+					if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
+					throwIfAbandoned();
+				} finally {
+					scopeActive = false;
+					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 { request_exports as a, resolveCodexNativeSandboxBlock as c, requestCodexAppServerJson as i, resolveCodexNativeExecutionPolicy as l, readCodexAppServerUsage as n, withCodexAppServerJsonClient as o, requestCodexAppServerClientJson as r, resolveCodexNativeExecutionBlock as s, CodexAppServerScopedRequestRejectedError as t, resolveCodexNodeExecToolOverrides as u };