@openclaw/codex 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{shared-client-rR6TDJA3.js → shared-client-4ICy3U6d.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { d as resolveCodexAppServerRuntimeOptions, r as codexAppServerStartOptionsKey } from "./config-C_whBx3M.js";
-import { l as resolveCodexAppServerSpawnEnv, o as isUnsupportedCodexAppServerVersionError, s as MANAGED_CODEX_APP_SERVER_PACKAGE, t as CodexAppServerClient } from "./client-IcTBKEqA.js";
+import { i as isRpcResponse, r as isJsonObject$1 } from "./protocol-2POPqAY4.js";
+import { d as resolveCodexAppServerRuntimeOptions, f as resolveCodexAppServerUserHomeDir, r as codexAppServerStartOptionsKey } from "./config-CYEDnLJ2.js";
 import { createRequire } from "node:module";
 import fs, { access } from "node:fs/promises";
 import path from "node:path";
@@ -8,10 +8,101 @@ import { createHash } from "node:crypto";
 import fsSync, { constants, readFileSync } from "node:fs";
 import os from "node:os";
 import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
+import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
+import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { isDeepStrictEqual } from "node:util";
 import { hasUsableOAuthCredential } from "openclaw/plugin-sdk/provider-auth";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { EventEmitter } from "node:events";
+import { PassThrough, Writable } from "node:stream";
+import WebSocket from "ws";
 import { fileURLToPath } from "node:url";
 import { withTimeout } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/codex/src/app-server/transport-stdio.ts
+/**
+* Creates and configures stdio-backed Codex app-server transports, including
+* Windows spawn normalization and environment filtering.
+*/
+const UNSAFE_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const QA_PARENT_PID_ENV = "OPENCLAW_QA_PARENT_PID";
+const DEFAULT_SPAWN_RUNTIME = {
+	platform: process.platform,
+	env: process.env,
+	execPath: process.execPath
+};
+/** Resolves the concrete command/argv/shell settings used to spawn Codex app-server. */
+function resolveCodexAppServerSpawnInvocation(options, runtime = DEFAULT_SPAWN_RUNTIME) {
+	if (options.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
+	const resolved = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
+		command: options.command,
+		platform: runtime.platform,
+		env: runtime.env,
+		execPath: runtime.execPath,
+		packageName: "@openai/codex"
+	}), options.args);
+	return {
+		command: resolved.command,
+		args: resolved.argv,
+		shell: resolved.shell,
+		windowsHide: resolved.windowsHide
+	};
+}
+/** Merges app-server environment overrides while honoring clearEnv and unsafe key filtering. */
+function resolveCodexAppServerSpawnEnv(options, baseEnv = process.env, platform = process.platform) {
+	const env = Object.create(null);
+	copySafeEnvironmentEntries(env, baseEnv);
+	copySafeEnvironmentEntries(env, options.env ?? {});
+	const keysToClear = normalizedEnvironmentKeys(options.clearEnv ?? []);
+	if (platform === "win32") {
+		const lowerCaseKeysToClear = new Set(keysToClear.map((key) => key.toLowerCase()));
+		for (const candidate of Object.keys(env)) if (lowerCaseKeysToClear.has(candidate.toLowerCase())) delete env[candidate];
+	} else for (const key of keysToClear) delete env[key];
+	return env;
+}
+/** Keeps QA-owned app-server processes inside the gateway process-group cleanup boundary. */
+function resolveCodexAppServerDetachedMode(env, platform = process.platform) {
+	return platform !== "win32" && !env[QA_PARENT_PID_ENV]?.trim();
+}
+function normalizedEnvironmentKeys(rawKeys) {
+	const keys = [];
+	for (const rawKey of rawKeys) {
+		const key = rawKey.trim();
+		if (key.length > 0) keys.push(key);
+	}
+	return keys;
+}
+function copySafeEnvironmentEntries(target, source) {
+	for (const [key, value] of Object.entries(source)) {
+		if (UNSAFE_ENVIRONMENT_KEYS.has(key)) continue;
+		target[key] = value;
+	}
+}
+/** Spawns the Codex app-server process and returns the shared transport interface. */
+function createStdioTransport(options) {
+	const env = resolveCodexAppServerSpawnEnv(options);
+	const invocation = resolveCodexAppServerSpawnInvocation(options, {
+		platform: process.platform,
+		env,
+		execPath: process.execPath
+	});
+	return spawn(invocation.command, invocation.args, {
+		env,
+		detached: resolveCodexAppServerDetachedMode(env),
+		shell: invocation.shell,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: invocation.windowsHide
+	});
+}
+//#endregion
 //#region extensions/codex/src/app-server/auth-bridge.ts
 const CODEX_APP_SERVER_AUTH_PROVIDER = "openai";
 const OPENAI_CODEX_APP_SERVER_AUTH_PROVIDER = "openai-codex";
