@openclaw/codex 2026.7.2-beta.4 → 2026.7.2-beta.5

package/dist/{app-server-policy-BO3jYBkv.js → app-server-policy-BmDgseo_.js}

@@ -1,4 +1,4 @@
-import { m as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-ZSMX1omP.js";
+import { b as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-DlVQ-Pxs.js";
 //#region extensions/codex/src/app-server/app-server-policy.ts
 /**
 * Policy promotion for Codex app-server runs that can safely use OpenClaw tool

package/dist/attempt-client-cleanup-Ia52yRWc.js

@@ -0,0 +1,127 @@
+import { f as retireSharedCodexAppServerClientIfCurrent, n as clearSharedCodexAppServerClientIfCurrentAndUnclaimed, t as clearSharedCodexAppServerClientIfCurrent } from "./shared-client-BVKE40c-.js";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/attempt-client-cleanup.ts
+/**
+* Best-effort cleanup helpers for Codex app-server startup attempts and turns.
+*/
+/** Timeout for best-effort app-server turn interruption during cleanup. */
+const CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS = 5e3;
+/** Timeout for best-effort thread unsubscribe during cleanup. */
+const CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS = 5e3;
+/** Raised when a thread subscription may be live on a client OpenClaw no longer controls. */
+var CodexAppServerUnsafeSubscriptionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "CodexAppServerUnsafeSubscriptionError";
+	}
+};
+function isCodexAppServerUnsafeSubscriptionError(error) {
+	return error instanceof CodexAppServerUnsafeSubscriptionError;
+}
+/** Asserts Codex resumed the exact thread this attempt subscribed to. */
+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 unclaimedSharedClient = clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client);
+	if (unclaimedSharedClient.closed) {
+		await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	if (unclaimedSharedClient.found) {
+		if (retireSharedCodexAppServerClientIfCurrent(client)?.closed) await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	const retiredSharedClient = retireSharedCodexAppServerClientIfCurrent(client);
+	if (retiredSharedClient) {
+		if (retiredSharedClient.closed) await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	if (clearSharedCodexAppServerClientIfCurrent(client)) {
+		await closeClientAndWaitIfAvailable(client);
+		return;
+	}
+	await closeClientAndWaitIfAvailable(client);
+}
+/** Sends a turn interrupt without blocking abort cleanup on app-server errors. */
+function interruptCodexTurnBestEffort(client, params) {
+	interruptCodexTurnAndWaitBestEffort(client, params);
+}
+/** Sends a bounded turn interrupt and waits for Codex to confirm terminal abort handling. */
+async function interruptCodexTurnAndWaitBestEffort(client, params) {
+	const requestOptions = params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? { timeoutMs: params.timeoutMs } : void 0;
+	const requestParams = {
+		threadId: params.threadId,
+		turnId: params.turnId
+	};
+	try {
+		await (requestOptions ? client.request("turn/interrupt", requestParams, requestOptions) : client.request("turn/interrupt", requestParams));
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server turn interrupt failed during abort", { error });
+	}
+}
+/** Unsubscribes from a thread while swallowing cleanup-only failures. */
+async function unsubscribeCodexThreadBestEffort(client, params) {
+	try {
+		await client.request("thread/unsubscribe", { threadId: params.threadId }, { timeoutMs: params.timeoutMs });
+		return true;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server thread unsubscribe cleanup failed", {
+			threadId: params.threadId,
+			error
+		});
+		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))) {
+		interruptCodexTurnBestEffort(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 { closeCodexStartupClientBestEffort as a, isCodexAppServerUnsafeSubscriptionError as c, assertCodexThreadResumeSubscription as i, retireCodexAppServerClientAfterTimedOutTurn as l, CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS as n, interruptCodexTurnAndWaitBestEffort as o, CodexAppServerUnsafeSubscriptionError as r, interruptCodexTurnBestEffort as s, CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS as t, unsubscribeCodexThreadBestEffort as u };

package/dist/{attempt-notifications-DdmnBMUp.js → attempt-notifications-CMR2_fmR.js}

@@ -1,4 +1,4 @@
-import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
+import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/attempt-notifications.ts
 /**

package/dist/{bounded-turn-CaQL96kg.js → bounded-turn-FEbUXoYT.js}

@@ -1,10 +1,11 @@
-import { Q as isJsonObject, o as isCodexAppServerStartSelectionChangedError } from "./shared-client-wmgNFNYp.js";
-import { _ as readCodexNotificationItem, h as isRetryableErrorNotification } from "./attempt-notifications-DdmnBMUp.js";
-import { x as resolveCodexAppServerRuntimeOptions } from "./session-binding-ZSMX1omP.js";
-import { Q as mergeCodexThreadConfigs, d as buildCodexRingZeroThreadConfigPatch, f as buildCodexRuntimeThreadConfig, l as assertCodexRingZeroHasNoManagedHooks, p as readCodexInheritedMcpServerNames, u as attestCodexRingZeroThreadHasNoMcpServers } from "./thread-lifecycle-cqrOlJkq.js";
-import { t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-D6tE7_qD.js";
-import { C as readCodexTurnCompletedNotification, _ as assertCodexThreadStartResponse, b as readCodexErrorNotification, v as assertCodexTurnStartResponse } from "./transcript-mirror-2p7kl6e4.js";
-import { r as readModelListResult } from "./models-BNeMlHgg.js";
+import { V as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-BVKE40c-.js";
+import { p as resolveCodexAppServerRuntimeOptions } from "./session-binding-DlVQ-Pxs.js";
+import { o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-Ia52yRWc.js";
+import { _ as readCodexNotificationItem, h as isRetryableErrorNotification } from "./attempt-notifications-CMR2_fmR.js";
+import { G as mergeCodexThreadConfigs, d as buildCodexRingZeroThreadConfigPatch, f as buildCodexRuntimeThreadConfig, l as assertCodexRingZeroHasNoManagedHooks, p as readCodexInheritedMcpServerNames, u as attestCodexRingZeroThreadHasNoMcpServers } from "./thread-lifecycle-DRg_FdzC.js";
+import { t as normalizeCodexResponseTokenUsage } from "./event-projector-usage-tvgb1NCX.js";
+import { a as assertCodexTurnStartResponse, i as assertCodexThreadStartResponse, s as readCodexErrorNotification, u as readCodexTurnCompletedNotification } from "./protocol-validators-Dm4eXZmt.js";
+import { r as readModelListResult } from "./models-BA01NEez.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -65,22 +66,39 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		authProfileId: params.profile,
 		agentDir,
 		config: params.config,
-		timeoutMs
-	}) : await import("./shared-client-wmgNFNYp.js").then((n) => n.f).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+		timeoutMs,
+		...params.signal ? { abandonSignal: params.signal } : {}
+	}) : await import("./shared-client-BVKE40c-.js").then((n) => n.p).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions,
 		timeoutMs,
 		authProfileId: params.profile,
 		agentDir,
 		authProfileStore: params.authProfileStore,
-		config: params.config
+		config: params.config,
+		...params.signal ? { abandonSignal: params.signal } : {}
 	}));
 	const abortController = new AbortController();
-	const abortFromCaller = () => abortController.abort(params.signal?.reason ?? "aborted");
+	let activeThreadId;
+	let activeTurnId = "";
+	let interruptPromise;
+	const requestInterrupt = () => {
+		if (!activeThreadId || interruptPromise) return;
+		interruptPromise = interruptCodexTurnAndWaitBestEffort(client, {
+			threadId: activeThreadId,
+			turnId: activeTurnId,
+			timeoutMs: CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS
+		});
+	};
+	const abortRun = (reason) => {
+		abortController.abort(reason);
+		requestInterrupt();
+	};
+	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();
-	if (remainingRunMs <= 0) abortController.abort("timeout");
-	const timeout = setTimeout(() => abortController.abort("timeout"), Math.max(1, remainingRunMs));
+	if (remainingRunMs <= 0) abortRun("timeout");
+	const timeout = setTimeout(() => abortRun("timeout"), Math.max(1, remainingRunMs));
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
@@ -111,6 +129,8 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			timeoutMs,
 			signal: abortController.signal
 		}));
+		activeThreadId = thread.thread.id;
+		if (abortController.signal.aborted) requestInterrupt();
 		if (params.requireNoExternalCapabilities) await attestCodexRingZeroThreadHasNoMcpServers(client, thread.thread.id, abortController.signal);
 		if (params.historyItems?.length) await client.request("thread/inject_items", {
 			threadId: thread.thread.id,
@@ -134,6 +154,8 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 				timeoutMs,
 				signal: abortController.signal
 			}));
+			activeTurnId = turn.turn.id;
+			if (abortController.signal.aborted) requestInterrupt();
 			return {
 				...await collector.collect(turn.turn, {
 					timeoutMs,
@@ -151,6 +173,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 	} finally {
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
+		await interruptPromise;
 		if (ownsClient) client.close();
 	}
 	if (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {

package/dist/{capabilities-CLICvTxf.js → capabilities-BHRSI6Cn.js}

@@ -1,4 +1,4 @@
-import { R as CodexAppServerRpcError } from "./shared-client-wmgNFNYp.js";
+import { _ as CodexAppServerRpcError } from "./shared-client-BVKE40c-.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-CYJTfRLG.js");
+		const { registerCodexSessionCli } = await import("./session-cli-CqZ0Fp2a.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-DgADqnHa.js → command-formatters-ico4ZFnk.js}

@@ -1,5 +1,5 @@
-import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
-import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-D0IJT-a6.js";
+import { V as isJsonObject } from "./shared-client-BVKE40c-.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-S_PXs0ul.js";
 //#region extensions/codex/src/command-formatters.ts
 /** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {