@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{isolated-completion-C58NbL40.js → isolated-completion-Cbbx_5Ed.js}

@@ -1,7 +1,7 @@
-import { T as readCodexPluginConfig, h as resolveCodexAppServerHomeScope } from "./session-binding-DPxIvMgE.js";
-import { ct as isJsonObject, rt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-kIBbGjk4.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
-import { i as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+import { T as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-Cxw3Cl3k.js";
+import { Ht as isJsonObject, Lt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-kNkljY-R.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-rq5tiSXk.js";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-C5-Ds8mA.js";
 //#region extensions/codex/src/app-server/isolated-completion.ts
 const ISOLATED_PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set(["agentMessage", "reasoning"]);
 function assertIsolatedCompletionItems(items, prompt) {

package/dist/launch-args-sXOAg0SX.js

@@ -0,0 +1,84 @@
+//#region extensions/codex/src/app-server/launch-args.ts
+const CODEX_VALUE_OPTIONS = /* @__PURE__ */ new Set([
+	"-m",
+	"--model",
+	"--local-provider",
+	"-p",
+	"--profile",
+	"-s",
+	"--sandbox",
+	"-a",
+	"--ask-for-approval",
+	"-C",
+	"--cd",
+	"--add-dir",
+	"--remote",
+	"--remote-auth-token-env",
+	"-c",
+	"--config",
+	"--enable",
+	"--disable",
+	"--listen",
+	"--code-mode-host",
+	"--ws-auth",
+	"--ws-token-file",
+	"--ws-token-sha256",
+	"--ws-shared-secret-file",
+	"--ws-issuer",
+	"--ws-audience",
+	"--ws-max-clock-skew-seconds"
+]);
+/** One tokenization owner for launch, turn policy, reviewer trust, and private turns. */
+function readCodexArgs(args) {
+	const tokens = [];
+	let nativeSubcommand = false;
+	let end = 0;
+	for (const [index, arg] of args.entries()) {
+		if (index < end) continue;
+		end = index + 1;
+		const attached = /^(--[^=]+)=([\s\S]*)$/u.exec(arg) ?? /^(-[cmpisaC])=?([\s\S]+)$/u.exec(arg);
+		const name = attached?.[1] ?? arg;
+		let value = attached?.[2];
+		if (name === "-i" || name === "--image") while (args[end]?.startsWith("-") === false) end += 1;
+		else if (!attached && CODEX_VALUE_OPTIONS.has(name)) {
+			value = args[end];
+			if (value !== void 0) end += 1;
+		}
+		tokens.push({
+			index,
+			end,
+			name,
+			value
+		});
+		if (name === "app-server") nativeSubcommand = true;
+		if (name === "--" && nativeSubcommand) break;
+	}
+	return tokens;
+}
+function readCodexAppServerConfigOptions(args) {
+	return readCodexArgs(args).filter(({ name }) => name === "-c" || name === "--config" || name === "-p" || name === "--profile");
+}
+/** Keeps Codex overrides in one CLI scope without rewriting raw TOML or wrapper prefixes. */
+function normalizeCodexAppServerArgs(rawArgs, enforcedOverride) {
+	const tokens = readCodexArgs(rawArgs);
+	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
+	const prefix = subcommandIndex < 0 ? [...rawArgs] : rawArgs.slice(0, subcommandIndex);
+	const suffix = [];
+	if (subcommandIndex >= 0) for (const token of tokens) {
+		if (token.index <= subcommandIndex) continue;
+		if (token.name === "--") {
+			suffix.push(...rawArgs.slice(token.index));
+			break;
+		}
+		(token.name === "-c" || token.name === "--config" ? prefix : suffix).push(...rawArgs.slice(token.index, token.end));
+	}
+	if (enforcedOverride && !(prefix.at(-2) === "-c" && prefix.at(-1) === enforcedOverride)) prefix.push("-c", enforcedOverride);
+	const normalized = subcommandIndex < 0 ? prefix : [
+		...prefix,
+		"app-server",
+		...suffix
+	];
+	return normalized.length === rawArgs.length && normalized.every((arg, index) => arg === rawArgs[index]) ? rawArgs : normalized;
+}
+//#endregion
+export { readCodexAppServerConfigOptions as n, normalizeCodexAppServerArgs as t };

package/dist/managed-binary-ZkGodW19.js

@@ -0,0 +1,248 @@
+import { createRequire } from "node:module";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { constants, existsSync, readFileSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+//#region extensions/codex/src/app-server/desktop-app-paths.ts
+/** Shared path candidates for Codex's macOS desktop app bundle. */
+const MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES = [{
+	appName: "ChatGPT.app",
+	appBundlePath: "/Applications/ChatGPT.app",
+	appServerCommandPath: "/Applications/ChatGPT.app/Contents/Resources/codex",
+	bundledMarketplacePath: "/Applications/ChatGPT.app/Contents/Resources/plugins/openai-bundled",
+	computerUseServiceAppPaths: ["/Applications/ChatGPT.app/Contents/Resources/cua_node/lib/node_modules/@oai/sky/Codex Computer Use.app", "/Applications/ChatGPT.app/Contents/Resources/plugins/openai-bundled/plugins/computer-use/Codex Computer Use.app"]
+}, {
+	appName: "Codex.app",
+	appBundlePath: "/Applications/Codex.app",
+	appServerCommandPath: "/Applications/Codex.app/Contents/Resources/codex",
+	bundledMarketplacePath: "/Applications/Codex.app/Contents/Resources/plugins/openai-bundled",
+	computerUseServiceAppPaths: ["/Applications/Codex.app/Contents/Resources/plugins/openai-bundled/plugins/computer-use/Codex Computer Use.app", "/Applications/Codex.app/Contents/Resources/cua_node/lib/node_modules/@oai/sky/Codex Computer Use.app"]
+}];
+function resolveMacOSDesktopCodexAppPathCandidates(platform = process.platform) {
+	return platform === "darwin" ? MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES : [];
+}
+function resolveMacOSDesktopCodexAppServerCommandCandidates(platform = process.platform) {
+	return resolveMacOSDesktopCodexAppPathCandidates(platform).map((candidate) => candidate.appServerCommandPath);
+}
+function resolveMacOSDesktopCodexBundledMarketplaceCandidates(platform = process.platform) {
+	return resolveMacOSDesktopCodexAppPathCandidates(platform).map((candidate) => candidate.bundledMarketplacePath);
+}
+function resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform = process.platform, appServerCommand) {
+	if (platform !== "darwin") return [];
+	const candidates = resolveMacOSDesktopCodexAppPathCandidates(platform);
+	const matchingCandidate = appServerCommand ? candidates.find((candidate) => path.resolve(candidate.appServerCommandPath) === path.resolve(appServerCommand)) : void 0;
+	const orderedCandidates = matchingCandidate ? [matchingCandidate, ...candidates.filter((candidate) => candidate !== matchingCandidate)] : candidates;
+	return [...new Set(orderedCandidates.flatMap((candidate) => candidate.computerUseServiceAppPaths))];
+}
+function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}) {
+	const candidates = params.candidates ?? resolveMacOSDesktopCodexBundledMarketplaceCandidates(params.platform);
+	const pathExists = params.pathExists ?? existsSync;
+	return candidates.find((candidate) => pathExists(candidate));
+}
+//#endregion
+//#region extensions/codex/src/app-server/version.ts
+/**
+* Version and package pins for the managed Codex app-server runtime.
+*/
+/** Exact Codex app-server version shipped by the OpenClaw Codex bridge. */
+const CODEX_APP_SERVER_VERSION = "0.151.0";
+/** Inclusive runtime compatibility floor for external app-server binaries. */
+const MIN_SUPPORTED_CODEX_APP_SERVER_VERSION = "0.149.0";
+/** npm package name for the managed Codex app-server binary. */
+const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
+//#endregion
+//#region extensions/codex/src/app-server/managed-binary.ts
+/**
+* Resolves the managed Codex app-server binary shipped with or installed beside
+* the Codex plugin before stdio startup.
+*/
+const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(path.dirname(fileURLToPath(import.meta.url)));
+let registeredCodexPluginRoot;
+/** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
+function setManagedCodexPluginRoot(pluginRoot) {
+	registeredCodexPluginRoot = pluginRoot;
+}
+/** Rewrites managed stdio start options to point at an executable Codex binary path. */
+async function resolveManagedCodexAppServerStartOptions(startOptions, options = {}) {
+	if (startOptions.transport !== "stdio" || startOptions.commandSource !== "managed") return startOptions;
+	const platform = options.platform ?? process.platform;
+	const commandPaths = await findManagedCodexAppServerCommandPaths({
+		candidateCommandPaths: resolveManagedCodexAppServerCommandCandidates(options.pluginRoot ?? registeredCodexPluginRoot ?? CODEX_PLUGIN_ROOT, platform, startOptions.managedCommandOrder ?? "package-first"),
+		pathExists: options.pathExists ?? commandPathExists,
+		platform
+	});
+	const commandPath = expectDefined(commandPaths[0], "resolved managed Codex command path");
+	const managedFallbackCommandPaths = commandPaths.slice(1);
+	return {
+		...startOptions,
+		command: commandPath,
+		commandSource: "resolved-managed",
+		...managedFallbackCommandPaths.length > 0 ? { managedFallbackCommandPaths } : {}
+	};
+}
+/** Resolves the native artifact behind a successful managed launcher selection. */
+function resolveManagedCodexNativeCommand(command, options = {}) {
+	const platform = options.platform ?? process.platform;
+	if (isManagedCodexDesktopCommand(command, platform)) return command;
+	const target = resolveCodexNativeTarget(platform, options.arch ?? process.arch);
+	if (!target) return;
+	const packageRoot = resolveManagedCodexPackageRootForCommand(command, platform);
+	if (!packageRoot) return;
+	const resolvePackageJson = options.resolvePackageJson ?? resolvePackageJsonFromRoot;
+	const pathExists = options.pathExists ?? existsSync;
+	for (const packageName of [target.packageName, MANAGED_CODEX_APP_SERVER_PACKAGE]) {
+		const packageJsonPath = resolvePackageJson(packageName, packageRoot);
+		if (!packageJsonPath) continue;
+		const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
+		if (pathExists(candidate)) return candidate;
+	}
+}
+/** Returns whether a command is one of the standard macOS desktop app executables. */
+function isManagedCodexDesktopCommand(command, platform = process.platform) {
+	return platform === "darwin" && resolveMacOSDesktopCodexAppServerCommandCandidates(platform).some((candidate) => candidate === command);
+}
+function resolveManagedCodexPackageRootForCommand(command, platform) {
+	const pathApi = pathForPlatform(platform);
+	const commandPaths = [command];
+	try {
+		commandPaths.unshift(realpathSync(command));
+	} catch {}
+	for (const commandPath of commandPaths) {
+		let current = pathApi.dirname(commandPath);
+		while (true) {
+			if (pathApi.basename(current) === "codex" && pathApi.basename(pathApi.dirname(current)) === "@openai") return current;
+			if (pathApi.basename(current) === ".bin") return pathApi.join(pathApi.dirname(current), "@openai", "codex");
+			const parent = pathApi.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+}
+function resolveCodexNativeTarget(platform, arch) {
+	if ((platform === "linux" || platform === "android") && arch === "x64") return {
+		packageName: "@openai/codex-linux-x64",
+		triple: "x86_64-unknown-linux-musl"
+	};
+	if ((platform === "linux" || platform === "android") && arch === "arm64") return {
+		packageName: "@openai/codex-linux-arm64",
+		triple: "aarch64-unknown-linux-musl"
+	};
+	if (platform === "darwin" && arch === "x64") return {
+		packageName: "@openai/codex-darwin-x64",
+		triple: "x86_64-apple-darwin"
+	};
+	if (platform === "darwin" && arch === "arm64") return {
+		packageName: "@openai/codex-darwin-arm64",
+		triple: "aarch64-apple-darwin"
+	};
+	if (platform === "win32" && arch === "x64") return {
+		packageName: "@openai/codex-win32-x64",
+		triple: "x86_64-pc-windows-msvc"
+	};
+	if (platform === "win32" && arch === "arm64") return {
+		packageName: "@openai/codex-win32-arm64",
+		triple: "aarch64-pc-windows-msvc"
+	};
+}
+function resolvePackageJsonFromRoot(packageName, root) {
+	try {
+		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
+	} catch {
+		return;
+	}
+}
+function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, managedCommandOrder) {
+	const pathApi = pathForPlatform(platform);
+	const commandName = platform === "win32" ? "codex.cmd" : "codex";
+	const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
+	const packageCommandPaths = [...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)), ...resolveManagedCodexPackageBinCandidates(roots, platform)];
+	const desktopCommandPaths = resolveDesktopCodexAppServerCommandCandidates(platform);
+	const orderedCommandPaths = managedCommandOrder === "desktop-first" ? [...desktopCommandPaths, ...packageCommandPaths] : [...packageCommandPaths, ...desktopCommandPaths];
+	return [...new Set(orderedCommandPaths)];
+}
+function resolveDesktopCodexAppServerCommandCandidates(platform) {
+	return resolveMacOSDesktopCodexAppServerCommandCandidates(platform);
+}
+function resolveDefaultCodexPluginRoot(moduleDir) {
+	const moduleBaseName = path.basename(moduleDir);
+	if (moduleBaseName === "dist" || moduleBaseName === "dist-runtime") return path.dirname(moduleDir);
+	return path.resolve(moduleDir, "..", "..");
+}
+function resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform) {
+	const pathApi = pathForPlatform(platform);
+	const directRoots = [
+		pluginRoot,
+		pathApi.dirname(pluginRoot),
+		pathApi.dirname(pathApi.dirname(pluginRoot)),
+		isDistExtensionRoot(pluginRoot, platform) ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot))) : null
+	].filter((root) => Boolean(root));
+	return [.../* @__PURE__ */ new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
+}
+function resolveNearestNodeModulesProjectRoots(roots, platform) {
+	const pathApi = pathForPlatform(platform);
+	const projectRoots = [];
+	for (const root of roots) {
+		let current = pathApi.resolve(root);
+		while (true) {
+			if (pathApi.basename(current) === "node_modules") {
+				projectRoots.push(pathApi.dirname(current));
+				break;
+			}
+			const parent = pathApi.dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+	return projectRoots;
+}
+function resolveManagedCodexPackageBinCandidates(roots, platform) {
+	if (platform === "win32") return [];
+	const candidates = [];
+	for (const root of roots) {
+		const candidate = resolveManagedCodexPackageBinCandidate(root);
+		if (candidate) candidates.push(candidate);
+	}
+	return candidates;
+}
+function resolveManagedCodexPackageBinCandidate(root) {
+	try {
+		const packageJsonPath = createRequire(path.join(root, "package.json")).resolve(`${MANAGED_CODEX_APP_SERVER_PACKAGE}/package.json`);
+		const packageRoot = path.dirname(packageJsonPath);
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		const packageBin = packageJson.bin && typeof packageJson.bin === "object" ? packageJson.bin : void 0;
+		const binPath = typeof packageJson.bin === "string" ? packageJson.bin : typeof packageBin?.codex === "string" ? packageBin.codex : null;
+		return binPath ? path.resolve(packageRoot, binPath) : null;
+	} catch {
+		return null;
+	}
+}
+function isDistExtensionRoot(pluginRoot, platform) {
+	const pathApi = pathForPlatform(platform);
+	const extensionsDir = pathApi.dirname(pluginRoot);
+	const distDir = pathApi.dirname(extensionsDir);
+	return pathApi.basename(extensionsDir) === "extensions" && (pathApi.basename(distDir) === "dist" || pathApi.basename(distDir) === "dist-runtime");
+}
+function pathForPlatform(platform) {
+	return platform === "win32" ? path.win32 : path.posix;
+}
+async function findManagedCodexAppServerCommandPaths(params) {
+	const commandPaths = [];
+	for (const commandPath of params.candidateCommandPaths) if (await params.pathExists(commandPath, params.platform)) commandPaths.push(commandPath);
+	if (commandPaths.length > 0) return commandPaths;
+	throw new Error([
+		`Managed Codex app-server binary was not found for ${MANAGED_CODEX_APP_SERVER_PACKAGE}.`,
+		"Reinstall or update OpenClaw, or run pnpm install in a source checkout.",
+		"Set plugins.entries.codex.config.appServer.command or OPENCLAW_CODEX_APP_SERVER_BIN to use a custom Codex binary."
+	].join(" "));
+}
+async function commandPathExists(filePath, platform) {
+	try {
+		await access(filePath, platform === "win32" ? constants.F_OK : constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { CODEX_APP_SERVER_VERSION as a, resolveMacOSDesktopCodexAppPathCandidates as c, setManagedCodexPluginRoot as i, resolveMacOSDesktopCodexBundledMarketplaceCandidates as l, resolveManagedCodexAppServerStartOptions as n, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as o, resolveManagedCodexNativeCommand as r, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as u };

package/dist/media-understanding-provider.js

@@ -1,6 +1,6 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
-import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-rq5tiSXk.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts
 /**
 * Codex-backed media understanding provider for bounded image description and

package/dist/model-catalog-o6Cgjoss.js

@@ -0,0 +1,101 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-DVfUQBlQ.js";
+import { T as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { Ht as isJsonObject, r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-kNkljY-R.js";
+import { t as listAllCodexAppServerModels } from "./models-DgFWSuxA.js";
+import { o as withCodexAppServerJsonClient } from "./request-CCm4LaED.js";
+//#region extensions/codex/src/app-server/model-catalog.ts
+const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
+const INPUT_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"image",
+	"audio",
+	"video",
+	"document"
+]);
+function isModelInputType(value) {
+	return INPUT_TYPES.has(value);
+}
+function codexAppServerModelsToCatalogEntries(models, runtime) {
+	return models.map((model, providerOrder) => {
+		const input = model.inputModalities.filter(isModelInputType);
+		const runtimeParams = buildCodexRuntimeModelParams(model.id, model.model);
+		return {
+			provider: "openai",
+			id: model.id,
+			name: model.displayName ?? model.id,
+			providerOrder,
+			nativeRuntime: runtime,
+			reasoning: model.supportedReasoningEfforts.length > 0,
+			...input.length > 0 ? { input } : {},
+			...runtimeParams ? { params: runtimeParams } : {},
+			compat: {
+				supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
+				supportedReasoningEfforts: model.supportedReasoningEfforts
+			}
+		};
+	});
+}
+/** One harness registration owns its observations; none travel with worker snapshots. */
+function createCodexAppServerModelCatalog(runtime) {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	const scopeKey = (params) => JSON.stringify([
+		params.agentId,
+		params.agentDir,
+		params.workspaceDir
+	]);
+	let disposed = false;
+	return {
+		dispose() {
+			disposed = true;
+		},
+		read(params, pluginConfig) {
+			const observation = scopes.get(params.config)?.get(scopeKey(params));
+			return !disposed && params.provider === "openai" && observation !== void 0 && observation.pluginConfig === pluginConfig && observation.models?.has(params.modelId) && observation.accountType && observation.isCurrent?.() ? { accountType: observation.accountType } : void 0;
+		},
+		async load(params, pluginConfig) {
+			if (disposed) return [];
+			let observations = scopes.get(params.config);
+			if (!observations) {
+				observations = /* @__PURE__ */ new Map();
+				scopes.set(params.config, observations);
+			}
+			const key = scopeKey(params);
+			const observation = { pluginConfig };
+			observations.set(key, observation);
+			const discovery = readCodexPluginConfig(pluginConfig).discovery;
+			if (discovery?.enabled === false) return [];
+			const { start } = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+			const timeoutMs = discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS;
+			const result = await withCodexAppServerJsonClient({
+				startOptions: start,
+				config: params.config,
+				agentDir: params.agentDir,
+				timeoutMs
+			}, async (request, client) => {
+				const isCurrent = captureSharedCodexAppServerCatalogLifetime(client);
+				const listed = await listAllCodexAppServerModels({
+					request,
+					limit: 100
+				});
+				const account = await request({
+					method: "account/read",
+					requestParams: { refreshToken: false }
+				});
+				const observedType = isJsonObject(account.account) ? account.account.type : void 0;
+				const accountType = account.requiresOpenaiAuth === true ? observedType === "apiKey" || observedType === "chatgpt" ? observedType : void 0 : void 0;
+				return {
+					models: listed.models,
+					isCurrent,
+					accountType
+				};
+			});
+			if (disposed || observations.get(key) !== observation || !result.isCurrent()) return [];
+			observation.models = new Set(result.models.map((model) => model.id));
+			observation.accountType = result.accountType;
+			observation.isCurrent = result.isCurrent;
+			return codexAppServerModelsToCatalogEntries(result.models, runtime);
+		}
+	};
+}
+//#endregion
+export { createCodexAppServerModelCatalog };

package/dist/{models-BFlpn1Ex.js → models-DgFWSuxA.js}

@@ -1,4 +1,4 @@
-import { t as assertCodexModelListResponse } from "./protocol-validators-B4F7L8Rf.js";
+import { n as assertCodexModelListResponse } from "./protocol-validators-Bg5rpNxk.js";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -7,22 +7,18 @@ import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/stri
 */
 /** Lists one Codex app-server model page using the configured auth/client options. */
 async function listCodexAppServerModels(options = {}) {
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => requestModelListPage(client, {
-		...options,
-		timeoutMs
-	}));
+	return await withCodexAppServerModelRequest(options, async (request) => requestModelListPage(request, options));
 }
 /** Walks Codex app-server model pages until exhaustion or the max-page guard. */
 async function listAllCodexAppServerModels(options = {}) {
 	const maxPages = normalizeMaxPages(options.maxPages);
-	return await withCodexAppServerModelClient(options, async ({ client, timeoutMs }) => {
+	return await withCodexAppServerModelRequest(options, async (request) => {
 		const models = [];
 		let cursor = options.cursor;
 		let nextCursor;
 		for (let page = 0; page < maxPages; page += 1) {
-			const result = await requestModelListPage(client, {
+			const result = await requestModelListPage(request, {
 				...options,
-				timeoutMs,
 				cursor
 			});
 			models.push(...result.models);
@@ -37,18 +33,13 @@ async function listAllCodexAppServerModels(options = {}) {
 		};
 	});
 }
-async function withCodexAppServerModelClient(options, run) {
+async function withCodexAppServerModelRequest(options, run) {
+	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-kIBbGjk4.js").then((n) => n.m);
-	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
-		startOptions: options.startOptions,
-		timeoutMs,
-		authProfileId: options.authProfileId,
-		authRequirement: options.authRequirement,
-		agentDir: options.agentDir,
-		config: options.config
-	}) : await createIsolatedCodexAppServerClient({
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-kNkljY-R.js").then((n) => n.x);
+	const { requestCodexAppServerClientJson } = await import("./request-CCm4LaED.js").then((n) => n.a);
+	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,
 		authProfileId: options.authProfileId,
@@ -57,21 +48,26 @@ async function withCodexAppServerModelClient(options, run) {
 		config: options.config
 	});
 	try {
-		return await run({
+		return await run((request) => requestCodexAppServerClientJson({
+			...request,
 			client,
-			timeoutMs
-		});
+			timeoutMs,
+			config: options.config
+		}));
 	} finally {
 		if (useSharedClient) releaseLeasedSharedCodexAppServerClient(client);
 		else client.close();
 	}
 }
-async function requestModelListPage(client, options) {
-	return readModelListResult(await client.request("model/list", {
-		limit: options.limit ?? null,
-		cursor: options.cursor ?? null,
-		includeHidden: options.includeHidden ?? null
-	}, { timeoutMs: options.timeoutMs }));
+async function requestModelListPage(request, options) {
+	return readModelListResult(await request({
+		method: "model/list",
+		requestParams: {
+			limit: options.limit ?? null,
+			cursor: options.cursor ?? null,
+			includeHidden: options.includeHidden ?? null
+		}
+	}));
 }
 /** Parses a raw Codex app-server model/list response into OpenClaw's normalized shape. */
 function readModelListResult(value) {
@@ -96,7 +92,8 @@ function readCodexModel(value) {
 		isDefault: value.isDefault,
 		inputModalities: value.inputModalities,
 		supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-		...normalizeOptionalString(value.defaultReasoningEffort) ? { defaultReasoningEffort: normalizeOptionalString(value.defaultReasoningEffort) } : {}
+		...normalizeOptionalString(value.defaultReasoningEffort) ? { defaultReasoningEffort: normalizeOptionalString(value.defaultReasoningEffort) } : {},
+		...value.multiAgentVersion !== void 0 ? { multiAgentVersion: value.multiAgentVersion } : {}
 	};
 }
 function readReasoningEfforts(value) {