@openclaw/codex 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/event-projector-assistant-message-DTgnPPVF.js

@@ -0,0 +1,101 @@
+import { formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/local-runtime-attribution.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_RESPONSES_API = "openai-responses";
+const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
+function normalizeRuntimeId(value) {
+	return value?.trim().toLowerCase() ?? "";
+}
+/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
+function resolveCodexLocalRuntimeAttribution(params) {
+	const authProfileProvider = normalizeRuntimeId(params.runtimePlan?.auth?.authProfileProviderForAuth);
+	if (normalizeRuntimeId(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.provider) === OPENAI_PROVIDER_ID && normalizeRuntimeId(params.model.api) === OPENAI_RESPONSES_API) return {
+		provider: OPENAI_PROVIDER_ID,
+		api: OPENAI_CODEX_RESPONSES_API
+	};
+	return {
+		provider: params.provider,
+		api: params.model.api
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-assistant-message.ts
+const ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+function createAssistantMessage(params, text, options) {
+	const attribution = resolveCodexLocalRuntimeAttribution(params);
+	const usage = options.tokenUsage ? {
+		input: options.tokenUsage.input ?? 0,
+		output: options.tokenUsage.output ?? 0,
+		cacheRead: options.tokenUsage.cacheRead ?? 0,
+		cacheWrite: options.tokenUsage.cacheWrite ?? 0,
+		...options.tokenUsage.contextUsage ? { contextUsage: options.tokenUsage.contextUsage } : {},
+		totalTokens: options.tokenUsage.total ?? (options.tokenUsage.input ?? 0) + (options.tokenUsage.output ?? 0) + (options.tokenUsage.cacheRead ?? 0) + (options.tokenUsage.cacheWrite ?? 0),
+		cost: ZERO_USAGE.cost
+	} : ZERO_USAGE;
+	return {
+		role: "assistant",
+		content: [{
+			type: "text",
+			text
+		}],
+		api: attribution.api ?? "openai-chatgpt-responses",
+		provider: attribution.provider,
+		model: params.modelId,
+		usage,
+		stopReason: options.aborted ? "aborted" : options.promptError ? "error" : "stop",
+		errorMessage: options.promptError ? formatErrorMessage(options.promptError) : void 0,
+		timestamp: Date.now()
+	};
+}
+function createAssistantCommentaryMessage(params, text, itemId, timestamp) {
+	const attribution = resolveCodexLocalRuntimeAttribution(params);
+	return {
+		role: "assistant",
+		content: [{
+			type: "text",
+			text
+		}],
+		api: attribution.api ?? "openai-chatgpt-responses",
+		provider: attribution.provider,
+		model: params.modelId,
+		usage: ZERO_USAGE,
+		stopReason: "stop",
+		timestamp,
+		openclawStreamFallback: {
+			replacementText: text,
+			source: "segment",
+			itemId
+		}
+	};
+}
+function createAssistantMirrorMessage(params, title, text) {
+	const attribution = resolveCodexLocalRuntimeAttribution(params);
+	return {
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: `${title}:\n${text}`
+		}],
+		api: attribution.api ?? "openai-chatgpt-responses",
+		provider: attribution.provider,
+		model: params.modelId,
+		usage: ZERO_USAGE,
+		stopReason: "stop",
+		timestamp: Date.now()
+	};
+}
+//#endregion
+export { resolveCodexLocalRuntimeAttribution as i, createAssistantMessage as n, createAssistantMirrorMessage as r, createAssistantCommentaryMessage as t };

package/dist/event-projector-usage-D6tE7_qD.js

@@ -0,0 +1,69 @@
+import { Q as isJsonObject } from "./shared-client-wmgNFNYp.js";
+import { dt as readNonNegativeInteger, pt as readNumber } from "./thread-lifecycle-cqrOlJkq.js";
+import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/event-projector-usage.ts
+function readTokenCount(record, key) {
+	const value = readNonNegativeInteger(record, key);
+	return value !== void 0 && Number.isSafeInteger(value) ? value : void 0;
+}
+function readCodexThreadTokenUsage(params) {
+	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
+	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
+	return last ? normalizeCodexThreadTokenUsage(last) : void 0;
+}
+function readCodexThreadContextSnapshot(params) {
+	const tokenUsage = isJsonObject(params.tokenUsage) ? params.tokenUsage : void 0;
+	const last = tokenUsage && isJsonObject(tokenUsage.last) ? tokenUsage.last : void 0;
+	const modelContextWindow = tokenUsage ? readTokenCount(tokenUsage, "modelContextWindow") : void 0;
+	const promptTokens = last ? readTokenCount(last, "inputTokens") : void 0;
+	return {
+		...modelContextWindow && modelContextWindow > 0 ? { modelContextWindow } : {},
+		...promptTokens !== void 0 ? { promptTokens } : {}
+	};
+}
+function projectCodexThreadUsageUpdate(params, currentUsage, applyUsage, emitContext) {
+	applyUsage(readCodexThreadTokenUsage(params) ?? currentUsage);
+	const context = readCodexThreadContextSnapshot(params);
+	if (context.modelContextWindow !== void 0 || context.promptTokens !== void 0) emitContext(context);
+}
+function normalizeCodexThreadTokenUsage(record) {
+	const inputTokens = readNumber(record, "inputTokens");
+	const cacheRead = readNumber(record, "cachedInputTokens");
+	const usage = normalizeUsage({
+		input: inputTokens !== void 0 && cacheRead !== void 0 ? Math.max(0, inputTokens - cacheRead) : inputTokens,
+		output: readNumber(record, "outputTokens"),
+		cacheRead,
+		total: readNumber(record, "totalTokens")
+	});
+	return usage ? {
+		...usage,
+		contextUsage: { state: "unavailable" }
+	} : void 0;
+}
+function normalizeCodexResponseTokenUsage(record) {
+	const totalTokens = readTokenCount(record, "totalTokens");
+	const inputTokens = readTokenCount(record, "inputTokens");
+	const cacheRead = readTokenCount(record, "cachedInputTokens");
+	const output = readTokenCount(record, "outputTokens");
+	const reasoningOutput = readTokenCount(record, "reasoningOutputTokens");
+	const cacheWrite = record.cacheWriteInputTokens === void 0 ? 0 : readTokenCount(record, "cacheWriteInputTokens");
+	if (totalTokens === void 0 || inputTokens === void 0 || cacheRead === void 0 || cacheWrite === void 0 || output === void 0 || reasoningOutput === void 0 || cacheRead + cacheWrite > inputTokens || totalTokens !== inputTokens + output) return;
+	const usage = normalizeUsage({
+		input: inputTokens - cacheRead - cacheWrite,
+		output,
+		cacheRead,
+		cacheWrite,
+		total: totalTokens
+	});
+	if (!usage) return;
+	return {
+		...usage,
+		contextUsage: {
+			state: "available",
+			promptTokens: inputTokens,
+			totalTokens
+		}
+	};
+}
+//#endregion
+export { projectCodexThreadUsageUpdate as n, normalizeCodexResponseTokenUsage as t };

package/dist/harness.js

@@ -22,13 +22,29 @@ function createCodexAppServerAgentHarness(options) {
 	const harnessRuntimeId = options?.id ?? "codex";
 	const normalizedHarnessRuntimeId = harnessRuntimeId.trim().toLowerCase();
 	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
+	const sessionCatalogControl = options.sessionCatalogControl;
+	const sessionRuntime = options.runtime;
 	return {
 		id: harnessRuntimeId,
 		label: options?.label ?? "Codex agent harness",
+		autoSelection: { providerIds: [...providerIds] },
 		delegatedExecutionPluginIds: ["voice-call"],
 		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
-		deliveryDefaults: { sourceVisibleReplies: "message_tool" },
+		deliveryDefaults: { visibleReplies: "message_tool" },
 		authBootstrap: "harness",
+		...sessionCatalogControl && sessionRuntime ? { sessionFork: {
+			upstreamKinds: ["codex-app-server"],
+			fork: async (params) => {
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-vPjwkT1i.js");
+				return await forkCodexUpstreamSession(params, {
+					bindingStore: options.bindingStore,
+					control: sessionCatalogControl,
+					harnessRuntimeId,
+					resolveConfig: options.resolveConfig,
+					runtime: sessionRuntime
+				});
+			}
+		} } : {},
 		authBinding: { fingerprint: async (params) => {
 			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-C1czuHPA.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
@@ -38,7 +54,7 @@ function createCodexAppServerAgentHarness(options) {
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-D5Rohxoc.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-DM_I3mPT.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		supports: (ctx) => {
@@ -79,15 +95,19 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-MLzoMe_m.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt--858NXDl.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
 				nativeHookRelay: { enabled: true }
 			});
 		},
+		finalizeSettledTurn: async (params) => {
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-DHltNgtF.js");
+			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
+		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-DqDvIwSU.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-BfFZCsJ-.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -95,14 +115,14 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-DCTmg3id.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CC5KhBzX.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		compactAfterContextEngine: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-DCTmg3id.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CC5KhBzX.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -111,7 +131,7 @@ function createCodexAppServerAgentHarness(options) {
 		},
 		reset: async (params) => {
 			if (params.sessionId) {
-				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-h1mmCGnl.js").then((n) => n.l);
+				const { reclaimCurrentCodexSessionGeneration, sessionBindingIdentity } = await import("./session-binding-ZSMX1omP.js").then((n) => n.u);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,

package/dist/incognito-session-ET_ufDH-.js

@@ -0,0 +1,2 @@
+import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
+export { isIncognitoSessionKey as t };

package/dist/index.js

@@ -1,20 +1,22 @@
 import { registerCodexCliMetadata } from "./cli-metadata.js";
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import { C as resolveCodexAppServerFallbackApiKeyCacheKey, J as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, S as resolveCodexAppServerAuthProfileIdForAgent, Z as isJsonObject, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerAuthAccountCacheKey, c as releaseLeasedSharedCodexAppServerClient, p as withLeasedCodexAppServerClientStartSelectionRetry, r as clearSharedCodexAppServerClientIfCurrentAndWait, s as releaseCodexAppServerClientLease } from "./shared-client-JiAnW6pc.js";
-import { D as resolveOpenClawExecPolicyForCodexAppServer, E as resolveCodexSupervisionAppServerRuntimeOptions, a as isCodexAppServerNativeAuthProfile, b as resolveCodexAppServerRuntimeOptions, c as sessionBindingIdentity, f as assertCodexAppServerConnectionSecurity, h as codexSandboxPolicyForTurn, m as codexAppServerStartOptionsKey, n as assertCodexBindingMayBeReplaced, o as normalizeCodexAppServerBindingModelProvider, p as canUseCodexModelBackedApprovalsReviewerForModel, u as CODEX_PLUGINS_MARKETPLACE_NAME, y as readCodexPluginConfig } from "./session-binding-h1mmCGnl.js";
-import { d as assertCodexThreadStartResponse } from "./transcript-mirror-D9rTxx2P.js";
-import { i as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-Ceb-lm2c.js";
-import { X as ensureCodexPluginActivation, Z as pluginReadParams, c as resumeCodexAppServerThread, h as resolveCodexAppServerRequestModelSelection, p as CODEX_NATIVE_PERSONALITY_NONE } from "./thread-lifecycle-CN_pPtPh.js";
+import { C as resolveCodexAppServerFallbackApiKeyCacheKey, Q as isJsonObject, S as resolveCodexAppServerAuthProfileIdForAgent, Y as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, a as getLeasedSharedCodexAppServerClient, b as resolveCodexAppServerAuthAccountCacheKey, c as releaseLeasedSharedCodexAppServerClient, p as withLeasedCodexAppServerClientStartSelectionRetry, r as clearSharedCodexAppServerClientIfCurrentAndWait, s as releaseCodexAppServerClientLease } from "./shared-client-wmgNFNYp.js";
+import { D as resolveCodexSupervisionAppServerRuntimeOptions, O as resolveOpenClawExecPolicyForCodexAppServer, b as readCodexPluginConfig, d as CODEX_PLUGINS_MARKETPLACE_NAME, g as codexSandboxPolicyForTurn, h as codexAppServerStartOptionsKey, l as sessionBindingIdentity, m as canUseCodexModelBackedApprovalsReviewerForModel, n as assertCodexBindingMayBeReplaced, o as isCodexAppServerNativeAuthProfile, p as assertCodexAppServerConnectionSecurity, s as normalizeCodexAppServerBindingModelProvider, x as resolveCodexAppServerRuntimeOptions } from "./session-binding-ZSMX1omP.js";
+import { N as CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS, R as unsubscribeCodexThreadBestEffort, _ as CODEX_NATIVE_PERSONALITY_NONE, c as resumeCodexAppServerThread, et as ensureCodexPluginActivation, tt as pluginReadParams, y as resolveCodexAppServerRequestModelSelection } from "./thread-lifecycle-cqrOlJkq.js";
+import { _ as assertCodexThreadStartResponse } from "./transcript-mirror-2p7kl6e4.js";
+import { i as defaultCodexAppInventoryCache, r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-CvzvmBRz.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
-import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-D31dOJwb.js";
-import { d as CODEX_CONTROL_METHODS, f as describeControlFailure, r as formatCodexDisplayText } from "./command-formatters-Dq9InZUK.js";
-import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-Scc-Wevo.js";
+import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
+import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CLICvTxf.js";
+import { r as formatCodexDisplayText } from "./command-formatters-DgADqnHa.js";
+import { t as resolveCodexAppServerForModelProvider } from "./app-server-policy-BO3jYBkv.js";
 import { n as resolveCodexNativeExecutionBlock, r as resolveCodexNativeSandboxBlock } from "./sandbox-guard-D1Wky__S.js";
-import { d as CODEX_NATIVE_EXECUTION_AUTH_ERROR, f as canMutateCodexHost, u as trackCodexConversationActiveTurn } from "./conversation-control-CGkBlfc5.js";
+import { d as CODEX_NATIVE_EXECUTION_AUTH_ERROR, f as canMutateCodexHost, u as trackCodexConversationActiveTurn } from "./conversation-control-sNPsbTCP.js";
 import { a as readCodexConversationBindingDataRecord, i as readCodexConversationBindingData, o as resolveCodexDefaultWorkspaceDir, r as createCodexConversationBindingData } from "./conversation-binding-data-BHRpYbX3.js";
-import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-KmfV4EkP.js";
-import { d as createCodexCliSessionNodeHostCommands, f as createCodexCliSessionNodeInvokePolicies, g as resumeCodexCliSessionOnNode, h as resolveCodexCliSessionForBindingOnNode, i as createCodexSessionCatalogNodeInvokePolicies, m as listCodexCliSessionsOnNode, n as createCodexSessionCatalogControl, o as codexControlRequest, r as createCodexSessionCatalogNodeHostCommands, t as codexSessionCatalogRuntime, u as assertCodexArchiveDescendantsUnowned } from "./session-catalog-CEvoXWHA.js";
-import { r as requestCodexAppServerJson } from "./request-B_oQsCXy.js";
+import { a as resolveCodexBindingAppServerConnection, n as readCodexNotificationThreadId, r as readCodexNotificationTurnId } from "./notification-correlation-BGLixv5_.js";
+import { d as createCodexCliSessionNodeHostCommands, f as createCodexCliSessionNodeInvokePolicies, g as resumeCodexCliSessionOnNode, h as resolveCodexCliSessionForBindingOnNode, i as createCodexSessionCatalogNodeInvokePolicies, m as listCodexCliSessionsOnNode, n as createCodexSessionCatalogControl, o as codexControlRequest, r as createCodexSessionCatalogNodeHostCommands, t as codexSessionCatalogRuntime, u as assertCodexArchiveDescendantsUnowned } from "./session-catalog-DsKaezgR.js";
+import { r as requestCodexAppServerJson } from "./request-BTccUTD3.js";
 import { t as createCodexWebSearchProviderBase } from "./web-search-provider.shared-BrZmlqyR.js";
 import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
 import { normalizePluginsConfig, resolveEffectiveEnableState, resolveLivePluginConfigObject, resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -34,7 +36,7 @@ import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { canonicalPathFromExistingAncestor, isPathInside, pathExists } from "openclaw/plugin-sdk/security-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { ModelSelectionLockedError, isModelSelectionLocked } from "openclaw/plugin-sdk/model-session-runtime";
-import { MIGRATION_REASON_TARGET_EXISTS, applyMigrationManualItem, createMigrationItem, createMigrationManualItem, hasMigrationConfigPatchConflict, markMigrationItemConflict, markMigrationItemError, markMigrationItemSkipped, readMigrationConfigPath, summarizeMigrationItems, writeMigrationConfigPath } from "openclaw/plugin-sdk/migration";
+import { MIGRATION_REASON_TARGET_EXISTS, applyMigrationManualItem, createMigrationItem, createMigrationManualItem, hasMigrationConfigPatchConflict, markMigrationItemConflict, markMigrationItemError, markMigrationItemSkipped, readMigrationConfigPath, resolveMigrationConfigRuntime, summarizeMigrationItems, writeMigrationConfigPath } from "openclaw/plugin-sdk/migration";
 import { archiveMigrationItem, copyMemoryMigrationFileItem, copyMigrationFileItem, withCachedMigrationConfigRuntime, writeMigrationReport } from "openclaw/plugin-sdk/migration-runtime";
 import { sleep } from "openclaw/plugin-sdk/runtime-env";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
@@ -45,7 +47,7 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 /** Defers schema compilation and auth loading until the first binding operation. */
 function createLazyCodexAppServerBindingStore(state) {
 	let resolved;
-	const store = () => resolved ??= import("./session-binding-h1mmCGnl.js").then((n) => n.l).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
+	const store = () => resolved ??= import("./session-binding-ZSMX1omP.js").then((n) => n.u).then(({ createCodexAppServerBindingStore }) => createCodexAppServerBindingStore(state));
 	return {
 		read: async (identity) => (await store()).read(identity),
 		hasOtherThreadOwner: async (threadId, currentIdentity) => (await store()).hasOtherThreadOwner(threadId, currentIdentity),
@@ -72,7 +74,7 @@ async function handleCodexCommand(ctx, options) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-IgqmL_kv.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-l_lVPNlB.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -569,7 +571,8 @@ async function requestNewConversationBindingThread(params, resolved) {
 			personality: CODEX_NATIVE_PERSONALITY_NONE,
 			...buildThreadRequestRuntimeOptions(params, resolved),
 			developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
-			experimentalRawEvents: true
+			experimentalRawEvents: true,
+			...isIncognitoSessionKey(params.sessionKey) ? { ephemeral: true } : {}
 		}, requestOptions),
 		onClientChange: (client) => {
 			resolved.client = client;
@@ -717,7 +720,8 @@ async function runBoundTurn(params) {
 					...modelScopedRuntime.networkProxy ? { config: modelScopedRuntime.networkProxy.configPatch } : { sandbox },
 					...serviceTier ? { serviceTier } : {},
 					developerInstructions: CODEX_CONVERSATION_THREAD_DEVELOPER_INSTRUCTIONS,
-					experimentalRawEvents: true
+					experimentalRawEvents: true,
+					...isIncognitoSessionKey(params.sessionKey) ? { ephemeral: true } : {}
 				}, requestOptions),
 				onClientChange: (nextClient) => {
 					client = nextClient;
@@ -834,6 +838,19 @@ async function runBoundTurn(params) {
 		});
 		collector.setTurnId(turnId);
 		return { reply: { text: (await collector.wait({ timeoutMs: params.timeoutMs ?? DEFAULT_BOUND_TURN_TIMEOUT_MS }).finally(activeCleanup)).replyText.trim() || "Codex completed without a text reply." } };
+	} catch (error) {
+		if (isIncognitoSessionKey(params.sessionKey)) {
+			const bindingReleased = await params.bindingStore.mutate(identity, {
+				kind: "clear",
+				threadId
+			});
+			const timedOut = error instanceof Error && error.message === "codex app-server bound turn timed out";
+			if (bindingReleased && !timedOut) await unsubscribeCodexThreadBestEffort(client, {
+				threadId,
+				timeoutMs: CODEX_APP_SERVER_UNSUBSCRIBE_TIMEOUT_MS
+			});
+		}
+		throw error;
 	} finally {
 		notificationCleanup();
 		requestCleanup();
@@ -1219,7 +1236,7 @@ function hasAuthProfileConfigConflict(config, profile, overwrite) {
 function hasCurrentAuthProfileConfigConflict(ctx, profile) {
 	let config = ctx.config;
 	try {
-		config = ctx.runtime?.config?.current?.() ?? config;
+		config = resolveMigrationConfigRuntime(ctx)?.current?.() ?? config;
 	} catch {}
 	return hasAuthProfileConfigConflict(config, profile, Boolean(ctx.overwrite));
 }
@@ -1310,7 +1327,7 @@ function authProfileConfigForCredential(credential, profileId) {
 	return credential.kind === "oauth" ? oauthAuthProfileConfig(credential, profileId) : apiKeyAuthProfileConfig(credential, profileId);
 }
 async function applyCodexAuthProfileConfig(ctx, profile, applyConfig) {
-	const configApi = ctx.runtime?.config;
+	const configApi = resolveMigrationConfigRuntime(ctx);
 	if (!configApi?.current || !configApi.mutateConfigFile) return "unavailable";
 	try {
 		await configApi.mutateConfigFile({
@@ -1386,6 +1403,7 @@ async function applyCodexAuthItem(params) {
 	let wrote = false;
 	const store = await updateAuthProfileStoreWithLock({
 		agentDir: targets.agentDir,
+		stateDir: ctx.stateDir,
 		updater: (freshStore) => {
 			const existing = freshStore.profiles[profileId];
 			if (!ctx.overwrite && existing) {
@@ -2086,6 +2104,7 @@ function buildPluginItems(ctx, plugins) {
 				action: "install",
 				status: conflict ? "conflict" : "planned",
 				reason: conflict ? MIGRATION_REASON_PLUGIN_EXISTS : void 0,
+				applyPhase: "after-promotion",
 				source: plugin.source,
 				target: `plugins.entries.codex.config.codexPlugins.plugins.${configKey}`,
 				message: `Install Codex plugin "${plugin.pluginName}" in the OpenClaw-managed Codex app-server runtime.`,
@@ -2215,6 +2234,7 @@ function buildPluginConfigItem(ctx, pluginItems) {
 		target: "plugins.entries.codex.config.codexPlugins",
 		status: conflict ? "conflict" : "planned",
 		reason: conflict ? MIGRATION_REASON_TARGET_EXISTS : void 0,
+		applyPhase: "after-promotion",
 		message: "Enable OpenClaw's Codex plugin integration and record migrated source-installed curated plugins.",
 		details: {
 			path: [...CODEX_PLUGIN_CONFIG_PATH],
@@ -2542,10 +2562,18 @@ async function buildTargetCodexPluginAppCacheKey(ctx) {
 	});
 }
 async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
+	if (appliedItems.filter((candidate) => candidate.kind === "plugin" && candidate.action === "install" && readCodexPluginPolicy(candidate) !== void 0 && !isCodexPluginConfigTerminal(candidate)).length > 0) return {
+		...item,
+		status: "warning",
+		reason: "selected Codex plugin activation is incomplete"
+	};
 	const entries = appliedItems.map(readAppliedPluginConfigEntry).filter((entry) => entry !== void 0);
-	if (entries.length === 0) return markMigrationItemSkipped(item, "no selected Codex plugins");
+	if (entries.length === 0) return {
+		...markMigrationItemSkipped(item, "no selected Codex plugins"),
+		deferredCompletion: true
+	};
 	const returnPatch = shouldReturnCodexPluginConfigPatch(ctx);
-	const configApi = ctx.runtime?.config;
+	const configApi = resolveMigrationConfigRuntime(ctx);
 	const currentConfig = returnPatch ? ctx.config : configApi?.current?.();
 	if (!currentConfig) return markMigrationItemError(item, "config runtime unavailable");
 	const value = buildCodexPluginsConfigValue(entries, { config: currentConfig });
@@ -2576,8 +2604,11 @@ async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
 		return markMigrationItemError(item, error instanceof Error ? error.message : String(error));
 	}
 }
+function isCodexPluginConfigTerminal(item) {
+	return item.status === "migrated" || item.status === "skipped" && (item.deferredCompletion === true || item.reason === CODEX_PLUGIN_NOT_SELECTED_REASON || item.reason === CODEX_PLUGIN_AUTH_REQUIRED_REASON);
+}
 function readAppliedPluginConfigEntry(item) {
-	if (item.status === "migrated") return readCodexPluginMigrationConfigEntry(item, true);
+	if (item.status === "migrated" || item.deferredCompletion === true) return readCodexPluginMigrationConfigEntry(item, true);
 	if (item.status === "skipped" && item.reason !== CODEX_PLUGIN_NOT_SELECTED_REASON && item.reason === CODEX_PLUGIN_AUTH_REQUIRED_REASON) return readCodexPluginMigrationConfigEntry(item, false);
 }
 function readCodexPluginPolicy(item) {
@@ -2620,6 +2651,7 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		plan: buildCodexMigrationPlan,
+		deferredApply: { retrySafe: true },
 		prepareApply(ctx) {
 			if (isMemoryOnlyMigration(ctx)) return;
 			return prepareTargetCodexAppServer(ctx);
@@ -3726,7 +3758,7 @@ function createCodexSupervisionTools(options) {
 }
 //#endregion
 //#region extensions/codex/src/web-search-provider.ts
-const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-CKVBn3fP.js"));
+const loadCodexWebSearchRuntime = createLazyRuntimeModule(() => import("./web-search-provider.runtime-Bx6HAc_k.js"));
 const CodexWebSearchSchema = {
 	type: "object",
 	properties: { query: {
@@ -3825,8 +3857,10 @@ var codex_default = definePluginEntry({
 		}, { names: [...CODEX_SUPERVISION_COMPAT_TOOL_NAMES] });
 		api.registerAgentHarness(createCodexAppServerAgentHarness({
 			bindingStore,
+			sessionCatalogControl,
 			resolveConfig: resolveCurrentConfig,
-			resolvePluginConfig: resolveCurrentPluginConfig
+			resolvePluginConfig: resolveCurrentPluginConfig,
+			runtime: api.runtime
 		}));
 		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
 		api.registerWebSearchProvider(createCodexWebSearchProvider({ resolvePluginConfig: resolveCurrentPluginConfig }));
@@ -3914,7 +3948,7 @@ var codex_default = definePluginEntry({
 			if (!previousSessionId || !sessionId || previousSessionId === sessionId) return;
 			const config = resolveCurrentConfig();
 			const sessionKey = ctx.sessionKey?.trim();
-			const { sessionBindingIdentity } = await import("./session-binding-h1mmCGnl.js").then((n) => n.l);
+			const { sessionBindingIdentity } = await import("./session-binding-ZSMX1omP.js").then((n) => n.u);
 			const identity = sessionBindingIdentity({
 				sessionId,
 				...sessionKey ? { sessionKey } : {},
@@ -3931,7 +3965,7 @@ var codex_default = definePluginEntry({
 			const nextSessionKey = event.nextSessionKey?.trim();
 			if (endedSessionKey && nextSessionKey && nextSessionKey !== endedSessionKey) return;
 			const config = resolveCurrentConfig();
-			const { sessionBindingIdentity } = await import("./session-binding-h1mmCGnl.js").then((n) => n.l);
+			const { sessionBindingIdentity } = await import("./session-binding-ZSMX1omP.js").then((n) => n.u);
 			await bindingStore.retireSessionGeneration(sessionBindingIdentity({
 				sessionId: event.sessionId,
 				...sessionKey ? { sessionKey } : {},

package/dist/media-understanding-provider.js

@@ -1,2 +1,169 @@
-import { t as buildCodexMediaUnderstandingProvider } from "./media-understanding-provider-D31dOJwb.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-CaQL96kg.js";
+import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
+//#region extensions/codex/media-understanding-provider.ts
+/**
+* Codex-backed media understanding provider for bounded image description and
+* structured extraction turns.
+*/
+const CODEX_MEDIA_PROVIDER_ID = "codex";
+const DEFAULT_CODEX_IMAGE_MODEL = "gpt-5.6-sol";
+const DEFAULT_CODEX_IMAGE_PROMPT = "Describe the image.";
+/**
+* Builds the media-understanding provider that delegates image tasks to an
+* isolated Codex app-server session.
+*/
+function buildCodexMediaUnderstandingProvider(options = {}) {
+	return {
+		id: CODEX_MEDIA_PROVIDER_ID,
+		capabilities: ["image"],
+		defaultModels: { image: DEFAULT_CODEX_IMAGE_MODEL },
+		describeImage: async (req) => describeCodexImages({
+			images: [{
+				buffer: req.buffer,
+				fileName: req.fileName,
+				mime: req.mime
+			}],
+			provider: req.provider,
+			model: req.model,
+			prompt: req.prompt,
+			maxTokens: req.maxTokens,
+			timeoutMs: req.timeoutMs,
+			profile: req.profile,
+			preferredProfile: req.preferredProfile,
+			authStore: req.authStore,
+			agentDir: req.agentDir,
+			cfg: req.cfg
+		}, options),
+		describeImages: async (req) => describeCodexImages(req, options),
+		extractStructured: async (req) => extractCodexStructured(req, options)
+	};
+}
+async function describeCodexImages(req, options) {
+	const model = req.model.trim();
+	if (!model) throw new Error("Codex image understanding requires model id.");
+	const { text } = await runBoundedCodexAppServerTurn({
+		config: req.cfg,
+		model: {
+			mode: "required",
+			id: model
+		},
+		profile: req.profile,
+		timeoutMs: req.timeoutMs,
+		agentDir: req.agentDir,
+		authProfileStore: req.authStore,
+		options,
+		taskLabel: "image understanding",
+		developerInstructions: "You are OpenClaw's bounded image-understanding worker. Describe only the provided image content. Do not call tools, edit files, or ask follow-up questions.",
+		input: [{
+			type: "text",
+			text: buildCodexImagePrompt(req),
+			text_elements: []
+		}, ...req.images.map((image) => ({
+			type: "image",
+			url: `data:${image.mime ?? "image/png"};base64,${image.buffer.toString("base64")}`
+		}))],
+		requiredModalities: ["text", "image"],
+		isolation: "configured-transport"
+	});
+	return {
+		text,
+		model
+	};
+}
+async function extractCodexStructured(req, options) {
+	const model = req.model.trim();
+	if (!model) throw new Error("Codex structured extraction requires model id.");
+	if (!req.instructions.trim()) throw new Error("Codex structured extraction requires instructions.");
+	if (req.input.length === 0) throw new Error("Codex structured extraction requires at least one input.");
+	if (!req.input.some((entry) => entry.type === "image")) throw new Error("Codex structured extraction requires at least one image input.");
+	const { text } = await runBoundedCodexAppServerTurn({
+		config: req.cfg,
+		model: {
+			mode: "required",
+			id: model
+		},
+		profile: req.profile,
+		timeoutMs: req.timeoutMs,
+		agentDir: req.agentDir,
+		authProfileStore: req.authStore,
+		options,
+		taskLabel: "structured extraction",
+		developerInstructions: "You are OpenClaw's bounded structured-extraction worker. Return only the requested extraction. Do not call tools, edit files, ask follow-up questions, or include secrets.",
+		input: buildCodexStructuredInput(req),
+		requiredModalities: requiredStructuredModalities(),
+		isolation: "configured-transport"
+	});
+	return normalizeStructuredExtractionResult({
+		text,
+		model,
+		provider: req.provider,
+		req
+	});
+}
+function buildCodexImagePrompt(req) {
+	const prompt = req.prompt?.trim() || DEFAULT_CODEX_IMAGE_PROMPT;
+	if (req.images.length <= 1) return prompt;
+	return `${prompt}\n\nAnalyze all ${req.images.length} images together.`;
+}
+function requiredStructuredModalities() {
+	return ["text", "image"];
+}
+function buildCodexStructuredInput(req) {
+	return [{
+		type: "text",
+		text: buildStructuredExtractionPrompt(req),
+		text_elements: []
+	}, ...req.input.map((entry) => {
+		if (entry.type === "text") return {
+			type: "text",
+			text: entry.text,
+			text_elements: []
+		};
+		return {
+			type: "image",
+			url: `data:${entry.mime ?? "image/png"};base64,${entry.buffer.toString("base64")}`
+		};
+	})];
+}
+function buildStructuredExtractionPrompt(req) {
+	return [
+		req.instructions.trim(),
+		req.schemaName ? `Schema name: ${req.schemaName}` : void 0,
+		req.jsonSchema ? `JSON schema:\n${JSON.stringify(req.jsonSchema)}` : void 0,
+		req.jsonMode === false ? "Return the extraction as concise text." : "Return valid JSON only. Do not wrap the JSON in Markdown fences."
+	].filter((part) => Boolean(part)).join("\n\n");
+}
+function isJsonSchemaObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeStructuredExtractionResult(params) {
+	const result = {
+		text: params.text,
+		model: params.model,
+		provider: params.provider,
+		contentType: params.req.jsonMode === false ? "text" : "json"
+	};
+	if (params.req.jsonMode !== false) {
+		try {
+			result.parsed = JSON.parse(params.text);
+		} catch {
+			throw new Error("Codex structured extraction returned invalid JSON.");
+		}
+		if (isJsonSchemaObject(params.req.jsonSchema)) {
+			const validation = validateJsonSchemaValue({
+				schema: params.req.jsonSchema,
+				cacheKey: "codex.media-understanding.extractStructured",
+				value: result.parsed,
+				cache: false
+			});
+			if (!validation.ok) {
+				const message = validation.errors.map((error) => error.text).join("; ") || "invalid";
+				throw new Error(`Codex structured extraction JSON did not match schema: ${message}`);
+			}
+			result.parsed = validation.value;
+		}
+	}
+	return result;
+}
+//#endregion
 export { buildCodexMediaUnderstandingProvider };