@openclaw/codex 2026.9.1 → 2026.9.3

package/dist/{thread-ownership-zGokd8i1.js → thread-ownership-D6oASVRu.js}

@@ -1,14 +1,16 @@
-import { At as retainCodexAppServerLiveThread, Et as isCodexAppServerLiveThreadClaimed, _ as retainSharedCodexAppServerClientByInstanceId, kt as releaseCodexAppServerLiveThread } from "./shared-client-DxcfF9KX.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DYHcRQAa.js";
-import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
-import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as withCodexAppServerThreadMutation } from "./incognito-session-uhrBF6wJ.js";
+import { U as releaseCodexAppServerLiveThread, W as retainCodexAppServerLiveThread, _ as retainSharedCodexAppServerClientByInstanceId, z as isCodexAppServerLiveThreadClaimed } from "./shared-client-CVhez2Uo.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
 //#region extensions/codex/src/app-server/thread-ownership.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);
-}
+var thread_ownership_exports = /* @__PURE__ */ __exportAll({
+	isSameCodexAppServerThreadOwner: () => isSameCodexAppServerThreadOwner,
+	releaseCodexAppServerBindingSubscription: () => releaseCodexAppServerBindingSubscription,
+	retainCodexAppServerBindingSubscription: () => retainCodexAppServerBindingSubscription,
+	retireCodexConversationThreadBinding: () => retireCodexConversationThreadBinding,
+	rollbackCodexAppServerBindingSubscription: () => rollbackCodexAppServerBindingSubscription,
+	withExclusiveCodexAppServerThread: () => withExclusiveCodexAppServerThread
+});
 /** Codex subscriptions belong to a physical connection, not the native thread ID alone. */
 function isSameCodexAppServerThreadOwner(current, expected) {
 	return current !== void 0 && expected !== void 0 && current.threadId === expected.threadId && current.clientId === expected.clientId;
@@ -20,10 +22,6 @@ async function withExclusiveCodexAppServerThread(params) {
 		return await params.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);
-}
 /** Publishes one owned subscription with its persistent or ephemeral retention lifetime. */
 async function retainCodexAppServerBindingSubscription(client, threadId, ownership) {
 	return await retainCodexAppServerLiveThread(client, threadId, ownership?.release ?? (async (releasedThreadId, assertCurrent) => {
@@ -71,10 +69,10 @@ async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
 }
 /** Clears and releases one exact conversation generation without touching its replacement. */
 async function retireCodexConversationThreadBinding(params) {
-	const expected = await params.bindingStore.read(params.identity);
+	const expected = params.bindingStore.read(params.identity);
 	if (!expected || params.expectedThreadId && expected.threadId !== params.expectedThreadId) return false;
 	return await withCodexAppServerThreadMutation(expected.threadId, () => params.bindingStore.withLease(params.identity, async () => {
-		const current = await params.bindingStore.read(params.identity);
+		const current = params.bindingStore.read(params.identity);
 		if (!current || !isSameCodexAppServerThreadOwner(current, expected) || params.expectedStartId && current?.conversationStartId !== params.expectedStartId) return false;
 		await releaseCodexAppServerBindingSubscription(current, { allowUntracked: params.allowUntracked });
 		const cleared = await params.bindingStore.mutate(params.identity, {
@@ -100,4 +98,4 @@ async function retireCodexConversationThreadBinding(params) {
 	}));
 }
 //#endregion
-export { rollbackCodexAppServerBindingSubscription as a, withExclusiveCodexAppServerThread as c, retireCodexConversationThreadBinding as i, isIncognitoSessionKey as l, releaseCodexAppServerBindingSubscription as n, withCodexAppServerThreadMutation as o, retainCodexAppServerBindingSubscription as r, withCodexConversationThreadActivity as s, isSameCodexAppServerThreadOwner as t };
+export { rollbackCodexAppServerBindingSubscription as a, retireCodexConversationThreadBinding as i, releaseCodexAppServerBindingSubscription as n, thread_ownership_exports as o, retainCodexAppServerBindingSubscription as r, withExclusiveCodexAppServerThread as s, isSameCodexAppServerThreadOwner as t };

package/dist/{thread-policy-g4KbJPzp.js → thread-policy-D8kI7yAO.js}

@@ -1,5 +1,5 @@
-import { H as isCodexAppServerOverloadError, U as isCodexAppServerPrewriteRequestCancellationError } from "./shared-client-DxcfF9KX.js";
-import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-DYAI5FQE.js";
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError } from "./client-BEKu4yDx.js";
+import { r as requestCodexAppServerClientJson, t as CodexAppServerScopedRequestRejectedError } from "./request-CGvGOpeR.js";
 import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/thread-policy.ts
 /** A refusal, not a failed native write: the ephemeral conversation must stay alive. */

package/dist/thread-resume-T5cveyxA.js

@@ -0,0 +1,52 @@
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, y as assertCodexThreadResumeResponse } from "./client-BEKu4yDx.js";
+import { r as CodexAppServerRpcError } from "./session-catalog-provenance-DkJHo735.js";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-CGvGOpeR.js";
+import { I as forgetCodexWorkspaceReferences, k as isCodexAppServerStartupError, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CVhez2Uo.js";
+import { d as unsubscribeCodexThreadBestEffort, i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-D6cR54TV.js";
+//#region extensions/codex/src/app-server/thread-resume.ts
+/** Owns Codex thread/resume subscription safety. */
+/** Resumes one thread, releasing or isolating every possible native subscription. */
+async function resumeCodexAppServerThread(params) {
+	const threadId = params.request.threadId;
+	let response;
+	let ownershipRejected = false;
+	const assertCurrent = params.assertCurrent && (() => {
+		try {
+			params.assertCurrent?.();
+		} catch (error) {
+			ownershipRejected = true;
+			throw error;
+		}
+	});
+	try {
+		response = assertCodexThreadResumeResponse(await (params.requestResume ? params.requestResume(params.request) : params.client.request("thread/resume", params.request, {
+			...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {},
+			assertCurrent
+		})));
+		assertCodexThreadResumeSubscription(threadId, response.thread.id);
+		forgetCodexWorkspaceReferences(params.client, threadId);
+	} catch (error) {
+		if (ownershipRejected || isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerStartupError(error) || error instanceof CodexAppServerScopedRequestRejectedError || isCodexAppServerPrewriteRequestCancellationError(error) || isCodexAppServerOverloadError(error)) throw error;
+		if (error instanceof CodexAppServerRpcError) {
+			if (await unsubscribeCodexThreadBestEffort(params.client, {
+				threadId,
+				timeoutMs: 5e3,
+				assertCurrent: params.assertCurrent
+			}).catch(() => false)) {
+				params.onSubscriptionReleased?.();
+				throw error;
+			}
+		}
+		try {
+			await params.abandonClient();
+		} catch (abandonError) {
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume client could not be retired for ${threadId}`, { cause: abandonError });
+		}
+		if (error instanceof CodexAppServerUnsafeSubscriptionError) throw error;
+		throw new CodexAppServerUnsafeSubscriptionError(error instanceof Error ? error.message : `Codex thread/resume outcome is indeterminate for ${threadId}`, { cause: error });
+	}
+	return response;
+}
+//#endregion
+export { resumeCodexAppServerThread as t };

package/dist/timeout-BVw8aaM1.js

@@ -0,0 +1,33 @@
+import { withTimeout } from "openclaw/plugin-sdk/time-runtime";
+//#region extensions/codex/src/app-server/timeout.ts
+/**
+* Thin Codex app-server timeout adapter around OpenClaw's shared timeout helper.
+*/
+function resolveAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error("Codex app-server operation aborted", { cause: signal.reason });
+}
+/** Awaits a promise with a Codex-specific timeout error message. */
+async function withTimeout$1(promise, timeoutMs, timeoutMessage, createError) {
+	return await withTimeout(promise, timeoutMs, {
+		message: timeoutMessage,
+		...createError ? { createError } : {}
+	});
+}
+/** Bounds an operation by both its owner lifecycle and one total wall-clock budget. */
+async function withAbortableTimeout(params) {
+	const signal = params.signal;
+	if (signal?.aborted) throw resolveAbortError(signal);
+	let removeAbortListener;
+	const operation = signal ? Promise.race([params.promise, new Promise((_, reject) => {
+		const onAbort = () => reject(resolveAbortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+	})]) : params.promise;
+	try {
+		return await withTimeout$1(operation, params.timeoutMs, params.timeoutMessage, params.createTimeoutError);
+	} finally {
+		removeAbortListener?.();
+	}
+}
+//#endregion
+export { withTimeout$1 as n, withAbortableTimeout as t };

package/dist/transcript-mirror-attestation-DibE0krH.js

@@ -0,0 +1,89 @@
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createHash } from "node:crypto";
+//#region extensions/codex/src/app-server/transcript-mirror-attestation.ts
+function isMirroredAgentMessage(message) {
+	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
+}
+function buildCodexMirrorDedupeIdentity(message) {
+	const identity = readMirrorIdentity(message);
+	if (identity) return identity;
+	const payload = JSON.stringify({
+		role: message.role,
+		content: message.content
+	});
+	return `${message.role}:${createHash("sha256").update(payload).digest("hex").slice(0, 16)}`;
+}
+const MIRROR_ORIGIN_META_KEY = "mirrorOrigin";
+const MIRROR_SOURCE_FINGERPRINT_META_KEY = "mirrorSourceFingerprint";
+const CODEX_APP_SERVER_MIRROR_ORIGIN = "codex-app-server";
+const CODEX_META_KEY = "__openclaw";
+function applyCodexTranscriptTaint(message, state) {
+	if (message.role === "user") {
+		state.tainted = false;
+		return message;
+	}
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const metadata = asOptionalRecord(existing);
+	state.tainted ||= metadata?.turnTainted === true || metadata?.resultContentSource === "network";
+	return message.role === "assistant" && state.tainted ? {
+		...message,
+		__openclaw: {
+			...metadata,
+			turnTainted: true
+		}
+	} : message;
+}
+function attachCodexMirrorAttestation(message, sourceFingerprint) {
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	return {
+		...message,
+		[CODEX_META_KEY]: {
+			...baseMeta,
+			[MIRROR_ORIGIN_META_KEY]: CODEX_APP_SERVER_MIRROR_ORIGIN,
+			...sourceFingerprint ? { [MIRROR_SOURCE_FINGERPRINT_META_KEY]: sourceFingerprint } : {}
+		}
+	};
+}
+function attachCodexMirrorRunId(message, runId, terminal = false, settlementWarning) {
+	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	const { runTerminal: _staleTerminal, ...current } = asOptionalRecord(existing) ?? {};
+	return {
+		...message,
+		[CODEX_META_KEY]: {
+			...current,
+			runId,
+			...terminal ? { runTerminal: true } : {},
+			...terminal && settlementWarning ? { settlementWarning } : {}
+		}
+	};
+}
+function hasCodexMirrorOrigin(message) {
+	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	return asOptionalRecord(meta)?.[MIRROR_ORIGIN_META_KEY] === CODEX_APP_SERVER_MIRROR_ORIGIN;
+}
+function readCodexMirrorSourceFingerprint(message) {
+	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	const value = meta[MIRROR_SOURCE_FINGERPRINT_META_KEY];
+	return typeof value === "string" && value ? value : void 0;
+}
+function serializeCodexMirrorSourceEvidence(message) {
+	const content = "content" in message ? message.content : void 0;
+	return JSON.stringify({
+		role: message.role,
+		content,
+		...message.role === "user" ? { upstreamUserText: readUpstreamUserText(message) } : {},
+		...message.role === "toolResult" ? {
+			toolCallId: message.toolCallId,
+			toolName: message.toolName,
+			isError: message.isError
+		} : {}
+	});
+}
+function fingerprintCodexMirrorSourceMessage(message) {
+	return createHash("sha256").update(serializeCodexMirrorSourceEvidence(message)).digest("hex").slice(0, 32);
+}
+//#endregion
+export { fingerprintCodexMirrorSourceMessage as a, readCodexMirrorSourceFingerprint as c, buildCodexMirrorDedupeIdentity as i, serializeCodexMirrorSourceEvidence as l, attachCodexMirrorAttestation as n, hasCodexMirrorOrigin as o, attachCodexMirrorRunId as r, isMirroredAgentMessage as s, applyCodexTranscriptTaint as t };