@openclaw/codex 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/.setup/{effective-mcp-catalog-B5HKFZNK.mjs → effective-mcp-catalog-C3ta5hHc.mjs}

@@ -1,7 +1,7 @@
-import { m as sessionBindingIdentity } from "./session-binding-record-DU_0biMD.mjs";
-import { S as retainSharedCodexAppServerClientByInstanceId } from "./auth-cache-key-f8ODJ_OX.mjs";
-import { W as protectCodexAppServerLiveThread } from "./shared-client-BCx1wbyA.mjs";
-import "./session-binding-JEHNMPsr.mjs";
+import { g as sessionBindingIdentity } from "./session-binding-record-C_THntMe.mjs";
+import { T as retainSharedCodexAppServerClientByInstanceId } from "./auth-cache-key-CVcYw8HD.mjs";
+import { I as protectCodexAppServerLiveThread } from "./shared-client-CE_uY0A1.mjs";
+import "./session-binding-BgsWcbdY.mjs";
 import { n as projectCodexMcpToolMetadata, t as projectCodexMcpServerMetadata } from "./mcp-tool-metadata-DW41snf3.mjs";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { assignMcpCatalogSafeServerNames } from "openclaw/plugin-sdk/agent-harness-runtime";
@@ -83,7 +83,7 @@ async function listCodexMcpServerStatuses(client, threadId) {
 }
 /** Loads MCP inventory from the bound Codex client while retaining its lease through all pages. */
 async function loadCodexEffectiveMcpCatalog(params, options) {
-	const binding = options.bindingStore.read(sessionBindingIdentity({
+	const binding = await options.bindingStore.readAsync(sessionBindingIdentity({
 		agentId: params.agentId,
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
@@ -102,12 +102,13 @@ async function loadCodexEffectiveMcpCatalog(params, options) {
 /** Explicit App requests retain the thread owner, never start a second MCP client. */
 async function acquireCodexMcpAppRuntime(params, options) {
 	const identity = sessionBindingIdentity(params);
-	let binding = options.bindingStore.read(identity);
+	let binding = await options.bindingStore.readAsync(identity);
+	params.assertCurrent();
 	let retained = await retainSharedCodexAppServerClientByInstanceId(binding?.clientId);
 	if (!retained && params.prepareSession) {
 		const preparation = await params.prepareSession();
 		params.assertCurrent();
-		const { prepareCodexMcpAppSession } = await import("./mcp-app-session-preparation-Dz2GOwyE.mjs");
+		const { prepareCodexMcpAppSession } = await import("./mcp-app-session-preparation-fnsnCovu.mjs");
 		await prepareCodexMcpAppSession({
 			preparation,
 			bindingStore: options.bindingStore,
@@ -115,7 +116,8 @@ async function acquireCodexMcpAppRuntime(params, options) {
 			assertCurrent: params.assertCurrent
 		});
 		params.assertCurrent();
-		binding = options.bindingStore.read(identity);
+		binding = await options.bindingStore.readAsync(identity);
+		params.assertCurrent();
 		retained = await retainSharedCodexAppServerClientByInstanceId(binding?.clientId);
 	}
 	if (!binding?.clientId || !retained) return;
@@ -128,7 +130,7 @@ async function acquireCodexMcpAppRuntime(params, options) {
 		};
 		params.assertCurrent();
 		assertBinding();
-		const { createNativeMcpRuntime } = await import("./native-mcp-app-DX3nyTtc.mjs").then((n) => n.n);
+		const { createNativeMcpRuntime } = await import("./native-mcp-app-CsWj-v_x.mjs").then((n) => n.n);
 		params.assertCurrent();
 		const runtime = createNativeMcpRuntime({
 			client: retained.client,

package/dist/.setup/{ephemeral-turn-De3qb8EQ.mjs → ephemeral-turn-1ZF17fUR.mjs}

@@ -1,7 +1,7 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { x as readCodexTurnCompletedNotification } from "./client-D93nbdB8.mjs";
-import { n as getCodexAppServerTurnRouter } from "./turn-router-DBVMToGo.mjs";
-import { o as isTerminalTurnStatus, s as readCodexNotificationItem, t as CodexUsageProjection } from "./event-projector-usage-BpKfdoTm.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { b as readCodexTurnCompletedNotification } from "./client-BS8X7HmG.mjs";
+import { n as getCodexAppServerTurnRouter } from "./turn-router-Dbw17k3K.mjs";
+import { o as isTerminalTurnStatus, s as readCodexNotificationItem, t as CodexUsageProjection } from "./event-projector-usage-CBY0Hkga.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
@@ -35,6 +35,7 @@ var CodexEphemeralTurn = class {
 						if (delta && options.textMode === "all") this.assistantItems.set(itemId, `${this.assistantItems.get(itemId) ?? ""}${delta}`);
 						if (firstDelta) await options.onAssistantMessageStart?.();
 					} else if (notification.method === "rawResponse/completed") this.usage.record(params);
+					else if (notification.method === "thread/tokenUsage/updated") this.usage.recordThread(params);
 					else if (notification.method === "turn/completed") {
 						const completed = readCodexTurnCompletedNotification(params);
 						if (completed) {

package/dist/.setup/{event-projector-assistant-message-CLMKN4x-.mjs → event-projector-assistant-message-ChOAY7rW.mjs}

@@ -1,4 +1,4 @@
-import { t as codexProviderRefusalDiagnostics } from "./event-projector-values-CLvG1Hil.mjs";
+import { t as codexProviderRefusalDiagnostics } from "./event-projector-values-yf4us9Pf.mjs";
 import { t as resolveCodexLocalRuntimeAttribution } from "./local-runtime-attribution-CZz2DJ4q.mjs";
 import { createAgentHarnessAssistantMessage } from "openclaw/plugin-sdk/agent-harness-attempt-runtime";
 //#region extensions/codex/src/app-server/event-projector-assistant-message.ts
@@ -35,16 +35,21 @@ function createAssistantCommentaryMessage(params, text, itemId, timestamp) {
 		}
 	};
 }
-function createAssistantAsyncMessage(params, text, itemId, timestamp, questions) {
+function createAssistantAsyncDelivery(params, text, itemId, timestamp, questions) {
+	if (!text?.trim() || timestamp === void 0) return;
 	return {
-		...createNonterminalAssistantMessage(params, [{
-			type: "text",
-			text
-		}], timestamp),
-		openclawAsyncDelivery: {
-			itemId,
-			...questions ? { questions } : {}
-		}
+		itemId,
+		message: {
+			...createNonterminalAssistantMessage(params, [{
+				type: "text",
+				text
+			}], timestamp),
+			openclawAsyncDelivery: {
+				itemId,
+				...questions ? { questions } : {}
+			}
+		},
+		text
 	};
 }
 function createAssistantReasoningMessage(params, text) {
@@ -66,4 +71,4 @@ function createNonterminalAssistantMessage(params, content, timestamp) {
 	});
 }
 //#endregion
-export { createAttributedCodexAssistantMessage as a, createAssistantReasoningMessage as i, createAssistantCommentaryMessage as n, createAssistantMessage as r, createAssistantAsyncMessage as t };
+export { createAttributedCodexAssistantMessage as a, createAssistantReasoningMessage as i, createAssistantCommentaryMessage as n, createAssistantMessage as r, createAssistantAsyncDelivery as t };

package/dist/.setup/{event-projector-usage-BpKfdoTm.mjs → event-projector-usage-CBY0Hkga.mjs}

@@ -1,5 +1,5 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as extractRawResponseItemText } from "./event-projector-values-CLvG1Hil.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { n as extractRawResponseItemText } from "./event-projector-values-yf4us9Pf.mjs";
 import { asSafeIntegerInRange, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/attempt-notifications.ts

package/dist/.setup/{event-projector-values-CLvG1Hil.mjs → event-projector-values-yf4us9Pf.mjs}

@@ -1,4 +1,4 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
 import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { Buffer } from "node:buffer";
 //#region extensions/codex/src/app-server/event-projector-values.ts

package/dist/.setup/experimental-features-uGnVDtp-.mjs

@@ -0,0 +1,19 @@
+//#region extensions/codex/src/app-server/experimental-features.ts
+async function readCodexExperimentalFeature(request, featureName, threadId) {
+	let cursor;
+	const visited = /* @__PURE__ */ new Set();
+	do {
+		const response = await request({
+			...threadId ? { threadId } : {},
+			...cursor ? { cursor } : {},
+			limit: 100
+		});
+		const feature = response.data.find((entry) => entry.name === featureName);
+		if (feature) return feature.enabled;
+		cursor = response.nextCursor ?? void 0;
+		if (cursor && visited.has(cursor)) return;
+		if (cursor) visited.add(cursor);
+	} while (cursor);
+}
+//#endregion
+export { readCodexExperimentalFeature as t };

package/dist/.setup/inference-context-mv_dBpAL.mjs

@@ -0,0 +1,209 @@
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { n as defineCodexBuildState } from "./build-state-VcujMRqP.mjs";
+import { n as readCodexInferenceMetadata } from "./inference-metadata-CYFWLHVk.mjs";
+import { randomUUID } from "node:crypto";
+//#region extensions/codex/src/app-server/inference-context.ts
+const MAX_CONTEXT_BYTES = 262144;
+const MAX_ACTIVE_ROOTS = 64;
+const MAX_PREPARED_PREFIXES = 256;
+const MAX_RETAINED_REQUEST_BYTES = 33554432;
+const retained = defineCodexBuildState("openclaw.codexPreparedRequests", () => ({
+	requests: /* @__PURE__ */ new Map(),
+	bytes: 0
+}))();
+function forgetRequest(prefix) {
+	if (!prefix) return;
+	const request = retained.requests.get(prefix);
+	if (request) {
+		retained.bytes -= request.bytes;
+		retained.requests.delete(prefix);
+	}
+}
+function retainRequest(prefix, body) {
+	const previous = retained.requests.get(prefix)?.body;
+	forgetRequest(prefix);
+	const continuation = body.previous_response_id != null;
+	const snapshot = {};
+	for (const key of [
+		"instructions",
+		"tools",
+		"input",
+		"prompt_cache_key"
+	]) {
+		if (continuation && key === "input") continue;
+		const value = body[key] ?? (continuation ? previous?.[key] : void 0);
+		if (value !== void 0) snapshot[key] = value;
+	}
+	if (continuation) {
+		const inputTools = Array.isArray(previous?.input) ? previous.input.find((item) => isJsonObject(item) && item.type === "additional_tools") : previous?.inputTools;
+		if (inputTools !== void 0) snapshot.inputTools = inputTools;
+	}
+	const bytes = Buffer.byteLength(JSON.stringify(snapshot));
+	if (bytes > MAX_RETAINED_REQUEST_BYTES) return;
+	while (retained.bytes + bytes > MAX_RETAINED_REQUEST_BYTES) forgetRequest(retained.requests.keys().next().value);
+	retained.requests.set(prefix, {
+		body: snapshot,
+		bytes
+	});
+	retained.bytes += bytes;
+}
+/** One physical inference transport owns these confidential, nonpersistent snapshots. */
+function createCodexInferenceContext(assertClientCurrent) {
+	const roots = /* @__PURE__ */ new Map();
+	const prefixes = /* @__PURE__ */ new Map();
+	let closed = false;
+	const assertOpen = () => {
+		if (closed) throw new Error("Codex parent-local inference transport is closed");
+		assertClientCurrent();
+	};
+	return {
+		register(params) {
+			assertOpen();
+			params.signal.throwIfAborted();
+			params.assertCurrent();
+			if (Buffer.byteLength(params.text) > MAX_CONTEXT_BYTES) throw new Error("Codex parent-local context exceeds the 256 KiB inference limit");
+			if (!roots.has(params.threadId) && roots.size >= MAX_ACTIVE_ROOTS) throw new Error("Codex parent-local inference root limit reached");
+			if (params.retainPrefix !== false && !prefixes.has(params.threadId) && prefixes.size >= MAX_PREPARED_PREFIXES) throw new Error("Codex prepared inference prefix limit reached; reconnect before retrying");
+			roots.get(params.threadId)?.release();
+			const controller = new AbortController();
+			const registration = {
+				generation: randomUUID(),
+				text: params.text,
+				forkPrefix: params.forkPrefix,
+				denyToolCalls: params.denyToolCalls === true,
+				controller,
+				assertCurrent: () => {
+					assertOpen();
+					controller.signal.throwIfAborted();
+					params.signal.throwIfAborted();
+					params.assertCurrent();
+					if (roots.get(params.threadId) !== registration) throw new Error("Codex parent-local inference generation was replaced");
+				},
+				release: () => {
+					if (roots.get(params.threadId) === registration) roots.delete(params.threadId);
+					registration.text = "";
+					controller.abort();
+					params.signal.removeEventListener("abort", registration.release);
+				}
+			};
+			roots.set(params.threadId, registration);
+			if (params.retainPrefix !== false) {
+				const prefix = prefixes.get(params.threadId);
+				if (prefix) prefix.text = params.text;
+				else prefixes.set(params.threadId, { text: params.text });
+			}
+			params.signal.addEventListener("abort", registration.release, { once: true });
+			return {
+				generation: registration.generation,
+				release: registration.release
+			};
+		},
+		/** A retained prefix is data; only the new root's caller grants model authority. */
+		fork(params) {
+			assertOpen();
+			const prefix = prefixes.get(params.sourceThreadId);
+			if (!prefix) throw new Error("Cache-parity fork has no prepared parent inference context.");
+			const request = retained.requests.get(prefix);
+			if (request) {
+				retained.requests.delete(prefix);
+				retained.requests.set(prefix, request);
+			}
+			return this.register({
+				threadId: params.threadId,
+				text: prefix.text,
+				forkPrefix: request?.body,
+				retainPrefix: false,
+				denyToolCalls: true,
+				signal: params.signal,
+				assertCurrent: params.assertCurrent
+			});
+		},
+		forget(threadId) {
+			forgetRequest(prefixes.get(threadId));
+			prefixes.delete(threadId);
+			roots.get(threadId)?.release();
+		},
+		/** Caller must authenticate its private transport before parsing any model request. */
+		prepare(body, preparedMetadata, requireAdmission = false) {
+			assertOpen();
+			const metadata = preparedMetadata ?? readCodexInferenceMetadata(body);
+			const child = Boolean(metadata.parentThreadId || metadata.subagentKind || metadata.subagent);
+			const kind = metadata.requestKind;
+			if (!requireAdmission && (child || kind === "compaction" || kind === "memory")) return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (child || kind !== "turn" && kind !== "prewarm" && !(requireAdmission && kind === "compaction")) throw new Error("Codex inference request has an unsupported native purpose");
+			const registration = metadata.threadId ? roots.get(metadata.threadId) : void 0;
+			const generation = metadata.generation;
+			if (!requireAdmission && kind === "prewarm" && body.generate === false && generation == null) return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (!registration || generation !== registration.generation) throw new Error("Codex inference has no current admitted parent generation");
+			registration.assertCurrent();
+			let preparedBody = body;
+			if (kind !== "compaction") {
+				const instructions = body.instructions;
+				if (instructions !== void 0 && typeof instructions !== "string") throw new Error("Codex inference request has invalid top-level instructions");
+				if (registration.text) preparedBody = {
+					...body,
+					instructions: instructions === void 0 ? registration.text : instructions + "\n\n" + registration.text
+				};
+			}
+			if (kind === "turn") {
+				const prefix = registration.forkPrefix;
+				const inputTools = Array.isArray(prefix?.input) ? prefix.input.find((item) => isJsonObject(item) && item.type === "additional_tools") : prefix?.inputTools;
+				const input = prefix && Array.isArray(body.input) ? body.input.map((item) => isJsonObject(inputTools) && isJsonObject(item) && item.type === "additional_tools" ? inputTools : item) : void 0;
+				if (prefix && Array.isArray(prefix.input) && input && prefix.input.length <= input.length && prefix.input.every((item, index) => JSON.stringify(item) === JSON.stringify(input[index]))) {
+					preparedBody = { ...body };
+					delete preparedBody.previous_response_id;
+					for (const key of [
+						"instructions",
+						"tools",
+						"input"
+					]) delete preparedBody[key];
+					for (const key of [
+						"instructions",
+						"tools",
+						"input",
+						"prompt_cache_key"
+					]) {
+						const value = prefix[key];
+						if (value !== void 0) preparedBody[key] = value;
+					}
+					preparedBody.input = [...prefix.input, ...input.slice(prefix.input.length)];
+				} else if (prefix) {
+					preparedBody = {
+						...preparedBody,
+						...prefix.tools !== void 0 ? { tools: prefix.tools } : {},
+						...input ? { input } : {}
+					};
+					delete preparedBody.instructions;
+					if (prefix.instructions !== void 0) preparedBody.instructions = prefix.instructions;
+				}
+				if (registration.denyToolCalls) preparedBody = {
+					...preparedBody,
+					tool_choice: "none"
+				};
+				const retainedPrefix = metadata.threadId ? prefixes.get(metadata.threadId) : void 0;
+				if (retainedPrefix) retainRequest(retainedPrefix, preparedBody);
+			}
+			return {
+				body: preparedBody,
+				assertCurrent: registration.assertCurrent,
+				signal: registration.controller.signal
+			};
+		},
+		close() {
+			closed = true;
+			for (const prefix of prefixes.values()) forgetRequest(prefix);
+			prefixes.clear();
+			for (const registration of roots.values()) registration.release();
+		}
+	};
+}
+//#endregion
+export { createCodexInferenceContext as t };

package/dist/.setup/{inference-dispatch-CO6tTs4q.mjs → inference-dispatch-C2zVSnrr.mjs}

@@ -1,5 +1,5 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as readCodexInferenceMetadata } from "./inference-metadata-DCvcG_N_.mjs";
+import { r as isJsonObject } from "./protocol-CaPAVwe9.mjs";
+import { n as readCodexInferenceMetadata } from "./inference-metadata-CYFWLHVk.mjs";
 import { promisify } from "node:util";
 import { isUtf8 } from "node:buffer";
 import { zstdCompress, zstdDecompress } from "node:zlib";

package/dist/.setup/{inference-metadata-DCvcG_N_.mjs → inference-metadata-CYFWLHVk.mjs}

@@ -22,8 +22,10 @@ function readCodexInferenceMetadata(body, headers, transport = "http", path) {
 	const nativeThreadId = readId("thread", ...nativeField("thread_id"));
 	if (!nativeThreadId && (requestKind === "turn" || requestKind === "prewarm" && !(body.generate === false && generation === void 0))) throw new Error("Codex inference request has no native thread metadata");
 	const readTurnId = (field, key) => readId(field, flat?.[key], ...nativeField(key));
+	const sessionId = readId("session", flat?.session_id, ...nativeField("session_id"));
+	const routingSessionId = readId("routing session", httpHeaders?.["session-id"]);
 	return Object.freeze({
-		sessionId: readId("session", flat?.session_id, ...nativeField("session_id"), httpHeaders?.["session-id"]),
+		sessionId: sessionId ?? routingSessionId,
 		threadId: readId("thread", flat?.thread_id, nativeThreadId, httpHeaders?.["thread-id"]),
 		turnId: readTurnId("turn", "turn_id"),
 		parentThreadId: readId("parent thread", flat?.["x-codex-parent-thread-id"], ...nativeField("parent_thread_id"), httpHeaders?.["x-codex-parent-thread-id"]),

package/dist/.setup/{inference-proxy-BDWV0djM.mjs → inference-proxy-yd3hr2dr.mjs}

@@ -1,6 +1,6 @@
 import { t as codexWebSocketDataToBuffer } from "./websocket-data-XlRvt8Ys.mjs";
-import { CODEX_INFERENCE_TRANSPORT_FAILURE, authorizationFailure, createCodexInferenceDispatch, isTerminalResponse, n as createUploadAdmission, readProxyBody, t as MAX_BODY_BYTES } from "./inference-dispatch-CO6tTs4q.mjs";
-import { t as createCodexInferenceContext } from "./inference-context-DNlGwzwy.mjs";
+import { CODEX_INFERENCE_TRANSPORT_FAILURE, authorizationFailure, createCodexInferenceDispatch, isTerminalResponse, n as createUploadAdmission, readProxyBody, t as MAX_BODY_BYTES } from "./inference-dispatch-C2zVSnrr.mjs";
+import { t as createCodexInferenceContext } from "./inference-context-mv_dBpAL.mjs";
 import { createDeferred, createPermitPool } from "openclaw/plugin-sdk/concurrency-runtime";
 import { Writable } from "node:stream";
 import { WebSocket, WebSocketServer, rejectWebSocketUpgrade } from "openclaw/plugin-sdk/websocket-runtime";
@@ -61,7 +61,7 @@ const MAX_RESIDENTS = 80;
 const REQUEST_TIMEOUT_MS = 3e4;
 const HANDSHAKE_TIMEOUT_MS = 1e4;
 const IDLE_WEBSOCKET_MS = 6e4;
-/** Private, fixed-destination relay. No upstream credentials or model content are retained. */
+/** Private, fixed-destination relay. Upstream credentials are never retained. */
 async function createCodexInferenceProxy(params) {
 	const upstream = new URL(params.upstream);
 	if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.hash) throw new Error("Codex inference requires a credential-free HTTPS upstream URL");
@@ -213,7 +213,6 @@ async function createCodexInferenceProxy(params) {
 						preparedUpload.assertCurrent();
 						auth?.assertCurrent();
 					};
-					assertAuthorized();
 					if (auth) {
 						for (const key of [
 							"authorization",
@@ -289,6 +288,7 @@ async function createCodexInferenceProxy(params) {
 			let resident = null;
 			const controller = new AbortController();
 			const deadlineAtMs = Date.now() + HANDSHAKE_TIMEOUT_MS;
+			const deadlineAtMonotonicMs = performance.now() + HANDSHAKE_TIMEOUT_MS;
 			let releasePermit = null;
 			let framePending = false;
 			let idleTimer;
@@ -322,7 +322,7 @@ async function createCodexInferenceProxy(params) {
 				});
 			};
 			const close = () => finish();
-			const failHandshake = () => finish(Date.now() >= deadlineAtMs ? 504 : 502);
+			const failHandshake = () => finish(performance.now() >= deadlineAtMonotonicMs ? 504 : 502);
 			try {
 				const { target, path } = resolveTarget(req);
 				if (params.oauth) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
@@ -352,12 +352,12 @@ async function createCodexInferenceProxy(params) {
 					rejectBusyUpgrade(socket);
 					return;
 				}
-				handshakeTimer = setTimeout(() => finish(504), Math.max(1, deadlineAtMs - Date.now()));
+				handshakeTimer = setTimeout(() => finish(504), Math.max(1, deadlineAtMonotonicMs - performance.now()));
 				handshakeTimer.unref();
 				const assertHandshakeCurrent = () => {
 					assertCurrent();
 					signal.throwIfAborted();
-					if (Date.now() >= deadlineAtMs) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
+					if (performance.now() >= deadlineAtMonotonicMs) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 				};
 				proxyAgent = createNodeProxyAgent({
 					mode: "env",
@@ -374,7 +374,7 @@ async function createCodexInferenceProxy(params) {
 					followRedirects: false,
 					perMessageDeflate: false,
 					maxPayload: MAX_BODY_BYTES,
-					handshakeTimeout: Math.max(1, deadlineAtMs - Date.now()),
+					handshakeTimeout: Math.max(1, deadlineAtMonotonicMs - performance.now()),
 					finishRequest(request) {
 						let socketClosed = Promise.resolve();
 						request.once("socket", (upstreamSocket) => {

package/dist/.setup/installed-probe-lVC1X5ve.mjs

@@ -0,0 +1,185 @@
+import { n as INSTALLED_CODEX_PROBE_TIMEOUT_MS } from "./managed-binary-DbKvGXKl.mjs";
+import { n as resolveCodexAppServerSpawnEnv, r as resolveCodexAppServerSpawnInvocation } from "./transport-stdio-Bq160Dhv.mjs";
+import { n as buildCodexAppServerInitializeParams, o as readCodexVersionFromUserAgent } from "./client-initialize-CjgZcX61.mjs";
+import { runUtf8CommandWithTimeout, signalProcessTree } from "openclaw/plugin-sdk/process-runtime";
+import path from "node:path";
+import { access, mkdtemp, rm } from "node:fs/promises";
+import { once } from "node:events";
+import { spawn } from "node:child_process";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+//#region extensions/codex/src/app-server/installed-probe.ts
+/**
+* Bounded initialize handshake that qualifies a user-installed Codex before
+* selection. The candidate runs privately against a throwaway CODEX_HOME: it is
+* never registered as a Gateway app-server and never opens OpenClaw state.
+*/
+const HANDSHAKE_MAX_OUTPUT_CHARS = 1048576;
+const HANDSHAKE_EXIT_TIMEOUT_MS = 2e3;
+const INITIALIZE_REQUEST_ID = 1;
+async function assertProbeCanOverrideStorage(timeoutMs) {
+	const metadataOptions = {
+		baseEnv: {
+			...process.env,
+			LC_ALL: "C"
+		},
+		input: "",
+		timeoutMs: Math.min(1e3, timeoutMs),
+		maxOutputBytes: 4096,
+		killProcessTree: true,
+		killSignal: "SIGKILL",
+		killGraceMs: 0
+	};
+	let managedPaths = ["/etc/codex/managed_config.toml", "/etc/codex/requirements.toml"];
+	if (process.platform === "win32") {
+		const result = await runUtf8CommandWithTimeout([
+			"powershell.exe",
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			"[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false); [Environment]::GetFolderPath('CommonApplicationData')"
+		], metadataOptions);
+		const programData = result.stdout.trim();
+		if (result.termination !== "exit" || result.code !== 0 || result.outputLimitExceeded || !path.win32.isAbsolute(programData)) throw new Error("cannot locate managed Codex requirements for an isolated selection probe");
+		managedPaths = [path.win32.join(programData, "OpenAI", "Codex", "requirements.toml")];
+	}
+	for (const managedPath of managedPaths) if (await access(managedPath).then(() => true, (error) => {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	})) throw new Error("managed Codex configuration prevents an isolated selection probe");
+	if (process.platform === "darwin") for (const key of ["config_toml_base64", "requirements_toml_base64"]) {
+		const result = await runUtf8CommandWithTimeout([
+			"/usr/bin/defaults",
+			"read-type",
+			"com.openai.codex",
+			key
+		], metadataOptions);
+		const missing = result.stderr.includes("does not exist") || result.stderr.includes(`Could not find key '${key}'`) || result.stderr.includes("Domain 'com.openai.codex' not found.");
+		if (result.termination !== "exit" || result.code !== 1 || result.outputLimitExceeded || !missing) throw new Error("managed Codex preferences cannot be excluded from the selection probe");
+	}
+}
+/** Sends one initialize request and returns the Codex version from its reply. */
+async function probeCodexAppServerHandshake(command, timeoutMs = INSTALLED_CODEX_PROBE_TIMEOUT_MS) {
+	const deadline = performance.now() + timeoutMs;
+	await assertProbeCanOverrideStorage(timeoutMs);
+	const codexHome = await mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "openclaw-codex-probe-"));
+	try {
+		const remainingMs = deadline - performance.now();
+		if (remainingMs <= 0) throw new Error("selection probe timed out before initialize");
+		return await exchangeInitialize(command, codexHome, remainingMs);
+	} finally {
+		await rm(codexHome, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function exchangeInitialize(command, codexHome, timeoutMs) {
+	const options = {
+		transport: "stdio",
+		command,
+		commandSource: "resolved-managed",
+		args: [
+			"-c",
+			`sqlite_home=${JSON.stringify(codexHome)}`,
+			"app-server",
+			"--listen",
+			"stdio://"
+		],
+		headers: {},
+		env: {
+			CODEX_HOME: codexHome,
+			CODEX_SQLITE_HOME: codexHome
+		}
+	};
+	const env = resolveCodexAppServerSpawnEnv(options);
+	const invocation = resolveCodexAppServerSpawnInvocation(options, env);
+	const detached = process.platform !== "win32";
+	const child = spawn(invocation.command, invocation.argv, {
+		env,
+		detached,
+		shell: invocation.shell,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: invocation.windowsHide
+	});
+	const closed = once(child, "close").then(() => void 0, () => void 0);
+	try {
+		return await readInitializeReply(child, timeoutMs);
+	} finally {
+		if (child.pid !== void 0 && child.exitCode === null && child.signalCode === null) signalProcessTree(child.pid, "SIGKILL", { detached });
+		await Promise.race([closed, setTimeout$1(HANDSHAKE_EXIT_TIMEOUT_MS, void 0, { ref: false })]);
+		child.stdin.destroy();
+		child.stdout.destroy();
+		child.stderr.destroy();
+	}
+}
+async function readInitializeReply(child, timeoutMs) {
+	const { promise, resolve, reject } = createDeferred();
+	let pending = "";
+	let received = 0;
+	let stderrTail = "";
+	const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`timed out after ${timeoutMs} ms`)), timeoutMs);
+	child.once("error", reject);
+	child.once("exit", (code, signal) => {
+		const stderr = stderrTail.trim();
+		reject(/* @__PURE__ */ new Error(`exited (${signal ?? code}) before answering initialize${stderr ? `: ${stderr}` : ""}`));
+	});
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk) => {
+		stderrTail = `${stderrTail}${chunk}`.slice(-1024);
+	});
+	child.stdout.setEncoding("utf8");
+	child.stdout.on("data", (chunk) => {
+		received += chunk.length;
+		if (received > HANDSHAKE_MAX_OUTPUT_CHARS) {
+			reject(/* @__PURE__ */ new Error("output exceeded its capture limit before initialize"));
+			return;
+		}
+		pending += chunk;
+		for (let newline = pending.indexOf("\n"); newline >= 0; newline = pending.indexOf("\n")) {
+			const reply = parseInitializeReply(pending.slice(0, newline));
+			pending = pending.slice(newline + 1);
+			if (reply && "error" in reply) {
+				reject(/* @__PURE__ */ new Error(`initialize failed: ${JSON.stringify(reply.error).slice(0, 512)}`));
+				return;
+			}
+			if (reply) {
+				resolve(readCodexVersionFromUserAgent(reply.userAgent));
+				return;
+			}
+		}
+	});
+	child.stdin.on("error", () => void 0);
+	child.stdin.write(`${JSON.stringify({
+		id: INITIALIZE_REQUEST_ID,
+		method: "initialize",
+		params: buildCodexAppServerInitializeParams()
+	})}\n`);
+	try {
+		return await promise;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Codex frames JSON-RPC as one JSON object per line, without a `jsonrpc` field. */
+function parseInitializeReply(line) {
+	let message;
+	try {
+		message = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (typeof message !== "object" || message === null || !("id" in message)) return;
+	if (message.id !== INITIALIZE_REQUEST_ID) return;
+	if ("error" in message) return { error: message.error };
+	const result = "result" in message ? message.result : void 0;
+	const userAgent = typeof result === "object" && result !== null && "userAgent" in result ? result.userAgent : void 0;
+	return { userAgent: typeof userAgent === "string" ? userAgent : void 0 };
+}
+//#endregion
+export { probeCodexAppServerHandshake };

package/dist/.setup/{isolated-completion-BPJdvk5F.mjs → isolated-completion-P-r8NRE4.mjs}

@@ -1,11 +1,11 @@
 import { d as readCodexPluginConfig } from "./config-parsing-DsWSCPHO.mjs";
-import { i as resolveCodexAppServerHomeScope } from "./config-options-DDzeNQ8m.mjs";
-import "./config-C1YVVLEA.mjs";
-import { nt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-BCx1wbyA.mjs";
-import { f as assertCodexPassiveTurnItems } from "./client-D93nbdB8.mjs";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-DfIJtRlv.mjs";
-import { t as resolveCodexBoundedTurnIsolation } from "./bounded-turn-isolation-BfDAo-qZ.mjs";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-CLMKN4x-.mjs";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-DMFZkd3X.mjs";
+import "./config-BfrAlTMT.mjs";
+import { Q as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CE_uY0A1.mjs";
+import { d as assertCodexPassiveTurnItems } from "./client-BS8X7HmG.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-mN_ekXYW.mjs";
+import { t as resolveCodexBoundedTurnIsolation } from "./bounded-turn-isolation-D8CDrAVX.mjs";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-ChOAY7rW.mjs";
 //#region extensions/codex/src/app-server/isolated-completion.ts
 /** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */
 async function runCodexIsolatedCompletion(params, options) {