@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/ephemeral-turn-D78_VmzO.js

@@ -0,0 +1,101 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { T as readCodexTurnCompletedNotification } from "./client-B57KWPQx.js";
+import { p as getCodexAppServerTurnRouter } from "./attempt-client-cleanup-DKHzbwt5.js";
+import { o as isTerminalTurnStatus, s as readCodexNotificationItem } from "./attempt-notifications-C9XufG6l.js";
+import { t as CodexUsageProjection } from "./event-projector-usage-BfXmpOec.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-B9kp6iGC.js → event-projector-assistant-message-BmBM4qBV.js}

@@ -58,19 +58,11 @@ function createAttributedCodexAssistantMessage(attribution, text, options) {
 	};
 }
 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",
@@ -79,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-items-5VhsECCO.js

@@ -0,0 +1,200 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { asFiniteNumber, normalizeOptionalString as normalizeOptionalString$1, readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/event-projector-values.ts
+const BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX = "This content was flagged for possible biological risk.";
+/** Project only Codex's explicit refusal contracts; other policy errors retain their own paths. */
+function readCodexProviderRefusal(message, codexErrorInfo) {
+	if (!message) return;
+	if (codexErrorInfo === "cyberPolicy") return {
+		category: "cyber",
+		message
+	};
+	if (codexErrorInfo === "misalignmentPolicyViolation") return {
+		category: "misalignment",
+		message
+	};
+	return message.startsWith(BIO_POLICY_SAFETY_ACCESS_BLOCK_PREFIX) ? {
+		category: "bio",
+		message
+	} : void 0;
+}
+function readNonEmptyString(record, key) {
+	return normalizeOptionalString$1(record[key]);
+}
+function readNonEmptyStringArray(record, key) {
+	const value = record[key];
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const entry of value) {
+		const normalized = normalizeOptionalString$1(entry);
+		if (normalized) entries.push(normalized);
+	}
+	return entries;
+}
+function readNullableString(record, key) {
+	const value = record[key];
+	if (value === null) return null;
+	return typeof value === "string" ? value : void 0;
+}
+function readNonNegativeInteger(record, key) {
+	const value = asFiniteNumber(record[key]);
+	return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function readCodexErrorNotificationMessage(record) {
+	const error = record.error;
+	return isJsonObject(error) ? readStringField(error, "message") : void 0;
+}
+function readHookOutputEntries(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const text = readStringField(entry, "text");
+		if (!text) return [];
+		const kind = readStringField(entry, "kind");
+		return [{
+			...kind ? { kind } : {},
+			text
+		}];
+	});
+}
+function splitPlanText(text) {
+	return text.split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 0);
+}
+function extractRawAssistantText(item) {
+	const parts = (Array.isArray(item.content) ? item.content : []).flatMap((entry) => {
+		if (!isJsonObject(entry)) return [];
+		const type = readStringField(entry, "type");
+		if (type !== "output_text" && type !== "text") return [];
+		const value = readStringField(entry, "text");
+		return value === void 0 ? [] : [value];
+	});
+	return parts.length > 0 ? parts.join("").trim() : void 0;
+}
+function readItemString(item, key) {
+	const value = item[key];
+	return typeof value === "string" ? value : void 0;
+}
+function readItem(value) {
+	if (!isJsonObject(value)) return;
+	const type = typeof value.type === "string" ? value.type : void 0;
+	const id = typeof value.id === "string" ? value.id : void 0;
+	if (!type || !id) return;
+	return value;
+}
+//#endregion
+//#region extensions/codex/src/app-server/event-projector-items.ts
+function matchesCodexSnapshotTurn(item, turnId) {
+	const itemTurnId = readItemString(item, "turnId");
+	return itemTurnId === void 0 || itemTurnId === turnId;
+}
+function itemKind(item) {
+	switch (item.type) {
+		case "dynamicToolCall":
+		case "mcpToolCall": return "tool";
+		case "commandExecution": return "command";
+		case "fileChange": return "patch";
+		case "webSearch": return "search";
+		case "reasoning":
+		case "contextCompaction": return "analysis";
+		default: return;
+	}
+}
+function itemTitle(item) {
+	switch (item.type) {
+		case "commandExecution": return "Command";
+		case "fileChange": return "File change";
+		case "mcpToolCall": return "MCP tool";
+		case "dynamicToolCall": return "Tool";
+		case "webSearch": return "Web search";
+		case "contextCompaction": return "Context compaction";
+		case "reasoning": return "Reasoning";
+		default: return item.type;
+	}
+}
+function itemStatus(item) {
+	const status = readItemString(item, "status");
+	if (status === "failed" || status === "error") return "failed";
+	if (status === "declined") return "blocked";
+	if (status === "inProgress" || status === "in_progress" || status === "running") return "running";
+	return "completed";
+}
+function unknownItemStatus(item) {
+	const status = readItemString(item, "status");
+	switch (status) {
+		case void 0:
+		case "completed":
+		case "failed":
+		case "error":
+		case "declined":
+		case "inProgress":
+		case "in_progress":
+		case "running": return;
+		default: return status;
+	}
+}
+function auditNativeToolTerminalStatus(item) {
+	if (item.type === "imageView" || item.type === "sleep") return "completed";
+	const status = readItemString(item, "status");
+	if (status === "completed") return "completed";
+	if (status === "failed" || status === "error") return "failed";
+	if (status === "declined") return "blocked";
+	return "unknown";
+}
+function auditNativeToolUnfinishedStatus(item) {
+	return item.type === "webSearch" || item.type === "imageGeneration" ? "unknown" : "failed";
+}
+function isNonSuccessItemStatus(status) {
+	return status === "failed" || status === "blocked";
+}
+function itemName(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 : 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 auditNativeToolName(item) {
+	if (item.type === "dynamicToolCall") return;
+	const progressName = itemName(item);
+	if (progressName) return progressName;
+	if (item.type === "collabAgentToolCall") return typeof item.tool === "string" && item.tool.trim() ? `collab.${item.tool.trim()}` : "collab_agent";
+	if (item.type === "imageGeneration") return "image_generation";
+	if (item.type === "imageView") return "image_view";
+	if (item.type === "sleep") return "sleep";
+}
+function isSideEffectingNativeToolItem(item) {
+	return itemStatus(item) !== "blocked" && (isMutatingNativeToolItem(item) || item.type === "mcpToolCall");
+}
+function shouldSynthesizeToolProgressForItem(item) {
+	switch (item.type) {
+		case "commandExecution":
+		case "fileChange":
+		case "webSearch":
+		case "mcpToolCall": return true;
+		default: return false;
+	}
+}
+function shouldRecordNativeToolTranscript(item) {
+	return shouldSynthesizeToolProgressForItem(item);
+}
+function isMutatingNativeToolItem(item) {
+	if (item.type === "commandExecution") return true;
+	return item.type === "fileChange" || item.type === "collabAgentToolCall" || item.type === "imageGeneration";
+}
+function shouldClearTerminalPresentationForNativeItem(item) {
+	switch (item.type) {
+		case "collabAgentToolCall":
+		case "commandExecution":
+		case "fileChange":
+		case "imageGeneration":
+		case "imageView":
+		case "mcpToolCall":
+		case "webSearch": return true;
+		default: return false;
+	}
+}
+//#endregion
+export { readNonEmptyString as C, splitPlanText as D, readNullableString as E, readItemString as S, readNonNegativeInteger as T, normalizeOptionalString$1 as _, isNonSuccessItemStatus as a, readHookOutputEntries as b, itemName as c, matchesCodexSnapshotTurn as d, shouldClearTerminalPresentationForNativeItem as f, extractRawAssistantText as g, unknownItemStatus as h, isMutatingNativeToolItem as i, itemStatus as l, shouldSynthesizeToolProgressForItem as m, auditNativeToolTerminalStatus as n, isSideEffectingNativeToolItem as o, shouldRecordNativeToolTranscript as p, auditNativeToolUnfinishedStatus as r, itemKind as s, auditNativeToolName as t, itemTitle as u, readCodexErrorNotificationMessage as v, readNonEmptyStringArray as w, readItem as x, readCodexProviderRefusal as y };

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

@@ -0,0 +1,102 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.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-Czh2Sdoc.js → harness-C7rRa7bm.js}

