@openclaw/codex 2026.9.2 → 2026.9.3

package/dist/auth-profile-selection-DFu9e167.js

@@ -0,0 +1,45 @@
+import { resolveDefaultAgentDir } from "openclaw/plugin-sdk/agent-harness-registration";
+//#region extensions/codex/src/app-server/auth-profile-selection.ts
+const CODEX_APP_SERVER_AUTH_PROVIDER = "openai";
+const CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS = [CODEX_APP_SERVER_AUTH_PROVIDER];
+function createCodexAuthProfileSelection({ ensureAuthProfileStore, resolveAuthProfileOrder }) {
+	function resolveCodexAppServerAuthProfileId(params) {
+		const requested = params.authProfileId?.trim();
+		if (requested) return requested;
+		return resolveAuthProfileOrder({
+			cfg: params.config,
+			store: params.store,
+			provider: CODEX_APP_SERVER_AUTH_PROVIDER
+		})[0]?.trim();
+	}
+	function resolveCodexAppServerAuthProfileIdForAgent(params) {
+		const store = resolveCodexAppServerAuthProfileStore({
+			agentDir: params.agentDir?.trim() || resolveDefaultAgentDir(params.config ?? {}),
+			authProfileId: params.authProfileId,
+			authProfileStore: params.authProfileStore,
+			config: params.config
+		});
+		return resolveCodexAppServerAuthProfileId({
+			authProfileId: params.authProfileId,
+			store,
+			config: params.config
+		});
+	}
+	function resolveCodexAppServerAuthProfileStore(params) {
+		if (params.authProfileStore) return params.authProfileStore;
+		return ensureAuthProfileStore(params.agentDir, {
+			profileId: params.authProfileId,
+			allowKeychainPrompt: false,
+			config: params.config,
+			externalCliProviderIds: CODEX_APP_SERVER_EXTERNAL_CLI_PROVIDER_IDS,
+			...params.authProfileId ? { externalCliProfileIds: [params.authProfileId] } : {}
+		});
+	}
+	return {
+		resolveCodexAppServerAuthProfileId,
+		resolveCodexAppServerAuthProfileIdForAgent,
+		resolveCodexAppServerAuthProfileStore
+	};
+}
+//#endregion
+export { createCodexAuthProfileSelection as n, CODEX_APP_SERVER_AUTH_PROVIDER as t };

package/dist/binding-connection-QqgcPCgk.js

