@openclaw/codex 2026.9.3 → 2026.9.5

package/dist/.setup/inference-proxy-CC15HuSi.mjs

@@ -0,0 +1,311 @@
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { n as createCodexInferenceContext } from "./inference-context-fulhZuz8.mjs";
+import { promisify } from "node:util";
+import { zstdCompress, zstdDecompress } from "node:zlib";
+import { Writable } from "node:stream";
+import { WebSocket, WebSocketServer } from "openclaw/plugin-sdk/websocket-runtime";
+import { createServer } from "node:http";
+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-proxy.ts
+const MAX_BODY_BYTES = 33554432;
+const MAX_ERROR_BODY_BYTES = 1048576;
+const MAX_CONNECTIONS = 16;
+const compress = promisify(zstdCompress);
+const decompress = promisify(zstdDecompress);
+const HOP_HEADERS = /* @__PURE__ */ new Set([
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"host",
+	"content-length"
+]);
+const FAILURE = "Codex parent-local inference transport failed; retry on a fresh connection.";
+/** 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");
+	const lifetime = new AbortController();
+	const assertCurrent = () => {
+		lifetime.signal.throwIfAborted();
+		params.assertCurrent();
+	};
+	const context = createCodexInferenceContext(assertCurrent);
+	const pathPrefix = "/" + generateSecureToken({
+		bytes: 32,
+		redact: true
+	}) + upstream.pathname.replace(/\/$/, "");
+	const active = /* @__PURE__ */ new Set();
+	const sockets = /* @__PURE__ */ new Set();
+	const wss = new WebSocketServer({
+		noServer: true,
+		maxPayload: MAX_BODY_BYTES,
+		perMessageDeflate: false
+	});
+	const handshakeHeaders = /* @__PURE__ */ new WeakMap();
+	wss.on("headers", (headers, request) => {
+		for (const [key, value] of Object.entries(handshakeHeaders.get(request) ?? {})) if (!key.startsWith("sec-websocket-")) headers.push(key + ": " + value);
+		handshakeHeaders.delete(request);
+	});
+	const resolveTarget = (request) => {
+		assertCurrent();
+		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(FAILURE);
+		const suffix = request.url.slice(pathPrefix.length);
+		if (suffix.startsWith("//") || suffix.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|\?|$)/i.test(suffix)) throw new Error(FAILURE);
+		const target = new URL(upstream);
+		const incoming = new URL(suffix, "http://localhost");
+		target.pathname = upstream.pathname.replace(/\/$/, "") + incoming.pathname;
+		for (const [key, value] of incoming.searchParams) target.searchParams.append(key, value);
+		return {
+			target,
+			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 > MAX_BODY_BYTES) throw new Error(FAILURE);
+		return {
+			...prepared,
+			bytes: rewritten
+		};
+	};
+	const server = createServer((req, res) => {
+		const controller = new AbortController();
+		let guarded;
+		const abort = () => controller.abort();
+		req.once("aborted", abort);
+		res.once("close", abort);
+		(async () => {
+			try {
+				const { target, sampling } = resolveTarget(req);
+				if (req.method !== "POST" || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
+				active.add(controller);
+				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;
+				assertCurrent();
+				const prepared = prepare(decoded, sampling);
+				const body = Buffer.from(encoding === "zstd" ? await compress(prepared.bytes) : prepared.bytes);
+				prepared.assertCurrent();
+				const signal = AbortSignal.any([
+					lifetime.signal,
+					controller.signal,
+					...prepared.signal ? [prepared.signal] : []
+				]);
+				guarded = await fetchWithSsrFGuard({
+					url: target.toString(),
+					init: {
+						method: "POST",
+						headers: relayHeaders(req.headers),
+						body,
+						signal
+					},
+					signal,
+					beforeRequest: prepared.assertCurrent,
+					requireHttps: true,
+					maxRedirects: 0,
+					capture: false,
+					mode: "trusted_env_proxy",
+					auditContext: "codex-parent-local-inference"
+				});
+				prepared.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 });
+			} catch {
+				if (!res.headersSent && !res.destroyed) res.writeHead(502, { "content-type": "text/plain" }).end(FAILURE);
+				else res.destroy();
+			} finally {
+				active.delete(controller);
+				req.off("aborted", abort);
+				res.off("close", abort);
+				await guarded?.release().catch(() => void 0);
+			}
+		})();
+	});
+	server.maxConnections = MAX_CONNECTIONS;
+	server.requestTimeout = 3e4;
+	server.headersTimeout = 1e4;
+	server.on("upgrade", (req, socket, head) => {
+		(async () => {
+			let remote;
+			let local;
+			let proxyAgent;
+			const controller = new AbortController();
+			const close = () => {
+				controller.abort();
+				active.delete(controller);
+				remote?.terminate();
+				local?.terminate();
+				proxyAgent?.destroy();
+				if (remote) sockets.delete(remote);
+				if (local) sockets.delete(local);
+				socket.destroy();
+			};
+			try {
+				const { target, sampling } = resolveTarget(req);
+				if (!sampling || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
+				active.add(controller);
+				socket.once("close", close);
+				socket.once("error", close);
+				const signal = AbortSignal.any([lifetime.signal, controller.signal]);
+				proxyAgent = createNodeProxyAgent({
+					mode: "env",
+					targetUrl: target.href
+				});
+				const lookup = proxyAgent ? void 0 : (await resolvePinnedHostnameWithPolicy(target.hostname, { signal })).lookup;
+				assertCurrent();
+				signal.throwIfAborted();
+				target.protocol = "wss:";
+				const headers = relayHeaders(req.headers);
+				for (const key of Object.keys(headers)) if (key.startsWith("sec-websocket-")) delete headers[key];
+				remote = new WebSocket(target, {
+					headers,
+					...proxyAgent ? { agent: proxyAgent } : { lookup },
+					followRedirects: false,
+					perMessageDeflate: false,
+					maxPayload: MAX_BODY_BYTES,
+					handshakeTimeout: 1e4
+				});
+				sockets.add(remote);
+				remote.once("upgrade", (response) => {
+					handshakeHeaders.set(req, relayHeaders(response.headers));
+				});
+				remote.once("error", close);
+				remote.once("close", close);
+				remote.once("unexpected-response", (_request, response) => {
+					(async () => {
+						try {
+							const body = await readProxyBody(response, MAX_ERROR_BODY_BYTES);
+							assertCurrent();
+							signal.throwIfAborted();
+							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();
+						}
+					})();
+				});
+				remote.once("open", () => {
+					try {
+						assertCurrent();
+						signal.throwIfAborted();
+						wss.handleUpgrade(req, socket, head, (accepted) => {
+							local = accepted;
+							sockets.add(accepted);
+							accepted.once("error", close);
+							accepted.once("close", close);
+							let releaseFrame = () => {};
+							accepted.on("message", (data, binary) => {
+								try {
+									if (binary) throw new Error(FAILURE);
+									const prepared = prepare(rawBytes(data), true);
+									prepared.assertCurrent();
+									releaseFrame();
+									const onAbort = () => close();
+									prepared.signal?.addEventListener("abort", onAbort, { once: true });
+									releaseFrame = () => prepared.signal?.removeEventListener("abort", onAbort);
+									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > MAX_BODY_BYTES) throw new Error(FAILURE);
+									remote.send(prepared.bytes, { binary: false }, (error) => {
+										if (error) close();
+									});
+								} catch {
+									close();
+								}
+							});
+							accepted.once("close", () => releaseFrame());
+							remote.on("message", (data, binary) => {
+								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + rawBytes(data).length > MAX_BODY_BYTES) {
+									close();
+									return;
+								}
+								accepted.send(data, { binary }, (error) => {
+									if (error) close();
+								});
+							});
+						});
+					} catch {
+						close();
+					}
+				});
+			} catch {
+				close();
+			}
+		})();
+	});
+	const close = () => {
+		lifetime.abort();
+		context.close();
+		for (const controller of active) controller.abort();
+		for (const socket of sockets) socket.terminate();
+		server.close();
+		server.closeAllConnections();
+		wss.close();
+	};
+	try {
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(0, "127.0.0.1", () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		assertCurrent();
+		server.on("error", close);
+		const address = server.address();
+		if (!address || typeof address === "string") throw new Error(FAILURE);
+		return {
+			context,
+			upstream: upstream.toString(),
+			baseUrl: "http://127.0.0.1:" + address.port + pathPrefix,
+			assertCurrent,
+			close
+		};
+	} catch (error) {
+		close();
+		throw error;
+	}
+}
+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 };

