@openclaw/codex 2026.9.6 → 2026.9.7

package/dist/.setup/{inference-proxy-b-aJMSxm.mjs → inference-proxy-DhcXOgUE.mjs}

@@ -1,83 +1,13 @@
-import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
-import { n as createCodexInferenceContext } from "./inference-context-D96l9-ew.mjs";
-import { promisify } from "node:util";
-import { zstdCompress, zstdDecompress } from "node:zlib";
-import { Writable, getDefaultHighWaterMark } from "node:stream";
+import { CODEX_INFERENCE_TRANSPORT_FAILURE, CodexInferenceAuthorizationError, authorizationFailure, createCodexInferenceDispatch, isTerminalResponse, n as createUploadAdmission, readProxyBody, readProxyWebSocketBody, t as MAX_BODY_BYTES } from "./inference-dispatch-CMZtjQyz.mjs";
+import { t as createCodexInferenceContext } from "./inference-context-D-9gWlTR.mjs";
+import { createPermitPool } from "openclaw/plugin-sdk/concurrency-runtime";
+import { Writable } from "node:stream";
 import { WebSocket, WebSocketServer, rejectWebSocketUpgrade } from "openclaw/plugin-sdk/websocket-runtime";
 import { createServer } from "node:http";
-import { createPermitPool } from "openclaw/plugin-sdk/concurrency-runtime";
 import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
 import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
 import { fetchWithSsrFGuard, isBlockedHostnameOrIp, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
-//#region extensions/codex/src/app-server/inference-upload.ts
-const MAX_BODY_BYTES = 33554432;
-function createUploadAdmission() {
-	const permits = createPermitPool(16);
-	let outstanding = 0;
-	let queuedBytes = 0;
-	return async (signal, deadlineAtMs, bytes = 0) => {
-		const queued = outstanding >= 16;
-		if (outstanding >= 32 || queued && queuedBytes + bytes > 33554432) return null;
-		outstanding++;
-		if (queued) queuedBytes += bytes;
-		const releasePermit = await permits.acquire({
-			signal,
-			deadlineAtMs
-		});
-		if (queued) queuedBytes -= bytes;
-		let released = false;
-		const release = () => {
-			if (released) return;
-			released = true;
-			outstanding--;
-			releasePermit?.();
-		};
-		if (!releasePermit || signal.aborted) {
-			release();
-			return null;
-		}
-		return release;
-	};
-}
-function createUploadBody(bytes, signal, release) {
-	const length = bytes.length;
-	const chunkSize = getDefaultHighWaterMark(false);
-	let remaining = bytes;
-	let offset = 0;
-	const settle = () => {
-		remaining = void 0;
-		signal.removeEventListener("abort", settle);
-		release();
-	};
-	signal.addEventListener("abort", settle, { once: true });
-	if (signal.aborted) settle();
-	return {
-		body: new ReadableStream({
-			pull(controller) {
-				signal.throwIfAborted();
-				if (!remaining || offset === length) {
-					settle();
-					controller.close();
-					return;
-				}
-				const end = Math.min(offset + chunkSize, length);
-				controller.enqueue(Uint8Array.from(remaining.subarray(offset, end)));
-				offset = end;
-			},
-			cancel: settle
-		}, { highWaterMark: 0 }),
-		length,
-		settle
-	};
-}
-//#endregion
-//#region extensions/codex/src/app-server/inference-proxy.ts
-const MAX_ERROR_BODY_BYTES = 1048576;
-const MAX_WEBSOCKETS = 64;
-const MAX_RESIDENTS = 80;
-const REQUEST_TIMEOUT_MS = 3e4;
-const HANDSHAKE_TIMEOUT_MS = 1e4;
-const IDLE_WEBSOCKET_MS = 6e4;
+//#region extensions/codex/src/app-server/inference-proxy-http.ts
 const OVERLOADED = "Codex inference relay is busy; retry on a fresh connection.";
 const OVERLOAD_HEADERS = {
 	"content-type": "application/json",
@@ -93,8 +23,6 @@ const OVERLOAD_BODY = JSON.stringify({
 	},
 	headers: { "retry-after": "1" }
 });
-const compress = promisify(zstdCompress);
-const decompress = promisify(zstdDecompress);
 const HOP_HEADERS = /* @__PURE__ */ new Set([
 	"connection",
 	"keep-alive",
@@ -107,21 +35,47 @@ const HOP_HEADERS = /* @__PURE__ */ new Set([
 	"host",
 	"content-length"
 ]);
-const FAILURE = "Codex parent-local inference transport failed; retry on a fresh connection.";
+function rejectBusyUpgrade(socket) {
+	rejectWebSocketUpgrade(socket, {
+		status: 503,
+		headers: { "Retry-After": "1" },
+		body: {
+			contentType: "application/json",
+			text: OVERLOAD_BODY
+		}
+	});
+}
+function relayHeaders(input) {
+	const excluded = new Set(HOP_HEADERS);
+	for (const token of (input.connection ?? "").split(",")) excluded.add(token.trim().toLowerCase());
+	const output = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0 && !excluded.has(key.toLowerCase())) output[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	return output;
+}
+//#endregion
+//#region extensions/codex/src/app-server/inference-proxy.ts
+const MAX_ERROR_BODY_BYTES = 1048576;
+const MAX_WEBSOCKETS = 64;
+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. */
 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");
+	if (params.oauth && upstream.href.replace(/\/$/, "") !== "https://api.openai.com/v1") throw new Error("ChatGPT subscription sharing requires the public Responses endpoint");
 	const lifetime = new AbortController();
 	const assertCurrent = () => {
 		lifetime.signal.throwIfAborted();
 		params.assertCurrent();
 	};
 	const context = createCodexInferenceContext(assertCurrent);
+	const upstreamPath = upstream.pathname.replace(/\/+$/, "");
 	const pathPrefix = "/" + generateSecureToken({
 		bytes: 32,
 		redact: true
-	}) + upstream.pathname.replace(/\/$/, "");
+	}) + (params.preserveAzureUrlFeatures ? "/azure-api." : "") + upstreamPath + (params.preserveCodexBackendRoutes && !upstreamPath.endsWith("/backend-api/codex") ? "/backend-api/codex" : params.preserveCodexBackendRoutes === false && upstreamPath.endsWith("/backend-api/codex") ? "/native-responses" : "");
 	const acquireUpload = createUploadAdmission();
 	const connections = /* @__PURE__ */ new Set();
 	const idleConnections = /* @__PURE__ */ new Set();
@@ -193,52 +147,27 @@ async function createCodexInferenceProxy(params) {
 	});
 	const resolveTarget = (request) => {
 		assertCurrent();
-		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(FAILURE);
+		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 		const suffix = request.url.slice(pathPrefix.length);
-		if (suffix.startsWith("//") || suffix.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|\?|$)/i.test(suffix)) throw new Error(FAILURE);
+		const rawPath = suffix.split("?", 1)[0] ?? suffix;
+		if (rawPath.startsWith("//") || rawPath.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|$)/i.test(rawPath)) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 		const target = new URL(upstream);
 		const incoming = new URL(suffix, "http://localhost");
