@openclaw/codex 2026.6.5-beta.6 → 2026.6.6-beta.1

package/dist/{client-kMCtlApt.js → client-DovmVtbr.js}

@@ -1,4 +1,5 @@
-import { l as resolveCodexAppServerRuntimeOptions } from "./config-BT6SLiE6.js";
+import { d as resolveCodexAppServerRuntimeOptions } from "./config-DJXpBkGf.js";
+import { n as isRpcResponse } from "./protocol-oeJQu4rs.js";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createInterface } from "node:readline";
@@ -6,14 +7,6 @@ import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { PassThrough, Writable } from "node:stream";
 import WebSocket from "ws";
-//#region extensions/codex/src/app-server/protocol.ts
-function isJsonObject$1(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
-}
-//#endregion
 //#region extensions/codex/src/app-server/transport-stdio.ts
 /**
 * Creates and configures stdio-backed Codex app-server transports, including
@@ -711,4 +704,4 @@ function formatExitValue(value) {
 	return "unknown";
 }
 //#endregion
-export { isCodexAppServerConnectionClosedError as a, resolveCodexAppServerSpawnEnv as c, isCodexAppServerApprovalRequest as i, isJsonObject$1 as l, CodexAppServerRpcError as n, MANAGED_CODEX_APP_SERVER_PACKAGE as o, compareCodexAppServerVersions as r, MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION as s, CodexAppServerClient as t };
+export { isCodexAppServerConnectionClosedError as a, resolveCodexAppServerSpawnEnv as c, isCodexAppServerApprovalRequest as i, CodexAppServerRpcError as n, MANAGED_CODEX_APP_SERVER_PACKAGE as o, compareCodexAppServerVersions as r, MIN_CODEX_SANDBOX_EXEC_SERVER_APP_SERVER_VERSION as s, CodexAppServerClient as t };

package/dist/{client-factory-Bt49r45B.js → client-factory-XajDuvQ1.js}

@@ -1,7 +1,7 @@
 //#region extensions/codex/src/app-server/client-factory.ts
 let sharedClientModulePromise = null;
 const loadSharedClientModule = async () => {
-	sharedClientModulePromise ??= import("./shared-client-xytpSKD0.js").then((n) => n.c);
+	sharedClientModulePromise ??= import("./shared-client-CflavQ_i.js").then((n) => n.c);
 	return await sharedClientModulePromise;
 };
 /** Returns a leased shared client so startup can release ownership explicitly. */

package/dist/{command-handlers-DMn2M7W7.js → command-handlers-DIUFKqaF.js}

