@openclaw/codex 2026.9.1-beta.1 → 2026.9.2

package/dist/{effective-mcp-catalog-CTeGrnfO.js → effective-mcp-catalog-CY9Jn4bA.js}

@@ -1,5 +1,6 @@
-import { h as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-DKz23hHY.js";
-import { d as sessionBindingIdentity } from "./session-binding-Bcynfd-_.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-C5-Ds8mA.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()
 	};
 }
@@ -86,13 +95,13 @@ function createAssistantAsyncMessage(params, text, itemId, timestamp) {
 		openclawAsyncDelivery: { itemId }
 	};
 }
-function createAssistantMirrorMessage(params, title, text) {
+function createAssistantReasoningMessage(params, text) {
 	const attribution = resolveCodexLocalRuntimeAttribution(params);
 	return {
 		role: "assistant",
 		content: [{
-			type: "text",
-			text: `${title}:\n${text}`
+			type: "thinking",
+			thinking: text
 		}],
 		api: attribution.api ?? "openai-chatgpt-responses",
 		provider: attribution.provider,
@@ -103,4 +112,4 @@ function createAssistantMirrorMessage(params, title, text) {
 	};
 }
 //#endregion
-export { createAttributedCodexAssistantMessage as a, createAssistantMirrorMessage as i, createAssistantCommentaryMessage as n, createAssistantMessage as r, createAssistantAsyncMessage as t };
+export { createAttributedCodexAssistantMessage as a, createAssistantReasoningMessage as i, createAssistantCommentaryMessage as n, createAssistantMessage as r, createAssistantAsyncMessage as t };

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

@@ -0,0 +1,212 @@
+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
+const CODEX_TURN_ABORT_MARKER_START = "<turn_aborted>";
+const CODEX_TURN_ABORT_MARKER_END = "</turn_aborted>";
+/** Tracks actual native items for explicit terminal-tool batching. */
+function updateActiveTurnItemIds(notification, activeItemIds) {
+	if (notification.method !== "item/started" && notification.method !== "item/completed") return;
+	const itemId = readNotificationItemId(notification);
+	if (!itemId) return;
+	if (notification.method === "item/started") {
+		activeItemIds.add(itemId);
+		return;
+	}
+	activeItemIds.delete(itemId);
+}
+/** Reads an item id from supported notification envelope shapes. */
+function readNotificationItemId(notification) {
+	if (!isJsonObject(notification.params)) return;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return (item ? readStringField(item, "id") : void 0) ?? readStringField(notification.params, "itemId") ?? readStringField(notification.params, "id");
+}
+/** Detects completion for an OpenClaw dynamic tool result still awaited by Codex. */
+function isPendingOpenClawDynamicToolCompletionNotification(notification, pendingOpenClawDynamicToolCompletionIds) {
+	if (notification.method !== "item/completed" || !isJsonObject(notification.params)) return false;
+	const itemId = readNotificationItemId(notification);
+	if (!itemId || !pendingOpenClawDynamicToolCompletionIds.has(itemId)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	const itemType = item ? readStringField(item, "type") : void 0;
+	return itemType === void 0 || itemType === "dynamicToolCall";
+}
+function isRawFunctionToolOutputCompletionNotification(notification) {
+	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return item ? readStringField(item, "type") === "function_call_output" : false;
+}
+/** Distinguishes progress-only assistant items from conversation answers. */
+function isAssistantCommentaryCompletionNotification(notification) {
+	if (!isJsonObject(notification.params) || notification.method !== "item/completed") return false;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	return Boolean(item && readStringField(item, "type") === "agentMessage" && (readStringField(item, "phase") === "commentary" || readStringField(item, "delivery") === "async"));
+}
+/** A retryable native error is not a terminal outcome for bounded operations. */
+function isRetryableErrorNotification(value) {
+	return isJsonObject(value) && value.willRetry === true;
+}
+/** Returns true for terminal app-server thread status strings. */
+function isTerminalTurnStatus(status) {
+	return status === "completed" || status === "interrupted" || status === "failed";
+}
+/** Detects Codex's interrupted-turn marker, not user-authored copies of it. */
+function isCodexTurnAbortMarkerNotification(notification, options = {}) {
+	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return false;
+	const item = notification.params.item;
+	const role = isJsonObject(item) ? readStringField(item, "role") : void 0;
+	if (!isJsonObject(item) || readStringField(item, "type") !== "message" || role !== "user" && role !== "developer") return false;
+	const text = extractRawResponseItemText(item).trim();
+	const currentPromptTexts = [options.currentPromptText, ...options.currentPromptTexts ?? []].filter(isNonEmptyString).map((prompt) => prompt.trim());
+	if (role === "user" && currentPromptTexts.includes(text)) return false;
+	return readCodexTurnAbortMarkerBody(text) !== void 0;
+}
+function readCodexTurnAbortMarkerBody(text) {
+	if (!text.startsWith(CODEX_TURN_ABORT_MARKER_START) || !text.endsWith(CODEX_TURN_ABORT_MARKER_END)) return;
+	return text.slice(14, -15).trim();
+}
+function extractRawResponseItemText(item) {
+	const content = item.content;
+	if (!Array.isArray(content)) return "";
+	return content.flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const type = readStringField(entry, "type");
+		if (type !== "input_text" && type !== "text") return [];
+		const text = readStringField(entry, "text");
+		return text ? [text] : [];
+	}).join("");
+}
+/** Reads a typed Codex item from notification params when id/type are present. */
+function readCodexNotificationItem(params) {
+	if (!isJsonObject(params) || !isJsonObject(params.item)) return;
+	const item = params.item;
+	return typeof item.id === "string" && typeof item.type === "string" ? item : void 0;
+}
+/** Reads the stable call id from a model-emitted raw tool item. */
+function readRawResponseToolCallId(notification) {
+	if (notification.method !== "rawResponseItem/completed" || !isJsonObject(notification.params)) return;
+	const item = isJsonObject(notification.params.item) ? notification.params.item : void 0;
+	if (!item) return;
+	switch (readStringField(item, "type")) {
+		case "custom_tool_call":
+		case "function_call":
+		case "local_shell_call":
+		case "tool_search_call": return readStringField(item, "call_id");
+		case "image_generation_call":
+		case "web_search_call": return readStringField(item, "id");
+		default: return;
+	}
+}
+/** Maps Codex item types to the tool name shown in execution progress. */
+function codexExecutionToolName(item) {
+	if (item.type === "dynamicToolCall" && typeof item.tool === "string") return item.tool;
+	if (item.type === "mcpToolCall" && typeof item.tool === "string") {
+		const server = typeof item.server === "string" && item.server ? item.server : void 0;
+		return server ? `${server}.${item.tool}` : item.tool;
+	}
+	if (item.type === "commandExecution") return "bash";
+	if (item.type === "fileChange") return "apply_patch";
+	if (item.type === "webSearch") return "web_search";
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+//#endregion
+//#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 { 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-Csz0F-DK.js → harness-Czh2Sdoc.js}

@@ -1,5 +1,6 @@
+import { l as sessionBindingIdentity, o as readCodexSessionOwnershipBinding } from "./session-binding-record-CyaXZvTe.js";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { completeWithPreparedSimpleCompletionModel } from "openclaw/plugin-sdk/simple-completion-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";
@@ -40,30 +41,6 @@ const CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES = [
 	"runtime-llm-complete",
 	"thread-bootstrap-projection"
 ];
-async function runCodexHostPreparedIsolatedCompletion(params) {
-	const timeoutSignal = AbortSignal.timeout(params.timeoutMs);
-	const signal = params.abortSignal ? AbortSignal.any([params.abortSignal, timeoutSignal]) : timeoutSignal;
-	return { assistant: await completeWithPreparedSimpleCompletionModel({
-		model: params.model,
-		auth: params.auth,
-		cfg: params.config,
-		context: {
-			systemPrompt: params.systemPrompt,
-			messages: [{
-				role: "user",
-				content: params.prompt,
-				timestamp: Date.now()
-			}],
-			tools: []
-		},
-		options: {
-			maxTokens: params.streamParams?.maxTokens,
-			temperature: params.streamParams?.temperature,
-			reasoning: params.thinkLevel,
-			signal
-		}
-	}) };
-}
 async function disposeSharedCodexAppServerClients() {
 	const dispose = globalThis[SHARED_CODEX_APP_SERVER_CLIENT_DISPOSER];
 	await dispose?.();
@@ -78,6 +55,8 @@ function createCodexAppServerAgentHarness(options) {
 	const providerIds = new Set([...options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS].map((id) => id.trim().toLowerCase()));
 	const sessionCatalogControlFactory = options.sessionCatalogControlFactory;
 	const sessionRuntime = options.runtime;
+	let modelCatalog;
+	let disposed = false;
 	const resolveAttemptPluginConfig = (config) => resolvePluginConfigObject(config, "codex") ?? options.resolvePluginConfig?.() ?? options.pluginConfig;
 	return {
 		id: harnessRuntimeId,
@@ -96,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-DlaHxSLC.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-1fwbNKzQ.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -110,23 +111,26 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		} } : {},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-B4FfbcCg.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Ds_QVm-X.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BvyT1uyd.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Bh_gf6-t.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-ROIaW3wo.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-i9fv5-4m.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { loadCodexAppServerModelCatalog } = await import("./model-catalog-i9rNBthX.js");
-			return await loadCodexAppServerModelCatalog(params, resolveAttemptPluginConfig(params.config));
+			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-CTeGrnfO.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-CY9Jn4bA.js");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -169,7 +173,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-DYc0QCBF.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-BzthFQSM.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: resolveAttemptPluginConfig(params.config),
@@ -179,27 +183,27 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		runIsolatedCompletionV2: async (params) => {
-			if (params.authorization.owner === "host") {
-				const { authorization, ...commonParams } = params;
-				return runCodexHostPreparedIsolatedCompletion({
-					...commonParams,
-					model: authorization.model,
-					auth: authorization.auth,
-					...authorization.sourceAuthFingerprint ? { sourceAuthFingerprint: authorization.sourceAuthFingerprint } : {}
-				});
-			}
-			const { runCodexIsolatedCompletion } = await import("./isolated-completion-Cv6FqygM.js");
+			if (params.authorization.owner === "host") return runHostPreparedIsolatedCompletion(params);
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-CRh-51AK.js");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
-			return runCodexHostPreparedIsolatedCompletion(params);
+			return runHostPreparedIsolatedCompletion({
+				...params,
+				authorization: {
+					owner: "host",
+					model: params.model,
+					auth: params.auth,
+					sourceAuthFingerprint: params.sourceAuthFingerprint
+				}
+			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-Dc3ApjU4.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-DjA_jsNe.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-B6DWAw1A.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -209,15 +213,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-BglNFZrQ.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-DNdmYdFc.js");
+			params.assertCurrent();
+			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
+		},
 		reset: async (params) => {
-			if (params.sessionId) {
-				const [{ reclaimCurrentCodexSessionGeneration, sessionBindingIdentity }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-Bcynfd-_.js").then((n) => n.f), import("./session-retirement-CcNC3YSY.js")]);
+			if (params.sessionId && params.reason !== "deleted") {
+				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,
@@ -226,7 +235,7 @@ function createCodexAppServerAgentHarness(options) {
 				const resetGeneration = () => retireCodexAppServerSessionGeneration({
 					bindingStore: options.bindingStore,
 					identity,
-					mode: params.reason === "deleted" ? "retire" : "reset"
+					mode: "reset"
 				});
 				let reset = await resetGeneration();
 				if (reset === "conflict") {
@@ -239,13 +248,17 @@ function createCodexAppServerAgentHarness(options) {
 				if (reset === "conflict") throw new Error(`Codex binding generation changed before session ${params.sessionId} could reset`);
 			}
 		},
-		dispose: disposeSharedCodexAppServerClients
+		dispose: async () => {
+			disposed = true;
+			modelCatalog?.dispose();
+			await disposeSharedCodexAppServerClients();
+		}
 	};
 }
 /** Creates the private native-compaction bridge registered in host-owned capability state. */
 function createCodexAppServerNativeCompaction(options) {
 	return async (params) => {
-		const { maybeCompactCodexAppServerSession } = await import("./compact-BglNFZrQ.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-Csz0F-DK.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 };