@openclaw/codex 2026.8.1-beta.3 → 2026.8.1

package/dist/{upstream-session-fork-BDVJCLAD.js → upstream-session-fork-BACGlOFa.js}

@@ -1,7 +1,8 @@
-import { d as sessionBindingIdentity } from "./session-binding-BTrLf9Qm.js";
-import { r as assertCodexThreadForkResponse } from "./protocol-validators-VAVyEnDp.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D_2npHlA.js";
+import { d as sessionBindingIdentity } from "./session-binding-q2WSTVmC.js";
+import { a as assertCodexThreadForkResponse } from "./protocol-validators-Bg5rpNxk.js";
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-CFmsKwr9.js";
+import { c as fingerprintCodexMirrorSourceMessage, l as readCodexMirrorSourceFingerprint, p as projectCodexUserItemText } from "./transcript-mirror-CkEQIna-.js";
+import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-Bcy33kam.js";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
 import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
@@ -17,31 +18,6 @@ function failure(code, message) {
 function asInputs(item) {
 	return Array.isArray(item.content) ? item.content : [];
 }
-function userMessageDisplay(item) {
-	let text = "";
-	let hasTextElement = false;
-	let hasImage = false;
-	let hasUnverifiableInput = false;
-	for (const input of asInputs(item)) if (input.type === "text") {
-		if (typeof input.text === "string") text += input.text;
-		hasTextElement ||= Array.isArray(input.textElements) && input.textElements.length > 0;
-	} else {
-		hasUnverifiableInput = true;
-		hasImage ||= input.type === "image" || input.type === "localImage";
-	}
-	return {
-		text,
-		visible: Boolean(text.trim()) || hasTextElement || hasImage,
-		hasUnverifiableInput
-	};
-}
-function isHiddenNestedReviewTurn(previous, turn) {
-	if (previous?.status !== "completed" || turn.status !== "interrupted" || turn.completedAt != null || !previous.items.some((item) => item.type === "enteredReviewMode") || !previous.items.some((item) => item.type === "exitedReviewMode")) return false;
-	const userMessages = turn.items.filter((item) => item.type === "userMessage");
-	const [firstUserMessage, secondUserMessage] = userMessages;
-	if (!firstUserMessage || !secondUserMessage || userMessages.length !== 2) return false;
-	return JSON.stringify(asInputs(firstUserMessage)) === JSON.stringify(asInputs(secondUserMessage));
-}
 function localMessageText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return;
@@ -52,37 +28,35 @@ function localMessageText(content) {
 		if (typed.type !== "text" || typeof typed.text !== "string") return;
 		texts.push(typed.text);
 	}
-	return texts.join("");
+	return texts.join("\n");
 }
 function resolveCodexUpstreamForkBoundaryFromTurns(params) {
-	let visibleUserMessagesSeen = 0;
-	let reviewMode = false;
+	let localIndex = 0;
+	let matchedPrefix = false;
 	for (const [turnIndex, turn] of params.turns.entries()) {
-		const hiddenNestedReviewTurn = isHiddenNestedReviewTurn(params.turns[turnIndex - 1], turn);
 		let userMessagesInTurn = 0;
 		for (const item of turn.items) {
-			if (item.type === "enteredReviewMode") {
-				reviewMode = true;
-				continue;
-			}
-			if (item.type === "exitedReviewMode") {
-				reviewMode = false;
-				continue;
-			}
 			if (item.type !== "userMessage") continue;
 			const isSteer = userMessagesInTurn > 0;
 			userMessagesInTurn += 1;
-			if (reviewMode || hiddenNestedReviewTurn) continue;
-			const display = userMessageDisplay(item);
-			if (display.hasUnverifiableInput) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			if (!display.visible) continue;
-			const ordinal = visibleUserMessagesSeen;
-			if (ordinal > params.userMessageOrdinal) break;
-			const localText = params.localPrefixTexts[ordinal];
-			if (localText === void 0) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			if (display.text !== localText) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
-			if (ordinal !== params.userMessageOrdinal) {
-				visibleUserMessagesSeen += 1;
+			if (asInputs(item).some((input) => input.type !== "text")) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
+			const text = projectCodexUserItemText(item);
+			if (!text) continue;
+			const local = params.localPrefix[localIndex];
+			const identity = local && readMirrorIdentity(local.message);
+			const matchesIdentity = identity === `${turn.id}:${item.id}` || !isSteer && identity === `${turn.id}:prompt`;
+			if (!matchedPrefix && !matchesIdentity) continue;
+			matchedPrefix = true;
+			const localText = localMessageText(local && "content" in local.message ? local.message.content : void 0);
+			const upstreamText = local && readUpstreamUserText(local.message);
+			const upstreamPromptVerified = !upstreamText || local?.message.role === "user" && readCodexMirrorSourceFingerprint(local.message) === fingerprintCodexMirrorSourceMessage(local.message);
+			const expectedText = upstreamText ? projectCodexUserItemText({ content: [{
+				type: "text",
+				text: upstreamText
+			}] }) : localText;
+			if (!matchesIdentity || !upstreamPromptVerified || localText === void 0 || text !== expectedText) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
+			if (localIndex < params.localPrefix.length - 1) {
+				localIndex += 1;
 				continue;
 			}
 			if (isSteer) return failure("steer-message", "This message steered an existing Codex turn and cannot be forked independently. Fork from the turn's first message instead.");
@@ -104,7 +78,7 @@ function resolveCodexUpstreamForkBoundaryFromTurns(params) {
 			};
 		}
 	}
-	return failure("drift-mismatch", "The message could not be matched to the Codex thread. Refresh the session and try again.");
+	return failure("drift-mismatch", "The local history has no verified boundary in this Codex thread. Use native Codex to fork this conversation.");
 }
 async function listCodexUpstreamTurns(control, threadId) {
 	const turns = [];
@@ -128,24 +102,23 @@ async function listCodexUpstreamTurns(control, threadId) {
 }
 async function resolveCodexUpstreamForkBoundary(params) {
 	try {
-		if ((await params.control.readThread(params.threadId, false)).historyMode === "paginated") return failure("upstream-unavailable", "This Codex thread uses paginated history, which cannot be forked from OpenClaw yet.");
 		const visibleUserEntries = (await readVisibleSessionTranscriptMessageEntries({
 			agentId: params.agentId,
 			sessionId: params.sessionId,
 			sessionKey: params.sessionKey,
 			storePath: params.storePath
 		})).filter((entry) => entry.role === "user");
-		const userMessageOrdinal = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
-		if (userMessageOrdinal < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
-		const localPrefixTexts = visibleUserEntries.slice(0, userMessageOrdinal + 1).map((entry) => localMessageText("content" in entry.message ? entry.message.content : void 0));
+		const targetIndex = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
+		if (targetIndex < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
+		const localPrefix = visibleUserEntries.slice(0, targetIndex + 1);
 		const resolved = resolveCodexUpstreamForkBoundaryFromTurns({
 			turns: await listCodexUpstreamTurns(params.control, params.threadId),
-			userMessageOrdinal,
-			localPrefixTexts
+			localPrefix
 		});
+		const target = localPrefix.at(-1)?.message;
 		return resolved.ok ? {
 			...resolved,
-			editorText: localPrefixTexts[userMessageOrdinal]
+			editorText: localMessageText(target && "content" in target ? target.content : void 0)
 		} : resolved;
 	} catch {
 		return failure("upstream-unavailable", "The Codex thread could not be read. Check that Codex is available, then try again.");
@@ -166,9 +139,6 @@ function readConnectionFingerprint(ref) {
 	if (!isRecord(ref)) return;
 	return typeof ref.connectionFingerprint === "string" && ref.connectionFingerprint.trim() ? ref.connectionFingerprint : void 0;
 }
-function normalizeTurnId(value) {
-	return normalizeOptionalString(value);
-}
 async function forkCodexUpstreamSession(params, options) {
 	try {
 		const sourceFingerprint = params.upstream.kind === "codex-app-server" ? readConnectionFingerprint(params.upstream.ref) : void 0;
@@ -179,27 +149,33 @@ async function forkCodexUpstreamSession(params, options) {
 			message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
 		};
 		return await requestControl.withPinnedConnection(async (control) => {
-			const incognito = isIncognitoSessionKey(params.targetKey);
-			const clientId = control.clientId?.trim();
-			if (incognito && !clientId) throw new Error("Incognito Codex forks require the live pinned app-server client");
+			const sourceBinding = await options.bindingStore.read(sessionBindingIdentity({
+				...params.source,
+				config: options.resolveConfig?.()
+			}));
+			const supervised = sourceBinding?.connectionScope === "supervision";
+			const sourceThreadId = params.upstream.threadId;
 			let linked = false;
-			let bindingIdentity;
+			let createdBinding;
 			const compensateFork = async (forkedThreadId) => {
-				if (bindingIdentity) await options.bindingStore.mutate(bindingIdentity, {
-					kind: "clear",
-					threadId: forkedThreadId
-				}).catch(() => void 0);
+				if (createdBinding) {
+					if (!await options.bindingStore.mutate(createdBinding.identity, {
+						kind: "clear",
+						threadId: forkedThreadId,
+						expectedPendingSupervisionBranch: createdBinding.pending
+					}).catch(() => false)) return;
+				}
 				if (linked) deleteSessionUpstreamLink(params.targetKey, params.source.agentId);
 				await control.archiveThread(forkedThreadId).catch(() => void 0);
 			};
-			if (sourceFingerprint !== control.connectionFingerprint) return {
+			if (sourceFingerprint !== control.connectionFingerprint || supervised && (sourceBinding.supervisionSourceThreadId !== params.upstream.threadId || (sourceBinding.pendingSupervisionBranch?.connectionFingerprint ?? sourceBinding.appServerRuntimeFingerprint) !== sourceFingerprint)) return {
 				status: "failed",
 				code: "upstream-unavailable",
 				message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
 			};
 			const resolved = await resolveCodexUpstreamForkBoundary({
 				...params.source,
-				threadId: params.upstream.threadId,
+				threadId: sourceThreadId,
 				control
 			});
 			if (!resolved.ok) return {
@@ -207,7 +183,7 @@ async function forkCodexUpstreamSession(params, options) {
 				code: resolved.code,
 				message: resolved.message
 			};
-			const liveTurns = await listCodexUpstreamTurns(control, params.upstream.threadId);
+			const liveTurns = await listCodexUpstreamTurns(control, sourceThreadId);
 			const precheck = precheckCodexUpstreamForkBoundary({
 				boundary: resolved.boundary,
 				turns: liveTurns
@@ -218,27 +194,27 @@ async function forkCodexUpstreamSession(params, options) {
 				message: precheck.message
 			};
 			const rawResponse = await control.forkThread({
-				threadId: params.upstream.threadId,
+				threadId: sourceThreadId,
 				beforeTurnId: resolved.boundary.beforeTurnId,
-				...incognito ? { ephemeral: true } : {},
-				excludeTurns: !incognito
+				...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
+				excludeTurns: true
 			});
 			let response;
 			try {
 				response = assertCodexThreadForkResponse(rawResponse);
 			} catch (error) {
 				const orphanThreadId = isRecord(rawResponse.thread) && typeof rawResponse.thread.id === "string" ? rawResponse.thread.id.trim() : "";
-				if (orphanThreadId && orphanThreadId !== params.upstream.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
+				if (orphanThreadId && orphanThreadId !== sourceThreadId && orphanThreadId !== sourceBinding?.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
 				throw error;
 			}
 			const threadId = response.thread.id.trim();
 			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
-			if (threadId === params.upstream.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
 			const forkedThreadId = threadId;
 			try {
-				const connectionFingerprint = control.connectionFingerprint;
+				const connectionFingerprint = normalizeOptionalString(control.connectionFingerprint);
 				if (!connectionFingerprint) throw new Error("Codex fork connection did not include a fingerprint");
-				const forkedTurns = incognito ? response.thread.turns ?? [] : await listCodexUpstreamTurns(control, threadId);
+				const forkedTurns = await listCodexUpstreamTurns(control, threadId);
 				const expectedLastTurnId = resolved.boundary.retainedMarker.turnId;
 				if ((forkedTurns.at(-1)?.id ?? null) !== expectedLastTurnId) {
 					await compensateFork(forkedThreadId);
@@ -252,8 +228,8 @@ async function forkCodexUpstreamSession(params, options) {
 					...response.thread,
 					turns: forkedTurns
 				};
-				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeTurnId) ?? null;
-				const marker = codexUpstreamBaseline(forkedThread, normalizeTurnId);
+				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeOptionalString) ?? null;
+				const marker = codexUpstreamBaseline(forkedThread, normalizeOptionalString);
 				const config = options.resolveConfig?.() ?? {};
 				return {
 					status: "created",
@@ -269,7 +245,7 @@ async function forkCodexUpstreamSession(params, options) {
 							modelSelectionLocked: true
 						},
 						afterImport: async (entry) => {
-							bindingIdentity = sessionBindingIdentity({
+							const bindingIdentity = sessionBindingIdentity({
 								agentId: entry.agentId,
 								sessionId: entry.sessionId,
 								sessionKey: entry.key,
@@ -289,17 +265,33 @@ async function forkCodexUpstreamSession(params, options) {
 								marker
 							});
 							if (!linked) throw new Error("Codex fork link could not be persisted");
+							createdBinding = {
+								identity: bindingIdentity,
+								pending: {
+									sourceThreadId: threadId,
+									connectionFingerprint,
+									...throughTurnId ? { lastTurnId: throughTurnId } : {}
+								}
+							};
 							if (!await options.bindingStore.mutate(bindingIdentity, {
 								kind: "set",
+								if: { kind: "absent" },
 								binding: {
 									threadId,
-									...incognito && clientId ? { clientId } : {},
+									connectionScope: "supervision",
+									supervisionSourceThreadId: threadId,
+									preserveNativeModel: true,
+									conversationSourceTransferComplete: true,
+									pendingSupervisionBranch: createdBinding.pending,
 									cwd: forkedThread.cwd ?? "",
 									model: response.model,
 									modelProvider: response.modelProvider ?? void 0,
 									historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
 								}
-							})) throw new Error("Codex session binding changed before the fork could be attached");
+							})) {
+								createdBinding = void 0;
+								throw new Error("Codex session binding changed before the fork could be attached");
+							}
 							return { pluginExtensions: entry.entry.pluginExtensions };
 						}
 					})).key,

package/dist/{usage-9dKJCgcy.js → usage-C2l8Mils.js}

@@ -1,6 +1,6 @@
-import { i as resolveCodexAppServerRuntimeOptions } from "./config-CpNeo5AE.js";
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-BI1dMHDG.js";
-import { t as readCodexAppServerUsage } from "./request-DSK0W6YI.js";
+import { i as resolveCodexAppServerRuntimeOptions } from "./config-Cxw3Cl3k.js";
+import { n as readCodexAppServerUsage } from "./request-CCm4LaED.js";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-hFtzt2Up.js";
 import { CODEX_APP_SERVER_AUTH_MARKER } from "openclaw/plugin-sdk/agent-runtime";
 //#region extensions/codex/src/app-server/usage.ts
 /** Handles the synthetic usage credential for a Codex-backed OpenAI route. */

package/dist/{web-search-provider.runtime-DCdx4DGu.js → web-search-provider.runtime-B2XgRdFv.js}

@@ -1,6 +1,6 @@
-import { ut as isJsonObject } from "./shared-client-Dw-rzii0.js";
-import { d as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-DKdrnTMX.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-4BjrZEwW.js";
+import { Ht as isJsonObject } from "./shared-client-kNkljY-R.js";
+import { b as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-Ss-uwnC4.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-rq5tiSXk.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { readStringParam, resolveSearchTimeoutSeconds, wrapWebContent } from "openclaw/plugin-sdk/provider-web-search";
 //#region extensions/codex/src/web-search-provider.runtime.ts

package/openclaw.plugin.json

@@ -1,9 +1,27 @@
 {
   "id": "codex",
+  "backupResources": [
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/tmp/arg0"
+    },
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/.tmp/plugins"
+    },
+    {
+      "disposition": "regenerable",
+      "scope": "agent",
+      "relativePath": "codex-home/.tmp/bundled-marketplaces"
+    }
+  ],
   "doctorContract": {
     "configRepair": true,
     "stateMigrations": true
   },
+  "doctorHealthChecks": true,
   "sessionRouteStateOwners": [
     {
       "id": "codex",
@@ -497,7 +515,7 @@
     },
     "computerUse.autoRepair": {
       "label": "Auto Repair",
-      "help": "When true, failed Computer Use live tests repair stale scoped Computer Use MCP children before retrying once.",
+      "help": "When true, failed Computer Use live tests reload the Codex-owned MCP runtime before retrying once.",
       "advanced": true
     },
     "computerUse.marketplaceSource": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.8.1-beta.3",
+  "version": "2026.8.1",
   "description": "OpenClaw Codex app-server harness and native session supervision plugin.",
   "repository": {
     "type": "git",
@@ -8,11 +8,11 @@
   },
   "type": "module",
   "dependencies": {
-    "@openai/codex": "0.149.1",
+    "@openai/codex": "0.151.0",
     "semver": "7.8.5",
-    "smol-toml": "1.7.1",
-    "typebox": "1.3.6",
-    "ws": "8.21.1",
+    "smol-toml": "1.8.0",
+    "typebox": "1.3.16",
+    "ws": "8.21.3",
     "zod": "4.4.3"
   },
   "devDependencies": {
@@ -36,10 +36,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.8.1-beta.3"
+      "pluginApi": ">=2026.8.1"
     },
     "build": {
-      "openclawVersion": "2026.8.1-beta.3"
+      "openclawVersion": "2026.8.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -59,7 +59,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.8.1-beta.3"
+    "openclaw": ">=2026.8.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/app-server-policy-bg5QPSVP.js

@@ -1,25 +0,0 @@
-import { b as canUseCodexModelBackedApprovalsReviewerForModel } from "./config-CpNeo5AE.js";
-//#region extensions/codex/src/app-server/app-server-policy.ts
-function resolveCodexAppServerForModelProvider(params) {
-	const explicitProvider = normalizeModelBackedReviewerProvider(params.provider);
-	if (!isCodexModelBackedApprovalsReviewer(params.appServer.approvalsReviewer) || canUseCodexModelBackedApprovalsReviewerForModel({
-		modelProvider: explicitProvider,
-		model: params.model,
-		config: params.config,
-		env: params.env,
-		agentDir: params.agentDir,
-		codexConfigToml: params.codexConfigToml
-	})) return params.appServer;
-	return {
-		...params.appServer,
-		approvalsReviewer: "user"
-	};
-}
-function isCodexModelBackedApprovalsReviewer(value) {
-	return value === "auto_review" || value === "guardian_subagent";
-}
-function normalizeModelBackedReviewerProvider(provider) {
-	return provider?.trim().toLowerCase() || void 0;
-}
-//#endregion
-export { resolveCodexAppServerForModelProvider as t };

package/dist/command-rpc-xUIIonsO.js

@@ -1,90 +0,0 @@
-import { i as resolveCodexAppServerRuntimeOptions, s as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-CpNeo5AE.js";
-import { n as listCodexAppServerModels } from "./models-CZw1wClT.js";
-import { n as describeControlFailure, t as CODEX_CONTROL_METHODS } from "./capabilities-CH3K57v4.js";
-import { i as withCodexAppServerJsonClient, r as requestCodexAppServerJson } from "./request-DSK0W6YI.js";
-//#region extensions/codex/src/command-rpc.ts
-function requestOptions(pluginConfig, limit, config, agentDir) {
-	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	return {
-		limit,
-		timeoutMs: runtime.requestTimeoutMs,
-		startOptions: runtime.start,
-		config,
-		agentDir
-	};
-}
-async function codexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	const runtime = options.startOptions ? resolveCodexSupervisionAppServerRuntimeOptions({ pluginConfig }) : resolveCodexAppServerRuntimeOptions({ pluginConfig });
-	const controlRequestOptions = {
-		timeoutMs: options.timeoutMs ?? runtime.requestTimeoutMs,
-		startOptions: options.startOptions ?? runtime.start,
-		config: options.config,
-		sessionKey: options.sessionKey,
-		sessionId: options.sessionId,
-		authProfileId: options.authProfileId,
-		agentDir: options.agentDir,
-		isolated: options.isolated
-	};
-	if (options.onResponse) return await withCodexAppServerJsonClient(controlRequestOptions, async (request, client) => {
-		const response = await request({
-			method,
-			requestParams
-		});
-		await options.onResponse(response, client);
-		return response;
-	});
-	return await requestCodexAppServerJson({
-		method,
-		requestParams,
-		...controlRequestOptions
-	});
-}
-async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
-	return await safeValue(async () => await codexControlRequest(pluginConfig, method, requestParams, options));
-}
-async function safeCodexModelList(pluginConfig, limit, config, agentDir) {
-	return await safeValue(async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config, agentDir)));
-}
-async function readCodexStatusProbes(pluginConfig, config, agentDir) {
-	const [models, account, limits, mcps, skills] = await Promise.all([
-		safeCodexModelList(pluginConfig, 20, config, agentDir),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listMcpServers, { limit: 100 }, {
-			config,
-			agentDir
-		}),
-		safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, {
-			config,
-			agentDir
-		})
-	]);
-	return {
-		models,
-		account,
-		limits,
-		mcps,
-		skills
-	};
-}
-async function safeValue(read) {
-	try {
-		return {
-			ok: true,
-			value: await read()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error: describeControlFailure(error)
-		};
-	}
-}
-//#endregion
-export { safeCodexControlRequest as i, readCodexStatusProbes as n, requestOptions as r, codexControlRequest as t };

package/dist/incognito-session-ET_ufDH-.js

@@ -1,2 +0,0 @@
-import { isIncognitoSessionKey } from "openclaw/plugin-sdk/routing";
-export { isIncognitoSessionKey as t };

package/dist/model-catalog-CmGoqVKB.js

@@ -1,48 +0,0 @@
-import { r as buildCodexRuntimeModelParams } from "./harness-DoKQcF8n.js";
-import { h as readCodexPluginConfig } from "./config-CpNeo5AE.js";
-import { t as listAllCodexAppServerModels } from "./models-CZw1wClT.js";
-import { r as requestOptions } from "./command-rpc-xUIIonsO.js";
-//#region extensions/codex/src/app-server/model-catalog.ts
-const OPENAI_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
-const DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS = 2500;
-const INPUT_TYPES = /* @__PURE__ */ new Set([
-	"text",
-	"image",
-	"audio",
-	"video",
-	"document"
-]);
-function isModelInputType(value) {
-	return INPUT_TYPES.has(value);
-}
-function codexAppServerModelsToCatalogEntries(models) {
-	return models.map((model, providerOrder) => {
-		const input = model.inputModalities.filter(isModelInputType);
-		const runtimeParams = buildCodexRuntimeModelParams(model.id, model.model);
-		return {
-			provider: "openai",
-			id: model.id,
-			name: model.displayName ?? model.id,
-			providerOrder,
-			api: "openai-chatgpt-responses",
-			baseUrl: OPENAI_CODEX_BASE_URL,
-			reasoning: model.supportedReasoningEfforts.length > 0,
-			...input.length > 0 ? { input } : {},
-			...runtimeParams ? { params: runtimeParams } : {},
-			compat: {
-				supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
-				supportedReasoningEfforts: model.supportedReasoningEfforts
-			}
-		};
-	});
-}
-async function loadCodexAppServerModelCatalog(params, pluginConfig) {
-	const discovery = readCodexPluginConfig(pluginConfig).discovery;
-	if (discovery?.enabled === false) return [];
-	return codexAppServerModelsToCatalogEntries((await listAllCodexAppServerModels({
-		...requestOptions(pluginConfig, 100, params.config, params.agentDir),
-		timeoutMs: discovery?.timeoutMs ?? DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS
-	})).models);
-}
-//#endregion
-export { loadCodexAppServerModelCatalog };