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

package/dist/upstream-session-fork-vPjwkT1i.js

@@ -0,0 +1,320 @@
+import { l as sessionBindingIdentity } from "./session-binding-ZSMX1omP.js";
+import { h as assertCodexThreadForkResponse } from "./transcript-mirror-2p7kl6e4.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D7XlI9us.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/app-server/upstream-fork-boundary.ts
+const TURN_PAGE_LIMIT = 100;
+function failure(code, message) {
+	return {
+		ok: false,
+		code,
+		message
+	};
+}
+function asInputs(item) {
+	return Array.isArray(item.content) ? item.content : [];
+}
+function userMessageDisplay(item) {
+	let text = "";
+	let hasTextElement = false;
+	let hasImage = false;
+	let hasUnverifiableInput = false;
+	for (const input of asInputs(item)) if (input.type === "text") {
+		if (typeof input.text === "string") text += input.text;
+		hasTextElement ||= Array.isArray(input.textElements) && input.textElements.length > 0;
+	} else {
+		hasUnverifiableInput = true;
+		hasImage ||= input.type === "image" || input.type === "localImage";
+	}
+	return {
+		text,
+		visible: Boolean(text.trim()) || hasTextElement || hasImage,
+		hasUnverifiableInput
+	};
+}
+function isHiddenNestedReviewTurn(previous, turn) {
+	if (previous?.status !== "completed" || turn.status !== "interrupted" || turn.completedAt != null || !previous.items.some((item) => item.type === "enteredReviewMode") || !previous.items.some((item) => item.type === "exitedReviewMode")) return false;
+	const userMessages = turn.items.filter((item) => item.type === "userMessage");
+	const [firstUserMessage, secondUserMessage] = userMessages;
+	if (!firstUserMessage || !secondUserMessage || userMessages.length !== 2) return false;
+	return JSON.stringify(asInputs(firstUserMessage)) === JSON.stringify(asInputs(secondUserMessage));
+}
+function localMessageText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return;
+	const texts = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object" || Array.isArray(block)) return;
+		const typed = block;
+		if (typed.type !== "text" || typeof typed.text !== "string") return;
+		texts.push(typed.text);
+	}
+	return texts.join("");
+}
+function resolveCodexUpstreamForkBoundaryFromTurns(params) {
+	let visibleUserMessagesSeen = 0;
+	let reviewMode = false;
+	for (const [turnIndex, turn] of params.turns.entries()) {
+		const hiddenNestedReviewTurn = isHiddenNestedReviewTurn(params.turns[turnIndex - 1], turn);
+		let userMessagesInTurn = 0;
+		for (const item of turn.items) {
+			if (item.type === "enteredReviewMode") {
+				reviewMode = true;
+				continue;
+			}
+			if (item.type === "exitedReviewMode") {
+				reviewMode = false;
+				continue;
+			}
+			if (item.type !== "userMessage") continue;
+			const isSteer = userMessagesInTurn > 0;
+			userMessagesInTurn += 1;
+			if (reviewMode || hiddenNestedReviewTurn) continue;
+			const display = userMessageDisplay(item);
+			if (display.hasUnverifiableInput) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
+			if (!display.visible) continue;
+			const ordinal = visibleUserMessagesSeen;
+			if (ordinal > params.userMessageOrdinal) break;
+			const localText = params.localPrefixTexts[ordinal];
+			if (localText === void 0) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
+			if (display.text !== localText) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
+			if (ordinal !== params.userMessageOrdinal) {
+				visibleUserMessagesSeen += 1;
+				continue;
+			}
+			if (isSteer) return failure("steer-message", "This message steered an existing Codex turn and cannot be forked independently. Fork from the turn's first message instead.");
+			if (turn.status === "inProgress") return failure("in-progress-turn", "This Codex turn is still in progress. Wait for it to finish, then try forking again.");
+			const retained = turnIndex > 0 ? params.turns[turnIndex - 1] : void 0;
+			return {
+				ok: true,
+				boundary: {
+					beforeTurnId: turn.id,
+					targetTurnId: turn.id,
+					retainedMarker: retained ? {
+						turnId: retained.id,
+						userMessageCount: retained.items.filter((retainedItem) => retainedItem.type === "userMessage").length
+					} : {
+						turnId: null,
+						userMessageCount: 0
+					}
+				}
+			};
+		}
+	}
+	return failure("drift-mismatch", "The message could not be matched to the Codex thread. Refresh the session and try again.");
+}
+async function listCodexUpstreamTurns(control, threadId) {
+	const turns = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor;
+	for (;;) {
+		const page = await control.listTurnPage({
+			threadId,
+			limit: TURN_PAGE_LIMIT,
+			sortDirection: "asc",
+			itemsView: "full",
+			...cursor ? { cursor } : {}
+		});
+		turns.push(...page.data);
+		const nextCursor = page.nextCursor?.trim() || void 0;
+		if (!nextCursor) return turns;
+		if (seenCursors.has(nextCursor)) throw new Error("Codex returned a repeated thread/turns/list cursor");
+		seenCursors.add(nextCursor);
+		cursor = nextCursor;
+	}
+}
+async function resolveCodexUpstreamForkBoundary(params) {
+	try {
+		if ((await params.control.readThread(params.threadId, false)).historyMode === "paginated") return failure("upstream-unavailable", "This Codex thread uses paginated history, which cannot be forked from OpenClaw yet.");
+		const visibleUserEntries = (await readVisibleSessionTranscriptMessageEntries({
+			agentId: params.agentId,
+			sessionId: params.sessionId,
+			sessionKey: params.sessionKey,
+			storePath: params.storePath
+		})).filter((entry) => entry.role === "user");
+		const userMessageOrdinal = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
+		if (userMessageOrdinal < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
+		const localPrefixTexts = visibleUserEntries.slice(0, userMessageOrdinal + 1).map((entry) => localMessageText("content" in entry.message ? entry.message.content : void 0));
+		const resolved = resolveCodexUpstreamForkBoundaryFromTurns({
+			turns: await listCodexUpstreamTurns(params.control, params.threadId),
+			userMessageOrdinal,
+			localPrefixTexts
+		});
+		return resolved.ok ? {
+			...resolved,
+			editorText: localPrefixTexts[userMessageOrdinal]
+		} : resolved;
+	} catch {
+		return failure("upstream-unavailable", "The Codex thread could not be read. Check that Codex is available, then try again.");
+	}
+}
+function precheckCodexUpstreamForkBoundary(params) {
+	const target = params.turns.find((turn) => turn.id === params.boundary.targetTurnId);
+	if (!target) return failure("upstream-unavailable", "The Codex thread changed before it could be forked. Refresh the session and try again.");
+	if (target.status === "inProgress") return failure("in-progress-turn", "This Codex turn is still in progress. Wait for it to finish, then try forking again.");
+	return {
+		ok: true,
+		boundary: params.boundary
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/upstream-session-fork.ts
+function readConnectionFingerprint(ref) {
+	if (!isRecord(ref)) return;
+	return typeof ref.connectionFingerprint === "string" && ref.connectionFingerprint.trim() ? ref.connectionFingerprint : void 0;
+}
+function normalizeTurnId(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+async function forkCodexUpstreamSession(params, options) {
+	try {
+		return await options.control.withPinnedConnection(async (control) => {
+			const incognito = isIncognitoSessionKey(params.targetKey);
+			const clientId = control.clientId?.trim();
+			if (incognito && !clientId) throw new Error("Incognito Codex forks require the live pinned app-server client");
+			let linked = false;
+			let bindingIdentity;
+			const compensateFork = async (forkedThreadId) => {
+				if (bindingIdentity) await options.bindingStore.mutate(bindingIdentity, {
+					kind: "clear",
+					threadId: forkedThreadId
+				}).catch(() => void 0);
+				if (linked) deleteSessionUpstreamLink(params.targetKey, params.source.agentId);
+				await control.archiveThread(forkedThreadId).catch(() => void 0);
+			};
+			const sourceFingerprint = readConnectionFingerprint(params.upstream.ref);
+			if (params.upstream.kind !== "codex-app-server" || !sourceFingerprint || sourceFingerprint !== control.connectionFingerprint) return {
+				status: "failed",
+				code: "upstream-unavailable",
+				message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
+			};
+			const resolved = await resolveCodexUpstreamForkBoundary({
+				...params.source,
+				threadId: params.upstream.threadId,
+				control
+			});
+			if (!resolved.ok) return {
+				status: "failed",
+				code: resolved.code,
+				message: resolved.message
+			};
+			const liveTurns = await listCodexUpstreamTurns(control, params.upstream.threadId);
+			const precheck = precheckCodexUpstreamForkBoundary({
+				boundary: resolved.boundary,
+				turns: liveTurns
+			});
+			if (!precheck.ok) return {
+				status: "failed",
+				code: precheck.code,
+				message: precheck.message
+			};
+			const rawResponse = await control.forkThread({
+				threadId: params.upstream.threadId,
+				beforeTurnId: resolved.boundary.beforeTurnId,
+				...incognito ? { ephemeral: true } : {},
+				excludeTurns: !incognito
+			});
+			let response;
+			try {
+				response = assertCodexThreadForkResponse(rawResponse);
+			} catch (error) {
+				const orphanThreadId = isRecord(rawResponse.thread) && typeof rawResponse.thread.id === "string" ? rawResponse.thread.id.trim() : "";
+				if (orphanThreadId && orphanThreadId !== params.upstream.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
+				throw error;
+			}
+			const threadId = response.thread.id.trim();
+			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
+			if (threadId === params.upstream.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			const forkedThreadId = threadId;
+			try {
+				const connectionFingerprint = control.connectionFingerprint;
+				if (!connectionFingerprint) throw new Error("Codex fork connection did not include a fingerprint");
+				const forkedTurns = incognito ? response.thread.turns ?? [] : await listCodexUpstreamTurns(control, threadId);
+				const expectedLastTurnId = resolved.boundary.retainedMarker.turnId;
+				if ((forkedTurns.at(-1)?.id ?? null) !== expectedLastTurnId) {
+					await compensateFork(forkedThreadId);
+					return {
+						status: "failed",
+						code: "upstream-unavailable",
+						message: "This Codex version does not support message-level forks. Update Codex, reconnect, and try again."
+					};
+				}
+				const forkedThread = {
+					...response.thread,
+					turns: forkedTurns
+				};
+				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeTurnId) ?? null;
+				const marker = codexUpstreamBaseline(forkedThread, normalizeTurnId);
+				const config = options.resolveConfig?.() ?? {};
+				return {
+					status: "created",
+					key: (await createImportedCodexSession({
+						runtime: options.runtime,
+						config,
+						key: params.targetKey,
+						agentId: params.source.agentId,
+						thread: forkedThread,
+						throughTurnId,
+						initialEntry: {
+							agentHarnessId: options.harnessRuntimeId,
+							modelSelectionLocked: true
+						},
+						afterImport: async (entry) => {
+							bindingIdentity = sessionBindingIdentity({
+								agentId: entry.agentId,
+								sessionId: entry.sessionId,
+								sessionKey: entry.key,
+								config
+							});
+							linked = upsertSessionUpstreamLink({
+								sessionKey: entry.key,
+								agentId: entry.agentId,
+								catalogId: params.upstream.catalogId,
+								hostId: params.upstream.hostId,
+								threadId,
+								upstreamKind: params.upstream.kind,
+								upstreamRef: {
+									connectionFingerprint,
+									threadId
+								},
+								marker
+							});
+							if (!linked) throw new Error("Codex fork link could not be persisted");
+							if (!await options.bindingStore.mutate(bindingIdentity, {
+								kind: "set",
+								binding: {
+									threadId,
+									...incognito && clientId ? { clientId } : {},
+									cwd: forkedThread.cwd ?? "",
+									model: response.model,
+									modelProvider: response.modelProvider ?? void 0,
+									historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
+								}
+							})) throw new Error("Codex session binding changed before the fork could be attached");
+							return { pluginExtensions: entry.entry.pluginExtensions };
+						}
+					})).key,
+					...resolved.editorText !== void 0 ? { editorText: resolved.editorText } : {}
+				};
+			} catch {
+				await compensateFork(forkedThreadId);
+				return {
+					status: "failed",
+					code: "upstream-unavailable",
+					message: "The Codex fork could not be verified or imported into a new session. Refresh sessions and try again."
+				};
+			}
+		});
+	} catch {
+		return {
+			status: "failed",
+			code: "upstream-unavailable",
+			message: "The Codex thread could not be forked. Check that Codex is available, then try again."
+		};
+	}
+}
+//#endregion
+export { forkCodexUpstreamSession };

package/dist/{usage-D5Rohxoc.js → usage-DM_I3mPT.js}

@@ -1,6 +1,6 @@
-import { b as resolveCodexAppServerRuntimeOptions } from "./session-binding-h1mmCGnl.js";
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-DyXaYAxU.js";
-import { t as readCodexAppServerUsage } from "./request-B_oQsCXy.js";
+import { x as resolveCodexAppServerRuntimeOptions } from "./session-binding-ZSMX1omP.js";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-D0IJT-a6.js";
+import { t as readCodexAppServerUsage } from "./request-BTccUTD3.js";
 import { CODEX_APP_SERVER_AUTH_MARKER } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/codex/src/app-server/usage.ts
 /** Handles the synthetic usage credential for a Codex-backed OpenAI route. */

package/dist/{web-search-provider.runtime-CKVBn3fP.js → web-search-provider.runtime-Bx6HAc_k.js}

@@ -1,6 +1,6 @@
-import { Z as isJsonObject } from "./shared-client-JiAnW6pc.js";
-import { u as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-CN_pPtPh.js";
-import { n as runBoundedCodexAppServerTurn } from "./media-understanding-provider-D31dOJwb.js";
+import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
+import { m as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-cqrOlJkq.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-CaQL96kg.js";
 import { readStringParam, resolveSearchTimeoutSeconds, wrapWebContent } from "openclaw/plugin-sdk/provider-web-search";
 //#region extensions/codex/src/web-search-provider.runtime.ts
 async function executeCodexWebSearchProviderTool(ctx, args, executionContext, options) {

package/npm-shrinkwrap.json

@@ -1,25 +1,25 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/codex",
-      "version": "2026.7.2-beta.2",
+      "version": "2026.7.2-beta.4",
       "dependencies": {
-        "@openai/codex": "0.144.5",
+        "@openai/codex": "0.145.0",
         "semver": "7.8.5",
         "smol-toml": "1.7.0",
-        "typebox": "1.3.3",
-        "ws": "8.21.0",
+        "typebox": "1.3.6",
+        "ws": "8.21.1",
         "zod": "4.4.3"
       }
     },
     "node_modules/@openai/codex": {
-      "version": "0.144.5",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5.tgz",
-      "integrity": "sha512-jjB+K+OMv572mKhS+2QuLxWXDJNdpwbPenf+V+8bdq7wg4Scqt3cn6WEekD8wPqDVZqck0HSX17K9rD9kbDJQA==",
+      "version": "0.145.0",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0.tgz",
+      "integrity": "sha512-/PSPSFujjjmiyVFvG2yu/grOFhsWdokTH8t2KGWhXSo/M5n/dIDsnbsnO82/7bLtIoDuzQf7ATBUMWqPWQINlQ==",
       "license": "Apache-2.0",
       "bin": {
         "codex": "bin/codex.js"
@@ -28,19 +28,19 @@
         "node": ">=16"
       },
       "optionalDependencies": {
-        "@openai/codex-darwin-arm64": "npm:@openai/codex@0.144.5-darwin-arm64",
-        "@openai/codex-darwin-x64": "npm:@openai/codex@0.144.5-darwin-x64",
-        "@openai/codex-linux-arm64": "npm:@openai/codex@0.144.5-linux-arm64",
-        "@openai/codex-linux-x64": "npm:@openai/codex@0.144.5-linux-x64",
-        "@openai/codex-win32-arm64": "npm:@openai/codex@0.144.5-win32-arm64",
-        "@openai/codex-win32-x64": "npm:@openai/codex@0.144.5-win32-x64"
+        "@openai/codex-darwin-arm64": "npm:@openai/codex@0.145.0-darwin-arm64",
+        "@openai/codex-darwin-x64": "npm:@openai/codex@0.145.0-darwin-x64",
+        "@openai/codex-linux-arm64": "npm:@openai/codex@0.145.0-linux-arm64",
+        "@openai/codex-linux-x64": "npm:@openai/codex@0.145.0-linux-x64",
+        "@openai/codex-win32-arm64": "npm:@openai/codex@0.145.0-win32-arm64",
+        "@openai/codex-win32-x64": "npm:@openai/codex@0.145.0-win32-x64"
       }
     },
     "node_modules/@openai/codex-darwin-arm64": {
       "name": "@openai/codex",
-      "version": "0.144.5-darwin-arm64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-darwin-arm64.tgz",
-      "integrity": "sha512-zcT6NfBCqLFt+BReNSETTZW6v6PdbH0dzNtm9j7l7mDGqwPbKZDGJdnpkBao2389I0ZacyIKgSZoI0vez1d4Dw==",
+      "version": "0.145.0-darwin-arm64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-darwin-arm64.tgz",
+      "integrity": "sha512-h6aQ0UxnaP8mIM/9/qPAH9MNkRliJo88toq1T36IxNM2L5JSU0TFamu+MZn7YkFgDsrp0RfiI+97Tm8AVVxqtA==",
       "cpu": [
         "arm64"
       ],
@@ -55,9 +55,9 @@
     },
     "node_modules/@openai/codex-darwin-x64": {
       "name": "@openai/codex",
-      "version": "0.144.5-darwin-x64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-darwin-x64.tgz",
-      "integrity": "sha512-//Mo0m1MwaoT6psu5xsmofXpKx4/0irIkeq10xJvk59+886EG355ibjA+ZmlRcKhE3bLjsKD7p81nTbAdRL/bw==",
+      "version": "0.145.0-darwin-x64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-darwin-x64.tgz",
+      "integrity": "sha512-FCYzVKCa9VoLtg9gVyzKpqylonfgZrfcWZN6HsXAZPeuo8CukdMqdgTUOhDn2V6h3MbqS0z6VqQVKUllN/yKhA==",
       "cpu": [
         "x64"
       ],
@@ -72,9 +72,9 @@
     },
     "node_modules/@openai/codex-linux-arm64": {
       "name": "@openai/codex",
-      "version": "0.144.5-linux-arm64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-linux-arm64.tgz",
-      "integrity": "sha512-zAHggxVwR2TBxKmybXY7ZMiB0G8DMonY2YPdwNNjwXcf+LOIqNGgswwNCDMbP/HEe6r8j+R9ZX/yYoo8f+n/RQ==",
+      "version": "0.145.0-linux-arm64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-linux-arm64.tgz",
+      "integrity": "sha512-8OLcPXaAol/FOrRoDxWhIiHIFa73KRsM41EKocjRZOwiT4TcelzJWn3dHyiuSb7teWF25rrslvSPyvhULYRRCQ==",
       "cpu": [
         "arm64"
       ],
@@ -89,9 +89,9 @@
     },
     "node_modules/@openai/codex-linux-x64": {
       "name": "@openai/codex",
-      "version": "0.144.5-linux-x64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-linux-x64.tgz",
-      "integrity": "sha512-FalLJlBQGFdK8Gc3kj9sa/ekNdgkHhUawLaKkvy5CtB18JaP2YxtTP/Pe1pD2iBiq8mMUliRnafpF6AdBdQMbg==",
+      "version": "0.145.0-linux-x64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-linux-x64.tgz",
+      "integrity": "sha512-u8w8LLv3DvsfrDCoswLIemZ0SoNEXyi511WsfFsSiYUazk9qMsB/NtU8N9vhAfN7mZAxLFoMex4v66JjHuZWwA==",
       "cpu": [
         "x64"
       ],
@@ -106,9 +106,9 @@
     },
     "node_modules/@openai/codex-win32-arm64": {
       "name": "@openai/codex",
-      "version": "0.144.5-win32-arm64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-win32-arm64.tgz",
-      "integrity": "sha512-0Pj7iqjEOEvPQPO3kFfCy9vGX4BTu76ChFFZHr2eNNIfVc3FOENAv/X98u4L+iIUtDOK9DbqmfUudW3DPapshg==",
+      "version": "0.145.0-win32-arm64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-win32-arm64.tgz",
+      "integrity": "sha512-sub61rjEFevi1i3Zx7nAd4JM5XxoNFqMqFc5LfTo2xSI8ixHjFvEYDFDXwXOftT04n3Ht1Wh271ioUZpDiEjEg==",
       "cpu": [
         "arm64"
       ],
@@ -123,9 +123,9 @@
     },
     "node_modules/@openai/codex-win32-x64": {
       "name": "@openai/codex",
-      "version": "0.144.5-win32-x64",
-      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.144.5-win32-x64.tgz",
-      "integrity": "sha512-DnsSTlnnzleTxvLwIGnBitKInscxn2I7qASqosS8Fv+qysBygd+ZiBn/SQsRCgQ28PAlsNzmd3Gf3ZTecolAmg==",
+      "version": "0.145.0-win32-x64",
+      "resolved": "https://registry.npmjs.org/@openai/codex/-/codex-0.145.0-win32-x64.tgz",
+      "integrity": "sha512-u0h9lk094CaXRSqE34SBW2dRaQTPa6fASXqehczWH9QdsU62mBsiAgAdp6tCG4i+YzPmmhjD8FdXNnYGNmwuMg==",
       "cpu": [
         "x64"
       ],
@@ -163,15 +163,15 @@
       }
     },
     "node_modules/typebox": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.3.tgz",
-      "integrity": "sha512-URXGUE31PJDQC+PtRMJeLdF4kmmOdFoVPikPCtV2oOIhUpNpppEdIz7W8bH8cFYPYHdDpaRvqwdegMTmHliudg==",
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/typebox/-/typebox-1.3.6.tgz",
+      "integrity": "sha512-Sc8RA0NCMEFmApHNU9ZMzqcpQj46She44J8ffpLM/bdhLNUZKq7DJumcLcsFx1gRmDfQPgCgOmFFJ7rcnfWNyA==",
       "license": "MIT"
     },
     "node_modules/ws": {
-      "version": "8.21.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
-      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "version": "8.21.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.1.tgz",
+      "integrity": "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/openclaw.plugin.json

@@ -279,6 +279,11 @@
             "minimum": 1,
             "default": 60000
           },
+          "turnAssistantCompletionIdleTimeoutMs": {
+            "type": "number",
+            "minimum": 1,
+            "default": 10000
+          },
           "postToolRawAssistantCompletionIdleTimeoutMs": {
             "type": "number",
             "minimum": 1,
@@ -536,7 +541,7 @@
     },
     "appServer.transport": {
       "label": "Transport",
-      "help": "Use stdio to spawn Codex locally, unix for the shared local control socket, or websocket for a remote app-server.",
+      "help": "Use stdio to spawn Codex locally or unix for the shared local control socket. Remote websocket transport is experimental and unsupported by Codex.",
       "advanced": true
     },
     "appServer.homeScope": {
@@ -601,6 +606,11 @@
       "help": "Maximum quiet time after Codex accepts a turn or after a turn-scoped app-server request before OpenClaw interrupts the turn while waiting for turn/completed.",
       "advanced": true
     },
+    "appServer.turnAssistantCompletionIdleTimeoutMs": {
+      "label": "Assistant Completion Idle Timeout",
+      "help": "Short quiet-time guard after Codex reports a completed assistant message before OpenClaw releases the turn.",
+      "advanced": true
+    },
     "appServer.postToolRawAssistantCompletionIdleTimeoutMs": {
       "label": "Post-Tool Continuation Idle Timeout",
       "help": "Completion-idle and progress guard after a tool handoff, native tool completion, or post-tool raw assistant progress while waiting for turn/completed. Defaults to 300000 ms when unset.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.4",
   "description": "OpenClaw Codex app-server harness and native session supervision plugin.",
   "repository": {
     "type": "git",
@@ -8,11 +8,11 @@
   },
   "type": "module",
   "dependencies": {
-    "@openai/codex": "0.144.5",
+    "@openai/codex": "0.145.0",
     "semver": "7.8.5",
     "smol-toml": "1.7.0",
-    "typebox": "1.3.3",
-    "ws": "8.21.0",
+    "typebox": "1.3.6",
+    "ws": "8.21.1",
     "zod": "4.4.3"
   },
   "devDependencies": {
@@ -36,10 +36,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.2"
+      "pluginApi": ">=2026.7.2-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.2"
+      "openclawVersion": "2026.7.2-beta.4"
     },
     "release": {
       "publishToClawHub": true,
@@ -60,7 +60,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.2"
+    "openclaw": ">=2026.7.2-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {