@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/thread-ownership-6kOQHlyC.js

@@ -0,0 +1,92 @@
+import { K as releaseCodexAppServerLiveThread, W as isCodexAppServerLiveThreadClaimed, d as retainSharedCodexAppServerClientByInstanceId, q as retainCodexAppServerLiveThread } from "./shared-client-kIBbGjk4.js";
+import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.js";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+//#region extensions/codex/src/app-server/thread-ownership.ts
+const nativeThreadOwners = new KeyedAsyncQueue();
+/** 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;
+}
+/** Fences native subscription and commit together; Codex subscriptions are not reference-counted. */
+async function withExclusiveCodexAppServerThread(params) {
+	return await nativeThreadOwners.enqueue(`thread:${params.threadId}`, async () => {
+		if (await params.bindingStore.hasOtherThreadOwner(params.threadId, params.identity)) throw new Error(`Codex thread ${params.threadId} is owned by another OpenClaw session or conversation.`);
+		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 persistent subscription into the shared bounded idle registry. */
+async function retainCodexAppServerBindingSubscription(client, threadId, ownership) {
+	return await retainCodexAppServerLiveThread(client, threadId, ownership?.release ?? (async (releasedThreadId) => {
+		if (!await unsubscribeCodexThreadBestEffort(client, {
+			threadId: releasedThreadId,
+			timeoutMs: 5e3
+		})) {
+			await closeCodexStartupClientBestEffort(client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread subscription could not be released: ${releasedThreadId}`);
+		}
+	}), ownership?.configFingerprint, ownership?.serviceTier);
+}
+/** Rolls back the exact subscription Codex created before its binding was committed. */
+async function rollbackCodexAppServerBindingSubscription(client, threadId, retained) {
+	if (retained && await releaseCodexAppServerLiveThread(client, threadId)) return;
+	if (isCodexAppServerLiveThreadClaimed(client, threadId)) return;
+	if (!await unsubscribeCodexThreadBestEffort(client, {
+		threadId,
+		timeoutMs: 5e3
+	})) await closeCodexStartupClientBestEffort(client);
+}
+/** Releases only the physical client and native thread recorded by the displaced binding owner. */
+async function releaseCodexAppServerBindingSubscription(binding, options = {}) {
+	const clientLease = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
+	if (!clientLease) return;
+	try {
+		if (await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId)) return;
+		if (isCodexAppServerLiveThreadClaimed(clientLease.client, binding.threadId)) throw new Error(`Codex thread ${binding.threadId} has an active run; stop it before changing its owner.`);
+		if (!options.allowUntracked) return;
+		if (!await unsubscribeCodexThreadBestEffort(clientLease.client, {
+			threadId: binding.threadId,
+			timeoutMs: 5e3
+		})) {
+			await closeCodexStartupClientBestEffort(clientLease.client);
+			throw new CodexAppServerUnsafeSubscriptionError(`Codex retired thread subscription could not be released: ${binding.threadId}`);
+		}
+	} finally {
+		clientLease.release();
+	}
+}
+/** Clears and releases one exact conversation generation without touching its replacement. */
+async function retireCodexConversationThreadBinding(params) {
+	const expected = await params.bindingStore.read(params.identity);
+	if (!expected || params.expectedThreadId && expected.threadId !== params.expectedThreadId) return false;
+	return await params.bindingStore.withLease(params.identity, async () => {
+		const current = await params.bindingStore.read(params.identity);
+		if (current?.threadId !== expected.threadId || params.expectedStartId && current.conversationStartId !== params.expectedStartId) return false;
+		await releaseCodexAppServerBindingSubscription(current, { allowUntracked: params.allowUntracked });
+		const cleared = await params.bindingStore.mutate(params.identity, {
+			kind: "clear",
+			threadId: current.threadId
+		});
+		if (!cleared || !params.afterClear) return cleared;
+		try {
+			await params.afterClear();
+			return true;
+		} catch (error) {
+			try {
+				if (!await params.bindingStore.mutate(params.identity, {
+					kind: "set",
+					binding: current,
+					if: { kind: "absent" }
+				})) throw new Error("the previous Codex binding generation could not be restored", { cause: error });
+			} catch (restorationError) {
+				throw new AggregateError([error, restorationError], `Codex conversation detachment failed and native thread ${current.threadId} could not be restored; run /codex resume ${current.threadId} to recover it`, { cause: restorationError });
+			}
+			throw error;
+		}
+	});
+}
+//#endregion
+export { rollbackCodexAppServerBindingSubscription as a, retireCodexConversationThreadBinding as i, releaseCodexAppServerBindingSubscription as n, withCodexConversationThreadActivity as o, retainCodexAppServerBindingSubscription as r, withExclusiveCodexAppServerThread as s, isSameCodexAppServerThreadOwner as t };

package/dist/thread-resume-CPrJNQVM.js

@@ -0,0 +1,30 @@
+import { F as isCodexAppServerPrewriteRequestCancellationError, s as isCodexAppServerStartSelectionChangedError, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
+import { i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.js";
+import { i as assertCodexThreadResumeResponse } from "./protocol-validators-B4F7L8Rf.js";
+//#region extensions/codex/src/app-server/thread-resume.ts
+/** Owns Codex thread/resume subscription safety. */
+/** Resumes one thread and retires the physical client when acceptance is indeterminate. */
+async function resumeCodexAppServerThread(params) {
+	const threadId = params.request.threadId;
+	let response;
+	try {
+		response = assertCodexThreadResumeResponse(await params.client.request("thread/resume", params.request, {
+			...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+			...params.signal ? { signal: params.signal } : {}
+		}));
+		assertCodexThreadResumeSubscription(threadId, response.thread.id);
+	} catch (error) {
+		if (isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerPrewriteRequestCancellationError(error)) throw error;
+		if (error instanceof CodexAppServerRpcError) 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 };