@openclaw/codex 2026.8.2 → 2026.9.1

package/dist/{shared-client-B1tT5U6r.js → shared-client-DxcfF9KX.js}

@@ -1,21 +1,24 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { F as resolveCodexAppServerLocalHomeDir, I as resolveCodexAppServerUserHomeDir, L as withEphemeralCodexAuthStore, P as resolveCodexAppServerHomeDir, a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey } from "./config-CcYL77O6.js";
-import { a as CODEX_APP_SERVER_VERSION, c as resolveMacOSDesktopCodexAppPathCandidates, l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, n as resolveManagedCodexAppServerStartOptions, o as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexComputerUseServiceAppCandidates } from "./managed-binary-ZkGodW19.js";
-import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-D0zinCP1.js";
-import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, n as resolveCodexAppServerSpawnEnv, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-NT_Dpd9V.js";
-import { l as readCodexDynamicToolCallParams } from "./protocol-validators-Bg5rpNxk.js";
+import { t as isCodexAppServerProxyLaunch } from "./launch-args-RXQwn8zV.js";
+import { F as resolveCodexAppServerHomeDir, I as resolveCodexAppServerLocalHomeDir, L as resolveCodexAppServerUserHomeDir, R as withEphemeralCodexAuthStore, a as resolveCodexAppServerStartOptionsForAgent, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig, t as codexAppServerStartOptionsKey } from "./config-BhmfC1s6.js";
+import { c as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, d as resolveMacOSDesktopCodexComputerUseServiceAppCandidates, l as resolveMacOSDesktopCodexAppPathCandidates, n as resolveManagedCodexAppServerStartOptions, o as CODEX_APP_SERVER_VERSION, r as resolveManagedCodexNativeCommand, s as MIN_SUPPORTED_CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexBundledMarketplaceCandidates } from "./managed-binary-4-Vjz5GH.js";
+import { o as isCodexAppServerNativeAuthProfile } from "./session-binding-BHuTCRZQ.js";
+import { a as hasCodexAppServerNaturalExit, i as closeCodexAppServerTransportAndWait, n as resolveCodexAppServerSpawnEnv, r as closeCodexAppServerTransport, t as createStdioTransport } from "./transport-stdio-CyPldczm.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { addTimerTimeoutGraceMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { AgentHarnessPreflightError, OPENCLAW_VERSION, embeddedAgentLog, formatErrorMessage, formatToolExecutionErrorMessage, normalizeQuestionTimeoutSeconds, resolveToolExecutionErrorKind } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { createZstdDecompress } from "node:zlib";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
 import { createHash, randomUUID } from "node:crypto";
-import fsSync, { constants, existsSync, watch } from "node:fs";
+import fsSync, { constants as constants$1, existsSync, watch } from "node:fs";
 import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
