@openclaw/codex 2026.8.1-beta.2 → 2026.9.1-beta.1

package/dist/{isolated-completion-C58NbL40.js → isolated-completion-Cv6FqygM.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 { h as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-giW8X0QA.js";
+import { pt as resolveCodexAppServerPreparedAuthHandoff, vt as isJsonObject } from "./shared-client-DKz23hHY.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-B7iBUcuP.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/managed-binary-DFYK4DWq.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.150.1";
+/** 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-B7iBUcuP.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-i9rNBthX.js

@@ -0,0 +1,48 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-Csz0F-DK.js";
+import { h as readCodexPluginConfig } from "./config-giW8X0QA.js";
+import { t as listAllCodexAppServerModels } from "./models-TS3HBU-q.js";
+import { r as requestOptions } from "./command-rpc-CCeCkf_v.js";
+//#region extensions/codex/src/app-server/model-catalog.ts
+const OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+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) {
+	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,
+			api: "openai-chatgpt-responses",
+			baseUrl: OPENAI_CODEX_BASE_URL,
+			reasoning: model.supportedReasoningEfforts.length > 0,
+			...input.length > 0 ? { input } : {},
+			...runtimeParams ? { params: runtimeParams } : {},
+			compat: {
+				supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
+				supportedReasoningEfforts: model.supportedReasoningEfforts
+			}
+		};
+	});
+}
+async function loadCodexAppServerModelCatalog(params, pluginConfig) {
+	const discovery = readCodexPluginConfig(pluginConfig).discovery;
+	if (discovery?.enabled === false) return [];
+	return codexAppServerModelsToCatalogEntries((await listAllCodexAppServerModels({
+		...requestOptions(pluginConfig, 100, params.config, params.agentDir),
+		timeoutMs: discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS
+	})).models);
+}
+//#endregion
+export { loadCodexAppServerModelCatalog };

package/dist/{models-BFlpn1Ex.js → models-TS3HBU-q.js}

@@ -1,4 +1,4 @@
-import { t as assertCodexModelListResponse } from "./protocol-validators-B4F7L8Rf.js";
+import { t as assertCodexModelListResponse } from "./protocol-validators-VeJxxJ0U.js";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -40,7 +40,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	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 { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-DKz23hHY.js").then((n) => n.y);
 	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,
@@ -96,7 +96,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) {