@openclaw/codex 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/plugin-approval-roundtrip-CuahdPLC.mjs

@@ -0,0 +1,109 @@
+import { pt as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-qhyYWbew.mjs";
+import { isApprovalNotFoundError, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { racePromiseWithAbortSignal } from "openclaw/plugin-sdk/time-runtime";
+//#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
+const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
+const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
+const MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH = 512;
+const ANSI_OSC_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b]|\u009d)[^\u001b\u009c\u0007]*(?:\u0007|\u001b\\|\u009c)`, "g");
+const ANSI_CONTROL_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b\[[0-?]*[ -/]*[@-~]|\u009b[0-?]*[ -/]*[@-~]|\u001b[@-Z\\-_])`, "g");
+const CONTROL_CHARACTER_RE = new RegExp(String.raw`[\u0000-\u001f\u007f-\u009f]+`, "g");
+const INVISIBLE_FORMATTING_CONTROL_RE = new RegExp(String.raw`[\u00ad\u034f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff\ufe00-\ufe0f\u{e0100}-\u{e01ef}]`, "gu");
+const DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE = new RegExp(String.raw`(?:\u001b\][^\u001b\u009c\u0007]*|\u009d[^\u001b\u009c\u0007]*|\u001b\[[0-?]*[ -/]*|\u009b[0-?]*[ -/]*|\u001b)$`);
+const CODEX_APPROVAL_TIMEOUT_SUBJECTS = {
+	command: "Command approval",
+	"file-change": "File change approval",
+	permissions: "Permission approval",
+	other: "Approval"
+};
+function codexApprovalTimeoutText(kind) {
+	return `${CODEX_APPROVAL_TIMEOUT_SUBJECTS[kind]} timed out before an operator responded.`;
+}
+/** Starts a two-phase plugin approval request through the OpenClaw gateway. */
+async function requestPluginApproval(params) {
+	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
+	return params.hostCapabilities.requestApproval({
+		signal: params.signal,
+		title: truncateCodexApprovalDisplayText(params.title, MAX_PLUGIN_APPROVAL_TITLE_LENGTH),
+		description: truncateCodexApprovalDisplayText(params.description, MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH),
+		severity: params.severity,
+		toolName: params.toolName,
+		toolCallId: params.toolCallId,
+		...params.mcpTool ? {
+			mcpTool: params.mcpTool,
+			isMcpToolApprovalActive: params.isMcpToolApprovalActive
+		} : {},
+		timeoutMs,
+		transportTimeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs),
+		...params.allowedDecisions ? { allowedDecisions: params.allowedDecisions } : {}
+	});
+}
+/** Detects the gateway's explicit null-decision marker for unavailable approvals. */
+function approvalRequestExplicitlyUnavailable(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return false;
+	let descriptor;
+	try {
+		descriptor = Object.getOwnPropertyDescriptor(result, "decision");
+	} catch {
+		return false;
+	}
+	return descriptor !== void 0 && "value" in descriptor && descriptor.value === null;
+}
+/** Waits for the gateway's final approval decision, respecting turn aborts. */
+async function waitForPluginApprovalDecision(params) {
+	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
+	const waitPromise = params.hostCapabilities.waitForApproval({
+		approvalId: params.approvalId,
+		timeoutMs,
+		transportTimeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs),
+		signal: params.signal
+	}).catch((error) => {
+		if (isApprovalNotFoundError(error)) return;
+		throw error;
+	});
+	return await racePromiseWithAbortSignal(waitPromise, params.signal, ({ reason }) => toErrorObject(reason, "Non-Error rejection"));
+}
+/** Converts a gateway exec approval decision into the app-server approval outcome enum. */
+function mapExecDecisionToOutcome(decision) {
+	switch (decision) {
+		case "allow-once": return "approved-once";
+		case "allow-always": return "approved-session";
+		case "deny": return "denied";
+		default: return "unavailable";
+	}
+}
+/** Runs one complete host approval request and maps transport failures to a closed outcome. */
+async function requestPluginApprovalOutcome(params) {
+	try {
+		const requestResult = await requestPluginApproval({
+			...params,
+			severity: "warning"
+		});
+		const approvalId = requestResult?.id;
+		if (!approvalId) return "unavailable";
+		const approvalResult = approvalRequestExplicitlyUnavailable(requestResult) ? void 0 : await waitForPluginApprovalDecision({
+			hostCapabilities: params.hostCapabilities,
+			approvalId,
+			signal: params.signal
+		});
+		if (params.signal?.aborted) return "cancelled";
+		if (approvalResult?.terminalReason === "timeout") return "timed-out";
+		const decision = approvalResult?.decision;
+		return mapExecDecisionToOutcome(decision === "allow-always" && params.allowedDecisions?.includes("allow-always") === false ? "allow-once" : decision);
+	} catch {
+		return params.signal?.aborted ? "cancelled" : "denied";
+	}
+}
+function truncateCodexApprovalDisplayText(value, maxLength) {
+	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
+}
+function stripDanglingCodexApprovalTerminalSequence(value) {
+	return value.replace(DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE, "");
+}
+function sanitizeCodexApprovalVisibleText(value, options = {}) {
+	const terminalSafe = value.replace(ANSI_OSC_SEQUENCE_RE, "").replace(ANSI_CONTROL_SEQUENCE_RE, "");
+	return (options.stripDanglingTerminalSequence ? stripDanglingCodexApprovalTerminalSequence(terminalSafe) : terminalSafe).replace(INVISIBLE_FORMATTING_CONTROL_RE, " ").replace(CONTROL_CHARACTER_RE, " ").replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { requestPluginApprovalOutcome as a, truncateCodexApprovalDisplayText as c, requestPluginApproval as i, waitForPluginApprovalDecision as l, codexApprovalTimeoutText as n, sanitizeCodexApprovalVisibleText as o, mapExecDecisionToOutcome as r, stripDanglingCodexApprovalTerminalSequence as s, approvalRequestExplicitlyUnavailable as t };

package/dist/.setup/{plugin-inventory-Cky2XJUw.mjs → plugin-inventory-Bf0_piTw.mjs}

@@ -1,6 +1,6 @@
-import { f as resolveCodexPluginsPolicy } from "./config-parsing-b088LyhT.mjs";
-import { c as findCodexAppById } from "./plugin-app-cache-key-BL9B5H0L.mjs";
-import "./config-DKhXquav.mjs";
+import { f as resolveCodexPluginsPolicy } from "./config-parsing-BQq-CHTF.mjs";
+import { c as findCodexAppById } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import "./config-0Gxk3_eq.mjs";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/config-contracts.ts
 const CODEX_PLUGINS_MARKETPLACE_NAME = "openai-curated";
@@ -40,14 +40,13 @@ async function readCodexPluginInventory(params) {
 		let listed = installedPlugins;
 		let resolvedPlugin = findConfiguredMarketplacePlugin(listed, pluginPolicy);
 		if (!resolvedPlugin && pluginPolicy.enabled && pluginPolicy.marketplaceName !== "workspace-directory") {
-			const requestParams = buildPluginCatalogRequestParams(params, pluginPolicy.marketplaceName);
-			const catalogKey = JSON.stringify([requestParams, pluginMetadataCatalogScope(pluginPolicy.marketplaceName)]);
+			const catalogKey = pluginMetadataCatalogScope(pluginPolicy.marketplaceName);
 			let catalog = pluginCatalogs.get(catalogKey);
 			if (!catalog) {
-				catalog = listCodexPluginMetadata(params, pluginPolicy.marketplaceName);
+				catalog = await listCodexPluginMetadata(params, pluginPolicy.marketplaceName);
 				pluginCatalogs.set(catalogKey, catalog);
 			}
-			listed = await catalog;
+			listed = catalog;
 			resolvedPlugin = findConfiguredMarketplacePlugin(listed, pluginPolicy);
 		}
 		if (!listed.marketplaces.some((marketplace) => marketplaceMatchesConfiguredName(marketplace, pluginPolicy.marketplaceName))) {
@@ -77,12 +76,8 @@ async function readCodexPluginInventory(params) {
 			if (!summary.installed) continue;
 		}
 		const detail = await readPluginDetail(params, marketplaceRef(resolvedPlugin.marketplace, pluginPolicy.marketplaceName), pluginPolicy, summary, diagnostics);
-		const ownedAppIds = detail?.apps.map((app) => app.id).filter(Boolean).toSorted() ?? [];
-		const appOwnership = resolveAppOwnership({
-			detail,
-			appInventory,
-			summary
-		});
+		const ownedAppIds = detail?.apps.map((app) => app.id).filter(Boolean) ?? [];
+		const appOwnership = detail?.apps.length ? "proven" : appInventory?.snapshot?.apps.some((app) => app.pluginDisplayNames.includes(summary.name)) ? "ambiguous" : "none";
 		if (appOwnership === "ambiguous") diagnostics.push({
 			code: "app_ownership_ambiguous",
 			plugin: pluginPolicy,
@@ -145,10 +140,8 @@ function pluginReadParams(marketplace, pluginName) {
 }
 function resolveRecoverableCodexPluginConfigKeys(params) {
 	return params.policy.pluginPolicies.filter((pluginPolicy) => pluginPolicy.enabled && !isSettledMissingPluginPolicy({
-		pluginPolicy,
-		metadataCache: params.metadataCache,
-		appCacheKey: params.appCacheKey,
-		configCwd: params.configCwd
+		...params,
+		pluginPolicy
 	})).map((pluginPolicy) => pluginPolicy.configKey).toSorted();
 }
 async function listCodexPluginMetadata(params, marketplaceName, options = {}) {
@@ -208,7 +201,6 @@ function readCachedAppInventory(params) {
 	});
 }
 async function readPluginDetail(params, marketplace, pluginPolicy, summary, diagnostics) {
-	if (params.readPluginDetails === false) return;
 	if (marketplace.remoteMarketplaceName && !summary.remotePluginId) {
 		diagnostics.push({
 			code: "plugin_detail_unavailable",
@@ -228,10 +220,6 @@ async function readPluginDetail(params, marketplace, pluginPolicy, summary, diag
 		return;
 	}
 }
-function resolveAppOwnership(params) {
-	if (params.detail && params.detail.apps.length > 0) return "proven";
-	return (params.appInventory?.snapshot?.apps ?? []).some((app) => app.pluginDisplayNames.includes(params.summary.name)) ? "ambiguous" : "none";
-}
 function resolveOwnedApps(params) {
 	const detailApps = params.detail?.apps ?? [];
 	if (detailApps.length === 0) return [];
@@ -271,20 +259,15 @@ function toCodexPluginOwnedAccountApp(app, installedApp) {
 function resolveOwnedAppApprovalOverrideKeys(app) {
 	if (!app.toolSummaries) return {};
 	const appName = app.name.trim();
-	const appNameLower = appName.toLowerCase();
-	const keys = app.toolSummaries.filter((tool) => !tool.isReadOnly).flatMap((tool) => resolveAppToolConfigKeys({
-		appName,
-		appNameLower,
-		tool
-	}));
-	return { approvalOverrideToolConfigKeys: Array.from(new Set(keys)).toSorted() };
-}
-function resolveAppToolConfigKeys(params) {
-	const keys = [params.tool.name];
-	if (params.tool.title) keys.push(params.tool.title);
-	if (params.appName) keys.push(`${params.appName}_${params.tool.name}`);
-	if (params.appNameLower && params.appNameLower !== params.appName) keys.push(`${params.appNameLower}_${params.tool.name}`);
-	return keys;
+	const prefixes = [.../* @__PURE__ */ new Set([appName, appName.toLowerCase()])].filter(Boolean);
+	const keys = /* @__PURE__ */ new Set();
+	for (const tool of app.toolSummaries) {
+		if (tool.isReadOnly) continue;
+		keys.add(tool.name);
+		if (tool.title) keys.add(tool.title);
+		for (const prefix of prefixes) keys.add(`${prefix}_${tool.name}`);
+	}
+	return { approvalOverrideToolConfigKeys: Array.from(keys).toSorted() };
 }
 function findPluginSummary(marketplace, pluginName) {
 	const exact = marketplace.plugins.find((plugin) => plugin.id === pluginName || plugin.id === `${pluginName}@${marketplace.name}`);
@@ -293,7 +276,14 @@ function findPluginSummary(marketplace, pluginName) {
 	return matches.length === 1 ? matches[0] : void 0;
 }
 function findConfiguredMarketplacePlugin(listed, plugin) {
-	if (plugin.marketplaceName === "workspace-directory") return findWorkspaceMarketplacePlugin(listed, plugin.pluginName);
+	if (plugin.marketplaceName === "workspace-directory") {
+		const marketplace = listed.marketplaces.find((entry) => entry.name === CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME);
+		const summary = marketplace?.plugins.find((entry) => entry.id === plugin.pluginName);
+		return marketplace && summary ? {
+			marketplace,
+			summary
+		} : void 0;
+	}
 	for (const marketplace of listed.marketplaces) {
 		if (!marketplaceMatchesConfiguredName(marketplace, plugin.marketplaceName)) continue;
 		const summary = findPluginSummary(marketplace, plugin.pluginName);
@@ -304,15 +294,7 @@ function findConfiguredMarketplacePlugin(listed, plugin) {
 	}
 }
 function marketplaceMatchesConfiguredName(marketplace, configuredMarketplaceName) {
-	return isOpenAiCuratedMarketplaceName(configuredMarketplaceName) ? isOpenAiCuratedMarketplace(marketplace) : marketplace.name === configuredMarketplaceName;
-}
-function findWorkspaceMarketplacePlugin(listed, pluginName) {
-	const marketplace = listed.marketplaces.find((entry) => entry.name === CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME);
-	const summary = marketplace?.plugins.find((plugin) => plugin.id === pluginName);
-	return marketplace && summary ? {
-		marketplace,
-		summary
-	} : void 0;
+	return isOpenAiCuratedMarketplaceName(configuredMarketplaceName) ? isOpenAiCuratedMarketplaceName(marketplace.name) : marketplace.name === configuredMarketplaceName;
 }
 function pluginNameFromPluginId(pluginId, marketplaceName) {
 	const trimmed = pluginId.trim();
@@ -327,12 +309,8 @@ function marketplaceRef(marketplace, name) {
 		...!marketplace.path ? { remoteMarketplaceName: marketplace.name } : {}
 	};
 }
-/** True for any supported OpenAI curated marketplace wire name, matching Codex's own curated predicate. */
-function isOpenAiCuratedMarketplace(marketplace) {
-	return isOpenAiCuratedMarketplaceName(marketplace.name);
-}
 function isOpenAiCuratedMarketplaceName(marketplaceName) {
 	return marketplaceName === "openai-curated" || marketplaceName === CODEX_PLUGINS_REMOTE_MARKETPLACE_NAME || marketplaceName === CODEX_PLUGINS_API_MARKETPLACE_NAME;
 }
 //#endregion
-export { marketplaceRef as a, resolveRecoverableCodexPluginConfigKeys as c, CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME as d, listCodexPluginMetadata as i, toCodexPluginOwnedAccountApp as l, isOpenAiCuratedMarketplace as n, pluginReadParams as o, isOpenAiCuratedMarketplaceName as r, readCodexPluginInventory as s, findCodexMarketplacePluginSummary as t, CODEX_PLUGINS_MARKETPLACE_NAME as u };
+export { pluginReadParams as a, toCodexPluginOwnedAccountApp as c, marketplaceRef as i, CODEX_PLUGINS_MARKETPLACE_NAME as l, isOpenAiCuratedMarketplaceName as n, readCodexPluginInventory as o, listCodexPluginMetadata as r, resolveRecoverableCodexPluginConfigKeys as s, findCodexMarketplacePluginSummary as t, CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME as u };

package/dist/.setup/{plugin-marketplace-discovery-D_dV9FXa.mjs → plugin-marketplace-discovery-SQPhSuic.mjs}

@@ -1,19 +1,5 @@
-import { d as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-utils-D0CXecki.mjs";
+import { n as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./service-tier-normalization-Cei89SW6.mjs";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/codex/src/command-authorization.ts
-const CODEX_NATIVE_EXECUTION_AUTH_ERROR = "Only an owner or operator.admin can control Codex native execution.";
-const CODEX_HOST_INSPECTION_AUTH_ERROR = "Only an owner or operator.admin can inspect Codex host state.";
-const CODEX_FULL_PERMISSIONS_AUTH_ERROR = "Full Codex permissions require operator.admin. Choose Admin in the Control UI permission picker, or use an admin-authenticated CLI.";
-function hasCodexAdminScope(ctx) {
-	return ctx.gatewayClientScopes?.includes("operator.admin") === true;
-}
-function canMutateCodexHost(ctx) {
-	return ctx.senderIsOwner === true || hasCodexAdminScope(ctx);
-}
-function assertCodexHostOwnerCurrent(ctx) {
-	if (!hasCodexAdminScope(ctx)) ctx.assertOwnerCurrent?.();
-}
-//#endregion
 //#region extensions/codex/src/plugin-marketplace-discovery.ts
 /** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
 const PLUGIN_NAME_PATTERN = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
@@ -131,4 +117,4 @@ function boundedCatalogText(value) {
 	return value.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_METADATA_LENGTH);
 }
 //#endregion
-export { CODEX_HOST_INSPECTION_AUTH_ERROR as a, canMutateCodexHost as c, CODEX_FULL_PERMISSIONS_AUTH_ERROR as i, hasCodexAdminScope as l, filterCodexMarketplacePlugins as n, CODEX_NATIVE_EXECUTION_AUTH_ERROR as o, parseCodexPluginMarketplaceId as r, assertCodexHostOwnerCurrent as s, discoverCodexMarketplacePlugins as t };
+export { filterCodexMarketplacePlugins as n, parseCodexPluginMarketplaceId as r, discoverCodexMarketplacePlugins as t };

package/dist/.setup/plugin-metadata-cache-DWnB7VMj.mjs

@@ -0,0 +1,84 @@
+//#region extensions/codex/src/app-server/plugin-metadata-cache.ts
+const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 36e5;
+var CodexPluginMetadataCache = class {
+	constructor(nowMs = Date.now) {
+		this.nowMs = nowMs;
+		this.entries = /* @__PURE__ */ new Map();
+		this.inFlight = /* @__PURE__ */ new Map();
+		this.generations = /* @__PURE__ */ new Map();
+		this.clearGeneration = 0;
+	}
+	read(appCacheKey, queryKind, requestParams, catalogScope) {
+		const entryKey = buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catalogScope);
+		const entry = this.entries.get(entryKey);
+		if (!entry) return;
+		if (entry.expiresAtMs <= this.nowMs()) {
+			this.entries.delete(entryKey);
+			return;
+		}
+		return entry.snapshot;
+	}
+	/** Returns a fresh snapshot or coalesces one catalog or installed-plugin request. */
+	async load(params) {
+		const entryKey = buildMetadataCacheEntryKey(params.appCacheKey, params.queryKind, params.requestParams, params.catalogScope);
+		const cached = this.read(params.appCacheKey, params.queryKind, params.requestParams, params.catalogScope);
+		if (cached) return cached;
+		const pending = this.inFlight.get(entryKey);
+		if (pending) try {
+			return await pending.promise;
+		} catch {
+			if (this.inFlight.get(entryKey) === pending) this.inFlight.delete(entryKey);
+			return await this.load(params);
+		}
+		const generation = this.generations.get(params.appCacheKey) ?? 0;
+		const clearGeneration = this.clearGeneration;
+		const promise = (async () => {
+			const method = params.queryKind === "installed" ? "plugin/installed" : "plugin/list";
+			const response = await params.request(method, params.requestParams);
+			const snapshot = {
+				appCacheKey: params.appCacheKey,
+				queryKind: params.queryKind,
+				response
+			};
+			if (generation === (this.generations.get(params.appCacheKey) ?? 0) && clearGeneration === this.clearGeneration && response.marketplaceLoadErrors.length === 0 && (params.cacheable?.(response) ?? true)) this.entries.set(entryKey, {
+				snapshot,
+				expiresAtMs: this.nowMs() + CODEX_PLUGIN_METADATA_CACHE_TTL_MS
+			});
+			return snapshot;
+		})();
+		this.inFlight.set(entryKey, {
+			appCacheKey: params.appCacheKey,
+			promise
+		});
+		try {
+			return await promise;
+		} finally {
+			if (this.inFlight.get(entryKey)?.promise === promise) this.inFlight.delete(entryKey);
+		}
+	}
+	invalidate(appCacheKey) {
+		this.generations.set(appCacheKey, (this.generations.get(appCacheKey) ?? 0) + 1);
+		for (const [entryKey, entry] of this.entries) if (entry.snapshot.appCacheKey === appCacheKey) this.entries.delete(entryKey);
+		for (const [entryKey, pending] of this.inFlight) if (pending.appCacheKey === appCacheKey) this.inFlight.delete(entryKey);
+	}
+	/** Clears snapshots and prevents late in-flight loads from repopulating them. */
+	clear() {
+		this.clearGeneration += 1;
+		this.generations.clear();
+		this.entries.clear();
+		this.inFlight.clear();
+	}
+};
+const defaultCodexPluginMetadataCache = new CodexPluginMetadataCache();
+function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catalogScope) {
+	const names = queryKind === "installed" ? requestParams?.installSuggestionPluginNames : requestParams?.marketplaceKinds;
+	return JSON.stringify([
+		appCacheKey,
+		queryKind,
+		requestParams?.cwds ?? [],
+		Array.from(new Set(names ?? [])).toSorted(),
+		...queryKind !== "installed" && catalogScope ? [catalogScope] : []
+	]);
+}
+//#endregion
+export { defaultCodexPluginMetadataCache as t };

package/dist/.setup/plugin-thread-config-deadline-B8LGaZNW.mjs

@@ -0,0 +1,124 @@
+import { f as resolveCodexPluginsPolicy } from "./config-parsing-BQq-CHTF.mjs";
+import { r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
+import { a as defaultCodexAppInventoryCache } from "./plugin-app-cache-key-BW8rd98k.mjs";
+import { s as resolveRecoverableCodexPluginConfigKeys } from "./plugin-inventory-Bf0_piTw.mjs";
+import "./config-0Gxk3_eq.mjs";
+import { Tt as shouldBuildCodexPluginThreadConfig, gt as buildCodexPluginThreadConfig, vt as buildCodexPluginThreadConfigTimeoutFallback } from "./thread-requests-CL1e8Wmx.mjs";
+import { m as readCurrentCodexScheduledAppPolicy, p as intersectCodexPluginThreadConfigWithScheduledAuthority } from "./thread-lifecycle-Cbz_7ySv.mjs";
+import { n as disableCodexPluginThreadConfig } from "./dynamic-tool-build-C8xGEXmR.mjs";
+import { t as defaultCodexPluginMetadataCache } from "./plugin-metadata-cache-DWnB7VMj.mjs";
+import { AgentHarnessPreflightError } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/plugin-thread-config-deadline.ts
+/** Enforces one bounded startup budget across Codex plugin config discovery. */
+const CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS = 6e4;
+const CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR = 4;
+const CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS = 100;
+var CodexPluginThreadConfigDeadlineError = class extends Error {
+	constructor() {
+		super("Codex plugin thread config deadline elapsed");
+		this.name = "CodexPluginThreadConfigDeadlineError";
+	}
+};
+/** Resolves the plugin policy state reused throughout app-server startup. */
+function resolveCodexPluginThreadConfigStartupPolicy(params) {
+	const pluginThreadConfigRequired = params.hostedAppsSupported === false || Boolean(params.scheduledRuntimeAuthority) || !params.nativeToolSurfaceEnabled || shouldBuildCodexPluginThreadConfig(params.pluginConfig);
+	const pluginThreadConfigPluginConfig = params.hostedAppsSupported !== false && (params.nativeToolSurfaceEnabled || params.scheduledRuntimeAuthority) ? params.pluginConfig : disableCodexPluginThreadConfig(params.pluginConfig);
+	const resolvedPluginPolicy = pluginThreadConfigRequired ? resolveCodexPluginsPolicy(pluginThreadConfigPluginConfig) : void 0;
+	return {
+		pluginThreadConfigRequired,
+		pluginThreadConfigPluginConfig,
+		resolvedPluginPolicy,
+		enabledPluginConfigKeys: resolvedPluginPolicy ? resolvedPluginPolicy.pluginPolicies.filter((plugin) => plugin.enabled).map((plugin) => plugin.configKey).toSorted() : void 0
+	};
+}
+/** Builds plugin config without allowing sequential RPC timeouts to consume the turn. */
+async function buildCodexPluginThreadConfigWithinDeadline(params) {
+	const { requestTimeoutMs, signal, request, failClosedOnTimeout, transform, ...buildParams } = params;
+	signal.throwIfAborted();
+	const timeoutMs = resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs);
+	const deadlineMs = performance.now() + timeoutMs;
+	let requestTimedOut = false;
+	const boundedRequest = async (method, requestParams) => {
+		const remainingTimeoutMs = deadlineMs - performance.now();
+		if (requestTimedOut || remainingTimeoutMs <= 0) throw new CodexPluginThreadConfigDeadlineError();
+		try {
+			return await request(method, requestParams, {
+				timeoutMs: remainingTimeoutMs,
+				signal
+			});
+		} catch (error) {
+			requestTimedOut ||= isCodexPluginThreadConfigTimeoutError(error);
+			throw error;
+		}
+	};
+	try {
+		return await withAbortableTimeout({
+			signal,
+			timeoutMs,
+			promise: (async () => {
+				const config = await buildCodexPluginThreadConfig({
+					...buildParams,
+					request: boundedRequest
+				});
+				const result = transform ? await transform(config, boundedRequest) : config;
+				if (requestTimedOut || performance.now() >= deadlineMs) throw new CodexPluginThreadConfigDeadlineError();
+				return result;
+			})(),
+			timeoutMessage: "Codex plugin thread config deadline elapsed",
+			createTimeoutError: () => new CodexPluginThreadConfigDeadlineError()
+		});
+	} catch (error) {
+		if (signal.aborted || !requestTimedOut && !isCodexPluginThreadConfigTimeoutError(error) && performance.now() < deadlineMs) throw error;
+		if (failClosedOnTimeout) throw new AgentHarnessPreflightError(`Codex app policy verification exceeded its ${timeoutMs} ms startup budget. No app tools were executed. Retry after Codex app inventory is responsive.`);
+		return buildCodexPluginThreadConfigTimeoutFallback({
+			pluginConfig: buildParams.pluginConfig,
+			appCacheKey: buildParams.appCacheKey,
+			message: `Codex plugin discovery exceeded its ${timeoutMs} ms startup budget; plugin apps were disabled for this turn.`
+		});
+	}
+}
+/** Creates the recovery metadata and bounded builder used by thread startup. */
+function createCodexPluginThreadConfigStartupProvider(params) {
+	const { client, policy, inputFingerprint, enabledPluginConfigKeys, appCache, metadataCache: configuredMetadataCache, ...buildParams } = params;
+	const metadataCache = configuredMetadataCache ?? defaultCodexPluginMetadataCache;
+	return {
+		enabled: true,
+		requiresCurrentPolicyCheck: Boolean(policy?.enabled || params.scheduledRuntimeAuthority),
+		inputFingerprint,
+		enabledPluginConfigKeys,
+		accountAppRecoveryEnabled: policy?.allowAllPlugins,
+		recoverablePluginConfigKeys: policy ? resolveRecoverableCodexPluginConfigKeys({
+			policy,
+			metadataCache,
+			appCacheKey: params.appCacheKey,
+			configCwd: params.configCwd
+		}) : void 0,
+		build: async (buildOptions) => {
+			const config = await buildCodexPluginThreadConfigWithinDeadline({
+				...buildParams,
+				threadId: buildOptions?.threadId,
+				appCache: appCache ?? defaultCodexAppInventoryCache,
+				metadataCache,
+				failClosedOnTimeout: Boolean(params.scheduledRuntimeAuthority),
+				transform: params.scheduledRuntimeAuthority ? async (builtConfig, request) => intersectCodexPluginThreadConfigWithScheduledAuthority(builtConfig, params.scheduledRuntimeAuthority, await readCurrentCodexScheduledAppPolicy({
+					request,
+					configCwd: params.configCwd,
+					threadId: buildOptions?.threadId
+				})) : void 0,
+				request: (method, requestParams, options) => client.request(method, requestParams, options)
+			});
+			return params.scheduledRuntimeAuthority && params.inputFingerprint ? {
+				...config,
+				inputFingerprint: params.inputFingerprint
+			} : config;
+		}
+	};
+}
+function resolveCodexPluginThreadConfigTimeoutMs(requestTimeoutMs) {
+	return Math.min(CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS, Math.max(CODEX_PLUGIN_THREAD_CONFIG_MIN_TIMEOUT_MS, Math.floor((Number.isFinite(requestTimeoutMs) && requestTimeoutMs > 0 ? requestTimeoutMs : CODEX_PLUGIN_THREAD_CONFIG_MAX_TIMEOUT_MS * CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR) / CODEX_PLUGIN_THREAD_CONFIG_TIMEOUT_DIVISOR)));
+}
+function isCodexPluginThreadConfigTimeoutError(error) {
+	return error instanceof CodexPluginThreadConfigDeadlineError || error instanceof Error && "code" in error && error.code === "CODEX_APP_SERVER_LOCAL_REQUEST_CANCELLED" && error.message.endsWith(" timed out");
+}
+//#endregion
+export { resolveCodexPluginThreadConfigStartupPolicy as n, createCodexPluginThreadConfigStartupProvider as t };

package/dist/.setup/{provider-D6F_7p1I.mjs → provider-BnwHVD_z.mjs}

@@ -11,7 +11,7 @@ function buildCodexMigrationProvider(params = {}) {
 		].join(" "),
 		supportedItemKinds: ["memory", "auth"],
 		async detect(ctx) {
-			const { discoverCodexSource, hasCodexSource } = await import("./source-CJis_1EF.mjs").then((n) => n.a);
+			const { discoverCodexSource, hasCodexSource } = await import("./source-BYu0T780.mjs").then((n) => n.a);
 			const memoryOnly = isOnlyMigrationKind(ctx, "memory");
 			const authOnly = isOnlyMigrationKind(ctx, "auth");
 			const source = await discoverCodexSource({
@@ -29,16 +29,16 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		async plan(ctx) {
-			const { buildCodexMigrationPlan } = await import("./plan-DPdMk1Oy.mjs");
+			const { buildCodexMigrationPlan } = await import("./plan-BJ37d2Og.mjs");
 			return buildCodexMigrationPlan(ctx);
 		},
 		deferredApply: { retrySafe: true },
 		prepareApply(ctx) {
 			if (isOnlyMigrationKind(ctx, "memory") || isOnlyMigrationKind(ctx, "auth")) return;
-			return import("./apply-Cqb-YoCS.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+			return import("./apply-CXTudl9p.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
 		},
 		async apply(ctx, plan) {
-			const { applyCodexMigrationPlan } = await import("./apply-Cqb-YoCS.mjs");
+			const { applyCodexMigrationPlan } = await import("./apply-CXTudl9p.mjs");
 			return await applyCodexMigrationPlan({
 				ctx,
 				plan,

package/dist/.setup/provider-capabilities-D68Whix6.mjs

@@ -0,0 +1,50 @@
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-qhyYWbew.mjs";
+//#region extensions/codex/src/app-server/provider-capabilities.ts
+function resolveOverriddenProviderWebSearchSupport(modelProviderOverride) {
+	const provider = modelProviderOverride?.trim().toLowerCase();
+	if (!provider) return;
+	return provider === "openai" ? "supported" : "unsupported";
+}
+async function resolveCodexProviderWebSearchSupportForClient(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	try {
+		const options = {
+			timeoutMs: params.timeoutMs,
+			signal: params.signal
+		};
+		if (params.expectedNativeModelProvider) {
+			if (((await params.client.request("config/read", { includeLayers: false }, options)).config.model_provider ?? "openai") !== params.expectedNativeModelProvider) return "unknown";
+		}
+		return (await params.client.request("modelProvider/capabilities/read", {}, options)).webSearch ? "supported" : "unsupported";
+	} catch {
+		return "unknown";
+	}
+}
+async function resolveCodexProviderWebSearchSupport(params) {
+	const overrideSupport = resolveOverriddenProviderWebSearchSupport(params.modelProviderOverride);
+	if (overrideSupport) return overrideSupport;
+	let client;
+	try {
+		client = await params.clientFactory({
+			startOptions: params.appServer.start,
+			...params.preparedAuth ? { preparedAuth: params.preparedAuth } : { authProfileId: params.authProfileId },
+			agentDir: params.agentDir,
+			config: params.config,
+			timeoutMs: params.appServer.requestTimeoutMs
+		});
+		return await resolveCodexProviderWebSearchSupportForClient({
+			client,
+			timeoutMs: params.appServer.requestTimeoutMs,
+			modelProviderOverride: params.modelProviderOverride,
+			expectedNativeModelProvider: params.expectedNativeModelProvider,
+			signal: params.signal
+		});
+	} catch {
+		return "unknown";
+	} finally {
+		if (client) releaseLeasedSharedCodexAppServerClient(client);
+	}
+}
+//#endregion
+export { resolveCodexProviderWebSearchSupportForClient as n, resolveCodexProviderWebSearchSupport as t };

package/dist/.setup/{rate-limits-B7-X2TgG.mjs → rate-limits-CMPy24F5.mjs}

@@ -222,7 +222,6 @@ function buildCodexAppServerUsageSnapshot(value, options = {}) {
 }
 function selectNextRateLimitReset(value, nowMs) {
 	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => snapshot[key] ?? [])).filter((window) => window.resetsAtMs > nowMs);
-	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
 }
@@ -334,10 +333,7 @@ function selectBlockingWindowEntry(entries, nowMs) {
 	const futureEntries = entries.filter((entry) => entry.window.resetsAtMs > nowMs);
 	const exhaustedFutureEntries = futureEntries.filter((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100);
 	const resetCandidates = exhaustedFutureEntries.length > 0 ? exhaustedFutureEntries : futureEntries;
-	if (resetCandidates.length > 0) {
-		const resetSort = exhaustedFutureEntries.length > 0 ? (left, right) => right.window.resetsAtMs - left.window.resetsAtMs : (left, right) => left.window.resetsAtMs - right.window.resetsAtMs;
-		return resetCandidates.toSorted(resetSort)[0];
-	}
+	if (resetCandidates.length > 0) return resetCandidates.toSorted((left, right) => exhaustedFutureEntries.length > 0 ? right.window.resetsAtMs - left.window.resetsAtMs : left.window.resetsAtMs - right.window.resetsAtMs)[0];
 	return entries.filter((entry) => entry.window.usedPercent !== void 0 && entry.window.usedPercent >= 100).toSorted((left, right) => (right.window.windowDurationMins ?? 0) - (left.window.windowDurationMins ?? 0))[0];
 }
 function readWindowEntries(snapshot) {