@@ -1,6 +1,6 @@
-import { l as sessionBindingIdentity, o as readCodexSessionOwnershipBinding } from "./session-binding-record-CyaXZvTe.js";
+import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
+import { t as codexBuildSymbol } from "./build-state-BCmg9-5p.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";
@@ -13,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",
@@ -81,12 +81,15 @@ function createCodexAppServerAgentHarness(options) {
 				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
-			});
+			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",
@@ -100,7 +103,7 @@ function createCodexAppServerAgentHarness(options) {
 		...sessionCatalogControlFactory && sessionRuntime ? { sessionFork: {
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-1fwbNKzQ.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-BZerMte_.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -110,27 +113,44 @@ function createCodexAppServerAgentHarness(options) {
 				});
 			}
 		} } : {},
+		taskHistory: {
+			taskKinds: ["codex-native"],
+			read: async (params) => {
+				const { readCodexNativeSubagentHistory } = await import("./native-subagent-history-DjtPloaU.js");
+				const assertCurrent = () => {
+					params.assertCurrent();
+					if (disposed) throw new Error("Agent harness is disposed");
+				};
+				return readCodexNativeSubagentHistory({
+					...params,
+					assertCurrent
+				}, {
+					bindingStore: options.bindingStore,
+					pluginConfig: resolveAttemptPluginConfig(params.cfg)
+				});
+			}
+		},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Ds_QVm-X.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-CWlKVccJ.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Bh_gf6-t.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-BJ0rXBZ_.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-i9fv5-4m.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-tCk-mg_x.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./model-catalog-DT5vo6qo.js");
+			const { createCodexAppServerModelCatalog } = await import("./model-catalog-Dq2n8f_p.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-CY9Jn4bA.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-Bd73bqA8.js");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -173,7 +193,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-BzthFQSM.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-CvsAAGa0.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: resolveAttemptPluginConfig(params.config),
@@ -183,11 +203,15 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		runIsolatedCompletionV2: async (params) => {
-			if (params.authorization.owner === "host") return runHostPreparedIsolatedCompletion(params);
-			const { runCodexIsolatedCompletion } = await import("./isolated-completion-CRh-51AK.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-DWVb5U2J.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: {
@@ -199,11 +223,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BI-b1sry.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-Dn91stmc.js");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-B6DWAw1A.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-BGMJQf4U.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -213,20 +237,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-Y_xBqrHN.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-B_H3AOd7.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-DNdmYdFc.js");
+			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-B2YfbAAT.js");
 			params.assertCurrent();
 			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
 		},
 		reset: async (params) => {
 			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 [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-CI8UuilT.js").then((n) => n.c), import("./session-retirement-B2YfbAAT.js")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -258,7 +282,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-Y_xBqrHN.js");
+		const { maybeCompactCodexAppServerSession } = await import("./compact-B_H3AOd7.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-Czh2Sdoc.js";
+import { n as createCodexAppServerNativeCompaction, t as createCodexAppServerAgentHarness } from "./harness-C7rRa7bm.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 };