@openclaw/codex 2026.5.10-beta.2 → 2026.5.10-beta.4

package/dist/{command-handlers-BLZCm3fD.js → command-handlers-iLF1EI-b.js}

@@ -1,11 +1,294 @@
-import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-H-PTi3W0.js";
+import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
+import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-Bg-Qf5s-.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { a as formatCodexStatus, c as formatModels, f as CODEX_CONTROL_METHODS, i as formatCodexDisplayText, l as formatThreads, n as buildHelp, o as formatComputerUseStatus, p as describeControlFailure, r as formatAccount, s as formatList, t as requestCodexAppServerJson, u as readString } from "./request-DC1Dz3iZ.js";
-import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
-import { a as parseCodexFastModeArg, c as setCodexConversationFastMode, d as steerCodexConversationTurn, f as stopCodexConversationTurn, i as formatPermissionsMode, l as setCodexConversationModel, m as resolveCodexDefaultWorkspaceDir, o as parseCodexPermissionsModeArg, p as readCodexConversationBindingData, r as startCodexConversationThread, s as readCodexConversationActiveTurn, u as setCodexConversationPermissions } from "./conversation-binding-FqeYliIk.js";
-import { a as readCodexComputerUseStatus, i as installCodexComputerUse, n as rememberCodexRateLimits } from "./rate-limit-cache-DbZvmrAD.js";
+import { n as CODEX_CONTROL_METHODS, r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BCAfJvSg.js";
+import { a as formatComputerUseStatus, c as formatThreads, i as formatCodexStatus, l as readString$1, n as formatAccount, o as formatList, p as summarizeCodexAccountUsage, r as formatCodexDisplayText, s as formatModels, t as buildHelp } from "./command-formatters-Ttwc_kgX.js";
+import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-UFKjHkKJ.js";
+import { a as parseCodexFastModeArg, c as setCodexConversationFastMode, d as steerCodexConversationTurn, f as stopCodexConversationTurn, i as formatPermissionsMode, l as setCodexConversationModel, m as resolveCodexDefaultWorkspaceDir, o as parseCodexPermissionsModeArg, p as readCodexConversationBindingData, r as startCodexConversationThread, s as readCodexConversationActiveTurn, u as setCodexConversationPermissions } from "./conversation-binding-D4XZ-tvV.js";
+import { n as installCodexComputerUse, r as readCodexComputerUseStatus } from "./computer-use-CVLaKaW3.js";
+import { n as rememberCodexRateLimits } from "./rate-limit-cache-dvhq-4pi.js";
 import crypto from "node:crypto";
+import { ensureAuthProfileStore, findNormalizedProviderValue, resolveAuthProfileEligibility, resolveAuthProfileOrder, resolveDefaultAgentDir, resolveProfileUnusableUntilForDisplay } from "openclaw/plugin-sdk/agent-runtime";
+//#region extensions/codex/src/command-account.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+async function readCodexAccountAuthOverview(params) {
+	const config = params.ctx.config;
+	const store = ensureAuthProfileStore(resolveDefaultAgentDir(config), {
+		allowKeychainPrompt: false,
+		config
+	});
+	const order = resolveDisplayAuthOrder({
+		config,
+		store
+	});
+	if (order.length === 0) return;
+	const now = Date.now();
+	const activeProfileId = resolveActiveProfileId({
+		store,
+		order,
+		config,
+		account: params.account,
+		limits: params.limits,
+		now
+	});
+	const subscriptionProfileId = order.find((profileId) => isChatGptSubscriptionProfile(store.profiles[profileId]));
+	const activeIsSubscription = activeProfileId !== void 0 && isChatGptSubscriptionProfile(store.profiles[activeProfileId]);
+	const activeUsage = activeIsSubscription && params.limits.ok ? summarizeCodexAccountUsage(params.limits.value, now) : void 0;
+	const subscriptionUsage = subscriptionProfileId && (!activeIsSubscription || subscriptionProfileId !== activeProfileId) ? await readSubscriptionUsage({
+		...params,
+		config,
+		subscriptionProfileId,
+		now
+	}) : activeUsage;
+	if (!params.account.ok && !params.limits.ok && !subscriptionUsage) return;
+	const rows = order.map((profileId, index) => buildProfileRow({
+		store,
+		config,
+		profileId,
+		activeProfileId,
+		activeIndex: activeProfileId ? order.indexOf(activeProfileId) : -1,
+		index,
+		now,
+		usage: profileId === subscriptionProfileId ? subscriptionUsage : void 0
+	}));
+	const activeRow = rows.find((row) => row.active);
+	if (!activeRow) return {
+		currentLine: "OpenAI credentials: no working credential",
+		orderTitle: "Auth order",
+		rows
+	};
+	const activeIsApiKey = store.profiles[activeRow.profileId]?.type === "api_key";
+	const subscriptionLabel = subscriptionProfileId ? formatProfileLabel(subscriptionProfileId, store.profiles[subscriptionProfileId]) : activeIsSubscription ? activeRow.label : void 0;
+	const subscriptionUsageLine = formatSubscriptionUsageLine(subscriptionUsage);
+	return {
+		...activeIsApiKey ? { currentLine: buildApiKeyActiveLine(activeRow, subscriptionUsage) } : {},
+		...subscriptionLabel ? { subscriptionLabel } : {},
+		...subscriptionUsageLine ? { subscriptionUsage: subscriptionUsageLine } : {},
+		orderTitle: "Auth order",
+		rows
+	};
+}
+function resolveDisplayAuthOrder(params) {
+	const codexOrder = resolveOrder(params.store.order, OPENAI_CODEX_PROVIDER_ID) ?? resolveOrder(params.config?.auth?.order, OPENAI_CODEX_PROVIDER_ID);
+	if (codexOrder && codexOrder.length > 0) return dedupe(codexOrder);
+	return resolveAuthProfileOrder({
+		cfg: params.config,
+		store: params.store,
+		provider: OPENAI_CODEX_PROVIDER_ID
+	});
+}
+function resolveOrder(order, provider) {
+	return findNormalizedProviderValue(order, provider);
+}
+function resolveActiveProfileId(params) {
+	const liveProfileId = resolveLiveAccountProfileId({
+		account: params.account,
+		store: params.store,
+		order: params.order
+	});
+	if (liveProfileId) return liveProfileId;
+	const lastGood = [params.store.lastGood?.[OPENAI_PROVIDER_ID], params.store.lastGood?.[OPENAI_CODEX_PROVIDER_ID]].find((profileId) => !!profileId && params.order.includes(profileId) && isActiveProfileCandidate(params, profileId));
+	if (lastGood) return lastGood;
+	const mostRecent = params.order.map((profileId) => ({
+		profileId,
+		lastUsed: params.store.usageStats?.[profileId]?.lastUsed ?? 0
+	})).filter((entry) => entry.lastUsed > 0 && isActiveProfileCandidate(params, entry.profileId)).toSorted((left, right) => right.lastUsed - left.lastUsed)[0]?.profileId;
+	if (mostRecent) return mostRecent;
+	if (shouldInferApiKeyActiveFromRateLimitProbe(params.limits)) {
+		const apiKeyProfile = params.order.find((profileId) => params.store.profiles[profileId]?.type === "api_key");
+		if (apiKeyProfile) return apiKeyProfile;
+	}
+	return resolveAuthProfileOrder({
+		cfg: params.config,
+		store: params.store,
+		provider: OPENAI_CODEX_PROVIDER_ID
+	})[0];
+}
+function isActiveProfileCandidate(params, profileId) {
+	return !isActiveUntil(resolveProfileUnusableUntilForDisplay(params.store, profileId) ?? void 0, params.now);
+}
+function resolveLiveAccountProfileId(params) {
+	if (!params.account.ok || !isJsonObject(params.account.value)) return;
+	const account = isJsonObject(params.account.value.account) ? params.account.value.account : params.account.value;
+	const type = readString(account, "type")?.toLowerCase();
+	if (type === "chatgpt") {
+		const email = readString(account, "email")?.toLowerCase();
+		const firstSubscription = params.order.find((profileId) => isChatGptSubscriptionProfile(params.store.profiles[profileId]));
+		if (!email) return firstSubscription;
+		return params.order.find((profileId) => {
+			const credential = params.store.profiles[profileId];
+			if (!isChatGptSubscriptionProfile(credential)) return false;
+			return (credential.email?.trim().toLowerCase() ?? extractEmailFromProfileId(profileId))?.toLowerCase() === email;
+		}) ?? firstSubscription;
+	}
+	if (type === "apikey" || type === "api_key") return params.order.find((profileId) => params.store.profiles[profileId]?.type === "api_key");
+}
+function shouldInferApiKeyActiveFromRateLimitProbe(limits) {
+	return !limits.ok && limits.error.toLowerCase().includes("chatgpt authentication required");
+}
+async function readSubscriptionUsage(params) {
+	const limits = await params.safeCodexControlRequest(params.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0, {
+		config: params.config,
+		authProfileId: params.subscriptionProfileId,
+		isolated: true
+	});
+	if (!limits.ok) return;
+	rememberCodexRateLimits(limits.value);
+	return summarizeCodexAccountUsage(limits.value, params.now);
+}
+function buildProfileRow(params) {
+	const credential = params.store.profiles[params.profileId];
+	const label = formatProfileLabel(params.profileId, credential);
+	const kind = formatProfileKind(credential);
+	const active = params.profileId === params.activeProfileId;
+	const status = active ? "active now" : params.usage?.blocked ? formatUsageBlockedStatus(params.usage) : describeInactiveProfileStatus({
+		store: params.store,
+		config: params.config,
+		profileId: params.profileId,
+		credential,
+		now: params.now,
+		afterActive: params.activeIndex >= 0 && params.index > params.activeIndex
+	});
+	return {
+		profileId: params.profileId,
+		label,
+		kind,
+		status,
+		active,
+		...credential?.type === "api_key" && active ? { billingNote: "billed per token" } : {},
+		...params.usage?.usageLine ? { usage: params.usage.usageLine } : {}
+	};
+}
+function formatUsageBlockedStatus(usage) {
+	return usage.blocked ? "rate-limited" : "available if needed";
+}
+function describeInactiveProfileStatus(params) {
+	const stats = params.store.usageStats?.[params.profileId];
+	const blockedUntil = stats?.blockedUntil;
+	if (isActiveUntil(blockedUntil, params.now)) return `rate-limited - resets ${formatRelativeReset(blockedUntil, params.now)}`;
+	if (isActiveUntil(resolveProfileUnusableUntilForDisplay(params.store, params.profileId) ?? void 0, params.now)) return describeFailureStatus(stats?.disabledReason ?? stats?.cooldownReason, params.credential);
+	const eligibility = resolveAuthProfileEligibility({
+		cfg: params.config,
+		store: params.store,
+		provider: OPENAI_CODEX_PROVIDER_ID,
+		profileId: params.profileId,
+		now: params.now
+	});
+	if (!eligibility.eligible) return describeEligibilityStatus(eligibility.reasonCode, params.credential);
+	return "available if needed";
+}
+function buildApiKeyActiveLine(activeRow, subscriptionUsage) {
+	if (subscriptionUsage?.blocked) {
+		const switchBack = subscriptionUsage.blockedResetRelative ? ` · switches back ${subscriptionUsage.blockedResetRelative}` : " · switches back automatically";
+		return `Now using: ${activeRow.label} - subscription rate-limited${switchBack}`;
+	}
+	return `Now using: ${activeRow.label} - subscription unavailable · switches back automatically`;
+}
+function formatSubscriptionUsageLine(usage) {
+	if (!usage) return;
+	const parts = usage.usageLine ? [formatUsageLineForDisplay(usage.usageLine)] : [];
+	if (usage.blockedResetRelative) parts.push(`Resets ${usage.blockedResetRelative}`);
+	return parts.length > 0 ? parts.join(" · ") : void 0;
+}
+function formatUsageLineForDisplay(value) {
+	return value.replace(/^weekly\b/u, "Weekly").replace(/\bshort-term\b/u, "Short-term");
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isChatGptSubscriptionProfile(credential) {
+	return credential?.type === "oauth" || credential?.type === "token";
+}
+function formatProfileKind(credential) {
+	if (!credential) return "credential";
+	if (isChatGptSubscriptionProfile(credential)) return "ChatGPT subscription";
+	if (credential.type === "api_key") return "API key";
+	return "credential";
+}
+function formatProfileLabel(profileId, credential) {
+	const tail = profileId.includes(":") ? profileId.slice(profileId.indexOf(":") + 1) : profileId;
+	const displayName = credential?.displayName?.trim();
+	if (displayName) return credential?.type === "api_key" ? simplifyApiKeyDisplayName(displayName, tail) : displayName;
+	const email = credential?.email?.trim() ?? extractEmailFromProfileId(profileId);
+	if (email) return email;
+	if (credential?.type === "api_key") return tail || "API key";
+	return humanizeProfileTail(tail);
+}
+function simplifyApiKeyDisplayName(value, tail) {
+	const stripped = value.replace(/^OpenAI\s+/iu, "").trim();
+	if (tail && stripped.toLowerCase() === humanizeApiKeyProfileTail(tail).toLowerCase()) return tail;
+	return stripped || value;
+}
+function humanizeApiKeyProfileTail(tail) {
+	const words = splitProfileTail(tail);
+	const hasBackup = words.includes("backup");
+	return [
+		words.filter((word) => word !== "api" && word !== "key" && word !== "backup").map(titleCase).join(" "),
+		"API key",
+		hasBackup ? "backup" : ""
+	].filter(Boolean).join(" ");
+}
+function humanizeProfileTail(tail) {
+	const words = splitProfileTail(tail);
+	return words.length > 0 ? words.map(titleCase).join(" ") : tail;
+}
+function splitProfileTail(tail) {
+	return tail.replace(/[_\s]+/gu, "-").split("-").map((word) => word.trim().toLowerCase()).filter(Boolean);
+}
+function titleCase(value) {
+	return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
+}
+function extractEmailFromProfileId(profileId) {
+	const tail = profileId.includes(":") ? profileId.slice(profileId.indexOf(":") + 1) : profileId;
+	return /^[^\s@<>()[\]`]+@[^\s@<>()[\]`]+\.[^\s@<>()[\]`]+$/.test(tail) ? tail : void 0;
+}
+function describeFailureStatus(reason, credential) {
+	if (reason === "auth" || reason === "auth_permanent" || reason === "session_expired") return credential?.type === "api_key" ? "auth failed - check key" : "sign-in expired";
+	if (reason === "billing") return "billing unavailable";
+	if (reason === "rate_limit") return "rate-limited";
+	return "temporarily unavailable";
+}
+function describeEligibilityStatus(reason, credential) {
+	if (reason === "profile_missing" || reason === "missing_credential") return credential?.type === "api_key" ? "not configured" : "sign-in required";
+	if (reason === "expired" || reason === "invalid_expires") return "sign-in expired";
+	if (reason === "unresolved_ref") return "credential unavailable";
+	if (reason === "provider_mismatch") return "wrong provider";
+	if (reason === "mode_mismatch") return "wrong credential type";
+	return "unavailable";
+}
+function isActiveUntil(value, now) {
+	return typeof value === "number" && Number.isFinite(value) && value > now;
+}
+function formatRelativeReset(untilMs, nowMs) {
+	const durationMs = Math.max(1e3, untilMs - nowMs);
+	const minuteMs = 6e4;
+	const hourMs = 60 * minuteMs;
+	const dayMs = 24 * hourMs;
+	if (durationMs < hourMs) {
+		const minutes = Math.ceil(durationMs / minuteMs);
+		return `in ${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+	}
+	if (durationMs < dayMs) {
+		const hours = Math.ceil(durationMs / hourMs);
+		return `in ${hours} ${hours === 1 ? "hour" : "hours"}`;
+	}
+	const days = Math.ceil(durationMs / dayMs);
+	return `in ${days} ${days === 1 ? "day" : "days"}`;
+}
+function dedupe(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		const trimmed = value.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		result.push(trimmed);
+	}
+	return result;
+}
+//#endregion
 //#region extensions/codex/src/command-rpc.ts
 function requestOptions(pluginConfig, limit, config) {
 	const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
@@ -23,7 +306,9 @@ async function codexControlRequest(pluginConfig, method, requestParams, options
 		requestParams,
 		timeoutMs: runtime.requestTimeoutMs,
 		startOptions: runtime.start,
-		config: options.config
+		config: options.config,
+		authProfileId: options.authProfileId,
+		isolated: options.isolated
 	});
 }
 async function safeCodexControlRequest(pluginConfig, method, requestParams, options = {}) {
@@ -149,7 +434,13 @@ async function handleCodexSubcommand(ctx, options) {
 		if (rest.length > 0) return { text: "Usage: /codex account" };
 		const [account, limits] = await Promise.all([deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.account, { refreshToken: false }), deps.safeCodexControlRequest(options.pluginConfig, CODEX_CONTROL_METHODS.rateLimits, void 0)]);
 		if (limits.ok) rememberCodexRateLimits(limits.value);
-		return { text: formatAccount(account, limits) };
+		return { text: formatAccount(account, limits, await readCodexAccountAuthOverview({
+			ctx,
+			pluginConfig: options.pluginConfig,
+			safeCodexControlRequest: deps.safeCodexControlRequest,
+			account,
+			limits
+		})) };
 	}
 	return { text: `Unknown Codex command: ${formatCodexDisplayText(subcommand)}\n\n${buildHelp()}` };
 }
