@openclaw/codex 2026.9.1-beta.1 → 2026.9.1

package/dist/{node-exec-server.runtime-BpWqJO1V.js → node-exec-server.runtime-CstNHCmC.js}

@@ -1,6 +1,5 @@
-import { W as closeCodexAppServerTransportAndWait } from "./shared-client-DKz23hHY.js";
-import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-DFYK4DWq.js";
-import { t as createStdioTransport } from "./transport-stdio-DhoGy33Z.js";
+import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-4-Vjz5GH.js";
+import { i as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-CyPldczm.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
@@ -9,7 +8,7 @@ import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";
 import { once } from "node:events";
 import { sanitizeEnvVars } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/codex/src/node-exec-server.runtime.ts
-const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 64 * 1024 * 1024;
+const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 67108864;
 const CODEX_EXEC_SERVER_TERMINATION_GRACE_MS = 1e3;
 const CODEX_EXEC_SERVER_REAP_TIMEOUT_MS = 5e3;
 const NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT = /^(?:SYSTEMROOT|WINDIR|COMSPEC|PATHEXT|TEMP|TMP|TMPDIR)$/iu;
@@ -125,7 +124,8 @@ async function runCodexNodeExecServer(params) {
 				customAllowedPatterns: [NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT]
 			}).allowed;
 			if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
-			const child = createStdioTransport({
+			params.assertExecAuthorized();
+			const child = await createStdioTransport({
 				transport: "stdio",
 				command: native,
 				commandSource: "resolved-managed",
@@ -138,7 +138,10 @@ async function runCodexNodeExecServer(params) {
 					...process.platform === "win32" ? { USERPROFILE: dir } : {}
 				},
 				clearEnv: ["NODE_OPTIONS"]
-			}, baseEnv);
+			}, baseEnv, () => {
+				if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+				params.assertExecAuthorized();
+			});
 			child.stdin.on("error", (error) => {
 				rejectDisconnected(error);
 			});

package/dist/{plugin-approval-roundtrip-bUm777tR.js → plugin-approval-roundtrip-CNe-Xrjx.js}

@@ -1,10 +1,10 @@
-import { D as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-DKz23hHY.js";
+import { N as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-DxcfF9KX.js";
 import { isApprovalNotFoundError, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
 const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
 const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
-const MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH = 256;
+const MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH = 512;
 const ANSI_OSC_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b]|\u009d)[^\u001b\u009c\u0007]*(?:\u0007|\u001b\\|\u009c)`, "g");
 const ANSI_CONTROL_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b\[[0-?]*[ -/]*[@-~]|\u009b[0-?]*[ -/]*[@-~]|\u001b[@-Z\\-_])`, "g");
 const CONTROL_CHARACTER_RE = new RegExp(String.raw`[\u0000-\u001f\u007f-\u009f]+`, "g");
@@ -23,11 +23,16 @@ function codexApprovalTimeoutText(kind) {
 async function requestPluginApproval(params) {
 	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
 	return params.hostCapabilities.requestApproval({
+		signal: params.signal,
 		title: truncateCodexApprovalDisplayText(params.title, MAX_PLUGIN_APPROVAL_TITLE_LENGTH),
 		description: truncateCodexApprovalDisplayText(params.description, MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH),
 		severity: params.severity,
 		toolName: params.toolName,
 		toolCallId: params.toolCallId,
+		...params.mcpTool ? {
+			mcpTool: params.mcpTool,
+			isMcpToolApprovalActive: params.isMcpToolApprovalActive
+		} : {},
 		timeoutMs,
 		transportTimeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs),
 		...params.allowedDecisions ? { allowedDecisions: params.allowedDecisions } : {}
@@ -81,6 +86,28 @@ function mapExecDecisionToOutcome(decision) {
 		default: return "unavailable";
 	}
 }
+/** Runs one complete host approval request and maps transport failures to a closed outcome. */
+async function requestPluginApprovalOutcome(params) {
+	try {
+		const requestResult = await requestPluginApproval({
+			...params,
+			severity: "warning"
+		});
+		const approvalId = requestResult?.id;
+		if (!approvalId) return "unavailable";
+		const approvalResult = approvalRequestExplicitlyUnavailable(requestResult) ? void 0 : await waitForPluginApprovalDecision({
+			hostCapabilities: params.hostCapabilities,
+			approvalId,
+			signal: params.signal
+		});
+		if (params.signal?.aborted) return "cancelled";
+		if (approvalResult?.terminalReason === "timeout") return "timed-out";
+		const decision = approvalResult?.decision;
+		return mapExecDecisionToOutcome(decision === "allow-always" && params.allowedDecisions?.includes("allow-always") === false ? "allow-once" : decision);
+	} catch {
+		return params.signal?.aborted ? "cancelled" : "denied";
+	}
+}
 function truncateCodexApprovalDisplayText(value, maxLength) {
 	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
 }
@@ -92,4 +119,4 @@ function sanitizeCodexApprovalVisibleText(value, options = {}) {
 	return (options.stripDanglingTerminalSequence ? stripDanglingCodexApprovalTerminalSequence(terminalSafe) : terminalSafe).replace(INVISIBLE_FORMATTING_CONTROL_RE, " ").replace(CONTROL_CHARACTER_RE, " ").replace(/\s+/g, " ").trim();
 }
 //#endregion
-export { sanitizeCodexApprovalVisibleText as a, waitForPluginApprovalDecision as c, requestPluginApproval as i, codexApprovalTimeoutText as n, stripDanglingCodexApprovalTerminalSequence as o, mapExecDecisionToOutcome as r, truncateCodexApprovalDisplayText as s, approvalRequestExplicitlyUnavailable as t };
+export { requestPluginApprovalOutcome as a, truncateCodexApprovalDisplayText as c, requestPluginApproval as i, waitForPluginApprovalDecision as l, codexApprovalTimeoutText as n, sanitizeCodexApprovalVisibleText as o, mapExecDecisionToOutcome as r, stripDanglingCodexApprovalTerminalSequence as s, approvalRequestExplicitlyUnavailable as t };

package/dist/{plugin-marketplace-discovery-B9DvaAG-.js → plugin-marketplace-discovery-CfFlKqDl.js}

@@ -1,9 +1,9 @@
-import { N as isCodexFastServiceTier } from "./config-giW8X0QA.js";
-import { o as getLeasedSharedCodexAppServerClient, p as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DKz23hHY.js";
-import { o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-Bcynfd-_.js";
-import { B as resolveCodexAppServerRequestModelSelection, H as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-L7oEkTlq.js";
-import { r as formatCodexDisplayText } from "./command-formatters-DEsIufkt.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-BMvPX73o.js";
+import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DxcfF9KX.js";
+import { A as isCodexFastServiceTier } from "./config-BhmfC1s6.js";
+import { o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-BHuTCRZQ.js";
+import { E as resolveCodexAppServerRequestModelSelection, O as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-DAcEJ_Om.js";
+import { a as formatCodexDisplayText } from "./command-formatters-CLHhEB1Q.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-E6uDsPlx.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
 import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
@@ -127,15 +127,16 @@ async function setCodexConversationModel(params) {
 	const lookup = buildBindingLookup(params);
 	const binding = await requireThreadBinding(params.bindingStore, params.identity);
 	if (binding.connectionScope === "supervision") throw new ModelSelectionLockedError();
+	const modelProvider = resolveConversationControlModelProvider({
+		authProfileId: binding.authProfileId,
+		bindingModel: binding.model,
+		bindingModelProvider: binding.modelProvider,
+		currentModel: model,
+		...lookup
+	});
 	const modelSelection = resolveCodexAppServerRequestModelSelection({
 		model,
-		modelProvider: resolveConversationControlModelProvider({
-			authProfileId: binding.authProfileId,
-			bindingModel: binding.model,
-			bindingModelProvider: binding.modelProvider,
-			currentModel: model,
-			...lookup
-		}),
+		modelProvider,
 		authProfileId: binding.authProfileId,
 		...lookup
 	});
@@ -214,7 +215,7 @@ async function setCodexConversationPermissions(params) {
 			return entry;
 		}
 	})) throw new Error("Codex session changed while applying the permission mode.");
-	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "default"}.`;
+	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "guarded"}.`;
 }
 function parseCodexFastModeArg(arg) {
 	const normalized = arg?.trim().toLowerCase();

package/dist/{plugin-metadata-cache-CTCT3w5L.js → plugin-metadata-cache-BFrPhb2c.js}

@@ -1,8 +1,8 @@
-import { i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-giW8X0QA.js";
-import { L as isCodexAppServerConnectionClosedError, R as isCodexAppServerIndeterminateRequestCancellationError, S as acquireCodexNativeConfigFence, b as waitForCodexAppServerClientDesktopGenerationDrain, bt as assertNotSymlink, c as isCodexAppServerStartSelectionChangedError, d as readCodexAppServerClientProcessIdentity, l as readCodexAppServerClientDesktopGeneration, m as resolveCodexNativeConfigFenceKey, o as getLeasedSharedCodexAppServerClient, p as releaseLeasedSharedCodexAppServerClient, st as reconcileCodexComputerUseStartArtifacts, t as assertCodexAppServerClientStartSelectionCurrent, xt as resolveCodexAppServerHomeDir, yt as resolveCodexManagedBundledMarketplacePath, z as isCodexAppServerIndeterminateTransportError } from "./shared-client-DKz23hHY.js";
-import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-DFYK4DWq.js";
-import { n as describeControlFailure } from "./capabilities-BRMh0aIq.js";
-import { r as requestCodexAppServerJson } from "./request-DXXGHko0.js";
+import { B as isCodexAppServerIndeterminateRequestCancellationError, D as acquireCodexNativeConfigFence, Gt as resolveCodexManagedBundledMarketplacePath, Kt as assertNotSymlink, Lt as reconcileCodexComputerUseStartArtifacts, S as waitForCodexAppServerClientDesktopGenerationDrain, V as isCodexAppServerIndeterminateTransportError, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, z as isCodexAppServerConnectionClosedError } from "./shared-client-DxcfF9KX.js";
+import { F as resolveCodexAppServerHomeDir, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-BhmfC1s6.js";
+import { c as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexBundledMarketplaceCandidates } from "./managed-binary-4-Vjz5GH.js";
+import { i as requestCodexAppServerJson } from "./request-DYAI5FQE.js";
+import { n as describeControlFailure } from "./capabilities-dIjNVCYH.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -721,7 +721,7 @@ function resolveComputerUseConfig(params) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/plugin-metadata-cache.ts
-const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 3600 * 1e3;
+const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 36e5;
 /** Process-local plugin metadata cache with coalesced loads per query. */
 var CodexPluginMetadataCache = class {
 	constructor(nowMs = Date.now) {

package/dist/provider-capabilities-DW5p4k9w.js

@@ -0,0 +1,101 @@
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DxcfF9KX.js";
+import { ut as normalizeCodexDynamicToolName } from "./thread-lifecycle-DAcEJ_Om.js";
+import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
+import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
+//#region extensions/codex/src/app-server/shell-dynamic-tools.ts
+const CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME = "node_exec";
+const CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME = "gateway_exec";
+const CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME = "gateway_process";
+const PROCESS_FOLLOWUP_TEXT = "Use process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.";
+/** Returns true when plugin config explicitly removes any named dynamic tool. */
+function isCodexDynamicToolExcluded(config, names) {
+	const normalizedNames = new Set(names.map((name) => normalizeCodexDynamicToolName(name)));
+	return (config.codexDynamicToolsExclude ?? []).some((name) => normalizedNames.has(normalizeCodexDynamicToolName(name)));
+}
+async function createNodeExecAliasDynamicTool(execTool, node, discoverySignal, availabilityRef) {
+	const pinnedNode = node?.trim();
+	const availability = await (availabilityRef ? availabilityRef.current ??= loadNodeExecAvailability(discoverySignal) : loadNodeExecAvailability(discoverySignal));
+	discoverySignal?.throwIfAborted();
+	if (!availability.isAvailable(pinnedNode)) return;
+	const pinnedTool = pinExecToolTarget(execTool, {
+		host: "node",
+		...pinnedNode ? { node: pinnedNode } : {}
+	});
+	const execute = async (toolCallId, args, signal, onUpdate) => {
+		const result = await pinnedTool.execute(toolCallId, args, signal, onUpdate);
+		return {
+			...result,
+			content: result.content.map((item) => item.type === "text" ? Object.assign({}, item, { text: item.text.replace(PROCESS_FOLLOWUP_TEXT, "Remote-node background follow-up is unavailable. Wait for the command to complete.") }) : item)
+		};
+	};
+	return {
+		...pinnedTool,
+		name: CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME,
+		description: pinnedNode ? "Run a shell command to completion on the OpenClaw configured remote node for this session. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available." : "Run a shell command to completion on an OpenClaw remote node. The sole connected node that can execute commands is selected automatically; select by name or id when several can. This tool always uses OpenClaw host=node internally and follows the existing node exec approval and allowlist policy. Remote-node background follow-up is unavailable. Use Codex's native shell for local app-server work when it is available.",
+		execute
+	};
+}
+function createGatewayExecProjection(createProjection, execTool, params) {
+	return createProjection(execTool, {
+		kind: "exec",
+		name: CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME,
+		description: "Run a shell command through OpenClaw on the Gateway host for OpenClaw-managed Gateway environment access, including Secret Store agent-readable environment values and protected egress sentinels. Native Codex shell remains preferred for ordinary local work. This tool always uses OpenClaw host=gateway internally and follows Gateway exec approval and allowlist policy.",
+		followupText: params.processAliasAvailable ? "Use gateway_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up." : "Background session follow-up is unavailable because gateway_process is not exposed. Rerun without background=true and set yieldMs high enough to wait for completion.",
+		...params.ask ? { ask: params.ask } : {}
+	});
+}
+function createGatewayProcessProjection(createProjection, processTool) {
+	return createProjection(processTool, {
+		kind: "process",
+		name: CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME,
+		description: "Manage background shell sessions in the existing per-session OpenClaw process scope: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use for gateway_exec follow-up; use native Codex shell session handling for ordinary local work."
+	});
+}
+//#endregion
+//#region extensions/codex/src/app-server/provider-capabilities.ts
+function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
+	const provider = modelProviderOverride?.trim().toLowerCase();
+	if (!provider) return;
+	return provider === "openai" ? "supported" : "unsupported";
+}
+async function readConfiguredProviderWebSearchSupport(params) {
+	return (await params.client.request("modelProvider/capabilities/read", {}, {
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	})).webSearch ? "supported" : "unsupported";
+}
+async function resolveCodexProviderWebSearchSupportForClient(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	try {
+		return await readConfiguredProviderWebSearchSupport(params);
+	} catch {
+		return "unknown";
+	}
+}
+async function resolveCodexProviderWebSearchSupport(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	let client;
+	try {
+		client = await params.clientFactory({
+			startOptions: params.appServer.start,
+			...params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.authProfileId },
+			agentDir: params.agentDir,
+			config: params.config,
+			timeoutMs: params.appServer.requestTimeoutMs
+		});
+		return await resolveCodexProviderWebSearchSupportForClient({
+			client,
+			timeoutMs: params.appServer.requestTimeoutMs,
+			modelProviderOverride: params.modelProviderOverride,
+			signal: params.signal
+		});
+	} catch {
+		return "unknown";
+	} finally {
+		if (client) releaseLeasedSharedCodexAppServerClient(client);
+	}
+}
+//#endregion
+export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, isCodexDynamicToolExcluded as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t };

package/dist/{rate-limits-C5_D8Gmb.js → rate-limits-CawQJfUS.js}

@@ -1,4 +1,4 @@
-import { vt as isJsonObject } from "./shared-client-DKz23hHY.js";
+import { $t as isJsonObject } from "./shared-client-DxcfF9KX.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";
@@ -186,8 +186,9 @@ function isRateLimitSnapshot(value) {
 function readRateLimitWindow(snapshot, key) {
 	const window = snapshot[key];
 	if (!isJsonObject(window)) return;
+	const resetsAt = asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at);
 	return {
-		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(asFiniteNumber(window.resetsAt) ?? asFiniteNumber(window.resets_at), { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
+		resetsAtMs: resolveExpiresAtMsFromEpochSeconds(resetsAt, { maxMs: MAX_DATE_TIMESTAMP_MS }) ?? 0,
 		...readOptionalNumberField(window, "usedPercent", "used_percent"),
 		...readOptionalNumberField(window, "windowDurationMins", "window_duration_mins", "windowMinutes", "window_minutes")
 	};

package/dist/{sandbox-guard-kuWTn9C5.js → request-DYAI5FQE.js}

@@ -1,4 +1,6 @@
-import { p as isCodexRemoteExecPlacementSandbox } from "./config-giW8X0QA.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { Nt as withTimeout, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient, s as createIsolatedCodexAppServerClient, u as isCodexAppServerStartSelectionChangedError, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-DxcfF9KX.js";
+import { w as isCodexRemoteExecPlacementSandbox } from "./config-BhmfC1s6.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";
@@ -279,4 +281,195 @@ 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,
+		signal: params.signal,
+		...params.assertCurrent ? { assertCurrent: () => assertRequestOwnerCurrent(params.assertCurrent) } : {}
+	}), 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 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 = 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");
+					assertRequestOwnerCurrent(params.assertCurrent);
+				};
+				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 };