@openclaw/codex 2026.9.2 → 2026.9.3

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-usage-CIyrYYid.js

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

package/dist/{harness-Czh2Sdoc.js → harness-FR6eQgyO.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-CaZjYwNS.js";
+import { t as codexBuildSymbol } from "./build-state-6RL6qohz.js";
 import { resolvePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { runHostPreparedIsolatedCompletion } from "openclaw/plugin-sdk/simple-completion-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/model-runtime.ts
 const CODEX_APP_SERVER_RUNTIME_MODEL_PARAM = "codexAppServerRuntimeModel";
@@ -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-De-sLJ2r.js");
 				return await forkCodexUpstreamSession(params, {
 					bindingStore: options.bindingStore,
 					controlFactory: sessionCatalogControlFactory,
@@ -111,26 +114,26 @@ function createCodexAppServerAgentHarness(options) {
 			}
 		} } : {},
 		authBinding: { fingerprint: async (params) => {
-			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Ds_QVm-X.js").then((n) => n.t);
+			const { fingerprintCodexAppServerAuthBinding } = await import("./auth-binding-Co2Vfcf_.js").then((n) => n.t);
 			return fingerprintCodexAppServerAuthBinding(params);
 		} },
 		runtimeArtifact: { validate: async (binding) => {
-			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-Bh_gf6-t.js");
+			const { validateCodexAppServerRuntimeArtifact } = await import("./runtime-artifact-T-NwqeSH.js");
 			return validateCodexAppServerRuntimeArtifact(binding);
 		} },
 		fetchUsageSnapshot: async (ctx) => {
-			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-i9fv5-4m.js");
+			const { fetchCodexAppServerUsageSnapshot } = await import("./usage-CPPTmBvZ.js");
 			return await fetchCodexAppServerUsageSnapshot(ctx, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		loadModelCatalog: async (params) => {
-			const { createCodexAppServerModelCatalog } = await import("./model-catalog-DT5vo6qo.js");
+			const { createCodexAppServerModelCatalog } = await import("./model-catalog-B_6M04Wo.js");
 			if (disposed) return [];
 			modelCatalog ??= createCodexAppServerModelCatalog(harnessRuntimeId);
 			return await modelCatalog.load(params, resolveAttemptPluginConfig(params.config));
 		},
 		readModelCatalogReadiness: (params) => modelCatalog?.read(params, resolveAttemptPluginConfig(params.config)),
 		loadMcpToolCatalog: async (params) => {
-			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-CY9Jn4bA.js");
+			const { loadCodexEffectiveMcpCatalog } = await import("./effective-mcp-catalog-J_5Ep5Um.js");
 			return await loadCodexEffectiveMcpCatalog(params, { bindingStore: options.bindingStore });
 		},
 		supports: (ctx) => {
@@ -173,7 +176,7 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-BzthFQSM.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DwKds3DN.js");
 			return runCodexAppServerAttempt(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: resolveAttemptPluginConfig(params.config),
@@ -183,11 +186,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-DHBefrzg.js");
 			return runCodexIsolatedCompletion(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runIsolatedCompletion: async (params) => {
+			const { runHostPreparedIsolatedCompletion } = await import("openclaw/plugin-sdk/simple-completion-runtime");
 			return runHostPreparedIsolatedCompletion({
 				...params,
 				authorization: {
@@ -199,11 +206,11 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		finalizeSettledTurn: async (params) => {
-			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BI-b1sry.js");
+			const { runCodexSettledTurnFinalization } = await import("./settled-turn-finalizer-BuLUrZl2.js");
 			return runCodexSettledTurnFinalization(params, { pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig });
 		},
 		runSideQuestion: async (params) => {
-			const { runCodexAppServerSideQuestion } = await import("./side-question-B6DWAw1A.js");
+			const { runCodexAppServerSideQuestion } = await import("./side-question-DLbr2vUU.js");
 			return runCodexAppServerSideQuestion(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig,
@@ -213,20 +220,20 @@ function createCodexAppServerAgentHarness(options) {
 			});
 		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-Y_xBqrHN.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-CGJZ2rlb.js");
 			return maybeCompactCodexAppServerSession(params, {
 				bindingStore: options.bindingStore,
 				pluginConfig: options?.resolvePluginConfig?.() ?? options?.pluginConfig
 			});
 		},
 		withSessionDeletion: async (params, run) => {
-			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-DNdmYdFc.js");
+			const { withCodexAppServerSessionDeletion } = await import("./session-retirement-BSNG_mhf.js");
 			params.assertCurrent();
 			return withCodexAppServerSessionDeletion(options.bindingStore, params, run);
 		},
 		reset: async (params) => {
 			if (params.sessionId && params.reason !== "deleted") {
-				const [{ reclaimCurrentCodexSessionGeneration }, { 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-CKSepwIC.js").then((n) => n.c), import("./session-retirement-BSNG_mhf.js")]);
 				const identity = sessionBindingIdentity({
 					agentId: params.agentId,
 					sessionId: params.sessionId,
@@ -258,7 +265,7 @@ function createCodexAppServerAgentHarness(options) {
 /** Creates the private native-compaction bridge registered in host-owned capability state. */
 function createCodexAppServerNativeCompaction(options) {
 	return async (params) => {
-		const { maybeCompactCodexAppServerSession } = await import("./compact-Y_xBqrHN.js");
+		const { maybeCompactCodexAppServerSession } = await import("./compact-CGJZ2rlb.js");
 		return maybeCompactCodexAppServerSession(params, {
 			bindingStore: options.bindingStore,
 			pluginConfig: options.resolvePluginConfig?.() ?? options.pluginConfig,

package/dist/harness.js

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

package/dist/history-rejection-B4nOXNXF.js

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

package/dist/incognito-session-uhrBF6wJ.js

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