@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{bounded-turn-B7iBUcuP.js → bounded-turn-DxGJRYbY.js}

@@ -1,15 +1,15 @@
-import { i as resolveCodexAppServerRuntimeOptions } from "./config-giW8X0QA.js";
-import { K as createCodexElicitationResponse, c as isCodexAppServerStartSelectionChangedError, vt as isJsonObject } from "./shared-client-DKz23hHY.js";
-import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-bfsmcQ6m.js";
-import { b as isTerminalTurnStatus, n as normalizeCodexResponseTokenUsage, x as readCodexNotificationItem, y as isRetryableErrorNotification } from "./event-projector-usage-Bk1I90Bg.js";
-import { a as assertCodexThreadStartResponse, c as readCodexErrorNotification, o as assertCodexTurnStartResponse, u as readCodexTurnCompletedNotification } from "./protocol-validators-VeJxxJ0U.js";
-import { r as readModelListResult } from "./models-TS3HBU-q.js";
-import { A as attestCodexRestrictedToolSurfaceMcpServersDisabled, M as buildCodexRuntimeThreadConfig, N as readCodexInheritedMcpServerNames, bt as mergeCodexThreadConfigs, j as buildCodexRingZeroThreadConfigPatch, k as assertCodexManagedRequirementsDoNotOverrideToolPolicy } from "./thread-lifecycle-L7oEkTlq.js";
+import { B as isJsonObject, i as resolveCodexAppServerRuntimeOptions } from "./config-CyapYSji.js";
+import { at as readCodexErrorNotification, ct as createCodexElicitationResponse, nt as assertCodexThreadStartResponse, rt as assertCodexTurnStartResponse, st as readCodexTurnCompletedNotification, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CKhX2kFt.js";
+import { m as readCodexAppServerConfigOptions } from "./managed-binary-DcpnJF9x.js";
+import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-Bp1ZOnk2.js";
+import { c as isRetryableErrorNotification, l as isTerminalTurnStatus, t as CodexUsageProjection, u as readCodexNotificationItem } from "./event-projector-usage-ZqEVbAEY.js";
+import { r as readModelListResult } from "./models-CcrgSMQR.js";
+import { Et as mergeCodexThreadConfigs, G as attestCodexRestrictedToolSurfaceMcpServersDisabled, _ as buildCodexRingZeroThreadConfigPatch, b as readCodexInheritedMcpServerNames, g as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-DPK30jad.js";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/codex/src/app-server/bounded-turn.ts
 const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
@@ -39,6 +39,7 @@ var CodexBoundedTurnTimeoutError = class extends Error {
 	}
 };
 async function runBoundedCodexAppServerTurn(params) {
+	params.assertCurrent?.();
 	const appServer = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.options.pluginConfig,
 		managedCommandOrder: params.isolation === "private-stdio" ? "package-first" : void 0
@@ -64,31 +65,23 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	const deadline = timing?.deadline ?? Date.now() + totalTimeoutMs;
 	const timeoutMs = deadline - Date.now();
 	if (timeoutMs <= 0) throw timeoutError;
+	params.assertCurrent?.();
 	const agentDir = params.agentDir?.trim() || void 0;
-	const isolatedStartOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
-	const startOptions = workspace.codexHome && params.preparedAuth ? {
-		...isolatedStartOptions,
-		homeScope: "agent"
-	} : isolatedStartOptions;
+	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
 	const ownsClient = !params.options.clientFactory;
-	const authSelection = params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.profile };
-	const client = params.options.clientFactory ? await params.options.clientFactory({
+	const clientOptions = {
 		startOptions,
-		...authSelection,
+		...params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.profile },
 		authRequirement: params.authRequirement,
 		agentDir,
 		config: params.config,
 		timeoutMs,
+		assertCurrent: params.assertCurrent,
 		...params.signal ? { abandonSignal: params.signal } : {}
-	}) : await import("./shared-client-DKz23hHY.js").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
-		startOptions,
-		timeoutMs,
-		...authSelection,
-		authRequirement: params.authRequirement,
-		agentDir,
-		authProfileStore: params.authProfileStore,
-		config: params.config,
-		...params.signal ? { abandonSignal: params.signal } : {}
+	};
+	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CKhX2kFt.js").then((n) => n.x).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		...clientOptions,
+		authProfileStore: params.authProfileStore
 	}));
 	const abortController = new AbortController();
 	let activeThreadId;
@@ -114,17 +107,23 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	const timeout = setTimeout(() => abortRun(timeoutError), Math.max(1, remainingRunMs));
 	timeout.unref?.();
 	let retrySelection = false;
