@openclaw/codex 2026.9.1 → 2026.9.2

package/dist/{effective-mcp-catalog-DzYBW4h1.js → effective-mcp-catalog-CY9Jn4bA.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-CyaXZvTe.js";
+import { _ as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-CKhX2kFt.js";
+import "./session-binding-4Ki04sW-.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/{event-projector-assistant-message-DHRFXKbS.js → event-projector-assistant-message-B9kp6iGC.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,8 +44,16 @@ 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()
 	};
 }

package/dist/{event-projector-usage-C5mcrGjp.js → event-projector-usage-ZqEVbAEY.js}

@@ -1,4 +1,4 @@
-import { $t as isJsonObject } from "./shared-client-DxcfF9KX.js";
+import { B as isJsonObject } from "./config-CyapYSji.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/attempt-notifications.ts
@@ -139,11 +139,6 @@ function readCodexThreadContextSnapshot(params) {
 		...reasoningOutputTokens !== void 0 ? { reasoningOutputTokens } : {}
 	};
 }
-function projectCodexThreadUsageUpdate(params, currentUsage, applyUsage, emitContext) {
-	applyUsage(readCodexThreadTokenUsage(params) ?? currentUsage);
-	const context = readCodexThreadContextSnapshot(params);
-	if (Object.keys(context).length > 0) emitContext(context);
-}
 function normalizeCodexResponseTokenUsage(record) {
 	const totalTokens = readTokenCount(record, "totalTokens");
 	const inputTokens = readTokenCount(record, "inputTokens");
@@ -171,25 +166,47 @@ function normalizeCodexResponseTokenUsage(record) {
 		} : { state: "unavailable" }
 	};
 }
-var CodexResponseCompletionProjection = class {
+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;
 	}
-	clear() {
-		this.usage = void 0;
+	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) ? params.usage : void 0;
-		this.usage = usage ? normalizeCodexResponseTokenUsage(usage) : void 0;
-		const outputTokens = this.usage?.output;
+		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 { codexExecutionToolName as a, isPendingOpenClawDynamicToolCompletionNotification as c, isTerminalTurnStatus as d, readCodexNotificationItem as f, updateActiveTurnItemIds as h, readCodexThreadContextSnapshot as i, isRawFunctionToolOutputCompletionNotification as l, readRawResponseToolCallId as m, normalizeCodexResponseTokenUsage as n, isAssistantCommentaryCompletionNotification as o, readNotificationItemId as p, projectCodexThreadUsageUpdate as r, isCodexTurnAbortMarkerNotification as s, CodexResponseCompletionProjection as t, isRetryableErrorNotification as u };
+export { isCodexTurnAbortMarkerNotification as a, isRetryableErrorNotification as c, readNotificationItemId as d, readRawResponseToolCallId as f, isAssistantCommentaryCompletionNotification as i, isTerminalTurnStatus as l, readCodexThreadContextSnapshot as n, isPendingOpenClawDynamicToolCompletionNotification as o, updateActiveTurnItemIds as p, codexExecutionToolName as r, isRawFunctionToolOutputCompletionNotification as s, CodexUsageProjection as t, readCodexNotificationItem as u };

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

@@ -1,3 +1,4 @@
+import { l as sessionBindingIdentity, o as readCodexSessionOwnershipBinding } from "./session-binding-record-CyaXZvTe.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";
@@ -74,10 +75,32 @@ 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 binding = readCodexSessionOwnershipBinding({
+				bindingStore: options.bindingStore,
+				identity: sessionBindingIdentity(params),
+				config: params.config,
+				storePath: params.storePath
+			});
+			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-1fwbNKzQ.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -92,22 +115,22 @@ function createCodexAppServerAgentHarness(options) {
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-C3jVimFn.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Bh_gf6-t.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-Bj-rrzkR.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-i9fv5-4m.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-DT5vo6qo.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-CY9Jn4bA.js");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -150,7 +173,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-D1hJO4fX.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-BzthFQSM.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: resolveAttemptPluginConfig(params.config),
@@ -161,7 +184,7 @@ function createCodexAppServerAgentHarness(options) {
 		},
 		runIsolatedCompletionV2: async (params) => {
 			if (params.authorization.owner === "host") return runHostPreparedIsolatedCompletion(params);
-			const { runCodexIsolatedCompletion } = await import("./isolated-completion-kg9kv4iH.js");
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-CRh-51AK.js");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
@@ -176,11 +199,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BVJx4yoc.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BI-b1sry.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-B6DWAw1A.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -190,20 +213,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-_t0HQrUS.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-Y_xBqrHN.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-DNdmYdFc.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-4Ki04sW-.js").then((n) => n.d), import("./session-retirement-DNdmYdFc.js")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -235,7 +258,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-Y_xBqrHN.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-Czh2Sdoc.js";
 export { createCodexAppServerAgentHarness, createCodexAppServerNativeCompaction };

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 };