@@ -0,0 +1,60 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { x as readCodexPluginConfig } from "./protocol-CAAcVIKF.js";
+import { a as resolveCodexCatalogConnectionHome, t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-CdSQzWyX.js";
+import { n as resolveCodexAppServerRuntimeOptions, r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-registration";
+//#region extensions/codex/src/app-server/binding-connection.ts
+var binding_connection_exports = /* @__PURE__ */ __exportAll({
+	assertCodexSessionRuntimeOwnership: () => assertCodexSessionRuntimeOwnership,
+	requireCodexSupervisionModelSelection: () => requireCodexSupervisionModelSelection,
+	resolveCodexBindingAppServerConnection: () => resolveCodexBindingAppServerConnection
+});
+/** Prevents a prepared native session from becoming a fresh thread after its binding changes. */
+function assertCodexSessionRuntimeOwnership(binding, expected) {
+	if (!expected) return;
+	const auth = binding?.connectionScope === "supervision" ? "native" : "host";
+	const hostModelChanged = expected.auth === "host" && (!expected.modelRef || binding?.model !== expected.modelRef.model || binding?.modelProvider !== expected.modelRef.provider);
+	if (binding?.preserveNativeModel !== true || auth !== expected.auth || hostModelChanged) throw new AgentHarnessPreflightError("Codex native session ownership is missing or changed. Reattach the original native session or create a new chat with a concrete model; no replacement thread was started.");
+}
+/** Requires the native model pair after a supervised pending branch has materialized. */
+function requireCodexSupervisionModelSelection(binding) {
+	const model = binding.model?.trim();
+	const modelProvider = binding.modelProvider?.trim();
+	if (binding.connectionScope !== "supervision" || !model || !modelProvider) throw new Error("Codex supervised binding is missing its native model and provider; refusing request selection");
+	return {
+		model,
+		modelProvider
+	};
+}
+/** Resolves connection and auth ownership exclusively from the private thread binding. */
+function resolveCodexBindingAppServerConnection(params) {
+	const { binding, authProfileId, ...runtimeParams } = params;
+	const usesSupervisionConnection = binding?.connectionScope === "supervision";
+	if (usesSupervisionConnection && readCodexPluginConfig(runtimeParams.pluginConfig).supervision?.enabled !== true) throw new Error("Codex supervision is disabled; refusing to open a native user-home supervised session");
+	let appServer = (usesSupervisionConnection ? resolveCodexSupervisionAppServerRuntimeOptions : resolveCodexAppServerRuntimeOptions)(runtimeParams);
+	if (usesSupervisionConnection) {
+		const persistedFingerprint = binding.pendingSupervisionBranch?.connectionFingerprint ?? binding.appServerRuntimeFingerprint;
+		const catalogHome = persistedFingerprint ? resolveCodexCatalogConnectionHome(persistedFingerprint, runtimeParams.agentDir) : void 0;
+		if (catalogHome) appServer = {
+			...appServer,
+			start: {
+				...appServer.start,
+				homeScope: "user",
+				env: {
+					...appServer.start.env,
+					CODEX_HOME: catalogHome
+				}
+			}
+		};
+		const currentFingerprint = buildCodexAppServerConnectionFingerprint(appServer, runtimeParams.agentDir);
+		if (!persistedFingerprint || persistedFingerprint !== currentFingerprint) throw new Error("Codex supervision connection changed; refusing to operate on its bound native thread");
+	}
+	return {
+		appServer,
+		usesSupervisionConnection,
+		requestAuthProfileId: usesSupervisionConnection ? void 0 : authProfileId,
+		clientAuthProfileId: usesSupervisionConnection ? null : authProfileId
+	};
+}
+//#endregion
+export { resolveCodexBindingAppServerConnection as i, binding_connection_exports as n, requireCodexSupervisionModelSelection as r, assertCodexSessionRuntimeOwnership as t };

package/dist/{bounded-turn-DxGJRYbY.js → bounded-turn-lRpmZHFv.js}

@@ -1,15 +1,15 @@
-import { B as isJsonObject, i as resolveCodexAppServerRuntimeOptions } from "./config-CyapYSji.js";
-import { at as readCodexErrorNotification, ct as createCodexElicitationResponse, nt as assertCodexThreadStartResponse, rt as assertCodexTurnStartResponse, st as readCodexTurnCompletedNotification, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CKhX2kFt.js";
-import { m as readCodexAppServerConfigOptions } from "./managed-binary-DcpnJF9x.js";
-import { _ as readCodexNotificationTurnId, a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-Bp1ZOnk2.js";
-import { c as isRetryableErrorNotification, l as isTerminalTurnStatus, t as CodexUsageProjection, u as readCodexNotificationItem } from "./event-projector-usage-ZqEVbAEY.js";
-import { r as readModelListResult } from "./models-CcrgSMQR.js";
-import { Et as mergeCodexThreadConfigs, G as attestCodexRestrictedToolSurfaceMcpServersDisabled, _ as buildCodexRingZeroThreadConfigPatch, b as readCodexInheritedMcpServerNames, g as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-DPK30jad.js";
-import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { r as readCodexAppServerConfigOptions } from "./launch-args-RXQwn8zV.js";
+import { C as readCodexErrorNotification, E as createCodexElicitationResponse, b as assertCodexThreadStartResponse, x as assertCodexTurnStartResponse } from "./client-BEKu4yDx.js";
+import "./config-JDfTI4VI.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-BWf6JLWG.js";
+import { u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort, o as interruptCodexTurnAndWaitBestEffort, t as CODEX_APP_SERVER_INTERRUPT_TIMEOUT_MS } from "./attempt-client-cleanup-D6cR54TV.js";
+import { t as CodexEphemeralTurn } from "./ephemeral-turn-DSwzP8YY.js";
+import { r as readModelListResult } from "./models-P9k2qAof.js";
+import { G as attestCodexRestrictedToolSurfaceMcpServersDisabled, Tt as mergeCodexThreadConfigs, _ as buildCodexRingZeroThreadConfigPatch, b as readCodexInheritedMcpServerNames, g as assertCodexManagedRequirementsDoNotOverrideToolPolicy, v as buildCodexRuntimeThreadConfig } from "./thread-lifecycle-D1pzRwHB.js";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import fs from "node:fs/promises";
 import path from "node:path";
-import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import fs from "node:fs/promises";
 import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/codex/src/app-server/bounded-turn.ts
 const CODEX_APP_SERVER_ARGS_ENV_KEY = "OPENCLAW_CODEX_APP_SERVER_ARGS";
@@ -79,7 +79,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 		assertCurrent: params.assertCurrent,
 		...params.signal ? { abandonSignal: params.signal } : {}
 	};
-	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CKhX2kFt.js").then((n) => n.x).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	const client = params.options.clientFactory ? await params.options.clientFactory(clientOptions) : await import("./shared-client-CVhez2Uo.js").then((n) => n.y).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		...clientOptions,
 		authProfileStore: params.authProfileStore
 	}));
@@ -147,9 +147,10 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			items: params.historyItems
 		}, requestOptions);
 		params.assertCurrent?.();
