@openclaw/codex 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/mcp-app-session-preparation-BxN0_CYe.mjs

@@ -0,0 +1,223 @@
+import { m as sessionBindingIdentity } from "./session-binding-record-BZB8RgcF.mjs";
+import { f as readCodexRequirementsToml } from "./config-security-KAPScztc.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-BQq-CHTF.mjs";
+import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
+import { n as buildCodexAppServerRuntimeFingerprint, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { i as resolveCodexBindingAppServerConnection } from "./binding-connection-C-08ez1w.mjs";
+import { r as resolveOpenClawExecPolicyForCodexAppServer } from "./config-0Gxk3_eq.mjs";
+import { r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
+import { I as ensureCodexAppServerClientRuntime, c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-qhyYWbew.mjs";
+import { Ct as mergeCodexThreadConfigs, _t as buildCodexPluginThreadConfigInputFingerprint } from "./thread-requests-CL1e8Wmx.mjs";
+import { s as startOrResumeThread } from "./thread-lifecycle-Cbz_7ySv.mjs";
+import { r as resolveCodexSessionBinding } from "./session-binding-Ce7BqiPN.mjs";
+import { a as rollbackCodexAppServerBindingSubscription, r as retainCodexAppServerBindingSubscription, t as isSameCodexAppServerThreadOwner } from "./thread-ownership-DwuSrt3s.mjs";
+import { n as resolveCodexPluginThreadConfigStartupPolicy, t as createCodexPluginThreadConfigStartupProvider } from "./plugin-thread-config-deadline-B8LGaZNW.mjs";
+import { n as applyCodexSessionPermissionPolicy } from "./session-permission-policy-BxIUJ0Zd.mjs";
+import { z } from "zod";
+import { loadCodexBundleMcpThreadConfig } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
+import { buildCodexUserMcpServersThreadConfigPatchForRuntime } from "openclaw/plugin-sdk/codex-mcp-projection";
+//#region extensions/codex/src/app-server/mcp-app-session-preparation.ts
+/** Runs the existing thread lifecycle only. This path has no prompt or turn submission. */
+async function prepareCodexMcpAppSession(params) {
+	const { preparation } = params;
+	if (preparation.version !== 1 || preparation.purpose !== "mcp-app") throw new Error("Unsupported native session preparation capability");
+	return preparation.run(async () => {
+		const input = preparation.params;
+		const assertSourceCurrent = () => {
+			params.assertCurrent();
+			input.hostCapabilities.assertActive();
+			input.abortSignal?.throwIfAborted();
+		};
+		assertSourceCurrent();
+		const pluginConfig = readCodexPluginConfig(params.pluginConfig);
+		const admitted = await resolveCodexSessionBinding({
+			bindingStore: params.bindingStore,
+			identity: sessionBindingIdentity(input),
+			config: input.config,
+			storePath: input.sessionTarget?.storePath,
+			reclaimStale: true,
+			signal: input.abortSignal,
+			assertCurrent: assertSourceCurrent
+		});
+		const assertCurrent = () => {
+			assertSourceCurrent();
+			admitted.authority.assertLegacyCurrent();
+		};
+		assertCurrent();
+		const prepareThread = async () => {
+			const execPolicy = resolveOpenClawExecPolicyForCodexAppServer({
+				permissionMode: input.permissionMode,
+				execOverrides: input.execOverrides,
+				approvals: input.permissionMode === "full" ? void 0 : loadExecApprovals(),
+				config: input.config,
+				agentId: input.agentId
+			});
+			const { appServer: runtimeOptions } = await resolveCodexBindingAppServerConnection({
+				binding: admitted.binding,
+				pluginConfig,
+				execPolicy,
+				modelProvider: input.provider,
+				model: input.modelId,
+				config: input.config,
+				agentDir: input.agentDir,
+				requirementsToml: readCodexRequirementsToml({}),
+				openClawSandboxActive: false,
+				sessionPermissionMode: input.permissionMode,
+				assertCurrent
+			});
+			assertCurrent();
+			const appServer = applyCodexSessionPermissionPolicy({
+				appServer: runtimeOptions,
+				pluginConfig,
+				permissionMode: input.permissionMode,
+				sessionRoot: input.sessionRoot,
+				defaultRoot: input.workspaceDir,
+				canUseAutoReview: false
+			});
+			const environment = input.hostCapabilities.preparedEnvironment?.();
+			const startOptions = appServer.start.transport === "stdio" && !isCodexAppServerProxyLaunch(appServer.start.args) ? {
+				...appServer.start,
+				env: {
+					...appServer.start.env,
+					...environment?.credentialScrubEnv,
+					...environment?.localIdentityEnv,
+					...environment?.localProcessEnv
+				}
+			} : appServer.start;
+			const authProfileId = resolveCodexAppServerAuthProfileId({
+				authProfileId: input.authProfileId ?? admitted.binding?.authProfileId,
+				store: input.authProfileStore,
+				config: input.config
+			});
+			const client = await getLeasedSharedCodexAppServerClient({
+				startOptions,
+				pluginConfig: params.pluginConfig,
+				agentId: input.agentId,
+				agentDir: input.agentDir,
+				config: input.config,
+				authProfileStore: input.authProfileStore,
+				authProfileId: admitted.binding?.connectionScope === "supervision" || appServer.start.homeScope === "user" ? null : authProfileId,
+				abandonSignal: input.abortSignal,
+				assertCurrent,
+				timeoutMs: appServer.requestTimeoutMs
+			});
+			try {
+				assertCurrent();
+				ensureCodexAppServerClientRuntime(client, {
+					agentDir: input.agentDir,
+					authProfileId,
+					authProfileStore: input.authProfileStore,
+					config: input.config
+				});
+				const pluginPolicy = resolveCodexPluginThreadConfigStartupPolicy({
+					pluginConfig,
+					nativeToolSurfaceEnabled: true
+				});
+				const appCacheKey = buildCodexPluginAppCacheKey({
+					appServer,
+					agentDir: input.agentDir,
+					authProfileId,
+					appServerVersion: client.getServerVersion(),
+					runtimeIdentity: client.getRuntimeIdentity()
+				});
+				const pluginThreadConfig = pluginPolicy.pluginThreadConfigRequired ? createCodexPluginThreadConfigStartupProvider({
+					inputFingerprint: buildCodexPluginThreadConfigInputFingerprint({
+						pluginConfig: pluginPolicy.pluginThreadConfigPluginConfig,
+						appCacheKey
+					}),
+					enabledPluginConfigKeys: pluginPolicy.enabledPluginConfigKeys,
+					policy: pluginPolicy.resolvedPluginPolicy,
+					requestTimeoutMs: appServer.requestTimeoutMs,
+					signal: input.abortSignal ?? new AbortController().signal,
+					pluginConfig: pluginPolicy.pluginThreadConfigPluginConfig,
+					client,
+					configCwd: input.workspaceDir,
+					appCacheKey
+				}) : void 0;
+				const bundle = await loadCodexBundleMcpThreadConfig({
+					workspaceDir: input.workspaceDir,
+					agentId: input.agentId,
+					cfg: input.config,
+					toolOverrides: input.toolOverrides
+				});
+				assertCurrent();
+				const user = await buildCodexUserMcpServersThreadConfigPatchForRuntime(input.config, {
+					agentId: input.agentId,
+					agentDir: input.agentDir,
+					toolOverrides: input.toolOverrides,
+					allowLiteralOAuthProjection: appServer.connectionClass !== "remote"
+				});
+				assertCurrent();
+				const modelSource = input.hostCapabilities.retainSourceAuthority?.();
+				let nativeModelAdmission;
+				try {
+					modelSource?.assertCurrent();
+					nativeModelAdmission = modelSource ? modelSource.modelPolicyRequired !== false ? "required" : "optional" : void 0;
+				} finally {
+					modelSource?.release();
+				}
+				const bundleConfig = bundle.configPatch ? z.record(z.string(), z.json()).parse(bundle.configPatch) : void 0;
+				const thread = await startOrResumeThread({
+					client,
+					bindingStore: params.bindingStore,
+					params: {
+						...input,
+						authProfileId
+					},
+					assertCurrent,
+					agentId: input.agentId,
+					agentDir: input.agentDir,
+					cwd: input.workspaceDir,
+					appServer,
+					dynamicTools: [],
+					nativeCodeModeEnabled: false,
+					webSearchAllowed: false,
+					persistentWebSearchAllowed: false,
+					userMcpServersEnabled: false,
+					nativeModelAdmission,
+					pluginThreadConfig,
+					appServerRuntimeFingerprint: buildCodexAppServerRuntimeFingerprint({
+						appServer,
+						appServerVersion: client.getServerVersion(),
+						runtimeIdentity: client.getRuntimeIdentity()
+					}),
+					config: mergeCodexThreadConfigs(bundleConfig, user),
+					signal: input.abortSignal
+				});
+				let retained = false;
+				try {
+					retained = await params.bindingStore.withLease(sessionBindingIdentity(input), async () => {
+						assertCurrent();
+						if (!isSameCodexAppServerThreadOwner(params.bindingStore.read(sessionBindingIdentity(input)), thread)) return false;
+						thread.liveThreadOwnership?.assertCurrent();
+						return await retainCodexAppServerBindingSubscription(client, thread.threadId, {
+							release: thread.liveThreadOwnership?.release,
+							configFingerprint: thread.liveThreadConfigFingerprint,
+							serviceTier: thread.liveThreadOwnership?.serviceTier,
+							ephemeralPolicy: thread.liveThreadEphemeralPolicy
+						});
+					});
+					if (!retained) throw new Error("Native MCP session ownership changed before retention");
+					return thread;
+				} finally {
+					if (!retained) {
+						if (thread.liveThreadOwnership) await thread.liveThreadOwnership.release(thread.threadId);
+						else await rollbackCodexAppServerBindingSubscription(client, thread.threadId, false);
+					}
+				}
+			} finally {
+				releaseLeasedSharedCodexAppServerClient(client);
+			}
+		};
+		if (admitted.binding) return await prepareThread();
+		const thread = await params.bindingStore.withLease(sessionBindingIdentity(input), async () => {
+			assertCurrent();
+			return params.bindingStore.read(sessionBindingIdentity(input)) ?? await prepareThread();
+		});
+		assertCurrent();
+		return thread;
+	});
+}
+//#endregion
+export { prepareCodexMcpAppSession };

package/dist/.setup/mcp-tool-metadata-j10HhfTC.mjs

@@ -0,0 +1,43 @@
+import { r as parseCodexPluginMarketplaceId } from "./plugin-marketplace-discovery-SQPhSuic.mjs";
+import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeMcpCodexToolAnnotations, readMcpAppIcons, readMcpAppSettingsCapability, readMcpAppToolExtensions } from "openclaw/plugin-sdk/codex-mcp-projection";
+//#region extensions/codex/src/app-server/mcp-tool-metadata.ts
+function projectCodexMcpServerMetadata(status) {
+	const plugin = status.pluginId ? parseCodexPluginMarketplaceId(status.pluginId) : void 0;
+	return {
+		serverName: status.name,
+		launchSummary: "Codex native MCP connection",
+		...status.pluginId ? {
+			pluginId: plugin?.pluginName ?? status.pluginId,
+			marketplace: plugin?.marketplaceName
+		} : {},
+		title: status.serverInfo?.title ?? void 0,
+		icons: readMcpAppIcons(status.serverInfo?.icons),
+		settings: readMcpAppSettingsCapability(status.serverCapabilities),
+		toolCount: Object.keys(status.tools).length
+	};
+}
+function projectCodexMcpToolMetadata(toolName, raw) {
+	const tool = asOptionalRecord(raw);
+	return {
+		title: normalizeOptionalString(tool?.title) ?? normalizeOptionalString(asOptionalRecord(tool?.annotations)?.title),
+		fallbackDescription: normalizeOptionalString(tool?.description) ?? toolName,
+		appExtensions: readMcpAppToolExtensions(tool ?? {}),
+		codexAnnotations: normalizeMcpCodexToolAnnotations(tool?.annotations),
+		uiResourceUri: normalizeOptionalString(asOptionalRecord(asOptionalRecord(tool?._meta)?.ui)?.resourceUri)
+	};
+}
+/** Hosted app ownership is authoritative only on metadata supplied by Codex. */
+function readCodexMcpToolConnectorId(tool) {
+	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
+	return normalizeOptionalString(metadata?.connector_id) ?? normalizeOptionalString(metadata?.connectorId);
+}
+/** Preserve MCP App visibility so model-only tools cannot become widget authority. */
+function readCodexMcpToolUiVisibility(tool) {
+	const metadata = asOptionalRecord(asOptionalRecord(tool)?.["_meta"]);
+	const visibility = asOptionalRecord(metadata?.ui)?.visibility;
+	if (!Array.isArray(visibility)) return;
+	return [...new Set(visibility.filter((value) => value === "app" || value === "model"))].toSorted();
+}
+//#endregion
+export { readCodexMcpToolUiVisibility as i, projectCodexMcpToolMetadata as n, readCodexMcpToolConnectorId as r, projectCodexMcpServerMetadata as t };

package/dist/.setup/{model-catalog-DiC0Tkha.mjs → model-catalog-DZyNeDKG.mjs}

@@ -1,13 +1,13 @@
 import { t as buildCodexRuntimeModelParams } from "./model-runtime-BdqzOMkU.mjs";
-import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-BQq-CHTF.mjs";
 import { n as isCodexAppServerProxyLaunch } from "./launch-args-DbFCehO7.mjs";
-import { o as withCodexAppServerJsonClient } from "./request-BZOfsSXW.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-B0okYl2D.mjs";
-import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-CJCTeFpQ.mjs";
+import { a as withCodexAppServerJsonClient } from "./request-jSbhc1sg.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
+import { a as resolveCodexAppServerAuthProfileStore, r as resolveCodexAppServerAuthProfileId } from "./auth-profile-CgHQ8Vot.mjs";
+import { r as captureSharedCodexAppServerCatalogLifetime } from "./shared-client-qhyYWbew.mjs";
 import { i as isCodexResponsesOAuthCredential } from "./responses-oauth-twnuTaAa.mjs";
-import { n as listAllCodexAppServerModels } from "./models-DfLmPV0k.mjs";
-import { probeCodexNativeAuth } from "./native-auth-CuG53tu4.mjs";
+import { n as listAllCodexAppServerModels } from "./models-DSseKSMg.mjs";
+import { probeCodexNativeAuth } from "./native-auth-Cjb9y7IZ.mjs";
 //#region extensions/codex/src/app-server/model-catalog.ts
 const INPUT_TYPES = /* @__PURE__ */ new Set([
 	"text",

package/dist/.setup/{models-DfLmPV0k.mjs → models-DSseKSMg.mjs}

@@ -1,4 +1,4 @@
-import { g as assertCodexModelListResponse } from "./client-qyUBJlGZ.mjs";
+import { d as assertCodexModelListResponse } from "./client-C8lgBOoO.mjs";
 import { normalizeOptionalString, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 1e4;
@@ -32,8 +32,8 @@ async function withCodexAppServerModelRequest(options, run) {
 	if (options.request) return await run(options.request);
 	const timeoutMs = options.timeoutMs ?? 1e4;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-CJCTeFpQ.mjs").then((n) => n.v);
-	const { requestCodexAppServerClientJson } = await import("./request-BZOfsSXW.mjs").then((n) => n.a);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-qhyYWbew.mjs").then((n) => n.v);
+	const { requestCodexAppServerClientJson } = await import("./request-jSbhc1sg.mjs").then((n) => n.i);
 	const client = await (useSharedClient ? getLeasedSharedCodexAppServerClient : createIsolatedCodexAppServerClient)({
 		startOptions: options.startOptions,
 		timeoutMs,
@@ -66,7 +66,7 @@ async function requestModelListPage(request, options) {
 }
 function readModelListResult(value) {
 	const response = assertCodexModelListResponse(value);
-	const models = response.data.map((entry) => readCodexModel(entry));
+	const models = response.data.map(readCodexModel);
 	const nextCursor = response.nextCursor ?? void 0;
 	return {
 		models,
@@ -77,17 +77,20 @@ function readCodexModel(value) {
 	const id = normalizeOptionalString(value.id);
 	const model = normalizeOptionalString(value.model);
 	if (!id || !model) throw new Error("Invalid Codex app-server model/list response: model id and name must be non-empty strings");
+	const displayName = normalizeOptionalString(value.displayName);
+	const description = normalizeOptionalString(value.description);
+	const defaultReasoningEffort = normalizeOptionalString(value.defaultReasoningEffort);
 	return {
 		id,
 		model,
-		...normalizeOptionalString(value.displayName) ? { displayName: normalizeOptionalString(value.displayName) } : {},
-		...normalizeOptionalString(value.description) ? { description: normalizeOptionalString(value.description) } : {},
+		...displayName ? { displayName } : {},
+		...description ? { description } : {},
 		hidden: value.hidden,
 		isDefault: value.isDefault,
 		inputModalities: value.inputModalities,
 		serviceTiers: normalizeUniqueTrimmedStringList((value.serviceTiers ?? []).map((tier) => tier.id)),
 		supportedReasoningEfforts: normalizeUniqueTrimmedStringList(value.supportedReasoningEfforts.map((entry) => entry.reasoningEffort)),
-		...normalizeOptionalString(value.defaultReasoningEffort) ? { defaultReasoningEffort: normalizeOptionalString(value.defaultReasoningEffort) } : {},
+		...defaultReasoningEffort ? { defaultReasoningEffort } : {},
 		...value.multiAgentVersion !== void 0 ? { multiAgentVersion: value.multiAgentVersion } : {}
 	};
 }

package/dist/.setup/{native-auth-CuG53tu4.mjs → native-auth-Cjb9y7IZ.mjs}

@@ -1,10 +1,10 @@
-import { d as readCodexPluginConfig } from "./config-parsing-b088LyhT.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-BQq-CHTF.mjs";
 import { n as isCodexAppServerProxyLaunch, t as buildCodexLoginStatusArgs } from "./launch-args-DbFCehO7.mjs";
-import { r as resolveManagedCodexAppServerStartOptions } from "./managed-binary-kiWRhNRE.mjs";
-import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-Bdegpn2V.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
-import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
+import { r as resolveManagedCodexAppServerStartOptions } from "./managed-binary-C1VFoVPf.mjs";
+import { n as resolveCodexAppServerSpawnEnv } from "./transport-stdio-a0HDa2Mj.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-cUYrqu_a.mjs";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
+import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 //#region extensions/codex/src/app-server/native-auth.ts
 const OPENAI_LOGIN_MODES = {
 	"Logged in using ChatGPT": "oauth",
@@ -22,7 +22,6 @@ async function probeCodexNativeAuth(params) {
 		});
 		if (options.start.transport !== "stdio" || options.start.homeScope !== "user" || isCodexAppServerProxyLaunch(options.start.args)) return;
 		const start = await resolveManagedCodexAppServerStartOptions(options.start, { pluginRoot: params.pluginRoot });
-		if (start.transport !== "stdio") return;
 		const env = resolveCodexAppServerSpawnEnv(start, params.env ?? process.env);
 		const invocation = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
 			command: start.command,

package/dist/.setup/{native-execution-policy-BxZJy5mP.mjs → native-execution-policy-ClzpdG3D.mjs}

@@ -16,11 +16,7 @@ function resolveCodexNodeExecToolOverrides(policy) {
 function resolveCodexNativeExecutionPolicy(params) {
 	const config = params.config ?? {};
 	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim() || void 0;
-	const agentId = resolvePolicyAgentId({
-		config,
-		sessionKey,
-		agentId: params.agentId
-	});
+	const agentId = normalizeAgentIdOrDefault(params.agentId) ?? parseAgentIdFromSessionKey(sessionKey) ?? tryResolveDefaultAgentId(config);
 	const canReadSessionEntry = Boolean(agentId) && params.readRuntimeSessionEntry && shouldReadRuntimeSessionEntry({
 		config,
 		sessionKey,
@@ -58,13 +54,6 @@ function formatCodexNativeNodeExecBlock(params) {
 		"Use a normal Codex harness turn so OpenClaw exec/process tools run on the node, or switch exec host to gateway for native Codex app-server execution."
 	].join(" ");
 }
-function resolvePolicyAgentId(params) {
-	const explicitAgentId = normalizeAgentIdOrDefault(params.agentId);
-	if (explicitAgentId) return explicitAgentId;
-	const sessionAgentId = parseAgentIdFromSessionKey(params.sessionKey);
-	if (sessionAgentId) return sessionAgentId;
-	return tryResolveDefaultAgentId(params.config);
-}
 function parseAgentIdFromSessionKey(sessionKey) {
 	const raw = sessionKey?.trim();
 	if (!raw) return;