-import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveAuthProfileOrder, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
-import { hasUsableOAuthCredential, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
+import { ensureAuthProfileStore, findPersistedAuthProfileCredential, loadAuthProfileStoreForSecretsRuntime, refreshOAuthCredentialForRuntime, resolveApiKeyForProfile, resolveDefaultAgentDir, resolvePersistedAuthProfileOwnerAgentDir, resolveProviderIdForAuth } from "openclaw/plugin-sdk/agent-runtime";
+import { hasUsableOAuthCredential, resolveAuthProfileOrder, resolveOpenAICodexAuthIdentity } from "openclaw/plugin-sdk/provider-auth";
 import { readSecretFile } from "openclaw/plugin-sdk/secret-file";
 import { assertNoSymlinkParents, withTimeout } from "openclaw/plugin-sdk/security-runtime";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
@@ -25,10 +28,117 @@ import { coerceErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/erro
 import { sliceUtf16Safe, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { parse } from "semver";
 import { hasPendingInternalDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
+import { Compile } from "typebox/compile";
 import net from "node:net";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import WebSocket from "ws";
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
+const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
+function isJsonObject(value) {
+	return isRecord(value);
+}
+function isRpcResponse(message) {
+	return "id" in message && !("method" in message);
+}
+//#endregion
+//#region extensions/codex/src/session-catalog-provenance.ts
+const MAX_SESSION_META_BYTES = 1048576;
+const SESSION_META_READ_CHUNK_BYTES = 65536;
+const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
+const provenanceByPath = /* @__PURE__ */ new Map();
+function cacheProvenance(key, value) {
+	provenanceByPath.delete(key);
+	provenanceByPath.set(key, value);
+	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
+		const oldest = provenanceByPath.keys().next().value;
+		if (oldest === void 0) break;
+		provenanceByPath.delete(oldest);
+	}
+}
+/** Undefined means the metadata line is not durable enough to cache yet. */
+async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
+	let safeRoot;
+	try {
+		safeRoot = await root(sessionsRoot, {
+			hardlinks: "reject",
+			maxBytes: Number.MAX_SAFE_INTEGER,
+			symlinks: "reject"
+		});
+	} catch {
+		return;
+	}
+	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
+	for (const candidate of candidates) {
+		let opened;
+		try {
+			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
+		} catch {
+			continue;
+		}
+		const input = opened.handle.createReadStream({
+			autoClose: false,
+			highWaterMark: SESSION_META_READ_CHUNK_BYTES
+		});
+		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
+		try {
+			const chunks = [];
+			let bytesReadTotal = 0;
+			let line;
+			for await (const value of reader) {
+				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
+				if (remaining <= 0) break;
+				const bounded = chunk.subarray(0, remaining);
+				bytesReadTotal += bounded.length;
+				const newline = bounded.indexOf(10);
+				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
+				if (newline >= 0) {
+					line = Buffer.concat(chunks).toString("utf8");
+					break;
+				}
+			}
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
+			const payload = parsed.payload;
+			return payload.id === threadId ? payload : null;
+		} catch {
+			continue;
+		} finally {
+			reader.destroy();
+			input.destroy();
+			await opened.handle.close().catch(() => void 0);
+		}
+	}
+}
+/**
+* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
+* immutable session metadata is the authoritative historical provenance.
+*/
+async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
+	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
+	if (!localSessionsRoot || !rolloutPath) return false;
+	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
+	const cached = provenanceByPath.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
+	const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
+	if (managed !== void 0) cacheProvenance(cacheKey, managed);
+	return managed ?? false;
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use-service-path.ts
 /** Filesystem ownership guards for isolated Computer Use service provisioning. */
 async function assertOwnedServicePath(params) {
@@ -687,7 +797,7 @@ function identitiesMatch(left, right) {
 }
 async function hasExecutableClient(appPath) {
 	try {
-		await fs.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants.X_OK);
+		await fs.access(path.join(appPath, CLIENT_RELATIVE_PATH), constants$1.X_OK);
 		return true;
 	} catch {
 		return false;
@@ -788,21 +898,6 @@ async function copyServiceAppWithDitto(sourcePath, targetPath) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/protocol.ts
-/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
-const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
-function flattenCodexDynamicToolFunctions(tools) {
-	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
-}
-const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
-const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
-function isJsonObject(value) {
-	return isRecord(value);
-}
-function isRpcResponse(message) {
-	return "id" in message && !("method" in message);
-}
-//#endregion
 //#region extensions/codex/src/app-server/auth-bridge.ts
 const CODEX_APP_SERVER_AUTH_PROVIDER = "openai";
 const CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS = [CODEX_APP_SERVER_AUTH_PROVIDER];
@@ -1713,6 +1808,32 @@ function isCodexAppServerClientRuntimeLive(client) {
 	const runtime = configuredClients.get(client);
 	return runtime !== void 0 && !runtime.closed;
 }
+/** Immutable declarations are data owned by this physical client, never retained executors. */
+async function readCodexClientSessionMeta(client, sessionsRoot, boundRolloutPath, threadId) {
+	let rolloutPath = boundRolloutPath;
+	const runtime = configuredClients.get(client);
+	if (!runtime || runtime.closed) throw new Error("Codex native metadata requires a live selected client");
+	const cached = runtime.sessionMetadata.get(threadId);
+	if (cached && cached.sessionsRoot === sessionsRoot && (!rolloutPath || cached.rolloutPath === rolloutPath)) return structuredClone(cached.metadata);
+	if (!rolloutPath) {
+		const { thread } = await client.request("thread/read", {
+			threadId,
+			includeTurns: false
+		});
+		if (thread.id !== threadId || !thread.path) throw new Error("Codex native metadata has no verified thread path");
+		rolloutPath = thread.path;
+	}
+	const metadata = await readCodexSessionMeta(sessionsRoot, rolloutPath, threadId);
+	if (runtime.closed || !metadata) throw new Error("Codex native metadata is unavailable on the selected client");
+	runtime.sessionMetadata.delete(threadId);
+	runtime.sessionMetadata.set(threadId, {
+		sessionsRoot,
+		rolloutPath,
+		metadata
+	});
+	pruneMapToMaxSize(runtime.sessionMetadata, CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE);
+	return structuredClone(metadata);
+}
 /** Installs one auth-refresh handler and one rate-limit observer per physical client. */
 function ensureCodexAppServerClientRuntime(client, context) {
 	const existing = configuredClients.get(client);
@@ -1730,7 +1851,8 @@ function ensureCodexAppServerClientRuntime(client, context) {
 		retainedThreads: /* @__PURE__ */ new Map(),
 		claimedThreads: /* @__PURE__ */ new Map(),
 		releasingThreads: /* @__PURE__ */ new Map(),
-		protectedThreads: /* @__PURE__ */ new Map()
+		protectedThreads: /* @__PURE__ */ new Map(),
+		sessionMetadata: /* @__PURE__ */ new Map()
 	};
 	configuredClients.set(client, runtime);
 	client.addCloseHandler(() => {
@@ -1742,6 +1864,7 @@ function ensureCodexAppServerClientRuntime(client, context) {
 		runtime.retainedThreads.clear();
 		runtime.claimedThreads.clear();
 		runtime.protectedThreads.clear();
+		runtime.sessionMetadata.clear();
 	});
 	client.addRequestHandler(async (request) => {
 		if (request.method !== "account/chatgptAuthTokens/refresh") return;
@@ -1774,6 +1897,7 @@ function ensureCodexAppServerClientRuntime(client, context) {
 				if (releasing) releasing.invalidated = true;
 				runtime.retainedThreads.delete(threadId);
 				runtime.claimedThreads.delete(threadId);
+				runtime.sessionMetadata.delete(threadId);
 				scheduleRetainedThreadEviction(client, runtime);
 			}
 		}
@@ -1822,7 +1946,7 @@ async function releaseRetainedThread(client, runtime, threadId, assertCurrent) {
 		return true;
 	} catch (error) {
 		if (!runtime.closed && !transition.invalidated && runtime.releasingThreads.get(threadId) === transition && !runtime.retainedThreads.has(threadId) && !runtime.claimedThreads.has(threadId)) {
-			retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
+			if (retained.ephemeralPolicy === void 0) retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
 			const newerThreads = [...runtime.retainedThreads.entries()].filter(([candidateThreadId]) => !olderThreadIds.has(candidateThreadId));
 			for (const [candidateThreadId] of newerThreads) runtime.retainedThreads.delete(candidateThreadId);
 			runtime.retainedThreads.set(threadId, retained);
@@ -1840,14 +1964,15 @@ async function evictExpiredRetainedThreads(client, runtime) {
 	scheduleRetainedThreadEviction(client, runtime);
 }
 async function evictExcessIdleThreads(client, runtime) {
-	let idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+	const idleThreads = () => [...runtime.retainedThreads].filter(([threadId, thread]) => thread.ephemeralPolicy === void 0 && !runtime.protectedThreads.has(threadId));
+	let idleThreadIds = idleThreads();
 	while (idleThreadIds.length > CODEX_APP_SERVER_LIVE_THREAD_MAX_IDLE) {
-		await releaseRetainedThread(client, runtime, idleThreadIds[0]);
-		idleThreadIds = [...runtime.retainedThreads.keys()].filter((threadId) => !runtime.protectedThreads.has(threadId));
+		await releaseRetainedThread(client, runtime, idleThreadIds[0][0]);
+		idleThreadIds = idleThreads();
 	}
 }
 /** Retain separately owned Codex subscriptions; completing B must never cold-restart A. */
-async function retainCodexAppServerLiveThread(client, threadId, releaseThread, configFingerprint, serviceTier) {
+async function retainCodexAppServerLiveThread(client, threadId, releaseThread, configFingerprint, serviceTier, ephemeralPolicy) {
 	const runtime = configuredClients.get(client);
 	if (!runtime || runtime.closed) return false;
 	const claimed = runtime.claimedThreads.get(threadId);
@@ -1860,8 +1985,9 @@ async function retainCodexAppServerLiveThread(client, threadId, releaseThread, c
 	runtime.retainedThreads.delete(threadId);
 	const retained = {
 		configFingerprint,
+		ephemeralPolicy,
 		serviceTier,
-		expiresAt: Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS,
+		expiresAt: ephemeralPolicy === void 0 ? Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS : Number.POSITIVE_INFINITY,
 		release: (releaseThread ? physicalThreadReleases.get(releaseThread) ?? releaseThread : void 0) ?? (async (releasedThreadId, assertCurrent) => {
 			await unsubscribeCodexAppServerLiveThread(client, releasedThreadId, 5e3, assertCurrent);
 		})
@@ -1917,17 +2043,26 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 	const claimed = Symbol(threadId);
 	runtime.claimedThreads.set(threadId, claimed);
 	scheduleRetainedThreadEviction(client, runtime);
-	const release = async (releasedThreadId, assertCurrent) => {
-		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) return;
+	const assertCurrent = () => {
+		if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) throw new Error(`Codex thread subscription ownership changed: ${threadId}`);
+	};
+	const release = async (releasedThreadId, assertReleaseCurrent) => {
+		if (releasedThreadId !== threadId || runtime.claimedThreads.get(threadId) !== claimed) {
+			assertReleaseCurrent?.();
+			return;
+		}
 		const pendingRelease = runtime.releasingThreads.get(threadId);
 		if (pendingRelease) {
 			await pendingRelease.completion;
 			return;
 		}
 		const transition = { completion: Promise.resolve().then(async () => {
-			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) return;
-			assertCurrent?.();
-			await (assertCurrent ? retained.release(releasedThreadId, assertCurrent) : retained.release(releasedThreadId));
+			if (runtime.closed || runtime.claimedThreads.get(threadId) !== claimed) {
+				assertReleaseCurrent?.();
+				return;
+			}
+			assertReleaseCurrent?.();
+			await (assertReleaseCurrent ? retained.release(releasedThreadId, assertReleaseCurrent) : retained.release(releasedThreadId));
 		}) };
 		runtime.releasingThreads.set(threadId, transition);
 		try {
@@ -1940,7 +2075,9 @@ function claimCodexAppServerThreadOwnership(client, runtime, threadId, retained)
 	physicalThreadReleases.set(release, retained.release);
 	claimedThreadReleaseTokens.set(release, claimed);
 	return {
+		assertCurrent,
 		configFingerprint: retained.configFingerprint,
+		ephemeralPolicy: retained.ephemeralPolicy,
 		serviceTier: retained.serviceTier,
 		release
 	};
@@ -1966,12 +2103,16 @@ async function unsubscribeCodexAppServerLiveThread(client, threadId, timeoutMs,
 		return;
 	}
 	const physicalRelease = Promise.resolve().then(async () => {
-		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed || retained !== void 0 && runtime?.retainedThreads.get(threadId) !== retained) return;
+		if (claimed !== void 0 && runtime?.claimedThreads.get(threadId) !== claimed || retained !== void 0 && runtime?.retainedThreads.get(threadId) !== retained) {
+			assertCurrent?.();
+			return;
+		}
 		assertCurrent?.();
 		await client.request("thread/unsubscribe", { threadId }, {
 			timeoutMs,
 			assertCurrent
 		});
+		assertCurrent?.();
 	});
 	const ownsTransition = runtime !== void 0 && transition === void 0;
 	if (transition) transition.physicalRelease = physicalRelease;
@@ -2014,7 +2155,7 @@ function protectCodexAppServerLiveThread(client, threadId) {
 			runtime.protectedThreads.delete(threadId);
 			const retained = runtime.retainedThreads.get(threadId);
 			if (retained) {
-				retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
+				if (retained.ephemeralPolicy === void 0) retained.expiresAt = Date.now() + CODEX_APP_SERVER_LIVE_THREAD_IDLE_TIMEOUT_MS;
 				runtime.retainedThreads.delete(threadId);
 				runtime.retainedThreads.set(threadId, retained);
 			}
@@ -2485,6 +2626,2545 @@ function createCodexElicitationResponse(action, content = null, meta = null) {
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/DynamicToolCallParams.json
+var DynamicToolCallParams_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"arguments": true,
+		"callId": { "type": "string" },
+		"namespace": { "type": ["string", "null"] },
+		"threadId": { "type": "string" },
+		"tool": { "type": "string" },
+		"turnId": { "type": "string" }
+	},
+	required: [
+		"arguments",
+		"callId",
+		"threadId",
+		"tool",
+		"turnId"
+	],
+	title: "DynamicToolCallParams",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/CodexAppServerProtocolDefinitions.json
+var definitions = {
+	"AbsolutePathBuf": {
+		"description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.",
+		"type": "string"
+	},
+	"Account": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["apiKey"],
+				"title": "ApiKeyAccountType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "ApiKeyAccount",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"email": { "type": ["string", "null"] },
+				"planType": { "$ref": "#/definitions/PlanType" },
+				"type": {
+					"enum": ["chatgpt"],
+					"title": "ChatgptAccountType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"email",
+				"planType",
+				"type"
+			],
+			"title": "ChatgptAccount",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["amazonBedrock"],
+					"title": "AmazonBedrockAccountType",
+					"type": "string"
+				},
+				"usesCodexManagedCredentials": {
+					"default": false,
+					"type": "boolean"
+				}
+			},
+			"required": ["type"],
+			"title": "AmazonBedrockAccount",
+			"type": "object"
+		}
+	] },
+	"ActivePermissionProfile": {
+		"properties": {
+			"extends": {
+				"default": null,
+				"description": "Parent profile identifier from the selected permissions profile's `extends` setting, when present.",
+				"type": ["string", "null"]
+			},
+			"id": {
+				"description": "Identifier from `default_permissions` or the implicit built-in default, such as `:workspace` or a user-defined `[permissions.<id>]` profile.",
+				"type": "string"
+			}
+		},
+		"required": ["id"],
+		"type": "object"
+	},
+	"AgentMessageDelivery": {
+		"enum": ["async"],
+		"type": "string"
+	},
+	"AgentPath": { "type": "string" },
+	"ApprovalsReviewer": {
+		"description": "Configures who approval requests are routed to for review. Examples include sandbox escapes, blocked network access, MCP approval prompts, and ARC escalations. Defaults to `user`. `auto_review` uses a carefully prompted subagent to gather relevant context and apply a risk-based decision framework before approving or denying the request. The legacy value `guardian_subagent` is accepted for compatibility.",
+		"enum": [
+			"user",
+			"auto_review",
+			"guardian_subagent"
+		],
+		"type": "string"
+	},
+	"AskForApproval": { "oneOf": [{
+		"additionalProperties": false,
+		"properties": { "granular": {
+			"properties": {
+				"mcp_elicitations": { "type": "boolean" },
+				"request_permissions": {
+					"default": false,
+					"type": "boolean"
+				},
+				"rules": { "type": "boolean" },
+				"sandbox_approval": { "type": "boolean" },
+				"skill_approval": {
+					"default": false,
+					"type": "boolean"
+				}
+			},
+			"required": [
+				"mcp_elicitations",
+				"rules",
+				"sandbox_approval"
+			],
+			"type": "object"
+		} },
+		"required": ["granular"],
+		"title": "GranularAskForApproval",
+		"type": "object"
+	}, {
+		"enum": [
+			"untrusted",
+			"on-request",
+			"never"
+		],
+		"type": "string"
+	}] },
+	"ByteRange": {
+		"properties": {
+			"end": {
+				"format": "uint",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"start": {
+				"format": "uint",
+				"minimum": 0,
+				"type": "integer"
+			}
+		},
+		"required": ["end", "start"],
+		"type": "object"
+	},
+	"CodexErrorInfo": {
+		"description": "This translation layer make sure that we expose codex error code in camel case.\n\nWhen an upstream HTTP status is available (for example, from the Responses API or a provider), it is forwarded in `httpStatusCode` on the relevant `codexErrorInfo` variant.",
+		"oneOf": [
+			{
+				"additionalProperties": false,
+				"properties": { "httpConnectionFailed": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["httpConnectionFailed"],
+				"title": "HttpConnectionFailedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Failed to connect to the response SSE stream.",
+				"properties": { "responseStreamConnectionFailed": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseStreamConnectionFailed"],
+				"title": "ResponseStreamConnectionFailedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "The response SSE stream disconnected in the middle of a turn before completion.",
+				"properties": { "responseStreamDisconnected": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseStreamDisconnected"],
+				"title": "ResponseStreamDisconnectedCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Reached the retry limit for responses.",
+				"properties": { "responseTooManyFailedAttempts": {
+					"properties": { "httpStatusCode": {
+						"format": "uint16",
+						"minimum": 0,
+						"type": ["integer", "null"]
+					} },
+					"type": "object"
+				} },
+				"required": ["responseTooManyFailedAttempts"],
+				"title": "ResponseTooManyFailedAttemptsCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"additionalProperties": false,
+				"description": "Returned when `turn/start` or `turn/steer` is submitted while the current active turn cannot accept same-turn steering, for example `/review` or manual `/compact`.",
+				"properties": { "activeTurnNotSteerable": {
+					"properties": { "turnKind": { "$ref": "#/definitions/NonSteerableTurnKind" } },
+					"required": ["turnKind"],
+					"type": "object"
+				} },
+				"required": ["activeTurnNotSteerable"],
+				"title": "ActiveTurnNotSteerableCodexErrorInfo",
+				"type": "object"
+			},
+			{
+				"enum": [
+					"contextWindowExceeded",
+					"sessionBudgetExceeded",
+					"usageLimitExceeded",
+					"rateLimitExceeded",
+					"serverOverloaded",
+					"cyberPolicy",
+					"misalignmentPolicyViolation",
+					"internalServerError",
+					"unauthorized",
+					"badRequest",
+					"threadRollbackFailed",
+					"sandboxError",
+					"other"
+				],
+				"type": "string"
+			}
+		]
+	},
+	"CollabAgentState": {
+		"properties": {
+			"message": { "type": ["string", "null"] },
+			"status": { "$ref": "#/definitions/CollabAgentStatus" }
+		},
+		"required": ["status"],
+		"type": "object"
+	},
+	"CollabAgentStatus": {
+		"enum": [
+			"pendingInit",
+			"running",
+			"interrupted",
+			"completed",
+			"errored",
+			"shutdown",
+			"notFound"
+		],
+		"type": "string"
+	},
+	"CollabAgentTool": {
+		"enum": [
+			"spawnAgent",
+			"sendInput",
+			"resumeAgent",
+			"wait",
+			"closeAgent",
+			"sendMessage",
+			"followupTask",
+			"interruptAgent",
+			"listAgents"
+		],
+		"type": "string"
+	},
+	"CollabAgentToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"interrupted"
+		],
+		"type": "string"
+	},
+	"CommandAction": { "oneOf": [
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"name": { "type": "string" },
+				"path": { "$ref": "#/definitions/LegacyAppPathString" },
+				"type": {
+					"enum": ["read"],
+					"title": "ReadCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"command",
+				"name",
+				"path",
+				"type"
+			],
+			"title": "ReadCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"path": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["listFiles"],
+					"title": "ListFilesCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "ListFilesCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"path": { "type": ["string", "null"] },
+				"query": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["search"],
+					"title": "SearchCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "SearchCommandAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"command": { "type": "string" },
+				"type": {
+					"enum": ["unknown"],
+					"title": "UnknownCommandActionType",
+					"type": "string"
+				}
+			},
+			"required": ["command", "type"],
+			"title": "UnknownCommandAction",
+			"type": "object"
+		}
+	] },
+	"CommandExecutionSource": {
+		"enum": [
+			"agent",
+			"userShell",
+			"unifiedExecStartup",
+			"unifiedExecInteraction"
+		],
+		"type": "string"
+	},
+	"CommandExecutionStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"declined"
+		],
+		"type": "string"
+	},
+	"DynamicToolCallOutputContentItem": { "oneOf": [
+		{
+			"properties": {
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["inputText"],
+					"title": "InputTextDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["text", "type"],
+			"title": "InputTextDynamicToolCallOutputContentItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"imageUrl": { "type": "string" },
+				"type": {
+					"enum": ["inputImage"],
+					"title": "InputImageDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["imageUrl", "type"],
+			"title": "InputImageDynamicToolCallOutputContentItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"audioUrl": { "type": "string" },
+				"type": {
+					"enum": ["inputAudio"],
+					"title": "InputAudioDynamicToolCallOutputContentItemType",
+					"type": "string"
+				}
+			},
+			"required": ["audioUrl", "type"],
+			"title": "InputAudioDynamicToolCallOutputContentItem",
+			"type": "object"
+		}
+	] },
+	"DynamicToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed"
+		],
+		"type": "string"
+	},
+	"FileUpdateChange": {
+		"properties": {
+			"diff": { "type": "string" },
+			"kind": { "$ref": "#/definitions/PatchChangeKind" },
+			"path": { "type": "string" }
+		},
+		"required": [
+			"diff",
+			"kind",
+			"path"
+		],
+		"type": "object"
+	},
+	"FunctionCallOutputBody": { "anyOf": [{
+		"items": { "$ref": "#/definitions/FunctionCallOutputContentItem" },
+		"type": "array"
+	}, { "type": "string" }] },
+	"FunctionCallOutputContentItem": {
+		"description": "Responses API compatible content items that can be returned by a tool call. This is a subset of ContentItem with the types we support as function call outputs.",
+		"oneOf": [
+			{
+				"properties": {
+					"text": { "type": "string" },
+					"type": {
+						"enum": ["input_text"],
+						"title": "InputTextFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["text", "type"],
+				"title": "InputTextFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"detail": { "anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }] },
+					"image_url": { "type": "string" },
+					"type": {
+						"enum": ["input_image"],
+						"title": "InputImageFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["image_url", "type"],
+				"title": "InputImageFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"audio_url": { "type": "string" },
+					"type": {
+						"enum": ["input_audio"],
+						"title": "InputAudioFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["audio_url", "type"],
+				"title": "InputAudioFunctionCallOutputContentItem",
+				"type": "object"
+			},
+			{
+				"properties": {
+					"encrypted_content": { "type": "string" },
+					"type": {
+						"enum": ["encrypted_content"],
+						"title": "EncryptedContentFunctionCallOutputContentItemType",
+						"type": "string"
+					}
+				},
+				"required": ["encrypted_content", "type"],
+				"title": "EncryptedContentFunctionCallOutputContentItem",
+				"type": "object"
+			}
+		]
+	},
+	"GitInfo": {
+		"properties": {
+			"branch": { "type": ["string", "null"] },
+			"originUrl": { "type": ["string", "null"] },
+			"sha": { "type": ["string", "null"] }
+		},
+		"type": "object"
+	},
+	"HookPromptFragment": {
+		"properties": {
+			"hookRunId": { "type": "string" },
+			"text": { "type": "string" }
+		},
+		"required": ["hookRunId", "text"],
+		"type": "object"
+	},
+	"ImageDetail": {
+		"enum": [
+			"auto",
+			"low",
+			"high",
+			"original"
+		],
+		"type": "string"
+	},
+	"ImageGenerationFailure": { "oneOf": [{
+		"properties": {
+			"limitId": { "type": "string" },
+			"resetsAt": {
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"type": {
+				"enum": ["usageLimitExceeded"],
+				"title": "UsageLimitExceededImageGenerationFailureType",
+				"type": "string"
+			}
+		},
+		"required": ["limitId", "type"],
+		"title": "UsageLimitExceededImageGenerationFailure",
+		"type": "object"
+	}] },
+	"InputModality": {
+		"description": "Canonical user-input modality tags advertised by a model.",
+		"oneOf": [
+			{
+				"description": "Plain text turns and tool payloads.",
+				"enum": ["text"],
+				"type": "string"
+			},
+			{
+				"description": "Image attachments included in user turns.",
+				"enum": ["image"],
+				"type": "string"
+			},
+			{
+				"description": "Audio attachments included in user turns.",
+				"enum": ["audio"],
+				"type": "string"
+			}
+		]
+	},
+	"LegacyAppPathString": { "type": "string" },
+	"McpToolCallAppContext": {
+		"properties": {
+			"actionName": { "type": ["string", "null"] },
+			"appName": { "type": ["string", "null"] },
+			"connectorId": { "type": "string" },
+			"linkId": { "type": ["string", "null"] },
+			"resourceUri": { "type": ["string", "null"] }
+		},
+		"required": ["connectorId"],
+		"type": "object"
+	},
+	"McpToolCallError": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"McpToolCallResult": {
+		"properties": {
+			"_meta": true,
+			"content": {
+				"items": true,
+				"type": "array"
+			},
+			"structuredContent": true
+		},
+		"required": ["content"],
+		"type": "object"
+	},
+	"McpToolCallStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed"
+		],
+		"type": "string"
+	},
+	"MemoryCitation": {
+		"properties": {
+			"entries": {
+				"items": { "$ref": "#/definitions/MemoryCitationEntry" },
+				"type": "array"
+			},
+			"threadIds": {
+				"items": { "type": "string" },
+				"type": "array"
+			}
+		},
+		"required": ["entries", "threadIds"],
+		"type": "object"
+	},
+	"MemoryCitationEntry": {
+		"properties": {
+			"lineEnd": {
+				"format": "uint32",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"lineStart": {
+				"format": "uint32",
+				"minimum": 0,
+				"type": "integer"
+			},
+			"note": { "type": "string" },
+			"path": { "type": "string" }
+		},
+		"required": [
+			"lineEnd",
+			"lineStart",
+			"note",
+			"path"
+		],
+		"type": "object"
+	},
+	"MessagePhase": {
+		"description": "Classifies an assistant message as interim commentary or final answer text.\n\nProviders do not emit this consistently, so callers must treat `None` as \"phase unknown\" and keep compatibility behavior for legacy models.",
+		"oneOf": [{
+			"description": "Mid-turn assistant text (for example preamble/progress narration).\n\nAdditional tool calls or assistant output may follow before turn completion.",
+			"enum": ["commentary"],
+			"type": "string"
+		}, {
+			"description": "The assistant's terminal answer text for the current turn.",
+			"enum": ["final_answer"],
+			"type": "string"
+		}]
+	},
+	"MisalignmentErrorDetails": {
+		"properties": {
+			"detailedExplanation": {
+				"description": "A substantive localized explanation is required before offering continuation.",
+				"type": ["string", "null"]
+			},
+			"errorType": {
+				"description": "Open-ended classification; clients must accept categories added by Responses.",
+				"type": ["string", "null"]
+			},
+			"steer": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentSteer" }, { "type": "null" }],
+				"description": "Instruction to submit as the next turn's user input if continuation is confirmed."
+			}
+		},
+		"type": "object"
+	},
+	"MisalignmentSteer": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"Model": {
+		"properties": {
+			"additionalSpeedTiers": {
+				"default": [],
+				"description": "Deprecated: use `serviceTiers` instead.",
+				"items": { "type": "string" },
+				"type": "array"
+			},
+			"availabilityNux": { "anyOf": [{ "$ref": "#/definitions/ModelAvailabilityNux" }, { "type": "null" }] },
+			"defaultReasoningEffort": { "$ref": "#/definitions/ReasoningEffort" },
+			"defaultServiceTier": {
+				"default": null,
+				"description": "Catalog default service tier id for this model, when one is configured.",
+				"type": ["string", "null"]
+			},
+			"description": { "type": "string" },
+			"displayName": { "type": "string" },
+			"hidden": { "type": "boolean" },
+			"id": { "type": "string" },
+			"inputModalities": {
+				"default": ["text", "image"],
+				"items": { "$ref": "#/definitions/InputModality" },
+				"type": "array"
+			},
+			"isDefault": { "type": "boolean" },
+			"model": { "type": "string" },
+			"modelSpecialty": {
+				"default": null,
+				"type": ["string", "null"]
+			},
+			"multiAgentVersion": {
+				"anyOf": [{ "$ref": "#/definitions/MultiAgentVersion" }, { "type": "null" }],
+				"description": "Multi-agent runtime declared by this model, when available."
+			},
+			"serviceTiers": {
+				"default": [],
+				"items": { "$ref": "#/definitions/ModelServiceTier" },
+				"type": "array"
+			},
+			"supportedReasoningEfforts": {
+				"items": { "$ref": "#/definitions/ReasoningEffortOption" },
+				"type": "array"
+			},
+			"supportsPersonality": {
+				"default": false,
+				"type": "boolean"
+			},
+			"upgrade": { "type": ["string", "null"] },
+			"upgradeInfo": { "anyOf": [{ "$ref": "#/definitions/ModelUpgradeInfo" }, { "type": "null" }] }
+		},
+		"required": [
+			"defaultReasoningEffort",
+			"description",
+			"displayName",
+			"hidden",
+			"id",
+			"isDefault",
+			"model",
+			"supportedReasoningEfforts"
+		],
+		"type": "object"
+	},
+	"ModelAvailabilityNux": {
+		"properties": { "message": { "type": "string" } },
+		"required": ["message"],
+		"type": "object"
+	},
+	"ModelServiceTier": {
+		"properties": {
+			"description": { "type": "string" },
+			"id": { "type": "string" },
+			"name": { "type": "string" }
+		},
+		"required": [
+			"description",
+			"id",
+			"name"
+		],
+		"type": "object"
+	},
+	"ModelUpgradeInfo": {
+		"properties": {
+			"migrationMarkdown": { "type": ["string", "null"] },
+			"model": { "type": "string" },
+			"modelLink": { "type": ["string", "null"] },
+			"retirementAt": {
+				"description": "Informational Unix timestamp for this upgrade's scheduled retirement, if known.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"upgradeCopy": { "type": ["string", "null"] }
+		},
+		"required": ["model"],
+		"type": "object"
+	},
+	"MultiAgentMode": {
+		"description": "Controls the effective multi-agent delegation instructions for a turn. `custom` means the configured mode hint defines the policy instead of a built-in policy.",
+		"oneOf": [{
+			"additionalProperties": false,
+			"properties": { "custom": { "type": "string" } },
+			"required": ["custom"],
+			"title": "CustomMultiAgentMode",
+			"type": "object"
+		}, {
+			"enum": ["explicitRequestOnly", "proactive"],
+			"type": "string"
+		}]
+	},
+	"MultiAgentVersion": {
+		"description": "Multi-agent runtime supported by a model.",
+		"enum": [
+			"disabled",
+			"v1",
+			"v2"
+		],
+		"type": "string"
+	},
+	"NetworkAccess": {
+		"enum": ["restricted", "enabled"],
+		"type": "string"
+	},
+	"NonSteerableTurnKind": {
+		"enum": ["review", "compact"],
+		"type": "string"
+	},
+	"PatchApplyStatus": {
+		"enum": [
+			"inProgress",
+			"completed",
+			"failed",
+			"declined"
+		],
+		"type": "string"
+	},
+	"PatchChangeKind": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["add"],
+				"title": "AddPatchChangeKindType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "AddPatchChangeKind",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["delete"],
+				"title": "DeletePatchChangeKindType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "DeletePatchChangeKind",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"move_path": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["update"],
+					"title": "UpdatePatchChangeKindType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "UpdatePatchChangeKind",
+			"type": "object"
+		}
+	] },
+	"PlanType": {
+		"enum": [
+			"free",
+			"go",
+			"plus",
+			"pro",
+			"prolite",
+			"team",
+			"self_serve_business_prolite",
+			"self_serve_business_usage_based",
+			"business",
+			"ent26",
+			"enterprise_cbp_automation",
+			"enterprise_cbp_usage_based",
+			"enterprise",
+			"edu",
+			"edu_plus",
+			"edu_pro",
+			"unknown"
+		],
+		"type": "string"
+	},
+	"ReasoningEffort": {
+		"description": "A non-empty reasoning effort value advertised by the model.",
+		"minLength": 1,
+		"type": "string"
+	},
+	"ReasoningEffortOption": {
+		"properties": {
+			"description": { "type": "string" },
+			"reasoningEffort": { "$ref": "#/definitions/ReasoningEffort" }
+		},
+		"required": ["description", "reasoningEffort"],
+		"type": "object"
+	},
+	"SandboxPolicy": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["dangerFullAccess"],
+				"title": "DangerFullAccessSandboxPolicyType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "DangerFullAccessSandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"networkAccess": {
+					"default": false,
+					"type": "boolean"
+				},
+				"type": {
+					"enum": ["readOnly"],
+					"title": "ReadOnlySandboxPolicyType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "ReadOnlySandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"networkAccess": {
+					"allOf": [{ "$ref": "#/definitions/NetworkAccess" }],
+					"default": "restricted"
+				},
+				"type": {
+					"enum": ["externalSandbox"],
+					"title": "ExternalSandboxSandboxPolicyType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "ExternalSandboxSandboxPolicy",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"excludeSlashTmp": {
+					"default": false,
+					"type": "boolean"
+				},
+				"excludeTmpdirEnvVar": {
+					"default": false,
+					"type": "boolean"
+				},
+				"networkAccess": {
+					"default": false,
+					"type": "boolean"
+				},
+				"type": {
+					"enum": ["workspaceWrite"],
+					"title": "WorkspaceWriteSandboxPolicyType",
+					"type": "string"
+				},
+				"writableRoots": {
+					"default": [],
+					"items": { "$ref": "#/definitions/AbsolutePathBuf" },
+					"type": "array"
+				}
+			},
+			"required": ["type"],
+			"title": "WorkspaceWriteSandboxPolicy",
+			"type": "object"
+		}
+	] },
+	"SessionSource": { "oneOf": [
+		{
+			"additionalProperties": false,
+			"properties": { "custom": { "type": "string" } },
+			"required": ["custom"],
+			"title": "CustomSessionSource",
+			"type": "object"
+		},
+		{
+			"additionalProperties": false,
+			"properties": { "subAgent": { "$ref": "#/definitions/SubAgentSource" } },
+			"required": ["subAgent"],
+			"title": "SubAgentSessionSource",
+			"type": "object"
+		},
+		{
+			"enum": [
+				"cli",
+				"vscode",
+				"exec",
+				"appServer",
+				"unknown"
+			],
+			"type": "string"
+		}
+	] },
+	"SubAgentActivityKind": {
+		"enum": [
+			"started",
+			"interacted",
+			"interrupted",
+			"completed"
+		],
+		"type": "string"
+	},
+	"SubAgentSource": { "oneOf": [
+		{
+			"additionalProperties": false,
+			"properties": { "thread_spawn": {
+				"properties": {
+					"agent_nickname": {
+						"default": null,
+						"type": ["string", "null"]
+					},
+					"agent_path": {
+						"anyOf": [{ "$ref": "#/definitions/AgentPath" }, { "type": "null" }],
+						"default": null
+					},
+					"agent_role": {
+						"default": null,
+						"type": ["string", "null"]
+					},
+					"depth": {
+						"format": "int32",
+						"type": "integer"
+					},
+					"parent_thread_id": { "$ref": "#/definitions/ThreadId" }
+				},
+				"required": ["depth", "parent_thread_id"],
+				"type": "object"
+			} },
+			"required": ["thread_spawn"],
+			"title": "ThreadSpawnSubAgentSource",
+			"type": "object"
+		},
+		{
+			"additionalProperties": false,
+			"properties": { "other": { "type": "string" } },
+			"required": ["other"],
+			"title": "OtherSubAgentSource",
+			"type": "object"
+		},
+		{
+			"enum": [
+				"review",
+				"compact",
+				"memory_consolidation"
+			],
+			"type": "string"
+		}
+	] },
+	"TextElement": {
+		"properties": {
+			"byteRange": {
+				"allOf": [{ "$ref": "#/definitions/ByteRange" }],
+				"description": "Byte range in the parent `text` buffer that this element occupies."
+			},
+			"placeholder": {
+				"description": "Optional human-readable placeholder for the element, displayed in the UI.",
+				"type": ["string", "null"]
+			}
+		},
+		"required": ["byteRange"],
+		"type": "object"
+	},
+	"Thread": {
+		"properties": {
+			"agentNickname": {
+				"description": "Optional random unique nickname assigned to an AgentControl-spawned sub-agent.",
+				"type": ["string", "null"]
+			},
+			"agentRole": {
+				"description": "Optional role (agent_role) assigned to an AgentControl-spawned sub-agent.",
+				"type": ["string", "null"]
+			},
+			"canAcceptDirectInput": {
+				"description": "Whether the app server accepts direct turn input for this loaded thread. `None` means the capability is unavailable, such as for an unloaded stored thread.",
+				"type": ["boolean", "null"]
+			},
+			"cliVersion": {
+				"description": "Version of the CLI that created the thread.",
+				"type": "string"
+			},
+			"createdAt": {
+				"description": "Unix timestamp (in seconds) when the thread was created.",
+				"format": "int64",
+				"type": "integer"
+			},
+			"cwd": {
+				"allOf": [{ "$ref": "#/definitions/AbsolutePathBuf" }],
+				"description": "Working directory captured for the thread."
+			},
+			"ephemeral": {
+				"description": "Whether the thread is ephemeral and should not be materialized on disk.",
+				"type": "boolean"
+			},
+			"extra": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadExtra" }, { "type": "null" }],
+				"description": "Optional implementation-specific thread data."
+			},
+			"forkedFromId": {
+				"description": "Source thread id when this thread was created by forking another thread.",
+				"type": ["string", "null"]
+			},
+			"gitInfo": {
+				"anyOf": [{ "$ref": "#/definitions/GitInfo" }, { "type": "null" }],
+				"description": "Optional Git metadata captured when the thread was created."
+			},
+			"historyMode": {
+				"allOf": [{ "$ref": "#/definitions/ThreadHistoryMode" }],
+				"default": "legacy",
+				"description": "Persisted thread history contract selected when this thread was created."
+			},
+			"id": {
+				"description": "Identifier for this thread. Codex-generated thread IDs are UUIDv7.",
+				"type": "string"
+			},
+			"modelProvider": {
+				"description": "Model provider used for this thread (for example, 'openai').",
+				"type": "string"
+			},
+			"name": {
+				"description": "Optional user-facing thread title.",
+				"type": ["string", "null"]
+			},
+			"parentThreadId": {
+				"description": "The ID of the parent thread. This will only be set if this thread is a subagent.",
+				"type": ["string", "null"]
+			},
+			"path": {
+				"description": "[UNSTABLE] Path to the thread on disk.",
+				"type": ["string", "null"]
+			},
+			"preview": {
+				"description": "Usually the first user message in the thread, if available.",
+				"type": "string"
+			},
+			"projectId": {
+				"description": "Canonical project assignment owned by app-server, if any.",
+				"type": ["string", "null"]
+			},
+			"recencyAt": {
+				"description": "Unix timestamp (in seconds) used for thread recency ordering.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"section": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSection" }, { "type": "null" }],
+				"default": null,
+				"description": "The independently persisted section selected for this thread, if any."
+			},
+			"sectionEnteredAt": {
+				"default": null,
+				"description": "Unix timestamp in seconds when the thread entered its current section.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"sessionId": {
+				"description": "Session id shared by threads that belong to the same session tree.",
+				"type": "string"
+			},
+			"source": {
+				"allOf": [{ "$ref": "#/definitions/SessionSource" }],
+				"description": "Origin of the thread (CLI, VSCode, codex exec, codex app-server, etc.)."
+			},
+			"status": {
+				"allOf": [{ "$ref": "#/definitions/ThreadStatus" }],
+				"description": "Current runtime status for the thread."
+			},
+			"threadSource": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSource" }, { "type": "null" }],
+				"description": "Optional analytics source classification for this thread."
+			},
+			"turns": {
+				"description": "Only populated on `thread/resume`, `thread/rollback`, `thread/fork`, and `thread/read` (when `includeTurns` is true) responses. For all other responses and notifications returning a Thread, the turns field will be an empty list.",
+				"items": { "$ref": "#/definitions/Turn" },
+				"type": "array"
+			},
+			"updatedAt": {
+				"description": "Unix timestamp (in seconds) when the thread was last updated.",
+				"format": "int64",
+				"type": "integer"
+			}
+		},
+		"required": [
+			"cliVersion",
+			"createdAt",
+			"cwd",
+			"ephemeral",
+			"id",
+			"modelProvider",
+			"preview",
+			"projectId",
+			"sessionId",
+			"source",
+			"status",
+			"turns",
+			"updatedAt"
+		],
+		"type": "object"
+	},
+	"ThreadActiveFlag": {
+		"enum": ["waitingOnApproval", "waitingOnUserInput"],
+		"type": "string"
+	},
+	"ThreadExtra": {
+		"description": "Extra app-server data for a thread.",
+		"type": "object"
+	},
+	"ThreadHistoryMode": {
+		"enum": ["legacy", "paginated"],
+		"type": "string"
+	},
+	"ThreadId": { "type": "string" },
+	"ThreadItem": { "oneOf": [
+		{
+			"properties": {
+				"clientId": { "type": ["string", "null"] },
+				"content": {
+					"items": { "$ref": "#/definitions/UserInput" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["userMessage"],
+					"title": "UserMessageThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"content",
+				"id",
+				"type"
+			],
+			"title": "UserMessageThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"fragments": {
+					"items": { "$ref": "#/definitions/HookPromptFragment" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["hookPrompt"],
+					"title": "HookPromptThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"fragments",
+				"id",
+				"type"
+			],
+			"title": "HookPromptThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"delivery": {
+					"anyOf": [{ "$ref": "#/definitions/AgentMessageDelivery" }, { "type": "null" }],
+					"default": null
+				},
+				"id": { "type": "string" },
+				"memoryCitation": {
+					"anyOf": [{ "$ref": "#/definitions/MemoryCitation" }, { "type": "null" }],
+					"default": null
+				},
+				"phase": {
+					"anyOf": [{ "$ref": "#/definitions/MessagePhase" }, { "type": "null" }],
+					"default": null
+				},
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["agentMessage"],
+					"title": "AgentMessageThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"text",
+				"type"
+			],
+			"title": "AgentMessageThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"name": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"output": { "$ref": "#/definitions/FunctionCallOutputBody" },
+				"type": {
+					"enum": ["functionCallOutput"],
+					"title": "FunctionCallOutputThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"name",
+				"output",
+				"type"
+			],
+			"title": "FunctionCallOutputThreadItem",
+			"type": "object"
+		},
+		{
+			"description": "EXPERIMENTAL - proposed plan item content. The completed plan item is authoritative and may not match the concatenation of `PlanDelta` text.",
+			"properties": {
+				"id": { "type": "string" },
+				"text": { "type": "string" },
+				"type": {
+					"enum": ["plan"],
+					"title": "PlanThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"text",
+				"type"
+			],
+			"title": "PlanThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"content": {
+					"default": [],
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"summary": {
+					"default": [],
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["reasoning"],
+					"title": "ReasoningThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": ["id", "type"],
+			"title": "ReasoningThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"aggregatedOutput": {
+					"description": "The command's output, aggregated from stdout and stderr.",
+					"type": ["string", "null"]
+				},
+				"command": {
+					"description": "The command to be executed.",
+					"type": "string"
+				},
+				"commandActions": {
+					"description": "A best-effort parsing of the command to understand the action(s) it will perform. This returns a list of CommandAction objects because a single shell command may be composed of many commands piped together.",
+					"items": { "$ref": "#/definitions/CommandAction" },
+					"type": "array"
+				},
+				"cwd": {
+					"allOf": [{ "$ref": "#/definitions/LegacyAppPathString" }],
+					"description": "The command's working directory."
+				},
+				"durationMs": {
+					"description": "The duration of the command execution in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"exitCode": {
+					"description": "The command's exit code.",
+					"format": "int32",
+					"type": ["integer", "null"]
+				},
+				"id": { "type": "string" },
+				"pluginId": {
+					"default": null,
+					"description": "Trusted first-party plugin id when this command resolves to one plugin script.",
+					"type": ["string", "null"]
+				},
+				"processId": {
+					"description": "Identifier for the underlying PTY process (when available).",
+					"type": ["string", "null"]
+				},
+				"scriptPath": {
+					"default": null,
+					"description": "Safe plugin-relative path when this command resolves to one plugin script.",
+					"type": ["string", "null"]
+				},
+				"source": {
+					"allOf": [{ "$ref": "#/definitions/CommandExecutionSource" }],
+					"default": "agent"
+				},
+				"status": { "$ref": "#/definitions/CommandExecutionStatus" },
+				"type": {
+					"enum": ["commandExecution"],
+					"title": "CommandExecutionThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"command",
+				"commandActions",
+				"cwd",
+				"id",
+				"status",
+				"type"
+			],
+			"title": "CommandExecutionThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"changes": {
+					"items": { "$ref": "#/definitions/FileUpdateChange" },
+					"type": "array"
+				},
+				"id": { "type": "string" },
+				"status": { "$ref": "#/definitions/PatchApplyStatus" },
+				"type": {
+					"enum": ["fileChange"],
+					"title": "FileChangeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"changes",
+				"id",
+				"status",
+				"type"
+			],
+			"title": "FileChangeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"appContext": { "anyOf": [{ "$ref": "#/definitions/McpToolCallAppContext" }, { "type": "null" }] },
+				"arguments": true,
+				"durationMs": {
+					"description": "The duration of the MCP tool call in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"error": { "anyOf": [{ "$ref": "#/definitions/McpToolCallError" }, { "type": "null" }] },
+				"id": { "type": "string" },
+				"mcpAppResourceUri": {
+					"description": "Deprecated: use `appContext.resourceUri` instead.",
+					"type": ["string", "null"]
+				},
+				"pluginId": { "type": ["string", "null"] },
+				"readOnlyHint": { "type": ["boolean", "null"] },
+				"result": { "anyOf": [{ "$ref": "#/definitions/McpToolCallResult" }, { "type": "null" }] },
+				"server": { "type": "string" },
+				"status": { "$ref": "#/definitions/McpToolCallStatus" },
+				"tool": { "type": "string" },
+				"type": {
+					"enum": ["mcpToolCall"],
+					"title": "McpToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"arguments",
+				"id",
+				"server",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "McpToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"arguments": true,
+				"contentItems": {
+					"items": { "$ref": "#/definitions/DynamicToolCallOutputContentItem" },
+					"type": ["array", "null"]
+				},
+				"durationMs": {
+					"description": "The duration of the dynamic tool call in milliseconds.",
+					"format": "int64",
+					"type": ["integer", "null"]
+				},
+				"id": { "type": "string" },
+				"namespace": { "type": ["string", "null"] },
+				"status": { "$ref": "#/definitions/DynamicToolCallStatus" },
+				"success": { "type": ["boolean", "null"] },
+				"tool": { "type": "string" },
+				"type": {
+					"enum": ["dynamicToolCall"],
+					"title": "DynamicToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"arguments",
+				"id",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "DynamicToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"agentsStates": {
+					"additionalProperties": { "$ref": "#/definitions/CollabAgentState" },
+					"description": "Last known status of the target agents, when available.",
+					"type": "object"
+				},
+				"id": {
+					"description": "Unique identifier for this collab tool call.",
+					"type": "string"
+				},
+				"model": {
+					"description": "Model requested for the spawned agent, when applicable.",
+					"type": ["string", "null"]
+				},
+				"prompt": {
+					"description": "Prompt text sent as part of the collab tool call, when available.",
+					"type": ["string", "null"]
+				},
+				"reasoningEffort": {
+					"anyOf": [{ "$ref": "#/definitions/ReasoningEffort" }, { "type": "null" }],
+					"description": "Reasoning effort requested for the spawned agent, when applicable."
+				},
+				"receiverThreadIds": {
+					"description": "Thread ID of the receiving agent, when applicable. In case of spawn operation, this corresponds to the newly spawned agent.",
+					"items": { "type": "string" },
+					"type": "array"
+				},
+				"senderThreadId": {
+					"description": "Thread ID of the agent issuing the collab request.",
+					"type": "string"
+				},
+				"status": {
+					"allOf": [{ "$ref": "#/definitions/CollabAgentToolCallStatus" }],
+					"description": "Current status of the collab tool call."
+				},
+				"tool": {
+					"allOf": [{ "$ref": "#/definitions/CollabAgentTool" }],
+					"description": "Name of the collab tool that was invoked."
+				},
+				"type": {
+					"enum": ["collabAgentToolCall"],
+					"title": "CollabAgentToolCallThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"agentsStates",
+				"id",
+				"receiverThreadIds",
+				"senderThreadId",
+				"status",
+				"tool",
+				"type"
+			],
+			"title": "CollabAgentToolCallThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"agentPath": { "type": "string" },
+				"agentThreadId": { "type": "string" },
+				"id": { "type": "string" },
+				"kind": { "$ref": "#/definitions/SubAgentActivityKind" },
+				"type": {
+					"enum": ["subAgentActivity"],
+					"title": "SubAgentActivityThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"agentPath",
+				"agentThreadId",
+				"id",
+				"kind",
+				"type"
+			],
+			"title": "SubAgentActivityThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"action": { "anyOf": [{ "$ref": "#/definitions/WebSearchAction" }, { "type": "null" }] },
+				"id": { "type": "string" },
+				"query": { "type": "string" },
+				"results": {
+					"default": null,
+					"description": "Structured search results returned out-of-band by standalone web search.\n\nThese stay as opaque JSON at the extension/app-server boundary so new result fields and result types can pass through without a Codex release.",
+					"items": true,
+					"type": ["array", "null"]
+				},
+				"type": {
+					"enum": ["webSearch"],
+					"title": "WebSearchThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"query",
+				"type"
+			],
+			"title": "WebSearchThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"path": { "$ref": "#/definitions/LegacyAppPathString" },
+				"type": {
+					"enum": ["imageView"],
+					"title": "ImageViewThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"path",
+				"type"
+			],
+			"title": "ImageViewThreadItem",
+			"type": "object"
+		},
+		{
+			"description": "Display item emitted by the interruptible `clock.sleep` tool.",
+			"properties": {
+				"durationMs": {
+					"format": "uint64",
+					"minimum": 0,
+					"type": "integer"
+				},
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["sleep"],
+					"title": "SleepThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"durationMs",
+				"id",
+				"type"
+			],
+			"title": "SleepThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"failure": {
+					"anyOf": [{ "$ref": "#/definitions/ImageGenerationFailure" }, { "type": "null" }],
+					"default": null
+				},
+				"id": { "type": "string" },
+				"result": { "type": "string" },
+				"revisedPrompt": { "type": ["string", "null"] },
+				"savedPath": { "anyOf": [{ "$ref": "#/definitions/AbsolutePathBuf" }, { "type": "null" }] },
+				"status": { "type": "string" },
+				"transparentBackground": {
+					"default": null,
+					"type": ["boolean", "null"]
+				},
+				"type": {
+					"enum": ["imageGeneration"],
+					"title": "ImageGenerationThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"result",
+				"status",
+				"type"
+			],
+			"title": "ImageGenerationThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"review": { "type": "string" },
+				"type": {
+					"enum": ["enteredReviewMode"],
+					"title": "EnteredReviewModeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"review",
+				"type"
+			],
+			"title": "EnteredReviewModeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"review": { "type": "string" },
+				"type": {
+					"enum": ["exitedReviewMode"],
+					"title": "ExitedReviewModeThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"id",
+				"review",
+				"type"
+			],
+			"title": "ExitedReviewModeThreadItem",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"id": { "type": "string" },
+				"type": {
+					"enum": ["contextCompaction"],
+					"title": "ContextCompactionThreadItemType",
+					"type": "string"
+				}
+			},
+			"required": ["id", "type"],
+			"title": "ContextCompactionThreadItem",
+			"type": "object"
+		}
+	] },
+	"ThreadSection": {
+		"description": "An independently persisted, user-visible thread section.",
+		"properties": {
+			"appearance": {
+				"anyOf": [{ "$ref": "#/definitions/ThreadSectionAppearance" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional appearance synchronized across clients."
+			},
+			"id": {
+				"description": "Opaque UUIDv7 identity that remains stable when the section is renamed.",
+				"type": "string"
+			},
+			"name": {
+				"description": "The current user-visible section name.",
+				"type": "string"
+			}
+		},
+		"required": ["id", "name"],
+		"type": "object"
+	},
+	"ThreadSectionAppearance": {
+		"description": "Extensible visual presentation for a custom thread section.",
+		"properties": {
+			"color": { "type": ["string", "null"] },
+			"icon": { "type": ["string", "null"] }
+		},
+		"type": "object"
+	},
+	"ThreadSource": { "type": "string" },
+	"ThreadStatus": { "oneOf": [
+		{
+			"properties": { "type": {
+				"enum": ["notLoaded"],
+				"title": "NotLoadedThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "NotLoadedThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["idle"],
+				"title": "IdleThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "IdleThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["systemError"],
+				"title": "SystemErrorThreadStatusType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "SystemErrorThreadStatus",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"activeFlags": {
+					"items": { "$ref": "#/definitions/ThreadActiveFlag" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["active"],
+					"title": "ActiveThreadStatusType",
+					"type": "string"
+				}
+			},
+			"required": ["activeFlags", "type"],
+			"title": "ActiveThreadStatus",
+			"type": "object"
+		}
+	] },
+	"Turn": {
+		"properties": {
+			"completedAt": {
+				"description": "Unix timestamp (in seconds) when the turn completed.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"durationMs": {
+				"description": "Duration between turn start and completion in milliseconds, if known.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"error": {
+				"anyOf": [{ "$ref": "#/definitions/TurnError" }, { "type": "null" }],
+				"description": "Only populated when the Turn's status is failed."
+			},
+			"id": {
+				"description": "Identifier for this turn. Codex-generated turn IDs are UUIDv7.",
+				"type": "string"
+			},
+			"items": {
+				"description": "Thread items currently included in this turn payload.",
+				"items": { "$ref": "#/definitions/ThreadItem" },
+				"type": "array"
+			},
+			"itemsView": {
+				"allOf": [{ "$ref": "#/definitions/TurnItemsView" }],
+				"default": "full",
+				"description": "Describes how much of `items` has been loaded for this turn."
+			},
+			"startedAt": {
+				"description": "Unix timestamp (in seconds) when the turn started.",
+				"format": "int64",
+				"type": ["integer", "null"]
+			},
+			"status": { "$ref": "#/definitions/TurnStatus" }
+		},
+		"required": [
+			"id",
+			"items",
+			"status"
+		],
+		"type": "object"
+	},
+	"TurnError": {
+		"properties": {
+			"additionalDetails": {
+				"default": null,
+				"type": ["string", "null"]
+			},
+			"codexErrorInfo": { "anyOf": [{ "$ref": "#/definitions/CodexErrorInfo" }, { "type": "null" }] },
+			"message": { "type": "string" },
+			"misalignment": {
+				"anyOf": [{ "$ref": "#/definitions/MisalignmentErrorDetails" }, { "type": "null" }],
+				"default": null,
+				"description": "Optional public explanation and continuation instruction for a misalignment block."
+			}
+		},
+		"required": ["message"],
+		"type": "object"
+	},
+	"TurnItemsView": { "oneOf": [
+		{
+			"description": "`items` was not loaded for this turn. The field is intentionally empty.",
+			"enum": ["notLoaded"],
+			"type": "string"
+		},
+		{
+			"description": "`items` contains only a display summary for this turn.",
+			"enum": ["summary"],
+			"type": "string"
+		},
+		{
+			"description": "`items` contains every ThreadItem available from persisted app-server history for this turn.",
+			"enum": ["full"],
+			"type": "string"
+		}
+	] },
+	"TurnStatus": {
+		"enum": [
+			"completed",
+			"interrupted",
+			"failed",
+			"inProgress"
+		],
+		"type": "string"
+	},
+	"TurnsPage": {
+		"properties": {
+			"backwardsCursor": { "type": ["string", "null"] },
+			"data": {
+				"items": { "$ref": "#/definitions/Turn" },
+				"type": "array"
+			},
+			"nextCursor": { "type": ["string", "null"] }
+		},
+		"required": ["data"],
+		"type": "object"
+	},
+	"UserInput": { "oneOf": [
+		{
+			"properties": {
+				"text": { "type": "string" },
+				"text_elements": {
+					"default": [],
+					"description": "UI-defined spans within `text` used to render or persist special elements.",
+					"items": { "$ref": "#/definitions/TextElement" },
+					"type": "array"
+				},
+				"type": {
+					"enum": ["text"],
+					"title": "TextUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["text", "type"],
+			"title": "TextUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"detail": {
+					"anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }],
+					"default": null
+				},
+				"type": {
+					"enum": ["image"],
+					"title": "ImageUserInputType",
+					"type": "string"
+				},
+				"url": { "type": "string" }
+			},
+			"required": ["type", "url"],
+			"title": "ImageUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"detail": {
+					"anyOf": [{ "$ref": "#/definitions/ImageDetail" }, { "type": "null" }],
+					"default": null
+				},
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["localImage"],
+					"title": "LocalImageUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["path", "type"],
+			"title": "LocalImageUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["audio"],
+					"title": "AudioUserInputType",
+					"type": "string"
+				},
+				"url": { "type": "string" }
+			},
+			"required": ["type", "url"],
+			"title": "AudioUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["localAudio"],
+					"title": "LocalAudioUserInputType",
+					"type": "string"
+				}
+			},
+			"required": ["path", "type"],
+			"title": "LocalAudioUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"name": { "type": "string" },
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["skill"],
+					"title": "SkillUserInputType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"name",
+				"path",
+				"type"
+			],
+			"title": "SkillUserInput",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"name": { "type": "string" },
+				"path": { "type": "string" },
+				"type": {
+					"enum": ["mention"],
+					"title": "MentionUserInputType",
+					"type": "string"
+				}
+			},
+			"required": [
+				"name",
+				"path",
+				"type"
+			],
+			"title": "MentionUserInput",
+			"type": "object"
+		}
+	] },
+	"WebSearchAction": { "oneOf": [
+		{
+			"properties": {
+				"queries": {
+					"items": { "type": "string" },
+					"type": ["array", "null"]
+				},
+				"query": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["search"],
+					"title": "SearchWebSearchActionType",
+					"type": "string"
+				}
+			},
+			"required": ["type"],
+			"title": "SearchWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"type": {
+					"enum": ["openPage"],
+					"title": "OpenPageWebSearchActionType",
+					"type": "string"
+				},
+				"url": { "type": ["string", "null"] }
+			},
+			"required": ["type"],
+			"title": "OpenPageWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": {
+				"pattern": { "type": ["string", "null"] },
+				"type": {
+					"enum": ["findInPage"],
+					"title": "FindInPageWebSearchActionType",
+					"type": "string"
+				},
+				"url": { "type": ["string", "null"] }
+			},
+			"required": ["type"],
+			"title": "FindInPageWebSearchAction",
+			"type": "object"
+		},
+		{
+			"properties": { "type": {
+				"enum": ["other"],
+				"title": "OtherWebSearchActionType",
+				"type": "string"
+			} },
+			"required": ["type"],
+			"title": "OtherWebSearchAction",
+			"type": "object"
+		}
+	] }
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ErrorNotification.json
+var ErrorNotification_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"error": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/TurnError" },
+		"threadId": { "type": "string" },
+		"turnId": { "type": "string" },
+		"willRetry": { "type": "boolean" }
+	},
+	required: [
+		"error",
+		"threadId",
+		"turnId",
+		"willRetry"
+	],
+	title: "ErrorNotification",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ModelListResponse.json
+var ModelListResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"data": {
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Model" },
+			"type": "array"
+		},
+		"nextCursor": {
+			"description": "Opaque cursor to pass to the next call to continue after the last item. If None, there are no more items to return.",
+			"type": ["string", "null"]
+		}
+	},
+	required: ["data"],
+	title: "ModelListResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ThreadResumeResponse.json
+var ThreadResumeResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"activePermissionProfile": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ActivePermissionProfile" }, { "type": "null" }],
+			"default": null,
+			"description": "Named or implicit built-in profile that produced the active permissions, when known."
+		},
+		"approvalPolicy": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AskForApproval" },
+		"approvalsReviewer": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ApprovalsReviewer" }],
+			"description": "Reviewer currently used for approval requests on this thread."
+		},
+		"cwd": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+		"initialTurnsPage": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/TurnsPage" }, { "type": "null" }],
+			"default": null,
+			"description": "`thread/turns/list` page returned when requested by `initialTurnsPage`."
+		},
+		"instructionSources": {
+			"default": [],
+			"description": "Environment-native paths to instruction source files currently loaded for this thread.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/LegacyAppPathString" },
+			"type": "array"
+		},
+		"itemsBackwardsCursor": {
+			"default": null,
+			"description": "Opaque cursor for hydrating paginated items backwards.\n\nPass this as `cursor` to `thread/items/list` with `sortDirection: \"desc\"`. The first page includes the item identified by the cursor.",
+			"type": ["string", "null"]
+		},
+		"model": { "type": "string" },
+		"modelProvider": { "type": "string" },
+		"multiAgentMode": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/MultiAgentMode" }],
+			"default": "explicitRequestOnly",
+			"description": "@deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior."
+		},
+		"reasoningEffort": { "anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ReasoningEffort" }, { "type": "null" }] },
+		"runtimeWorkspaceRoots": {
+			"default": [],
+			"description": "Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+			"type": "array"
+		},
+		"sandbox": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/SandboxPolicy" }],
+			"description": "Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance."
+		},
+		"serviceTier": { "type": ["string", "null"] },
+		"thread": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Thread" },
+		"turnsBackwardsCursor": {
+			"default": null,
+			"description": "Opaque cursor for hydrating paginated turns backwards.\n\nPass this as `cursor` to `thread/turns/list` with `sortDirection: \"desc\"`. The first page includes the turn identified by the cursor.",
+			"type": ["string", "null"]
+		}
+	},
+	required: [
+		"approvalPolicy",
+		"approvalsReviewer",
+		"cwd",
+		"model",
+		"modelProvider",
+		"sandbox",
+		"thread"
+	],
+	title: "ThreadResumeResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/ThreadStartResponse.json
+var ThreadStartResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"activePermissionProfile": {
+			"anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ActivePermissionProfile" }, { "type": "null" }],
+			"default": null,
+			"description": "Named or implicit built-in profile that produced the active permissions, when known."
+		},
+		"approvalPolicy": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AskForApproval" },
+		"approvalsReviewer": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ApprovalsReviewer" }],
+			"description": "Reviewer currently used for approval requests on this thread."
+		},
+		"cwd": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+		"instructionSources": {
+			"default": [],
+			"description": "Environment-native paths to instruction source files currently loaded for this thread.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/LegacyAppPathString" },
+			"type": "array"
+		},
+		"model": { "type": "string" },
+		"modelProvider": { "type": "string" },
+		"multiAgentMode": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/MultiAgentMode" }],
+			"default": "explicitRequestOnly",
+			"description": "@deprecated Always `explicitRequestOnly`. Use `reasoningEffort` for Ultra behavior."
+		},
+		"reasoningEffort": { "anyOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/ReasoningEffort" }, { "type": "null" }] },
+		"runtimeWorkspaceRoots": {
+			"default": [],
+			"description": "Thread-scoped runtime workspace roots used to materialize `:workspace_roots`.",
+			"items": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/AbsolutePathBuf" },
+			"type": "array"
+		},
+		"sandbox": {
+			"allOf": [{ "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/SandboxPolicy" }],
+			"description": "Legacy sandbox policy retained for compatibility. Experimental clients should prefer `activePermissionProfile` for profile provenance."
+		},
+		"serviceTier": { "type": ["string", "null"] },
+		"thread": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Thread" }
+	},
+	required: [
+		"approvalPolicy",
+		"approvalsReviewer",
+		"cwd",
+		"model",
+		"modelProvider",
+		"sandbox",
+		"thread"
+	],
+	title: "ThreadStartResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/TurnCompletedNotification.json
+var TurnCompletedNotification_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: {
+		"threadId": { "type": "string" },
+		"turn": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Turn" }
+	},
+	required: ["threadId", "turn"],
+	title: "TurnCompletedNotification",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-generated/json/v2/TurnStartResponse.json
+var TurnStartResponse_default = {
+	$schema: "http://json-schema.org/draft-07/schema#",
+	properties: { "turn": { "$ref": "./CodexAppServerProtocolDefinitions.json#/definitions/Turn" } },
+	required: ["turn"],
+	title: "TurnStartResponse",
+	type: "object"
+};
+//#endregion
+//#region extensions/codex/src/app-server/protocol-validators.ts
+/**
+* Runtime validators for Codex app-server protocol payloads, including schema
+* normalization for generated JSON Schema before TypeBox compilation.
+*/
+const externalDefinitionRefPrefix = "./CodexAppServerProtocolDefinitions.json#/definitions/";
+const rootExternalDefinitionRefPrefix = "./v2/CodexAppServerProtocolDefinitions.json#/definitions/";
+const localDefinitionRefPrefix = "#/definitions/";
+function materializeCodexSchema(schema, externalRefPrefix = externalDefinitionRefPrefix) {
+	const sharedDefinitions = definitions;
+	if (!isRecord(schema) || !isRecord(sharedDefinitions)) return schema;
+	const reachable = collectDefinitionRefs(schema, externalRefPrefix);
+	const pending = [...reachable];
+	while (pending.length > 0) {
+		const name = pending.pop();
+		if (name === void 0) continue;
+		const definition = sharedDefinitions[name];
+		if (definition === void 0) throw new Error(`Missing generated Codex schema definition: ${name}`);
+		for (const dependency of collectDefinitionRefs(definition, localDefinitionRefPrefix)) if (!reachable.has(dependency)) {
+			reachable.add(dependency);
+			pending.push(dependency);
+		}
+	}
+	if (reachable.size === 0) return schema;
+	const definitions$1 = Object.fromEntries(Object.entries(sharedDefinitions).filter(([name]) => reachable.has(name)));
+	return rewriteDefinitionRefs({
+		...schema,
+		definitions: definitions$1
+	}, externalRefPrefix);
+}
+function collectDefinitionRefs(value, prefix, names = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(value)) for (const entry of value) collectDefinitionRefs(entry, prefix, names);
+	else if (isRecord(value)) {
+		if (typeof value.$ref === "string" && value.$ref.startsWith(prefix)) {
+			const name = value.$ref.slice(prefix.length).split("/", 1)[0];
+			if (name) names.add(name.replaceAll("~1", "/").replaceAll("~0", "~"));
+		}
+		for (const entry of Object.values(value)) collectDefinitionRefs(entry, prefix, names);
+	}
+	return names;
+}
+function rewriteDefinitionRefs(value, externalRefPrefix) {
+	if (Array.isArray(value)) return value.map((entry) => rewriteDefinitionRefs(entry, externalRefPrefix));
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, key === "$ref" && typeof entry === "string" && entry.startsWith(externalRefPrefix) ? `${localDefinitionRefPrefix}${entry.slice(externalRefPrefix.length)}` : rewriteDefinitionRefs(entry, externalRefPrefix)]));
+}
+const dynamicToolCallParamsSchema = materializeCodexSchema(DynamicToolCallParams_default, rootExternalDefinitionRefPrefix);
+const errorNotificationSchema = materializeCodexSchema(ErrorNotification_default);
+const modelListResponseSchema = materializeCodexSchema(ModelListResponse_default);
+const threadResumeResponseSchema = materializeCodexSchema(ThreadResumeResponse_default);
+const threadStartResponseSchema = materializeCodexSchema(ThreadStartResponse_default);
+const turnCompletedNotificationSchema = materializeCodexSchema(TurnCompletedNotification_default);
+const turnStartResponseSchema = materializeCodexSchema(TurnStartResponse_default);
+function compileCodexSchema(schema) {
+	const validator = Compile(normalizeJsonSchemaNode(schema));
+	return {
+		check: (value) => validator.Check(value),
+		errors: (value) => [...validator.Errors(value)]
+	};
+}
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const schemaValueKeywords = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const schemaArrayKeywords = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+function schemaTypeIncludes(schema, type) {
+	return schema.type === type || Array.isArray(schema.type) && schema.type.includes(type);
+}
+function normalizeSchemaMap(value) {
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeJsonSchemaNode(entry)]));
+}
+function expandJsonSchemaTypeArray(schema) {
+	const { type, ...rest } = schema;
+	if (!Array.isArray(type)) return schema;
+	return { anyOf: type.map((entry) => Object.assign({}, rest, { type: entry })) };
+}
+function normalizeJsonSchemaNode(schema) {
+	if (Array.isArray(schema)) return schema.map((entry) => normalizeJsonSchemaNode(entry));
+	if (!isRecord(schema)) return schema;
+	const normalizedSchema = expandJsonSchemaTypeArray(schema);
+	return Object.fromEntries(Object.entries(normalizedSchema).map(([key, value]) => {
+		if (schemaMapKeywords.has(key)) return [key, normalizeSchemaMap(value)];
+		if (schemaValueKeywords.has(key) || schemaArrayKeywords.has(key)) return [key, normalizeJsonSchemaNode(value)];
+		return [key, value];
+	}));
+}
+function readDefault(schema) {
+	if (!isRecord(schema) || !Object.hasOwn(schema, "default")) return;
+	return structuredClone(schema.default);
+}
+function decodePointerSegment(segment) {
+	return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveLocalRef(root, ref) {
+	if (ref === "#") return root;
+	if (!ref.startsWith("#/")) return;
+	let current = root;
+	for (const segment of ref.slice(2).split("/").map(decodePointerSegment)) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function applySchemaDefaults(schema, value, root = schema, resolvingRefs = /* @__PURE__ */ new Set()) {
+	if (value === void 0) {
+		const defaultValue = readDefault(schema);
+		if (defaultValue !== void 0) return defaultValue;
+	}
+	if (!isRecord(schema)) return value;
+	let nextValue = value;
+	if (typeof schema.$ref === "string" && !resolvingRefs.has(schema.$ref)) {
+		const target = resolveLocalRef(root, schema.$ref);
+		if (target !== void 0) {
+			resolvingRefs.add(schema.$ref);
+			nextValue = applySchemaDefaults(target, nextValue, root, resolvingRefs);
+			resolvingRefs.delete(schema.$ref);
+		}
+	}
+	for (const key of ["allOf"]) {
+		const branches = schema[key];
+		if (Array.isArray(branches)) for (const branch of branches) nextValue = applySchemaDefaults(branch, nextValue, root, resolvingRefs);
+	}
+	if (schemaTypeIncludes(schema, "object") && isRecord(nextValue) && isRecord(schema.properties)) {
+		for (const [key, propertySchema] of Object.entries(schema.properties)) {
+			const currentValue = nextValue[key];
+			const defaultedValue = applySchemaDefaults(propertySchema, currentValue, root, resolvingRefs);
+			if (defaultedValue !== void 0 && defaultedValue !== currentValue) nextValue[key] = defaultedValue;
+		}
+		if (isRecord(schema.additionalProperties)) for (const key of Object.keys(nextValue)) {
+			if (Object.hasOwn(schema.properties, key)) continue;
+			nextValue[key] = applySchemaDefaults(schema.additionalProperties, nextValue[key], root, resolvingRefs);
+		}
+	}
+	if (schemaTypeIncludes(schema, "array") && Array.isArray(nextValue) && isRecord(schema.items)) return nextValue.map((entry) => applySchemaDefaults(schema.items, entry, root, resolvingRefs));
+	return nextValue;
+}
+function normalizeWithDefaults(schema, value) {
+	if (value === void 0 || value === null) return value;
+	return applySchemaDefaults(schema, structuredClone(value));
+}
+const validateDynamicToolCallParams = compileCodexSchema(dynamicToolCallParamsSchema);
+const validateErrorNotification = compileCodexSchema(errorNotificationSchema);
+const validateModelListResponse = compileCodexSchema(modelListResponseSchema);
+const validateThreadResumeResponse = compileCodexSchema(threadResumeResponseSchema);
+const validateThreadStartResponse = compileCodexSchema(threadStartResponseSchema);
+const validateTurnCompletedNotification = compileCodexSchema(turnCompletedNotificationSchema);
+const validateTurnStartResponse = compileCodexSchema(turnStartResponseSchema);
+/** Asserts and normalizes a Codex thread/start response. */
+function assertCodexThreadStartResponse(value) {
+	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
+	return assertCodexShape(validateThreadStartResponse, normalized, "thread/start response");
+}
+/** Asserts and normalizes a Codex thread/fork response. */
+function assertCodexThreadForkResponse(value) {
+	const normalized = normalizeWithDefaults(threadStartResponseSchema, value);
+	return assertCodexShape(validateThreadStartResponse, normalized, "thread/fork response");
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
+}
+/** Asserts and normalizes a Codex thread/resume response. */
+function assertCodexThreadResumeResponse(value) {
+	const normalized = normalizeWithDefaults(threadResumeResponseSchema, value);
+	return assertCodexShape(validateThreadResumeResponse, normalized, "thread/resume response");
+}
+var CodexThreadDirectInputError = class extends Error {
+	constructor(threadId) {
+		super(`Codex thread ${threadId} is controlled by its parent and cannot accept direct input. Continue its parent thread, or use /new for a separate OpenClaw session.`);
+		this.name = "CodexThreadDirectInputError";
+	}
+};
+/** Native V2 children allow observation, but only their parent may supply turn input. */
+function assertCodexThreadAcceptsDirectInput(thread) {
+	if (thread.canAcceptDirectInput === false) throw new CodexThreadDirectInputError(thread.id);
+}
+/** Asserts and normalizes a Codex turn/start response. */
+function assertCodexTurnStartResponse(value) {
+	const normalized = normalizeWithDefaults(turnStartResponseSchema, normalizeTurnStartResponse(value));
+	return assertCodexShape(validateTurnStartResponse, normalized, "turn/start response");
+}
+/** Reads Codex dynamic-tool call params, returning undefined for invalid payloads. */
+function readCodexDynamicToolCallParams(value) {
+	return readCodexShape(validateDynamicToolCallParams, normalizeWithDefaults(dynamicToolCallParamsSchema, value));
+}
+/** Reads a Codex error notification payload if it matches the protocol schema. */
+function readCodexErrorNotification(value) {
+	return readCodexShape(validateErrorNotification, normalizeWithDefaults(errorNotificationSchema, value));
+}
+/** Asserts and normalizes a Codex model/list response. */
+function assertCodexModelListResponse(value) {
+	return assertCodexShape(validateModelListResponse, normalizeWithDefaults(modelListResponseSchema, value), "model/list response");
+}
+/** Reads and normalizes a Codex turn object. */
+function readCodexTurn(value) {
+	return readCodexShape(validateTurnStartResponse, normalizeWithDefaults(turnStartResponseSchema, { turn: normalizeTurn(value) }))?.turn;
+}
+/** Reads a Codex turn/completed notification payload if it matches the protocol schema. */
+function readCodexTurnCompletedNotification(value) {
+	return readCodexShape(validateTurnCompletedNotification, normalizeWithDefaults(turnCompletedNotificationSchema, normalizeTurnCompletedNotification(value)));
+}
+function assertCodexShape(validate, value, label) {
+	if (validate.check(value)) return value;
+	throw new Error(`Invalid Codex app-server ${label}: ${formatValidationErrors(validate, value)}`);
+}
+function readCodexShape(validate, value) {
+	return validate.check(value) ? value : void 0;
+}
+function normalizeTurn(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	return {
+		error: null,
+		startedAt: null,
+		completedAt: null,
+		durationMs: null,
+		...value,
+		items: Array.isArray(value.items) ? value.items.map(normalizeThreadItem) : []
+	};
+}
+function normalizeThreadItem(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+	switch (value.type) {
+		case "agentMessage": return {
+			phase: null,
+			delivery: null,
+			memoryCitation: null,
+			...value
+		};
+		case "plan": return {
+			text: "",
+			...value
+		};
+		case "reasoning": return {
+			summary: [],
+			content: [],
+			...value
+		};
+		case "dynamicToolCall": return {
+			namespace: null,
+			arguments: null,
+			status: "completed",
+			contentItems: null,
+			success: null,
+			durationMs: null,
+			...value
+		};
+		default: return value;
+	}
+}
+function normalizeTurnStartResponse(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
+	return {
+		...value,
+		turn: normalizeTurn(value.turn)
+	};
+}
+function normalizeTurnCompletedNotification(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("turn" in value)) return value;
+	return {
+		...value,
+		turn: normalizeTurn(value.turn)
+	};
+}
+function formatValidationErrors(validate, value) {
+	const errors = validate.errors(value);
+	if (!errors || errors.length === 0) return "schema validation failed";
+	return errors.map((error) => {
+		const message = error.message?.trim() || "schema validation failed";
+		return error.instancePath ? `${error.instancePath} ${message}` : message;
+	}).join("; ");
+}
+//#endregion
 //#region extensions/codex/src/app-server/rpc-error.ts
 /** RPC error wrapper that preserves app-server error code and data. */
 var CodexAppServerRpcError = class extends Error {
@@ -3338,7 +6018,7 @@ function assertSupportedCodexAppServerVersion(response) {
 	if (!detectedVersion) throw new CodexAppServerVersionError(detectedVersion);
 	const detected = parse(detectedVersion);
 	if (!detected || detected.compare("0.149.0") < 0) throw new CodexAppServerVersionError(detectedVersion);
-	if (detected.compare("0.151.0") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
+	if (detected.compare("0.152.1") > 0) embeddedAgentLog.warn("codex app-server is newer than OpenClaw's managed runtime; continuing with normal startup validation", {
 		detectedVersion,
 		validatedVersion: CODEX_APP_SERVER_VERSION
 	});
@@ -3415,16 +6095,7 @@ function formatExitValue(value) {
 */
 /** Minimum startup timeout accepted by the Codex app-server harness. */
 const CODEX_APP_SERVER_STARTUP_TIMEOUT_FLOOR_MS = 100;
-/** Default idle timeout while waiting for app-server turn completion. */
-const CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS = 6e4;
-/** Short guard after apparent assistant completion. */
-const CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 1e4;
-const CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS = 3e5;
-/** Guard after reasoning/commentary progress when no tool handoff occurred. */
-const CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS = 3e5;
-/** Long terminal idle watch for app-server turns that never send completion. */
-const CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS = 18e5;
-const TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS = 12e4;
+const TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS = 12e4;
 const TURN_FINALIZE_DRAIN_ABORT_GRACE_MS = 5e3;
 var CodexAppServerStartupError = class extends Error {
 	constructor(reason, message = reason === "timed_out" ? "codex app-server startup timed out" : "codex app-server startup aborted") {
@@ -3485,23 +6156,6 @@ function resolveCodexStartupTimeoutMs(params) {
 	const timeoutMs = resolvePositiveIntegerTimeoutMs(params.timeoutMs, timeoutFloorMs);
 	return Math.max(timeoutFloorMs, timeoutMs);
 }
-/** Resolves the completion-idle timeout for an active turn. */
-function resolveCodexTurnCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the short assistant-completion release timeout. */
-function resolveCodexTurnAssistantCompletionIdleTimeoutMs(value) {
-	return resolvePositiveIntegerTimeoutMs(value, CODEX_TURN_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS);
-}
-/** Resolves the conservative post-tool raw assistant guard timeout. */
-function resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs(value, fallbackMs) {
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(resolvePositiveIntegerTimeoutMs(void 0, fallbackMs), CODEX_POST_TOOL_RAW_ASSISTANT_COMPLETION_IDLE_TIMEOUT_MS));
-}
-/** Resolves the long terminal turn idle timeout. */
-function resolveCodexTurnTerminalIdleTimeoutMs(value, runTimeoutOverrideMs) {
-	const explicitRunBudgetMs = resolvePositiveIntegerTimeoutMs(runTimeoutOverrideMs, CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS);
-	return resolvePositiveIntegerTimeoutMs(value, Math.max(CODEX_TURN_TERMINAL_IDLE_TIMEOUT_MS, explicitRunBudgetMs));
-}
 /** Adds gateway grace time to a caller timeout without overflowing invalid values. */
 function resolveCodexGatewayTimeoutWithGraceMs(timeoutMs, graceMs = 1e4) {
 	const timeout = resolvePositiveIntegerTimeoutMs(timeoutMs, 1);
@@ -3591,8 +6245,8 @@ async function statFingerprint(filePath) {
 	}
 }
 async function readFileFingerprint(filePath, expected, followsSymlink) {
-	const noFollow = followsSymlink ? 0 : constants.O_NOFOLLOW ?? 0;
-	const handle = await fs.open(filePath, constants.O_RDONLY | noFollow);
+	const noFollow = followsSymlink ? 0 : constants$1.O_NOFOLLOW ?? 0;
+	const handle = await fs.open(filePath, constants$1.O_RDONLY | noFollow);
 	try {
 		const before = await handle.stat({ bigint: true });
 		if (!sameStat(before, expected)) throw new Error(`Codex desktop artifact changed while fingerprinting: ${filePath}`);
@@ -3902,15 +6556,9 @@ var CodexThreadBindingConflictError = class extends Error {
 		this.name = "CodexThreadBindingConflictError";
 	}
 };
-var CodexRestrictedToolSurfaceAttestationError = class extends Error {
-	constructor(cause) {
-		super("Codex restricted-tool-surface MCP attestation failed", { cause });
-		this.name = "CodexRestrictedToolSurfaceAttestationError";
-	}
-};
-var CodexAdoptedThreadActiveError = class extends Error {
-	constructor() {
-		super("Codex session became active in another runner; wait for it to finish before continuing");
+var CodexAdoptedThreadActiveError = class extends AgentHarnessPreflightError {
+	constructor(message = "Codex session became active in another runner; wait for it to finish before continuing") {
+		super(message);
 		this.name = "CodexAdoptedThreadActiveError";
 	}
 };
@@ -3922,7 +6570,7 @@ var CodexAdoptedThreadActiveError = class extends Error {
 */
 var shared_client_exports = /* @__PURE__ */ __exportAll({
 	assertCodexAppServerClientStartSelectionCurrent: () => assertCodexAppServerClientStartSelectionCurrent,
-	captureExclusiveSharedCodexAppServerClient: () => captureExclusiveSharedCodexAppServerClient,
+	captureCodexAppServerClientLifetime: () => captureCodexAppServerClientLifetime,
 	captureSharedCodexAppServerCatalogLifetime: () => captureSharedCodexAppServerCatalogLifetime,
 	clearSharedCodexAppServerClientAndWait: () => clearSharedCodexAppServerClientAndWait,
 	clearSharedCodexAppServerClientIfCurrent: () => clearSharedCodexAppServerClientIfCurrent,
@@ -4446,11 +7094,10 @@ async function startInitializedCodexAppServerClient(params) {
 		} finally {
 			artifactDrain?.cancel();
 		}
-		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-D9pYp4zL.js") : void 0;
-		const nativeCommandBeforeStart = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
+		const runtimeArtifactModule = params.runtimeArtifactMode ? await import("./runtime-artifact-C3jVimFn.js") : void 0;
 		const runtimeArtifactBeforeStart = runtimeArtifactModule ? await runtimeArtifactModule.captureCodexAppServerRuntimeArtifactBeforeStart({
 			startOptions,
-			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions, nativeCommandBeforeStart),
+			spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
 			signal: params.runtimeArtifactSignal
 		}) : void 0;
 		if (runtimeArtifactModule && runtimeArtifactBeforeStart && params.expectedRuntimeArtifact && !runtimeArtifactModule.validateCodexAppServerRuntimeArtifactCapture(params.expectedRuntimeArtifact, runtimeArtifactBeforeStart)) {
@@ -4497,11 +7144,10 @@ async function startInitializedCodexAppServerClient(params) {
 		let runtimeArtifact;
 		try {
 			if (runtimeArtifactModule && runtimeArtifactBeforeStart) {
-				const nativeCommand = startOptions.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(startOptions.command) : void 0;
 				runtimeArtifact = await runtimeArtifactModule.finalizeCodexAppServerRuntimeArtifact({
 					before: runtimeArtifactBeforeStart,
 					startOptions,
-					spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions, nativeCommand),
+					spawnIdentity: resolveCodexAppServerSpawnIdentity(startOptions),
 					runtimeIdentity: client.getRuntimeIdentity(),
 					signal: params.runtimeArtifactSignal
 				});
@@ -4586,12 +7232,17 @@ function clearSharedCodexAppServerClientIfCurrent(client) {
 }
 /** Captures a revocable observation of the exact shared client and native account/config. */
 function captureSharedCodexAppServerCatalogLifetime(client) {
+	const isCurrent = captureSharedClientRegistration(client);
+	const revision = client.getModelCatalogRevision();
+	return () => isCurrent() && client.getModelCatalogRevision() === revision;
+}
+/** Registration ends on retirement even when sibling leases keep the process alive. */
+function captureSharedClientRegistration(client) {
 	const state = getSharedCodexAppServerClientState();
 	const entry = state.entriesByClient.get(client);
 	const key = [...state.clients].find(([, candidate]) => candidate === entry)?.[0];
 	const generation = readCodexAppServerClientDesktopGeneration(client);
-	const revision = client.getModelCatalogRevision();
-	return () => key !== void 0 && state.clients.get(key) === entry && entry?.client === client && !entry.closeWhenIdle && !entry.closeError && !client.getCloseError() && client.getModelCatalogRevision() === revision && (!generation || isCodexDesktopGenerationCurrent(generation));
+	return () => key !== void 0 && state.clients.get(key) === entry && entry?.client === client && !entry.closeWhenIdle && !entry.closeError && !client.getCloseError() && (!generation || isCodexDesktopGenerationCurrent(generation));
 }
 /** Retains the matching shared client and returns a release callback. */
 function retainSharedCodexAppServerClientIfCurrent(client) {
@@ -4612,19 +7263,18 @@ function retainSharedCodexAppServerClientByInstanceId(clientId) {
 		};
 	}
 }
-/** Captures sole physical-client ownership across awaited configuration adoption. */
-function captureExclusiveSharedCodexAppServerClient(client) {
+/** Captures physical ownership, independently of unrelated thread and reader leases. */
+function captureCodexAppServerClientLifetime(client, requiredOwnership) {
 	const state = getSharedCodexAppServerClientState();
-	for (const [key, entry] of state.clients) {
-		if (entry.client !== client) continue;
-		const generation = entry.leaseGeneration;
-		const assertExclusive = () => {
-			if (state.clients.get(key) !== entry || entry.client !== client || entry.closeWhenIdle || entry.closeError || entry.activeLeases !== 1 || entry.pendingAcquires !== 0 || entry.leaseGeneration !== generation) throw new CodexAdoptedThreadActiveError();
-		};
-		assertExclusive();
-		return assertExclusive;
-	}
-	throw new CodexAdoptedThreadActiveError();
+	const start = getCodexAppServerClientStartMetadata().get(client)?.startOptions;
+	if (requiredOwnership === "native-process" && (start?.transport !== "stdio" || isCodexAppServerProxyLaunch(start.args))) throw new AgentHarnessPreflightError("Codex ordinary configuration refresh requires an OpenClaw-managed local stdio process, not an external socket or app-server proxy. No turn was sent; reconnect through managed local stdio before continuing.");
+	const isCurrent = requiredOwnership === "native-process" && state.isolatedClients.has(client) ? () => state.isolatedClients.has(client) && !client.getCloseError() : captureSharedClientRegistration(client);
+	const assertCurrent = () => {
+		if (!isCurrent()) throw new CodexAdoptedThreadActiveError("Codex app-server connection changed during thread preparation; reconnect before continuing");
+		assertCodexAppServerClientStartSelectionCurrent({ client });
+	};
+	assertCurrent();
+	return assertCurrent;
 }
 /**
 * Retires a matching shared client. Default is graceful: detach from the map
@@ -4750,7 +7400,6 @@ function getOrCreateSharedClientEntry(state, key) {
 		entry = {
 			activeLeases: 0,
 			pendingAcquires: 0,
-			leaseGeneration: 0,
 			closeWhenIdle: false,
 			onStartedClientCallbacks: /* @__PURE__ */ new Set()
 		};
@@ -4786,7 +7435,6 @@ function clearSharedCodexAppServerClientIfCurrentAndUnclaimed(client) {
 }
 function retainPendingSharedClientAcquire(entry) {
 	let released = false;
-	entry.leaseGeneration += 1;
 	entry.pendingAcquires += 1;
 	return () => {
 		if (released) return;
@@ -4798,7 +7446,6 @@ function retainPendingSharedClientAcquire(entry) {
 }
 function retainSharedClientEntry(entry) {
 	let released = false;
-	entry.leaseGeneration += 1;
 	entry.activeLeases += 1;
 	return () => {
 		if (released) return;
@@ -4844,4 +7491,4 @@ function collectSharedClients(state) {
 	return [...state.liveClients];
 }
 //#endregion
-export { CodexAppServerRpcError as $, CODEX_POST_REASONING_REPLY_IDLE_TIMEOUT_MS as A, reconcileCodexComputerUseStartArtifacts as At, resolveCodexTurnTerminalIdleTimeoutMs as B, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as Bt, withLeasedCodexAppServerClientStartSelectionRetry as C, retainCodexAppServerLiveThread as Ct, CodexThreadStartRequestError as D, readCodexRateLimitsRevision as Dt, CodexThreadBindingConflictError as E, withTimeout$1 as Et, resolveCodexGatewayTimeoutWithGraceMs as F, resolveCodexAppServerFallbackApiKeyCacheKey as Ft, isCodexAppServerConnectionClosedError as G, getCodexAppServerClientInstanceId as H, isJsonObject as Ht, resolveCodexPostToolRawAssistantCompletionIdleTimeoutMs as I, resolveCodexAppServerPreparedApiKeyCacheKey as It, isCodexAppServerOverloadError as J, isCodexAppServerIndeterminateRequestCancellationError as K, resolveCodexStartupTimeoutMs as L, resolveCodexAppServerPreparedAuthHandoff as Lt, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as M, resolveCodexAppServerAuthProfileId as Mt, TURN_TERMINAL_SETTLEMENT_IDLE_TIMEOUT_MS as N, resolveCodexAppServerAuthProfileIdForAgent as Nt, acquireCodexNativeConfigFence as O, readRecentCodexRateLimits as Ot, isCodexAppServerStartupError as P, resolveCodexAppServerAuthProfileStore as Pt, resolveCodexAppServerClientInstanceId as Q, resolveCodexTurnAssistantCompletionIdleTimeoutMs as R, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as Rt, waitForCodexAppServerClientDesktopGenerationDrain as S, releaseCodexAppServerLiveThread as St, CodexRestrictedToolSurfaceAttestationError as T, withAbortableTimeout as Tt, isCodexAppServerApprovalRequest as U, resolveCodexManagedBundledMarketplacePath as Ut, withCodexStartupTimeout as V, flattenCodexDynamicToolFunctions as Vt, isCodexAppServerBrokenPipeError as W, assertNotSymlink as Wt, isCodexAppServerRequestTimeoutError as X, isCodexAppServerPrewriteRequestCancellationError as Y, isUnsupportedCodexAppServerVersionError as Z, retainSharedCodexAppServerClientByInstanceId as _, ensureCodexAppServerClientRuntime as _t, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, resolveDynamicToolCallTimeoutMs as at, retireSharedCodexAppServerClientsBeforeDesktopGeneration as b, isCodexAppServerLiveThreadClaimed as bt, getLeasedSharedCodexAppServerClient as c, shouldReleaseTurnAfterTerminalDynamicTool as ct, readCodexAppServerClientDesktopGeneration as d, resolveCodexToolAbortTerminalReason as dt, createCodexElicitationResponse as et, readCodexAppServerClientDesktopGenerationFingerprint as f, createFailedDynamicToolResponse as ft, resolveCodexNativeConfigFenceKey as g, consumeCodexAppServerLiveThread as gt, releaseLeasedSharedCodexAppServerClient as h, claimCodexAppServerLiveThread as ht, clearSharedCodexAppServerClientIfCurrent as i, isMatchingDynamicToolTerminalDiagnostic as it, CodexAppServerStartupError as j, resolveCodexAppServerAuthAccountCacheKey as jt, createCodexDesktopGenerationService as k, rememberCodexRateLimitsRead as kt, getSharedCodexAppServerClient as l, toCodexDynamicToolProgressResponse as lt, releaseCodexAppServerClientLease as m, withDynamicToolTranscriptDetails as mt, captureExclusiveSharedCodexAppServerClient as n, hasPendingDynamicToolTerminalDiagnostic as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, resolveTerminalDynamicToolBatchAction as ot, readCodexAppServerClientProcessIdentity as p, withDynamicToolExecutionState as pt, isCodexAppServerIndeterminateTransportError as q, captureSharedCodexAppServerCatalogLifetime as r, isDynamicToolTerminalDiagnosticEvent as rt, createIsolatedCodexAppServerClient as s, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as st, assertCodexAppServerClientStartSelectionCurrent as t, handleDynamicToolCallWithTimeout as tt, isCodexAppServerStartSelectionChangedError as u, toCodexDynamicToolProtocolResponse as ut, retainSharedCodexAppServerClientIfCurrent as v, hasCodexAppServerLiveThread as vt, CodexAdoptedThreadActiveError as w, unsubscribeCodexAppServerLiveThread as wt, shared_client_exports as x, protectCodexAppServerLiveThread as xt, retireSharedCodexAppServerClientIfCurrent as y, isCodexAppServerClientRuntimeLive as yt, resolveCodexTurnCompletionIdleTimeoutMs as z, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as zt };
+export { assertCodexThreadResumeResponse as $, isJsonObject as $t, TURN_FINALIZE_DRAIN_ABORT_GRACE_MS as A, retainCodexAppServerLiveThread as At, isCodexAppServerIndeterminateRequestCancellationError as B, resolveCodexAppServerAuthProfileIdForAgent as Bt, withLeasedCodexAppServerClientStartSelectionRetry as C, ensureCodexAppServerClientRuntime as Ct, acquireCodexNativeConfigFence as D, protectCodexAppServerLiveThread as Dt, CodexThreadStartRequestError as E, isCodexAppServerLiveThreadClaimed as Et, withCodexStartupTimeout as F, readRecentCodexRateLimits as Ft, isUnsupportedCodexAppServerVersionError as G, resolveCodexManagedBundledMarketplacePath as Gt, isCodexAppServerOverloadError as H, resolveCodexAppServerFallbackApiKeyCacheKey as Ht, getCodexAppServerClientInstanceId as I, rememberCodexRateLimitsRead as It, CodexThreadDirectInputError as J, readCodexSessionMeta as Jt, resolveCodexAppServerClientInstanceId as K, assertNotSymlink as Kt, isCodexAppServerApprovalRequest as L, reconcileCodexComputerUseStartArtifacts as Lt, isCodexAppServerStartupError as M, withAbortableTimeout as Mt, resolveCodexGatewayTimeoutWithGraceMs as N, withTimeout$1 as Nt, createCodexDesktopGenerationService as O, readCodexClientSessionMeta as Ot, resolveCodexStartupTimeoutMs as P, readCodexRateLimitsRevision as Pt, assertCodexThreadForkResponse as Q, flattenCodexDynamicToolFunctions as Qt, isCodexAppServerBrokenPipeError as R, resolveCodexAppServerAuthAccountCacheKey as Rt, waitForCodexAppServerClientDesktopGenerationDrain as S, consumeCodexAppServerLiveThread as St, CodexThreadBindingConflictError as T, isCodexAppServerClientRuntimeLive as Tt, isCodexAppServerPrewriteRequestCancellationError as U, resolveCodexAppServerPreparedApiKeyCacheKey as Ut, isCodexAppServerIndeterminateTransportError as V, resolveCodexAppServerAuthProfileStore as Vt, isCodexAppServerRequestTimeoutError as W, resolveCodexAppServerPreparedAuthHandoff as Wt, assertCodexThreadAcceptsDirectInput as X, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as Xt, assertCodexModelListResponse as Y, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as Yt, assertCodexThreadForkParams as Z, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as Zt, retainSharedCodexAppServerClientByInstanceId as _, resolveCodexToolAbortTerminalReason as _t, clearSharedCodexAppServerClientIfCurrentAndUnclaimed as a, readCodexTurnCompletedNotification as at, retireSharedCodexAppServerClientsBeforeDesktopGeneration as b, withDynamicToolTranscriptDetails as bt, getLeasedSharedCodexAppServerClient as c, hasPendingDynamicToolTerminalDiagnostic as ct, readCodexAppServerClientDesktopGeneration as d, resolveDynamicToolCallTimeoutMs as dt, assertCodexThreadStartResponse as et, readCodexAppServerClientDesktopGenerationFingerprint as f, resolveTerminalDynamicToolBatchAction as ft, resolveCodexNativeConfigFenceKey as g, toCodexDynamicToolProtocolResponse as gt, releaseLeasedSharedCodexAppServerClient as h, toCodexDynamicToolProgressResponse as ht, clearSharedCodexAppServerClientIfCurrent as i, readCodexTurn as it, TURN_TERMINAL_SETTLEMENT_TIMEOUT_MS as j, unsubscribeCodexAppServerLiveThread as jt, CodexAppServerStartupError as k, releaseCodexAppServerLiveThread as kt, getSharedCodexAppServerClient as l, isDynamicToolTerminalDiagnosticEvent as lt, releaseCodexAppServerClientLease as m, shouldReleaseTurnAfterTerminalDynamicTool as mt, captureCodexAppServerClientLifetime as n, readCodexDynamicToolCallParams as nt, clearSharedCodexAppServerClientIfCurrentAndWait as o, createCodexElicitationResponse as ot, readCodexAppServerClientProcessIdentity as p, shouldBlockTerminalReleaseForNonTerminalDynamicToolResult as pt, CodexAppServerRpcError as q, isOpenClawManagedCodexThread as qt, captureSharedCodexAppServerCatalogLifetime as r, readCodexErrorNotification as rt, createIsolatedCodexAppServerClient as s, handleDynamicToolCallWithTimeout as st, assertCodexAppServerClientStartSelectionCurrent as t, assertCodexTurnStartResponse as tt, isCodexAppServerStartSelectionChangedError as u, isMatchingDynamicToolTerminalDiagnostic as ut, retainSharedCodexAppServerClientIfCurrent as v, createFailedDynamicToolResponse as vt, CodexAdoptedThreadActiveError as w, hasCodexAppServerLiveThread as wt, shared_client_exports as x, claimCodexAppServerLiveThread as xt, retireSharedCodexAppServerClientIfCurrent as y, withDynamicToolExecutionState as yt, isCodexAppServerConnectionClosedError as z, resolveCodexAppServerAuthProfileId as zt };