-		const collector = createCodexBoundedTurnCollector(thread.thread.id, params.taskLabel, params.allowEmptyText === true);
-		const cleanup = client.addNotificationHandler(collector.handleNotification);
-		const requestCleanup = client.addRequestHandler(createCodexBoundedApprovalHandler(params.taskLabel));
+		const collector = new CodexEphemeralTurn(client, thread.thread.id, {
+			textMode: "all",
+			onRequest: createCodexBoundedApprovalHandler(params.taskLabel)
+		});
 		try {
 			const turn = assertCodexTurnStartResponse(await client.request("turn/start", {
 				threadId: thread.thread.id,
@@ -159,13 +160,18 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			}, requestOptions));
 			activeTurnId = turn.turn.id;
 			if (abortController.signal.aborted) requestInterrupt();
-			const result = await collector.collect(turn.turn, {
+			const result = await collector.wait(turn.turn, {
 				signal: abortController.signal,
-				timeoutError
+				abortError: () => resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError)
 			});
+			if (result.error || result.turn?.status === "failed") throw new Error((result.error ? readCodexErrorNotification(result.error)?.error.message : result.turn?.error?.message) ?? `codex app-server ${params.taskLabel} turn failed`);
+			if (result.turn?.status !== "completed") throw new Error(`codex app-server ${params.taskLabel} turn ended with status ${result.turn?.status ?? "unknown"}`);
+			if (!result.text && !params.allowEmptyText) throw new Error(`Codex app-server ${params.taskLabel} turn returned no text.`);
 			params.assertCurrent?.();
 			return {
-				...result,
+				text: result.text,
+				items: result.items,
+				usage: result.usage,
 				model: modelSelection.catalogId,
 				nativeSelection: {
 					model: thread.model,
@@ -174,8 +180,7 @@ async function runBoundedCodexAppServerTurnInWorkspace(params, appServer, worksp
 			};
 		} finally {
 			await interruptPromise;
-			requestCleanup();
-			cleanup();
+			collector.route.release();
 		}
 	} catch (error) {
 		if (abortController.signal.aborted) throw resolveCodexBoundedTurnAbortError(abortController.signal, params.taskLabel, timeoutError);
@@ -269,110 +274,8 @@ async function resolveCodexBoundedTurnModel(params) {
 		runtimeModelId: match.model
 	};
 }
-function createCodexBoundedTurnCollector(threadId, taskLabel, allowEmptyText) {
-	let turnId;
-	let completedTurn;
-	let promptError;
-	const usageProjection = new CodexUsageProjection();
-	const pending = [];
-	const completedItems = /* @__PURE__ */ new Map();
-	const assistantTextByItem = /* @__PURE__ */ new Map();
-	const assistantItemOrder = [];
-	const { promise: completion, resolve: resolveCompletion } = createDeferred();
-	const rememberAssistantText = (itemId, text) => {
-		if (!text) return;
-		if (!assistantTextByItem.has(itemId)) assistantItemOrder.push(itemId);
-		assistantTextByItem.set(itemId, text);
-	};
-	const handleNotification = (notification) => {
-		const params = isJsonObject(notification.params) ? notification.params : void 0;
-		if (!params || readStringField(params, "threadId") !== threadId) return;
-		if (!turnId) {
-			pending.push(notification);
-			return;
-		}
-		if (readCodexNotificationTurnId(params) !== turnId) return;
-		if (notification.method === "item/completed") {
-			const item = readCodexNotificationItem(notification.params);
-			if (item) {
-				completedItems.set(item.id, item);
-				if (item.type === "agentMessage" && typeof item.text === "string") rememberAssistantText(item.id, item.text);
-			}
-			return;
-		}
-		if (notification.method === "item/agentMessage/delta") {
-			const itemId = readStringField(params, "itemId") ?? readStringField(params, "id") ?? "assistant";
-			const delta = readStringField(params, "delta") ?? "";
-			rememberAssistantText(itemId, `${assistantTextByItem.get(itemId) ?? ""}${delta}`);
-			return;
-		}
-		if (notification.method === "rawResponse/completed") {
-			usageProjection.record(params);
-			return;
-		}
-		if (notification.method === "turn/completed") {
-			completedTurn = readCodexTurnCompletedNotification(notification.params)?.turn ?? completedTurn;
-			resolveCompletion();
-			return;
-		}
-		if (notification.method === "error") {
-			usageProjection.invalidateContext();
-			if (isRetryableErrorNotification(notification.params)) return;
-			promptError = readCodexErrorNotification(notification.params)?.error.message ?? `codex app-server ${taskLabel} turn failed`;
-			resolveCompletion();
-		}
-	};
-	return {
-		handleNotification,
-		async collect(startedTurn, options) {
-			turnId = startedTurn.id;
-			if (isTerminalTurnStatus(startedTurn.status)) completedTurn = startedTurn;
-			for (const notification of pending.splice(0)) handleNotification(notification);
-			if (!completedTurn && !promptError) await waitForTurnCompletion({
-				completion,
-				signal: options.signal,
-				taskLabel,
-				timeoutError: options.timeoutError
-			});
-			if (promptError) throw new Error(promptError);
-			if (completedTurn?.status === "failed") throw new Error(completedTurn.error?.message ?? `codex app-server ${taskLabel} turn failed`);
-			if (completedTurn?.status !== "completed") throw new Error(`codex app-server ${taskLabel} turn ended with status ${completedTurn?.status ?? "unknown"}`);
-			const items = collectCompletedItems(completedTurn?.items, completedItems);
-			const itemText = collectAssistantTextFromItems(items);
-			const deltaText = assistantItemOrder.map((itemId) => assistantTextByItem.get(itemId)?.trim()).filter((text) => Boolean(text)).join("\n\n").trim();
-			const text = (itemText || deltaText).trim();
-			if (!text && !allowEmptyText) throw new Error(`Codex app-server ${taskLabel} turn returned no text.`);
-			return {
-				text,
-				items,
-				usage: usageProjection.usage
-			};
-		}
-	};
-}
-function collectCompletedItems(turnItems, notificationItems) {
-	const items = new Map(notificationItems);
-	for (const item of turnItems ?? []) items.set(item.id, item);
-	return [...items.values()];
-}
-async function waitForTurnCompletion(params) {
-	if (params.signal.aborted) throw resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError);
-	let cleanupAbort;
-	try {
-		await Promise.race([params.completion, new Promise((_, reject) => {
-			const abortListener = () => reject(resolveCodexBoundedTurnAbortError(params.signal, params.taskLabel, params.timeoutError));
-			params.signal.addEventListener("abort", abortListener, { once: true });
-			cleanupAbort = () => params.signal.removeEventListener("abort", abortListener);
-		})]);
-	} finally {
-		cleanupAbort?.();
-	}
-}
 function resolveCodexBoundedTurnAbortError(signal, taskLabel, timeoutError) {
 	return signal.reason === timeoutError ? timeoutError : /* @__PURE__ */ new Error(`codex app-server ${taskLabel} turn aborted`);
 }
-function collectAssistantTextFromItems(items) {
-	return (items ?? []).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean).join("\n\n").trim();
-}
 //#endregion