package/dist/{isolated-completion-DHBefrzg.js → .setup/isolated-completion-B6srt48J.mjs}

@@ -1,10 +1,10 @@
-import { i as resolveCodexAppServerHomeScope } from "./config-options-jnIFvwxD.js";
-import { x as readCodexPluginConfig } from "./protocol-CAAcVIKF.js";
-import { g as assertCodexPassiveTurnItems } from "./client-BEKu4yDx.js";
-import "./config-JDfTI4VI.js";
-import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CVhez2Uo.js";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-lRpmZHFv.js";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
+import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
+import { g as assertCodexPassiveTurnItems } from "./client-vXs2929Q.mjs";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-BsanJ8QG.mjs";
+import "./config-CedDWjM-.mjs";
+import { Z as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-BpTtuLQ5.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-BtlZcivC.mjs";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-DNUR1s0A.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) {

package/dist/{launch-args-RXQwn8zV.js → .setup/launch-args-DnMak49W.mjs}

@@ -55,6 +55,27 @@ function readCodexArgs(args) {
 	}
 	return tokens;
 }
+/** Uses the native CLI configuration for status without starting its transport. */
+function buildCodexLoginStatusArgs(args) {
+	const options = /* @__PURE__ */ new Set([
+		"-c",
+		"--config",
+		"-p",
+		"--profile",
+		"--enable",
+		"--disable"
+	]);
+	const tokens = readCodexArgs(args);
+	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
+	const prefix = subcommandIndex < 0 ? [] : args.slice(0, subcommandIndex);
+	const configArgs = tokens.filter(({ index, name }) => index > subcommandIndex && options.has(name)).flatMap(({ index, end }) => args.slice(index, end));
+	return [
+		...prefix,
+		...configArgs,
+		"login",
+		"status"
+	];
+}
 function readCodexAppServerConfigOptions(args) {
 	return readCodexArgs(args).filter(({ name }) => name === "-c" || name === "--config" || name === "-p" || name === "--profile");
 }