-		target.pathname = upstream.pathname.replace(/\/$/, "") + incoming.pathname;
+		if (params.oauth && (incoming.pathname !== "/responses" || incoming.search)) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
+		target.pathname = upstreamPath + incoming.pathname;
 		for (const [key, value] of incoming.searchParams) target.searchParams.append(key, value);
 		return {
 			target,
+			path: incoming.pathname,
 			sampling: incoming.pathname === "/responses"
 		};
 	};
-	const prepare = (bytes, sampling) => {
-		assertCurrent();
-		if (!sampling) return {
-			bytes,
-			assertCurrent,
-			signal: void 0
-		};
-		const value = JSON.parse(bytes.toString("utf8"));
-		if (!isJsonObject(value)) throw new Error(FAILURE);
-		const prepared = context.prepare(value);
-		const rewritten = Buffer.from(JSON.stringify(prepared.body));
-		if (rewritten.length > 33554432) throw new Error(FAILURE);
-		return {
-			bytes: rewritten,
-			assertCurrent: prepared.assertCurrent,
-			signal: prepared.signal
-		};
-	};
-	const prepareHttp = async (req, sampling, signal, release) => {
-		const wire = await readProxyBody(req, MAX_BODY_BYTES);
-		const encoding = req.headers["content-encoding"];
-		if (encoding && encoding !== "identity" && encoding !== "zstd") throw new Error(FAILURE);
-		const decoded = encoding === "zstd" ? await decompress(wire, { maxOutputLength: MAX_BODY_BYTES }) : wire;
-		signal.throwIfAborted();
-		const prepared = prepare(decoded, sampling);
-		const body = encoding === "zstd" ? await compress(prepared.bytes) : prepared.bytes;
-		prepared.assertCurrent();
-		const requestSignal = AbortSignal.any([signal, ...prepared.signal ? [prepared.signal] : []]);
-		return {
-			...createUploadBody(body, requestSignal, release),
-			assertCurrent: prepared.assertCurrent,
-			signal: requestSignal
-		};
-	};
+	const { prepare, prepareHttp } = createCodexInferenceDispatch({
+		context,
+		assertCurrent,
+		bindModelExecution: params.bindModelExecution,
+		requireAdmission: Boolean(params.oauth)
+	});
 	const server = createServer((req, res) => {
 		const socket = req.socket;
 		res.setHeader("Connection", "close");
@@ -254,8 +183,8 @@ async function createCodexInferenceProxy(params) {
 		res.once("close", abort);
 		(async () => {
 			try {
-				const { target, sampling } = resolveTarget(req);
-				if (req.method !== "POST") throw new Error(FAILURE);
+				const { target, sampling, path } = resolveTarget(req);
+				if (req.method !== "POST") throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 				resident = reserveResident(socket, signal, deadlineAtMs);
 				const admitted = resident && await resident.ready;
 				signal.throwIfAborted();
@@ -271,43 +200,78 @@ async function createCodexInferenceProxy(params) {
 					res.writeHead(503, OVERLOAD_HEADERS).end(OVERLOAD_BODY);
 					return;
 				}
-				upload = await prepareHttp(req, sampling, signal, releasePermit);
-				const init = {
-					method: "POST",
-					headers: {
+				upload = await prepareHttp(req, sampling, path, signal, releasePermit, Boolean(params.oauth));
+				const preparedUpload = upload;
+				let body = upload.body;
+				for (let attempt = 0; attempt < (params.oauth ? 2 : 1); attempt++) {
+					const headers = {
 						...relayHeaders(req.headers),
 						"content-length": String(upload.length)
-					},
-					body: upload.body,
-					signal: upload.signal,
-					duplex: "half"
-				};
-				guarded = await fetchWithSsrFGuard({
-					url: target.toString(),
-					init,
-					signal: upload.signal,
-					beforeRequest: upload.assertCurrent,
-					requireHttps: true,
-					maxRedirects: 0,
-					capture: false,
-					mode: "trusted_env_proxy",
-					auditContext: "codex-parent-local-inference"
-				});
+					};
+					const auth = await params.oauth?.resolve(attempt === 1);
+					const assertAuthorized = () => {
+						preparedUpload.assertCurrent();
+						auth?.assertCurrent();
+					};
+					assertAuthorized();
+					if (auth) {
+						for (const key of [
+							"authorization",
+							"chatgpt-account-id",
+							"openai-organization",
+							"openai-project"
+						]) delete headers[key];
+						headers.authorization = `Bearer ${auth.token}`;
+						headers["x-openai-chatpass-test"] = "codex-direct";
+					}
+					const init = {
+						method: "POST",
+						headers,
+						body,
+						signal: upload.signal,
+						duplex: "half"
+					};
+					guarded = await fetchWithSsrFGuard({
+						url: target.toString(),
+						init,
+						signal: upload.signal,
+						beforeRequest: assertAuthorized,
+						requireHttps: true,
+						maxRedirects: 0,
+						capture: false,
+						mode: "trusted_env_proxy",
+						auditContext: "codex-parent-local-inference"
+					});
+					assertAuthorized();
+					if (!upload.retry || guarded.response.status !== 401 || attempt === 1) {
+						upload.commit?.();
+						break;
+					}
+					await guarded.response.body?.cancel();
+					await guarded.release();
+					guarded = void 0;
+					body = upload.retry();
+				}
+				if (!guarded) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 				upload.assertCurrent();
 				const headers = Object.fromEntries(guarded.response.headers);
 				delete headers["content-encoding"];
 				res.writeHead(guarded.response.status, relayHeaders(headers));
 				if (!guarded.response.body) res.end();
 				else await guarded.response.body.pipeTo(Writable.toWeb(res), { signal: upload.signal });
-			} catch {
-				if (!res.headersSent && !res.destroyed) res.writeHead(502, { "content-type": "text/plain" }).end(FAILURE);
-				else res.destroy();
+			} catch (error) {
+				if (!res.headersSent && !res.destroyed) {
+					const denied = authorizationFailure(error);
+					if (denied) res.writeHead(403, { "content-type": "application/json" }).end(denied);
+					else res.writeHead(502, { "content-type": "text/plain" }).end(CODEX_INFERENCE_TRANSPORT_FAILURE);
+				} else res.destroy();
 			} finally {
 				upload?.settle();
 				releasePermit?.();
 				req.off("aborted", abort);
 				res.off("close", abort);
 				await guarded?.release().catch(() => void 0);
+				upload?.releaseModelExecution();
 				resident?.finish();
 			}
 		})();
@@ -333,7 +297,7 @@ async function createCodexInferenceProxy(params) {
 			let idleTimer;
 			let handshakeTimer;
 			let closing = false;
-			const close = () => {
+			const finish = (status) => {
 				if (closing) return;
 				closing = true;
 				if (idleConnections.has(close)) resident?.retireIdle();
@@ -346,16 +310,26 @@ async function createCodexInferenceProxy(params) {
 				remote?.terminate();
 				local?.terminate();
 				proxyAgent?.destroy();
-				socket.destroy();
+				if (status && !local && !socket.destroyed && !socket.writableEnded) rejectWebSocketUpgrade(socket, {
+					status,
+					body: {
+						contentType: "text/plain",
+						text: CODEX_INFERENCE_TRANSPORT_FAILURE
+					}
+				});
+				else socket.destroy();
 				setupSettled.then(() => upstreamClosed).then(() => {
 					releasePermit?.();
 					releasePermit = null;
 					resident?.finish();
 				});
 			};
+			const close = () => finish();
+			const failHandshake = () => finish(Date.now() >= deadlineAtMs ? 504 : 502);
 			try {
-				const { target, sampling } = resolveTarget(req);
-				if (!sampling) throw new Error(FAILURE);
+				const { target, sampling, path } = resolveTarget(req);
+				if (params.oauth) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
+				if (!sampling && path !== "/guardian" && path !== "/guardian-classifier") throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 				if (connections.size >= MAX_WEBSOCKETS) idleConnections.values().next().value?.();
 				if (connections.size >= MAX_WEBSOCKETS) {
 					rejectBusyUpgrade(socket);
@@ -381,12 +355,12 @@ async function createCodexInferenceProxy(params) {
 					rejectBusyUpgrade(socket);
 					return;
 				}
-				handshakeTimer = setTimeout(close, Math.max(1, deadlineAtMs - Date.now()));
+				handshakeTimer = setTimeout(() => finish(504), Math.max(1, deadlineAtMs - Date.now()));
 				handshakeTimer.unref();
 				const assertHandshakeCurrent = () => {
 					assertCurrent();
 					signal.throwIfAborted();
-					if (Date.now() >= deadlineAtMs) throw new Error(FAILURE);
+					if (Date.now() >= deadlineAtMs) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 				};
 				proxyAgent = createNodeProxyAgent({
 					mode: "env",
@@ -422,20 +396,20 @@ async function createCodexInferenceProxy(params) {
 				remote.once("upgrade", (response) => {
 					handshakeHeaders.set(req, relayHeaders(response.headers));
 				});
-				remote.once("error", close);
-				remote.once("close", close);
+				remote.once("error", failHandshake);
+				remote.once("close", failHandshake);
 				remote.once("unexpected-response", (_request, response) => {
 					(async () => {
 						try {
 							const body = await readProxyBody(response, MAX_ERROR_BODY_BYTES);
-							assertCurrent();
-							signal.throwIfAborted();
+							assertHandshakeCurrent();
+							clearTimeout(handshakeTimer);
 							const failureHeaders = Object.entries(relayHeaders(response.headers)).map(([key, value]) => key + ": " + value);
 							failureHeaders.push("Connection: close", "Content-Length: " + body.length);
 							const status = "HTTP/1.1 " + response.statusCode + " " + (response.statusMessage ?? "Upstream refused");
 							socket.end(Buffer.concat([Buffer.from(status + "\r\n" + failureHeaders.join("\r\n") + "\r\n\r\n"), body]), close);
 						} catch {
-							close();
+							failHandshake();
 						}
 					})();
 				});
@@ -449,6 +423,7 @@ async function createCodexInferenceProxy(params) {
 							accepted.once("error", close);
 							accepted.once("close", close);
 							let releaseFrame = () => {};
+							let settleFrame = () => {};
 							const idle = (reclaimable = true) => {
 								framePending = false;
 								idleConnections.delete(close);
@@ -472,7 +447,7 @@ async function createCodexInferenceProxy(params) {
 										accepted.send(OVERLOAD_BODY, { binary: false }, close);
 										return;
 									}
-									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > 33554432) throw new Error(FAILURE);
+									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > 33554432) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 									const release = releaseUpload;
 									remote.send(prepared.bytes, { binary: false }, (error) => {
 										release();
@@ -484,43 +459,67 @@ async function createCodexInferenceProxy(params) {
 								}
 							};
 							accepted.on("message", (data, binary) => {
-								try {
-									if (binary) throw new Error(FAILURE);
-									const prepared = prepare(rawBytes(data), true);
-									prepared.assertCurrent();
-									if (framePending) throw new Error(FAILURE);
-									framePending = true;
-									clearTimeout(idleTimer);
-									idleConnections.delete(close);
-									releaseFrame();
-									const onAbort = () => close();
-									const frameSignal = prepared.signal;
-									frameSignal?.addEventListener("abort", onAbort, { once: true });
-									releaseFrame = () => frameSignal?.removeEventListener("abort", onAbort);
-									forward(prepared);
-								} catch {
+								if (framePending) {
 									close();
+									return;
 								}
+								framePending = true;
+								clearTimeout(idleTimer);
+								idleConnections.delete(close);
+								releaseFrame();
+								(async () => {
+									let prepared;
+									try {
+										if (binary) throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
+										prepared = await prepare(readProxyWebSocketBody(data), sampling, path, req.headers, signal, "websocket");
+										prepared.assertCurrent();
+										const frame = prepared;
+										const onAbort = () => close();
+										frame.signal.addEventListener("abort", onAbort, { once: true });
+										frame.contextSignal?.addEventListener("abort", onAbort, { once: true });
+										const releaseModel = () => {
+											frame.signal.removeEventListener("abort", onAbort);
+											frame.release();
+										};
+										settleFrame = releaseModel;
+										releaseFrame = () => {
+											frame.contextSignal?.removeEventListener("abort", onAbort);
+											releaseModel();
+										};
+										frame.signal.throwIfAborted();
+										await forward(frame);
+									} catch (error) {
+										prepared?.release();
+										const denied = authorizationFailure(error);
+										if (denied && accepted.readyState === WebSocket.OPEN) accepted.send(denied, { binary: false }, close);
+										else close();
+									}
+								})();
 							});
 							accepted.once("close", () => releaseFrame());
 							remote.on("message", (data, binary) => {
-								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + rawBytes(data).length > 33554432) {
+								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + readProxyWebSocketBody(data).length > 33554432) {
 									close();
 									return;
 								}
-								const terminal = !binary && isTerminalResponse(rawBytes(data));
+								const terminal = !binary && isTerminalResponse(readProxyWebSocketBody(data));
+								const releaseCompletedFrame = terminal ? settleFrame : void 0;
 								accepted.send(data, { binary }, (error) => {
 									if (error) close();
-									else if (terminal && connections.has(close)) idle();
+									else if (terminal && connections.has(close)) {
+										releaseCompletedFrame?.();
+										idle();
+									}
 								});
 							});
 						});
 					} catch {
-						close();
+						failHandshake();
 					}
 				});
 			} catch {
-				close();
+				if (connections.has(close)) failHandshake();
+				else close();
 			} finally {
 				finishSetup();
 			}
@@ -545,7 +544,7 @@ async function createCodexInferenceProxy(params) {
 		assertCurrent();
 		server.on("error", close);
 		const address = server.address();
-		if (!address || typeof address === "string") throw new Error(FAILURE);
+		if (!address || typeof address === "string") throw new Error(CODEX_INFERENCE_TRANSPORT_FAILURE);
 		return {
 			context,
 			upstream: upstream.toString(),
@@ -558,44 +557,5 @@ async function createCodexInferenceProxy(params) {
 		throw error;
 	}
 }
-function rejectBusyUpgrade(socket) {
-	rejectWebSocketUpgrade(socket, {
-		status: 503,
-		headers: { "Retry-After": "1" },
-		body: {
-			contentType: "application/json",
-			text: OVERLOAD_BODY
-		}
-	});
-}
-function isTerminalResponse(bytes) {
-	try {
-		const event = JSON.parse(bytes.toString("utf8"));
-		return isJsonObject(event) && (event.type === "response.failed" || event.type === "response.incomplete" || event.type === "response.completed" && isJsonObject(event.response) && typeof event.response.id === "string");
-	} catch {
-		return false;
-	}
-}
-async function readProxyBody(stream, maxBytes) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of stream) {
-		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += bytes.length;
-		if (size > maxBytes) throw new Error(FAILURE);
-		chunks.push(bytes);
-	}
-	return Buffer.concat(chunks);
-}
-function rawBytes(data) {
-	return Array.isArray(data) ? Buffer.concat(data) : Buffer.isBuffer(data) ? data : Buffer.from(data);
-}
-function relayHeaders(input) {
-	const excluded = new Set(HOP_HEADERS);
-	for (const token of (input.connection ?? "").split(",")) excluded.add(token.trim().toLowerCase());
-	const output = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0 && !excluded.has(key.toLowerCase())) output[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-	return output;
-}
 //#endregion
-export { createCodexInferenceProxy };
+export { CodexInferenceAuthorizationError, createCodexInferenceProxy };

package/dist/.setup/{isolated-completion-BIZFhTNG.mjs → isolated-completion-Dm3PzxJk.mjs}

@@ -1,12 +1,11 @@
-import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
-import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
-import { i as resolveCodexAppServerHomeScope } from "./config-options-BvaRs51b.mjs";
-import "./config-BoTP_mrL.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
-import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-DA4VR4Eb.mjs";
-import { _ as assertCodexPassiveTurnItems } from "./client-Cs08OXVQ.mjs";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-B2HScEgT.mjs";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BsruvNrH.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-CzyWLTJt.mjs";
+import "./config-DKhXquav.mjs";
+import { tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-DqyTMYug.mjs";
+import { _ as assertCodexPassiveTurnItems } from "./client-N0JpgSzF.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-CbjoN2OW.mjs";
+import { t as resolveCodexBoundedTurnIsolation } from "./bounded-turn-isolation-B8K_ylqk.mjs";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-CigreO4K.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) {
@@ -15,8 +14,6 @@ async function runCodexIsolatedCompletion(params, options) {
 	if (authorization.owner !== "harness") throw new Error("Codex native isolated completion requires harness-owned authorization.");
 	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
 	const homeScope = resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer });
-	const { start } = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
-	const privateStdio = start.transport === "stdio" && homeScope === "agent" && !isCodexAppServerProxyLaunch(start.args);
 	const authRequirement = authorization.plan.modelRoute?.authRequirement;
 	const authHandoff = await resolveCodexAppServerPreparedAuthHandoff({
 		authRequirement,
@@ -53,7 +50,7 @@ async function runCodexIsolatedCompletion(params, options) {
 			text_elements: []
 		}],
 		requiredModalities: ["text"],
-		isolation: privateStdio ? "private-stdio" : "configured-transport",
+		isolation: resolveCodexBoundedTurnIsolation(options),
 		requireNoExternalCapabilities: true,
 		allowEmptyText: params.outputTextPolicy === "strict-visible"
 	});

package/dist/.setup/{managed-binary-BnshlFag.mjs → managed-binary-kiWRhNRE.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
 import { createRequire } from "node:module";
 import { constants, existsSync, realpathSync } from "node:fs";
 import path from "node:path";
@@ -19,7 +19,10 @@ const MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES = [{
 	appServerCommandPath: "/Applications/Codex.app/Contents/Resources/codex",
 	bundledMarketplacePath: "/Applications/Codex.app/Contents/Resources/plugins/openai-bundled",
 	computerUseServiceAppPaths: ["/Applications/Codex.app/Contents/Resources/plugins/openai-bundled/plugins/computer-use/Codex Computer Use.app", "/Applications/Codex.app/Contents/Resources/cua_node/lib/node_modules/@oai/sky/Codex Computer Use.app"]
-}];
+}].flatMap((candidate) => [{
+	...candidate,
+	appServerCommandPath: path.join(candidate.appBundlePath, "Contents", "Resources", "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex")
+}, candidate]);
 function resolveMacOSDesktopCodexAppPathCandidates(platform = process.platform) {
 	return platform === "darwin" ? MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES : [];
 }
@@ -27,7 +30,7 @@ function resolveMacOSDesktopCodexAppServerCommandCandidates(platform = process.p
 	return resolveMacOSDesktopCodexAppPathCandidates(platform).map((candidate) => candidate.appServerCommandPath);
 }
 function resolveMacOSDesktopCodexBundledMarketplaceCandidates(platform = process.platform) {
-	return resolveMacOSDesktopCodexAppPathCandidates(platform).map((candidate) => candidate.bundledMarketplacePath);
+	return [...new Set(resolveMacOSDesktopCodexAppPathCandidates(platform).map((candidate) => candidate.bundledMarketplacePath))];
 }
 function resolveMacOSDesktopCodexComputerUseServiceAppCandidates(platform = process.platform, appServerCommand) {
 	if (platform !== "darwin") return [];
@@ -43,14 +46,10 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 }
 //#endregion
 //#region extensions/codex/src/app-server/version.ts
-/**
-* Version and package pins for the managed Codex app-server runtime.
-*/
 /** Exact Codex app-server version shipped by the OpenClaw Codex bridge. */
-const CODEX_APP_SERVER_VERSION = "0.155.1";
+const CODEX_APP_SERVER_VERSION = "0.158.0";
 /** Inclusive runtime compatibility floor for external app-server binaries. */
 const MIN_SUPPORTED_CODEX_APP_SERVER_VERSION = "0.149.0";
-/** npm package name for the managed Codex app-server binary. */
 const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
 //#endregion
 //#region extensions/codex/src/app-server/managed-binary.ts
@@ -117,7 +116,7 @@ function isManagedCodexDesktopCommand(command, platform = process.platform) {
 	return platform === "darwin" && resolveMacOSDesktopCodexAppServerCommandCandidates(platform).some((candidate) => candidate === command);
 }
 function resolveManagedCodexPackageRootForCommand(command, platform) {
-	const pathApi = pathForPlatform(platform);
+	const pathApi = platform === "win32" ? path.win32 : path.posix;
 	const commandPaths = [command];
 	try {
 		commandPaths.unshift(realpathSync(command));
@@ -181,9 +180,6 @@ function resolveManagedCodexPackageEntrypoint(pluginRoot) {
 		return;
 	}
 }
-function pathForPlatform(platform) {
-	return platform === "win32" ? path.win32 : path.posix;
-}
 async function findManagedCodexAppServerCommandPaths(params) {
 	const commandPaths = [];
 	for (const commandPath of params.candidateCommandPaths) if (await params.pathExists(commandPath, params.platform)) commandPaths.push(commandPath);