@openclaw/codex 2026.9.4 → 2026.9.6

package/dist/{upstream-session-fork-BZerMte_.js → .setup/upstream-session-fork-BUr4OUbC.mjs}

@@ -1,37 +1,38 @@
-import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
-import { f as assertCodexModelBackedReviewerEffectiveConfig } from "./config-options-CXMq1T-C.js";
-import { a as flattenCodexDynamicToolFunctions, o as isJsonObject, x as readCodexPluginConfig } from "./protocol-5bh1G-H7.js";
-import { _ as assertCodexThreadAcceptsDirectInput, v as assertCodexThreadForkResponse } from "./client-B57KWPQx.js";
-import { n as withCodexAppServerThreadMutation } from "./incognito-session-uhrBF6wJ.js";
-import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { i as projectCodexUserItemText } from "./transcript-history-projection-v17wXgdK.js";
-import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.js";
-import { r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-d0eKxy7b.js";
-import { n as readCodexSessionMeta } from "./session-catalog-provenance-D-dIfRAH.js";
-import { t as CodexAppServerScopedRequestRejectedError } from "./request-B7hEkBGq.js";
-import { n as resolveOpenClawExecPolicyForCodexAppServer } from "./config-oIORaQ5T.js";
-import { r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
-import { a as fingerprintCodexMirrorSourceMessage, c as readCodexMirrorSourceFingerprint } from "./transcript-mirror-attestation-DibE0krH.js";
-import { L as claimCodexAppServerLiveThread, V as hasCodexAppServerLiveThread, f as readCodexAppServerClientDesktopGenerationFingerprint } from "./shared-client-CscigXXL.js";
-import { $ as codexDynamicToolsFingerprint, C as resolveCodexWebSearchPlan, Et as mergeCodexThreadConfigs, G as checkCodexThreadAppAvailability, H as resolveCodexNativeHookRelayEvents, I as assertCodexNativeHookRelayAllowed, L as buildCodexNativeHookRelayConfig, Ot as shouldBuildCodexPluginThreadConfig, St as buildCodexPluginThreadConfig, X as applyCodexNativeSkillIsolation, Y as parseCodexNativeToolCatalog, Z as resolveCodexNativeSkillIsolation, b as buildCodexThreadConfiguration, nt as fingerprintUserMcpServersConfigPatch, tt as fingerprintJsonObject, w as buildDeveloperInstructions, z as buildCodexNativeHookRelayId } from "./thread-lifecycle-DXl1-I6b.js";
-import "./session-binding-CI8UuilT.js";
-import { i as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError } from "./thread-policy-BuEQfE0g.js";
-import "./thread-ownership-BsDRTsyp.js";
-import { n as resolveCodexNativeExecutionPolicy } from "./native-execution-policy-umd0tgh4.js";
-import { l as isCodexDynamicToolExcluded, n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-BvCUL69A.js";
-import { o as prepareCodexWorkspaceDeveloperInstructions } from "./attempt-context-D44yeDII.js";
-import { n as prepareCodexSessionInitialization } from "./session-initialization-Ct0_Hzmg.js";
-import { createImportedCodexSession } from "./session-history-import-DwyijFI6.js";
+import { m as sessionBindingIdentity } from "./session-binding-record-BGoz8wOK.mjs";
+import { d as readCodexPluginConfig } from "./config-parsing-CcB9iPoq.mjs";
+import { i as isJsonObject, r as flattenCodexDynamicToolFunctions } from "./protocol-CANUwXJ3.mjs";
+import { s as assertCodexModelBackedReviewerEffectiveConfig } from "./config-options-BvaRs51b.mjs";
+import { o as readCodexSessionMeta } from "./session-catalog-events-Bj6j94E_.mjs";
+import { n as withCodexAppServerThreadMutation } from "./incognito-session-uhrBF6wJ.mjs";
+import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.mjs";
+import { i as projectCodexUserItemText } from "./transcript-history-projection-ZZpkFkJ_.mjs";
+import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.mjs";
+import { r as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B2CsSdnV.mjs";
+import { t as CodexAppServerScopedRequestRejectedError } from "./request-D2L0zMrq.mjs";
+import { n as resolveOpenClawExecPolicyForCodexAppServer } from "./config-BoTP_mrL.mjs";
+import { r as resolveCodexSupervisionAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
+import { a as fingerprintCodexMirrorSourceMessage, c as readCodexMirrorSourceFingerprint } from "./transcript-mirror-attestation-CzM-94NC.mjs";
+import { I as hasCodexAppServerLiveThread, M as claimCodexAppServerLiveThread, f as readCodexAppServerClientDesktopGenerationFingerprint } from "./shared-client-DA4VR4Eb.mjs";
+import { l as isCodexAppServerOverloadError, u as isCodexAppServerPrewriteRequestCancellationError, v as assertCodexThreadAcceptsDirectInput, y as assertCodexThreadForkResponse } from "./client-Cs08OXVQ.mjs";
+import { B as parseCodexNativeToolCatalog, Ct as shouldBuildCodexPluginThreadConfig, E as buildCodexNativeHookRelayConfig, F as checkCodexThreadAppAvailability, H as resolveCodexNativeSkillIsolation, K as codexDynamicToolsFingerprint, O as buildCodexNativeHookRelayId, T as assertCodexNativeHookRelayAllowed, V as applyCodexNativeSkillIsolation, X as fingerprintJsonObject, Z as fingerprintUserMcpServersConfigPatch, a as buildCodexThreadConfiguration, j as resolveCodexNativeHookRelayEvents, m as buildDeveloperInstructions, mt as buildCodexPluginThreadConfig, p as resolveCodexWebSearchPlan, xt as mergeCodexThreadConfigs } from "./thread-requests-BLvGkP2R.mjs";
+import "./session-binding-Cm0apEbd.mjs";
+import { a as refreshCodexThreadPolicy, n as CodexThreadPolicyHandoffError } from "./thread-policy-DGuQsuFC.mjs";
+import "./thread-ownership-DcTtAcXj.mjs";
+import { n as resolveCodexNativeExecutionPolicy } from "./native-execution-policy-umd0tgh4.mjs";
+import { d as isCodexDynamicToolExcluded, n as resolveCodexProviderWebSearchSupportForClient } from "./provider-capabilities-BfE88FZ5.mjs";
+import { u as prepareCodexWorkspaceDeveloperInstructions } from "./attempt-workspace-context-DUVEn_CS.mjs";
+import { n as prepareCodexSessionInitialization } from "./session-initialization-rcgbZiid.mjs";
+import { createImportedCodexSession } from "./session-history-import-D-3wAgOP.mjs";
 import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import path from "node:path";
 import { lstat } from "node:fs/promises";
-import { constants, createZstdDecompress } from "node:zlib";
 import { root } from "openclaw/plugin-sdk/file-access-runtime";
+import { constants, createZstdDecompress } from "node:zlib";
 import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/agent-runtime";
 import { loadCodexBundleMcpThreadConfig } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { loadExecApprovals } from "openclaw/plugin-sdk/exec-approvals-runtime";
-import { isDeepStrictEqual } from "node:util";
 import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { buildCodexUserMcpServersThreadConfigPatchForRuntime, resolveCodexMcpToolOverridesForAgent } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { buildNativeHookRelayCommandPlan } from "openclaw/plugin-sdk/native-hook-relay-runtime";
@@ -258,7 +259,7 @@ async function prepareCanonicalCodexFork(params) {
 	const nativeSkillIsolation = await resolveCodexNativeSkillIsolation({
 		client: context.client,
 		cwd,
-		codexHome: appServer.start.env?.CODEX_HOME,
+		codexHome: appServer.start.codexHome ?? appServer.start.env?.CODEX_HOME,
 		home: appServer.start.env?.HOME,
 		userProfile: appServer.start.env?.USERPROFILE
 	});
@@ -374,15 +375,15 @@ function resolveCodexUpstreamForkBoundaryFromTurns(params) {
 			if (item.type !== "userMessage") continue;
 			const isSteer = userMessagesInTurn > 0;
 			userMessagesInTurn += 1;
+			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;
 			const nativeText = textOnlyMessage(item.content);
 			if (nativeText === 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.");
-			const local = params.localPrefix[localIndex];
 			const upstreamText = local && readUpstreamUserText(local.message);
 			const text = upstreamText ? nativeText : projectCodexUserItemText(item);
 			if (!text) continue;
-			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 = textOnlyMessage(local && "content" in local.message ? local.message.content : void 0);
 			const upstreamPromptVerified = !upstreamText || local?.message.role === "user" && readCodexMirrorSourceFingerprint(local.message) === fingerprintCodexMirrorSourceMessage(local.message);
@@ -566,6 +567,7 @@ async function forkCanonicalCodexSession(params) {
 						}
 					});
 					const assertCurrent = () => {
+						fork.assertCurrent();
 						initialization.assertCurrent();
 						if (ownership && !subscriptionReleased) ownership.assertCurrent();
 					};
@@ -731,7 +733,7 @@ function readConnectionFingerprint(ref) {
 async function forkCodexUpstreamSession(params, options) {
 	try {
 		const sourceFingerprint = params.upstream.kind === "codex-app-server" ? readConnectionFingerprint(params.upstream.ref) : void 0;
-		const requestControl = sourceFingerprint ? options.controlFactory.forUpstream(params.source.agentId, sourceFingerprint) : void 0;
+		const requestControl = sourceFingerprint ? await options.controlFactory.forUpstream(params.source.agentId, sourceFingerprint) : void 0;
 		if (!sourceFingerprint || !requestControl) return {
 			status: "failed",
 			code: "upstream-unavailable",
@@ -796,16 +798,23 @@ async function forkCodexUpstreamSession(params, options) {
 				code: precheck.code,
 				message: precheck.message
 			};
-			const rawResponse = await control.forkThread({
-				threadId: sourceThreadId,
-				beforeTurnId: resolved.boundary.beforeTurnId,
-				...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
-				excludeTurns: true
-			});
-			const response = assertCodexThreadForkResponse(rawResponse);
-			const threadId = response.thread.id.trim();
-			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
-			if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			let response;
+			let threadId;
+			try {
+				const rawResponse = await control.forkThread({
+					threadId: sourceThreadId,
+					beforeTurnId: resolved.boundary.beforeTurnId,
+					...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
+					excludeTurns: true
+				}, params.assertCurrent);
+				response = assertCodexThreadForkResponse(rawResponse);
+				threadId = response.thread.id.trim();
+				if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
+				if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
+			} catch (error) {
+				if (!(error instanceof CodexAppServerScopedRequestRejectedError) && !isCodexAppServerPrewriteRequestCancellationError(error) && !isCodexAppServerOverloadError(error)) control.retireConnection?.();
+				throw error;
+			}
 			const forkedThreadId = threadId;
 			try {
 				const connectionFingerprint = normalizeOptionalString(control.connectionFingerprint);

package/dist/{usage-tCk-mg_x.js → .setup/usage-BML0r-ua.mjs}

@@ -1,7 +1,7 @@
-import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-CBMmWBr9.js";
-import { n as readCodexAppServerUsage } from "./request-B7hEkBGq.js";
-import "./config-oIORaQ5T.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { t as buildCodexAppServerUsageSnapshot } from "./rate-limits-CMU3DUD0.mjs";
+import { n as readCodexAppServerUsage } from "./request-D2L0zMrq.mjs";
+import "./config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C8Rw1m1m.mjs";
 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. */
@@ -10,6 +10,7 @@ async function fetchCodexAppServerUsageSnapshot(ctx, options = {}) {
 	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
 	const usage = await (options.readUsage ?? readCodexAppServerUsage)({
 		timeoutMs: ctx.timeoutMs,
+		signal: ctx.signal,
 		agentDir: ctx.agentDir,
 		...ctx.authProfileId ? { authProfileId: ctx.authProfileId } : {},
 		config: ctx.config,

package/dist/.setup/usage-limit-error-DUMbefVY.mjs

@@ -0,0 +1,166 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { a as shouldRefreshCodexRateLimitsForUsageLimitMessage, i as resolveCodexUsageLimitResetAtMs, n as formatCodexUsageLimitErrorMessage } from "./rate-limits-CMU3DUD0.mjs";
+import { t as CODEX_CONTROL_METHODS } from "./capabilities-CDXOOFdZ.mjs";
+import { J as rememberCodexRateLimitsRead, K as readCodexRateLimitsRevision, q as readRecentCodexRateLimits } from "./shared-client-DA4VR4Eb.mjs";
+import { readStringField } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { markAuthProfileBlockedUntil } from "openclaw/plugin-sdk/agent-runtime";
+import { embeddedAgentLog, formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/usage-limit-error.ts
+/**
+* Enriches Codex usage-limit failures with current rate-limit information and
+* marks blocked auth profiles when Codex exposes a reset time.
+*/
+const CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS = 5e3;
+var CodexUsageLimitPromptError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.status = 429;
+	}
+};
+function resolveCodexPromptError(source) {
+	const usageLimitMessage = formatCodexUsageLimitErrorMessage(source);
+	if (usageLimitMessage) return new CodexUsageLimitPromptError(usageLimitMessage);
+	const info = source.codexErrorInfo;
+	let status = info === "rateLimitExceeded" ? 429 : info === "serverOverloaded" ? 503 : info === "internalServerError" ? 500 : void 0;
+	if (isJsonObject(info)) for (const variant of [
+		"httpConnectionFailed",
+		"responseStreamConnectionFailed",
+		"responseStreamDisconnected",
+		"responseTooManyFailedAttempts"
+	]) {
+		const detail = info[variant];
+		if (isJsonObject(detail) && typeof detail.httpStatusCode === "number") {
+			status = detail.httpStatusCode;
+			break;
+		}
+	}
+	return status === void 0 ? source.message ?? void 0 : Object.assign(new Error(source.message ?? "codex app-server error"), {
+		status,
+		...info === "serverOverloaded" ? { code: "OVERLOADED" } : {}
+	});
+}
+/** Marks a Codex auth profile blocked until the reset time advertised by rate limits. */
+async function markCodexAuthProfileBlockedFromRateLimits(params) {
+	const authProfileId = params.authProfileId?.trim();
+	if (!authProfileId || !params.params.authProfileStore) return;
+	const blockedUntil = resolveCodexUsageLimitResetAtMs(params.rateLimits);
+	if (!blockedUntil) return;
+	try {
+		await markAuthProfileBlockedUntil({
+			store: params.params.authProfileStore,
+			profileId: authProfileId,
+			blockedUntil,
+			source: "codex_rate_limits",
+			agentDir: params.params.agentDir,
+			runId: params.params.runId,
+			modelId: params.params.modelId
+		});
+	} catch (error) {
+		embeddedAgentLog.debug("failed to mark Codex auth profile blocked from app-server limits", {
+			authProfileId,
+			error: formatErrorMessage(error)
+		});
+	}
+}
+/** Formats a turn-start usage-limit error, refreshing rate limits when needed. */
+async function formatCodexTurnStartUsageLimitError(params) {
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: readCodexTurnStartUsageLimitErrorSource(params.client, params.error, params.errorNotification, params.rateLimitsRevisionBeforeTurnStart),
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+/** Refreshes a generic prompt usage-limit message into a reset-aware message. */
+async function refreshCodexUsageLimitPromptError(params) {
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(params.message)) return;
+	return refreshCodexUsageLimitError({
+		client: params.client,
+		source: {
+			message: params.message,
+			codexErrorInfo: "usageLimitExceeded",
+			rateLimits: readRecentCodexRateLimits(params.client)
+		},
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+}
+async function refreshCodexUsageLimitError(params) {
+	const initialMessage = formatCodexUsageLimitErrorMessage(params.source);
+	if (!shouldRefreshCodexRateLimitsForUsageLimitMessage(initialMessage)) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const rateLimits = await readCodexRateLimitsFromAppServerForUsageLimitError({
+		client: params.client,
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	if (!rateLimits) return initialMessage ? {
+		message: initialMessage,
+		...params.source.rateLimitsTrustedForProfile ? { rateLimitsForProfile: params.source.rateLimits } : {}
+	} : void 0;
+	const message = formatCodexUsageLimitErrorMessage({
+		message: params.source.message,
+		codexErrorInfo: params.source.codexErrorInfo,
+		rateLimits,
+		rateLimitsAuthoritative: true
+	}) ?? initialMessage;
+	return message ? {
+		message,
+		rateLimitsForProfile: rateLimits
+	} : void 0;
+}
+async function readCodexRateLimitsFromAppServerForUsageLimitError(params) {
+	if (params.signal?.aborted) return;
+	try {
+		const rateLimits = await params.client.request(CODEX_CONTROL_METHODS.rateLimits, void 0, {
+			timeoutMs: resolveCodexUsageLimitRateLimitRefreshTimeoutMs(params.timeoutMs),
+			signal: params.signal
+		});
+		rememberCodexRateLimitsRead(params.client, rateLimits);
+		return rateLimits;
+	} catch (error) {
+		embeddedAgentLog.debug("codex app-server rate-limit refresh failed after usage-limit error", { error: formatErrorMessage(error) });
+		return;
+	}
+}
+function resolveCodexUsageLimitRateLimitRefreshTimeoutMs(timeoutMs) {
+	if (timeoutMs === void 0 || !Number.isFinite(timeoutMs) || timeoutMs <= 0) return CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS;
+	return Math.max(100, Math.min(timeoutMs, CODEX_USAGE_LIMIT_RATE_LIMIT_REFRESH_TIMEOUT_MS));
+}
+function readCodexTurnStartUsageLimitErrorSource(client, error, errorNotification, rateLimitsRevisionBeforeTurnStart) {
+	const notificationError = readCodexErrorNotification(errorNotification);
+	const errorPayload = readCodexErrorPayload(error);
+	const rateLimits = errorPayload.rateLimits ?? readRecentCodexRateLimits(client);
+	const cacheUpdatedDuringTurnStart = rateLimitsRevisionBeforeTurnStart !== void 0 && readCodexRateLimitsRevision(client) > rateLimitsRevisionBeforeTurnStart;
+	return {
+		message: notificationError?.message ?? errorPayload.message ?? formatErrorMessage(error),
+		codexErrorInfo: notificationError?.codexErrorInfo ?? errorPayload.codexErrorInfo,
+		rateLimits,
+		rateLimitsTrustedForProfile: errorPayload.rateLimits !== void 0 || cacheUpdatedDuringTurnStart
+	};
+}
+function readCodexErrorNotification(notification) {
+	if (notification?.method !== "error" || !isJsonObject(notification.params)) return;
+	const error = notification.params.error;
+	return isJsonObject(error) ? {
+		message: readStringField(error, "message"),
+		codexErrorInfo: error.codexErrorInfo
+	} : void 0;
+}
+function readCodexErrorPayload(error) {
+	const message = error instanceof Error ? error.message : void 0;
+	if (!error || typeof error !== "object" || !("data" in error)) return { message };
+	const data = error.data;
+	if (!isJsonObject(data)) return { message };
+	const nestedError = isJsonObject(data.error) ? data.error : data;
+	const rateLimits = nestedError.rateLimits ?? data.rateLimits;
+	return {
+		message: readStringField(nestedError, "message") ?? message,
+		codexErrorInfo: nestedError.codexErrorInfo,
+		rateLimits
+	};
+}
+//#endregion
+export { resolveCodexPromptError as a, refreshCodexUsageLimitPromptError as i, formatCodexTurnStartUsageLimitError as n, markCodexAuthProfileBlockedFromRateLimits as r, CodexUsageLimitPromptError as t };

package/dist/{web-search-provider.runtime-B7bGbGWq.js → .setup/web-search-provider.runtime-CDKlN-Rv.mjs}

@@ -1,6 +1,6 @@
-import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
-import { S as buildCodexNativeWebSearchThreadConfig } from "./thread-lifecycle-DXl1-I6b.js";
-import { runBoundedCodexAppServerTurn } from "./bounded-turn-C_Hneydj.js";
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+import { f as buildCodexNativeWebSearchThreadConfig } from "./thread-requests-BLvGkP2R.mjs";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-B2HScEgT.mjs";
 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
@@ -13,6 +13,7 @@ async function executeCodexWebSearchProviderTool(ctx, args, executionContext, op
 		modelProvider: "openai",
 		timeoutMs: resolveSearchTimeoutSeconds(ctx.searchConfig) * 1e3,
 		signal: executionContext?.signal,
+		assertCurrent: executionContext?.assertCurrent,
 		agentDir: ctx.agentDir,
 		options,
 		taskLabel: "hosted search",

package/dist/api.js

@@ -1,8 +1,10 @@
-import { a as resolveCodexAppServerStartOptionsForAgent } from "./config-options-CXMq1T-C.js";
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-D22rNEcR.js";
-import { t as CODEX_APP_SERVER_VERSION } from "./version-omm6IPI3.js";
-import "./config-oIORaQ5T.js";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { d as readCodexPluginConfig } from "./.setup/config-parsing-CcB9iPoq.mjs";
+import { a as resolveCodexAppServerStartOptionsForAgent } from "./.setup/config-options-BvaRs51b.mjs";
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, s as CODEX_APP_SERVER_VERSION, t as isManagedCodexDesktopCommand } from "./.setup/managed-binary-BnshlFag.mjs";
+import { t as codexNativeProfileRecoveryHealthCheck } from "./.setup/auth-profile-health-oHizqgye.mjs";
+import { n as findCodexAppServerSpawnError, t as describeCodexSpawnError } from "./.setup/spawn-error-CL3n6MAa.mjs";
+import "./.setup/config-BoTP_mrL.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./.setup/config-runtime-C8Rw1m1m.mjs";
 import { listAgentIds, resolveAgentDir } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { runUtf8CommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
 import path from "node:path";
@@ -67,7 +69,7 @@ function createCodexManagedAppServerHealthCheck(params) {
 			const isFinalization = ctx.mode === "fix" && env.OPENCLAW_UPDATE_POST_CORE === "1";
 			const versionFailureSeverity = isFinalization ? "warning" : "error";
 			const versionFailureHint = isFinalization ? "Codex readiness will be rechecked by its plugin after restart; inspect the Codex plugin if the warning persists." : void 0;
-			let resolved;
+			const candidates = [];
 			for (const agentId of listAgentIds(ctx.cfg)) {
 				const model = resolveDefaultModelForAgent({
 					cfg: ctx.cfg,
@@ -79,13 +81,20 @@ function createCodexManagedAppServerHealthCheck(params) {
 					modelId: model.model,
 					agentId
 				}) !== "codex") continue;
-				const agentStart = resolveAgentStartOptions({
+				candidates.push(resolveAgentStartOptions({
 					startOptions: start,
 					agentDir: resolveAgentDir(ctx.cfg, agentId, env),
 					env
-				});
+				}));
+			}
+			if (ctx.cfg.plugins?.entries?.codex?.enabled === true && readCodexPluginConfig(pluginConfig).sessionCatalog?.enabled !== false) candidates.push({
+				...start,
+				managedCommandOrder: "package-only"
+			});
+			let resolved;
+			for (const candidate of candidates) {
 				try {
-					resolved = await resolveStartOptions(agentStart, { pluginRoot: params.pluginRoot });
+					resolved = await resolveStartOptions(candidate, { pluginRoot: params.pluginRoot });
 				} catch (error) {
 					return [managedCodexFinding({
 						message: `Managed Codex app-server could not be resolved: ${readErrorMessage(error)}`,
@@ -109,16 +118,17 @@ function createCodexManagedAppServerHealthCheck(params) {
 			try {
 				output = await (params.deps?.runVersionCommand ? params.deps.runVersionCommand(nativeCommand) : runVersionCommand(nativeCommand, env));
 			} catch (error) {
+				const spawnFailure = findCodexAppServerSpawnError(describeCodexSpawnError(error, nativeCommand));
 				return [managedCodexFinding({
-					message: `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
-					severity: versionFailureSeverity,
+					message: spawnFailure?.message ?? `Managed Codex app-server version check failed: ${readErrorMessage(error)}`,
+					severity: spawnFailure && resolved.managedCommandOrder === "package-only" ? "warning" : versionFailureSeverity,
 					path: nativeCommand,
 					requirement: `Codex ${CODEX_APP_SERVER_VERSION} must report its version within ${CODEX_VERSION_TIMEOUT_MS} ms`,
 					fixHint: versionFailureHint ?? "Repair or reinstall the staged OpenClaw package, then rerun the candidate check before cutover."
 				})];
 			}
 			const detectedVersion = parseCodexVersion(`${output.stdout}\n${output.stderr}`);
-			if (detectedVersion !== "0.153.4") return [managedCodexFinding({
+			if (detectedVersion !== "0.155.1") return [managedCodexFinding({
 				severity: versionFailureSeverity,
 				message: detectedVersion ? `Managed Codex app-server version mismatch: expected ${CODEX_APP_SERVER_VERSION}, detected ${detectedVersion}.` : `Managed Codex app-server did not report a parseable version; expected ${CODEX_APP_SERVER_VERSION}.`,
 				path: nativeCommand,
@@ -144,6 +154,7 @@ function registerCodexManagedAppServerDoctorChecks(host) {
 		...host,
 		pluginRoot: CODEX_PLUGIN_ROOT
 	});
+	if (!host.getHealthCheck(codexNativeProfileRecoveryHealthCheck.id)) host.registerHealthCheck(codexNativeProfileRecoveryHealthCheck);
 }
 //#endregion
 export { CODEX_MANAGED_APP_SERVER_CHECK_ID, registerCodexManagedAppServerDoctorChecks };

package/dist/catalog-page-worker-entrypoint.js

@@ -0,0 +1,12 @@
+//#region extensions/codex/catalog-page-worker-entrypoint.ts
+const codexCatalogPageWorkerEntrypoint = {
+	currentModuleUrl: import.meta.url,
+	sourceWorkerName: "catalog-page.worker",
+	distWorkerPath: "extensions/codex/catalog-page.worker.js",
+	package: {
+		name: "@openclaw/codex",
+		distWorkerPath: "catalog-page.worker.js"
+	}
+};
+//#endregion
+export { codexCatalogPageWorkerEntrypoint };

package/dist/catalog-page.worker.js

@@ -0,0 +1,9 @@
+import { t as createCodexCatalogDecoder } from "./.setup/client-catalog-response-BMgt_4q4.mjs";
+import { serveWorkerTasks } from "openclaw/plugin-sdk/worker-task-server";
+//#region extensions/codex/catalog-page.worker.ts
+const decode = createCodexCatalogDecoder();
+serveWorkerTasks((input) => {
+	return decode(input);
+});
+//#endregion
+export {};

package/dist/cli-metadata.js

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/codex/cli-metadata.ts
 function registerCodexCliMetadata(api) {
 	api.registerCli(async ({ program }) => {
-		const { registerCodexSessionCli } = await import("./session-cli-DNN_jhGc.js");
+		const { registerCodexSessionCli } = await import("./.setup/session-cli-irrD-uo7.mjs");
 		registerCodexSessionCli(program);
 	}, { descriptors: [{
 		name: "codex",