@openclaw/codex 2026.9.2 → 2026.9.4

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

@@ -1,15 +1,15 @@
-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 { r as readCodexAppServerConfigOptions } from "./launch-args-RXQwn8zV.js";
+import { C as readCodexErrorNotification, E as createCodexElicitationResponse, b as assertCodexThreadStartResponse, x as assertCodexTurnStartResponse } from "./client-B57KWPQx.js";
+import "./config-oIORaQ5T.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
+import { a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-DKHzbwt5.js";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-D78_VmzO.js";
+import { r as readModelListResult } from "./models-PCKOim-h.js";
+import { Et as mergeCodexThreadConfigs, K as attestCodexRestrictedToolSurfaceMcpServersDisabled, _ as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRingZeroThreadConfigPatch, x as readCodexInheritedMcpServerNames, y as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-DXl1-I6b.js";
 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 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";
@@ -62,8 +62,8 @@ async function runBoundedCodexAppServerTurn(params) {
 async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt = 0, timing) {
 	const totalTimeoutMs = timing?.timeoutMs ?? resolveTimerTimeoutMs(params.timeoutMs, 100, 100);
 	const timeoutError = new CodexBoundedTurnTimeoutError(params.taskLabel, totalTimeoutMs);
-	const deadline = timing?.deadline ?? Date.now() + totalTimeoutMs;
-	const timeoutMs = deadline - Date.now();
+	const deadline = timing?.deadline ?? performance.now() + totalTimeoutMs;
+	const timeoutMs = deadline - performance.now();
 	if (timeoutMs <= 0) throw timeoutError;
 	params.assertCurrent?.();
 	const agentDir = params.agentDir?.trim() || void 0;
@@ -79,7 +79,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		assertCurrent: params.assertCurrent,
 		...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({
+	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CscigXXL.js").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		...clientOptions,
 		authProfileStore: params.authProfileStore
 	}));
@@ -102,7 +102,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	const abortFromCaller = () => abortRun(params.signal?.reason ?? "aborted");
 	if (params.signal?.aborted) abortFromCaller();
 	else params.signal?.addEventListener("abort", abortFromCaller, { once: true });
-	const remainingRunMs = deadline - Date.now();
+	const remainingRunMs = deadline - performance.now();
 	if (remainingRunMs <= 0) abortRun(timeoutError);
 	const timeout = setTimeout(() => abortRun(timeoutError), Math.max(1, remainingRunMs));
 	timeout.unref?.();
@@ -147,9 +147,10 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			items: params.historyItems
 		}, 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));
+		const collector = new CodexEphemeralTurn(client, thread.thread.id, {
+			textMode: "all",
+			onRequest: createCodexBoundedApprovalHandler(params.taskLabel)
+		});
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				threadId: thread.thread.id,
@@ -159,13 +160,18 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			}, requestOptions));
 			activeTurnId = turn.turn.id;
 			if (abortController.signal.aborted) requestInterrupt();
-			const result = await collector.collect(turn.turn, {
+			const result = await collector.wait(turn.turn, {
 				signal: abortController.signal,
-				timeoutError
+				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 {
-				...result,
+				text: result.text,
+				items: result.items,
+				usage: result.usage,
 				model: modelSelection.catalogId,
 				nativeSelection: {
 					model: thread.model,
@@ -174,8 +180,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			};
 		} finally {
 			await interruptPromise;
-			requestCleanup();
-			cleanup();
+			collector.route.release();
 		}
 	} catch (error) {
 		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
@@ -269,110 +274,8 @@ async function resolveCodexBoundedTurnModel(params) {
 		runtimeModelId: match.model
 	};
 }
-function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
-	let turnId;
-	let completedTurn;
-	let promptError;
-	const usageProjection = new CodexUsageProjection();
-	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") {
-			usageProjection.record(params);
-			return;
-		}
-		if (notification.method === "turn/completed") {
-			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
-			resolveCompletion();
-			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();
-		}
-	};
-	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,
-				usage: usageProjection.usage
-			};
-		}
-	};
-}
-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-BCmg9-5p.js

@@ -0,0 +1,19 @@
+//#region extensions/codex/package.json
+var version = "2026.9.4";
+//#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-B1mgvpP8.js → capabilities-8vx68WLH.js}

@@ -1,4 +1,4 @@
-import { q as CodexAppServerRpcError } from "./shared-client-CKhX2kFt.js";
+import { t as CodexAppServerRpcError } from "./rpc-error-ttN_QjEm.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.

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-BjLhpmS1.js");
+		const { registerCodexSessionCli } = await import("./session-cli-DNN_jhGc.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",