pi-chatgpt-pool 0.1.0 → 0.2.1

package/README.md

@@ -20,7 +20,7 @@ Run `/chatgpt-pool` and choose **+ Add account**, or add them directly:
 /login
 ```
 
-`/login` lists each account as `ChatGPT (<label>)`. Sign in to each one with a different ChatGPT account. Then pick a pooled model:
+`/login` lists each account as `ChatGPT (<label>)`, or under a name you choose with `/chatgpt-pool name`. Renaming keeps the account signed in. Sign in to each one with a different ChatGPT account. Then pick a pooled model:
 
 ```text
 /model chatgpt/gpt-5.6-sol
@@ -32,14 +32,35 @@ The pool offers the ChatGPT subscription models: the OpenAI models that pi also
 
 | Command | What it does |
 | --- | --- |
-| `/chatgpt-pool` | Open the pool: each account's usage, reset times, and banked resets. Pick an account to spend a reset, clear its limit, or remove it |
+| `/chatgpt-pool` | Open the pool panel (see below) |
 | `/chatgpt-pool add <label>` | Add an account slot. Sign in to it with `/login` |
+| `/chatgpt-pool name <label> <name>` | Set the name the account shows in `/login`, for example `Work (jal@mastra.ai)`. Leave the name empty to go back to `ChatGPT (<label>)` |
 | `/chatgpt-pool remove <label>` | Remove an account. Run `/logout` for it first to delete its token |
 | `/chatgpt-pool spend <label>` | Spend one banked reset on that account, after you confirm |
 | `/chatgpt-pool strategy <name>` | Set the routing strategy: `fill-first`, `round-robin`, `least-used`, or `use-it-or-lose-it` |
 | `/chatgpt-pool reset` | Forget recorded limits, for example after a limit clears early |
 
-The command autocompletes its actions and account labels. The footer shows `chatgpt: <account>` while a pooled model is selected, plus how many accounts are limited and when the next one comes back.
+The command autocompletes its actions and account labels.
+
+## Pool panel
+
+`/chatgpt-pool` opens a panel with every account, its state (ready, limited with a countdown, or not signed in), a usage bar per window with the time until it resets, and its banked resets.
+
+| Key | Action |
+| --- | --- |
+| `↑` `↓` or `j` `k` | Select an account |
+| `s` | Spend a banked reset on the selected account, after you confirm |
+| `c` | Clear the selected account's recorded limit |
+| `n` | Set the name the selected account shows in `/login` |
+| `d` | Remove the selected account |
+| `a` | Add an account |
+| `t` | Choose the strategy |
+| `r` | Refresh usage |
+| `esc` or `q` | Close |
+
+Over RPC the same actions are offered as a list instead.
+
+While a pooled model is selected, the footer shows the account in use with its usage and reset time, for example `chatgpt: work 42% · resets in 3d 4h`, plus how many accounts are limited. When a conversation moves to another account, pi shows a notice such as `ChatGPT pool: personal is limited (back in 1h 30m), switched to work.`
 
 `/chatgpt-pool` and `spend` need the interactive UI; in `--print` or `--mode json` they stop with an error instead of spending anything. From a shell, use pi's own commands:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-chatgpt-pool",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Pool several Sign in with ChatGPT accounts in pi, with routing strategies, failover, and banked resets",
   "keywords": [
     "pi-package",
@@ -37,11 +37,13 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.99.1",
     "@earendil-works/pi-coding-agent": "^0.99.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0"
   },

package/src/format.ts

