@openclaw/codex 2026.10.5-beta.3 → 2026.10.10-beta.1

package/dist/.setup/{auth-profile-CgHQ8Vot.mjs → auth-profile-auwzSwwy.mjs}

@@ -1,21 +1,27 @@
-import { n as createCodexAuthProfileSelection } from "./auth-profile-selection-hr8ocLtz.mjs";
+import { n as createCodexAuthProfileSelection } from "./auth-profile-selection-Bp5PDk3W.mjs";
 import { embeddedAgentLog, resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
 import { resolveProviderIdForAuth } from "openclaw/plugin-sdk/provider-auth-aliases";
-import { ensureAuthProfileStore, resolveAuthProfileOrder } from "openclaw/plugin-sdk/provider-auth";
+import { ensureAuthProfileStore, ensureAuthProfileStoreAsync, resolveAuthProfileOrder } from "openclaw/plugin-sdk/provider-auth";
 //#region extensions/codex/src/app-server/auth-profile.ts
-/** Synchronous auth-profile selection and native provider identity. */
+/** Worker-backed auth-profile selection and native provider identity. */
 const CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER = "openai";
 const PUBLIC_OPENAI_MODEL_PROVIDER = "openai";
+async function resolveModelBackedReviewerPolicyProvider(params) {
+	const modelProvider = params.modelProvider?.trim();
+	if (modelProvider && modelProvider.toLowerCase() !== "codex") return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
+	return await isCodexAppServerNativeAuthProfile(params) ? "openai" : void 0;
+}
 const { resolveCodexAppServerAuthProfileId, resolveCodexAppServerAuthProfileIdForAgent, resolveCodexAppServerAuthProfileStore } = createCodexAuthProfileSelection({
 	ensureAuthProfileStore,
+	ensureAuthProfileStoreAsync,
 	resolveAuthProfileOrder
 });
 /** Returns true when an auth profile uses native Codex/OpenAI app-server auth. */
-function isCodexAppServerNativeAuthProfile(lookup) {
+async function isCodexAppServerNativeAuthProfile(lookup) {
 	const authProfileId = lookup.authProfileId?.trim();
 	if (!authProfileId) return false;
 	try {
-		const credential = (lookup.authProfileStore ?? ensureAuthProfileStore(lookup.agentDir?.trim() || resolveDefaultAgentDir(lookup.config ?? {}), {
+		const credential = (lookup.authProfileStore ?? await ensureAuthProfileStoreAsync(lookup.agentDir?.trim() || resolveDefaultAgentDir(lookup.config ?? {}), {
 			allowKeychainPrompt: false,
 			config: lookup.config,
 			externalCliProviderIds: [CODEX_APP_SERVER_NATIVE_AUTH_PROVIDER],
@@ -33,11 +39,11 @@ function isCodexAppServerNativeAuthProfile(lookup) {
 	}
 }
 /** Hides redundant OpenAI provider attribution for native Codex auth bindings. */
-function normalizeCodexAppServerBindingModelProvider(params) {
+async function normalizeCodexAppServerBindingModelProvider(params) {
 	const modelProvider = params.modelProvider?.trim();
 	if (!modelProvider) return;
-	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === PUBLIC_OPENAI_MODEL_PROVIDER) return;
+	if (modelProvider.toLowerCase() === PUBLIC_OPENAI_MODEL_PROVIDER && await isCodexAppServerNativeAuthProfile(params)) return;
 	return modelProvider;
 }
 //#endregion
-export { resolveCodexAppServerAuthProfileStore as a, resolveCodexAppServerAuthProfileIdForAgent as i, normalizeCodexAppServerBindingModelProvider as n, resolveCodexAppServerAuthProfileId as r, isCodexAppServerNativeAuthProfile as t };
+export { resolveCodexAppServerAuthProfileStore as a, resolveCodexAppServerAuthProfileIdForAgent as i, normalizeCodexAppServerBindingModelProvider as n, resolveModelBackedReviewerPolicyProvider as o, resolveCodexAppServerAuthProfileId as r, isCodexAppServerNativeAuthProfile as t };

package/dist/.setup/{auth-profile-health-oHizqgye.mjs → auth-profile-health-BVPZU9I8.mjs}

@@ -5,15 +5,15 @@ const PROFILE_ID = "openai:default";
 async function collectFindings(config, env) {
 	const declared = config.auth?.profiles?.[PROFILE_ID];
 	if (declared?.provider !== "openai" || declared.mode !== "oauth") return [];
-	const [{ loadAuthProfileStoreForRuntime }, { listAgentIds, resolveAgentDir }] = await Promise.all([import("openclaw/plugin-sdk/agent-runtime"), import("openclaw/plugin-sdk/agent-scope-runtime")]);
+	const [{ loadAuthProfileStoreForRuntimeAsync }, { listAgentIds, resolveAgentDir }] = await Promise.all([import("openclaw/plugin-sdk/agent-runtime"), import("openclaw/plugin-sdk/agent-scope-runtime")]);
 	const findings = [];
 	const missing = [];
 	for (const agentId of listAgentIds(config)) try {
-		if (!loadAuthProfileStoreForRuntime(resolveAgentDir(config, agentId, env), {
+		if (!(await loadAuthProfileStoreForRuntimeAsync(resolveAgentDir(config, agentId, env), {
 			readOnly: true,
 			config,
 			externalCli: { mode: "none" }
-		}, env).profiles[PROFILE_ID]) missing.push(agentId);
+		}, env)).profiles[PROFILE_ID]) missing.push(agentId);
 	} catch (error) {
 		findings.push({
 			checkId: CHECK_ID,
@@ -41,12 +41,19 @@ const codexNativeProfileRecoveryHealthCheck = {
 };
 const codexNativeProfileRecoveryService = {
 	id: CHECK_ID,
-	async start(ctx) {
-		const findings = await collectFindings(ctx.config, {
-			...process.env,
-			OPENCLAW_STATE_DIR: ctx.stateDir
+	apiVersion: 2,
+	start(ctx) {
+		ctx.scheduler.schedule({
+			id: CHECK_ID,
+			delayMs: 0,
+			async run() {
+				const findings = await collectFindings(ctx.config, {
+					...process.env,
+					OPENCLAW_STATE_DIR: ctx.stateDir
+				});
+				if (!ctx.scheduler.signal.aborted) for (const finding of findings) ctx.logger.warn(finding.message);
+			}
 		});
-		for (const finding of findings) ctx.logger.warn(finding.message);
 	}
 };
 //#endregion

package/dist/.setup/{auth-profile-selection-hr8ocLtz.mjs → auth-profile-selection-Bp5PDk3W.mjs}

@@ -2,7 +2,7 @@ import { resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-regist
 //#region extensions/codex/src/app-server/auth-profile-selection.ts
 const CODEX_APP_SERVER_AUTH_PROVIDER = "openai";
 const CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS = [CODEX_APP_SERVER_AUTH_PROVIDER];
-function createCodexAuthProfileSelection({ ensureAuthProfileStore, resolveAuthProfileOrder }) {
+function createCodexAuthProfileSelection({ ensureAuthProfileStore, ensureAuthProfileStoreAsync, resolveAuthProfileOrder }) {
 	function resolveCodexAppServerAuthProfileId(params) {
 		const requested = params.authProfileId?.trim();
 		if (requested) return requested;
@@ -12,9 +12,11 @@ function createCodexAuthProfileSelection({ ensureAuthProfileStore, resolveAuthPr
 			provider: CODEX_APP_SERVER_AUTH_PROVIDER
 		})[0]?.trim();
 	}
-	function resolveCodexAppServerAuthProfileIdForAgent(params) {
+	async function resolveCodexAppServerAuthProfileIdForAgent(params) {
+		const requested = params.authProfileId?.trim();
+		if (requested) return requested;
 		const agentDir = params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {});
-		const store = resolveCodexAppServerAuthProfileStore({
+		const store = await resolveCodexAppServerAuthProfileStore({
 			...params,
 			agentDir
 		});
@@ -23,19 +25,34 @@ function createCodexAuthProfileSelection({ ensureAuthProfileStore, resolveAuthPr
 			store
 		});
 	}
-	function resolveCodexAppServerAuthProfileStore(params) {
-		if (params.authProfileStore) return params.authProfileStore;
-		return ensureAuthProfileStore(params.agentDir, {
+	/** Current account selection for a synchronous external-effect guard only. */
+	function resolveCodexAppServerAuthProfileIdAtEffect(params) {
+		const requested = params.authProfileId?.trim();
+		if (requested) return requested;
+		const agentDir = params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {});
+		const store = params.authProfileStore ?? ensureAuthProfileStore(agentDir, storeOptions(params));
+		return resolveCodexAppServerAuthProfileId({
+			...params,
+			store
+		});
+	}
+	function storeOptions(params) {
+		return {
 			profileId: params.authProfileId,
 			allowKeychainPrompt: false,
 			config: params.config,
 			externalCliProviderIds: CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS,
 			...params.authProfileId ? { externalCliProfileIds: [params.authProfileId] } : {}
-		});
+		};
+	}
+	async function resolveCodexAppServerAuthProfileStore(params) {
+		if (params.authProfileStore) return params.authProfileStore;
+		return ensureAuthProfileStoreAsync(params.agentDir, storeOptions(params));
 	}
 	return {
 		resolveCodexAppServerAuthProfileId,
 		resolveCodexAppServerAuthProfileIdForAgent,
+		resolveCodexAppServerAuthProfileIdAtEffect,
 		resolveCodexAppServerAuthProfileStore
 	};
 }

package/dist/.setup/{binding-connection-B7HAAZSI.mjs → binding-connection-GTgUj9pi.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./session-binding-sidecars-DD-enC8w.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-BNSS6WL4.mjs";
 import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-registration";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/codex/src/app-server/binding-connection.ts
@@ -44,7 +44,7 @@ function requireCodexSupervisionModelSelection(binding) {
 }
 /** Registration publishes the resolver; connection policy loads only for an actual request. */
 async function resolveCodexBindingAppServerConnection(params) {
-	return (await import("./binding-connection.runtime-DAXn7iFl.mjs")).resolveCodexBindingAppServerConnection(params, catalogHomes.tryGetRuntime());
+	return (await import("./binding-connection.runtime-RcWR3vQu.mjs")).resolveCodexBindingAppServerConnection(params, catalogHomes.tryGetRuntime());
 }
 //#endregion
 export { setCodexCatalogConnectionHomeResolver as a, resolveCodexBindingAppServerConnection as i, binding_connection_exports as n, requireCodexSupervisionModelSelection as r, assertCodexSessionRuntimeOwnership as t };

package/dist/.setup/{binding-connection.runtime-DAXn7iFl.mjs → binding-connection.runtime-RcWR3vQu.mjs}

@@ -1,11 +1,12 @@
 import { d as readCodexPluginConfig } from "./config-parsing-DsWSCPHO.mjs";
 import { n as resolveCodexAppServerLocalHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-Bg9DbDI6.mjs";
-import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
+import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-DRb-niJc.mjs";
+import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-BZRizyuG.mjs";
 //#region extensions/codex/src/app-server/binding-connection.runtime.ts
 /** Resolves connection and auth ownership exclusively from the private thread binding. */
 async function resolveCodexBindingAppServerConnection(params, discoverHomes) {
-	const { binding, authProfileId, assertCurrent, ...runtimeParams } = params;
+	const { binding, authProfileId, assertCurrent, assertCurrentAsync, ...runtimeParams } = params;
+	await assertCurrentAsync?.();
 	assertCurrent?.();
 	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");

package/dist/.setup/{bounded-turn-isolation-BfDAo-qZ.mjs → bounded-turn-isolation-D8CDrAVX.mjs}

@@ -1,8 +1,8 @@
 import { d as readCodexPluginConfig } from "./config-parsing-DsWSCPHO.mjs";
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
-import { i as resolveCodexAppServerHomeScope } from "./config-options-DDzeNQ8m.mjs";
-import "./config-C1YVVLEA.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-DMFZkd3X.mjs";
+import "./config-BfrAlTMT.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BZRizyuG.mjs";
 //#region extensions/codex/src/app-server/bounded-turn-isolation.ts
 function resolveCodexBoundedTurnIsolation(options) {
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);

package/dist/.setup/{bounded-turn-BmChqNaK.mjs → bounded-turn-mN_ekXYW.mjs}

@@ -1,18 +1,17 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
 import { a as resolveCodexPrivateLauncher, i as readCodexAppServerConfigOptions } from "./launch-args-DbFCehO7.mjs";
-import { d as readCodexEffectiveConfig } from "./config-options-DDzeNQ8m.mjs";
-import { a as codexPrewriteRejectionCause } from "./rpc-error-C98SHchT.mjs";
-import "./config-C1YVVLEA.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-DWzK-k0n.mjs";
-import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CCz9ldpr.mjs";
-import { _ as assertCodexTurnStartResponse, b as readCodexErrorNotification, g as assertCodexThreadStartResponse, w as createCodexElicitationResponse } from "./client-aPKNc4Ii.mjs";
-import { o as closeCodexStartupClientBestEffort, s as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-D3YvP0N7.mjs";
-import { t as CodexEphemeralTurn } from "./ephemeral-turn-DAlEbytF.mjs";
-import { i as readModelListResult } from "./models-BB0l-gUb.mjs";
-import { d as mergeCodexThreadConfigs } from "./project-doc-thread-config-BVcvnps8.mjs";
+import { d as readCodexEffectiveConfig } from "./config-options-DMFZkd3X.mjs";
+import { a as codexPrewriteRejectionCause } from "./rpc-error-DemqqaxE.mjs";
+import "./config-BfrAlTMT.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BZRizyuG.mjs";
+import { C as createCodexElicitationResponse, g as assertCodexTurnStartResponse, h as assertCodexThreadStartResponse, y as readCodexErrorNotification } from "./client-BS8X7HmG.mjs";
+import { o as closeCodexStartupClientBestEffort, s as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-6OcbMH46.mjs";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-1ZF17fUR.mjs";
+import { i as readModelListResult } from "./models-BWLEUo2E.mjs";
+import { d as mergeCodexThreadConfigs } from "./project-doc-thread-config-B0UI3f1D.mjs";
 import { n as resolveCodexAppServerReasoningEffort } from "./reasoning-effort-CS9kKWB9.mjs";
-import { n as buildCodexRingZeroThreadConfigPatch, p as attestCodexRestrictedToolSurfaceMcpServersDisabled, r as buildCodexRuntimeThreadConfig, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, u as readCodexInheritedMcpServerNames } from "./thread-requests-BgzJwJtS.mjs";
-import { a as resolveCodexPromptError } from "./usage-limit-error-CJoJ_F8V.mjs";
+import { n as buildCodexRingZeroThreadConfigPatch, p as attestCodexRestrictedToolSurfaceMcpServersDisabled, r as buildCodexRuntimeThreadConfig, t as assertCodexManagedRequirementsDoNotOverrideToolPolicy, u as readCodexInheritedMcpServerNames } from "./thread-requests-BjawdIVV.mjs";
+import { a as resolveCodexPromptError } from "./usage-limit-error-DcOSH3J4.mjs";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { parse } from "smol-toml";
 import path from "node:path";
@@ -102,6 +101,7 @@ var CodexBoundedTurnTimeoutError = class extends Error {
 	constructor(taskLabel, timeoutMs) {
 		const bound = timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3}s` : `${timeoutMs}ms`;
 		super(`codex app-server ${taskLabel} turn timed out after ${bound}`);
+		this.timeoutMs = timeoutMs;
 		this.name = "TimeoutError";
 	}
 };
@@ -126,10 +126,10 @@ async function runBoundedCodexAppServerTurn(params) {
 		});
 	});
 }
-async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt = 0, timing) {
-	const totalTimeoutMs = timing?.timeoutMs ?? resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
+async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace) {
+	const totalTimeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
 	const timeoutError = new CodexBoundedTurnTimeoutError(params.taskLabel, totalTimeoutMs);
-	const deadline = timing?.deadline ?? performance.now() + totalTimeoutMs;
+	const deadline = performance.now() + totalTimeoutMs;
 	const timeoutMs = deadline - performance.now();
 	if (timeoutMs <= 0) throw timeoutError;
 	params.assertCurrent?.();
@@ -146,7 +146,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		assertCurrent: params.assertCurrent,
 		...params.signal ? { abandonSignal: params.signal } : {}
 	};
-	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CCz9ldpr.mjs").then((n) => n.v).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CE_uY0A1.mjs").then((n) => n.m).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		...clientOptions,
 		authProfileStore: params.authProfileStore
 	}));
@@ -273,17 +273,13 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		}
 	} catch (error) {
 		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
-		if (!ownsClient || !isCodexAppServerStartSelectionChangedError(error) || selectionAttempt !== 0) throw codexPrewriteRejectionCause(error);
+		throw codexPrewriteRejectionCause(error);
 	} finally {
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
 		await interruptPromise;
 		if (ownsClient) await closeCodexStartupClientBestEffort(client);
 	}
-	return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
-		deadline,
-		timeoutMs: totalTimeoutMs
-	});
 }
 function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames, enableManagedHooks) {
 	const configs = [

package/dist/.setup/{build-state-sjOWPg_o.mjs → build-state-VcujMRqP.mjs}

@@ -1,5 +1,5 @@
 //#region extensions/codex/package.json
-var version = "2026.10.5-beta.3";
+var version = "2026.10.10-beta.1";
 //#endregion
 //#region extensions/codex/src/build-state.ts
 /**

package/dist/.setup/{capabilities-DbOzOglY.mjs → capabilities-DAS-JX1z.mjs}

@@ -1,4 +1,4 @@
-import { r as CodexAppServerRpcError } from "./rpc-error-C98SHchT.mjs";
+import { r as CodexAppServerRpcError } from "./rpc-error-DemqqaxE.mjs";
 //#region extensions/codex/src/app-server/capabilities.ts
 const CODEX_CONTROL_METHODS = {
 	account: "account/read",