@openclaw/codex 2026.9.3 → 2026.9.5

package/dist/.setup/event-projector-items-DyTQ_XqL.mjs

@@ -0,0 +1,200 @@
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+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/{attempt-notifications--H8zXR5-.js → .setup/event-projector-usage-C7Ntzs-f.mjs}

@@ -1,5 +1,6 @@
-import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
-import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+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>";
@@ -34,12 +35,6 @@ function isRawFunctionToolOutputCompletionNotification(notification) {
 	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"));
-}
 /** Returns true for terminal app-server thread status strings. */
 function isTerminalTurnStatus(status) {
 	return status === "completed" || status === "interrupted" || status === "failed";
@@ -106,4 +101,102 @@ function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
 //#endregion
-export { isRawFunctionToolOutputCompletionNotification as a, readNotificationItemId as c, isPendingOpenClawDynamicToolCompletionNotification as i, readRawResponseToolCallId as l, isAssistantCommentaryCompletionNotification as n, isTerminalTurnStatus as o, isCodexTurnAbortMarkerNotification as r, readCodexNotificationItem as s, codexExecutionToolName as t, updateActiveTurnItemIds as u };
+//#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 { isPendingOpenClawDynamicToolCompletionNotification as a, readCodexNotificationItem as c, updateActiveTurnItemIds as d, isCodexTurnAbortMarkerNotification as i, readNotificationItemId as l, readCodexThreadContextSnapshot as n, isRawFunctionToolOutputCompletionNotification as o, codexExecutionToolName as r, isTerminalTurnStatus as s, CodexUsageProjection as t, readRawResponseToolCallId as u };

package/dist/{harness-FR6eQgyO.js → .setup/harness-rxaaoN-o.mjs}

@@ -1,5 +1,6 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-CaZjYwNS.js";
-import { t as codexBuildSymbol } from "./build-state-6RL6qohz.js";
+import { CODEX_NATIVE_TOOL_REQUIREMENTS } from "../native-tool-policy.js";
+import { p as sessionBindingIdentity } from "./session-binding-record-TH3xA0zj.mjs";
+import { t as codexBuildSymbol } from "./build-state-Xx9ybZqa.mjs";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/model-runtime.ts
@@ -73,6 +74,7 @@ function createCodexAppServerAgentHarness(options) {
 		contextEngineHostCapabilities: CODEX_APP_SERVER_CONTEXT_ENGINE_HOST_CAPABILITIES,
 		conversationToolPolicySupport: "exact",
 		conversationToolPolicySafeDenyTools: CODEX_TOOL_POLICY_SAFE_DENY_NAMES,
+		conversationToolPolicyNativeTools: CODEX_NATIVE_TOOL_REQUIREMENTS,
 		deliveryDefaults: { visibleReplies: "message_tool" },
 		authBootstrap: "harness",
 		resolveSessionRuntimeOwnership: (params) => {
@@ -103,7 +105,7 @@ function createCodexAppServerAgentHarness(options) {
 		...sessionCatalogControlFactory && sessionRuntime ? { sessionFork: {
 			upstreamKinds: ["codex-app-server"],
 			fork: async (params) => {
-				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-De-sLJ2r.js");
+				const { forkCodexUpstreamSession } = await import("./upstream-session-fork-D3UKxgVD.mjs");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -113,27 +115,44 @@ function createCodexAppServerAgentHarness(options) {
 				});
 			}
 		} } : {},
+		taskHistory: {
+			taskKinds: ["codex-native"],
+			read: async (params) => {
+				const { readCodexNativeSubagentHistory } = await import("./native-subagent-history-YXaL6dMd.mjs");
+				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-Co2Vfcf_.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-DhLWa_7K.mjs").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-T-NwqeSH.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Dy38Z5iU.mjs");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-CPPTmBvZ.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-BOgBEKso.mjs");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./model-catalog-B_6M04Wo.js");
+			const { createCodexAppServerModelCatalog } = await import("./model-catalog-DkvUuBey.mjs");
 			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-J_5Ep5Um.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-K6kLCN8X.mjs");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -176,21 +195,73 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-DwKds3DN.js");
-			return runCodexAppServerAttempt(params, {
+			const { runCodexAppServerAttempt } = await import("./run-attempt-rlA07pUv.mjs");
+			const { planCodexCyberEscalation, readCodexCyberAttemptVerdict, recordCodexCyberTargetUnavailable, reserveCodexCyberProbe, resolveCodexCyberFailoverConfig } = await import("./cyber-failover-DYwbmf1o.mjs");
+			const { emitCodexCyberNotice } = await import("./cyber-failover-notice-e9G3J9-e.mjs");
+			const pluginConfig = resolveAttemptPluginConfig(params.config);
+			const attemptModel = readCodexRuntimeModelId(params.model, params.modelId);
+			const runAttemptOnModel = (model, isRetry = false) => runCodexAppServerAttempt(isRetry ? {
+				...params,
+				suppressNextUserMessagePersistence: true
+			} : params, {
 				bindingStore: options.bindingStore,
-				pluginConfig: resolveAttemptPluginConfig(params.config),
+				pluginConfig,
 				runtime: sessionRuntime,
-				runtimeModelId: readCodexRuntimeModelId(params.model, params.modelId),
+				runtimeModelId: model,
 				nativeHookRelay: { enabled: true }
 			});
+			const cyberFailover = resolveCodexCyberFailoverConfig(pluginConfig);
+			const workspace = {
+				agentId: params.agentId,
+				authProfileId: params.authProfileId
+			};
+			const result = await runAttemptOnModel(attemptModel);
+			const refusal = readCodexCyberAttemptVerdict(result);
+			if (!refusal.cyberRefused) return result;
+			const plan = planCodexCyberEscalation({
+				config: cyberFailover,
+				currentModel: attemptModel,
+				replaySafe: refusal.replaySafe,
+				workspace
+			});
+			if (plan.kind !== "escalate") {
+				if (plan.reason === "target_unavailable") await emitCodexCyberNotice(params, {
+					state: "unavailable",
+					model: attemptModel,
+					fallbackModel: cyberFailover.model
+				});
+				return result;
+			}
+			const releaseProbe = reserveCodexCyberProbe({
+				model: plan.model,
+				workspace
+			});
+			let escalated;
+			try {
+				escalated = await runAttemptOnModel(plan.model, true);
+			} finally {
+				releaseProbe();
+			}
+			const outcome = readCodexCyberAttemptVerdict(escalated);
+			if (outcome.unavailable) recordCodexCyberTargetUnavailable({
+				model: plan.model,
+				workspace,
+				cooloffMs: cyberFailover.cooloffMs
+			});
+			if (outcome.answered || outcome.unavailable) await emitCodexCyberNotice(params, {
+				state: outcome.answered ? "escalated" : "unavailable",
+				model: attemptModel,
+				fallbackModel: plan.model
+			});
+			if (outcome.unavailable && outcome.replaySafe && escalated.terminal.kind === "failed" && escalated.toolMetas.length === 0) return result;
+			return escalated;
 		},
 		runIsolatedCompletionV2: async (params) => {
 			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");
+			const { runCodexIsolatedCompletion } = await import("./isolated-completion-B6srt48J.mjs");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
@@ -206,11 +277,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BuLUrZl2.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-CiY2bLFK.mjs");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-DLbr2vUU.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DSCZyoBD.mjs");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -220,20 +291,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-CGJZ2rlb.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-C3i3qlzj.mjs");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-BSNG_mhf.js");
+			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-CU87AOg9.mjs");
 			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-CKSepwIC.js").then((n) => n.c), import("./session-retirement-BSNG_mhf.js")]);
+				const [{ reclaimCurrentCodexSessionGeneration }, { retireCodexAppServerSessionGeneration }] = await Promise.all([import("./session-binding-_0W_fHRr.mjs").then((n) => n.c), import("./session-retirement-CU87AOg9.mjs")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -265,7 +336,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-CGJZ2rlb.js");
+		const { maybeCompactCodexAppServerSession } = await import("./compact-C3i3qlzj.mjs");
 		return maybeCompactCodexAppServerSession(params, {
 			bindingStore: options.bindingStore,
 			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,

package/dist/.setup/inference-context-fulhZuz8.mjs

@@ -0,0 +1,94 @@
+import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
+import { randomUUID } from "node:crypto";
+//#region extensions/codex/src/app-server/inference-context.ts
+const MAX_CONTEXT_BYTES = 262144;
+const MAX_ACTIVE_ROOTS = 64;
+const CODEX_INFERENCE_GENERATION_KEY = "openclaw_inference_generation";
+/** One physical inference transport owns these confidential, nonpersistent snapshots. */
+function createCodexInferenceContext(assertClientCurrent) {
+	const roots = /* @__PURE__ */ new Map();
+	let closed = false;
+	const assertOpen = () => {
+		if (closed) throw new Error("Codex parent-local inference transport is closed");
+		assertClientCurrent();
+	};
+	return {
+		register(params) {
+			assertOpen();
+			params.signal.throwIfAborted();
+			params.assertCurrent();
+			if (Buffer.byteLength(params.text) > MAX_CONTEXT_BYTES) throw new Error("Codex parent-local context exceeds the 256 KiB inference limit");
+			if (!roots.has(params.threadId) && roots.size >= MAX_ACTIVE_ROOTS) throw new Error("Codex parent-local inference root limit reached");
+			roots.get(params.threadId)?.release();
+			const controller = new AbortController();
+			const registration = {
+				generation: randomUUID(),
+				text: params.text,
+				controller,
+				assertCurrent: () => {
+					assertOpen();
+					controller.signal.throwIfAborted();
+					params.signal.throwIfAborted();
+					params.assertCurrent();
+					if (roots.get(params.threadId) !== registration) throw new Error("Codex parent-local inference generation was replaced");
+				},
+				release: () => {
+					if (roots.get(params.threadId) === registration) roots.delete(params.threadId);
+					registration.text = "";
+					controller.abort();
+					params.signal.removeEventListener("abort", registration.release);
+				}
+			};
+			roots.set(params.threadId, registration);
+			params.signal.addEventListener("abort", registration.release, { once: true });
+			return {
+				generation: registration.generation,
+				release: registration.release
+			};
+		},
+		/** Caller must authenticate its private transport before parsing any model request. */
+		prepare(body) {
+			assertOpen();
+			const metadata = isJsonObject(body.client_metadata) ? body.client_metadata : void 0;
+			const raw = metadata?.["x-codex-turn-metadata"];
+			if (typeof raw !== "string" || Buffer.byteLength(raw) > 1048576) throw new Error("Codex inference request is missing bounded native metadata");
+			const value = JSON.parse(raw);
+			if (!isJsonObject(value)) throw new Error("Codex inference request has invalid native metadata");
+			const threadId = value.thread_id;
+			if (metadata?.thread_id != null && threadId != null && metadata.thread_id !== threadId) throw new Error("Codex inference thread metadata disagrees");
+			const child = Boolean(value.parent_thread_id || value.subagent_kind || metadata?.["x-openai-subagent"] || metadata?.["x-codex-parent-thread-id"]);
+			const kind = value.request_kind;
+			if (child || kind === "compaction" || kind === "memory") return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (kind !== "turn" && kind !== "prewarm") throw new Error("Codex inference request has an unsupported native purpose");
+			const registration = typeof threadId === "string" ? roots.get(threadId) : void 0;
+			const generation = value[CODEX_INFERENCE_GENERATION_KEY];
+			if (kind === "prewarm" && body.generate === false && generation == null) return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (!registration || generation !== registration.generation) throw new Error("Codex inference has no current admitted parent generation");
+			registration.assertCurrent();
+			const instructions = body.instructions;
+			if (instructions !== void 0 && typeof instructions !== "string") throw new Error("Codex inference request has invalid top-level instructions");
+			return {
+				body: registration.text ? {
+					...body,
+					instructions: instructions === void 0 ? registration.text : instructions + "\n\n" + registration.text
+				} : body,
+				assertCurrent: registration.assertCurrent,
+				signal: registration.controller.signal
+			};
+		},
+		close() {
+			closed = true;
+			for (const registration of roots.values()) registration.release();
+		}
+	};
+}
+//#endregion
+export { createCodexInferenceContext as n, CODEX_INFERENCE_GENERATION_KEY as t };