@@ -0,0 +1,30 @@
+export function formatWindow(seconds: number): string {
+	if (seconds % 604800 === 0) return seconds === 604800 ? "weekly" : `${seconds / 604800}-week`;
+	if (seconds % 86400 === 0) return seconds === 86400 ? "daily" : `${seconds / 86400}-day`;
+	if (seconds % 3600 === 0) return `${seconds / 3600}h`;
+	return `${Math.round(seconds / 60)}m`;
+}
+
+export function formatReset(at: number): string {
+	const date = new Date(at);
+	const time = date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
+	return date.toDateString() === new Date().toDateString()
+		? `at ${time}`
+		: `${date.toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" })} at ${time}`;
+}
+
+export function formatIn(ms: number): string {
+	const minutes = Math.max(1, Math.ceil(ms / 60_000));
+	const days = Math.floor(minutes / 1440);
+	const hours = Math.floor((minutes % 1440) / 60);
+	const rest = minutes % 60;
+	if (days > 0) return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+	if (hours > 0) return rest > 0 ? `${hours}h ${rest}m` : `${hours}h`;
+	return `${rest}m`;
+}
+
+export function usageBar(percent: number, width: number) {
+	const clamped = Math.min(100, Math.max(0, percent));
+	const filled = Math.round((clamped / 100) * width);
+	return { filled: "█".repeat(filled), empty: "░".repeat(width - filled) };
+}

package/src/index.ts

@@ -6,7 +6,9 @@ import { BorderedLoader, type ExtensionAPI, type ExtensionContext, getAgentDir }
 import {
 	type Account,
 	isStrategy,
+	failoverMessage,
 	limitCooldown,
+	loginName,
 	nextAccountId,
 	orderAccounts,
 	parseResetAt,
@@ -15,6 +17,8 @@ import {
 	type Strategy,
 	type UsageSnapshot,
 } from "./pool.ts";
+import { formatIn, formatReset, formatWindow } from "./format.ts";
+import { type AccountStatus, type PanelAction, PoolPanel } from "./panel.ts";
 import { fetchUsage, spendReset, type Usage } from "./usage.ts";
 
 const POOL_PROVIDER = "chatgpt";
@@ -76,7 +80,7 @@ function subscriptionModels(providers: readonly Provider[]): Model<Api>[] {
 }
 
 function accountProvider(openai: Provider, account: Account, onReset: ResetListener): Provider {
-	const name = `ChatGPT (${account.label})`;
+	const name = loginName(account);
 	const signIn = openai.auth.oauth;
 	if (!signIn) throw new Error("pi's openai provider has no Sign in with ChatGPT flow; update pi to 0.99.1 or later");
 	const models: Model<Api>[] = subscriptionModels(builtinProviders()).map((model) => ({
@@ -96,20 +100,6 @@ function accountProvider(openai: Provider, account: Account, onReset: ResetListe
 	};
 }
 
-function formatWindow(seconds: number): string {
-	if (seconds % 604800 === 0) return seconds === 604800 ? "weekly" : `${seconds / 604800}-week`;
-	if (seconds % 3600 === 0) return `${seconds / 3600}h`;
-	return `${Math.round(seconds / 60)}m`;
-}
-
-function formatReset(at: number): string {
-	const date = new Date(at);
-	const time = date.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
-	return date.toDateString() === new Date().toDateString()
-		? `at ${time}`
-		: `${date.toLocaleDateString([], { weekday: "short", month: "short", day: "numeric" })} at ${time}`;
-}
-
 export default function chatgptPool(pi: ExtensionAPI) {
 	const providers = builtinProviders();
 	const openai = providers.find((provider) => provider.id === "openai");
@@ -142,6 +132,14 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		);
 		return new Map([...usageCache].map(([id, entry]) => [id, entry.snapshot]));
 	};
+	const refreshUsage = async (ctx: ExtensionContext, accountId: string) => {
+		const cached = usageCache.get(accountId);
+		if (cached && Date.now() - cached.at < USAGE_TTL_MS) return;
+		const token = await ctx.modelRegistry.getApiKeyForProvider(accountId).catch(() => undefined);
+		if (!token) return;
+		await fetchUsage(token).then((usage) => rememberUsage(accountId, usage), () => undefined);
+	};
+
 	const reportedResets = new Map<string, number>();
 	const onReset: ResetListener = (accountId, resetsAt) => reportedResets.set(accountId, resetsAt);
 
@@ -165,11 +163,16 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		if (provider !== POOL_PROVIDER) return ctx.ui.setStatus(STATUS_KEY, undefined);
 		const now = Date.now();
 		const active = accounts.find((account) => account.id === lastRouted);
+		const snapshot = active && usageCache.get(active.id)?.snapshot;
 		const limited = accounts.filter((account) => (account.resetsAt ?? 0) > now);
 		const parts = [`chatgpt: ${active?.label ?? "pool"}`];
+		if (snapshot) {
+			parts[0] += ` ${Math.round(snapshot.usedPercent)}%`;
+			parts.push(`resets in ${formatIn(snapshot.resetsAt - now)}`);
+		}
 		if (limited.length > 0) {
 			const next = Math.min(...limited.map((account) => account.resetsAt ?? now));
-			parts.push(`${limited.length} limited, next back ${formatReset(next)}`);
+			parts.push(`${limited.length} limited, next back in ${formatIn(next - now)}`);
 		}
 		ctx.ui.setStatus(STATUS_KEY, parts.join(" · "));
 	};
@@ -212,10 +215,18 @@ export default function chatgptPool(pi: ExtensionAPI) {
 							: "Every ChatGPT account in the pool is signed out or limited. Run /chatgpt-pool to see reset times and banked resets.",
 					);
 				}
+				if (sticky !== undefined && sticky !== routed.provider && ctx.hasUI) {
+					const from = accounts.find((candidate) => candidate.id === sticky);
+					const until = from?.resetsAt && from.resetsAt > Date.now() ? ` (back in ${formatIn(from.resetsAt - Date.now())})` : "";
+					ctx.ui.notify(`ChatGPT pool: ${from?.label ?? sticky} is limited${until}, switched to ${account.label}.`, "info");
+				}
 				if (lastRouted !== routed.provider) {
 					lastRouted = routed.provider;
 					updateStatus(ctx);
 				}
+				refreshUsage(ctx, routed.provider)
+					.then(() => updateStatus(ctx, POOL_PROVIDER))
+					.catch(() => undefined);
 				return { model: routed, thinkingLevel: request.thinkingLevel };
 			},
 		});
