@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{bounded-turn-wzJrwKKe.js → bounded-turn-lRpmZHFv.js}

@@ -1,15 +1,15 @@
-import { $t as isJsonObject, at as readCodexTurnCompletedNotification, et as assertCodexThreadStartResponse, ot as createCodexElicitationResponse, rt as readCodexErrorNotification, tt as assertCodexTurnStartResponse, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-DxcfF9KX.js";
 import { r as readCodexAppServerConfigOptions } from "./launch-args-RXQwn8zV.js";
-import { i as resolveCodexAppServerRuntimeOptions } from "./config-BhmfC1s6.js";
-import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { d as isTerminalTurnStatus, f as readCodexNotificationItem, n as normalizeCodexResponseTokenUsage, u as isRetryableErrorNotification } from "./event-projector-usage-C5mcrGjp.js";
-import { r as readModelListResult } from "./models-sYnEc0gd.js";
-import { Dt as mergeCodexThreadConfigs, G as attestCodexRestrictedToolSurfaceMcpServersDisabled, _ as buildCodexRingZeroThreadConfigPatch, b as readCodexInheritedMcpServerNames, g as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-DAcEJ_Om.js";
-import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { C as readCodexErrorNotification, E as createCodexElicitationResponse, b as assertCodexThreadStartResponse, x as assertCodexTurnStartResponse } from "./client-BEKu4yDx.js";
+import "./config-JDfTI4VI.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
+import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-D6cR54TV.js";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-DSwzP8YY.js";
+import { r as readModelListResult } from "./models-P9k2qAof.js";
+import { G as attestCodexRestrictedToolSurfaceMcpServersDisabled, Tt as mergeCodexThreadConfigs, _ as buildCodexRingZeroThreadConfigPatch, b as readCodexInheritedMcpServerNames, g as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-D1pzRwHB.js";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import path from "node:path";
+import fs from "node:fs/promises";
 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,27 +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 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-DxcfF9KX.js").then((n) => n.x).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-CVhez2Uo.js").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		...clientOptions,
+		authProfileStore: params.authProfileStore
 	}));
 	const abortController = new AbortController();
 	let activeThreadId;
@@ -110,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 } : {},
@@ -135,47 +138,49 @@ 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 = new CodexEphemeralTurn(client, thread.thread.id, {
+			textMode: "all",
+			onRequest: createCodexBoundedApprovalHandler(params.taskLabel)
 		});
-		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel, params.allowEmptyText === true);
-		const cleanup = client.addNotificationHandler(collector.handleNotification);
-		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				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.wait(turn.turn, {
+				signal: abortController.signal,
+				abortError: () => resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError)
+			});
+			if (result.error || result.turn?.status === "failed") throw new Error((result.error ? readCodexErrorNotification(result.error)?.error.message : result.turn?.error?.message) ?? `codex app-server ${params.taskLabel} turn failed`);
+			if (result.turn?.status !== "completed") throw new Error(`codex app-server ${params.taskLabel} turn ended with status ${result.turn?.status ?? "unknown"}`);
+			if (!result.text && !params.allowEmptyText) throw new Error(`Codex app-server ${params.taskLabel} turn returned no text.`);
+			params.assertCurrent?.();
 			return {
-				...await collector.collect(turn.turn, {
-					signal: abortController.signal,
-					timeoutError
-				}),
-				model: modelSelection.catalogId
+				text: result.text,
+				items: result.items,
+				usage: result.usage,
+				model: modelSelection.catalogId,
+				nativeSelection: {
+					model: thread.model,
+					modelProvider: thread.modelProvider
+				}
 			};
 		} finally {
 			await interruptPromise;
-			requestCleanup();
-			cleanup();
+			collector.route.release();
 		}
 	} catch (error) {
 		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
@@ -246,7 +251,8 @@ async function resolveCodexBoundedTurnModel(params) {
 		includeHidden: params.selection.mode === "required"
 	}, {
 		timeoutMs: Math.min(params.timeoutMs, 5e3),
-		signal: params.signal
+		signal: params.signal,
+		assertCurrent: params.assertCurrent
 	});
 	const listed = readModelListResult(result).models;
 	if (params.selection.mode === "live-default") {
@@ -268,110 +274,8 @@ async function resolveCodexBoundedTurnModel(params) {
 		runtimeModelId: match.model
 	};
 }