@@ -29,8 +120,8 @@ const CODEX_HOME_DIRNAME = ".codex";
 const scopedOAuthRefreshQueues = /* @__PURE__ */ new WeakMap();
 async function bridgeCodexAppServerStartOptions(params) {
 	if (params.startOptions.transport !== "stdio") return params.startOptions;
-	const isolatedStartOptions = await withAgentCodexHomeEnvironment(params.startOptions, params.agentDir);
-	if (params.authProfileId === null) return isolatedStartOptions;
+	const scopedStartOptions = await withCodexHomeEnvironment(params.startOptions, params.agentDir);
+	if (params.authProfileId === null) return scopedStartOptions;
 	const store = resolveCodexAppServerAuthProfileStore({
 		agentDir: params.agentDir,
 		authProfileId: params.authProfileId,
@@ -45,7 +136,7 @@ async function bridgeCodexAppServerStartOptions(params) {
 			config: params.config
 		}),
 		config: params.config
-	}) ? withClearedEnvironmentVariables(isolatedStartOptions, CODEX_APP_SERVER_API_KEY_ENV_VARS) : isolatedStartOptions;
+	}) ? withClearedEnvironmentVariables(scopedStartOptions, CODEX_APP_SERVER_API_KEY_ENV_VARS) : scopedStartOptions;
 }
 function resolveCodexAppServerAuthProfileId(params) {
 	const requested = params.authProfileId?.trim();
@@ -190,8 +281,8 @@ function fingerprintCodexCliAuthFileApiKeyCacheKey(apiKey) {
 function resolveCodexAppServerHomeDir(agentDir) {
 	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
 }
-async function withAgentCodexHomeEnvironment(startOptions, agentDir) {
-	const codexHome = startOptions.env?.[CODEX_HOME_ENV_VAR]?.trim() ? startOptions.env[CODEX_HOME_ENV_VAR] : resolveCodexAppServerHomeDir(agentDir);
+async function withCodexHomeEnvironment(startOptions, agentDir) {
+	const codexHome = startOptions.env?.[CODEX_HOME_ENV_VAR]?.trim() ? startOptions.env[CODEX_HOME_ENV_VAR] : startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(process.env) : resolveCodexAppServerHomeDir(agentDir);
 	const nativeHome = startOptions.env?.[HOME_ENV_VAR]?.trim() ? startOptions.env[HOME_ENV_VAR] : void 0;
 	await fs.mkdir(codexHome, { recursive: true });
 	if (nativeHome) await fs.mkdir(nativeHome, { recursive: true });
@@ -505,6 +596,781 @@ function resolveChatgptAccountId(profileId, credential) {
 	return credential.email?.trim() || profileId;
 }
 //#endregion
+//#region extensions/codex/src/app-server/rate-limit-cache.ts
+const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 10 * 6e4;
+const SPARSE_ACCOUNT_METADATA_KEYS = [
+	"credits",
+	"individualLimit",
+	"planType"
+];
+const rateLimitsByClient = /* @__PURE__ */ new WeakMap();
+/** Replaces one physical client's cache with an authoritative rate-limit read response. */
+function rememberCodexRateLimitsRead(client, value, nowMs = Date.now()) {
+	if (value !== void 0) {
+		const revisionsByLimitId = { ...rateLimitsByClient.get(client)?.revisionsByLimitId };
+		for (const limitId of readRateLimitIds(value)) revisionsByLimitId[limitId] = (revisionsByLimitId[limitId] ?? 0) + 1;
+		rateLimitsByClient.set(client, {
+			value,
+			updatedAtMs: nowMs,
+			revisionsByLimitId
+		});
+	}
+}
+/** Merges a sparse rolling notification into one physical client's latest read response. */
+function mergeCodexRateLimitsUpdate(client, value, nowMs = Date.now()) {
+	const update = isJsonObject$1(value) && isJsonObject$1(value.rateLimits) ? value.rateLimits : void 0;
+	if (!update) return;
+	const currentState = rateLimitsByClient.get(client);
+	const current = currentState?.value;
+	const limitId = readLimitId(update);
+	rateLimitsByClient.set(client, {
+		value: mergeRateLimitUpdate(current, update),
+		updatedAtMs: nowMs,
+		revisionsByLimitId: {
+			...currentState?.revisionsByLimitId,
+			[limitId]: (currentState?.revisionsByLimitId[limitId] ?? 0) + 1
+		}
+	});
+}
+/** Per-limit marker used to trust only primary Codex updates from one turn startup. */
+function readCodexRateLimitsRevision(client, limitId = "codex") {
+	return rateLimitsByClient.get(client)?.revisionsByLimitId[limitId] ?? 0;
+}
+/** Reads one physical client's cached rate-limit payload within the max-age window. */
+function readRecentCodexRateLimits(client, options) {
+	const state = rateLimitsByClient.get(client);
+	if (!state) return;
+	const nowMs = options?.nowMs ?? Date.now();
+	const maxAgeMs = options?.maxAgeMs ?? DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS;
+	return maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs ? void 0 : state.value;
+}
+function mergeRateLimitUpdate(current, update) {
+	const currentEnvelope = isJsonObject$1(current) ? current : void 0;
+	const currentPrimary = currentEnvelope && isJsonObject$1(currentEnvelope.rateLimits) ? currentEnvelope.rateLimits : void 0;
+	const currentByLimitId = currentEnvelope && isJsonObject$1(currentEnvelope.rateLimitsByLimitId) ? currentEnvelope.rateLimitsByLimitId : void 0;
+	const limitId = readLimitId(update);
+	const currentPrimaryLimitId = currentPrimary ? readLimitId(currentPrimary) : void 0;
+	const currentForLimit = (currentByLimitId && isJsonObject$1(currentByLimitId[limitId]) ? currentByLimitId[limitId] : void 0) ?? (currentPrimaryLimitId === limitId ? currentPrimary : void 0);
+	const merged = mergeSparseSnapshot(isJsonObject$1(currentForLimit) ? currentForLimit : void 0, currentPrimary, update, limitId);
+	const nextPrimary = !currentPrimary || currentPrimaryLimitId === limitId ? merged : currentPrimary;
+	let nextByLimitId;
+	if (currentByLimitId) nextByLimitId = {
+		...currentByLimitId,
+		[limitId]: merged
+	};
+	else if (currentPrimary && currentPrimaryLimitId && currentPrimaryLimitId !== limitId) nextByLimitId = {
+		[currentPrimaryLimitId]: currentPrimary,
+		[limitId]: merged
+	};
+	return {
+		...currentEnvelope,
+		rateLimits: nextPrimary,
+		...nextByLimitId ? { rateLimitsByLimitId: nextByLimitId } : {}
+	};
+}
+function readRateLimitIds(value) {
+	if (!isJsonObject$1(value)) return [];
+	const ids = /* @__PURE__ */ new Set();
+	if (isJsonObject$1(value.rateLimits)) ids.add(readLimitId(value.rateLimits));
+	if (isJsonObject$1(value.rateLimitsByLimitId)) for (const [key, snapshot] of Object.entries(value.rateLimitsByLimitId)) {
+		const snapshotLimitId = isJsonObject$1(snapshot) && typeof snapshot.limitId === "string" ? snapshot.limitId.trim() : "";
+		ids.add(snapshotLimitId || key);
+	}
+	return [...ids];
+}
+function mergeSparseSnapshot(current, accountFallback, update, limitId) {
+	const merged = {
+		...update,
+		limitId
+	};
+	for (const key of SPARSE_ACCOUNT_METADATA_KEYS) {
+		const previous = current?.[key] ?? accountFallback?.[key];
+		if (merged[key] == null && previous != null) merged[key] = previous;
+	}
+	return merged;
+}
+function readLimitId(snapshot) {
+	const value = snapshot.limitId;
+	return typeof value === "string" && value.trim() ? value.trim() : "codex";
+}
+//#endregion
+//#region extensions/codex/src/app-server/client-runtime.ts
+/** Client-scoped Codex auth and account observers. */
+const configuredClients = /* @__PURE__ */ new WeakMap();
+/** Installs one auth-refresh handler and one rate-limit observer per physical client. */
+function ensureCodexAppServerClientRuntime(client, context) {
+	const existing = configuredClients.get(client);
+	if (existing) {
+		existing.context = context;
+		return;
+	}
+	const runtime = { context };
+	configuredClients.set(client, runtime);
+	client.addRequestHandler(async (request) => {
+		if (request.method !== "account/chatgptAuthTokens/refresh") return;
+		return await refreshCodexAppServerAuthTokens({
+			agentDir: runtime.context.agentDir,
+			authProfileId: runtime.context.authProfileId,
+			...runtime.context.authProfileStore ? { authProfileStore: runtime.context.authProfileStore } : {},
+			config: runtime.context.config
+		});
+	});
+	client.addNotificationHandler((notification) => {
+		if (notification.method === "account/rateLimits/updated") mergeCodexRateLimitsUpdate(client, notification.params);
+	});
+}
+//#endregion
+//#region extensions/codex/src/app-server/transport-websocket.ts
+/**
+* Adapts a remote Codex app-server WebSocket endpoint to the shared stdio-like
+* transport interface.
+*/
+/** Opens a WebSocket app-server transport and maps newline-delimited frames to stdout/stdin. */
+function createWebSocketTransport(options) {
+	if (!options.url) throw new Error("codex app-server websocket transport requires plugins.entries.codex.config.appServer.url");
+	const events = new EventEmitter();
+	const stdout = new PassThrough();
+	const stderr = new PassThrough();
+	const headers = {
+		...options.headers,
+		...options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {}
+	};
+	const socket = new WebSocket(options.url, { headers });
+	const pendingFrames = [];
+	let killed = false;
+	const sendFrame = (frame) => {
+		const trimmed = frame.trim();
+		if (!trimmed) return;
+		if (socket.readyState === WebSocket.OPEN) {
+			socket.send(trimmed);
+			return;
+		}
+		pendingFrames.push(trimmed);
+	};
+	socket.once("open", () => {
+		for (const frame of pendingFrames.splice(0)) socket.send(frame);
+	});
+	socket.once("error", (error) => events.emit("error", error));
+	socket.once("close", (code, reason) => {
+		killed = true;
+		events.emit("exit", code, reason.toString("utf8"));
+	});
+	socket.on("message", (data) => {
+		const text = websocketFrameToText(data);
+		stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+	});
+	const stdin = new Writable({ write(chunk, _encoding, callback) {
+		for (const frame of chunk.toString("utf8").split("\n")) sendFrame(frame);
+		callback();
+	} });
+	const closeSocket = () => {
+		if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) return;
+		socket.close();
+	};
+	stdin.once("finish", closeSocket);
+	stdin.once("close", closeSocket);
+	return {
+		stdin,
+		stdout,
+		stderr,
+		get killed() {
+			return killed;
+		},
+		kill: () => {
+			killed = true;
+			socket.close();
+		},
+		once: (event, listener) => events.once(event, listener)
+	};
+}
+function websocketFrameToText(data) {
+	if (typeof data === "string") return data;
+	if (Buffer.isBuffer(data)) return data.toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return Buffer.from(data).toString("utf8");
+}
+//#endregion
+//#region extensions/codex/src/app-server/transport.ts
+/** Starts graceful transport shutdown and schedules a force kill fallback. */
+function closeCodexAppServerTransport(child, options = {}) {
+	child.stdin.end?.();
+	child.stdin.destroy?.();
+	const forceKillDelayMs = options.forceKillDelayMs ?? 1e3;
+	const forceKill = setTimeout(() => {
+		if (hasCodexAppServerTransportExited(child)) return;
+		signalCodexAppServerTransport(child, "SIGKILL");
+	}, Math.max(1, forceKillDelayMs));
+	forceKill.unref?.();
+	child.once("exit", () => {
+		clearTimeout(forceKill);
+		child.stdout.destroy?.();
+		child.stderr.destroy?.();
+	});
+	child.unref?.();
+	child.stdout.unref?.();
+	child.stderr.unref?.();
+	child.stdin.unref?.();
+}
+/** Closes a transport and waits briefly for an exit event. */
+async function closeCodexAppServerTransportAndWait(child, options = {}) {
+	if (!hasCodexAppServerTransportExited(child)) closeCodexAppServerTransport(child, options);
+	return await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3);
+}
+function hasCodexAppServerTransportExited(child) {
+	return child.exitCode !== null && child.exitCode !== void 0 ? true : child.signalCode !== null && child.signalCode !== void 0;
+}
+async function waitForCodexAppServerTransportExit(child, timeoutMs) {
+	if (hasCodexAppServerTransportExited(child)) return true;
+	return await new Promise((resolve) => {
+		let settled = false;
+		const onExit = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			resolve(true);
+		};
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			child.off?.("exit", onExit);
+			resolve(false);
+		}, Math.max(1, timeoutMs));
+		child.once("exit", onExit);
+	});
+}
+function signalCodexAppServerTransport(child, signal) {
+	if (child.pid && process.platform !== "win32") try {
+		process.kill(-child.pid, signal);
+		return;
+	} catch {}
+	child.kill?.(signal);
+}
+//#endregion
+//#region extensions/codex/src/app-server/version.ts
+/**
+* Version and package pins for the managed Codex app-server runtime.
+*/
+/** Minimum Codex app-server version supported by the OpenClaw Codex bridge. */
+const MIN_CODEX_APP_SERVER_VERSION = "0.143.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/client.ts
+/**
+* JSON-RPC client for Codex app-server transports, including request/response
+* routing, notification fanout, server request handlers, and version checks.
+*/
+const CODEX_APP_SERVER_PARSE_LOG_MAX = 500;
+const CODEX_APP_SERVER_PARSE_BUFFER_MAX = 1e6;
+const CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES = 1e3;
+const CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS = 6e5;
+const CODEX_APP_SERVER_STDERR_TAIL_MAX = 2e3;
+const UNPAIRED_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+	}
+};
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+function isJsonObject(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+/** Returns true for errors that mean the app-server transport is closed. */
+function isCodexAppServerConnectionClosedError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message === "codex app-server client is closed" || error.message.startsWith("codex app-server exited:");
+}
+/** Stateful app-server JSON-RPC client over stdio or websocket transport. */
+var CodexAppServerClient = class CodexAppServerClient {
+	constructor(child) {
+		this.pending = /* @__PURE__ */ new Map();
+		this.requestHandlers = /* @__PURE__ */ new Set();
+		this.notificationHandlers = /* @__PURE__ */ new Set();
+		this.closeHandlers = /* @__PURE__ */ new Set();
+		this.nextId = 1;
+		this.initialized = false;
+		this.closed = false;
+		this.stderrTail = "";
+		this.child = child;
+		this.lines = createInterface({ input: child.stdout });
+		this.lines.on("line", (line) => this.handleLine(line));
+		this.lines.on("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		child.stdout.on("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		child.stderr.on("data", (chunk) => {
+			const text = chunk.toString("utf8");
+			this.stderrTail = appendBoundedTail(this.stderrTail, text, CODEX_APP_SERVER_STDERR_TAIL_MAX);
+			const trimmed = text.trim();
+			if (trimmed) embeddedAgentLog.debug(`codex app-server stderr: ${trimmed}`);
+		});
+		child.stderr.on("error", (error) => {
+			embeddedAgentLog.warn("codex app-server stderr stream failed", { error });
+		});
+		child.once("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+		child.once("exit", (code, signal) => {
+			this.closeWithError(buildCodexAppServerExitError(code, signal, this.stderrTail));
+		});
+		child.stdin.on?.("error", (error) => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+	}
+	/** Starts a new app-server client using resolved runtime start options. */
+	static start(options) {
+		const defaults = resolveCodexAppServerRuntimeOptions().start;
+		const startOptions = {
+			...defaults,
+			...options,
+			headers: options?.headers ?? defaults.headers
+		};
+		if (startOptions.transport === "stdio" && startOptions.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
+		if (startOptions.transport === "websocket") return new CodexAppServerClient(createWebSocketTransport(startOptions));
+		return new CodexAppServerClient(createStdioTransport(startOptions));
+	}
+	/** Builds a client around a fake transport for tests. */
+	static fromTransportForTests(child) {
+		return new CodexAppServerClient(child);
+	}
+	/** Performs the app-server initialize handshake and validates protocol version. */
+	async initialize() {
+		if (this.initialized) return;
+		const response = await this.request("initialize", {
+			clientInfo: {
+				name: "openclaw",
+				title: "OpenClaw",
+				version: OPENCLAW_VERSION
+			},
+			capabilities: { experimentalApi: true }
+		});
+		this.serverVersion = assertSupportedCodexAppServerVersion(response);
+		this.runtimeIdentity = buildCodexAppServerRuntimeIdentity(response, this.serverVersion);
+		this.notify("initialized");
+		this.initialized = true;
+	}
+	/** Returns the version detected during initialize. */
+	getServerVersion() {
+		return this.serverVersion;
+	}
+	/** Returns runtime metadata detected during initialize. */
+	getRuntimeIdentity() {
+		return this.runtimeIdentity ? { ...this.runtimeIdentity } : void 0;
+	}
+	request(method, params, optionsInput) {
+		let options = optionsInput;
+		options ??= {};
+		if (this.closed) return Promise.reject(this.closeError ?? /* @__PURE__ */ new Error("codex app-server client is closed"));
+		if (options.signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error(`${method} aborted`));
+		const id = this.nextId++;
+		const message = {
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			let timeout;
+			let cleanupAbort;
+			const cleanup = () => {
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = void 0;
+				}
+				cleanupAbort?.();
+				cleanupAbort = void 0;
+			};
+			const rejectPending = (error) => {
+				if (!this.pending.has(id)) return;
+				this.pending.delete(id);
+				cleanup();
+				reject(error);
+			};
+			if (options.timeoutMs && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+				timeout = setTimeout(() => rejectPending(/* @__PURE__ */ new Error(`${method} timed out`)), Math.max(100, options.timeoutMs));
+				timeout.unref?.();
+			}
+			if (options.signal) {
+				const abortListener = () => rejectPending(/* @__PURE__ */ new Error(`${method} aborted`));
+				options.signal.addEventListener("abort", abortListener, { once: true });
+				cleanupAbort = () => options.signal?.removeEventListener("abort", abortListener);
+			}
+			this.pending.set(id, {
+				method,
+				resolve: (value) => {
+					cleanup();
+					resolve(value);
+				},
+				reject: (error) => {
+					cleanup();
+					reject(error);
+				},
+				cleanup
+			});
+			if (options.signal?.aborted) {
+				rejectPending(/* @__PURE__ */ new Error(`${method} aborted`));
+				return;
+			}
+			try {
+				this.writeMessage(message, (error) => rejectPending(error));
+			} catch (error) {
+				rejectPending(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	/** Sends a fire-and-forget JSON-RPC notification to the app-server. */
+	notify(method, params) {
+		this.writeMessage({
+			method,
+			params
+		});
+	}
+	/** Registers a handler for app-server requests sent back to OpenClaw. */
+	addRequestHandler(handler) {
+		this.requestHandlers.add(handler);
+		return () => this.requestHandlers.delete(handler);
+	}
+	/** Registers a notification handler and returns its disposer. */
+	addNotificationHandler(handler) {
+		this.notificationHandlers.add(handler);
+		return () => this.notificationHandlers.delete(handler);
+	}
+	/** Registers a close handler and returns its disposer. */
+	addCloseHandler(handler) {
+		this.closeHandlers.add(handler);
+		return () => this.closeHandlers.delete(handler);
+	}
+	/** Closes the transport without waiting for process/socket shutdown. */
+	close() {
+		if (!this.markClosed(/* @__PURE__ */ new Error("codex app-server client is closed"))) return;
+		closeCodexAppServerTransport(this.child);
+	}
+	/** Closes the transport and waits for shutdown according to transport policy. */
+	async closeAndWait(options) {
+		this.markClosed(/* @__PURE__ */ new Error("codex app-server client is closed"));
+		return await closeCodexAppServerTransportAndWait(this.child, options);
+	}
+	writeMessage(message, onError) {
+		if (this.closed) return;
+		const id = "id" in message ? message.id : void 0;
+		const method = "method" in message ? message.method : void 0;
+		this.child.stdin.write(`${stringifyCodexAppServerMessage(message)}\n`, (error) => {
+			if (error) {
+				embeddedAgentLog.warn("codex app-server write failed", {
+					error,
+					id,
+					method
+				});
+				onError?.(error);
+			}
+		});
+	}
+	handleLine(line) {
+		const rawLine = line.endsWith("\r") ? line.slice(0, -1) : line;
+		if (this.pendingParse) {
+			this.handlePendingParseLine(rawLine);
+			return;
+		}
+		const trimmed = rawLine.trim();
+		if (!trimmed) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch (error) {
+			if (shouldBufferCodexAppServerParseFailure(trimmed, error)) {
+				this.pendingParse = {
+					text: trimmed,
+					lineCount: 1,
+					firstError: error
+				};
+				return;
+			}
+			logCodexAppServerParseFailure(trimmed, error, 1);
+			return;
+		}
+		this.handleParsedMessage(parsed);
+	}
+	handlePendingParseLine(line) {
+		const pending = this.pendingParse;
+		if (!pending) return;
+		const candidate = `${pending.text}\\n${line}`;
+		let parsed;
+		try {
+			parsed = JSON.parse(candidate);
+		} catch (error) {
+			const lineCount = pending.lineCount + 1;
+			if (shouldBufferCodexAppServerParseFailure(candidate.trim(), error) && candidate.length <= CODEX_APP_SERVER_PARSE_BUFFER_MAX && lineCount <= CODEX_APP_SERVER_PARSE_BUFFER_MAX_LINES) {
+				this.pendingParse = {
+					text: candidate,
+					lineCount,
+					firstError: pending.firstError
+				};
+				return;
+			}
+			this.pendingParse = void 0;
+			logCodexAppServerParseFailure(candidate, error, lineCount);
+			return;
+		}
+		this.pendingParse = void 0;
+		this.handleParsedMessage(parsed);
+	}
+	handleParsedMessage(parsed) {
+		if (!parsed || typeof parsed !== "object") return;
+		const message = parsed;
+		if (isRpcResponse(message)) {
+			this.handleResponse(message);
+			return;
+		}
+		if (!("method" in message)) return;
+		if ("id" in message && message.id !== void 0) {
+			this.handleServerRequest({
+				id: message.id,
+				method: message.method,
+				params: message.params
+			});
+			return;
+		}
+		this.handleNotification({
+			method: message.method,
+			params: message.params
+		});
+	}
+	handleResponse(response) {
+		const pending = this.pending.get(response.id);
+		if (!pending) return;
+		this.pending.delete(response.id);
+		if (response.error) {
+			pending.reject(new CodexAppServerRpcError(response.error, pending.method));
+			return;
+		}
+		pending.resolve(response.result);
+	}
+	async handleServerRequest(request) {
+		try {
+			const result = await this.runServerRequestHandlers(request);
+			if (result !== void 0) {
+				this.writeMessage({
+					id: request.id,
+					result
+				});
+				return;
+			}
+			this.writeMessage({
+				id: request.id,
+				result: defaultServerRequestResponse(request)
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			embeddedAgentLog.warn("codex app-server server request handler failed", {
+				id: request.id,
+				method: request.method,
+				error
+			});
+			this.writeMessage({
+				id: request.id,
+				error: {
+					code: -32603,
+					message
+				}
+			});
+		}
+	}
+	async runServerRequestHandlers(request) {
+		const timeoutResponse = timeoutServerRequestResponse(request);
+		if (!timeoutResponse) return await this.runServerRequestHandlersWithoutTimeout(request);
+		let timeout;
+		try {
+			return await Promise.race([this.runServerRequestHandlersWithoutTimeout(request), new Promise((resolve) => {
+				timeout = setTimeout(() => {
+					embeddedAgentLog.warn("codex app-server server request timed out", {
+						id: request.id,
+						method: request.method,
+						timeoutMs: CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS
+					});
+					resolve(timeoutResponse);
+				}, CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS);
+				timeout.unref?.();
+			})]);
+		} finally {
+			if (timeout) clearTimeout(timeout);
+		}
+	}
+	async runServerRequestHandlersWithoutTimeout(request) {
+		for (const handler of this.requestHandlers) {
+			const result = await handler(request);
+			if (result !== void 0) return result;
+		}
+	}
+	handleNotification(notification) {
+		for (const handler of this.notificationHandlers) Promise.resolve(handler(notification)).catch((error) => {
+			embeddedAgentLog.warn("codex app-server notification handler failed", { error });
+		});
+	}
+	closeWithError(error) {
+		if (this.markClosed(error)) closeCodexAppServerTransport(this.child);
+	}
+	markClosed(error) {
+		if (this.closed) return false;
+		this.closed = true;
+		this.closeError = error;
+		this.lines.close();
+		this.rejectPendingRequests(error);
+		return true;
+	}
+	rejectPendingRequests(error) {
+		for (const pending of this.pending.values()) {
+			pending.cleanup();
+			pending.reject(error);
+		}
+		this.pending.clear();
+		for (const handler of this.closeHandlers) handler(this);
+	}
+};
+function defaultServerRequestResponse(request) {
+	if (request.method === "item/tool/call") return {
+		contentItems: [{
+			type: "inputText",
+			text: "OpenClaw did not register a handler for this app-server tool call."
+		}],
+		success: false
+	};
+	if (request.method === "item/commandExecution/requestApproval" || request.method === "item/fileChange/requestApproval") return { decision: "decline" };
+	if (request.method === "item/permissions/requestApproval") return {
+		permissions: {},
+		scope: "turn"
+	};
+	if (request.method === "item/tool/requestUserInput") return { answers: {} };
+	if (request.method === "mcpServer/elicitation/request") return { action: "decline" };
+	return {};
+}
+function stringifyCodexAppServerMessage(message) {
+	return JSON.stringify(message, (_key, value) => typeof value === "string" ? value.replace(UNPAIRED_SURROGATE_RE, "") : value) ?? "null";
+}
+function timeoutServerRequestResponse(request) {
+	if (request.method !== "item/tool/call") return;
+	return {
+		contentItems: [{
+			type: "inputText",
+			text: `OpenClaw dynamic tool call timed out after ${CODEX_DYNAMIC_TOOL_SERVER_REQUEST_TIMEOUT_MS}ms before sending a response to Codex.`
+		}],
+		success: false
+	};
+}
+/** Raised when the initialize handshake detects an unsupported app-server version. */
+var CodexAppServerVersionError = class extends Error {
+	constructor(detectedVersion) {
+		const detected = detectedVersion ? `detected ${detectedVersion}` : "OpenClaw could not determine the running Codex version";
+		super(`Codex app-server ${MIN_CODEX_APP_SERVER_VERSION} or newer is required, but ${detected}. Update the configured Codex app-server binary, or remove custom command overrides to use the managed binary.`);
+		this.name = "CodexAppServerVersionError";
+		this.detectedVersion = detectedVersion;
+	}
+};
+function assertSupportedCodexAppServerVersion(response) {
+	const detectedVersion = readCodexVersionFromUserAgent(response.userAgent);
+	if (!detectedVersion || compareCodexAppServerVersions(detectedVersion, "0.143.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
+	return detectedVersion;
+}
+function isUnsupportedCodexAppServerVersionError(error) {
+	return error instanceof CodexAppServerVersionError;
+}
+function buildCodexAppServerRuntimeIdentity(response, serverVersion) {
+	const userAgent = readNonEmptyInitializeString(response.userAgent);
+	const codexHome = readNonEmptyInitializeString(response.codexHome);
+	const platformFamily = readNonEmptyInitializeString(response.platformFamily);
+	const platformOs = readNonEmptyInitializeString(response.platformOs);
+	return {
+		serverVersion,
+		...userAgent ? { userAgent } : {},
+		...codexHome ? { codexHome } : {},
+		...platformFamily ? { platformFamily } : {},
+		...platformOs ? { platformOs } : {}
+	};
+}
+function readNonEmptyInitializeString(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+/** Extracts the Codex version from the app-server initialize user-agent field. */
+function readCodexVersionFromUserAgent(userAgent) {
+	return (userAgent?.match(/^[^/]+\/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)(?:[\s(]|$)/))?.[1];
+}
+/** Compares stable Codex app-server versions for protocol floor checks. */
+function compareCodexAppServerVersions(left, right) {
+	const leftVersion = parseVersionForComparison(left);
+	const rightVersion = parseVersionForComparison(right);
+	const leftParts = leftVersion.parts;
+	const rightParts = rightVersion.parts;
+	for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+		const leftPart = leftParts[index] ?? 0;
+		const rightPart = rightParts[index] ?? 0;
+		if (leftPart !== rightPart) return leftPart < rightPart ? -1 : 1;
+	}
+	if (leftVersion.unstableSuffix && !rightVersion.unstableSuffix) return -1;
+	if (!leftVersion.unstableSuffix && rightVersion.unstableSuffix) return 1;
+	return 0;
+}
+function parseVersionForComparison(version) {
+	const hasBuildMetadata = version.includes("+");
+	const [withoutBuild = version] = version.split("+", 1);
+	const prereleaseIndex = withoutBuild.indexOf("-");
+	return {
+		parts: (prereleaseIndex >= 0 ? withoutBuild.slice(0, prereleaseIndex) : withoutBuild).split(".").map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0),
+		unstableSuffix: prereleaseIndex >= 0 || hasBuildMetadata
+	};
+}
+function redactCodexAppServerLinePreview(value) {
+	const redacted = value.replace(/\s+/g, " ").trim().replace(/(Bearer\s+)[A-Za-z0-9._~+/-]+/gi, "$1<redacted>").replace(/("(?:api_?key|authorization|token|access_token|refresh_token)"\s*:\s*")([^"]+)(")/gi, "$1<redacted>$3").replace(/\b([a-z0-9_]*(?:api_?key|authorization|access_token|refresh_token|token))(\s*=\s*)(["']?)[^\s"']+(\3)/gi, "$1$2$3<redacted>$4");
+	return redacted.length > CODEX_APP_SERVER_PARSE_LOG_MAX ? `${redacted.slice(0, CODEX_APP_SERVER_PARSE_LOG_MAX)}...` : redacted;
+}
+function appendBoundedTail(current, next, maxLength) {
+	const combined = `${current}${next}`;
+	return combined.length > maxLength ? combined.slice(combined.length - maxLength) : combined;
+}
+function buildCodexAppServerExitError(code, signal, stderrTail) {
+	const stderrPreview = redactCodexAppServerLinePreview(stderrTail);
+	const suffix = stderrPreview ? ` stderr=${JSON.stringify(stderrPreview)}` : "";
+	return /* @__PURE__ */ new Error(`codex app-server exited: code=${formatExitValue(code)} signal=${formatExitValue(signal)}${suffix}`);
+}
+function shouldBufferCodexAppServerParseFailure(value, error) {
+	if (!value.startsWith("{") && !value.startsWith("[")) return false;
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("Unterminated string") || message.includes("Unexpected end of JSON input");
+}
+function logCodexAppServerParseFailure(value, error, fragmentCount) {
+	const linePreview = redactCodexAppServerLinePreview(value);
+	const suffix = fragmentCount > 1 ? ` fragments=${fragmentCount}` : "";
+	embeddedAgentLog.warn("failed to parse codex app-server message", {
+		error,
+		errorMessage: error instanceof Error ? error.message : String(error),
+		fragmentCount,
+		linePreview,
+		consoleMessage: `failed to parse codex app-server message${suffix}: preview=${JSON.stringify(linePreview)}`
+	});
+}
+const CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS = /* @__PURE__ */ new Set([
+	"item/commandExecution/requestApproval",
+	"item/fileChange/requestApproval",
+	"item/permissions/requestApproval"
+]);
+/** Returns true for app-server approval request methods OpenClaw can answer. */
+function isCodexAppServerApprovalRequest(method) {
+	return CODEX_APP_SERVER_APPROVAL_REQUEST_METHODS.has(method);
+}
+function formatExitValue(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return "unknown";
+}
+//#endregion
 //#region extensions/codex/src/app-server/managed-binary.ts
 /**
 * Resolves the managed Codex app-server binary shipped with or installed beside
@@ -548,7 +1414,7 @@ function resolveManagedCodexAppServerCommandCandidates(pluginRoot, platform) {
 	const pathApi = pathForPlatform(platform);
 	const commandName = platform === "win32" ? "codex.cmd" : "codex";
 	const roots = resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform);
-	return [...new Set([
+	return [.../* @__PURE__ */ new Set([
 		...resolveDesktopCodexAppServerCommandCandidates(platform),
 		...roots.map((root) => pathApi.join(root, "node_modules", ".bin", commandName)),
 		...resolveManagedCodexPackageBinCandidates(roots, platform)
@@ -570,7 +1436,7 @@ function resolveManagedCodexAppServerCandidateRoots(pluginRoot, platform) {
 		pathApi.dirname(pathApi.dirname(pluginRoot)),
 		isDistExtensionRoot(pluginRoot, platform) ? pathApi.dirname(pathApi.dirname(pathApi.dirname(pluginRoot))) : null
 	].filter((root) => Boolean(root));
-	return [...new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
+	return [.../* @__PURE__ */ new Set([...directRoots, ...resolveNearestNodeModulesProjectRoots(directRoots, platform)])];
 }
 function resolveNearestNodeModulesProjectRoots(roots, platform) {
 	const pathApi = pathForPlatform(platform);
@@ -656,69 +1522,28 @@ async function withTimeout$1(promise, timeoutMs, timeoutMessage) {
 * lease tracking, and teardown.
 */
 var shared_client_exports = /* @__PURE__ */ __exportAll({
-	clearSharedCodexAppServerClient: () => clearSharedCodexAppServerClient,
 	clearSharedCodexAppServerClientAndWait: () => clearSharedCodexAppServerClientAndWait,
 	clearSharedCodexAppServerClientIfCurrent: () => clearSharedCodexAppServerClientIfCurrent,
 	clearSharedCodexAppServerClientIfCurrentAndUnclaimed: () => clearSharedCodexAppServerClientIfCurrentAndUnclaimed,
 	clearSharedCodexAppServerClientIfCurrentAndWait: () => clearSharedCodexAppServerClientIfCurrentAndWait,
 	createIsolatedCodexAppServerClient: () => createIsolatedCodexAppServerClient,
-	detachSharedCodexAppServerClientIfCurrent: () => detachSharedCodexAppServerClientIfCurrent,
 	getLeasedSharedCodexAppServerClient: () => getLeasedSharedCodexAppServerClient,
-	getSharedCodexAppServerClient: () => getSharedCodexAppServerClient,
 	releaseLeasedSharedCodexAppServerClient: () => releaseLeasedSharedCodexAppServerClient,
-	resetSharedCodexAppServerClientForTests: () => resetSharedCodexAppServerClientForTests,
-	retainSharedCodexAppServerClientIfCurrent: () => retainSharedCodexAppServerClientIfCurrent,
 	retireSharedCodexAppServerClientIfCurrent: () => retireSharedCodexAppServerClientIfCurrent
 });
 const SHARED_CODEX_APP_SERVER_CLIENT_STATE = Symbol.for("openclaw.codexAppServerClientState");
 function getSharedCodexAppServerClientState() {
 	const globalState = globalThis;
-	const state = globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE];
-	const keyedState = readKeyedSharedCodexAppServerClientState(state);
-	if (keyedState) {
-		const clients = keyedState.clients;
-		for (const entry of clients.values()) {
-			entry.activeLeases ??= 0;
-			entry.pendingAcquires ??= 0;
-			entry.closeWhenIdle ??= false;
-		}
-		const nextState = {
-			clients,
-			leasedReleases: keyedState.leasedReleases instanceof WeakMap ? keyedState.leasedReleases : /* @__PURE__ */ new WeakMap()
-		};
-		globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE] = nextState;
-		return nextState;
-	}
-	const legacyState = readLegacySharedCodexAppServerClientState(state);
-	const clients = /* @__PURE__ */ new Map();
-	if (legacyState?.key && (legacyState.client || legacyState.promise)) {
-		const legacyKey = legacyState.key;
-		clients.set(legacyKey, {
-			client: legacyState.client,
-			promise: legacyState.promise,
-			activeLeases: 0,
-			pendingAcquires: 0,
-			closeWhenIdle: false
-		});
-		legacyState.client?.addCloseHandler((closedClient) => clearSharedClientEntryIfCurrent(legacyKey, closedClient));
-	}
-	const nextState = {
-		clients,
+	globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE] ??= {
+		clients: /* @__PURE__ */ new Map(),
 		leasedReleases: /* @__PURE__ */ new WeakMap()
 	};
-	globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE] = nextState;
-	return nextState;
-}
-function readKeyedSharedCodexAppServerClientState(value) {
-	return value !== null && typeof value === "object" && value.clients instanceof Map ? value : void 0;
-}
-function readLegacySharedCodexAppServerClientState(value) {
-	if (value === null || typeof value !== "object") return;
-	return value;
+	return globalState[SHARED_CODEX_APP_SERVER_CLIENT_STATE];
 }
 async function resolveCodexAppServerClientStartContext(options) {
 	const agentDir = options?.agentDir ?? resolveDefaultAgentDir(options?.config ?? {});
-	const usesNativeAuth = options?.authProfileId === null;
+	const requestedStartOptions = options?.startOptions ?? resolveCodexAppServerRuntimeOptions().start;
+	const usesNativeAuth = options?.authProfileId === null || requestedStartOptions.homeScope === "user";
 	const requestedAuthProfileId = options?.authProfileId === null ? void 0 : options?.authProfileId;
 	const authProfileStore = !usesNativeAuth && options?.authProfileStore ? resolveCodexAppServerAuthProfileStore({
 		agentDir,
@@ -738,7 +1563,7 @@ async function resolveCodexAppServerClientStartContext(options) {
 		authProfileId,
 		authProfileStore,
 		startOptions: await bridgeCodexAppServerStartOptions({
-			startOptions: await resolveManagedCodexAppServerStartOptions(options?.startOptions ?? resolveCodexAppServerRuntimeOptions().start),
+			startOptions: await resolveManagedCodexAppServerStartOptions(requestedStartOptions),
 			agentDir,
 			authProfileId: usesNativeAuth ? null : authProfileId,
 			config: options?.config,
@@ -746,10 +1571,6 @@ async function resolveCodexAppServerClientStartContext(options) {
 		})
 	};
 }
-/** Gets or starts a shared Codex app-server client without retaining a lease. */
-async function getSharedCodexAppServerClient(options) {
-	return (await acquireSharedCodexAppServerClient(options)).client;
-}
 /** Gets or starts a shared Codex app-server client and records a release lease. */
 async function getLeasedSharedCodexAppServerClient(options) {
 	const acquired = await acquireSharedCodexAppServerClient(options, { leased: true });
@@ -799,18 +1620,20 @@ async function acquireSharedCodexAppServerClient(options, leaseOptions) {
 			config: options?.config,
 			onStartedClient: (startedClient) => {
 				entry.client = startedClient;
-				startedClient.setActiveSharedLeaseCountProviderForUnscopedNotifications(() => entry.activeLeases);
 				options?.onStartedClient?.(startedClient);
 			}
 		});
 		entry.client = client;
-		client.setActiveSharedLeaseCountProviderForUnscopedNotifications(() => entry.activeLeases);
 		client.addCloseHandler((closedClient) => clearSharedClientEntryIfCurrent(key, closedClient));
 		return client;
 	})());
 	try {
 		const client = await withTimeout$1(sharedPromise, options?.timeoutMs ?? 0, "codex app-server initialize timed out");
-		client.setActiveSharedLeaseCountProviderForUnscopedNotifications(() => entry.activeLeases);
+		ensureCodexAppServerClientRuntime(client, {
+			agentDir,
+			authProfileId: usesNativeAuth ? void 0 : authProfileId,
+			config: options?.config
+		});
 		const release = leaseOptions?.leased ? retainSharedClientEntry(entry) : void 0;
 		return release ? {
 			client,
@@ -853,14 +1676,11 @@ async function startInitializedCodexAppServerClient(params) {
 			if (shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates)) continue;
 			throw error;
 		}
-		if (params.authProfileId) client.addRequestHandler(async (request) => {
-			if (request.method !== "account/chatgptAuthTokens/refresh") return;
-			return await refreshCodexAppServerAuthTokens({
-				agentDir: params.agentDir,
-				authProfileId: params.authProfileId,
-				...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {},
-				config: params.config
-			});
+		ensureCodexAppServerClientRuntime(client, {
+			agentDir: params.agentDir,
+			authProfileId: params.authProfileId ?? void 0,
+			...params.authProfileStore ? { authProfileStore: params.authProfileStore } : {},
+			config: params.config
 		});
 		try {
 			await applyCodexAppServerAuthProfile({
@@ -898,21 +1718,6 @@ function resolveManagedFallbackStartOptions(startOptions) {
 function shouldTryManagedFallbackStartOption(error, startOptions, index, startOptionsCandidates) {
 	return startOptions.commandSource === "resolved-managed" && index < startOptionsCandidates.length - 1 && isUnsupportedCodexAppServerVersionError(error);
 }
-/** Clears and closes all shared clients for deterministic tests. */
-function resetSharedCodexAppServerClientForTests() {
-	const state = getSharedCodexAppServerClientState();
-	const clients = collectSharedClients(state);
-	state.clients.clear();
-	state.leasedReleases = /* @__PURE__ */ new WeakMap();
-	for (const client of clients) client.close();
-}
-/** Clears and closes all shared clients. */
-function clearSharedCodexAppServerClient() {
-	const state = getSharedCodexAppServerClientState();
-	const clients = collectSharedClients(state);
-	state.clients.clear();
-	for (const client of clients) client.close();
-}
 /** Clears and closes the shared entry only if it still owns the supplied client. */
 function clearSharedCodexAppServerClientIfCurrent(client) {
 	if (!client) return false;
@@ -924,22 +1729,6 @@ function clearSharedCodexAppServerClientIfCurrent(client) {
 	}
 	return false;
 }
-/** Detaches the shared entry without closing the client when it still matches. */
-function detachSharedCodexAppServerClientIfCurrent(client) {
-	if (!client) return false;
-	const state = getSharedCodexAppServerClientState();
-	for (const [key, entry] of state.clients) if (entry.client === client) {
-		state.clients.delete(key);
-		return true;
-	}
-	return false;
-}
-/** Retains the matching shared client and returns a release callback. */
-function retainSharedCodexAppServerClientIfCurrent(client) {
-	if (!client) return;
-	const state = getSharedCodexAppServerClientState();
-	for (const entry of state.clients.values()) if (entry.client === client) return retainSharedClientEntry(entry);
-}
 /** Marks a matching shared client to close after active leases/acquires drain. */
 function retireSharedCodexAppServerClientIfCurrent(client) {
 	if (!client) return;
@@ -1061,4 +1850,4 @@ function collectSharedClients(state) {
 	return [...new Set([...state.clients.values()].map((entry) => entry.client).filter((client) => Boolean(client)))];
 }
 //#endregion
-export { getLeasedSharedCodexAppServerClient as a, shared_client_exports as c, resolveCodexAppServerAuthAccountCacheKey as d, resolveCodexAppServerAuthProfileId as f, resolveCodexAppServerHomeDir as h, createIsolatedCodexAppServerClient as i, withTimeout$1 as l, resolveCodexAppServerFallbackApiKeyCacheKey as m, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as n, releaseLeasedSharedCodexAppServerClient as o, resolveCodexAppServerAuthProfileIdForAgent as p, clearSharedCodexAppServerClientIfCurrentAndWait as r, retireSharedCodexAppServerClientIfCurrent as s, clearSharedCodexAppServerClientIfCurrent as t, refreshCodexAppServerAuthTokens as u };
+export { resolveCodexAppServerAuthAccountCacheKey as _, getLeasedSharedCodexAppServerClient as a, resolveCodexAppServerFallbackApiKeyCacheKey as b, shared_client_exports as c, isCodexAppServerApprovalRequest as d, isCodexAppServerConnectionClosedError as f, rememberCodexRateLimitsRead as g, readRecentCodexRateLimits as h, createIsolatedCodexAppServerClient as i, withTimeout$1 as l, readCodexRateLimitsRevision as m, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as n, releaseLeasedSharedCodexAppServerClient as o, ensureCodexAppServerClientRuntime as p, clearSharedCodexAppServerClientIfCurrentAndWait as r, retireSharedCodexAppServerClientIfCurrent as s, clearSharedCodexAppServerClientIfCurrent as t, CodexAppServerRpcError as u, resolveCodexAppServerAuthProfileId as v, resolveCodexAppServerHomeDir as x, resolveCodexAppServerAuthProfileIdForAgent as y };