@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{effective-mcp-catalog-DzYBW4h1.js → effective-mcp-catalog-J_5Ep5Um.js}

@@ -1,5 +1,6 @@
-import { _ as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-DxcfF9KX.js";
-import { d as sessionBindingIdentity } from "./session-binding-BHuTCRZQ.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { _ as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-CVhez2Uo.js";
+import "./session-binding-CKSepwIC.js";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { assignMcpCatalogSafeServerNames } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/effective-mcp-catalog.ts
@@ -95,7 +96,7 @@ async function loadCodexEffectiveMcpCatalogFromThread(params) {
 }
 /** Loads MCP inventory from the bound Codex client while retaining its lease through all pages. */
 async function loadCodexEffectiveMcpCatalog(params, options) {
-	const binding = await options.bindingStore.read(sessionBindingIdentity({
+	const binding = options.bindingStore.read(sessionBindingIdentity({
 		agentId: params.agentId,
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,

package/dist/{elicitation-input-DMkeki8d.js → elicitation-input-DPoK8F7w.js}

@@ -1,17 +1,8 @@
 import { agentHarnessStructuredInput } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/elicitation-input.ts
-/** Snapshots and compiles ordinary Codex input before it enters the per-turn queue. */
+/** Compiles a validated Codex input snapshot before it enters the per-turn queue. */
 function compileCodexOrdinaryElicitation(params) {
-	if (readRawOwnString(params.value, "threadId") !== params.threadId) return { kind: "ignored" };
-	const snapshot = agentHarnessStructuredInput.snapshot(params.value);
-	if (!agentHarnessStructuredInput.isRecord(snapshot)) return {
-		kind: "compiled",
-		input: {
-			kind: "unsupported",
-			message: "OpenClaw declined a malformed or over-limit MCP elicitation request."
-		}
-	};
-	const requestTurnId = readValue(snapshot, "turnId");
+	const requestTurnId = readValue(params.snapshot, "turnId");
 	if (typeof requestTurnId === "string" && requestTurnId !== params.turnId) return { kind: "ignored" };
 	if (requestTurnId !== null && typeof requestTurnId !== "string") return {
 		kind: "compiled",
@@ -20,13 +11,13 @@ function compileCodexOrdinaryElicitation(params) {
 			message: "OpenClaw declined an MCP elicitation with invalid turn correlation."
 		}
 	};
-	const mode = readCodexElicitationString(snapshot, "mode");
+	const mode = readCodexElicitationString(params.snapshot, "mode");
 	if (mode === "url") return {
 		kind: "compiled",
 		input: agentHarnessStructuredInput.compileUrl({
-			url: readValue(snapshot, "url"),
-			elicitationId: readValue(snapshot, "elicitationId"),
-			message: readValue(snapshot, "message"),
+			url: readValue(params.snapshot, "url"),
+			elicitationId: readValue(params.snapshot, "elicitationId"),
+			message: readValue(params.snapshot, "message"),
 			fallbackMessage: "Codex provided a URL",
 			protocolName: "MCP"
 		})
@@ -41,8 +32,8 @@ function compileCodexOrdinaryElicitation(params) {
 	return {
 		kind: "compiled",
 		input: agentHarnessStructuredInput.compileForm({
-			schema: readValue(snapshot, "requestedSchema"),
-			message: readCodexElicitationString(snapshot, "message"),
+			schema: readValue(params.snapshot, "requestedSchema"),
+			message: readCodexElicitationString(params.snapshot, "message"),
 			fallbackMessage: "Codex needs input",
 			options: {
 				protocolName: mode === "openai/form" ? "OpenAI" : "MCP",
@@ -62,10 +53,5 @@ function readCodexElicitationString(record, key) {
 	const value = readValue(record, key);
 	return typeof value === "string" ? value : void 0;
 }
-function readRawOwnString(value, key) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	const descriptor = Object.getOwnPropertyDescriptor(value, key);
-	return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : void 0;
-}
 //#endregion
 export { compileCodexOrdinaryElicitation };

package/dist/ephemeral-turn-DSwzP8YY.js

@@ -0,0 +1,101 @@
+import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import { T as readCodexTurnCompletedNotification } from "./client-BEKu4yDx.js";
+import { p as getCodexAppServerTurnRouter } from "./attempt-client-cleanup-D6cR54TV.js";
+import { o as isTerminalTurnStatus, s as readCodexNotificationItem } from "./attempt-notifications--H8zXR5-.js";
+import { t as CodexUsageProjection } from "./event-projector-usage-CIyrYYid.js";
+import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+//#region extensions/codex/src/app-server/ephemeral-turn.ts
+/** One ephemeral turn; the client router owns correlation, buffering and request lifetime. */
+var CodexEphemeralTurn = class {
+	constructor(client, threadId, options) {
+		this.options = options;
+		this.completion = createDeferred();
+		this.usage = new CodexUsageProjection();
+		this.items = /* @__PURE__ */ new Map();
+		this.assistantItems = /* @__PURE__ */ new Map();
+		this.assistantText = "";
+		this.route = getCodexAppServerTurnRouter(client).reserveThread({
+			threadId,
+			...options,
+			onNotification: async (notification, scope) => {
+				const params = isJsonObject(notification.params) ? notification.params : void 0;
+				if (params && scope.turnId) {
+					if (notification.method === "item/completed" && options.textMode === "all") {
+						const item = readCodexNotificationItem(params);
+						if (item) {
+							this.items.set(item.id, item);
+							if (item.type === "agentMessage" && item.text) this.assistantItems.set(item.id, item.text);
+						}
+					} else if (notification.method === "item/agentMessage/delta") {
+						const delta = readStringField(params, "delta") ?? "";
+						const itemId = readStringField(params, "itemId") ?? readStringField(params, "id") ?? "assistant";
+						const firstDelta = !this.assistantText && Boolean(delta);
+						this.assistantText += delta;
+						if (delta && options.textMode === "all") this.assistantItems.set(itemId, `${this.assistantItems.get(itemId) ?? ""}${delta}`);
+						if (firstDelta) await options.onAssistantMessageStart?.();
+					} else if (notification.method === "rawResponse/completed") this.usage.record(params);
+					else if (notification.method === "turn/completed") {
+						this.turn = readCodexTurnCompletedNotification(params)?.turn ?? this.turn;
+						this.completion.resolve();
+					} else if (notification.method === "error") {
+						this.usage.invalidateContext();
+						if (params.willRetry !== true) {
+							this.error = params;
+							this.completion.resolve();
+						}
+					}
+				}
+				await options.onNotification?.(notification, scope);
+			}
+		});
+		this.route.armTurn();
+	}
+	get completed() {
+		return this.turn !== void 0;
+	}
+	async wait(turn, options) {
+		if (isTerminalTurnStatus(turn.status)) {
+			this.turn = turn;
+			this.completion.resolve();
+		}
+		const completion = this.route.bindTurn(turn.id, { completed: isTerminalTurnStatus(turn.status) }).then(() => this.completion.promise);
+		const signals = [this.route.signal, options.signal];
+		const abortError = () => options.signal.aborted ? options.abortError() : toStringifiedError(this.route.signal.reason);
+		let timer;
+		let abort = () => {};
+		try {
+			await Promise.race([completion, new Promise((_resolve, reject) => {
+				abort = () => {
+					if (options.signal.aborted || !this.route.completed) reject(abortError());
+				};
+				for (const signal of signals) {
+					signal.addEventListener("abort", abort, { once: true });
+					if (signal.aborted) abort();
+				}
+				const timeout = options.timeout;
+				if (timeout) {
+					timer = setTimeout(() => reject(timeout.error), timeout.ms);
+					timer.unref?.();
+				}
+			})]);
+		} finally {
+			clearTimeout(timer);
+			for (const signal of signals) signal.removeEventListener("abort", abort);
+		}
+		const items = new Map(this.items);
+		for (const item of this.turn?.items ?? []) items.set(item.id, item);
+		const messages = (this.options.textMode === "last" ? this.turn?.items ?? [] : [...items.values()]).filter((item) => item.type === "agentMessage").map((item) => item.text.trim()).filter(Boolean);
+		const text = this.options.textMode === "last" ? messages.at(-1) || this.assistantText : messages.join("\n\n") || [...this.assistantItems.values()].map((message) => message.trim()).filter(Boolean).join("\n\n");
+		return {
+			turn: this.turn,
+			error: this.error,
+			items: [...items.values()],
+			text: text.trim(),
+			usage: this.usage.usage
+		};
+	}
+};
+//#endregion
+export { CodexEphemeralTurn as t };

package/dist/{event-projector-assistant-message-DHRFXKbS.js → event-projector-assistant-message-BmBM4qBV.js}

@@ -33,6 +33,7 @@ function createAttributedCodexAssistantMessage(attribution, text, options) {
 		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;
+	const refusal = options.providerRefusal;
 	return {
 		role: "assistant",
 		content: [{
@@ -43,25 +44,25 @@ function createAttributedCodexAssistantMessage(attribution, text, options) {
 		provider: attribution.provider,
 		model: attribution.modelId,
 		usage,
-		stopReason: options.aborted ? "aborted" : options.promptError ? "error" : "stop",
-		errorMessage: options.promptError ? formatErrorMessage(options.promptError) : void 0,
+		stopReason: options.aborted ? "aborted" : options.promptError || refusal ? "error" : "stop",
+		errorMessage: refusal?.message ?? (options.promptError ? formatErrorMessage(options.promptError) : void 0),
+		...refusal ? { diagnostics: [{
+			type: "provider_refusal",
+			timestamp: Date.now(),
+			details: {
+				provider: "openai",
+				category: refusal.category
+			}
+		}] } : {},
 		timestamp: Date.now()
 	};
 }
 function createAssistantCommentaryMessage(params, text, itemId, timestamp) {
-	const attribution = resolveCodexLocalRuntimeAttribution(params);
 	return {
-		role: "assistant",
-		content: [{
+		...createNonterminalAssistantMessage(params, [{
 			type: "text",
 			text
-		}],
-		api: attribution.api ?? "openai-chatgpt-responses",
-		provider: attribution.provider,
-		model: params.modelId,
-		usage: ZERO_USAGE,
-		stopReason: "stop",
-		timestamp,
+		}], timestamp),
 		openclawStreamFallback: {
 			replacementText: text,
 			source: "segment",
@@ -70,36 +71,31 @@ function createAssistantCommentaryMessage(params, text, itemId, timestamp) {
 	};
 }
 function createAssistantAsyncMessage(params, text, itemId, timestamp) {
-	const attribution = resolveCodexLocalRuntimeAttribution(params);
 	return {
-		role: "assistant",
-		content: [{
+		...createNonterminalAssistantMessage(params, [{
 			type: "text",
 			text
-		}],
-		api: attribution.api ?? "openai-chatgpt-responses",
-		provider: attribution.provider,
-		model: params.modelId,
-		usage: ZERO_USAGE,
-		stopReason: "stop",
-		timestamp,
+		}], timestamp),
 		openclawAsyncDelivery: { itemId }
 	};
 }
 function createAssistantReasoningMessage(params, text) {
+	return createNonterminalAssistantMessage(params, [{
+		type: "thinking",
+		thinking: text
+	}]);
+}
+function createNonterminalAssistantMessage(params, content, timestamp) {
 	const attribution = resolveCodexLocalRuntimeAttribution(params);
 	return {
 		role: "assistant",
-		content: [{
-			type: "thinking",
-			thinking: text
-		}],
+		content,
 		api: attribution.api ?? "openai-chatgpt-responses",
 		provider: attribution.provider,
 		model: params.modelId,
 		usage: ZERO_USAGE,
 		stopReason: "stop",
-		timestamp: Date.now()
+		timestamp: timestamp ?? Date.now()
 	};
 }
 //#endregion

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

@@ -0,0 +1,102 @@
+import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import { asSafeIntegerInRange, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeUsage } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/event-projector-usage.ts
+function readTokenCount(record, key) {
+	return asSafeIntegerInRange(record[key], { min: 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 ? normalizeCodexResponseTokenUsage(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 activeContextTokens = last ? readTokenCount(last, "totalTokens") : void 0;
+	const inputTokens = last ? readTokenCount(last, "inputTokens") : void 0;
+	const cachedInputTokens = last ? readTokenCount(last, "cachedInputTokens") : void 0;
+	const cacheWriteInputTokens = last ? readTokenCount(last, "cacheWriteInputTokens") : void 0;
+	const reasoningOutputTokens = last ? readTokenCount(last, "reasoningOutputTokens") : void 0;
+	return {
+		...activeContextTokens !== void 0 ? { activeContextTokens } : {},
+		...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+		...cacheWriteInputTokens !== void 0 ? { cacheWriteInputTokens } : {},
+		...inputTokens !== void 0 ? { inputTokens } : {},
+		...modelContextWindow && modelContextWindow > 0 ? { modelContextWindow } : {},
+		...inputTokens !== void 0 ? { promptTokens: inputTokens } : {},
+		...reasoningOutputTokens !== void 0 ? { reasoningOutputTokens } : {}
+	};
+}
+function normalizeCodexResponseTokenUsage(record) {
+	const totalTokens = readTokenCount(record, "totalTokens");
+	const inputTokens = readTokenCount(record, "inputTokens");
+	const cacheRead = readTokenCount(record, "cachedInputTokens");
+	const output = readTokenCount(record, "outputTokens");
+	const reasoningTokens = readTokenCount(record, "reasoningOutputTokens");
+	const cacheWrite = record.cacheWriteInputTokens === void 0 ? 0 : readTokenCount(record, "cacheWriteInputTokens");
+	const hasCoherentInput = inputTokens !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0 && cacheRead + cacheWrite <= inputTokens;
+	const hasCoherentContext = hasCoherentInput && totalTokens !== void 0 && output !== void 0 && totalTokens === inputTokens + output;
+	const usage = normalizeUsage({
+		input: hasCoherentInput ? inputTokens - cacheRead - cacheWrite : void 0,
+		output,
+		cacheRead,
+		cacheWrite,
+		reasoningTokens,
+		total: totalTokens
+	});
+	if (!usage) return;
+	return {
+		...usage,
+		contextUsage: hasCoherentContext ? {
+			state: "available",
+			promptTokens: inputTokens,
+			totalTokens
+		} : { state: "unavailable" }
+	};
+}
+var CodexUsageProjection = class {
+	constructor() {
+		this.responseIds = /* @__PURE__ */ new Set();
+	}
+	get usage() {
+		const usage = this.responseUsage ?? this.threadUsage;
+		return usage ? {
+			...usage,
+			contextUsage: this.contextUsage
+		} : void 0;
+	}
+	get modelIterations() {
+		return this.responseIds.size;
+	}
+	invalidateContext() {
+		this.contextUsage = { state: "unavailable" };
+	}
+	recordThread(params) {
+		const usage = readCodexThreadTokenUsage(params);
+		this.threadUsage = usage ?? this.threadUsage;
+		if (!this.responseUsage && usage) this.contextUsage = usage.contextUsage;
+		return readCodexThreadContextSnapshot(params);
+	}
+	record(params, reportOutputTokens) {
+		const responseId = readStringField(params, "responseId");
+		if (!responseId || this.responseIds.has(responseId)) return;
+		this.responseIds.add(responseId);
+		const usage = isJsonObject(params.usage) ? normalizeCodexResponseTokenUsage(params.usage) : void 0;
+		this.contextUsage = usage?.contextUsage ?? { state: "unavailable" };
+		this.responseUsage ??= {};
+		for (const field of [
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite",
+			"reasoningTokens",
+			"total"
+		]) if (usage?.[field] !== void 0) this.responseUsage[field] = (this.responseUsage[field] ?? 0) + usage[field];
+		const outputTokens = usage?.output;
+		if (outputTokens !== void 0) reportOutputTokens?.(outputTokens);
+	}
+};
+//#endregion
+export { readCodexThreadContextSnapshot as n, CodexUsageProjection as t };

package/dist/{harness-DXVZ5II5.js → harness-FR6eQgyO.js}

@@ -1,5 +1,6 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
+import { t as codexBuildSymbol } from "./build-state-6RL6qohz.js";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { runHostPreparedIsolatedCompletion } from "openclaw/plugin-sdk/simple-completion-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/model-runtime.ts
 const CODEX_APP_SERVER_RUNTIME_MODEL_PARAM = "codexAppServerRuntimeModel";
@@ -12,7 +13,7 @@ function readCodexRuntimeModelId(model, fallbackId) {
 //#endregion
 //#region extensions/codex/harness.ts
 const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = /* @__PURE__ */ new Set(["codex", "openai"]);
-const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = Symbol.for("openclaw.codexAppServerClientDisposer");
+const SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER = codexBuildSymbol("openclaw.codexAppServerClientDisposer");
 const CODEX_TOOL_POLICY_SAFE_DENY_NAMES = [
 	"web_fetch",
 	"x_search",
@@ -74,10 +75,35 @@ function createCodexAppServerAgentHarness(options) {
 		conversationToolPolicySafeDenyTools: CODEX_TOOL_POLICY_SAFE_DENY_NAMES,
 		deliveryDefaults: { visibleReplies: "message_tool" },
 		authBootstrap: "harness",
+		resolveSessionRuntimeOwnership: (params) => {
+			const assertCurrent = () => {
+				params.assertCurrent();
+				if (disposed) throw new Error("Codex agent harness is disposed");
+			};
+			assertCurrent();
+			const identity = sessionBindingIdentity(params);
+			let binding = options.bindingStore.read(identity);
+			if (!binding) {
+				const previousSessionId = params.readPreviousSessionId?.();
+				binding = previousSessionId ? options.bindingStore.read({
+					...identity,
+					sessionId: previousSessionId
+				}) : void 0;
+			}
+			assertCurrent();
+			return binding?.preserveNativeModel === true ? {
+				model: "native",
+				auth: binding.connectionScope === "supervision" ? "native" : "host",
+				...binding.model?.trim() && binding.modelProvider ? { modelRef: {
+					provider: binding.modelProvider,
+					model: binding.model
+				} } : {}
+			} : void 0;
+		},
 		...sessionCatalogControlFactory && sessionRuntime ? { sessionFork: {
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-CYlBIGVt.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-De-sLJ2r.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -88,26 +114,26 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		} } : {},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Ds_QVm-X.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Co2Vfcf_.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C3jVimFn.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-T-NwqeSH.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-Bj-rrzkR.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-CPPTmBvZ.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./model-catalog-CUM68Hkl.js");
+			const { createCodexAppServerModelCatalog } = await import("./model-catalog-B_6M04Wo.js");
 			if (disposed) return [];
 			modelCatalog ??= createCodexAppServerModelCatalog(harnessRuntimeId);
 			return await modelCatalog.load(params, resolveAttemptPluginConfig(params.config));
 		},
 		readModelCatalogReadiness: (params) => modelCatalog?.read(params, resolveAttemptPluginConfig(params.config)),
 		loadMcpToolCatalog: async (params) => {
-			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-DzYBW4h1.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-J_5Ep5Um.js");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -150,7 +176,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-D1hJO4fX.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DwKds3DN.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: resolveAttemptPluginConfig(params.config),
@@ -160,11 +186,15 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		runIsolatedCompletionV2: async (params) => {
-			if (params.authorization.owner === "host") return runHostPreparedIsolatedCompletion(params);
-			const { runCodexIsolatedCompletion } = await import("./isolated-completion-kg9kv4iH.js");
+			if (params.authorization.owner === "host") {
+				const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
+				return runHostPreparedIsolatedCompletion(params);
+			}
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-DHBefrzg.js");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
+			const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
 			return runHostPreparedIsolatedCompletion({
 				...params,
 				authorization: {
@@ -176,11 +206,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BVJx4yoc.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BuLUrZl2.js");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-BTZAII4l.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DLbr2vUU.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -190,20 +220,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-_t0HQrUS.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CGJZ2rlb.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-BujDjXVF.js");
+			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-BSNG_mhf.js");
 			params.assertCurrent();
 			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
 		},
 		reset: async (params) => {
 			if (params.sessionId && params.reason !== "deleted") {
-				const [{ reclaimCurrentCodexSessionGeneration, sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-BHuTCRZQ.js").then((n) => n.f), import("./session-retirement-BujDjXVF.js")]);
+				const [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-CKSepwIC.js").then((n) => n.c), import("./session-retirement-BSNG_mhf.js")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -235,7 +265,7 @@ function createCodexAppServerAgentHarness(options) {
 /** Creates the private native-compaction bridge registered in host-owned capability state. */
 function createCodexAppServerNativeCompaction(options) {
 	return async (params) => {
-		const { maybeCompactCodexAppServerSession } = await import("./compact-_t0HQrUS.js");
+		const { maybeCompactCodexAppServerSession } = await import("./compact-CGJZ2rlb.js");
 		return maybeCompactCodexAppServerSession(params, {
 			bindingStore: options.bindingStore,
 			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,

package/dist/harness.js

@@ -1,2 +1,2 @@
-import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-DXVZ5II5.js";
+import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-FR6eQgyO.js";
 export { createCodexAppServerAgentHarness, createCodexAppServerNativeCompaction };

package/dist/history-rejection-B4nOXNXF.js

@@ -0,0 +1,13 @@
+//#region extensions/codex/src/app-server/history-rejection.ts
+/** Only an owning rejection site can supply a diagnostic; exception text is never evidence. */
+var CodexHistoryRejection = class extends Error {
+	constructor(reason) {
+		super(`Codex history rejected: ${reason}`);
+		this.reason = reason;
+	}
+};
+function codexHistoryRejectionReason(error) {
+	return error instanceof CodexHistoryRejection ? error.reason : "history_read_failed";
+}
+//#endregion
+export { codexHistoryRejectionReason as n, CodexHistoryRejection as t };

package/dist/{image-payload-sanitizer-CnfoUPCE.js → image-payload-sanitizer-tupAr-2o.js}

@@ -24,42 +24,56 @@ function sanitizeImageContentRecord(record, label) {
 		};
 		const commaIndex = imageUrl.indexOf(",");
 		const mime = imageUrl.slice(INLINE_IMAGE_DATA_URL_PREFIX.length, commaIndex).split(";")[0] ?? mimeType;
-		return {
+		const data = imageUrl.slice(commaIndex + 1);
+		return mime === record.mimeType && data === record.data ? record : {
 			...record,
 			mimeType: mime,
-			data: imageUrl.slice(commaIndex + 1)
+			data
 		};
 	}
 	if (record.type === "inputImage" && typeof record.imageUrl === "string") {
 		const imageUrl = sanitizeInlineImageDataUrl$1(record.imageUrl);
-		return imageUrl ? {
-			...record,
-			imageUrl
-		} : {
+		if (!imageUrl) return {
 			type: "inputText",
 			text: invalidInlineImageText(label)
 		};
+		return imageUrl === record.imageUrl ? record : {
+			...record,
+			imageUrl
+		};
 	}
 	if (record.type === "input_image" && typeof record.image_url === "string") {
 		const imageUrl = sanitizeInlineImageDataUrl$1(record.image_url);
-		return imageUrl ? {
-			...record,
-			image_url: imageUrl
-		} : {
+		if (!imageUrl) return {
 			type: "input_text",
 			text: invalidInlineImageText(label)
 		};
+		return imageUrl === record.image_url ? record : {
+			...record,
+			image_url: imageUrl
+		};
 	}
 }
-/** Recursively sanitizes all Codex history image shapes while preserving unknown structure. */
+/** Sanitizes images without copying unchanged history or mutating its owned snapshot. */
 function sanitizeCodexHistoryImagePayloads(value, label) {
-	if (Array.isArray(value)) return value.map((entry) => sanitizeCodexHistoryImagePayloads(entry, label));
+	if (Array.isArray(value)) {
+		let next;
+		for (let index = 0; index < value.length; index++) {
+			const child = sanitizeCodexHistoryImagePayloads(value[index], label);
+			if (child !== value[index]) (next ??= value.slice())[index] = child;
+		}
+		return next ?? value;
+	}
 	if (!isRecord(value)) return value;
 	const imageRecord = sanitizeImageContentRecord(value, label);
 	if (imageRecord) return imageRecord;
-	const next = {};
-	for (const [key, child] of Object.entries(value)) next[key] = sanitizeCodexHistoryImagePayloads(child, label);
-	return next;
+	let next;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		const child = sanitizeCodexHistoryImagePayloads(value[key], label);
+		if (child !== value[key]) (next ??= { ...value })[key] = child;
+	}
+	return next ?? value;
 }
 //#endregion
 export { sanitizeCodexHistoryImagePayloads as n, sanitizeInlineImageDataUrl$1 as r, invalidInlineImageText as t };

package/dist/incognito-session-uhrBF6wJ.js

@@ -0,0 +1,15 @@
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { isIncognitoSessionKey as isIncognitoSessionKey$1 } from "openclaw/plugin-sdk/session-key-runtime";
+//#region extensions/codex/src/app-server/thread-ownership-queue.ts
+const nativeThreadOwners = resolveGlobalSingleton(Symbol.for("openclaw.codexNativeThreadOwners"), () => new KeyedAsyncQueue());
+/** Serialize OpenClaw-owned lifecycle changes, not native-internal thread controllers. */
+async function withCodexAppServerThreadMutation(threadId, run) {
+	return await nativeThreadOwners.enqueue(`thread:${threadId}`, run);
+}
+/** Serializes bound turns and retirement so detach cannot unsubscribe an active turn. */
+async function withCodexConversationThreadActivity(bindingId, run) {
+	return await nativeThreadOwners.enqueue(`conversation:${bindingId}`, run);
+}
+//#endregion
+export { withCodexAppServerThreadMutation as n, withCodexConversationThreadActivity as r, isIncognitoSessionKey$1 as t };