@@ -239,12 +530,12 @@ async function resumeThread(deps, ctx, pluginConfig, args) {
 		persistExtendedHistory: true
 	});
 	const thread = isJsonObject(response) && isJsonObject(response.thread) ? response.thread : {};
-	const effectiveThreadId = readString(thread, "id") ?? normalizedThreadId;
+	const effectiveThreadId = readString$1(thread, "id") ?? normalizedThreadId;
 	await deps.writeCodexAppServerBinding(ctx.sessionFile, {
 		threadId: effectiveThreadId,
-		cwd: readString(thread, "cwd") ?? "",
-		model: isJsonObject(response) ? readString(response, "model") : void 0,
-		modelProvider: isJsonObject(response) ? readString(response, "modelProvider") : void 0
+		cwd: readString$1(thread, "cwd") ?? "",
+		model: isJsonObject(response) ? readString$1(response, "model") : void 0,
+		modelProvider: isJsonObject(response) ? readString$1(response, "modelProvider") : void 0
 	});
 	return `Attached this OpenClaw session to Codex thread ${formatCodexDisplayText(effectiveThreadId)}.`;
 }
@@ -318,9 +609,9 @@ async function handleCodexDiagnosticsFeedback(deps, ctx, pluginConfig, args, com
 	if (parsed.action === "cancel") return { text: cancelCodexDiagnosticsFeedback(ctx, parsed.token) };
 	if (ctx.diagnosticsUploadApproved === true) return { text: await sendCodexDiagnosticsFeedbackForContext(deps, ctx, pluginConfig, parsed.note) };
 	if (ctx.diagnosticsPreviewOnly === true) return { text: await previewCodexDiagnosticsFeedbackApproval(deps, ctx, parsed.note) };
-	return await requestCodexDiagnosticsFeedbackApproval(deps, ctx, pluginConfig, parsed.note, commandPrefix);
+	return await requestCodexDiagnosticsFeedbackApproval(deps, ctx, parsed.note, commandPrefix);
 }