@@ -87,4 +108,4 @@ function normalizeCodexAppServerArgs(rawArgs, enforcedOverride) {
 	return normalized.length === rawArgs.length && normalized.every((arg, index) => arg === rawArgs[index]) ? rawArgs : normalized;
 }
 //#endregion
-export { normalizeCodexAppServerArgs as n, readCodexAppServerConfigOptions as r, isCodexAppServerProxyLaunch as t };
+export { readCodexAppServerConfigOptions as i, isCodexAppServerProxyLaunch as n, normalizeCodexAppServerArgs as r, buildCodexLoginStatusArgs as t };

package/dist/{managed-binary-DrjjRRUD.js → .setup/managed-binary-DP6Rib3P.mjs}

@@ -1,4 +1,5 @@
-import { n as MANAGED_CODEX_APP_SERVER_PACKAGE } from "./version-omm6IPI3.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { n as MANAGED_CODEX_APP_SERVER_PACKAGE } from "./version-CoqzXPgK.mjs";
 import { createRequire } from "node:module";
 import { constants, existsSync, realpathSync } from "node:fs";
 import path from "node:path";
@@ -47,6 +48,14 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 * Resolves the managed Codex app-server binary shipped with or installed beside
 * the Codex plugin before stdio startup.
 */
+var managed_binary_exports = /* @__PURE__ */ __exportAll({
+	isManagedCodexDesktopCommand: () => isManagedCodexDesktopCommand,
+	resolveManagedCodexAppServerStartOptions: () => resolveManagedCodexAppServerStartOptions,
+	resolveManagedCodexNativeCommand: () => resolveManagedCodexNativeCommand,
+	resolveManagedCodexPackageEntrypoint: () => resolveManagedCodexPackageEntrypoint,
+	resolvePackagedCodexNativeCommand: () => resolvePackagedCodexNativeCommand,
+	setManagedCodexPluginRoot: () => setManagedCodexPluginRoot
+});
 const registeredCodexPlugin = resolveGlobalSingleton(Symbol.for("openclaw.codexManagedPluginRoot"), () => ({}));
 /** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
 function setManagedCodexPluginRoot(pluginRoot) {
@@ -183,4 +192,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#endregion
-export { setManagedCodexPluginRoot as a, resolveMacOSDesktopCodexBundledMarketplaceCandidates as c, resolvePackagedCodexNativeCommand as i, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as l, resolveManagedCodexAppServerStartOptions as n, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as o, resolveManagedCodexNativeCommand as r, resolveMacOSDesktopCodexAppPathCandidates as s, isManagedCodexDesktopCommand as t };
+export { resolvePackagedCodexNativeCommand as a, resolveMacOSDesktopCodexAppPathCandidates as c, resolveManagedCodexNativeCommand as i, resolveMacOSDesktopCodexBundledMarketplaceCandidates as l, managed_binary_exports as n, setManagedCodexPluginRoot as o, resolveManagedCodexAppServerStartOptions as r, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as u };

package/dist/{managed-thread-store-D1t5jh3G.js → .setup/managed-thread-store-BMqgThVL.mjs}

@@ -28,10 +28,53 @@ function managedThreadStoreKey(sourceHomeId, threadId) {
 }
 /** Durable ownership index for Codex threads created by OpenClaw. */
 function createCodexManagedThreadStore(state) {
+	const byHome = /* @__PURE__ */ new Map();
+	const memberships = /* @__PURE__ */ new Map();
+	let hydration;
+	const remember = ({ sourceHomeId, threadId }) => {
+		const key = managedThreadStoreKey(sourceHomeId, threadId);
+		if (memberships.has(key)) return key;
+		memberships.set(key, {
+			sourceHomeId,
+			threadId
+		});
+		let ids = byHome.get(sourceHomeId);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			byHome.set(sourceHomeId, ids);
+		}
+		ids.add(threadId);
+		if (memberships.size > 2e4) {
+			const oldest = memberships.entries().next().value;
+			if (oldest) {
+				memberships.delete(oldest[0]);
+				const oldestHome = byHome.get(oldest[1].sourceHomeId);
+				oldestHome?.delete(oldest[1].threadId);
+				if (oldestHome?.size === 0) byHome.delete(oldest[1].sourceHomeId);
+			}
+		}
+		return key;
+	};
+	const snapshot = async () => {
+		hydration ??= state.entries().then((entries) => {
+			const marked = new Map(memberships);
+			memberships.clear();
+			byHome.clear();
+			for (const entry of entries.toSorted((a, b) => a.createdAt - b.createdAt)) {
+				const parsed = managedThreadSchema.safeParse(entry.value);
+				if (parsed.success) marked.delete(remember(parsed.data));
+			}
+			for (const membership of marked.values()) remember(membership);
+		}).catch((error) => {
+			hydration = void 0;
+			throw error;
+		});
+		await hydration;
+		return byHome;
+	};
 	return {
 		async has(sourceHomeId, threadId) {
-			const parsed = managedThreadSchema.safeParse(state.lookup(managedThreadStoreKey(sourceHomeId, threadId)));
-			return parsed.success && parsed.data.sourceHomeId === sourceHomeId && parsed.data.threadId === threadId;
+			return (await snapshot()).get(sourceHomeId)?.has(threadId) ?? false;
 		},
 		async mark(params) {
 			try {
@@ -42,24 +85,15 @@ function createCodexManagedThreadStore(state) {
 					threadId: params.threadId.trim(),
 					...params.rolloutPath?.trim() ? { rolloutPath: params.rolloutPath.trim() } : {}
 				});
-				state.registerIfAbsent(managedThreadStoreKey(value.sourceHomeId, value.threadId), value);
+				await state.registerIfAbsent(managedThreadStoreKey(value.sourceHomeId, value.threadId), value);
+				remember(value);
 				return true;
 			} catch (error) {
 				embeddedAgentLog.warn("failed to record Codex managed thread ownership", { error });
 				return false;
 			}
 		},
