@openclaw/codex 2026.8.1-beta.3 → 2026.8.2

package/dist/{isolated-completion-DPMtlH9r.js → isolated-completion-CxTus3vZ.js}

@@ -1,7 +1,7 @@
-import { h as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-CpNeo5AE.js";
-import { at as resolveCodexAppServerPreparedAuthHandoff, ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
-import { i as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+import { T as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-CcYL77O6.js";
+import { Ht as isJsonObject, Lt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-B1tT5U6r.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DRC3hcjm.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-By4FZC6i.js → managed-binary-ZkGodW19.js}

@@ -4,14 +4,51 @@ 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.149.1";
+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.147.0";
+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
@@ -22,7 +59,6 @@ const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
 */
 const CODEX_PLUGIN_ROOT = resolveDefaultCodexPluginRoot(path.dirname(fileURLToPath(import.meta.url)));
 let registeredCodexPluginRoot;
-const MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS = ["/Applications/ChatGPT.app/Contents/Resources/codex", "/Applications/Codex.app/Contents/Resources/codex"];
 /** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
 function setManagedCodexPluginRoot(pluginRoot) {
 	registeredCodexPluginRoot = pluginRoot;
@@ -62,9 +98,9 @@ function resolveManagedCodexNativeCommand(command, options = {}) {
 		if (pathExists(candidate)) return candidate;
 	}
 }
-/** Returns whether a resolved managed command is owned by the macOS desktop app. */
+/** Returns whether a command is one of the standard macOS desktop app executables. */
 function isManagedCodexDesktopCommand(command, platform = process.platform) {
-	return platform === "darwin" && MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS.some((candidate) => candidate === command);
+	return platform === "darwin" && resolveMacOSDesktopCodexAppServerCommandCandidates(platform).some((candidate) => candidate === command);
 }
 function resolveManagedCodexPackageRootForCommand(command, platform) {
 	const pathApi = pathForPlatform(platform);
@@ -126,7 +162,7 @@ function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, man
 	return [...new Set(orderedCommandPaths)];
 }
 function resolveDesktopCodexAppServerCommandCandidates(platform) {
-	return platform === "darwin" ? [...MACOS_DESKTOP_CODEX_APP_SERVER_COMMANDS] : [];
+	return resolveMacOSDesktopCodexAppServerCommandCandidates(platform);
 }
 function resolveDefaultCodexPluginRoot(moduleDir) {
 	const moduleBaseName = path.basename(moduleDir);
@@ -209,4 +245,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#endregion
-export { CODEX_APP_SERVER_VERSION as a, setManagedCodexPluginRoot as i, resolveManagedCodexAppServerStartOptions as n, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as o, resolveManagedCodexNativeCommand as r, isManagedCodexDesktopCommand as t };
+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,4 +1,4 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DRC3hcjm.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

package/dist/model-catalog-DULBcniB.js

@@ -0,0 +1,101 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-BgeB7LnD.js";
+import { T as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions } from "./config-CcYL77O6.js";
+import { Ht as isJsonObject, r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-B1tT5U6r.js";
+import { t as listAllCodexAppServerModels } from "./models-DaWfETQk.js";
+import { o as withCodexAppServerJsonClient } from "./request-BWxweEdK.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-CZw1wClT.js → models-DaWfETQk.js}

@@ -1,4 +1,4 @@
-import { t as assertCodexModelListResponse } from "./protocol-validators-VAVyEnDp.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-Dw-rzii0.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-B1tT5U6r.js").then((n) => n.x);
+	const { requestCodexAppServerClientJson } = await import("./request-BWxweEdK.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,11 +92,13 @@ 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) {
-	return uniqueStrings(value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
+	const efforts = value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0);
+	return uniqueStrings(efforts);
 }
 function normalizeMaxPages(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;