-async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, pluginConfig, note, commandPrefix) {
+async function requestCodexDiagnosticsFeedbackApproval(deps, ctx, note, commandPrefix) {
 	if (!await hasAnyCodexDiagnosticsSessionFile(ctx)) return { text: "Cannot send Codex diagnostics because this command did not include an OpenClaw session file." };
 	const targets = await resolveCodexDiagnosticsTargets(deps, ctx);
 	if (targets.length === 0) return { text: ["No Codex thread is attached to this OpenClaw session yet.", "Use /codex threads to find a thread, then /codex resume <thread-id> before sending diagnostics."].join("\n") };
@@ -442,7 +733,7 @@ async function sendCodexDiagnosticsFeedbackForTargets(deps, ctx, pluginConfig, n
 			});
 			continue;
 		}
-		const responseThreadId = isJsonObject(response.value) ? readString(response.value, "threadId") : void 0;
+		const responseThreadId = isJsonObject(response.value) ? readString$1(response.value, "threadId") : void 0;
 		sent.push({
 			...target,
 			threadId: responseThreadId ?? target.threadId

package/dist/{compact-4FVe6NwI.js → compact-BJ1UYEyA.js}

@@ -1,7 +1,7 @@
-import { s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { i as readCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
-import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-BJL_efz4.js";
+import { i as readCodexAppServerBinding } from "./session-binding-UFKjHkKJ.js";
+import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-D2P0KD6r.js";
 import { embeddedAgentLog, formatErrorMessage, isActiveHarnessContextEngine, runHarnessContextEngineMaintenance } from "openclaw/plugin-sdk/agent-harness-runtime";
 //#region extensions/codex/src/app-server/compact.ts
 const DEFAULT_CODEX_COMPACTION_WAIT_TIMEOUT_MS = 300 * 1e3;

package/dist/{rate-limit-cache-DbZvmrAD.js → computer-use-CVLaKaW3.js}

@@ -1,5 +1,5 @@
-import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
-import { p as describeControlFailure, t as requestCodexAppServerJson } from "./request-DC1Dz3iZ.js";
+import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
+import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BCAfJvSg.js";
 import { existsSync } from "node:fs";
 //#region extensions/codex/src/app-server/computer-use.ts
 var CodexComputerUseSetupError = class extends Error {
@@ -364,27 +364,4 @@ function resolveComputerUseConfig(params) {
 	});
 }
 //#endregion
-//#region extensions/codex/src/app-server/rate-limit-cache.ts
-const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 10 * 6e4;
-const CODEX_RATE_LIMIT_CACHE_STATE = Symbol.for("openclaw.codexRateLimitCacheState");
-function getCodexRateLimitCacheState() {
-	const globalState = globalThis;
-	globalState[CODEX_RATE_LIMIT_CACHE_STATE] ??= {};
-	return globalState[CODEX_RATE_LIMIT_CACHE_STATE];
-}
-function rememberCodexRateLimits(value, nowMs = Date.now()) {
-	if (value === void 0) return;
-	const state = getCodexRateLimitCacheState();
-	state.value = value;
-	state.updatedAtMs = nowMs;
-}
-function readRecentCodexRateLimits(options) {
-	const state = getCodexRateLimitCacheState();
-	if (state.value === void 0 || state.updatedAtMs === void 0) return;
-	const nowMs = options?.nowMs ?? Date.now();
-	const maxAgeMs = options?.maxAgeMs ?? DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS;
-	if (maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs) return;
-	return state.value;
-}
-//#endregion
-export { readCodexComputerUseStatus as a, installCodexComputerUse as i, rememberCodexRateLimits as n, ensureCodexComputerUse as r, readRecentCodexRateLimits as t };
+export { installCodexComputerUse as n, readCodexComputerUseStatus as r, ensureCodexComputerUse as t };

package/dist/{config-CT01BBDc.js → config-C7xdbzrp.js}

@@ -1,7 +1,7 @@
 import { createHmac, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { hostname } from "node:os";
-import { z } from "openclaw/plugin-sdk/zod";
+import { z } from "zod";
 //#region extensions/codex/src/app-server/config.ts
 const START_OPTIONS_KEY_SECRET = randomBytes(32);
 const UNIX_CODEX_REQUIREMENTS_PATH = "/etc/codex/requirements.toml";

package/dist/{conversation-binding-FqeYliIk.js → conversation-binding-D4XZ-tvV.js}

@@ -1,8 +1,9 @@
-import { i as isCodexFastServiceTier, r as codexSandboxPolicyForTurn, s as resolveCodexAppServerRuntimeOptions } from "./config-CT01BBDc.js";
+import { i as isCodexFastServiceTier, r as codexSandboxPolicyForTurn, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { f as CODEX_CONTROL_METHODS, i as formatCodexDisplayText } from "./request-DC1Dz3iZ.js";
-import { c as resolveCodexAppServerAuthProfileIdForAgent, n as getSharedCodexAppServerClient } from "./shared-client-p-TvEiNL.js";
-import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, r as normalizeCodexAppServerBindingModelProvider, t as clearCodexAppServerBinding } from "./session-binding-B44KIZM2.js";
+import { n as CODEX_CONTROL_METHODS } from "./request-BCAfJvSg.js";
+import { r as formatCodexDisplayText } from "./command-formatters-Ttwc_kgX.js";
+import { l as resolveCodexAppServerAuthProfileIdForAgent, r as getSharedCodexAppServerClient } from "./shared-client-K13b0L1X.js";
+import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, r as normalizeCodexAppServerBindingModelProvider, t as clearCodexAppServerBinding } from "./session-binding-UFKjHkKJ.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/agent-harness-runtime";
 import path from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/harness.js

@@ -18,21 +18,25 @@ function createCodexAppServerAgentHarness(options) {
 			};
 		},
 		runAttempt: async (params) => {
-			const { runCodexAppServerAttempt } = await import("./run-attempt-CefRS5_d.js");
+			const { runCodexAppServerAttempt } = await import("./run-attempt-DZvighJE.js");
 			return runCodexAppServerAttempt(params, { pluginConfig: options?.pluginConfig });
 		},
+		runSideQuestion: async (params) => {
+			const { runCodexAppServerSideQuestion } = await import("./side-question-Dh_g53P9.js");
+			return runCodexAppServerSideQuestion(params, { pluginConfig: options?.pluginConfig });
+		},
 		compact: async (params) => {
-			const { maybeCompactCodexAppServerSession } = await import("./compact-4FVe6NwI.js");
+			const { maybeCompactCodexAppServerSession } = await import("./compact-BJ1UYEyA.js");
 			return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.pluginConfig });
 		},
 		reset: async (params) => {
 			if (params.sessionFile) {
-				const { clearCodexAppServerBinding } = await import("./session-binding-B44KIZM2.js").then((n) => n.a);
+				const { clearCodexAppServerBinding } = await import("./session-binding-UFKjHkKJ.js").then((n) => n.a);
 				await clearCodexAppServerBinding(params.sessionFile);
 			}
 		},
 		dispose: async () => {
-			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-p-TvEiNL.js").then((n) => n.r);
+			const { clearSharedCodexAppServerClientAndWait } = await import("./shared-client-K13b0L1X.js").then((n) => n.i);
 			await clearSharedCodexAppServerClientAndWait();
 		}
 	};