@@ -237,13 +248,11 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		return {
 			message: {
 				...message,
-				errorMessage: `ChatGPT account "${account.label}" is rate limited; switching to another account in the pool.`,
+				errorMessage: failoverMessage(account.label),
 			},
 		};
 	});
 
-	type AccountStatus = { account: Account; signedIn: boolean; usage?: Usage; error?: string };
-
 	const loadStatuses = (ctx: ExtensionContext, signal?: AbortSignal): Promise<AccountStatus[]> =>
 		Promise.all(
 			accounts.map(async (account): Promise<AccountStatus> => {
@@ -275,7 +284,7 @@ export default function chatgptPool(pi: ExtensionAPI) {
 
 	const describe = ({ account, signedIn, usage, error }: AccountStatus): string => {
 		const limitedUntil = account.resetsAt && account.resetsAt > Date.now() ? account.resetsAt : undefined;
-		if (!signedIn) return `${account.label}  ·  not signed in, run /login and pick ChatGPT (${account.label})`;
+		if (!signedIn) return `${account.label}  ·  not signed in, run /login and pick ${loginName(account)}`;
 		const state = limitedUntil ? `limited until ${formatReset(limitedUntil)}` : "ready";
 		if (!usage) return `${account.label}  ·  ${state}  ·  usage unavailable${error ? ` (${error})` : ""}`;
 		const windows = usage.windows.map(
@@ -297,7 +306,25 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		update((config) => ({ ...config, accounts: [...config.accounts, account] }));
 		registerPooledModels();
 		pi.registerProvider(accountProvider(openai, account, onReset));
-		ctx.ui.notify(`Added ChatGPT (${label}). Run /login and pick it to sign in.`, "info");
+		ctx.ui.notify(`Added ${loginName(account)}. Run /login and pick it to sign in.`, "info");
+	};
+
+	const setLoginName = (ctx: ExtensionContext, account: Account, name: string) => {
+		const next = { ...account, name: name.trim() || undefined };
+		update((config) => ({
+			...config,
+			accounts: config.accounts.map((candidate) => (candidate.id === account.id ? next : candidate)),
+		}));
+		pi.registerProvider(accountProvider(openai, next, onReset));
+		ctx.ui.notify(`${account.label} now shows as "${loginName(next)}" in /login. Its sign-in is unchanged.`, "info");
+	};
+
+	const askLoginName = async (ctx: ExtensionContext, account: Account) => {
+		const name = await ctx.ui.input(
+			`Name shown in /login for ${account.label} (empty for "ChatGPT (${account.label})")`,
+			loginName(account),
+		);
+		if (name !== undefined) setLoginName(ctx, account, name);
 	};
 
 	const removeAccount = (ctx: ExtensionContext, account: Account) => {
@@ -352,7 +379,52 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		if (next && isStrategy(next)) setStrategy(ctx, next);
 	};
 
+	const runPanel = async (ctx: ExtensionContext) => {
+		let statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
+		while (statuses) {
+			updateStatus(ctx);
+			const current = statuses.map((status) => ({
+				...status,
+				account: accounts.find((account) => account.id === status.account.id) ?? status.account,
+			}));
+			const strategyName = STRATEGIES[strategy].split(":")[0];
+			const action = await ctx.ui.custom<PanelAction>(
+				(tui, theme, _keybindings, done) => new PoolPanel(tui, theme, current, strategyName, lastRouted, done),
+			);
+			if (!action || action.type === "close") return;
+			const status = "accountId" in action ? current.find((entry) => entry.account.id === action.accountId) : undefined;
+			let reload = false;
+			if (action.type === "refresh") {
+				reload = true;
+			} else if (action.type === "add") {
+				const label = (await ctx.ui.input("Label for the new ChatGPT account", "work"))?.trim();
+				if (label) addAccount(ctx, label);
+				reload = !!label;
+			} else if (action.type === "strategy") {
+				await chooseStrategy(ctx);
+			} else if (status && action.type === "spend") {
+				await spend(ctx, status.account, status.usage);
+				reload = true;
+			} else if (status && action.type === "name") {
+				await askLoginName(ctx, status.account);
+			} else if (status && action.type === "clear") {
+				setResetsAt(status.account.id, undefined);
+				ctx.ui.notify(`ChatGPT (${status.account.label}) is back in rotation.`, "info");
+			} else if (status && action.type === "remove") {
+				if (await ctx.ui.confirm(`Remove ${status.account.label}?`, "It will no longer be used by the pool.")) {
+					removeAccount(ctx, status.account);
+					statuses = statuses.filter((entry) => entry.account.id !== status.account.id);
+				}
+			}
+			if (reload) {
+				usageCache.clear();
+				statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
+			}
+		}
+	};
+
 	const openPool = async (ctx: ExtensionContext) => {
+		if (ctx.mode === "tui") return runPanel(ctx);
 		const statuses = await withLoader(ctx, "Checking ChatGPT accounts...", (signal) => loadStatuses(ctx, signal));
 		if (!statuses) return;
 		updateStatus(ctx);
@@ -390,12 +462,13 @@ export default function chatgptPool(pi: ExtensionAPI) {
 		{ value: "add", label: "add", description: "Add an account slot" },
 		{ value: "remove", label: "remove", description: "Remove an account" },
 		{ value: "spend", label: "spend", description: "Spend a banked reset, after confirming" },
+		{ value: "name", label: "name", description: "Set the name an account shows in /login" },
 		{ value: "reset", label: "reset", description: "Forget recorded limits" },
 		{ value: "strategy", label: "strategy", description: "Choose how new conversations pick an account" },
 	];
 
 	pi.registerCommand("chatgpt-pool", {
-		description: "Manage pooled ChatGPT accounts: usage, banked resets, strategy, add, remove, spend, reset",
+		description: "Manage pooled ChatGPT accounts: usage, banked resets, strategy, add, remove, name, spend, reset",
 		getArgumentCompletions(prefix) {
 			const [action, ...rest] = prefix.split(" ");
 			if (rest.length === 0) return SUBCOMMANDS.filter((item) => item.value.startsWith(action));
@@ -404,7 +477,8 @@ export default function chatgptPool(pi: ExtensionAPI) {
 					.filter(([name]) => name.startsWith(rest.join(" ")))
 					.map(([name, description]) => ({ value: `strategy ${name}`, label: name, description }));
 			}
-			if (action !== "remove" && action !== "spend") return null;
+			if (action !== "remove" && action !== "spend" && action !== "name") return null;
+			if (action === "name" && rest.length > 1) return null;
 			const partial = rest.join(" ");
 			return accounts
 				.filter((account) => account.label.startsWith(partial))
@@ -425,8 +499,16 @@ export default function chatgptPool(pi: ExtensionAPI) {
 				return removeAccount(ctx, account);
 			}
 
+			if (action === "name") {
+				const [target = "", ...nameParts] = rest;
+				const account = findAccount(target);
+				if (!account) return ctx.ui.notify("Usage: /chatgpt-pool name <label> <name shown in /login>", "warning");
+				if (nameParts.length > 0 || !ctx.hasUI) return setLoginName(ctx, account, nameParts.join(" "));
+				return askLoginName(ctx, account);
+			}
+
 			if (action === "reset") {
-				update((config) => ({ ...config, accounts: config.accounts.map(({ id, label }) => ({ id, label })) }));
+				update((config) => ({ ...config, accounts: config.accounts.map((account) => ({ ...account, resetsAt: undefined })) }));
 				updateStatus(ctx);
 				return ctx.ui.notify("Cleared recorded limits. Every signed-in account is back in rotation.", "info");
 			}
@@ -451,7 +533,7 @@ export default function chatgptPool(pi: ExtensionAPI) {
 				return spend(ctx, account);
 			}
 
-			if (action) return ctx.ui.notify(`Unknown action "${action}". Use add, remove, spend, reset, or strategy.`, "warning");
+			if (action) return ctx.ui.notify(`Unknown action "${action}". Use add, remove, name, spend, reset, or strategy.`, "warning");
 			if (accounts.length === 0) {
 				const label = (await ctx.ui.input("No ChatGPT accounts yet. Label for the first one", "personal"))?.trim();
 				if (label) addAccount(ctx, label);

package/src/panel.ts

@@ -0,0 +1,112 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Key, matchesKey, truncateToWidth, type TUI, visibleWidth } from "@earendil-works/pi-tui";
+import { formatIn, formatWindow, usageBar } from "./format.ts";
+import { type Account, loginName } from "./pool.ts";
+import type { Usage } from "./usage.ts";
+
+export type AccountStatus = { account: Account; signedIn: boolean; usage?: Usage; error?: string };
+
+export type PanelAction =
+	| { type: "close" }
+	| { type: "refresh" }
+	| { type: "add" }
+	| { type: "strategy" }
+	| { type: "spend" | "clear" | "remove" | "name"; accountId: string };
+
+const ACCOUNT_KEYS = new Map<string, "spend" | "clear" | "remove" | "name">([
+	["s", "spend"],
+	["c", "clear"],
+	["d", "remove"],
+	["n", "name"],
+]);
+const POOL_KEYS = new Map<string, "refresh" | "add" | "strategy">([
+	["r", "refresh"],
+	["a", "add"],
+	["t", "strategy"],
+]);
+const BAR_WIDTH = 16;
+const HINTS = [
+	"↑↓ select · s spend reset · c clear limit · n login name · d remove · a add · t strategy · r refresh · esc close",
+	"↑↓ · s spend · c clear · n name · d remove · a add · t strategy · r refresh · esc",
+	"s spend · c clear · n name · d del · a add · esc",
+];
+
+export class PoolPanel implements Component {
+	private selected = 0;
+
+	constructor(
+		private readonly tui: TUI,
+		private readonly theme: Theme,
+		private readonly statuses: readonly AccountStatus[],
+		private readonly strategyName: string,
+		private readonly activeId: string | undefined,
+		private readonly done: (action: PanelAction) => void,
+	) {}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape) || data === "q") return this.done({ type: "close" });
+		if (matchesKey(data, Key.up) || data === "k") return this.move(-1);
+		if (matchesKey(data, Key.down) || data === "j") return this.move(1);
+		const poolAction = POOL_KEYS.get(data);
+		const accountAction = ACCOUNT_KEYS.get(data);
+		const account = this.statuses[this.selected]?.account;
+		if (poolAction) this.done({ type: poolAction });
+		else if (accountAction && account) this.done({ type: accountAction, accountId: account.id });
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const { theme } = this;
+		const rule = theme.fg("borderAccent", "─".repeat(width));
+		const lines = [
+			rule,
+			`${theme.fg("accent", theme.bold("ChatGPT pool"))}  ${theme.fg("muted", `strategy: ${this.strategyName}`)}`,
+			"",
+		];
+		if (this.statuses.length === 0) lines.push(theme.fg("muted", "No accounts yet. Press a to add one."), "");
+		this.statuses.forEach((status, index) => lines.push(...this.renderAccount(status, index === this.selected), ""));
+		const hint = HINTS.find((text) => visibleWidth(text) <= width) ?? HINTS[HINTS.length - 1];
+		lines.push(theme.fg("dim", hint), rule);
+		return lines.map((line) => truncateToWidth(line, width));
+	}
+
+	private move(delta: number): void {
+		if (this.statuses.length === 0) return;
+		this.selected = (this.selected + delta + this.statuses.length) % this.statuses.length;
+		this.tui.requestRender();
+	}
+
+	private renderAccount({ account, signedIn, usage, error }: AccountStatus, selected: boolean): string[] {
+		const { theme } = this;
+		const now = Date.now();
+		const pointer = selected ? theme.fg("accent", "› ") : "  ";
+		const name = selected ? theme.fg("accent", theme.bold(account.label)) : theme.bold(account.label);
+		const active = account.id === this.activeId ? theme.fg("muted", " (in use)") : "";
+		const limitedUntil = account.resetsAt && account.resetsAt > now ? account.resetsAt : undefined;
+		const state = !signedIn
+			? theme.fg("muted", "not signed in")
+			: limitedUntil
+				? theme.fg("warning", `limited · back in ${formatIn(limitedUntil - now)}`)
+				: theme.fg("success", "ready");
+		const banked =
+			usage && usage.banked > 0
+				? theme.fg("accent", `  ${usage.banked} banked reset${usage.banked === 1 ? "" : "s"}`) +
+					(usage.usableNow > 0 ? theme.fg("success", ` (${usage.usableNow} usable now)`) : "")
+				: "";
+		const header = `${pointer}${name}${active}  ${state}${banked}`;
+
+		if (!signedIn) return [header, theme.fg("dim", `    run /login and pick ${loginName(account)}`)];
+		if (!usage) return [header, theme.fg("dim", `    usage unavailable${error ? `: ${error}` : ""}`)];
+		return [
+			header,
+			...usage.windows.map((window) => {
+				const bar = usageBar(window.usedPercent, BAR_WIDTH);
+				const color = window.usedPercent >= 90 ? "error" : window.usedPercent >= 70 ? "warning" : "success";
+				const label = formatWindow(window.windowSeconds).padEnd(7);
+				const percent = `${Math.round(window.usedPercent)}%`.padStart(4);
+				return `    ${theme.fg("muted", label)} ${theme.fg(color, bar.filled)}${theme.fg("dim", bar.empty)} ${percent}  ${theme.fg("muted", `resets in ${formatIn(window.resetsAt - now)}`)}`;
+			}),
+		];
+	}
+}

package/src/pool.ts

@@ -1,8 +1,16 @@
-export type Account = { id: string; label: string; resetsAt?: number };
+export type Account = { id: string; label: string; name?: string; resetsAt?: number };
+
+export function loginName(account: Account): string {
+	return account.name || `ChatGPT (${account.label})`;
+}
 
 const USAGE_LIMIT = /usage.?limit|subscription_sharing_usage_limit_exceeded|insufficient_quota|quota/i;
 const RATE_LIMIT = /rate.?limit|too many requests|\b429\b/i;
 
+export function failoverMessage(label: string): string {
+	return `ChatGPT account "${label}" hit its rate limit; switching to another account in the pool.`;
+}
+
 export const USAGE_COOLDOWN_MS = 60 * 60 * 1000;
 export const RATE_COOLDOWN_MS = 60 * 1000;