+	const requestOptions = {
+		timeoutMs,
+		signal: abortController.signal,
+		assertCurrent: params.assertCurrent
+	};
 	try {
+		params.assertCurrent?.();
 		const modelSelection = await resolveCodexBoundedTurnModel({
 			client,
 			selection: params.model,
 			requiredModalities: params.requiredModalities,
-			timeoutMs,
-			signal: abortController.signal
+			...requestOptions
 		});
 		const inheritedMcpServerNames = params.requireNoExternalCapabilities ? await readCodexInheritedMcpServerNames(client, workspace.cwd, abortController.signal) : [];
 		if (params.requireNoExternalCapabilities) await assertCodexManagedRequirementsDoNotOverrideToolPolicy(client, { restrictedToolSurface: true }, abortController.signal);
 		const threadConfig = buildCodexRuntimeThreadConfig(resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames), { nativeCodeModeEnabled: false });
+		params.assertCurrent?.();
 		const thread = assertCodexThreadStartResponse(await client.request("thread/start", {
 			model: modelSelection.runtimeModelId,
 			...params.modelProvider ? { modelProvider: params.modelProvider } : {},
@@ -139,20 +138,15 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			dynamicTools: [],
 			experimentalRawEvents: true,
 			ephemeral: true
-		}, {
-			timeoutMs,
-			signal: abortController.signal
-		}));
+		}, requestOptions));
 		activeThreadId = thread.thread.id;
 		if (abortController.signal.aborted) requestInterrupt();
 		if (params.requireNoExternalCapabilities) await attestCodexRestrictedToolSurfaceMcpServersDisabled(client, thread.thread.id, threadConfig, abortController.signal);
 		if (params.historyItems?.length) await client.request("thread/inject_items", {
 			threadId: thread.thread.id,
 			items: params.historyItems
-		}, {
-			timeoutMs,
-			signal: abortController.signal
-		});
+		}, requestOptions);
+		params.assertCurrent?.();
 		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel, params.allowEmptyText === true);
 		const cleanup = client.addNotificationHandler(collector.handleNotification);
 		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
@@ -161,20 +155,22 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				threadId: thread.thread.id,
 				input: params.input,
 				approvalPolicy: "on-request",
-				model: modelSelection.runtimeModelId,
 				effort: "low"
-			}, {
-				timeoutMs,
-				signal: abortController.signal
-			}));
+			}, requestOptions));
 			activeTurnId = turn.turn.id;
 			if (abortController.signal.aborted) requestInterrupt();
