@openclaw/codex 2026.5.10-beta.3 → 2026.5.10-beta.5

package/dist/{client-factory-BHbKz0nI.js → client-factory-D2P0KD6r.js}

@@ -1,5 +1,5 @@
 //#region extensions/codex/src/app-server/client-factory.ts
-const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-BRX9tReb.js").then((n) => n.r).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
+const defaultCodexAppServerClientFactory = (startOptions, authProfileId, agentDir, config) => import("./shared-client-K13b0L1X.js").then((n) => n.i).then(({ getSharedCodexAppServerClient }) => getSharedCodexAppServerClient({
 	startOptions,
 	authProfileId,
 	agentDir,

package/dist/{request-Bj4IRDU9.js → command-formatters-Ttwc_kgX.js}

@@ -1,26 +1,4 @@
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { n as CodexAppServerRpcError } from "./client-CpksBQ9l.js";
-import { i as withTimeout, n as getSharedCodexAppServerClient } from "./shared-client-BRX9tReb.js";
-//#region extensions/codex/src/app-server/capabilities.ts
-const CODEX_CONTROL_METHODS = {
-	account: "account/read",
-	compact: "thread/compact/start",
-	feedback: "feedback/upload",
-	listMcpServers: "mcpServerStatus/list",
-	listSkills: "skills/list",
-	listThreads: "thread/list",
-	rateLimits: "account/rateLimits/read",
-	resumeThread: "thread/resume",
-	review: "review/start"
-};
-function describeControlFailure(error) {
-	if (isUnsupportedControlError(error)) return "unsupported by this Codex app-server";
-	return error instanceof Error ? error.message : String(error);
-}
-function isUnsupportedControlError(error) {
-	return error instanceof CodexAppServerRpcError && error.code === -32601;
-}
-//#endregion
 //#region extensions/codex/src/app-server/rate-limits.ts
 const CODEX_LIMIT_ID = "codex";
 const LIMIT_WINDOW_KEYS = ["primary", "secondary"];
@@ -52,13 +30,34 @@ function summarizeCodexRateLimits(value, nowMs = Date.now()) {
 	return snapshots.slice(0, 4).map((snapshot) => summarizeRateLimitSnapshot(snapshot, nowMs)).join("; ");
 }
 function summarizeCodexAccountRateLimits(value, nowMs = Date.now()) {
+	const summary = summarizeCodexAccountUsage(value, nowMs);
+	if (!summary) return;
+	if (!summary.blocked) return ["Codex is available."];
+	return [summary.blockedUntilText ? `Codex is paused until ${summary.blockedUntilText}.` : "Codex is paused by a usage limit.", summary.blockingReason ? `Your ${summary.blockingReason}.` : "Your Codex usage limit is reached."];
+}
+function resolveCodexUsageLimitResetAtMs(value, nowMs = Date.now()) {
+	return selectBlockingRateLimitReset(value, nowMs)?.resetsAtMs;
+}
+function summarizeCodexAccountUsage(value, nowMs = Date.now()) {
 	const snapshots = collectCodexRateLimitSnapshots(value);
 	if (snapshots.length === 0) return;
+	const usageSnapshot = snapshots.find(isCodexLimitSnapshot) ?? snapshots[0];
 	const blockedSnapshots = snapshots.filter(snapshotHasLimitBlock);
 	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
-	if (!blockingSnapshot) return ["Codex is available."];
-	const blockingReset = selectSnapshotBlockingReset(blockingSnapshot, nowMs);
-	return [blockingReset ? `Codex is paused until ${formatAccountResetTime(blockingReset.resetsAtMs, nowMs)}.` : "Codex is paused by a usage limit.", formatBlockingLimitReason(blockingReset)];
+	const blockingReset = blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
+	const blockingPeriod = formatBlockingLimitPeriod(blockingReset?.windowDurationMins);
+	const blockedUntilText = blockingReset ? formatAccountResetTime(blockingReset.resetsAtMs, nowMs) : void 0;
+	const blockedResetRelative = blockingReset ? `in ${formatRelativeDuration(blockingReset.resetsAtMs - nowMs)}` : void 0;
+	const blockingReason = blockingPeriod ? `${blockingPeriod} Codex usage limit is reached` : blockingSnapshot ? "Codex usage limit is reached" : void 0;
+	return {
+		usageLine: formatUsageLine(usageSnapshot),
+		blocked: Boolean(blockingSnapshot),
+		...blockingReset ? { blockedUntilMs: blockingReset.resetsAtMs } : {},
+		...blockedUntilText ? { blockedUntilText } : {},
+		...blockedResetRelative ? { blockedResetRelative } : {},
+		...blockingPeriod ? { blockingPeriod } : {},
+		...blockingReason ? { blockingReason } : {}
+	};
 }
 function isCodexUsageLimitError(codexErrorInfo, message) {
 	if (codexErrorInfo === "usageLimitExceeded") return true;
@@ -71,9 +70,12 @@ function selectNextRateLimitReset(value, nowMs) {
 	const futureWindows = collectCodexRateLimitSnapshots(value).flatMap((snapshot) => LIMIT_WINDOW_KEYS.flatMap((key) => readRateLimitWindow(snapshot, key) ?? [])).filter((window) => window.resetsAtMs > nowMs);
 	if (futureWindows.length === 0) return;
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
-	const candidates = exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows;
-	candidates.sort((left, right) => left.resetsAtMs - right.resetsAtMs);
-	return candidates[0];
+	return (exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows).toSorted((left, right) => left.resetsAtMs - right.resetsAtMs)[0];
+}
+function selectBlockingRateLimitReset(value, nowMs) {
+	const blockedSnapshots = collectCodexRateLimitSnapshots(value).filter(snapshotHasLimitBlock);
+	const blockingSnapshot = blockedSnapshots.find(isCodexLimitSnapshot) ?? blockedSnapshots[0] ?? void 0;
+	return blockingSnapshot ? selectSnapshotBlockingReset(blockingSnapshot, nowMs) : void 0;
 }
 function summarizeRateLimitSnapshot(snapshot, nowMs) {
 	const label = formatLimitLabel(snapshot);
@@ -176,8 +178,8 @@ function selectSnapshotBlockingReset(snapshot, nowMs) {
 	const futureWindows = readWindowEntries(snapshot).map((entry) => entry.window).filter((window) => window.resetsAtMs > nowMs);
 	const exhaustedWindows = futureWindows.filter((window) => window.usedPercent !== void 0 && window.usedPercent >= 100);
 	const candidates = exhaustedWindows.length > 0 ? exhaustedWindows : futureWindows;
-	candidates.sort((left, right) => left.resetsAtMs - right.resetsAtMs);
-	return candidates[0];
+	const resetSort = exhaustedWindows.length > 0 ? (left, right) => right.resetsAtMs - left.resetsAtMs : (left, right) => left.resetsAtMs - right.resetsAtMs;
+	return candidates.toSorted(resetSort)[0];
 }
 function readWindowEntries(snapshot) {
 	return LIMIT_WINDOW_KEYS.flatMap((key) => {
@@ -188,15 +190,25 @@ function readWindowEntries(snapshot) {
 		}] : [];
 	});
 }
-function formatBlockingLimitReason(window) {
-	const period = formatBlockingLimitPeriod(window?.windowDurationMins);
-	return period ? `Your ${period} Codex usage limit is reached.` : "Your Codex usage limit is reached.";
-}
 function formatBlockingLimitPeriod(minutes) {
 	if (minutes === 10080) return "weekly";
 	if (minutes === 1440) return "daily";
 	if (minutes !== void 0 && minutes > 0 && minutes < 1440) return "short-term";
 }
+function formatUsageLine(snapshot) {
+	const windows = readWindowEntries(snapshot).filter((entry) => entry.window.usedPercent !== void 0).toSorted((left, right) => (right.window.windowDurationMins ?? 0) - (left.window.windowDurationMins ?? 0)).map((entry) => {
+		return `${formatUsageWindowLabel(entry.window.windowDurationMins)} ${Math.round(entry.window.usedPercent ?? 0)}%`;
+	});
+	return windows.length > 0 ? windows.join(" · ") : void 0;
+}
+function formatUsageWindowLabel(minutes) {
+	if (minutes === 10080) return "weekly";
+	if (minutes === 1440) return "daily";
+	if (minutes !== void 0 && minutes > 0 && minutes < 1440) return "short-term";
+	if (minutes !== void 0 && minutes > 0 && minutes % 1440 === 0) return `${minutes / 1440}-day`;
+	if (minutes !== void 0 && minutes > 0 && minutes % 60 === 0) return `${minutes / 60}-hour`;
+	return "usage";
+}
 function formatCalendarResetTime(resetsAtMs, nowMs) {
 	const resetDate = new Date(resetsAtMs);
 	const resetParts = new Intl.DateTimeFormat("en-US", {
@@ -295,11 +307,30 @@ function formatThreads(response) {
 		return `- ${formatCodexDisplayText(id)}${title ? ` - ${formatCodexDisplayText(title)}` : ""}${details.length > 0 ? ` (${details.map(formatCodexDisplayText).join(", ")})` : ""}\n  Resume: ${formatCodexResumeHint(id)}`;
 	})].join("\n");
 }
-function formatAccount(account, limits) {
+function formatAccount(account, limits, authOverview) {
+	if (authOverview) return formatAccountAuthOverview(authOverview);
 	const formattedLimits = limits.ok ? formatCodexRateLimitDetails(limits.value) : formatCodexDisplayText(limits.error);
 	const rateLimitBlock = formattedLimits.startsWith("Codex is ") ? formattedLimits : formattedLimits.includes("\n") ? `Rate limits:\n${formattedLimits}` : `Rate limits: ${formattedLimits}`;
 	return [`Account: ${account.ok ? formatCodexAccountSummary(account.value) : formatCodexDisplayText(account.error)}`, rateLimitBlock].join("\n\n");
 }
+function formatAccountAuthOverview(overview) {
+	const lines = [];
+	if (overview.currentLine) lines.push(overview.currentLine, "");
+	if (overview.subscriptionLabel) {
+		lines.push(`Subscription  ${overview.subscriptionLabel}`);
+		if (overview.subscriptionUsage) lines.push(`  ${overview.subscriptionUsage}`);
+		lines.push("");
+	}
+	if (overview.rows.length > 0) {
+		lines.push(overview.orderTitle);
+		for (const [index, row] of overview.rows.entries()) lines.push(`  ${index + 1}. ${row.label}   ${row.kind}   — ${formatAuthRowStatus(row)}`);
+	}
+	while (lines.at(-1) === "") lines.pop();
+	return lines.map(formatCodexAccountLine).join("\n");
+}
+function formatAuthRowStatus(row) {
+	return row.billingNote ? `${row.status} · ${row.billingNote}` : row.status;
+}
 function formatComputerUseStatus(status) {
 	const lines = [`Computer Use: ${status.ready ? "ready" : status.enabled ? "not ready" : "disabled"}`];
 	lines.push(`Plugin: ${formatCodexDisplayText(status.pluginName)} (${computerUsePluginState(status)})`);
@@ -335,13 +366,15 @@ function formatCodexAccountSummary(value) {
 	return isLikelyEmailAddress(safe) ? escapeCodexChatTextPreservingAt(safe) : escapeCodexChatText(safe);
 }
 function formatCodexTextForDisplay(value) {
+	return sanitizeCodexTextForDisplay(value).trim() || "<unknown>";
+}
+function sanitizeCodexTextForDisplay(value) {
 	let safe = "";
 	for (const character of value) {
 		const codePoint = character.codePointAt(0);
 		safe += codePoint != null && isUnsafeDisplayCodePoint(codePoint) ? "?" : character;
 	}
-	safe = safe.trim();
-	return safe || "<unknown>";
+	return safe;
 }
 function escapeCodexChatText(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("@", "＠").replaceAll("`", "｀").replaceAll("[", "［").replaceAll("]", "］").replaceAll("(", "（").replaceAll(")", "）").replaceAll("*", "∗").replaceAll("_", "＿").replaceAll("~", "～").replaceAll("|", "｜");
@@ -349,6 +382,22 @@ function escapeCodexChatText(value) {
 function escapeCodexChatTextPreservingAt(value) {
 	return escapeCodexChatText(value).replaceAll("＠", "@");
 }
+function formatCodexAccountLine(value) {
+	if (value === "") return "";
+	const safe = sanitizeCodexTextForDisplay(value).trimEnd();
+	if (!safe.trim()) return "";
+	const emailPattern = /[^\s@<>()[\]`]+@[^\s@<>()[\]`]+\.[^\s@<>()[\]`]+/gu;
+	let formatted = "";
+	let lastIndex = 0;
+	for (const match of safe.matchAll(emailPattern)) {
+		const index = match.index ?? 0;
+		formatted += escapeCodexChatText(safe.slice(lastIndex, index));
+		formatted += escapeCodexChatTextPreservingAt(match[0]);
+		lastIndex = index + match[0].length;
+	}
+	formatted += escapeCodexChatText(safe.slice(lastIndex));
+	return formatted;
+}
 function isLikelyEmailAddress(value) {
 	return /^[^\s@<>()[\]`]+@[^\s@<>()[\]`]+\.[^\s@<>()[\]`]+$/.test(value);
 }
@@ -434,17 +483,4 @@ function readString(record, key) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
 //#endregion
-//#region extensions/codex/src/app-server/request.ts
-async function requestCodexAppServerJson(params) {
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	return await withTimeout((async () => {
-		return await (await getSharedCodexAppServerClient({
-			startOptions: params.startOptions,
-			timeoutMs,
-			authProfileId: params.authProfileId,
-			config: params.config
-		})).request(params.method, params.requestParams, { timeoutMs });
-	})(), timeoutMs, `codex app-server ${params.method} timed out`);
-}
-//#endregion
-export { formatCodexStatus as a, formatModels as c, formatCodexUsageLimitErrorMessage as d, shouldRefreshCodexRateLimitsForUsageLimitMessage as f, formatCodexDisplayText as i, formatThreads as l, describeControlFailure as m, buildHelp as n, formatComputerUseStatus as o, CODEX_CONTROL_METHODS as p, formatAccount as r, formatList as s, requestCodexAppServerJson as t, readString as u };
+export { formatComputerUseStatus as a, formatThreads as c, resolveCodexUsageLimitResetAtMs as d, shouldRefreshCodexRateLimitsForUsageLimitMessage as f, formatCodexStatus as i, readString as l, formatAccount as n, formatList as o, summarizeCodexAccountUsage as p, formatCodexDisplayText as r, formatModels as s, buildHelp as t, formatCodexUsageLimitErrorMessage as u };

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

@@ -1,11 +1,294 @@
 import { i as isCodexFastServiceTier, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
-import { n as listCodexAppServerModels, t as listAllCodexAppServerModels } from "./models-lvthKXfT.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, i as formatCodexDisplayText, l as formatThreads, m as describeControlFailure, n as buildHelp, o as formatComputerUseStatus, p as CODEX_CONTROL_METHODS, r as formatAccount, s as formatList, t as requestCodexAppServerJson, u as readString } from "./request-Bj4IRDU9.js";
-import { i as readCodexAppServerBinding, o as writeCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-BAaJ-7s-.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-zeuTIuN2.js";
-import { a as readCodexComputerUseStatus, i as installCodexComputerUse, n as rememberCodexRateLimits } from "./rate-limit-cache-BFTJlMhx.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)}.`;
 }
@@ -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-CMIpm-H_.js → compact-BJ1UYEyA.js}

@@ -1,7 +1,7 @@
 import { s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { i as readCodexAppServerBinding } from "./session-binding-BAaJ-7s-.js";
-import { n as defaultCodexAppServerClientFactory, t as createCodexAppServerClientFactoryTestHooks } from "./client-factory-BHbKz0nI.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-BFTJlMhx.js → computer-use-CVLaKaW3.js}

@@ -1,5 +1,5 @@
 import { c as resolveCodexComputerUseConfig, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
-import { m as describeControlFailure, t as requestCodexAppServerJson } from "./request-Bj4IRDU9.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/{conversation-binding-zeuTIuN2.js → conversation-binding-D4XZ-tvV.js}

@@ -1,8 +1,9 @@
 import { i as isCodexFastServiceTier, r as codexSandboxPolicyForTurn, s as resolveCodexAppServerRuntimeOptions } from "./config-C7xdbzrp.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
-import { i as formatCodexDisplayText, p as CODEX_CONTROL_METHODS } from "./request-Bj4IRDU9.js";
-import { c as resolveCodexAppServerAuthProfileIdForAgent, n as getSharedCodexAppServerClient } from "./shared-client-BRX9tReb.js";
-import { i as readCodexAppServerBinding, n as isCodexAppServerNativeAuthProfile, o as writeCodexAppServerBinding, r as normalizeCodexAppServerBindingModelProvider, t as clearCodexAppServerBinding } from "./session-binding-BAaJ-7s-.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";