@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{isolated-completion-Cv6FqygM.js → isolated-completion-CRh-51AK.js}

@@ -1,26 +1,11 @@
-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";
+import { O as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-CyapYSji.js";
+import { Kt as resolveCodexAppServerPreparedAuthHandoff, Z as assertCodexPassiveTurnItems } from "./shared-client-CKhX2kFt.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DxGJRYbY.js";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-B9kp6iGC.js";
 //#region extensions/codex/src/app-server/isolated-completion.ts
-const ISOLATED_PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set(["agentMessage", "reasoning"]);
-function assertIsolatedCompletionItems(items, prompt) {
-	let promptEchoSeen = false;
-	for (const item of items) {
-		if (ISOLATED_PASSIVE_ITEM_TYPES.has(item.type)) continue;
-		if (item.type === "userMessage" && !promptEchoSeen) {
-			const content = Array.isArray(item.content) ? item.content : [];
-			const input = content[0];
-			if (content.length === 1 && isJsonObject(input) && input.type === "text" && input.text === prompt) {
-				promptEchoSeen = true;
-				continue;
-			}
-		}
-		throw new Error(`Codex isolated completion returned unexpected native item: ${item.type}`);
-	}
-}
 /** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */
 async function runCodexIsolatedCompletion(params, options) {
+	params.assertCurrent?.();
 	const authorization = params.authorization;
 	if (authorization.owner !== "harness") throw new Error("Codex native isolated completion requires harness-owned authorization.");
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
@@ -35,6 +20,7 @@ async function runCodexIsolatedCompletion(params, options) {
 		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a scoped native OAuth or token profile.",
 		subscriptionProfileUnusableError: `Prepared Codex auth profile "${authorization.plan.forwardedAuthProfileId}" is unusable.`
 	});
+	params.assertCurrent?.();
 	const authSelection = authHandoff.preparedAuth ? { preparedAuth: authHandoff.preparedAuth } : { profile: authHandoff.authProfileId };
 	const result = await runBoundedCodexAppServerTurn({
 		config: params.config,
@@ -46,6 +32,7 @@ async function runCodexIsolatedCompletion(params, options) {
 		authRequirement,
 		timeoutMs: params.timeoutMs,
 		signal: params.abortSignal,
+		assertCurrent: params.assertCurrent,
 		agentDir: params.agentDir,
 		authProfileStore: authorization.authProfileStore,
 		options,
@@ -60,7 +47,8 @@ async function runCodexIsolatedCompletion(params, options) {
 		isolation: "configured-transport",
 		requireNoExternalCapabilities: true
 	});
-	assertIsolatedCompletionItems(result.items, params.prompt);
+	params.assertCurrent?.();
+	assertCodexPassiveTurnItems(result.items, params.prompt, "isolated completion");
 	return { assistant: createAttributedCodexAssistantMessage({
 		api: "openai-chatgpt-responses",
 		provider: params.provider,

package/dist/{managed-binary-DFYK4DWq.js → managed-binary-DcpnJF9x.js}

@@ -1,9 +1,98 @@
 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 { constants, existsSync, realpathSync } from "node:fs";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+//#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");
+}
+/** The stdio proxy forwards to an external server; it does not own that runtime. */
+function isCodexAppServerProxyLaunch(args) {
+	const tokens = readCodexArgs(args);
+	const server = tokens.findLastIndex(({ name }) => name === "app-server");
+	return server >= 0 && tokens.slice(server + 1).find(({ name }) => !name.startsWith("-"))?.name === "proxy";
+}
+/** 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
 //#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 = [{
@@ -46,7 +135,7 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 * 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";
+const CODEX_APP_SERVER_VERSION = "0.153.4";
 /** 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. */
@@ -57,18 +146,19 @@ const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
 * 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;
+const registeredCodexPlugin = resolveGlobalSingleton(Symbol.for("openclaw.codexManagedPluginRoot"), () => ({}));
 /** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
 function setManagedCodexPluginRoot(pluginRoot) {
-	registeredCodexPluginRoot = pluginRoot;
+	registeredCodexPlugin.root = 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 pluginRoot = options.pluginRoot ?? registeredCodexPlugin.root;
+	if (!pluginRoot) throw new Error("Codex plugin root is unavailable. Load the Codex plugin before starting its managed app-server.");
 	const platform = options.platform ?? process.platform;
 	const commandPaths = await findManagedCodexAppServerCommandPaths({
-		candidateCommandPaths: resolveManagedCodexAppServerCommandCandidates(options.pluginRoot ?? registeredCodexPluginRoot ?? CODEX_PLUGIN_ROOT, platform, startOptions.managedCommandOrder ?? "package-first"),
+		candidateCommandPaths: resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform, startOptions.managedCommandOrder ?? "package-first"),
 		pathExists: options.pathExists ?? commandPathExists,
 		platform
 	});
@@ -91,12 +181,16 @@ function resolveManagedCodexNativeCommand(command, options = {}) {
 	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;
-	}
+	const packageJsonPath = resolvePackageJson(target.packageName, packageRoot) ?? resolvePackageJson("@openai/codex", packageRoot);
+	if (!packageJsonPath) return;
+	const candidate = path.join(path.dirname(packageJsonPath), "vendor", target.triple, "bin", platform === "win32" ? "codex.exe" : "codex");
+	return pathExists(candidate) ? candidate : void 0;
+}
+/** Recognizes only the official npm entrypoint, not arbitrary configured wrappers. */
+function resolvePackagedCodexNativeCommand(entrypoint) {
+	const packageRoot = path.dirname(path.dirname(entrypoint));
+	if (path.basename(packageRoot) !== "codex" || path.basename(path.dirname(packageRoot)) !== "@openai" || path.relative(packageRoot, entrypoint) !== path.join("bin", "codex.js")) return;
+	return resolveManagedCodexNativeCommand(entrypoint);
 }
 /** Returns whether a command is one of the standard macOS desktop app executables. */
 function isManagedCodexDesktopCommand(command, platform = process.platform) {
@@ -147,82 +241,25 @@ function resolveCodexNativeTarget(platform, arch) {
 }
 function resolvePackageJsonFromRoot(packageName, root) {
 	try {
-		return createRequire(path.join(root, "package.json")).resolve(`${packageName}/package.json`);
+		const manifestPath = realpathSync(path.join(root, "package.json"));
+		return createRequire(manifestPath).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;
+	const packageCommand = resolveManagedCodexPackageEntrypoint(pluginRoot);
+	const packageCommandPaths = packageCommand ? [packageCommand] : [];
+	const desktopCommandPaths = resolveMacOSDesktopCodexAppServerCommandCandidates(platform);
+	return managedCommandOrder === "desktop-first" ? [...desktopCommandPaths, ...packageCommandPaths] : [...packageCommandPaths, ...desktopCommandPaths];
 }
-function resolveManagedCodexPackageBinCandidate(root) {
+function resolveManagedCodexPackageEntrypoint(pluginRoot) {
 	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;
+		return createRequire(path.join(pluginRoot, "package.json")).resolve(`${MANAGED_CODEX_APP_SERVER_PACKAGE}/bin/codex.js`);
 	} catch {
-		return null;
+		return;
 	}
 }
-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;
 }
@@ -245,4 +282,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#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 };
+export { setManagedCodexPluginRoot as a, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as c, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as d, isCodexAppServerProxyLaunch as f, resolvePackagedCodexNativeCommand as i, resolveMacOSDesktopCodexAppPathCandidates as l, readCodexAppServerConfigOptions as m, resolveManagedCodexAppServerStartOptions as n, CODEX_APP_SERVER_VERSION as o, normalizeCodexAppServerArgs as p, resolveManagedCodexNativeCommand as r, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexBundledMarketplaceCandidates as u };

package/dist/media-understanding-provider.js

@@ -1,4 +1,4 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-B7iBUcuP.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DxGJRYbY.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-DT5vo6qo.js

@@ -0,0 +1,101 @@
+import { r as buildCodexRuntimeModelParams } from "./harness-Czh2Sdoc.js";
+import { B as isJsonObject, O as readCodexPluginConfig, i as resolveCodexAppServerRuntimeOptions } from "./config-CyapYSji.js";
+import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CKhX2kFt.js";
+import { t as listAllCodexAppServerModels } from "./models-CcrgSMQR.js";
+import { o as withCodexAppServerJsonClient } from "./request-C8H22rPi.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 models = (await listAllCodexAppServerModels({
+					request,
+					limit: 100,
+					includeHidden: true
+				})).models.filter((model) => !model.hidden || params.configuredModelRefs?.some((ref) => ref.provider === "openai" && ref.model === model.id));
+				const account = await request({
+					method: "account/read",
+					requestParams: { refreshToken: false }
+				});
+				const observedType = isJsonObject(account.account) ? account.account.type : void 0;
+				return {
+					models,
+					isCurrent,
+					accountType: account.requiresOpenaiAuth === true ? observedType === "apiKey" || observedType === "chatgpt" ? observedType : void 0 : void 0
+				};
+			});
+			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-TS3HBU-q.js → models-CcrgSMQR.js}

@@ -1,4 +1,4 @@
-import { t as assertCodexModelListResponse } from "./protocol-validators-VeJxxJ0U.js";
+import { X as assertCodexModelListResponse } from "./shared-client-CKhX2kFt.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-DKz23hHY.js").then((n) => n.y);
-	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-CKhX2kFt.js").then((n) => n.x);
+	const { requestCodexAppServerClientJson } = await import("./request-C8H22rPi.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();
+		else await client.closeAndWait();
 	}
 }
-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) {
@@ -101,7 +97,8 @@ function readCodexModel(value) {
 	};
 }
 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;