-function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
-	let turnId;
-	let completedTurn;
-	let promptError;
-	let responseUsage;
-	const pending = [];
-	const completedItems = /* @__PURE__ */ new Map();
-	const assistantTextByItem = /* @__PURE__ */ new Map();
-	const assistantItemOrder = [];
-	const { promise: completion, resolve: resolveCompletion } = createDeferred();
-	const rememberAssistantText = (itemId, text) => {
-		if (!text) return;
-		if (!assistantTextByItem.has(itemId)) assistantItemOrder.push(itemId);
-		assistantTextByItem.set(itemId, text);
-	};
-	const handleNotification = (notification) => {
-		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params || readStringField(params, "threadId") !== threadId) return;
-		if (!turnId) {
-			pending.push(notification);
-			return;
-		}
-		if (readCodexNotificationTurnId(params) !== turnId) return;
-		if (notification.method === "item/completed") {
-			const item = readCodexNotificationItem(notification.params);
-			if (item) {
-				completedItems.set(item.id, item);
-				if (item.type === "agentMessage" && typeof item.text === "string") rememberAssistantText(item.id, item.text);
-			}
-			return;
-		}
-		if (notification.method === "item/agentMessage/delta") {
-			const itemId = readStringField(params, "itemId") ?? readStringField(params, "id") ?? "assistant";
-			const delta = readStringField(params, "delta") ?? "";
-			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
-			return;
-		}
-		if (notification.method === "rawResponse/completed") {
-			const usage = isJsonObject(params.usage) ? params.usage : void 0;
-			responseUsage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
-			return;
-		}
-		if (notification.method === "turn/completed") {
-			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
-			resolveCompletion();
-			return;
-		}
-		if (notification.method === "error") {
-			if (isRetryableErrorNotification(notification.params)) return;
-			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
-			resolveCompletion();
-		}
-	};
-	return {
-		handleNotification,
-		async collect(startedTurn, options) {
-			turnId = startedTurn.id;
-			if (isTerminalTurnStatus(startedTurn.status)) completedTurn = startedTurn;
-			for (const notification of pending.splice(0)) handleNotification(notification);
-			if (!completedTurn && !promptError) await waitForTurnCompletion({
-				completion,
-				signal: options.signal,
-				taskLabel,
-				timeoutError: options.timeoutError
-			});
-			if (promptError) throw new Error(promptError);
-			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} turn failed`);
-			if (completedTurn?.status !== "completed") throw new Error(`codex app-server ${taskLabel} turn ended with status ${completedTurn?.status ?? "unknown"}`);
-			const items = collectCompletedItems(completedTurn?.items, completedItems);
-			const itemText = collectAssistantTextFromItems(items);
-			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
-			const text = (itemText || deltaText).trim();
-			if (!text && !allowEmptyText) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
-			return {
-				text,
-				items,
-				...responseUsage ? { usage: responseUsage } : {}
-			};
-		}
-	};
-}
-function collectCompletedItems(turnItems, notificationItems) {
-	const items = new Map(notificationItems);
-	for (const item of turnItems ?? []) items.set(item.id, item);
-	return [...items.values()];
-}
-async function waitForTurnCompletion(params) {
-	if (params.signal.aborted) throw resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError);
-	let cleanupAbort;
-	try {
-		await Promise.race([params.completion, new Promise((_, reject) => {
-			const abortListener = () => reject(resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError));
-			params.signal.addEventListener("abort", abortListener, { once: true });
-			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
-		})]);
-	} finally {
-		cleanupAbort?.();
-	}
-}
 function resolveCodexBoundedTurnAbortError(signal, taskLabel, timeoutError) {
 	return signal.reason === timeoutError ? timeoutError : /* @__PURE__ */ new Error(`codex app-server ${taskLabel} turn aborted`);
 }
-function collectAssistantTextFromItems(items) {
-	return (items ?? []).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean).join("\n\n").trim();
-}
 //#endregion
-export { runBoundedCodexAppServerTurn as t };
+export { runBoundedCodexAppServerTurn };

package/dist/build-state-6RL6qohz.js

@@ -0,0 +1,19 @@
+//#region extensions/codex/package.json
+var version = "2026.9.3";
+//#endregion
+//#region extensions/codex/src/build-state.ts
+/**
+* Duplicate module copies share one immutable published version's state.
+* In-process restarts retain old records and callbacks for their old owners.
+* Local rebuilds without a version bump deliberately share the same state.
+*/
+function codexBuildSymbol(name) {
+	return Symbol.for(`${name}@${version}`);
+}
+function defineCodexBuildState(name, create) {
+	const key = codexBuildSymbol(name);
+	const globalState = globalThis;
+	return () => globalState[key] ??= create();
+}
+//#endregion
+export { defineCodexBuildState as n, codexBuildSymbol as t };

package/dist/{capabilities-dIjNVCYH.js → capabilities-BeqLPbtM.js}

@@ -1,4 +1,4 @@
-import { q as CodexAppServerRpcError } from "./shared-client-DxcfF9KX.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.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-CmFEXMAM.js");
+		const { registerCodexSessionCli } = await import("./session-cli-CbgaHh0f.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",