-export { runBoundedCodexAppServerTurn as t };
+export { runBoundedCodexAppServerTurn };

package/dist/build-state-6RL6qohz.js

@@ -0,0 +1,19 @@
+//#region extensions/codex/package.json
+var version = "2026.9.3";
+//#endregion
+//#region extensions/codex/src/build-state.ts
+/**
+* Duplicate module copies share one immutable published version's state.
+* In-process restarts retain old records and callbacks for their old owners.
+* Local rebuilds without a version bump deliberately share the same state.
+*/
+function codexBuildSymbol(name) {
+	return Symbol.for(`${name}@${version}`);
+}
+function defineCodexBuildState(name, create) {
+	const key = codexBuildSymbol(name);
+	const globalState = globalThis;
+	return () => globalState[key] ??= create();
+}
+//#endregion
+export { defineCodexBuildState as n, codexBuildSymbol as t };

package/dist/{capabilities-B1mgvpP8.js → capabilities-BeqLPbtM.js}

@@ -1,4 +1,4 @@
-import { q as CodexAppServerRpcError } from "./shared-client-CKhX2kFt.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
 //#region extensions/codex/src/app-server/capabilities.ts
 /**
 * Capability helpers for optional Codex app-server control-plane methods.

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-BjLhpmS1.js");
+		const { registerCodexSessionCli } = await import("./session-cli-CbgaHh0f.js");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",