-		async snapshot() {
-			const byHome = /* @__PURE__ */ new Map();
-			for (const entry of state.entries()) {
-				const parsed = managedThreadSchema.safeParse(entry.value);
-				if (!parsed.success) continue;
-				const ids = byHome.get(parsed.data.sourceHomeId) ?? /* @__PURE__ */ new Set();
-				ids.add(parsed.data.threadId);
-				byHome.set(parsed.data.sourceHomeId, ids);
-			}
-			return byHome;
-		}
+		snapshot
 	};
 }
 //#endregion

package/dist/{model-catalog-B_6M04Wo.js → .setup/model-catalog-DkvUuBey.mjs}

@@ -1,9 +1,13 @@
-import { r as buildCodexRuntimeModelParams } from "./harness-FR6eQgyO.js";
-import { o as isJsonObject, x as readCodexPluginConfig } from "./protocol-CAAcVIKF.js";
-import { o as withCodexAppServerJsonClient } from "./request-CGvGOpeR.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
-import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CVhez2Uo.js";
-import { t as listAllCodexAppServerModels } from "./models-P9k2qAof.js";
+import { r as buildCodexRuntimeModelParams } from "./harness-rxaaoN-o.mjs";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
+import { n as isCodexAppServerProxyLaunch } from "./launch-args-DnMak49W.mjs";
+import { o as withCodexAppServerJsonClient } from "./request-BioXJLYa.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-WqZtZfXN.mjs";
+import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-BpTtuLQ5.mjs";
+import { t as listAllCodexAppServerModels } from "./models-BDFgm_G-.mjs";
+import { probeCodexNativeAuth } from "./native-auth-BLZGqFjw.mjs";
 //#region extensions/codex/src/app-server/model-catalog.ts
 const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
 const INPUT_TYPES = /* @__PURE__ */ new Set([
@@ -51,7 +55,10 @@ function createCodexAppServerModelCatalog(runtime) {
 		},
 		read(params, pluginConfig) {
 			const observation = scopes.get(params.config)?.get(scopeKey(params));
-			return !disposed && params.provider === "openai" && observation !== void 0 && observation.pluginConfig === pluginConfig && observation.models?.has(params.modelId) && observation.accountType && observation.isCurrent?.() ? { accountType: observation.accountType } : void 0;
+			return !disposed && params.provider === "openai" && observation !== void 0 && observation.pluginConfig === pluginConfig && observation.models?.has(params.modelId) && observation.accountType && observation.isCurrent?.() ? {
+				accountType: observation.accountType,
+				...observation.authMode ? { authMode: observation.authMode } : {}
+			} : void 0;
 		},
 		async load(params, pluginConfig) {
 			if (disposed) return [];
@@ -65,13 +72,30 @@ function createCodexAppServerModelCatalog(runtime) {
 			observations.set(key, observation);
 			const discovery = readCodexPluginConfig(pluginConfig).discovery;
 			if (discovery?.enabled === false) return [];
-			const { start } = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+			const options = resolveCodexAppServerRuntimeOptions({ pluginConfig });
+			const ownsLocalProcess = options.start.transport === "stdio" && !isCodexAppServerProxyLaunch(options.start.args);
+			const authProfileStore = ownsLocalProcess && options.start.homeScope === "agent" ? resolveCodexAppServerAuthProfileStore({
+				agentDir: params.agentDir,
+				config: params.config
+			}) : void 0;
+			const authProfileId = authProfileStore ? resolveCodexAppServerAuthProfileId({
+				store: authProfileStore,
+				config: params.config
+			}) : void 0;
+			const usesNativeHome = ownsLocalProcess && options.start.homeScope === "user";
+			const native = usesNativeHome ? await probeCodexNativeAuth({ pluginConfig }) : void 0;
+			if (usesNativeHome && !native || disposed || observations.get(key) !== observation) return [];
+			const { start } = options;
 			const timeoutMs = discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS;
 			const result = await withCodexAppServerJsonClient({
 				startOptions: start,
 				config: params.config,
 				agentDir: params.agentDir,
-				timeoutMs
+				timeoutMs,
+				...authProfileStore ? {
+					authProfileStore,
+					authProfileId
+				} : {}
 			}, async (request, client) => {
 				const isCurrent = captureSharedCodexAppServerCatalogLifetime(client);
 				const models = (await listAllCodexAppServerModels({
@@ -92,8 +116,9 @@ function createCodexAppServerModelCatalog(runtime) {
 			});
 			if (disposed || observations.get(key) !== observation || !result.isCurrent()) return [];
 			observation.models = new Set(result.models.map((model) => model.id));
-			observation.accountType = result.accountType;
+			observation.accountType = !usesNativeHome || native?.mode === "api-key" && result.accountType === "apiKey" || (native?.mode === "oauth" || native?.mode === "token") && result.accountType === "chatgpt" ? result.accountType : void 0;
 			observation.isCurrent = result.isCurrent;
+			observation.authMode = observation.accountType === "apiKey" ? "api_key" : observation.accountType === "chatgpt" && (native?.mode === "oauth" || native?.mode === "token") ? native.mode : void 0;
 			return codexAppServerModelsToCatalogEntries(result.models, runtime);
 		}
 	};

package/dist/{models-P9k2qAof.js → .setup/models-BDFgm_G-.mjs}

@@ -1,4 +1,4 @@
-import { h as assertCodexModelListResponse } from "./client-BEKu4yDx.js";
+import { h as assertCodexModelListResponse } from "./client-vXs2929Q.mjs";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
@@ -37,8 +37,8 @@ async function withCodexAppServerModelRequest(options, run) {
 	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-CVhez2Uo.js").then((n) => n.y);
-	const { requestCodexAppServerClientJson } = await import("./request-CGvGOpeR.js").then((n) => n.a);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
+	const { requestCodexAppServerClientJson } = await import("./request-BioXJLYa.mjs").then((n) => n.a);
 	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,

package/dist/.setup/native-auth-BLZGqFjw.mjs

@@ -0,0 +1,57 @@
+import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
+import { n as isCodexAppServerProxyLaunch, t as buildCodexLoginStatusArgs } from "./launch-args-DnMak49W.mjs";
+import { r as resolveManagedCodexAppServerStartOptions } from "./managed-binary-DP6Rib3P.mjs";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-Cmx94Oiy.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
+import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
+//#region extensions/codex/src/app-server/native-auth.ts
+const OPENAI_LOGIN_MODES = {
+	"Logged in using ChatGPT": "oauth",
+	"Logged in using access token": "token",
+	"Logged in using personal access token": "token"
+};
+/** Ask the selected native binary about its own store; retain no credential material. */
+async function probeCodexNativeAuth(params) {
+	params.signal?.throwIfAborted();
+	try {
+		const pluginConfig = readCodexPluginConfig(params.pluginConfig ?? params.config?.plugins?.entries?.codex?.config);
+		const options = resolveCodexAppServerRuntimeOptions({
+			pluginConfig,
+			env: params.env
+		});
+		if (options.start.transport !== "stdio" || options.start.homeScope !== "user" || isCodexAppServerProxyLaunch(options.start.args)) return;
+		const start = await resolveManagedCodexAppServerStartOptions(options.start, { pluginRoot: params.pluginRoot });
+		if (start.transport !== "stdio") return;
+		const env = resolveCodexAppServerSpawnEnv(start, params.env ?? process.env);
+		const invocation = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
+			command: start.command,
+			env,
+			packageName: "@openai/codex"
+		}), buildCodexLoginStatusArgs(start.args));
+		const result = await runUtf8CommandWithTimeout([invocation.command, ...invocation.argv], {
+			baseEnv: env,
+			timeoutMs: 3e3,
+			signal: params.signal,
+			killProcessTree: true
+		});
+		params.signal?.throwIfAborted();
+		if (result.termination !== "exit" || result.code !== 0) return;
+		const line = `${result.stdout}\n${result.stderr}`.split("\n").map((value) => value.trim()).find((value) => value.startsWith("Logged in using "));
+		const mode = line?.startsWith("Logged in using an API key - ") ? "api-key" : line ? OPENAI_LOGIN_MODES[line] : void 0;
+		return mode ? {
+			apiKey: "codex-app-server",
+			source: "Codex native login",
+			mode,
+			nativeAuth: {
+				runtime: "codex",
+				mode
+			}
+		} : void 0;
+	} catch {
+		params.signal?.throwIfAborted();
+		return;
+	}
+}
+//#endregion
+export { probeCodexNativeAuth };