@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/api.js

@@ -1,16 +1,15 @@
-import { a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions } from "./config-giW8X0QA.js";
-import { a as CODEX_APP_SERVER_VERSION, n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-DFYK4DWq.js";
+import { a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions } from "./config-CyapYSji.js";
+import { n as resolveManagedCodexAppServerStartOptions, o as CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-DcpnJF9x.js";
+import { listAgentIds, resolveAgentDir } from "openclaw/plugin-sdk/agent-scope-runtime";
 import path from "node:path";
 import { resolveDefaultModelForAgent } from "openclaw/plugin-sdk/agent-runtime";
-import { listAgentIds as listAgentIds$1, resolveAgentDir as resolveAgentDir$1 } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { execFile } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { resolveEffectiveAgentRuntime } from "openclaw/plugin-sdk/command-auth-native";
-import { getHealthCheck } from "openclaw/plugin-sdk/health";
 //#region extensions/codex/src/doctor.ts
 const CODEX_MANAGED_APP_SERVER_CHECK_ID = "codex/managed-app-server";
 const CODEX_VERSION_TIMEOUT_MS = 5e3;
-const CODEX_VERSION_MAX_BUFFER_BYTES = 64 * 1024;
+const CODEX_VERSION_MAX_BUFFER_BYTES = 65536;
 function managedCodexFinding(params) {
 	return {
 		checkId: CODEX_MANAGED_APP_SERVER_CHECK_ID,
@@ -68,7 +67,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 			if (start.transport !== "stdio" || start.commandSource !== "managed") return [];
 			const env = ctx.env ?? process.env;
 			let resolved;
-			for (const agentId of listAgentIds$1(ctx.cfg)) {
+			for (const agentId of listAgentIds(ctx.cfg)) {
 				const model = resolveDefaultModelForAgent({
 					cfg: ctx.cfg,
 					agentId
@@ -81,7 +80,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 				}) !== "codex") continue;
 				const agentStart = resolveAgentStartOptions({
 					startOptions: start,
-					agentDir: resolveAgentDir$1(ctx.cfg, agentId, env),
+					agentDir: resolveAgentDir(ctx.cfg, agentId, env),
 					env
 				});
 				try {
@@ -117,7 +116,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 				})];
 			}
 			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
-			if (detectedVersion !== "0.150.1") return [managedCodexFinding({
+			if (detectedVersion !== "0.153.4") return [managedCodexFinding({
 				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
 				path: nativeCommand,
 				requirement: `the exact OpenClaw-pinned Codex version ${CODEX_APP_SERVER_VERSION}`,
@@ -128,7 +127,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 	};
 }
 function registerCodexManagedAppServerDoctorChecks$1(host, deps) {
-	if (getHealthCheck("codex/managed-app-server")) return;
+	if (host.getHealthCheck("codex/managed-app-server")) return;
 	host.registerHealthCheck(createCodexManagedAppServerHealthCheck({
 		pluginRoot: host.pluginRoot,
 		deps

package/dist/{attempt-client-cleanup-bfsmcQ6m.js → attempt-client-cleanup-Bp1ZOnk2.js}

@@ -1,10 +1,24 @@
-import { G as CodexAppServerRpcError, _ as retireSharedCodexAppServerClientIfCurrent, tt as unsubscribeCodexAppServerLiveThread, vt as isJsonObject } from "./shared-client-DKz23hHY.js";
+import { B as isJsonObject } from "./config-CyapYSji.js";
+import { Nt as unsubscribeCodexAppServerLiveThread, q as CodexAppServerRpcError, y as retireSharedCodexAppServerClientIfCurrent } from "./shared-client-CKhX2kFt.js";
 import { asFiniteNumber, normalizeOptionalString, normalizeOptionalString as normalizeOptionalString$1, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
 import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 //#region extensions/codex/src/app-server/event-projector-values.ts
+const BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX = "This content was flagged for possible biological risk.";
+/** Project only Codex's explicit refusal contracts; other policy errors retain their own paths. */
+function readCodexProviderRefusal(message, codexErrorInfo) {
+	if (!message) return;
+	if (codexErrorInfo === "cyberPolicy") return {
+		category: "cyber",
+		message
+	};
+	return message.startsWith(BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX) ? {
+		category: "bio",
+		message
+	} : void 0;
+}
 function readNonEmptyString(record, key) {
 	return normalizeOptionalString$1(record[key]);
 }
@@ -70,6 +84,10 @@ function readItem(value) {
 }
 //#endregion
 //#region extensions/codex/src/app-server/event-projector-items.ts
+function matchesCodexSnapshotTurn(item, turnId) {
+	const itemTurnId = readItemString(item, "turnId");
+	return itemTurnId === void 0 || itemTurnId === turnId;
+}
 function itemKind(item) {
 	switch (item.type) {
 		case "dynamicToolCall":
@@ -330,28 +348,35 @@ var ClientTurnRouter = class {
 		const turnId = requireId(options.turnId, "turn id");
 		if (options.signal?.aborted) return {
 			completion: Promise.resolve(false),
+			state: "unconfirmed",
+			settledSignal: AbortSignal.abort(),
 			cancel: () => {}
 		};
-		if (this.routes.get(threadId)?.completedNativeTurnIds.delete(turnId)) return {
+		if (this.routes.get(threadId)?.completedNativeTurnIds.has(turnId)) return {
 			completion: Promise.resolve(true),
+			state: "confirmed",
+			settledSignal: AbortSignal.abort(),
 			cancel: () => {}
 		};
 		const { promise: completion, resolve: settle } = createDeferred();
+		const settlement = new AbortController();
 		const watchers = this.nativeTurnCompletionWatchers.get(threadId) ?? /* @__PURE__ */ new Set();
 		this.nativeTurnCompletionWatchers.set(threadId, watchers);
-		let settled = false;
+		let state = "pending";
 		const finish = (completed) => {
-			if (settled) return;
-			settled = true;
+			if (state !== "pending") return;
+			state = completed ? "confirmed" : "unconfirmed";
 			watchers.delete(watcher);
 			if (watchers.size === 0) this.nativeTurnCompletionWatchers.delete(threadId);
 			clearTimeout(timeout);
 			options.signal?.removeEventListener("abort", abort);
+			settlement.abort();
 			settle(completed);
 		};
 		const watcher = {
 			turnId,
-			finish
+			finish,
+			onStarted: options.onStarted
 		};
 		watchers.add(watcher);
 		const timeout = setTimeout(() => finish(false), Math.max(1, options.timeoutMs));
@@ -360,6 +385,10 @@ var ClientTurnRouter = class {
 		options.signal?.addEventListener("abort", abort, { once: true });
 		return {
 			completion,
+			settledSignal: settlement.signal,
+			get state() {
+				return state;
+			},
 			cancel: () => finish(false)
 		};
 	}
@@ -432,6 +461,7 @@ var ClientTurnRouter = class {
 		if (!watchers && !route) return;
 		if (scope.turnId && watchers) {
 			for (const watcher of watchers) if (watcher.turnId === scope.turnId && notification.method === "turn/completed") watcher.finish(true);
+			else if (watcher.turnId === scope.turnId && notification.method === "turn/started") watcher.onStarted?.();
 		}
 		if (!route) return;
 		const routeScope = {
@@ -439,12 +469,15 @@ var ClientTurnRouter = class {
 			...scope.turnId ? { turnId: scope.turnId } : {}
 		};
 		const receivedAtMs = Date.now();
-		if (route.gate !== "bound" && scope.turnId) {
-			if (notification.method === "turn/started") route.observedNativeTurn = {
-				id: scope.turnId,
-				completed: false
-			};
-			else if (notification.method === "turn/completed") {
+		if (scope.turnId && (route.gate !== "bound" || scope.turnId === route.turnId)) {
+			if (notification.method === "turn/started") {
+				route.completedNativeTurnIds.delete(scope.turnId);
+				route.observedNativeTurn = {
+					id: scope.turnId,
+					completed: false
+				};
+			} else if (notification.method === "turn/completed") {
+				if (route.gate === "bound") route.completedNativeTurnIds.clear();
 				route.completedNativeTurnIds.add(scope.turnId);
 				if (!route.observedNativeTurn || route.observedNativeTurn.completed || route.observedNativeTurn.id === scope.turnId) route.observedNativeTurn = {
 					id: scope.turnId,
@@ -560,7 +593,7 @@ var ClientTurnRouter = class {
 		await Promise.race([route.notificationTail, route.ended.promise]);
 	}
 	async drainNotifications(route) {
-		await route.notificationTail;
+		await Promise.race([route.notificationTail, route.ended.promise]);
 	}
 	release(route, error = /* @__PURE__ */ new Error("codex app-server thread route is released")) {
 		if (route.released) return;
@@ -622,8 +655,8 @@ const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5e3;
 const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5e3;
 const CODEX_NO_ACTIVE_TURN_ERROR_CODE = -32600;
 const CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE = "no active turn to interrupt";
-/** Identifies Codex's exact proof that an interrupt target already finished. */
-function isCodexAlreadyTerminalInterruptError(error) {
+/** Codex also reports this before an accepted turn publishes its start event. */
+function isCodexNoActiveTurnInterruptError(error) {
 	return error instanceof CodexAppServerRpcError && error.code === CODEX_NO_ACTIVE_TURN_ERROR_CODE && error.message === CODEX_NO_ACTIVE_TURN_ERROR_MESSAGE;
 }
 /** Raised when a thread subscription may be live on a client OpenClaw no longer controls. */
@@ -640,18 +673,10 @@ function isCodexAppServerUnsafeSubscriptionError(error) {
 function assertCodexThreadResumeSubscription(requestedThreadId, returnedThreadId) {
 	if (returnedThreadId !== requestedThreadId) throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume returned ${returnedThreadId} for ${requestedThreadId}`);
 }
-async function closeClientAndWaitIfAvailable(client) {
-	const closeable = client;
-	if (typeof closeable.closeAndWait === "function") {
-		await closeable.closeAndWait();
-		return;
-	}
-	closeable.close?.();
-}
 async function closeCodexStartupClientBestEffort(client) {
 	if (!client) return;
 	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
-	if (!retiredSharedClient || retiredSharedClient.closed) await closeClientAndWaitIfAvailable(client);
+	if (!retiredSharedClient || retiredSharedClient.closed) await client.closeAndWait();
 }
 /** Retires an unsafe turn client without replacing an already-authoritative failure. */
 async function retireUnsafeCodexTurnClientBestEffort(client, operation) {
@@ -679,29 +704,75 @@ async function interruptCodexTurnAndWaitBestEffort(client, params) {
 		threadId: params.threadId,
 		turnId: params.turnId
 	};
-	let completion;
+	let cancelWatch;
 	try {
-		completion = params.turnId ? getCodexAppServerTurnRouter(client).watchNativeTurnCompletion({
+		if (!params.turnId) {
+			await client.request("turn/interrupt", requestParams, { timeoutMs });
+			return true;
+		}
+		const deadline = Date.now() + timeoutMs;
+		const started = createDeferred();
+		const completion = getCodexAppServerTurnRouter(client).watchNativeTurnCompletion({
 			threadId: params.threadId,
 			turnId: params.turnId,
-			timeoutMs
-		}) : void 0;
-		await client.request("turn/interrupt", requestParams, { timeoutMs });
-		return completion ? await completion.completion : true;
+			timeoutMs,
+			onStarted: () => started.resolve(true)
+		});
+		cancelWatch = completion.cancel;
+		if (completion.state !== "pending") return await completion.completion;
+		const requestInterrupt = async () => {
+			try {
+				await client.request("turn/interrupt", requestParams, {
+					timeoutMs: Math.max(1, deadline - Date.now()),
+					signal: completion.settledSignal
+				});
+				return true;
+			} catch (error) {
+				if (completion.state === "confirmed") return true;
+				if (isCodexNoActiveTurnInterruptError(error)) return false;
+				throw error;
+			}
+		};
+		if (!await requestInterrupt()) {
+			if (await Promise.race([completion.completion.then(() => false), started.promise]) && completion.state === "pending" && Date.now() < deadline) await requestInterrupt();
+		}
+		return await completion.completion;
 	} catch (error) {
-		if (isCodexAlreadyTerminalInterruptError(error)) return true;
 		embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
 		return false;
 	} finally {
-		completion?.cancel();
+		cancelWatch?.();
+	}
+}
+/** Stops native terminals on the cancelled thread without retiring peer threads. */
+async function terminateCodexBackgroundTerminals(client, threadId) {
+	const options = {
+		timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS,
+		signal: AbortSignal.timeout(CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS)
+	};
+	try {
+		const { data } = await client.request("thread/backgroundTerminals/list", { threadId }, options);
+		for (const { processId } of data) await client.request("thread/backgroundTerminals/terminate", {
+			threadId,
+			processId
+		}, options);
+		if (data.length > 0) {
+			if ((await client.request("thread/backgroundTerminals/list", {
+				threadId,
+				limit: 1
+			}, options)).data.length > 0) throw new Error("native background terminals remain running");
+		}
+	} catch (cause) {
+		throw new Error("Codex background-terminal cleanup failed; inspect the thread's running terminals before starting more work.", { cause });
 	}
 }
 /** Unsubscribes from a thread while swallowing cleanup-only failures. */
 async function unsubscribeCodexThreadBestEffort(client, params) {
 	try {
-		await unsubscribeCodexAppServerLiveThread(client, params.threadId, params.timeoutMs);
+		await unsubscribeCodexAppServerLiveThread(client, params.threadId, params.timeoutMs, params.assertCurrent);
 		return true;
 	} catch (error) {
+		params.assertCurrent?.();
 		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
 			threadId: params.threadId,
 			error
@@ -709,46 +780,5 @@ async function unsubscribeCodexThreadBestEffort(client, params) {
 		return false;
 	}
 }
-/**
-* Retires the shared client after a timed-out turn so later runs do not reuse a
-* potentially wedged app-server connection.
-*/
-async function retireCodexAppServerClientAfterTimedOutTurn(client, params) {
-	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client, { failActiveLeases: params.suspectPhysicalClient });
-	const detachedSharedClient = Boolean(retiredSharedClient);
-	if (!(params.suspectPhysicalClient && (retiredSharedClient?.closed ?? false))) {
-		await interruptCodexTurnAndWaitBestEffort(client, {
-			threadId: params.threadId,
-			turnId: params.turnId,
-			timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
-		});
-		await unsubscribeCodexThreadBestEffort(client, {
-			threadId: params.threadId,
-			timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
-		});
-	}
-	let closedClient = retiredSharedClient?.closed ?? false;
-	if (!detachedSharedClient) {
-		const close = client.close;
-		if (typeof close === "function") try {
-			close.call(client);
-			closedClient = true;
-		} catch (error) {
-			embeddedAgentLog.debug("codex app-server client close failed during timeout cleanup", {
-				threadId: params.threadId,
-				turnId: params.turnId,
-				error
-			});
-		}
-	}
-	embeddedAgentLog.warn("codex app-server client retired after timed-out turn", {
-		threadId: params.threadId,
-		turnId: params.turnId,
-		reason: params.reason,
-		detachedSharedClient,
-		closedClient,
-		activeSharedClientLeases: retiredSharedClient?.activeLeases ?? 0
-	});
-}
 //#endregion
-export { shouldSynthesizeToolProgressForItem as A, readNullableString as B, isSideEffectingNativeToolItem as C, itemTitle as D, itemStatus as E, readItem as F, readItemString as I, readNonEmptyString as L, normalizeOptionalString$1 as M, readCodexErrorNotificationMessage as N, shouldClearTerminalPresentationForNativeItem as O, readHookOutputEntries as P, readNonEmptyStringArray as R, isNonSuccessItemStatus as S, itemName as T, splitPlanText as V, readCodexNotificationTurnId as _, closeCodexStartupClientBestEffort as a, auditNativeToolUnfinishedStatus as b, isCodexAppServerUnsafeSubscriptionError as c, unsubscribeCodexThreadBestEffort as d, CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS as f, readCodexNotificationThreadId as g, isCodexNotificationForTurn as h, assertCodexThreadResumeSubscription as i, extractRawAssistantText as j, shouldRecordNativeToolTranscript as k, retireCodexAppServerClientAfterTimedOutTurn as l, CodexProjectionDiagnostics as m, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, getCodexAppServerTurnRouter as p, CodexAppServerUnsafeSubscriptionError as r, isCodexAlreadyTerminalInterruptError as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, retireUnsafeCodexTurnClientBestEffort as u, auditNativeToolName as v, itemKind as w, isMutatingNativeToolItem as x, auditNativeToolTerminalStatus as y, readNonNegativeInteger as z };
+export { shouldRecordNativeToolTranscript as A, readNonEmptyStringArray as B, isSideEffectingNativeToolItem as C, itemTitle as D, itemStatus as E, readCodexProviderRefusal as F, readNullableString as H, readHookOutputEntries as I, readItem as L, extractRawAssistantText as M, normalizeOptionalString$1 as N, matchesCodexSnapshotTurn as O, readCodexErrorNotificationMessage as P, readItemString as R, isNonSuccessItemStatus as S, itemName as T, splitPlanText as U, readNonNegativeInteger as V, readCodexNotificationTurnId as _, closeCodexStartupClientBestEffort as a, auditNativeToolUnfinishedStatus as b, isCodexNoActiveTurnInterruptError as c, unsubscribeCodexThreadBestEffort as d, CODEX_APP_SERVER_NATIVE_TURN_WAIT_TIMEOUT_MS as f, readCodexNotificationThreadId as g, isCodexNotificationForTurn as h, assertCodexThreadResumeSubscription as i, shouldSynthesizeToolProgressForItem as j, shouldClearTerminalPresentationForNativeItem as k, retireUnsafeCodexTurnClientBestEffort as l, CodexProjectionDiagnostics as m, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, getCodexAppServerTurnRouter as p, CodexAppServerUnsafeSubscriptionError as r, isCodexAppServerUnsafeSubscriptionError as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, terminateCodexBackgroundTerminals as u, auditNativeToolName as v, itemKind as w, isMutatingNativeToolItem as x, auditNativeToolTerminalStatus as y, readNonEmptyString as z };