+			const result = await collector.collect(turn.turn, {
+				signal: abortController.signal,
+				timeoutError
+			});
+			params.assertCurrent?.();
 			return {
-				...await collector.collect(turn.turn, {
-					signal: abortController.signal,
-					timeoutError
-				}),
-				model: modelSelection.catalogId
+				...result,
+				model: modelSelection.catalogId,
+				nativeSelection: {
+					model: thread.model,
+					modelProvider: thread.modelProvider
+				}
 			};
 		} finally {
 			await interruptPromise;
@@ -204,10 +200,7 @@ function resolveBoundedThreadConfig(params, workspace, inheritedMcpServerNames)
 	return mergeCodexThreadConfigs(privateConfig, CODEX_SETTLED_FINALIZER_THREAD_CONFIG, buildCodexRingZeroThreadConfigPatch({ toolsAllow: ["openclaw"] }, true, inheritedMcpServerNames)) ?? privateConfig;
 }
 function buildPrivateCodexAppServerStartOptions(start, codexHome) {
-	const providerArgs = start.args.flatMap((arg, index) => {
-		const override = arg === "-c" || arg === "--config" ? start.args[index + 1] : arg.startsWith("--config=") ? arg.slice(9) : void 0;
-		return override && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(override) ? ["-c", override] : [];
-	});
+	const providerArgs = readCodexAppServerConfigOptions(start.args).flatMap(({ name, value }) => (name === "-c" || name === "--config") && value && /^\s*(?:openai_base_url|model_catalog_json)\s*=/u.test(value) ? ["-c", value] : []);
 	const privateEnv = Object.fromEntries(Object.entries(start.env ?? {}).filter(([name]) => name.trim().toUpperCase() !== CODEX_APP_SERVER_ARGS_ENV_KEY));
 	const clearEnv = (start.clearEnv ?? []).filter((name) => {
 		const normalized = name.trim().toUpperCase();
@@ -215,6 +208,7 @@ function buildPrivateCodexAppServerStartOptions(start, codexHome) {
 	});
 	return {
 		...start,
+		homeScope: "agent",
 		args: [
 			"app-server",
 			...providerArgs,
@@ -246,14 +240,16 @@ function createCodexBoundedApprovalHandler(taskLabel) {
 	};
 }
 async function resolveCodexBoundedTurnModel(params) {
-	const listed = readModelListResult(await params.client.request("model/list", {
+	const result = await params.client.request("model/list", {
 		limit: null,
 		cursor: null,
-		includeHidden: false
+		includeHidden: params.selection.mode === "required"
 	}, {
 		timeoutMs: Math.min(params.timeoutMs, 5e3),
-		signal: params.signal
-	})).models;
+		signal: params.signal,
+		assertCurrent: params.assertCurrent
+	});
+	const listed = readModelListResult(result).models;
 	if (params.selection.mode === "live-default") {
 		const supported = listed.filter((entry) => params.requiredModalities.every((modality) => entry.inputModalities.includes(modality)));
 		const selected = supported.find((entry) => entry.isDefault) ?? supported[0];
@@ -277,7 +273,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 	let turnId;
 	let completedTurn;
 	let promptError;
-	let responseUsage;
+	const usageProjection = new CodexUsageProjection();
 	const pending = [];
 	const completedItems = /* @__PURE__ */ new Map();
 	const assistantTextByItem = /* @__PURE__ */ new Map();
@@ -311,8 +307,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 			return;
 		}
 		if (notification.method === "rawResponse/completed") {
-			const usage = isJsonObject(params.usage) ? params.usage : void 0;
-			responseUsage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
+			usageProjection.record(params);
 			return;
 		}
 		if (notification.method === "turn/completed") {
@@ -321,6 +316,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 			return;
 		}
 		if (notification.method === "error") {
+			usageProjection.invalidateContext();
 			if (isRetryableErrorNotification(notification.params)) return;
 			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
 			resolveCompletion();
@@ -349,7 +345,7 @@ function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
 			return {
 				text,
 				items,
-				...responseUsage ? { usage: responseUsage } : {}
+				usage: usageProjection.usage
 			};
 		}
 	};

package/dist/{capabilities-BRMh0aIq.js → capabilities-B1mgvpP8.js}

@@ -1,4 +1,4 @@
-import { G as CodexAppServerRpcError } from "./shared-client-DKz23hHY.js";
+import { q as CodexAppServerRpcError } from "./shared-client-CKhX2kFt.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.
@@ -17,6 +17,7 @@ const CODEX_CONTROL_METHODS = {
 	listSkills: "skills/list",
 	listThreads: "thread/list",
 	listThreadTurns: "thread/turns/list",
+	listThreadItems: "thread/items/list",
 	readThread: "thread/read",
 	rateLimits: "account/rateLimits/read",
 	archiveThread: "thread/archive",

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-DMc4oS2w.js");
+		const { registerCodexSessionCli } = await import("./session-cli-BjLhpmS1.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-DEsIufkt.js → command-formatters-DSbGMXA0.js}

@@ -1,5 +1,5 @@
-import { vt as isJsonObject } from "./shared-client-DKz23hHY.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-C5_D8Gmb.js";
+import { B as isJsonObject } from "./config-CyapYSji.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-Fx_l4eNa.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/command-formatters.ts
 /**
@@ -118,7 +118,8 @@ function formatSkills(response) {
 	return lines.join("\n");
 }
 function formatCodexSkillEntry(entry) {
-	return `\`${formatCodexDisplayText(normalizeOptionalString((isJsonObject(entry) ? entry : {}).name) ?? "<unknown>")}\``;
+	const record = isJsonObject(entry) ? entry : {};
+	return `\`${formatCodexDisplayText(normalizeOptionalString(record.name) ?? "<unknown>")}\``;
 }
 const CODEX_RESUME_SAFE_THREAD_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
 function formatCodexResumeHint(threadId) {
@@ -278,4 +279,4 @@ function extractArray(value) {
 	return [];
 }
 //#endregion
-export { formatComputerUseStatus as a, formatSkills as c, formatCodexStatus as i, formatThreads as l, formatAccount as n, formatList as o, formatCodexDisplayText as r, formatModels as s, buildHelp as t };
+export { formatCodexDisplayText as a, formatComputerUseStatus as c, formatSkills as d, formatThreads as f, formatAccount as i, formatList as l, buildHelp as n, formatCodexStatus as o, escapeCodexChatText as r, formatCodexTextForDisplay as s, CODEX_RESUME_SAFE_THREAD_ID_PATTERN as t, formatModels as u };