@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{plugin-metadata-cache-ClPJpRio.js → .setup/plugin-metadata-cache-Ctmo83k_.mjs}

@@ -1,15 +1,167 @@
-import { o as resolveCodexComputerUseConfig } from "./config-options-CXMq1T-C.js";
-import { s as resolveCodexAppServerHomeDir } from "./protocol-5bh1G-H7.js";
-import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-B57KWPQx.js";
-import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-D22rNEcR.js";
-import { n as describeControlFailure } from "./capabilities-8vx68WLH.js";
-import { i as requestCodexAppServerJson } from "./request-B7hEkBGq.js";
-import "./config-oIORaQ5T.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
-import { $ as reconcileCodexComputerUseStartArtifacts, T as acquireCodexNativeConfigFence, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, nt as resolveCodexManagedBundledMarketplacePath, p as readCodexAppServerClientProcessIdentity, rt as assertNotSymlink, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
+import { d as resolveCodexAppServerHomeDir } from "./config-security-BEReZ6go.mjs";
+import { o as resolveCodexComputerUseConfig } from "./config-options-BvaRs51b.mjs";
+import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, l as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-BnshlFag.mjs";
+import { n as describeControlFailure } from "./capabilities-CDXOOFdZ.mjs";
+import { r as requestCodexAppServerClientJson } from "./request-D2L0zMrq.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { $ as assertNotSymlink, D as acquireCodexNativeConfigFence, Q as resolveCodexManagedBundledMarketplacePath, Y as reconcileCodexComputerUseStartArtifacts, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, x as withLeasedCodexAppServerClientStartSelectionRetry } from "./shared-client-DA4VR4Eb.mjs";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-Cs08OXVQ.mjs";
+import { r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-CEv1cKwF.mjs";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+//#region extensions/codex/src/app-server/computer-use-readiness.ts
+/** Computer Use readiness probes and their native subscription lifecycle. */
+function createComputerUseRequest(params) {
+	const assertCurrent = params.assertCurrent;
+	if (params.request) {
+		const request = params.request;
+		if (!assertCurrent) return request;
+		return async (method, requestParams, options) => {
+			if (method !== "thread/unsubscribe") assertCurrent();
+			return await request(method, requestParams, options);
+		};
+	}
+	const client = params.client;
+	if (!client) throw new Error("Computer Use setup requires an acquired app-server client");
+	return async (method, requestParams, options) => await client.request(method, requestParams, {
+		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
+		signal: options?.signal ?? params.signal,
+		...method === "thread/unsubscribe" ? {} : { assertCurrent }
+	});
+}
+const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
+const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
+const COMPUTER_USE_LIST_APPS_TOOL = "list_apps";
+const COMPUTER_USE_UNIFIED_JS_TOOL = "js";
+const COMPUTER_USE_UNIFIED_JS_PROBE = "await cua.getState();";
+async function runCodexComputerUseLiveTest(params) {
+	const startedAt = Date.now();
+	let lastError;
+	let repair;
+	const probe = resolveComputerUseLiveTestProbe(params.tools);
+	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
+		let threadId;
+		let outcome;
+		try {
+			threadId = (await params.request("thread/start", {
+				input: [],
+				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
+				ephemeral: true
+			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
+			if ((await params.request("mcpServer/tool/call", {
+				threadId,
+				server: params.config.mcpServerName,
+				tool: probe.tool,
+				arguments: probe.arguments
+			}, { timeoutMs: params.config.toolCallTimeoutMs })).isError === true) throw new Error(`Computer Use readiness tool ${params.config.mcpServerName}.${probe.tool} returned an error result`);
+			outcome = {
+				ok: true,
+				liveTest: {
+					status: "passed",
+					ok: true,
+					attempted: true,
+					attempts: attempt + 1,
+					timeoutMs: params.config.liveTestTimeoutMs,
+					retried: attempt > 0,
+					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+					durationMs: Math.max(0, Date.now() - startedAt),
+					message: "Computer Use live test passed."
+				}
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error
+			};
+		}
+		let cleanupError;
+		if (threadId) try {
+			await cleanupComputerUseProbeThread(params, threadId);
+		} catch (error) {
+			cleanupError = toErrorObject(error, "Computer Use readiness cleanup failed");
+		}
+		if (!outcome.ok && (params.signal?.aborted || isCodexAppServerStartSelectionChangedError(outcome.error))) throw toErrorObject(outcome.error, "Computer Use live test failed");
+		if (cleanupError) throw cleanupError;
+		if (outcome.ok) return {
+			liveTest: outcome.liveTest,
+			...repair ? { repair } : {}
+		};
+		lastError = outcome.error;
+		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
+	}
+	const errorMessage = describeControlFailure(lastError);
+	return {
+		liveTest: {
+			status: "failed",
+			ok: false,
+			attempted: true,
+			attempts: 2,
+			timeoutMs: params.config.liveTestTimeoutMs,
+			retried: true,
+			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+			durationMs: Math.max(0, Date.now() - startedAt),
+			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
+			error: errorMessage
+		},
+		...repair ? { repair } : {}
+	};
+}
+function resolveComputerUseLiveTestProbe(tools) {
+	if (tools?.includes(COMPUTER_USE_UNIFIED_JS_TOOL) && !tools.includes(COMPUTER_USE_LIST_APPS_TOOL)) return {
+		tool: COMPUTER_USE_UNIFIED_JS_TOOL,
+		arguments: { code: COMPUTER_USE_UNIFIED_JS_PROBE }
+	};
+	return {
+		tool: COMPUTER_USE_LIST_APPS_TOOL,
+		arguments: {}
+	};
+}
+async function repairComputerUseMcpRuntime(request, config) {
+	try {
+		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [],
+			message: "Reloaded Computer Use MCP servers through Codex app-server."
+		};
+	} catch (error) {
+		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [message],
+			message
+		};
+	}
+}
+async function cleanupComputerUseProbeThread(params, threadId) {
+	try {
+		await params.request("thread/unsubscribe", { threadId }, {
+			timeoutMs: params.config.liveTestTimeoutMs,
+			signal: AbortSignal.timeout(params.config.liveTestTimeoutMs)
+		});
+	} catch (error) {
+		if (params.client) await retireUnsafeCodexTurnClientBestEffort(params.client, "Computer Use readiness cleanup");
+		throw new CodexAppServerUnsafeSubscriptionError("Computer Use readiness cleanup failed", { cause: error });
+	}
+}
+function skippedLiveTestStatus(config, message) {
+	return {
+		status: "skipped",
+		ok: false,
+		attempted: false,
+		attempts: 0,
+		timeoutMs: config.liveTestTimeoutMs,
+		retried: false,
+		repaired: false,
+		message
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use.ts
 /**
 * Computer Use plugin/MCP readiness checks and optional install flow for Codex
@@ -31,8 +183,6 @@ const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
 	"openai-curated-remote",
 	"local"
 ];
-const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
-const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
 /** Reads Computer Use readiness without installing or mutating app-server state. */
 async function readCodexComputerUseStatus(params = {}) {
 	const config = resolveComputerUseConfig(params);
@@ -41,6 +191,7 @@ async function readCodexComputerUseStatus(params = {}) {
 		return await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
+			runLiveTest: true,
 			installPlugin: false
 		});
 	} catch (error) {
@@ -48,8 +199,8 @@ async function readCodexComputerUseStatus(params = {}) {
 	}
 }
 /**
-* Ensures Computer Use is ready when enabled, optionally installing when config
-* allows safe auto-install.
+* Ensures installation and MCP exposure before a turn, optionally installing when
+* config allows safe auto-install. Only strict startup waits for a live probe.
 */
 async function ensureCodexComputerUse(params = {}) {
 	const config = resolveComputerUseConfig(params);
@@ -57,19 +208,19 @@ async function ensureCodexComputerUse(params = {}) {
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
+		runLiveTest: config.strictReadiness,
 		installPlugin: false
 	});
 	if (status.ready) return status;
-	if (isNonStrictLiveTestStartupAllowed(status, config)) return status;
 	if (config.autoInstall) {
 		const blockedAutoInstallStatus = blockUnsafeAutoInstallStatus(config);
 		if (blockedAutoInstallStatus) throw new CodexComputerUseSetupError(blockedAutoInstallStatus);
 		const installedStatus = await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
+			runLiveTest: config.strictReadiness,
 			installPlugin: true
 		});
-		if (isNonStrictLiveTestStartupAllowed(installedStatus, config)) return installedStatus;
 		if (!installedStatus.ready) throw new CodexComputerUseSetupError(installedStatus);
 		return installedStatus;
 	}
@@ -90,13 +241,13 @@ async function installCodexComputerUse(params = {}) {
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
+		runLiveTest: true,
 		installPlugin: true
 	});
 	if (!status.ready) throw new CodexComputerUseSetupError(status);
 	return status;
 }
 async function inspectCodexComputerUse(params) {
-	if (!params.installPlugin) return await inspectCodexComputerUseWithoutFence(params);
 	const resolvedRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		managedCommandOrder: "desktop-first"
@@ -104,19 +255,57 @@ async function inspectCodexComputerUse(params) {
 	const operationTimeoutMs = params.timeoutMs ?? resolvedRuntime.requestTimeoutMs;
 	const deadline = operationTimeoutMs > 0 ? Date.now() + operationTimeoutMs : void 0;
 	const remainingTimeoutMs = () => deadline === void 0 ? operationTimeoutMs : Math.max(1, deadline - Date.now());
-	let leasedClient;
+	const clientOptions = {
+		startOptions: resolvedRuntime.start,
+		pluginConfig: params.pluginConfig,
+		config: params.config,
+		agentDir: params.agentDir,
+		abandonSignal: params.signal,
+		assertCurrent: params.assertCurrent
+	};
+	const lease = {};
 	try {
 		let client = params.client;
 		if (!client && !params.request) {
 			client = await getLeasedSharedCodexAppServerClient({
-				startOptions: resolvedRuntime.start,
-				pluginConfig: params.pluginConfig,
-				timeoutMs: remainingTimeoutMs(),
-				config: params.config,
-				agentDir: params.agentDir,
-				abandonSignal: params.signal
+				...clientOptions,
+				timeoutMs: remainingTimeoutMs()
+			});
+			lease.client = client;
+		}
+		if (!params.installPlugin) {
+			if (!lease.client) return await inspectCodexComputerUseWithoutFence(params);
+			return await withLeasedCodexAppServerClientStartSelectionRetry({
+				lease,
+				options: {
+					...clientOptions,
+					timeoutMs: remainingTimeoutMs()
+				},
+				signal: params.signal,
+				run: async (readClient, requestOptions) => {
+					const { assertCurrent } = requestOptions();
+					return await inspectCodexComputerUseWithoutFence({
+						...params,
+						client: readClient,
+						request: async (method, requestParams, options) => {
+							const scopedOptions = method === "thread/unsubscribe" ? {
+								timeoutMs: options?.timeoutMs ?? operationTimeoutMs,
+								signal: options?.signal,
+								assertCurrent
+							} : requestOptions();
+							return await requestCodexAppServerClientJson({
+								client: readClient,
+								method,
+								requestParams,
+								config: params.config,
+								timeoutMs: Math.min(options?.timeoutMs ?? operationTimeoutMs, scopedOptions.timeoutMs),
+								signal: scopedOptions.signal,
+								assertCurrent: scopedOptions.assertCurrent
+							});
+						}
+					});
+				}
 			});
-			leasedClient = client;
 		}
 		const explicitManagedInstall = client && !resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall ? await resolveExplicitManagedComputerUseInstallContext({
 			...params,
@@ -167,7 +356,7 @@ async function inspectCodexComputerUse(params) {
 			if (releaseFenceOnReturn) release();
 		}
 	} finally {
-		if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
+		if (lease.client) releaseLeasedSharedCodexAppServerClient(lease.client);
 	}
 }
 async function inspectCodexComputerUseWithoutFence(params) {
@@ -198,8 +387,11 @@ async function inspectCodexComputerUseWithoutFence(params) {
 	if (!pluginInspection.ok) return pluginInspection.status;
 	return await readComputerUseTools({
 		request,
+		client: params.client,
+		signal: params.signal,
 		config: params.computerUseConfig,
 		plugin: pluginInspection.plugin,
+		runLiveTest: params.runLiveTest,
 		installPlugin: params.installPlugin,
 		releaseNativeConfigFence: params.releaseNativeConfigFence
 	});
@@ -224,7 +416,10 @@ async function prepareExplicitManagedComputerUseInstall(params) {
 		ownsIsolatedCodexHome: true,
 		desktopGeneration: context.desktopGeneration,
 		forceCacheRefresh: true,
-		assertCurrent: () => assertCodexAppServerClientStartSelectionCurrent({ client: context.client })
+		assertCurrent: () => {
+			params.assertCurrent?.();
+			assertCodexAppServerClientStartSelectionCurrent({ client: context.client });
+		}
 	});
 }
 async function resolveExplicitManagedComputerUseInstallContext(params) {
@@ -315,10 +510,14 @@ async function readComputerUseTools(params) {
 		reason: "ready",
 		message: "Computer Use is ready."
 	});
+	if (!params.runLiveTest) return status;
 	params.releaseNativeConfigFence?.();
 	const { liveTest, repair } = await runCodexComputerUseLiveTest({
 		request: params.request,
-		config: params.config
+		client: params.client,
+		signal: params.signal,
+		config: params.config,
+		tools
 	});
 	const compatibilityStartupAllowed = !liveTest.ok && !params.config.strictReadiness;
 	return {
@@ -335,88 +534,6 @@ async function readComputerUseTools(params) {
 		message: liveTest.ok ? "Computer Use is ready." : compatibilityStartupAllowed ? `${liveTest.message} Startup is allowed because computerUse.strictReadiness is false.` : liveTest.message
 	};
 }
-function isNonStrictLiveTestStartupAllowed(status, config) {
-	return !config.strictReadiness && status.reason === "live_test_failed" && status.installed && status.pluginEnabled && status.mcpServerAvailable && status.installation.ok && status.exposure.ok;
-}
-async function runCodexComputerUseLiveTest(params) {
-	const startedAt = Date.now();
-	let lastError;
-	let repair;
-	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
-		let threadId;
-		try {
-			threadId = (await params.request("thread/start", {
-				input: [],
-				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
-				ephemeral: true
-			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
-			await params.request("mcpServer/tool/call", {
-				threadId,
-				server: params.config.mcpServerName,
-				tool: "list_apps",
-				arguments: {}
-			}, { timeoutMs: params.config.toolCallTimeoutMs });
-			return {
-				liveTest: {
-					status: "passed",
-					ok: true,
-					attempted: true,
-					attempts: attempt + 1,
-					timeoutMs: params.config.liveTestTimeoutMs,
-					retried: attempt > 0,
-					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-					durationMs: Math.max(0, Date.now() - startedAt),
-					message: "Computer Use live test passed."
-				},
-				...repair ? { repair } : {}
-			};
-		} catch (error) {
-			if (isCodexAppServerStartSelectionChangedError(error)) throw error;
-			lastError = error;
-		} finally {
-			if (threadId) await cleanupComputerUseProbeThread(params.request, threadId, params.config);
-		}
-		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
-	}
-	const errorMessage = describeControlFailure(lastError);
-	return {
-		liveTest: {
-			status: "failed",
-			ok: false,
-			attempted: true,
-			attempts: 2,
-			timeoutMs: params.config.liveTestTimeoutMs,
-			retried: true,
-			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-			durationMs: Math.max(0, Date.now() - startedAt),
-			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
-			error: errorMessage
-		},
-		...repair ? { repair } : {}
-	};
-}
-async function repairComputerUseMcpRuntime(request, config) {
-	try {
-		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [],
-			message: "Reloaded Computer Use MCP servers through Codex app-server."
-		};
-	} catch (error) {
-		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [message],
-			message
-		};
-	}
-}
-async function cleanupComputerUseProbeThread(request, threadId, config) {
-	await Promise.allSettled([request("thread/unsubscribe", { threadId }, { timeoutMs: config.liveTestTimeoutMs }), request("thread/archive", { threadId }, { timeoutMs: config.liveTestTimeoutMs })]);
-}
 async function resolveMarketplaceRef(params) {
 	let preferredMarketplaceName = params.config.marketplaceName;
 	if (params.config.marketplaceSource && params.allowAdd) {
@@ -679,44 +796,12 @@ function exposureStatusFromTools(config, tools) {
 		message: `Computer Use MCP server ${config.mcpServerName} exposes ${tools.length} tools.`
 	};
 }
-function skippedLiveTestStatus(config, message) {
-	return {
-		status: "skipped",
-		ok: false,
-		attempted: false,
-		attempts: 0,
-		timeoutMs: config.liveTestTimeoutMs,
-		retried: false,
-		repaired: false,
-		message
-	};
-}
 function pluginWarnings(plugin) {
 	const warnings = [];
 	const source = plugin.summary.source;
 	if (source && typeof source === "object" && "type" in source && source.type === "remote") warnings.push("Computer Use plugin is resolved from a remote marketplace; live local bundles are preferred.");
 	return warnings;
 }
-function createComputerUseRequest(params) {
-	if (params.request) return params.request;
-	if (params.client) return async (method, requestParams, options) => await params.client.request(method, requestParams, {
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
-		signal: params.signal
-	});
-	const runtime = resolveCodexAppServerRuntimeOptions({
-		pluginConfig: params.pluginConfig,
-		managedCommandOrder: "desktop-first"
-	});
-	return async (method, requestParams, options) => await requestCodexAppServerJson({
-		method,
-		requestParams,
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs ?? runtime.requestTimeoutMs,
-		pluginConfig: params.pluginConfig,
-		startOptions: runtime.start,
-		config: params.config,
-		agentDir: params.agentDir
-	});
-}
 function resolveComputerUseConfig(params) {
 	const overrides = params.forceEnable ? {
 		...params.overrides,

package/dist/.setup/protocol-CANUwXJ3.mjs

@@ -0,0 +1,17 @@
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
+}
+function isJsonObject(value) {
+	return isRecord(value);
+}
+//#endregion
+export { isJsonObject as i, assertCodexThreadForkParams as n, flattenCodexDynamicToolFunctions as r, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as t };

package/dist/{provider-MQ8PVkuE.js → .setup/provider-BOsxQHOM.mjs}

@@ -9,10 +9,14 @@ function buildCodexMigrationProvider(params = {}) {
 	return {
 		id: "codex",
 		label: "Codex",
-		description: "Import Codex memory and skills while keeping Codex native plugins and hooks explicit.",
+		description: [
+			"Import consolidated memories, selected Codex and personal AgentSkills, and selected eligible openai-curated plugins.",
+			"Auth credentials require separate consent. Sessions and chat history are not imported.",
+			"Codex config and hooks are saved for manual review, not activated. Source files are not moved or deleted."
+		].join(" "),
 		supportedItemKinds: ["memory", "auth"],
 		async detect(ctx) {
-			const { discoverCodexSource, hasCodexSource } = await import("./source-CElXU0Oy.js").then((n) => n.i);
+			const { discoverCodexSource, hasCodexSource } = await import("./source-CUzJq5WN.mjs").then((n) => n.a);
 			const source = await discoverCodexSource({
 				input: ctx.source,
 				memoryOnly: isMemoryOnlyMigration(ctx),
@@ -28,16 +32,16 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		async plan(ctx) {
-			const { buildCodexMigrationPlan } = await import("./plan-7uG-Fp36.js");
+			const { buildCodexMigrationPlan } = await import("./plan-CN3VwfNU.mjs");
 			return buildCodexMigrationPlan(ctx);
 		},
 		deferredApply: { retrySafe: true },
 		prepareApply(ctx) {
 			if (isMemoryOnlyMigration(ctx) || isAuthOnlyMigration(ctx)) return;
-			return import("./apply-CvT8tW5i.js").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+			return import("./apply-DDOi8uNx.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
 		},
 		async apply(ctx, plan) {
-			const { applyCodexMigrationPlan } = await import("./apply-CvT8tW5i.js");
+			const { applyCodexMigrationPlan } = await import("./apply-DDOi8uNx.mjs");
 			return await applyCodexMigrationPlan({
 				ctx,
 				plan,

package/dist/{provider-capabilities-BvCUL69A.js → .setup/provider-capabilities-BfE88FZ5.mjs}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CscigXXL.js";
-import { ct as normalizeCodexDynamicToolName } from "./thread-lifecycle-DXl1-I6b.js";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-DA4VR4Eb.mjs";
+import { ut as normalizeCodexDynamicToolName } from "./thread-requests-BLvGkP2R.mjs";
 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
@@ -51,6 +51,27 @@ function createGatewayProcessProjection(createProjection, processTool) {
 		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."
 	});
 }
+function createSandboxExecProjection(execTool) {
+	return {
+		...execTool,
+		name: "sandbox_exec",
+		description: "Run a shell command through OpenClaw's configured sandbox backend for this session. Use when OpenClaw sandboxing is active or when a command must execute in the sandbox backend, such as an SSH-backed sandbox or Docker container-path bind layout. Use Codex's native shell only when no OpenClaw sandbox is active and native Code Mode is available.",
+		execute: async (toolCallId, args, signal, onUpdate) => {
+			const result = await execTool.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, "Use sandbox_process (list/poll/log/write/send-keys/submit/paste/kill/clear/remove) for follow-up.") }) : item)
+			};
+		}
+	};
+}
+function createSandboxProcessProjection(processTool) {
+	return {
+		...processTool,
+		name: "sandbox_process",
+		description: "Manage background shell sessions through OpenClaw's configured sandbox backend for this session: list, poll, log, write, send-keys, submit, paste, kill, clear, or remove. Use only for sandbox follow-up; use Codex's native shell session handling only when no OpenClaw sandbox is active and native Code Mode is available."
+	};
+}
 //#endregion
 //#region extensions/codex/src/app-server/provider-capabilities.ts
 function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
@@ -59,6 +80,12 @@ function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
 	return provider === "openai" ? "supported" : "unsupported";
 }
 async function readConfiguredProviderWebSearchSupport(params) {
+	if (params.expectedNativeModelProvider) {
+		if (((await params.client.request("config/read", { includeLayers: false }, {
+			timeoutMs: params.timeoutMs,
+			signal: params.signal
+		})).config.model_provider ?? "openai") !== params.expectedNativeModelProvider) return "unknown";
+	}
 	return (await params.client.request("modelProvider/capabilities/read", {}, {
 		timeoutMs: params.timeoutMs,
 		signal: params.signal
@@ -89,6 +116,7 @@ async function resolveCodexProviderWebSearchSupport(params) {
 			client,
 			timeoutMs: params.appServer.requestTimeoutMs,
 			modelProviderOverride: params.modelProviderOverride,
+			expectedNativeModelProvider: params.expectedNativeModelProvider,
 			signal: params.signal
 		});
 	} catch {
@@ -98,4 +126,4 @@ async function resolveCodexProviderWebSearchSupport(params) {
 	}
 }
 //#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 };
+export { CODEX_NODE_EXEC_DYNAMIC_TOOL_NAME as a, createNodeExecAliasDynamicTool as c, isCodexDynamicToolExcluded as d, CODEX_GATEWAY_PROCESS_DYNAMIC_TOOL_NAME as i, createSandboxExecProjection as l, resolveCodexProviderWebSearchSupportForClient as n, createGatewayExecProjection as o, CODEX_GATEWAY_EXEC_DYNAMIC_TOOL_NAME as r, createGatewayProcessProjection as s, resolveCodexProviderWebSearchSupport as t, createSandboxProcessProjection as u };