package/dist/index.js

@@ -1,10 +1,11 @@
 import { createCodexAppServerAgentHarness } from "./harness.js";
-import { t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-CT01BBDc.js";
+import { t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-C7xdbzrp.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import { buildCodexProvider } from "./provider.js";
-import { i as formatCodexDisplayText, p as describeControlFailure, t as requestCodexAppServerJson } from "./request-DC1Dz3iZ.js";
-import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-FqeYliIk.js";
-import { i as defaultCodexAppInventoryCache, t as ensureCodexPluginActivation } from "./plugin-activation-CweAZa7r.js";
+import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-BCAfJvSg.js";
+import { r as formatCodexDisplayText } from "./command-formatters-Ttwc_kgX.js";
+import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-D4XZ-tvV.js";
+import { i as defaultCodexAppInventoryCache, t as ensureCodexPluginActivation } from "./plugin-activation-C0soz2YD.js";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import os from "node:os";
@@ -28,13 +29,17 @@ function createCodexCommand(options) {
 	};
 }
 async function handleCodexCommand(ctx, options = {}) {
-	const { handleCodexSubcommand } = await import("./command-handlers-BLZCm3fD.js");
+	const { loadSubcommandHandler, ...subcommandOptions } = options;
 	try {
-		return await handleCodexSubcommand(ctx, options);
+		return await (loadSubcommandHandler ? await loadSubcommandHandler() : await loadDefaultCodexSubcommandHandler())(ctx, subcommandOptions);
 	} catch (error) {
 		return { text: `Codex command failed: ${formatCodexDisplayText(describeControlFailure(error))}` };
 	}
 }
+async function loadDefaultCodexSubcommandHandler() {
+	const { handleCodexSubcommand } = await import("./command-handlers-iLF1EI-b.js");
+	return handleCodexSubcommand;
+}
 //#endregion
 //#region extensions/codex/src/migration/helpers.ts
 async function exists(filePath) {