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

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

@@ -1,4 +1,4 @@
-import { m as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-ZSMX1omP.js";
+import { C as canUseCodexModelBackedApprovalsReviewerForModel } from "./session-binding-BXpo9ymA.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-notifications-DdmnBMUp.js → attempt-notifications-AP-a-Q5k.js}

@@ -1,4 +1,4 @@
-import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
+import { W as isJsonObject } from "./shared-client-DTbvH-XV.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-D2ZAgZVz.js}

@@ -1,10 +1,10 @@
-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 { W as isJsonObject, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-DTbvH-XV.js";
+import { g as resolveCodexAppServerRuntimeOptions } from "./session-binding-BXpo9ymA.js";
+import { G as mergeCodexThreadConfigs, d as attestCodexRingZeroThreadHasNoMcpServers, f as buildCodexRingZeroThreadConfigPatch, m as readCodexInheritedMcpServerNames, mt as interruptCodexTurnAndWaitBestEffort, p as buildCodexRuntimeThreadConfig, u as assertCodexRingZeroHasNoManagedHooks, ut as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./thread-lifecycle-DF53ogiA.js";
+import { _ as readCodexNotificationItem, h as isRetryableErrorNotification } from "./attempt-notifications-AP-a-Q5k.js";
+import { n as normalizeCodexResponseTokenUsage } from "./event-projector-usage-Xp4AlR2k.js";
+import { C as readCodexTurnCompletedNotification, _ as assertCodexThreadStartResponse, b as readCodexErrorNotification, v as assertCodexTurnStartResponse } from "./transcript-mirror-DzsdNCf5.js";
+import { r as readModelListResult } from "./models-BBMKU4jA.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -32,6 +32,13 @@ const CODEX_SETTLED_FINALIZER_THREAD_CONFIG = {
 	"skills.include_instructions": false,
 	include_environment_context: false
 };
+var CodexBoundedTurnTimeoutError = class extends Error {
+	constructor(taskLabel, timeoutMs) {
+		const bound = timeoutMs % 1e3 === 0 ? `${timeoutMs / 1e3}s` : `${timeoutMs}ms`;
+		super(`codex app-server ${taskLabel} turn timed out after ${bound}`);
+		this.name = "TimeoutError";
+	}
+};
 async function runBoundedCodexAppServerTurn(params) {
 	const appServer = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.options.pluginConfig,
@@ -54,9 +61,10 @@ 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();
-	if (timeoutMs <= 0) throw new Error(`${params.taskLabel} timed out`);
+	if (timeoutMs <= 0) throw timeoutError;
 	const agentDir = params.agentDir?.trim() || void 0;
 	const startOptions = workspace.codexHome ? buildPrivateCodexAppServerStartOptions(appServer.start, workspace.codexHome) : appServer.start;
 	const ownsClient = !params.options.clientFactory;
@@ -65,22 +73,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-DTbvH-XV.js").then((n) => n.m).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(timeoutError);
+	const timeout = setTimeout(() => abortRun(timeoutError), Math.max(1, remainingRunMs));
 	timeout.unref?.();
 	let retrySelection = false;
 	try {
@@ -111,6 +136,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,10 +161,12 @@ 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,
-					signal: abortController.signal
+					signal: abortController.signal,
+					timeoutError
 				}),
 				model
 			};
@@ -146,11 +175,13 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			cleanup();
 		}
 	} catch (error) {
+		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
 		if (ownsClient && isCodexAppServerStartSelectionChangedError(error) && selectionAttempt === 0) retrySelection = true;
 		else throw error;
 	} finally {
 		clearTimeout(timeout);
 		params.signal?.removeEventListener("abort", abortFromCaller);
+		await interruptPromise;
 		if (ownsClient) client.close();
 	}
 	if (retrySelection) return await runBoundedCodexAppServerTurnInWorkspace(params, appServer, workspace, selectionAttempt + 1, {
@@ -284,9 +315,9 @@ function createCodexBoundedTurnCollector(threadId, taskLabel) {
 			for (const notification of pending.splice(0)) handleNotification(notification);
 			if (!completedTurn && !promptError) await waitForTurnCompletion({
 				completion,
-				timeoutMs: options.timeoutMs,
 				signal: options.signal,
-				taskLabel
+				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`);
@@ -310,22 +341,21 @@ function collectCompletedItems(turnItems, notificationItems) {
 	return [...items.values()];
 }
 async function waitForTurnCompletion(params) {
-	if (params.signal.aborted) throw new Error(`codex app-server ${params.taskLabel} turn aborted`);
-	let timeout;
+	if (params.signal.aborted) throw resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError);
 	let cleanupAbort;
 	try {
 		await Promise.race([params.completion, new Promise((_, reject) => {
-			timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} turn timed out`)), params.timeoutMs);
-			timeout.unref?.();
-			const abortListener = () => reject(/* @__PURE__ */ new Error(`codex app-server ${params.taskLabel} turn aborted`));
+			const abortListener = () => reject(resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError));
 			params.signal.addEventListener("abort", abortListener, { once: true });
 			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
 		})]);
 	} finally {
-		if (timeout) clearTimeout(timeout);
 		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();
 }

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

@@ -1,4 +1,4 @@
-import { R as CodexAppServerRpcError } from "./shared-client-wmgNFNYp.js";
+import { v as CodexAppServerRpcError } from "./shared-client-DTbvH-XV.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-2PZaFLRh.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",

package/dist/{command-formatters-DgADqnHa.js → command-formatters-C336eRVS.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 { W as isJsonObject } from "./shared-client-DTbvH-XV.js";
+import { c as summarizeCodexRateLimits, o as summarizeCodexAccountRateLimits, r as hasCodexRateLimitSnapshots } from "./rate-limits-CU-gVCCS.js";
 //#region extensions/codex/src/command-formatters.ts
 /** Formats the combined `/codex status` probe result. */
 function formatCodexStatus(probes) {