@@ -1,17 +1,19 @@
-import { a as isCodexFastServiceTier, l as resolveCodexAppServerRuntimeOptions } from "./config-BT6SLiE6.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-DXorTaja.js";
-import { l as isJsonObject } from "./client-kMCtlApt.js";
-import { a as readCodexAppServerBinding, s as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-BgTv_YGm.js";
-import { i as describeControlFailure, r as CODEX_CONTROL_METHODS, t as requestCodexAppServerJson } from "./request-D64BfplD.js";
-import { a as buildHelp, c as formatCodexStatus, d as formatModels, f as formatSkills, l as formatComputerUseStatus, m as readString$1, o as formatAccount, p as formatThreads, s as formatCodexDisplayText, u as formatList, v as summarizeCodexAccountUsage } from "./notification-correlation-o8quHmTK.js";
+import { d as resolveCodexAppServerRuntimeOptions, o as isCodexFastServiceTier } from "./config-DJXpBkGf.js";
+import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-CQGfP7nG.js";
+import { t as isJsonObject } from "./protocol-oeJQu4rs.js";
+import { l as summarizeCodexAccountUsage } from "./provider-Cs6kWhDQ.js";
+import { l as writeCodexAppServerBinding, n as clearCodexAppServerBinding, o as readCodexAppServerBinding } from "./session-binding-ElbcSq2o.js";
+import { n as CODEX_CONTROL_METHODS, r as describeControlFailure } from "./plugin-app-cache-key-NpzxEcSR.js";
+import { c as formatAccount, d as formatComputerUseStatus, f as formatList, g as readString$1, h as formatThreads, l as formatCodexDisplayText, m as formatSkills, p as formatModels, s as buildHelp, u as formatCodexStatus } from "./notification-correlation-D-MYfJwV.js";
 import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-C-Yv9uwY.js";
-import { _ as steerCodexConversationTurn, b as readCodexConversationBindingData, d as parseCodexFastModeArg, f as parseCodexPermissionsModeArg, g as setCodexConversationPermissions, h as setCodexConversationModel, m as setCodexConversationFastMode, o as formatCodexCliSessions, p as readCodexConversationActiveTurn, r as startCodexConversationThread, u as formatPermissionsMode, v as stopCodexConversationTurn, x as resolveCodexDefaultWorkspaceDir, y as createCodexCliNodeConversationBindingData } from "./conversation-binding-CzpvaBs1.js";
-import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-ClweWaMz.js";
+import { _ as steerCodexConversationTurn, b as readCodexConversationBindingData, d as parseCodexFastModeArg, f as parseCodexPermissionsModeArg, g as setCodexConversationPermissions, h as setCodexConversationModel, m as setCodexConversationFastMode, o as formatCodexCliSessions, p as readCodexConversationActiveTurn, r as startCodexConversationThread, u as formatPermissionsMode, v as stopCodexConversationTurn, x as resolveCodexDefaultWorkspaceDir, y as createCodexCliNodeConversationBindingData } from "./conversation-binding-CMwrZrt7.js";
+import { t as requestCodexAppServerJson } from "./request-Dq0LUOqZ.js";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-D3pi5csE.js";
 import { n as rememberCodexRateLimits } from "./rate-limit-cache-C7qmZ0Jh.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import crypto from "node:crypto";
-import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAgentDir, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
+import { normalizeOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-account.ts
 const OPENAI_PROVIDER_ID = "openai";
 const OPENAI_CODEX_PROVIDER_ID = OPENAI_PROVIDER_ID;

package/dist/{compact-CwnPeYnM.js → compact-BWiNkDSs.js}

@@ -1,8 +1,8 @@
-import { l as resolveCodexAppServerRuntimeOptions } from "./config-BT6SLiE6.js";
-import { a as readCodexAppServerBinding } from "./session-binding-BgTv_YGm.js";
-import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-xytpSKD0.js";
+import { d as resolveCodexAppServerRuntimeOptions } from "./config-DJXpBkGf.js";
+import { c as withCodexAppServerBindingLock, l as writeCodexAppServerBinding, o as readCodexAppServerBinding, t as CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS } from "./session-binding-ElbcSq2o.js";
+import { o as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CflavQ_i.js";
 import { n as resolveCodexNativeExecutionBlock } from "./sandbox-guard-C-Yv9uwY.js";
-import { t as defaultLeasedCodexAppServerClientFactory } from "./client-factory-Bt49r45B.js";
+import { t as defaultLeasedCodexAppServerClientFactory } from "./client-factory-XajDuvQ1.js";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 /**
@@ -71,7 +71,7 @@ function readRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 async function compactCodexNativeThread(params, options = {}) {
-	if (params.trigger !== "manual") {
+	if (params.trigger !== "manual" && !options.allowNonManualNativeRequest) {
 		embeddedAgentLog.info("skipping codex app-server compaction for non-manual trigger", {
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
@@ -106,11 +106,12 @@ async function compactCodexNativeThread(params, options = {}) {
 		reason: nativeExecutionBlock
 	};
 	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const binding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
-	if (!binding?.threadId) return failedCodexThreadBindingCompactionResult(params, {
+	const initialBinding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
+	if (!initialBinding?.threadId) return failedCodexThreadBindingCompactionResult(params, {
 		reason: "no codex app-server thread binding",
 		recovery: "missing_thread_binding"
 	});
+	let binding = initialBinding;
 	const requestedAuthProfileId = params.authProfileId?.trim() || void 0;
 	if (requestedAuthProfileId && binding.authProfileId && binding.authProfileId !== requestedAuthProfileId) return {
 		ok: false,
@@ -120,7 +121,47 @@ async function compactCodexNativeThread(params, options = {}) {
 	const shouldReleaseDefaultLease = !options.clientFactory;
 	const client = await (options.clientFactory ?? defaultLeasedCodexAppServerClientFactory)(appServer.start, requestedAuthProfileId ?? binding.authProfileId, params.agentDir, params.config);
 	try {
-		await client.request("thread/compact/start", { threadId: binding.threadId });
+		if (options.allowNonManualNativeRequest) {
+			const guardedResult = await withCodexAppServerBindingLock(params.sessionFile, async () => {
+				const currentBinding = await readCodexAppServerBinding(params.sessionFile, { config: params.config });
+				if (params.abortSignal?.aborted) return {
+					started: false,
+					result: skippedCodexNativeCompactionResult(params, {
+						reason: "codex app-server compaction aborted before native compaction",
+						code: "aborted_before_native_compaction",
+						expectedThreadId: binding.threadId,
+						currentThreadId: currentBinding?.threadId
+					})
+				};
+				if (!currentBinding || !isSameNativeCompactionBinding(currentBinding, binding)) {
+					embeddedAgentLog.warn("skipping codex app-server compaction because the thread binding changed", {
+						sessionId: params.sessionId,
+						sessionKey: params.sessionKey,
+						expectedThreadId: binding.threadId,
+						currentThreadId: currentBinding?.threadId
+					});
+					return {
+						started: false,
+						result: skippedCodexNativeCompactionResult(params, {
+							reason: "codex app-server binding changed before native compaction",
+							code: "binding_changed_before_native_compaction",
+							expectedThreadId: binding.threadId,
+							currentThreadId: currentBinding?.threadId
+						})
+					};
+				}
+				binding = currentBinding;
+				await clearContextEngineProjectionBeforeNativeCompaction({
+					sessionId: params.sessionId,
+					sessionFile: params.sessionFile,
+					binding,
+					config: params.config
+				});
+				await client.request("thread/compact/start", { threadId: binding.threadId }, { timeoutMs: Math.min(appServer.requestTimeoutMs, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS) });
+				return { started: true };
+			});
+			if (!guardedResult.started) return guardedResult.result;
+		} else await client.request("thread/compact/start", { threadId: binding.threadId });
 		embeddedAgentLog.info("started codex app-server compaction", {
 			sessionId: params.sessionId,
 			threadId: binding.threadId
@@ -149,7 +190,11 @@ async function compactCodexNativeThread(params, options = {}) {
 		backend: "codex-app-server",
 		threadId: binding.threadId,
 		signal: "thread/compact/start",
-		pending: true
+		pending: true,
+		...options.allowNonManualNativeRequest ? {
+			request: "after_context_engine",
+			trigger: params.trigger ?? "unknown"
+		} : {}
 	};
 	return {
 		ok: true,
@@ -162,6 +207,27 @@ async function compactCodexNativeThread(params, options = {}) {
 		}
 	};
 }
+function skippedCodexNativeCompactionResult(params, skipped) {
+	return {
+		ok: true,
+		compacted: false,
+		reason: skipped.reason,
+		result: {
+			summary: "",
+			firstKeptEntryId: "",
+			tokensBefore: params.currentTokenCount ?? 0,
+			details: {
+				backend: "codex-app-server",
+				skipped: true,
+				reason: skipped.code,
+				request: "after_context_engine",
+				trigger: params.trigger ?? "unknown",
+				...skipped.expectedThreadId ? { expectedThreadId: skipped.expectedThreadId } : {},
+				...skipped.currentThreadId ? { currentThreadId: skipped.currentThreadId } : {}
+			}
+		}
+	};
+}
 function failedCodexThreadBindingCompactionResult(params, recovery) {
 	embeddedAgentLog.warn("codex app-server compaction could not use thread binding", {
 		sessionId: params.sessionId,
@@ -180,6 +246,27 @@ function failedCodexThreadBindingCompactionResult(params, recovery) {
 		}
 	};
 }
+async function clearContextEngineProjectionBeforeNativeCompaction(params) {
+	const contextEngineBinding = params.binding.contextEngine;
+	if (!contextEngineBinding?.projection) return;
+	await writeCodexAppServerBinding(params.sessionFile, {
+		...params.binding,
+		contextEngine: {
+			...contextEngineBinding,
+			projection: void 0
+		},
+		createdAt: params.binding.createdAt
+	}, { config: params.config });
+	embeddedAgentLog.info("cleared codex context-engine projection before native compaction", {
+		sessionId: params.sessionId,
+		threadId: params.binding.threadId,
+		previousEpoch: contextEngineBinding.projection.epoch,
+		previousFingerprint: contextEngineBinding.projection.fingerprint
+	});
+}
+function isSameNativeCompactionBinding(current, expected) {
+	return current.threadId === expected.threadId && current.authProfileId === expected.authProfileId && current.contextEngine?.engineId === expected.contextEngine?.engineId && current.contextEngine?.policyFingerprint === expected.contextEngine?.policyFingerprint && current.contextEngine?.projection?.mode === expected.contextEngine?.projection?.mode && current.contextEngine?.projection?.epoch === expected.contextEngine?.projection?.epoch && current.contextEngine?.projection?.fingerprint === expected.contextEngine?.projection?.fingerprint;
+}
 function isCodexThreadNotFoundError(error) {
 	return formatCompactionError(error).toLowerCase().includes("thread not found");
 }

package/dist/{computer-use-ClweWaMz.js → computer-use-D3pi5csE.js}

@@ -1,5 +1,6 @@
-import { l as resolveCodexAppServerRuntimeOptions, u as resolveCodexComputerUseConfig } from "./config-BT6SLiE6.js";
-import { i as describeControlFailure, t as requestCodexAppServerJson } from "./request-D64BfplD.js";
+import { d as resolveCodexAppServerRuntimeOptions, f as resolveCodexComputerUseConfig } from "./config-DJXpBkGf.js";
+import { r as describeControlFailure } from "./plugin-app-cache-key-NpzxEcSR.js";
+import { t as requestCodexAppServerJson } from "./request-Dq0LUOqZ.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts
 /**

package/dist/{config-BT6SLiE6.js → config-DJXpBkGf.js}

@@ -2,6 +2,8 @@ import { resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtim
 import { createHmac, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
+import path from "node:path";
+import { resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
 import { resolveExecApprovalsFromFile } from "openclaw/plugin-sdk/exec-approvals-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { normalizeTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -12,6 +14,8 @@ const START_OPTIONS_KEY_SECRET_SYMBOL = Symbol.for("openclaw.codexAppServerStart
 const START_OPTIONS_KEY_SECRET = getStartOptionsKeySecret();
 const UNIX_CODEX_REQUIREMENTS_PATH = "/etc/codex/requirements.toml";
 const WINDOWS_CODEX_REQUIREMENTS_SUFFIX = "\\OpenAI\\Codex\\requirements.toml";
+const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
+const CODEX_CONFIG_TOML_FILENAME = "config.toml";
 const PLAIN_DECIMAL_NUMBER_RE = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))$/;
 const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";
 function shouldAutoApproveCodexAppServerApprovals(appServer) {
@@ -160,21 +164,31 @@ function resolveCodexAppServerRuntimeOptions(params = {}) {
 	const explicitApprovalsReviewer = resolveApprovalsReviewer(config.approvalsReviewer);
 	const normalizedPolicyMode = resolveCodexPolicyModeForOpenClawExecMode(execMode);
 	const ignoreLegacyYoloPolicyMode = normalizedPolicyMode === "guardian" && explicitPolicyMode === "yolo";
-	const forceUserReviewer = execMode !== void 0 && execMode !== "auto" && execMode !== "full";
-	const forceGuardianReviewer = execMode === "auto";
+	const canUseModelBackedReviewer = canUseCodexModelBackedApprovalsReviewerForModel({
+		modelProvider: params.modelProvider,
+		model: params.model,
+		config: params.config,
+		env,
+		agentDir: params.agentDir,
+		codexConfigToml: params.codexConfigToml
+	});
+	const forceUserReviewer = !canUseModelBackedReviewer && (explicitApprovalsReviewer === "auto_review" || explicitApprovalsReviewer === "guardian_subagent" || explicitPolicyMode === "guardian" && explicitApprovalsReviewer !== "user") || execMode !== void 0 && execMode !== "full" && (execMode !== "auto" || !canUseModelBackedReviewer);
+	const forceGuardianReviewer = execMode === "auto" && canUseModelBackedReviewer;
+	const execModeRequiringPromptingApprovals = execMode === "auto" || execMode === "ask" ? execMode : forceUserReviewer ? "ask" : void 0;
 	const forceDangerFullAccessSandbox = params.execPolicy?.touched === true && params.execPolicy.security === "full" && params.execPolicy.ask === "always";
 	const forceRuntimePolicy = forceUserReviewer || forceGuardianReviewer || forceDangerFullAccessSandbox;
 	const defaultPolicy = explicitPolicyMode && !forceRuntimePolicy && !ignoreLegacyYoloPolicyMode ? void 0 : resolveDefaultCodexAppServerPolicy({
 		transport,
 		env,
 		forceGuardian: normalizedPolicyMode === "guardian",
-		forceUserReviewer,
-		execModeRequiringPromptingApprovals: execMode === "auto" || execMode === "ask" ? execMode : void 0,
+		forceUserReviewer: forceUserReviewer || !canUseModelBackedReviewer,
+		execModeRequiringPromptingApprovals,
 		requirementsToml: params.requirementsToml,
 		requirementsPath: params.requirementsPath,
 		readRequirementsFile: params.readRequirementsFile,
 		platform: params.platform,
-		hostName: params.hostName
+		hostName: params.hostName,
+		execModeRequiringUserReviewer: forceUserReviewer ? execMode : void 0
 	});
 	const preserveExplicitAutoSandbox = forceGuardianReviewer && configuredSandbox === "read-only";
 	const forcedPolicy = forceRuntimePolicy ? {
@@ -228,6 +242,48 @@ function isCodexAppServerApprovalPolicyAllowedByRequirements(policy, params = {}
 	const allowedApprovalPolicies = parseAllowedApprovalPoliciesFromCodexRequirements(content);
 	return allowedApprovalPolicies === void 0 || allowedApprovalPolicies.has(policy);
 }
+function canUseCodexModelBackedApprovalsReviewerForModel(params) {
+	const explicitProvider = params.modelProvider?.trim().toLowerCase();
+	const inferredProvider = inferProviderFromModelRef(params.model);
+	if (explicitProvider && explicitProvider !== "codex") return isTrustedCodexModelBackedApprovalsReviewerProvider(explicitProvider, params) && (inferredProvider === void 0 || isTrustedCodexModelBackedApprovalsReviewerProvider(inferredProvider, params));
+	if (inferredProvider !== void 0) return isTrustedCodexModelBackedApprovalsReviewerProvider(inferredProvider, params);
+	return isTrustedCodexModelBackedApprovalsReviewerProvider(explicitProvider, params);
+}
+function isTrustedCodexModelBackedOpenAIProvider(params) {
+	if (!openAIBaseUrlEnvOverridesAreTrustedForModelBackedReview(params.env)) return false;
+	const codexBaseUrlOverrides = readCodexBaseUrlOverridesForModelBackedReview(params);
+	if (codexBaseUrlOverrides === false || !codexBaseUrlOverrides.openAI.every(isNativeOpenAIBaseUrl) || !codexBaseUrlOverrides.chatGPT.every(isNativeChatGPTBaseUrl)) return false;
+	const openAIProviders = readConfiguredOpenAIProvidersForModelBackedReview(params.config);
+	if (openAIProviders.length === 0) return true;
+	return openAIProviders.every((openAIProvider) => configuredOpenAIProviderIsTrustedForModelBackedReview(openAIProvider, params.model));
+}
+function resolveCodexModelBackedReviewerPolicyContext(params) {
+	const provider = params.provider?.trim();
+	if (provider && provider.toLowerCase() !== "codex") return {
+		modelProvider: normalizeCodexModelBackedReviewerPolicyProvider(provider),
+		model: params.model
+	};
+	const bindingModelProvider = params.bindingModelProvider?.trim();
+	const currentModel = params.model?.trim();
+	const bindingModel = params.bindingModel?.trim();
+	if (bindingModelProvider && currentModel && bindingModel && currentModel === bindingModel) return {
+		modelProvider: normalizeCodexModelBackedReviewerPolicyProvider(bindingModelProvider),
+		model: params.model ?? params.bindingModel
+	};
+	const currentModelProvider = inferProviderFromModelRef(params.model);
+	if (currentModelProvider) return {
+		modelProvider: normalizeCodexModelBackedReviewerPolicyProvider(currentModelProvider),
+		model: params.model
+	};
+	if (bindingModelProvider) return {
+		modelProvider: normalizeCodexModelBackedReviewerPolicyProvider(bindingModelProvider),
+		model: params.model ?? params.bindingModel
+	};
+	return {
+		modelProvider: params.nativeAuthProfile === true ? "openai" : void 0,
+		model: params.model ?? params.bindingModel
+	};
+}
 function resolveCodexComputerUseConfig(params = {}) {
 	const env = params.env ?? process.env;
 	const config = readCodexPluginConfig(params.pluginConfig).computerUse ?? {};
@@ -314,7 +370,7 @@ function resolveDefaultCodexAppServerPolicy(params) {
 			mode: "guardian",
 			dangerFullAccessAllowed: true,
 			approvalPolicy: selectGuardianApprovalPolicy(void 0, params.execModeRequiringPromptingApprovals),
-			approvalsReviewer: params.forceUserReviewer ? selectUserApprovalsReviewer(void 0) : selectGuardianApprovalsReviewer(void 0, params.execModeRequiringPromptingApprovals === "auto" ? "auto" : void 0),
+			approvalsReviewer: params.forceUserReviewer ? selectUserApprovalsReviewer(void 0, params.execModeRequiringUserReviewer) : selectGuardianApprovalsReviewer(void 0, params.execModeRequiringPromptingApprovals === "auto" ? "auto" : void 0),
 			sandbox: selectGuardianSandbox(void 0)
 		};
 	}
@@ -332,16 +388,16 @@ function resolveDefaultCodexAppServerPolicy(params) {
 		mode: "guardian",
 		dangerFullAccessAllowed: yoloSandboxAllowed,
 		approvalPolicy: selectGuardianApprovalPolicy(allowedApprovalPolicies, params.execModeRequiringPromptingApprovals),
-		approvalsReviewer: params.forceUserReviewer ? selectUserApprovalsReviewer(allowedApprovalsReviewers) : selectGuardianApprovalsReviewer(allowedApprovalsReviewers, params.execModeRequiringPromptingApprovals === "auto" ? "auto" : void 0),
+		approvalsReviewer: params.forceUserReviewer ? selectUserApprovalsReviewer(allowedApprovalsReviewers, params.execModeRequiringUserReviewer) : selectGuardianApprovalsReviewer(allowedApprovalsReviewers, params.execModeRequiringPromptingApprovals === "auto" ? "auto" : void 0),
 		sandbox: selectGuardianSandbox(allowedSandboxModes)
 	};
 }
 function readCodexRequirementsToml(params) {
 	if (params.requirementsToml !== void 0) return params.requirementsToml ?? void 0;
-	const path = readNonEmptyString(params.requirementsPath) ?? resolveCodexRequirementsPath(params.env ?? process.env, params.platform ?? process.platform);
+	const requirementsPath = readNonEmptyString(params.requirementsPath) ?? resolveCodexRequirementsPath(params.env ?? process.env, params.platform ?? process.platform);
 	try {
-		if (params.readRequirementsFile) return params.readRequirementsFile(path);
-		return readFileSync(path, "utf8");
+		if (params.readRequirementsFile) return params.readRequirementsFile(requirementsPath);
+		return readFileSync(requirementsPath, "utf8");
 	} catch {
 		return;
 	}
@@ -384,6 +440,24 @@ function parseRequirementsSandboxModes(values) {
 function parseTopLevelRequirementsStringArray(content, key) {
 	return parseRequirementsStringArray(stripTomlLineComments(content).slice(0, firstTomlTableOffset(content)), key);
 }
+function parseTomlStringValue(content, key) {
+	const match = parseTomlStringAssignment(content, tomlDottedKeyPattern(key));
+	return match ? match[1] ?? match[2] ?? "" : void 0;
+}
+function parseInlineOpenAIModelProviderBaseUrl(content) {
+	const match = parseTomlStringAssignment(content, `${tomlKeyPattern("model_providers")}\\s*=\\s*\\{[\\s\\S]*?${tomlKeyPattern("openai")}\\s*=\\s*\\{[\\s\\S]*?${tomlKeyPattern("base_url")}`);
+	return match ? match[1] ?? match[2] ?? "" : void 0;
+}
+function parseTomlStringAssignment(content, keyPattern) {
+	return content.match(new RegExp(`(?:^|\\n)\\s*${keyPattern}\\s*=\\s*(?:"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|'([^']*)')`));
+}
+function tomlDottedKeyPattern(key) {
+	return key.split(".").map(tomlKeyPattern).join("\\s*\\.\\s*");
+}
+function tomlKeyPattern(key) {
+	const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return `(?:"${escaped}"|'${escaped}'|${escaped})`;
+}
 function parseRequirementsStringArray(content, key) {
 	const match = content.match(new RegExp(`(?:^|\\n)\\s*${key}\\s*=\\s*\\[([\\s\\S]*?)\\]`));
 	if (!match) return;
@@ -392,6 +466,16 @@ function parseRequirementsStringArray(content, key) {
 	if (stringMatches.length === 0 && arrayBody.trim().length > 0) return;
 	return stringMatches.map((entry) => entry[1] ?? entry[2] ?? "");
 }
+function parseTomlTableSection(content, table) {
+	const strippedContent = stripTomlLineComments(content);
+	const tablePattern = tomlDottedKeyPattern(table);
+	const match = new RegExp(`^\\s*\\[\\s*${tablePattern}\\s*\\]\\s*$`, "m").exec(strippedContent);
+	if (!match) return;
+	const sectionStart = match.index + match[0].length;
+	const rest = strippedContent.slice(sectionStart);
+	const nextTableOffset = rest.search(/^\s*\[/m);
+	return nextTableOffset === -1 ? rest : rest.slice(0, nextTableOffset);
+}
 function parseTomlArrayTableSections(content, table) {
 	const strippedContent = stripTomlLineComments(content);
 	const escapedTable = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -486,9 +570,126 @@ function selectGuardianApprovalsReviewer(allowedApprovalsReviewers, execModeRequ
 	if (allowedApprovalsReviewers.has("user")) return "user";
 	return "auto_review";
 }
-function selectUserApprovalsReviewer(allowedApprovalsReviewers) {
+function selectUserApprovalsReviewer(allowedApprovalsReviewers, execModeRequiringUserReviewer) {
 	if (allowedApprovalsReviewers === void 0 || allowedApprovalsReviewers.has("user")) return "user";
-	throw new Error("tools.exec.mode=ask requires Codex app-server user approvals");
+	throw new Error(`tools.exec.mode=${execModeRequiringUserReviewer ?? "ask"} requires Codex app-server user approvals`);
+}
+function isCodexModelBackedApprovalsReviewerProvider(provider) {
+	return provider?.trim().toLowerCase() === "openai";
+}
+function isTrustedCodexModelBackedApprovalsReviewerProvider(provider, params) {
+	return isCodexModelBackedApprovalsReviewerProvider(provider) && isTrustedCodexModelBackedOpenAIProvider({
+		config: params.config,
+		env: params.env,
+		model: params.model,
+		agentDir: params.agentDir,
+		codexConfigToml: params.codexConfigToml
+	});
+}
+function readCodexBaseUrlOverridesForModelBackedReview(params) {
+	const configToml = readCodexAppServerConfigToml(params);
+	if (configToml === false) return false;
+	if (configToml === void 0) return {
+		openAI: [],
+		chatGPT: []
+	};
+	const topLevelContent = stripTomlLineComments(configToml).slice(0, firstTomlTableOffset(configToml));
+	const modelProviderOpenAISection = parseTomlTableSection(configToml, "model_providers.openai");
+	return {
+		openAI: [
+			parseTomlStringValue(topLevelContent, "openai_base_url"),
+			parseTomlStringValue(topLevelContent, "model_providers.openai.base_url"),
+			parseInlineOpenAIModelProviderBaseUrl(topLevelContent),
+			modelProviderOpenAISection ? parseTomlStringValue(modelProviderOpenAISection, "base_url") : void 0
+		].filter((entry) => entry !== void 0),
+		chatGPT: [parseTomlStringValue(topLevelContent, "chatgpt_base_url")].filter((entry) => entry !== void 0)
+	};
+}
+function readCodexAppServerConfigToml(params) {
+	if (params.codexConfigToml !== void 0) return params.codexConfigToml ?? void 0;
+	const configPath = resolveCodexAppServerConfigPath(params);
+	if (!configPath) return;
+	try {
+		return readFileSync(configPath, "utf8");
+	} catch (error) {
+		return readErrorCode(error) === "ENOENT" ? void 0 : false;
+	}
+}
+function resolveCodexAppServerConfigPath(params) {
+	const agentDir = readNonEmptyString(params.agentDir);
+	const codexHome = agentDir ? path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME) : void 0;
+	return codexHome ? path.join(codexHome, CODEX_CONFIG_TOML_FILENAME) : void 0;
+}
+function readErrorCode(error) {
+	return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
+}
+function readConfiguredOpenAIProvidersForModelBackedReview(config) {
+	const providerRecords = readRecord(readRecord(readRecord(config)?.models)?.providers);
+	if (!providerRecords) return [];
+	const openAIProviders = [];
+	for (const [providerId, providerConfig] of Object.entries(providerRecords)) {
+		if (resolveProviderIdForAuth(providerId, { config }) !== "openai") continue;
+		const record = readRecord(providerConfig);
+		if (record) openAIProviders.push(record);
+	}
+	return openAIProviders;
+}
+function configuredOpenAIProviderIsTrustedForModelBackedReview(openAIProvider, modelInput) {
+	if (readRecord(openAIProvider.localService) || hasNonEmptyRecord(openAIProvider.headers) || hasNonEmptyRecord(openAIProvider.request) || typeof openAIProvider.authHeader === "boolean" || !isNativeOpenAIBaseUrl(openAIProvider.baseUrl)) return false;
+	const models = openAIProvider.models;
+	if (!Array.isArray(models)) return true;
+	const modelId = normalizeOpenAIModelBackedReviewerModelId(modelInput);
+	if (!modelId) return false;
+	for (const entry of models) {
+		const model = readRecord(entry);
+		if (typeof model?.id !== "string" || !matchesConfiguredOpenAIModelId(modelId, model.id)) continue;
+		if (hasNonEmptyRecord(model.headers) || hasNonEmptyRecord(model.request) || !isNativeOpenAIBaseUrl(model.baseUrl)) return false;
+	}
+	return true;
+}
+function normalizeOpenAIModelBackedReviewerModelId(modelInput) {
+	const normalized = modelInput?.trim() ?? "";
+	const authProfileIndex = normalized.indexOf("@");
+	const withoutAuthProfile = authProfileIndex > 0 ? normalized.slice(0, authProfileIndex) : normalized;
+	const slashIndex = withoutAuthProfile.indexOf("/");
+	return slashIndex > 0 ? withoutAuthProfile.slice(slashIndex + 1).trim() : withoutAuthProfile;
+}
+function matchesConfiguredOpenAIModelId(modelId, configuredModelId) {
+	const configured = normalizeOpenAIModelBackedReviewerModelId(configuredModelId);
+	return Boolean(configured) && (modelId === configured || modelId.startsWith(`${configured}@`));
+}
+function hasNonEmptyRecord(value) {
+	const record = readRecord(value);
+	return record !== void 0 && Object.keys(record).length > 0;
+}
+function isNativeOpenAIBaseUrl(value) {
+	if (typeof value !== "string" || !value.trim()) return true;
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.hostname.toLowerCase() === "api.openai.com";
+	} catch {
+		return false;
+	}
+}
+function openAIBaseUrlEnvOverridesAreTrustedForModelBackedReview(env) {
+	return [env?.OPENAI_BASE_URL, env?.OPENAI_API_BASE].every(isNativeOpenAIBaseUrl);
+}
+function isNativeChatGPTBaseUrl(value) {
+	if (typeof value !== "string" || !value.trim()) return true;
+	try {
+		const url = new URL(value);
+		return url.protocol === "https:" && url.hostname.toLowerCase() === "chatgpt.com";
+	} catch {
+		return false;
+	}
+}
+function normalizeCodexModelBackedReviewerPolicyProvider(provider) {
+	return provider.toLowerCase() === "openai" ? "openai" : provider;
+}
+function inferProviderFromModelRef(model) {
+	const normalized = model?.trim().toLowerCase();
+	const slashIndex = normalized?.indexOf("/") ?? -1;
+	return slashIndex > 0 ? normalized?.slice(0, slashIndex) : void 0;
 }
 function selectForcedPromptingSandbox(params) {
 	if (params.configuredSandbox === "read-only" || params.defaultSandbox === "read-only") return "read-only";
@@ -757,4 +958,4 @@ function splitShellWords(value) {
 	return words;
 }
 //#endregion
-export { isCodexFastServiceTier as a, readCodexPluginConfig as c, resolveCodexPluginsPolicy as d, resolveOpenClawExecPolicyForCodexAppServer as f, isCodexAppServerApprovalPolicyAllowedByRequirements as i, resolveCodexAppServerRuntimeOptions as l, withMcpElicitationsApprovalPolicy as m, codexAppServerStartOptionsKey as n, isCodexSandboxExecServerEnabled as o, shouldAutoApproveCodexAppServerApprovals as p, codexSandboxPolicyForTurn as r, normalizeCodexServiceTier as s, CODEX_PLUGINS_MARKETPLACE_NAME as t, resolveCodexComputerUseConfig as u };
+export { withMcpElicitationsApprovalPolicy as _, isCodexAppServerApprovalPolicyAllowedByRequirements as a, isTrustedCodexModelBackedOpenAIProvider as c, resolveCodexAppServerRuntimeOptions as d, resolveCodexComputerUseConfig as f, shouldAutoApproveCodexAppServerApprovals as g, resolveOpenClawExecPolicyForCodexAppServer as h, codexSandboxPolicyForTurn as i, normalizeCodexServiceTier as l, resolveCodexPluginsPolicy as m, canUseCodexModelBackedApprovalsReviewerForModel as n, isCodexFastServiceTier as o, resolveCodexModelBackedReviewerPolicyContext as p, codexAppServerStartOptionsKey as r, isCodexSandboxExecServerEnabled as s, CODEX_PLUGINS_MARKETPLACE_NAME as t, readCodexPluginConfig as u };