@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/api.js

@@ -0,0 +1,146 @@
+import { a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { a as CODEX_APP_SERVER_VERSION, n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-ZkGodW19.js";
+import path from "node:path";
+import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
+import { listAgentIds as listAgentIds$1, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolveEffectiveAgentRuntime } from "openclaw/plugin-sdk/command-auth-native";
+//#region extensions/codex/src/doctor.ts
+const CODEX_MANAGED_APP_SERVER_CHECK_ID = "codex/managed-app-server";
+const CODEX_VERSION_TIMEOUT_MS = 5e3;
+const CODEX_VERSION_MAX_BUFFER_BYTES = 64 * 1024;
+function managedCodexFinding(params) {
+	return {
+		checkId: CODEX_MANAGED_APP_SERVER_CHECK_ID,
+		severity: "error",
+		source: "codex",
+		message: params.message,
+		...params.path ? { path: params.path } : {},
+		...params.requirement ? { requirement: params.requirement } : {},
+		...params.fixHint ? { fixHint: params.fixHint } : {}
+	};
+}
+function readErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function parseCodexVersion(output) {
+	return /(?:^|\s)(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:\s|$)/u.exec(output)?.[1];
+}
+function runVersionCommand(command) {
+	return new Promise((resolve, reject) => {
+		execFile(command, ["--version"], {
+			encoding: "utf8",
+			maxBuffer: CODEX_VERSION_MAX_BUFFER_BYTES,
+			timeout: CODEX_VERSION_TIMEOUT_MS,
+			windowsHide: true
+		}, (error, stdout, stderr) => {
+			if (error) {
+				reject(new Error(readErrorMessage(error), { cause: error }));
+				return;
+			}
+			resolve({
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+function createCodexManagedAppServerHealthCheck(params) {
+	const resolveStartOptions = params.deps?.resolveStartOptions ?? resolveManagedCodexAppServerStartOptions;
+	const resolveAgentStartOptions = params.deps?.resolveAgentStartOptions ?? resolveCodexAppServerStartOptionsForAgent;
+	const isDesktopCommand = params.deps?.isDesktopCommand ?? isManagedCodexDesktopCommand;
+	const resolveNativeCommand = params.deps?.resolveNativeCommand ?? resolveManagedCodexNativeCommand;
+	const executeVersion = params.deps?.runVersionCommand ?? runVersionCommand;
+	return {
+		id: CODEX_MANAGED_APP_SERVER_CHECK_ID,
+		kind: "plugin",
+		description: "Verify the selected managed Codex app-server binary and pinned version.",
+		source: "codex",
+		defaultEnabled: false,
+		async detect(ctx) {
+			const pluginConfig = ctx.cfg.plugins?.entries?.codex?.config;
+			const start = resolveCodexAppServerRuntimeOptions({
+				pluginConfig,
+				env: ctx.env ?? process.env
+			}).start;
+			if (start.transport !== "stdio" || start.commandSource !== "managed") return [];
+			const env = ctx.env ?? process.env;
+			let resolved;
+			for (const agentId of listAgentIds$1(ctx.cfg)) {
+				const model = resolveDefaultModelForAgent({
+					cfg: ctx.cfg,
+					agentId
+				});
+				if (resolveEffectiveAgentRuntime({
+					cfg: ctx.cfg,
+					provider: model.provider,
+					modelId: model.model,
+					agentId
+				}) !== "codex") continue;
+				const agentStart = resolveAgentStartOptions({
+					startOptions: start,
+					agentDir: resolveAgentDir$1(ctx.cfg, agentId, env),
+					env
+				});
+				try {
+					resolved = await resolveStartOptions(agentStart, { pluginRoot: params.pluginRoot });
+				} catch (error) {
+					return [managedCodexFinding({
+						message: `Managed Codex app-server could not be resolved: ${readErrorMessage(error)}`,
+						path: params.pluginRoot,
+						requirement: `an executable Codex ${CODEX_APP_SERVER_VERSION} managed artifact`,
+						fixHint: "Reinstall the staged OpenClaw package with its @openai/codex platform dependency, then rerun the candidate check."
+					})];
+				}
+				if (!isDesktopCommand(resolved.command)) break;
+				resolved = void 0;
+			}
+			if (!resolved) return [];
+			const nativeCommand = resolveNativeCommand(resolved.command);
+			if (!nativeCommand) return [managedCodexFinding({
+				message: "Managed Codex app-server resolved a launcher without a native artifact.",
+				path: resolved.command,
+				requirement: `the platform-native Codex ${CODEX_APP_SERVER_VERSION} executable`,
+				fixHint: "Reinstall the staged OpenClaw package with the matching @openai/codex platform package, then rerun the candidate check."
+			})];
+			let output;
+			try {
+				output = await executeVersion(nativeCommand);
+			} catch (error) {
+				return [managedCodexFinding({
+					message: `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
+					path: nativeCommand,
+					requirement: `Codex ${CODEX_APP_SERVER_VERSION} must report its version within ${CODEX_VERSION_TIMEOUT_MS} ms`,
+					fixHint: "Repair or reinstall the staged OpenClaw package, then rerun the candidate check before cutover."
+				})];
+			}
+			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
+			if (detectedVersion !== "0.151.0") return [managedCodexFinding({
+				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
+				path: nativeCommand,
+				requirement: `the exact OpenClaw-pinned Codex version ${CODEX_APP_SERVER_VERSION}`,
+				fixHint: "Reinstall the staged OpenClaw package so its managed @openai/codex dependency matches the pinned version, then rerun the candidate check."
+			})];
+			return [];
+		}
+	};
+}
+function registerCodexManagedAppServerDoctorChecks$1(host, deps) {
+	if (host.getHealthCheck("codex/managed-app-server")) return;
+	host.registerHealthCheck(createCodexManagedAppServerHealthCheck({
+		pluginRoot: host.pluginRoot,
+		deps
+	}));
+}
+//#endregion
+//#region extensions/codex/api.ts
+const CODEX_PLUGIN_ROOT = path.dirname(fileURLToPath(import.meta.url));
+function registerCodexManagedAppServerDoctorChecks(host) {
+	registerCodexManagedAppServerDoctorChecks$1({
+		...host,
+		pluginRoot: CODEX_PLUGIN_ROOT
+	});
+}
+//#endregion
+export { CODEX_MANAGED_APP_SERVER_CHECK_ID, registerCodexManagedAppServerDoctorChecks };

package/dist/{attempt-client-cleanup-DMLXUfa8.js → attempt-client-cleanup-CVPvp9dL.js}

@@ -1,4 +1,4 @@
-import { J as unsubscribeCodexAppServerLiveThread, ct as isJsonObject, p as retireSharedCodexAppServerClientIfCurrent, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
+import { $ as CodexAppServerRpcError, Ht as isJsonObject, wt as unsubscribeCodexAppServerLiveThread, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-kNkljY-R.js";
 import { asFiniteNumber, normalizeOptionalString, normalizeOptionalString as normalizeOptionalString$1, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
@@ -259,6 +259,7 @@ var CodexProjectionDiagnostics = class {
 //#region extensions/codex/src/app-server/turn-router.ts
 /** Keyed routing for all turn traffic on one shared Codex app-server client. */
 const DEFAULT_PREBIND_NOTIFICATION_LIMIT = 256;
+const DEFAULT_GLOBAL_WARNING_LIMIT = 32;
 const CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS = 3e4;
 const routers = /* @__PURE__ */ new WeakMap();
 /** Returns the sole router installed on a physical app-server client. */
@@ -272,6 +273,7 @@ function getCodexAppServerTurnRouter(client) {
 var ClientTurnRouter = class {
 	constructor(client) {
 		this.routes = /* @__PURE__ */ new Map();
+		this.globalWarnings = [];
 		this.nativeTurnCompletionWatchers = /* @__PURE__ */ new Map();
 		this.disposed = false;
 		client.addNotificationHandler((notification) => this.routeNotification(notification));
@@ -290,7 +292,11 @@ var ClientTurnRouter = class {
 			ended: createDeferred(),
 			activated: createDeferred(),
 			gate: "open",
-			pending: [],
+			pending: this.globalWarnings.map((notification) => ({
+				notification,
+				receivedAtMs: Date.now(),
+				scope: { threadId }
+			})),
 			notificationTail: Promise.resolve(),
 			completedNativeTurnIds: /* @__PURE__ */ new Set(),
 			ignoredTurnNotificationKeys: /* @__PURE__ */ new Set()
@@ -412,6 +418,15 @@ var ClientTurnRouter = class {
 	routeNotification(notification) {
 		if (this.disposed) return;
 		const scope = readScope(notification.params);
+		if (!scope.threadId && (notification.method === "configWarning" || notification.method === "warning")) {
+			if (this.globalWarnings.length === DEFAULT_GLOBAL_WARNING_LIMIT) this.globalWarnings.shift();
+			this.globalWarnings.push(notification);
+			for (const route of this.routes.values()) {
+				this.bufferNotification(route, notification, { threadId: route.threadId }, Date.now());
+				if (route.gate === "bound") this.flushNotifications(route);
+			}
+			return Promise.all([...this.routes.values()].map((route) => route.notificationTail)).then(() => void 0);
+		}
 		const watchers = scope.threadId ? this.nativeTurnCompletionWatchers.get(scope.threadId) : void 0;
 		const route = scope.threadId ? this.routes.get(scope.threadId) : void 0;
 		if (!watchers && !route) return;
@@ -489,6 +504,10 @@ var ClientTurnRouter = class {
 		const handler = route.handlers?.onNotification;
 		if (!handler) return;
 		for (const pending of route.pending.splice(0)) {
+			if (route.gate !== "bound" && (pending.notification.method === "configWarning" || pending.notification.method === "warning" && !readScope(pending.notification.params).threadId)) {
+				route.pending.push(pending);
+				continue;
+			}
 			if (route.gate === "bound" && pending.scope.turnId && pending.scope.turnId !== route.turnId) {
 				this.warnDroppedStaleTurnNotification(route, pending.notification, pending.scope);
 				continue;
@@ -541,7 +560,7 @@ var ClientTurnRouter = class {
 		await Promise.race([route.notificationTail, route.ended.promise]);
 	}
 	async drainNotifications(route) {
-		await route.notificationTail;
+		await Promise.race([route.notificationTail, route.ended.promise]);
 	}
 	release(route, error = /* @__PURE__ */ new Error("codex app-server thread route is released")) {
 		if (route.released) return;
@@ -677,12 +696,35 @@ async function interruptCodexTurnAndWaitBestEffort(client, params) {
 		completion?.cancel();
 	}
 }
+/** Stops native terminals on the cancelled thread without retiring peer threads. */
+async function terminateCodexBackgroundTerminals(client, threadId) {
+	const options = {
+		timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
+		signal: AbortSignal.timeout(CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS)
+	};
+	try {
+		const { data } = await client.request("thread/backgroundTerminals/list", { threadId }, options);
+		for (const { processId } of data) await client.request("thread/backgroundTerminals/terminate", {
+			threadId,
+			processId
+		}, options);
+		if (data.length > 0) {
+			if ((await client.request("thread/backgroundTerminals/list", {
+				threadId,
+				limit: 1
+			}, options)).data.length > 0) throw new Error("native background terminals remain running");
+		}
+	} catch (cause) {
+		throw new Error("Codex background-terminal cleanup failed; inspect the thread's running terminals before starting more work.", { cause });
+	}
+}
 /** Unsubscribes from a thread while swallowing cleanup-only failures. */
 async function unsubscribeCodexThreadBestEffort(client, params) {
 	try {
-		await unsubscribeCodexAppServerLiveThread(client, params.threadId, params.timeoutMs);
+		await unsubscribeCodexAppServerLiveThread(client, params.threadId, params.timeoutMs, params.assertCurrent);
 		return true;
 	} catch (error) {
+		params.assertCurrent?.();
 		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
 			threadId: params.threadId,
 			error
@@ -732,4 +774,4 @@ async function retireCodexAppServerClientAfterTimedOutTurn(client, params) {
 	});
 }
 //#endregion
-export { shouldSynthesizeToolProgressForItem as A, readNullableString as B, isSideEffectingNativeToolItem as C, itemTitle as D, itemStatus as E, readItem as F, readItemString as I, readNonEmptyString as L, normalizeOptionalString$1 as M, readCodexErrorNotificationMessage as N, shouldClearTerminalPresentationForNativeItem as O, readHookOutputEntries as P, readNonEmptyStringArray as R, isNonSuccessItemStatus as S, itemName as T, splitPlanText as V, readCodexNotificationTurnId as _, closeCodexStartupClientBestEffort as a, auditNativeToolUnfinishedStatus as b, isCodexAppServerUnsafeSubscriptionError as c, unsubscribeCodexThreadBestEffort as d, CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS as f, readCodexNotificationThreadId as g, isCodexNotificationForTurn as h, assertCodexThreadResumeSubscription as i, extractRawAssistantText as j, shouldRecordNativeToolTranscript as k, retireCodexAppServerClientAfterTimedOutTurn as l, CodexProjectionDiagnostics as m, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, getCodexAppServerTurnRouter as p, CodexAppServerUnsafeSubscriptionError as r, isCodexAlreadyTerminalInterruptError as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, retireUnsafeCodexTurnClientBestEffort as u, auditNativeToolName as v, itemKind as w, isMutatingNativeToolItem as x, auditNativeToolTerminalStatus as y, readNonNegativeInteger as z };
+export { shouldRecordNativeToolTranscript as A, readNonNegativeInteger as B, isNonSuccessItemStatus as C, itemStatus as D, itemName as E, readHookOutputEntries as F, splitPlanText as H, readItem as I, readItemString as L, extractRawAssistantText as M, normalizeOptionalString$1 as N, itemTitle as O, readCodexErrorNotificationMessage as P, readNonEmptyString as R, isMutatingNativeToolItem as S, itemKind as T, readNullableString as V, readCodexNotificationThreadId as _, closeCodexStartupClientBestEffort as a, auditNativeToolTerminalStatus as b, isCodexAppServerUnsafeSubscriptionError as c, terminateCodexBackgroundTerminals as d, unsubscribeCodexThreadBestEffort as f, isCodexNotificationForTurn as g, CodexProjectionDiagnostics as h, assertCodexThreadResumeSubscription as i, shouldSynthesizeToolProgressForItem as j, shouldClearTerminalPresentationForNativeItem as k, retireCodexAppServerClientAfterTimedOutTurn as l, getCodexAppServerTurnRouter as m, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS as p, CodexAppServerUnsafeSubscriptionError as r, isCodexAlreadyTerminalInterruptError as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, retireUnsafeCodexTurnClientBestEffort as u, readCodexNotificationTurnId as v, isSideEffectingNativeToolItem as w, auditNativeToolUnfinishedStatus as x, auditNativeToolName as y, readNonEmptyStringArray as z };

package/dist/{auth-binding-B4FfbcCg.js → auth-binding-Ds_QVm-X.js}

@@ -1,6 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { fingerprintResolvedAuthProfileCredential } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { resolveApiKeyForProfile } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 //#region extensions/codex/src/app-server/auth-binding.ts
 var auth_binding_exports = /* @__PURE__ */ __exportAll({
 	fingerprintCodexAppServerAuthBinding: () => fingerprintCodexAppServerAuthBinding,
@@ -26,14 +27,28 @@ function withMaterializedCredential(params) {
 /** Resolves one forwarded profile once so attestation and execution share exact material. */
 async function prepareCodexAppServerAuthBinding(params) {
 	const credential = params.authProfileStore.profiles[params.authProfileId];
-	if (!credential || credential.type === "oauth") return;
+	if (!credential) return;
+	if (credential.type === "oauth") {
+		const fingerprint = fingerprintResolvedAuthProfileCredential({
+			profileId: params.authProfileId,
+			credential: {
+				...credential,
+				accountId: resolveOpenAICodexAuthIdentity(credential).accountId
+			},
+			resolvedAuth: void 0
+		});
+		return fingerprint ? {
+			fingerprint,
+			authProfileStore: structuredClone(params.authProfileStore)
+		} : void 0;
+	}
 	const resolved = await resolveApiKeyForProfile({
 		cfg: params.config,
 		store: params.authProfileStore,
 		profileId: params.authProfileId,
 		agentDir: params.agentDir
 	});
-	if (!resolved?.apiKey) throw new Error(`Codex could not resolve auth profile "${params.authProfileId}".`);
+	if (!resolved?.apiKey) throw new Error(`Codex could not resolve auth profile "${params.authProfileId}". Repair or replace its credential or SecretRef, then retry.`);
 	const fingerprint = fingerprintResolvedAuthProfileCredential({
 		profileId: params.authProfileId,
 		credential,
@@ -44,7 +59,7 @@ async function prepareCodexAppServerAuthBinding(params) {
 			mode: credential.type === "api_key" ? "api-key" : "token"
 		}
 	});
-	if (!fingerprint) throw new Error(`Codex could not attest auth profile "${params.authProfileId}".`);
+	if (!fingerprint) throw new Error(`Codex could not attest auth profile "${params.authProfileId}". Re-select the OpenAI profile and retry.`);
 	return {
 		fingerprint,
 		authProfileStore: withMaterializedCredential({

package/dist/{binding-connection-I5Bo-AsX.js → binding-connection-CCQFs8lf.js}

@@ -1,5 +1,5 @@
-import { T as readCodexPluginConfig, g as resolveCodexAppServerRuntimeOptions, y as resolveCodexSupervisionAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-C3H2CVp6.js";
+import { T as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { n as buildCodexAppServerConnectionFingerprint, o as resolveCodexCatalogConnectionHome } from "./thread-resume-DF54hagX.js";
 //#region extensions/codex/src/app-server/binding-connection.ts
 /** Requires the native model pair after a supervised pending branch has materialized. */
 function requireCodexSupervisionModelSelection(binding) {
@@ -16,9 +16,21 @@ function resolveCodexBindingAppServerConnection(params) {
 	const { binding, authProfileId, ...runtimeParams } = params;
 	const usesSupervisionConnection = binding?.connectionScope === "supervision";
 	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
-	const appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
+	let appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
 	if (usesSupervisionConnection) {
 		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
+		const catalogHome = persistedFingerprint ? resolveCodexCatalogConnectionHome(persistedFingerprint, runtimeParams.agentDir) : void 0;
+		if (catalogHome) appServer = {
+			...appServer,
+			start: {
+				...appServer.start,
+				homeScope: "user",
+				env: {
+					...appServer.start.env,
+					CODEX_HOME: catalogHome
+				}
+			}
+		};
 		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
 		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
 	}

package/dist/{bounded-turn-qgZmzy_4.js → bounded-turn-rq5tiSXk.js}

@@ -1,10 +1,11 @@
-import { g as resolveCodexAppServerRuntimeOptions } from "./session-binding-DPxIvMgE.js";
-import { ct as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-kIBbGjk4.js";
-import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DMLXUfa8.js";
-import { b as isTerminalTurnStatus, n as normalizeCodexResponseTokenUsage, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-e5huIQWu.js";
-import { a as assertCodexThreadStartResponse, c as readCodexErrorNotification, o as assertCodexTurnStartResponse, u as readCodexTurnCompletedNotification } from "./protocol-validators-B4F7L8Rf.js";
-import { r as readModelListResult } from "./models-BFlpn1Ex.js";
-import { W as mergeCodexThreadConfigs, c as buildCodexRingZeroThreadConfigPatch, l as buildCodexRuntimeThreadConfig, o as assertCodexRestrictedToolSurfaceHasNoManagedHooks, s as attestCodexRestrictedToolSurfaceMcpServersDisabled, u as readCodexInheritedMcpServerNames } from "./thread-lifecycle-Bu1BTDXr.js";
+import { n as readCodexAppServerConfigOptions } from "./launch-args-sXOAg0SX.js";
+import { i as resolveCodexAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { Ht as isJsonObject, et as createCodexElicitationResponse, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-kNkljY-R.js";
+import { c as assertCodexTurnStartResponse, f as readCodexTurnCompletedNotification, s as assertCodexThreadStartResponse, u as readCodexErrorNotification } from "./protocol-validators-Bg5rpNxk.js";
+import { a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS, v as readCodexNotificationTurnId } from "./attempt-client-cleanup-CVPvp9dL.js";
+import { b as isTerminalTurnStatus, n as normalizeCodexResponseTokenUsage, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-D3PHFFXh.js";
+import { r as readModelListResult } from "./models-DgFWSuxA.js";
+import { _ as buildCodexRingZeroThreadConfigPatch, g as attestCodexRestrictedToolSurfaceMcpServersDisabled, h as assertCodexManagedRequirementsDoNotOverrideToolPolicy, ot as mergeCodexThreadConfigs, v as buildCodexRuntimeThreadConfig, y as readCodexInheritedMcpServerNames } from "./thread-lifecycle-Ss-uwnC4.js";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -65,11 +66,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	const timeoutMs = deadline - Date.now();
 	if (timeoutMs <= 0) throw timeoutError;
 	const agentDir = params.agentDir?.trim() || void 0;
-	const isolatedStartOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
-	const startOptions = workspace.codexHome && params.preparedAuth ? {
-		...isolatedStartOptions,
-		homeScope: "agent"
-	} : isolatedStartOptions;
+	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
 	const ownsClient = !params.options.clientFactory;
 	const authSelection = params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.profile };
 	const client = params.options.clientFactory ? await params.options.clientFactory({
@@ -80,7 +77,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		config: params.config,
 		timeoutMs,
 		...params.signal ? { abandonSignal: params.signal } : {}
-	}) : await import("./shared-client-kIBbGjk4.js").then((n) => n.m).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	}) : await import("./shared-client-kNkljY-R.js").then((n) => n.x).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
 		...authSelection,
@@ -115,7 +112,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
-		const model = await resolveCodexBoundedTurnModel({
+		const modelSelection = await resolveCodexBoundedTurnModel({
 			client,
 			selection: params.model,
 			requiredModalities: params.requiredModalities,
@@ -123,10 +120,10 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			signal: abortController.signal
 		});
 		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
-		if (params.requireNoExternalCapabilities) await assertCodexRestrictedToolSurfaceHasNoManagedHooks(client, abortController.signal);
+		if (params.requireNoExternalCapabilities) await assertCodexManagedRequirementsDoNotOverrideToolPolicy(client, { restrictedToolSurface: true }, abortController.signal);
 		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false });
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
-			model,
+			model: modelSelection.runtimeModelId,
 			...params.modelProvider ? { modelProvider: params.modelProvider } : {},
 			cwd: workspace.cwd,
 			approvalPolicy: "on-request",
@@ -161,7 +158,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				threadId: thread.thread.id,
 				input: params.input,
 				approvalPolicy: "on-request",
-				model,
+				model: modelSelection.runtimeModelId,
 				effort: "low"
 			}, {
 				timeoutMs,
@@ -174,7 +171,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 					signal: abortController.signal,
 					timeoutError
 				}),
-				model
+				model: modelSelection.catalogId
 			};
 		} finally {
 			await interruptPromise;
@@ -204,10 +201,7 @@ function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames)
 	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
-	const providerArgs = start.args.flatMap((arg, index) => {
-		const override = arg === "-c" || arg === "--config" ? start.args[index + 1] : arg.startsWith("--config=") ? arg.slice(9) : void 0;
-		return override && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(override) ? ["-c", override] : [];
-	});
+	const providerArgs = readCodexAppServerConfigOptions(start.args).flatMap(({ name, value }) => (name === "-c" || name === "--config") && value && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(value) ? ["-c", value] : []);
 	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
@@ -215,6 +209,7 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 	});
 	return {
 		...start,
+		homeScope: "agent",
 		args: [
 			"app-server",
 			...providerArgs,
@@ -242,14 +237,14 @@ function createCodexBoundedApprovalHandler(taskLabel) {
 			decision: "decline",
 			reason: `OpenClaw Codex ${taskLabel} does not grant native approvals.`
 		};
-		if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+		if (request.method === "mcpServer/elicitation/request") return createCodexElicitationResponse("decline", null, { message: `OpenClaw Codex ${taskLabel} does not support interactive input.` });
 	};
 }
 async function resolveCodexBoundedTurnModel(params) {
 	const listed = readModelListResult(await params.client.request("model/list", {
 		limit: null,
 		cursor: null,
-		includeHidden: false
+		includeHidden: params.selection.mode === "required"
 	}, {
 		timeoutMs: Math.min(params.timeoutMs, 5e3),
 		signal: params.signal
@@ -258,14 +253,20 @@ async function resolveCodexBoundedTurnModel(params) {
 		const supported = listed.filter((entry) => params.requiredModalities.every((modality) => entry.inputModalities.includes(modality)));
 		const selected = supported.find((entry) => entry.isDefault) ?? supported[0];
 		if (!selected) throw new Error(`Codex app-server has no model supporting ${params.requiredModalities.join(" and ")} input.`);
-		return selected.model;
+		return {
+			catalogId: selected.id,
+			runtimeModelId: selected.model
+		};
 	}
 	const model = params.selection.id;
 	const match = listed.find((entry) => entry.model === model || entry.id === model);
 	if (!match) throw new Error(`Codex app-server model not found: ${model}`);
 	if (params.requiredModalities.includes("image") && !match.inputModalities.includes("image")) throw new Error(`Codex app-server model does not support images: ${model}`);
 	if (params.requiredModalities.includes("text") && !match.inputModalities.includes("text")) throw new Error(`Codex app-server model does not support text: ${model}`);
-	return model;
+	return {
+		catalogId: match.id,
+		runtimeModelId: match.model
+	};
 }
 function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 	let turnId;

package/dist/{capabilities-CybGI1oz.js → capabilities-CGm_94eL.js}

@@ -1,4 +1,4 @@
-import { z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
+import { $ as CodexAppServerRpcError } from "./shared-client-kNkljY-R.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-7hgXZDV7.js");
+		const { registerCodexSessionCli } = await import("./session-cli-BuDjm5Ou.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-B1AEz8ZA.js → command-formatters-C54Yg3eA.js}

@@ -1,5 +1,5 @@
-import { ct as isJsonObject } from "./shared-client-kIBbGjk4.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-DZXmOL8-.js";
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-hFtzt2Up.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-formatters.ts
 /**