@eddyskywalker/dsh-chatgpt-subscription 0.10.7 → 0.10.9

package/lib/index.js

@@ -1251,6 +1251,12 @@ var AccountPoolCore = class {
 		if (!this.isCredentialUsable(target)) throw new LlmError(`${this.hooks.displayName} 账号的凭据已被拒绝，需要重新登录。`, "AUTH", { status: 401 });
 		if (!force && (!this.shouldRefreshCredential(target, Date.now()) || !this.hooks.refresh)) return target.credentials;
 		if (!this.hooks.refresh) return target.credentials;
+		const live = await this.hooks.liveCredentialsFor?.(target).catch(() => null);
+		if (live !== null && live !== void 0 && live.advanced) {
+			target.credentials = live.credentials;
+			await this.write(data).catch(() => void 0);
+			return live.credentials;
+		}
 		let refreshed;
 		try {
 			refreshed = await this.hooks.refresh(target.credentials, fetchFn);
@@ -13612,7 +13618,7 @@ async function refreshAccessToken$1(refreshToken, options = {}) {
 	throw new KimiCodeRetryableError("Token refresh failed after retries.", lastError);
 }
 /** One in-flight refresh, so concurrent callers share a single request. */
-let inFlightRefresh$2 = null;
+let inFlightRefresh$1 = null;
 /**
 * Return a usable access token, refreshing and persisting when needed.
 *
@@ -13626,7 +13632,7 @@ async function ensureAccessToken$1(store, options = {}) {
 	const threshold = refreshThresholdMs(credentials.expiresIn);
 	if (options.force !== true && credentials.expiresAt - Date.now() > threshold) return credentials;
 	if (isRecentlyRejected(credentials.refreshToken)) throw new KimiCodeUnauthorizedError("Kimi Code rejected the stored refresh token. Sign in again from Settings > Kimi Code.");
-	if (inFlightRefresh$2 !== null) return inFlightRefresh$2;
+	if (inFlightRefresh$1 !== null) return inFlightRefresh$1;
 	const pending = (async () => {
 		try {
 			const token = await refreshAccessToken$1(credentials.refreshToken, {
@@ -13653,10 +13659,10 @@ async function ensureAccessToken$1(store, options = {}) {
 			if (error instanceof KimiCodeUnauthorizedError) rememberRejected$1(credentials.refreshToken);
 			throw error;
 		} finally {
-			inFlightRefresh$2 = null;
+			inFlightRefresh$1 = null;
 		}
 	})();
-	inFlightRefresh$2 = pending;
+	inFlightRefresh$1 = pending;
 	return pending;
 }
 let webLoginFlow = { status: "idle" };
@@ -17922,14 +17928,43 @@ const USER_AGENT = "dsh-chatgpt-subscription (+https://github.com/Aa728848/dsh-c
 /**
 * How long before expiry a token is replaced.
 *
-* The access token lives about 24 hours, and MiniMax Code refreshes the same file
-* this plugin reads, so the policy is "read-only first": a token that is still
-* comfortably valid is used exactly as stored. The margin exists only so a
-* request cannot start with a token that expires while it is in flight — it is
-* deliberately far below the token's own lifetime so the plugin does not race the
-* desktop app for a rotation it does not need.
+* The measured MiniMax Code access token lives ONE HOUR, not the day an earlier
+* note assumed, and the desktop app refreshes the same file this plugin reads, so
+* the policy is "read-only first": a token that is still comfortably valid is used
+* exactly as stored. The margin exists only so a request cannot start with a token
+* that expires while it is in flight — it is deliberately far below the token's
+* own lifetime so the plugin does not race the desktop app for a rotation it does
+* not need.
 */
 const REFRESH_MARGIN_MS$1 = 6e4;
+/**
+* How long before expiry this plugin renews the credential ON ITS OWN schedule.
+*
+* This is the constant that removes the every-hour sign-out. The access token
+* lives one hour, so a reader that only acts once the token is already inside
+* {@link REFRESH_MARGIN_MS} of expiry presents a bearer the service has already
+* stopped accepting: every hour the line dips through 401 → refresh → retry, and
+* a burst of tool calls at that boundary has two callers spend the same rotating
+* refresh token. Renewing a few minutes early moves the rotation off the boundary
+* and onto a schedule this plugin controls.
+*
+* It must stay far away from the token's lifetime for the opposite reason: a
+* margin near the lifetime would rotate on every single read and race the desktop
+* app for a rotation neither side needs. Five minutes of a sixty-minute token is
+* the balance — the rotation happens once, well before the token can be refused.
+*/
+const PRE_EXPIRY_REFRESH_MS = 5 * 6e4;
+/**
+* How long a rotation stays "recent" for other readers of the same credential.
+*
+* A refresh token rotates: the moment one holder spends it, every other holder is
+* left with a token the service has already invalidated. This window is the answer
+* — a caller that observes the credential rotating right now waits for the winner
+* to write its result back and adopts that result instead of spending a token that
+* is already gone. It is a local patience bound, not a lock: no file is created,
+* and the desktop app's own `auth.lock` is never touched.
+*/
+const CREDENTIAL_ROTATION_WAIT_MS = 15e3;
 /** Exponential backoff base for a retryable refresh failure. */
 const REFRESH_BACKOFF_BASE_MS$1 = 1e3;
 /**
@@ -19048,6 +19083,24 @@ function credentialIsFresh(credentials, now = Date.now()) {
 	return credentials.expiresAtMs - now > REFRESH_MARGIN_MS$1;
 }
 /**
+* Whether a credential should be renewed BEFORE it can be refused.
+*
+* {@link credentialIsFresh} answers "can this token be presented right now"; this
+* answers "is it worth rotating on this plugin's own schedule instead of waiting
+* for the service to say no". The two questions need different answers: the whole
+* one-hour sign-out was the second question being answered with the first, so the
+* line only ever rotated inside the last sixty seconds of a sixty-minute token —
+* exactly the window in which concurrent callers spend the same rotating refresh
+* token, and exactly the window in which a request can already be refused.
+*
+* The desktop app reads the same file and remains the first authority for it: this
+* plugin renews a few minutes early, writes the rotation back atomically, and
+* never touches the app's own `auth.lock`.
+*/
+function credentialNeedsRefresh(credentials, now = Date.now()) {
+	return credentials.expiresAtMs - now <= PRE_EXPIRY_REFRESH_MS;
+}
+/**
 * Write one file through a temporary sibling plus `rename`.
 *
 * The temporary file is created in the same directory so the rename stays on one
@@ -19079,6 +19132,188 @@ function serialize(key, operation) {
 	});
 	return result;
 }
+const rotations = /* @__PURE__ */ new Map();
+/**
+* The credential the most recent storage read produced, and when.
+*
+* The store is read on every request, and on Windows each uncached read spawns
+* DPAPI - so the reads a single turn performs are served from here. Correctness
+* rests on one property the write path enforces: a rotation is written back
+* BEFORE its caller is handed the credential, and every write lands in the same
+* `fileOperations` chain this snapshot is filled from. A cached value therefore
+* can never outlive a write - it is either the current credential or one the very
+* next write replaces.
+*
+* The window is short for the opposite kind of risk: another process (the desktop
+* app) rotates the same file on its own schedule, and this snapshot must not hide
+* that for long.
+*/
+const RECENT_READ_WINDOW_MS = 1500;
+let recentRead = null;
+function rememberCredentialRead(filePath, credentials) {
+	recentRead = {
+		at: Date.now(),
+		path: path.resolve(filePath),
+		credentials
+	};
+}
+/**
+* The credential a read of THIS file inside the window produced, if any.
+*
+* The file is part of the key because a store whose path no longer matches what the
+* snapshot was taken from has nothing to do with it: one process can hold several
+* stores, and the tests point each case at a fresh temporary home.
+*/
+function recentCredentialRead(filePath) {
+	if (recentRead === null) return null;
+	if (recentRead.path !== path.resolve(filePath) || Date.now() - recentRead.at > RECENT_READ_WINDOW_MS) {
+		recentRead = null;
+		return null;
+	}
+	return recentRead.credentials;
+}
+/**
+* Identity one credential rotation is registered under.
+*
+* Built from the same facts {@link minimaxCodePoolIdentity} uses - a native
+* record slot, or the sign-in that produced the credential - so every holder of
+* one session agrees on the key. The region is part of it because the same record
+* key in two regions is two different sessions.
+*/
+function rotationKey(credentials) {
+	if (credentials.recordKey !== null && credentials.recordKey !== "") return "native:" + credentials.region + ":" + credentials.recordKey;
+	if (credentials.loginEpoch !== "") return "signin:" + credentials.region + ":" + credentials.loginEpoch;
+	return "token:" + credentials.refreshToken;
+}
+/**
+* Whether two credentials are two generations of ONE session.
+*
+* The file this line reads holds a single record, but the plugin's own file is a
+* mirror that the pool writes for whichever account is primary — so a credential
+* read from storage may belong to a completely different account than the one a
+* caller is working on. Adopting a stranger's token would present one account's
+* session as another's, which is the one mistake this whole line must never make.
+*
+* The identity is therefore the same one {@link rotationKey} uses: a native record
+* slot, or the sign-in that produced a plugin-owned credential.
+*/
+function minimaxCodeSameCredentialSession(a, b) {
+	if (a === null || b === null) return false;
+	if (a.source !== b.source || a.region !== b.region) return false;
+	if (a.recordKey !== b.recordKey) return false;
+	if (a.recordKey === null || a.recordKey === "") return a.loginEpoch === b.loginEpoch;
+	return true;
+}
+/**
+* Whether one credential is a LATER state of another.
+*
+* The generation is the desktop app's own rotation counter and the expiry moves
+* forward with every rotation, so either being greater means the candidate is the
+* result of a rotation the baseline predates. This is also what stops a stale copy
+* from rolling a newer state back: a pool row the mirror could not write must never
+* overwrite a fresh file.
+*/
+function minimaxCodeCredentialAdvancedPast(candidate, baseline) {
+	if (candidate === null) return false;
+	if (candidate.refreshToken !== baseline.refreshToken) return candidate.generation > baseline.generation || candidate.expiresAtMs > baseline.expiresAtMs;
+	return candidate.expiresAtMs > baseline.expiresAtMs + SAME_TOKEN_ADVANCE_TOLERANCE_MS;
+}
+/**
+* How much later an expiry must be, with an unchanged refresh token, to count as a
+* renewal rather than the same credential read twice.
+*/
+const SAME_TOKEN_ADVANCE_TOLERANCE_MS = 6e4;
+/** Sleep, honouring an abort signal. */
+function rotationSleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted === true) {
+			resolve();
+			return;
+		}
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Rotate one credential, or adopt the rotation somebody else is doing.
+*
+* The distinction matters: a caller that ADOPTED a result must use the credential
+* that comes back, because the winner replaced the whole record.
+*/
+async function rotateMinimaxCodeCredential(store, credentials, perform, options = {}) {
+	const key = rotationKey(credentials);
+	const seen = credentials.refreshToken;
+	const deadline = Date.now() + CREDENTIAL_ROTATION_WAIT_MS;
+	while (true) {
+		const active = rotations.get(key);
+		if (active === void 0) break;
+		if (active.promise !== null) {
+			if (active.token === seen) return {
+				credentials: await active.promise,
+				adopted: true
+			};
+			await active.promise.catch(() => void 0);
+			break;
+		}
+		const current = await store.readFresh().catch(() => null);
+		if (minimaxCodeSameCredentialSession(current, credentials) && minimaxCodeCredentialAdvancedPast(current, credentials)) return {
+			credentials: current,
+			adopted: true
+		};
+		if (Date.now() >= deadline) break;
+		await rotationSleep(200, options.signal);
+	}
+	const latest = await store.readFresh().catch(() => null);
+	if (minimaxCodeSameCredentialSession(latest, credentials) && minimaxCodeCredentialAdvancedPast(latest, credentials)) return {
+		credentials: latest,
+		adopted: true
+	};
+	const record = {
+		token: seen,
+		expiresAtMs: credentials.expiresAtMs,
+		promise: null
+	};
+	const pending = (async () => {
+		rotations.set(key, record);
+		try {
+			const next = await perform();
+			const settled = await store.readFresh().catch(() => null);
+			if (minimaxCodeSameCredentialSession(settled, credentials) && minimaxCodeCredentialAdvancedPast(settled, credentials)) return settled;
+			const rotated = next.source === credentials.source && next.recordKey === credentials.recordKey ? next : {
+				...next,
+				source: credentials.source,
+				recordKey: credentials.recordKey,
+				buildEnv: credentials.buildEnv
+			};
+			await store.write(rotated);
+			const verified = await store.readFresh().catch(() => null);
+			if (minimaxCodeSameCredentialSession(verified, rotated) && minimaxCodeCredentialAdvancedPast(verified, rotated)) return verified;
+			return rotated;
+		} catch (error) {
+			if (error instanceof Error && error.name === "MinimaxCodeUnauthorizedError") {
+				const settled = await store.readFresh().catch(() => null);
+				if (minimaxCodeSameCredentialSession(settled, credentials) && minimaxCodeCredentialAdvancedPast(settled, credentials)) return settled;
+			}
+			throw error;
+		} finally {
+			if (rotations.get(key) === record) rotations.delete(key);
+		}
+	})();
+	pending.catch(() => void 0);
+	record.promise = pending;
+	rotations.set(key, record);
+	return {
+		credentials: await pending,
+		adopted: false
+	};
+}
 /**
 * Read the desktop app's credential document for one region.
 *
@@ -19190,9 +19425,32 @@ var MinimaxCodeCredentialStore = class {
 			return null;
 		}
 	}
-	read() {
+	async read() {
+		await this.drain();
+		const recent = recentCredentialRead(this.path());
+		if (recent !== null) return recent;
 		return serialize(this.path(), async () => await this.readNative() ?? await this.readPluginFile());
 	}
+	/** Resolve once every operation already queued for this store's file settled. */
+	drain() {
+		return fileOperations.get(path.resolve(this.path())) ?? Promise.resolve();
+	}
+	/**
+	* Read storage, ignoring the snapshot.
+	*
+	* Used by the rotation path, where the whole question is whether somebody else
+	* has already replaced the credential: a cached answer would report the very
+	* state the caller is trying to move past. This is also what makes a rotation
+	* observable at all - the desktop app's write is only visible by reading the
+	* file again.
+	*/
+	readFresh() {
+		return serialize(this.path(), async () => {
+			const stored = await this.readNative() ?? await this.readPluginFile();
+			rememberCredentialRead(this.path(), stored);
+			return stored;
+		});
+	}
 	/**
 	* The credential in force plus where it came from, in one pass.
 	*
@@ -19228,9 +19486,23 @@ var MinimaxCodeCredentialStore = class {
 	* written to the plugin's own file. Either way the write is atomic.
 	*/
 	write(credentials) {
+		const target = credentials.source === "minimax-native" && credentials.recordKey !== null ? authJsonPath(credentials.region, credentials.buildEnv) : pluginCredentialPath();
+		return serialize(target, async () => {
+			await this.writeOnce(credentials);
+			rememberCredentialRead(target, credentials);
+		});
+	}
+	/**
+	* One write, to whichever file the credential came from.
+	*
+	* Called with the destination already held by {@link write}'s `serialize`; it
+	* must NOT claim the same chain again, or the outer frame would be waiting on the
+	* inner one while the inner one waits on the outer.
+	*/
+	async writeOnce(credentials) {
 		const native = credentials.source === "minimax-native" && credentials.recordKey !== null;
 		const target = native ? authJsonPath(credentials.region, credentials.buildEnv) : pluginCredentialPath();
-		return serialize(target, async () => {
+		{
 			if (!native) {
 				await writeFileAtomic(pluginCredentialPath(), JSON.stringify(credentials, null, 2) + "\n");
 				return;
@@ -19269,7 +19541,7 @@ var MinimaxCodeCredentialStore = class {
 				generation: credentials.generation,
 				expiresAtMs: credentials.expiresAtMs
 			});
-		});
+		}
 	}
 	/**
 	* Forget the credential this plugin owns.
@@ -19283,6 +19555,7 @@ var MinimaxCodeCredentialStore = class {
 	delete() {
 		return serialize(pluginCredentialPath(), async () => {
 			await fsPromises.rm(pluginCredentialPath(), { force: true });
+			recentRead = null;
 		});
 	}
 };
@@ -19608,8 +19881,7 @@ async function requestDeviceAuthorization$1(options = {}) {
 function parseTokenResponse$1(record) {
 	const accessToken = asString$6(record.access_token);
 	if (accessToken === void 0) throw new Error("MiniMax Code token response is missing its access token");
-	const refreshToken = asString$6(record.refresh_token);
-	if (refreshToken === void 0) throw new Error("MiniMax Code token response is missing its refresh token");
+	const refreshToken = asString$6(record.refresh_token) ?? "";
 	const expiresIn = Number(record.expires_in);
 	if (!Number.isFinite(expiresIn) || expiresIn <= 0) throw new Error("MiniMax Code token response carried an invalid lifetime");
 	return {
@@ -19820,8 +20092,35 @@ function isRefreshTokenRejected(refreshToken) {
 	}
 	return true;
 }
-/** One in-flight refresh, so concurrent callers share a single rotation. */
-let inFlightRefresh$1 = null;
+/**
+* One in-flight refresh per credential, so concurrent callers share a rotation.
+*
+* Keyed on the credential the rotation started from. The module-wide promise this
+* replaced was shared by EVERY caller, which cannot be right for a pool: a second
+* account would have been handed the first account's freshly rotated token, and
+* the desktop app's own file would have been written with a stranger's session.
+*/
+const inFlightRefreshes = /* @__PURE__ */ new Map();
+/** Identity one credential's in-flight rotation is registered under. */
+function refreshFlightKey(credentials) {
+	if (credentials.recordKey !== null && credentials.recordKey !== "") return "native:" + credentials.region + ":" + credentials.recordKey;
+	if (credentials.loginEpoch !== "") return "signin:" + credentials.region + ":" + credentials.loginEpoch;
+	return "token:" + credentials.refreshToken;
+}
+/**
+* The in-flight rotation this call may join.
+*
+* ONLY one that started from the very token this caller holds. A rotation of a
+* LATER credential of the same session is not a substitute — its result belongs to
+* the caller that started it, and adopting it here would hand back a credential
+* this caller never asked for. That case is handled by re-reading the store, which
+* is where the newer credential already is.
+*/
+function joinInFlightRefresh(credentials) {
+	const active = inFlightRefreshes.get(refreshFlightKey(credentials));
+	if (active === void 0 || active.token !== credentials.refreshToken) return null;
+	return active.promise;
+}
 /** The message a user sees when the credential can no longer be renewed. */
 function signInAgainMessage(reason) {
 	return reason + " Sign in again in the MiniMax Code app, then reopen this card.";
@@ -19831,47 +20130,70 @@ function signInAgainMessage(reason) {
 *
 * This is the whole of the contention discipline in one function:
 *
-* 1. read the stored credential and use it as-is while it is valid — the
-*    common case, and the one that never touches the file or the network;
-* 2. refresh only when it is not (or when `force` reports a 401 the service has
-*    already issued);
-* 3. share one rotation between concurrent callers, so a burst of tool calls at
-*    expiry cannot each try to rotate the same refresh token;
+* 1. read the stored credential and use it as-is while it is comfortably valid —
+*    the common case, and the one that never touches the file or the network;
+* 2. renew EARLY (PRE_EXPIRY_REFRESH_MS before expiry) rather than at the boundary
+*    the service refuses at, or when `force` reports a 401 the service has already
+*    issued;
+* 3. share one rotation between concurrent callers of the SAME credential, and go
+*    through the store's rotation registry so a rotation the desktop app is doing
+*    to the same file is waited for rather than raced;
 * 4. write the result back through the store's atomic replacement, and remember a
-*    rejected token so the next caller is told to sign in instead of retrying.
+*    rejection only when the credential on disk is still the rejected one.
+*
+* Step 4 is the one the every-hour sign-out hung on. `invalid_grant` used to be
+* recorded unconditionally, but that verdict has two possible meanings and only
+* one of them is "this sign-in is dead":
+*
+* - the token really is revoked (`invalid_grant` / `invalid_client`), which is a
+*   sign-in problem;
+* - another holder of the very same session rotated first, so the token this call
+*   presented was already spent. The service cannot tell the two apart, and the
+*   plugin must not either — so it looks at the file. A credential newer than the
+*   one it presented means somebody else rotated successfully, and that credential
+*   is adopted instead of being buried under a tombstone.
 */
 async function ensureAccessToken$2(store, options = {}) {
 	const credentials = await store.read();
 	if (credentials === null) throw new MinimaxCodeUnauthorizedError(signInAgainMessage("Not signed in to MiniMax Code."));
-	if (options.force !== true && credentialIsFresh(credentials)) return credentials;
-	if (isRefreshTokenRejected(credentials.refreshToken)) throw new MinimaxCodeUnauthorizedError(signInAgainMessage("MiniMax Code rejected the stored refresh token " + redactToken(credentials.refreshToken) + "."));
-	if (inFlightRefresh$1 !== null) return inFlightRefresh$1;
+	if (options.force !== true && !credentialNeedsRefresh(credentials)) return credentials;
+	if (isRefreshTokenRejected(credentials.refreshToken)) {
+		const current = await store.readFresh().catch(() => null);
+		if (current !== null && current.refreshToken !== credentials.refreshToken) return current;
+		throw new MinimaxCodeUnauthorizedError(signInAgainMessage("MiniMax Code rejected the stored refresh token " + redactToken(credentials.refreshToken) + "."));
+	}
+	const joined = joinInFlightRefresh(credentials);
+	if (joined !== null) return joined;
 	const pending = (async () => {
-		try {
+		return (await rotateMinimaxCodeCredential(store, credentials, async () => {
 			const token = await refreshAccessToken$2(credentials.refreshToken, {
 				fetchFn: options.fetchFn,
 				signal: options.signal,
 				region: credentials.region
 			});
-			const next = {
+			return {
 				...credentials,
 				accessToken: token.accessToken,
-				refreshToken: token.refreshToken,
+				refreshToken: token.refreshToken === "" ? credentials.refreshToken : token.refreshToken,
 				tokenType: token.tokenType,
 				expiresAtMs: token.expiresAtMs,
 				generation: credentials.generation + 1,
 				seenAt: Date.now()
 			};
-			await store.write(next);
-			return next;
-		} catch (error) {
-			if (error instanceof MinimaxCodeUnauthorizedError) rememberRejected(credentials.refreshToken);
-			throw error;
-		} finally {
-			inFlightRefresh$1 = null;
+		}, { signal: options.signal })).credentials;
+	})().catch(async (error) => {
+		if (error instanceof MinimaxCodeUnauthorizedError) {
+			const current = await store.readFresh().catch(() => null);
+			if (current === null || current.refreshToken === credentials.refreshToken) rememberRejected(credentials.refreshToken);
 		}
-	})();
-	inFlightRefresh$1 = pending;
+		throw error;
+	}).finally(() => {
+		if (inFlightRefreshes.get(refreshFlightKey(credentials))?.promise === pending) inFlightRefreshes.delete(refreshFlightKey(credentials));
+	});
+	inFlightRefreshes.set(refreshFlightKey(credentials), {
+		token: credentials.refreshToken,
+		promise: pending
+	});
 	return pending;
 }
 /**
@@ -20196,12 +20518,24 @@ const QUOTA_FAILURE_CACHE_MS = 10 * 6e4;
 /** Local timeout for one usage read. */
 const QUOTA_TIMEOUT_MS = 8e3;
 let quotaHostInForce = null;
+/**
+* The last usage snapshot, plus the last failure to have one.
+*
+* `value` and `reason` are tracked SEPARATELY from the last GOOD value on
+* purpose. A read that fails carries no information about the previous one, so
+* replacing a good snapshot with `null` turned every transient refusal into a
+* visible disappearance of the quota box; `quotaLastGood` lets the card keep
+* showing the last known numbers while saying they are old.
+*/
 let quotaSnapshot = null;
+/** The last snapshot that actually parsed, kept across failures. */
+let quotaLastGood = null;
 /** How long a refused credential is remembered before asking again. */
 const QUOTA_REJECTED_CACHE_MS = 30 * 6e4;
 /** Forget the cached usage snapshot (a sign-out, a sign-in, a test). */
 function clearCachedQuota$4() {
 	quotaSnapshot = null;
+	quotaLastGood = null;
 	quotaHostInForce = null;
 }
 /** The last usage snapshot without touching the network. */
@@ -20330,13 +20664,14 @@ async function fetchTokenPlanQuota(credentials, options = {}) {
 	const fetchFn = options.fetchFn ?? fetch;
 	const now = Date.now();
 	if (options.force !== true && quotaSnapshot !== null) {
-		const ttl = quotaSnapshot.reason === "credential-not-accepted" ? QUOTA_REJECTED_CACHE_MS : quotaSnapshot.value === null ? QUOTA_FAILURE_CACHE_MS : QUOTA_CACHE_MS;
+		const ttl = quotaSnapshot.reason === "credential-not-accepted" ? QUOTA_REJECTED_CACHE_MS : quotaSnapshot.reason === "token-expired" && quotaSnapshot.value === null ? QUOTA_FAILURE_CACHE_MS : quotaSnapshot.value === null ? QUOTA_FAILURE_CACHE_MS : QUOTA_CACHE_MS;
 		if (now - quotaSnapshot.at < ttl) return quotaSnapshot.value;
 	}
 	const candidates = quotaHostCandidates(credentials.region);
 	const ordered = quotaHostInForce === null ? candidates : [quotaHostInForce, ...candidates.filter((host) => host !== quotaHostInForce)];
 	let value = null;
 	let reason = null;
+	let authRefused = false;
 	for (const host of ordered) try {
 		const remainsPath = TOKEN_PLAN_REMAINS_PATH;
 		const response = await fetchFn(tokenPlanRemainsUrl(host), {
@@ -20344,6 +20679,11 @@ async function fetchTokenPlanQuota(credentials, options = {}) {
 			headers: quotaRequestHeaders(credentials.accessToken, remainsPath),
 			signal: withTimeout$1(options.signal, QUOTA_TIMEOUT_MS)
 		});
+		if (response.status === 401 || response.status === 403) {
+			if (await options.isCredentialStale?.() === true) return null;
+			authRefused = true;
+			break;
+		}
 		if (!response.ok) continue;
 		const payload = await response.json().catch(() => void 0);
 		if (numberOr$2(asRecord$5(asRecord$5(payload)?.base_resp)?.status_code, 0) !== 0) {
@@ -20357,7 +20697,22 @@ async function fetchTokenPlanQuota(credentials, options = {}) {
 		reason = null;
 		break;
 	} catch {}
-	if (value === null && reason === null) reason = "unreachable";
+	if (value === null && authRefused && options.renewCredential !== void 0) {
+		const renewed = await options.renewCredential().catch(() => null);
+		if (renewed !== null && renewed.accessToken !== credentials.accessToken) return fetchTokenPlanQuota(renewed, {
+			...options,
+			force: true
+		});
+	}
+	if (value === null && reason === null) reason = authRefused ? "token-expired" : "unreachable";
+	if (value !== null) quotaLastGood = {
+		value,
+		at: Date.now()
+	};
+	else if (quotaLastGood !== null) {
+		value = quotaLastGood.value;
+		reason = "stale";
+	}
 	quotaSnapshot = {
 		at: Date.now(),
 		value,
@@ -20884,6 +21239,15 @@ function projectAccount(input) {
 		...facts.planName === void 0 ? {} : { planName: facts.planName }
 	};
 }
+/**
+* Whether an account row carries an auth failure the card would render.
+*
+* Takes the summary shape as well as the pool row, because both the card's list
+* and the routing read ask the same question about it.
+*/
+function isMarkedFailed(account) {
+	return account.authStatus !== void 0 && account.authStatus !== "ok";
+}
 /** The alias an account is labelled with when the user has not named it. */
 function defaultAliasFor$1(credentials, position) {
 	const email = displayFacts(credentials).email;
@@ -21004,23 +21368,25 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 				isPrimary
 			}),
 			expiresAt: (credentials) => credentials.expiresAtMs,
-			needsRefresh: (credentials, now) => !credentialIsFresh(credentials, now),
+			needsRefresh: (credentials, now) => credentialNeedsRefresh(credentials, now),
 			refresh: async (credentials, fetchFn) => {
-				const token = await refreshAccessToken$2(credentials.refreshToken, {
-					fetchFn,
-					region: credentials.region
-				});
-				const next = {
-					...credentials,
-					accessToken: token.accessToken,
-					refreshToken: token.refreshToken,
-					tokenType: token.tokenType,
-					expiresAtMs: token.expiresAtMs,
-					generation: credentials.generation + 1,
-					seenAt: Date.now()
-				};
-				if (next.source === "minimax-native" && next.recordKey !== null) await store.write(next).catch(() => void 0);
-				return next;
+				return (await rotateMinimaxCodeCredential(store, credentials, async () => {
+					const token = await refreshAccessToken$2(credentials.refreshToken, {
+						fetchFn,
+						region: credentials.region
+					});
+					const next = {
+						...credentials,
+						accessToken: token.accessToken,
+						refreshToken: token.refreshToken === "" ? credentials.refreshToken : token.refreshToken,
+						tokenType: token.tokenType,
+						expiresAtMs: token.expiresAtMs,
+						generation: credentials.generation + 1,
+						seenAt: Date.now()
+					};
+					if (next.source === "minimax-native" && next.recordKey !== null) await store.write(next).catch(() => void 0);
+					return next;
+				})).credentials;
 			},
 			refreshFailureStatus: (error) => error instanceof MinimaxCodeUnauthorizedError ? "expired" : void 0,
 			authRejectedReason: (credentials) => isRefreshTokenRejected(credentials.refreshToken) ? "MiniMax Code 已拒绝该账号的刷新令牌，需要重新登录。" : void 0,
@@ -21059,6 +21425,7 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 					}
 				};
 			},
+			liveCredentialsFor: (account) => this.nativeAuthority(account),
 			emptyMessage: "Not signed in to MiniMax Code. Sign in with the MiniMax Code app, or add an account from Settings > MiniMax Code.",
 			...options.backend === void 0 ? {} : { backend: options.backend },
 			...options.maxAccounts === void 0 ? {} : { maxAccounts: options.maxAccounts }
@@ -21067,6 +21434,74 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 		this.store = store;
 	}
 	/**
+	* Account summaries, with a false auth failure cleared.
+	*
+	* A row can carry an `authStatus` of expired for a rotation that actually
+	* succeeded — the second of two concurrent rotations of one session gets a final
+	* verdict for a token the first already spent. Nobody comes back to clear that
+	* marker, so the account stays out of rotation until the user presses 重新登录.
+	*
+	* The verdict is re-checked against the token in force instead: a row whose
+	* credential has moved on since the failure is routable again, and the marker is
+	* removed. A row still holding the refused token keeps its marker, because that
+	* one really does need a sign-in.
+	*/
+	async listAccounts() {
+		const summaries = await super.listAccounts();
+		if (!summaries.some(isMarkedFailed)) return summaries;
+		await this.healStaleAuthFailures().catch(() => void 0);
+		return await super.listAccounts();
+	}
+	/**
+	* Pick an account, healing a stale auth failure first.
+	*
+	* The healing matters here, not only on the card: an account marked expired is
+	* excluded by the core's eligibility rule, so until the marker is gone the line
+	* answers a single-account pool with "all accounts need a new sign-in" — for a
+	* rotation that succeeded. Doing it on the request path means the very next
+	* request after a false refusal routes normally instead of waiting for the card's
+	* next poll.
+	*/
+	async getEffectiveAccount(excludeIds, fetchFn = fetch) {
+		const data = await this.read();
+		if (data.accounts.some(isMarkedFailed)) await this.healStaleAuthFailures(data).catch(() => void 0);
+		return await super.getEffectiveAccount(excludeIds, fetchFn);
+	}
+	/**
+	* Drop an `authStatus` that describes a credential this machine no longer holds.
+	*
+	* A row can be marked expired by a rotation that actually SUCCEEDED: the refresh
+	* token is single-use, so when two callers of one session rotate at the same time
+	* the loser is told `invalid_grant` for a token the winner already spent. That is
+	* a verdict about a spent generation, not about the sign-in — and nothing else in
+	* the system ever revisits it, which is why the account stayed parked at
+	* "需要重新登录" until the user pressed a button.
+	*
+	* The verdict is re-checked against the credential in force: if the stored
+	* credential for the same session has moved on, the marker was about the old
+	* token and is removed. A row still holding the refused token keeps its marker,
+	* because that one genuinely needs a sign-in.
+	*/
+	async healStaleAuthFailures(current) {
+		const data = current ?? await this.read();
+		if (!data.accounts.some(isMarkedFailed)) return false;
+		const live = await this.store.read().catch(() => null);
+		if (live === null) return false;
+		let changed = false;
+		for (const account of data.accounts) {
+			if (account.authStatus === void 0 || account.authStatus === "ok") continue;
+			if (!minimaxCodeSameCredentialSession(live, account.credentials)) continue;
+			if (!minimaxCodeCredentialAdvancedPast(live, account.credentials)) continue;
+			account.authStatus = void 0;
+			account.authFailedReason = void 0;
+			account.credentials = live;
+			changed = true;
+		}
+		if (!changed) return false;
+		await this.write(data).catch(() => void 0);
+		return true;
+	}
+	/**
 	* Pick the account for the next request.
 	*
 	* The returned credential carries its own region and record key, so a caller
@@ -21095,6 +21530,24 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 	* pair back, and reading the pre-refresh file would undo it.
 	*/
 	async liveNativeCredential(account) {
+		const found = await this.nativeAuthority(account);
+		return found === null || !found.advanced ? null : found.credentials;
+	}
+	/**
+	* The desktop app's own copy of one native account's session, and whether it has
+	* moved on from the row's copy.
+	*
+	* The app rotates its token on its own schedule, so the copy the pool adopted can
+	* be older than what is on disk. Only the same record slot counts: a different
+	* record key or region is a different account, and substituting it would present
+	* one account's token as another's.
+	*
+	* `advanced` is the whole reason this does not simply return the file: an
+	* EXPIRED file is not newer authority (that is the app's session having lapsed),
+	* while one that has moved on from the row is. The row's refresh token was spent
+	* by whichever side rotated last, and only the file can say what replaced it.
+	*/
+	async nativeAuthority(account) {
 		if (account.source !== "minimax-native") return null;
 		const recordKey = account.credentials.recordKey;
 		if (recordKey === null || recordKey === "") return null;
@@ -21102,7 +21555,10 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 		if (stored === null || stored.source !== "minimax-native") return null;
 		if (stored.recordKey !== recordKey || stored.region !== account.credentials.region) return null;
 		if (!credentialIsFresh(stored)) return null;
-		return stored;
+		return {
+			credentials: stored,
+			advanced: stored.refreshToken !== account.credentials.refreshToken
+		};
 	}
 	/**
 	* Adopt the sign-in the desktop app currently holds into the pool.
@@ -21373,11 +21829,21 @@ function registerMinimaxCodeRoutes(ctx, store = new MinimaxCodeCredentialStore()
 	* network, and the status route reads the snapshot through the cache instead.
 	*/
 	const refreshQuota = async (force) => {
-		const credentials = await store.read().catch(() => null);
+		const credentials = await (options.accountPool === void 0 ? ensureAccessToken$2(store, { fetchFn }).catch(() => null) : options.accountPool.getFreshCredential(void 0, fetchFn).catch(() => null));
 		if (credentials === null) return null;
+		const readToken = credentials.refreshToken;
+		const isCredentialStale = async () => {
+			const live = await store.readFresh().catch(() => null);
+			return live !== null && live.refreshToken !== readToken;
+		};
 		return await fetchTokenPlanQuota(credentials, {
 			fetchFn,
-			force
+			force,
+			isCredentialStale,
+			renewCredential: async () => await (options.accountPool === void 0 ? ensureAccessToken$2(store, {
+				fetchFn,
+				force: true
+			}) : options.accountPool.renewCredential(void 0, fetchFn)).catch(() => null)
 		}).catch(() => null);
 	};
 	/**
@@ -36317,13 +36783,204 @@ function installRelayProbe(ctx, options) {
 	};
 }
 //#endregion
+//#region src/host/reasoning-collapse-guard/index.ts
+const DEFAULT_GUARD_OPTIONS = {
+	windowChars: 4096,
+	minWindowChars: 1500,
+	threshold: .85,
+	ngramSize: 8,
+	maxBreaksPerTurn: 3,
+	cooldownMs: 3e4,
+	includeModels: [],
+	now: () => Date.now()
+};
+function pruneUndefined(options) {
+	const result = {};
+	for (const [key, value] of Object.entries(options)) if (value !== void 0) result[key] = value;
+	return result;
+}
+/**
+* Validate caller options fail-loud and fill in defaults. A threshold outside
+* (0,1), a minimum above the window, or a non-positive budget throws rather
+* than falling back to a value nobody chose.
+*/
+function resolveGuardOptions(options = {}) {
+	const resolved = {
+		...DEFAULT_GUARD_OPTIONS,
+		...pruneUndefined(options)
+	};
+	if (!Number.isInteger(resolved.windowChars) || resolved.windowChars < 1) throw new Error(`reasoning-collapse-guard: invalid windowChars ${String(resolved.windowChars)} — must be an integer >= 1`);
+	if (!Number.isInteger(resolved.ngramSize) || resolved.ngramSize < 2) throw new Error(`reasoning-collapse-guard: invalid ngramSize ${String(resolved.ngramSize)} — must be an integer >= 2`);
+	if (!Number.isInteger(resolved.minWindowChars) || resolved.minWindowChars < 1) throw new Error(`reasoning-collapse-guard: invalid minWindowChars ${String(resolved.minWindowChars)} — must be an integer >= 1`);
+	if (resolved.minWindowChars > resolved.windowChars) throw new Error(`reasoning-collapse-guard: invalid minWindowChars ${resolved.minWindowChars} — must not exceed windowChars ${resolved.windowChars}`);
+	if (resolved.windowChars < resolved.ngramSize) throw new Error(`reasoning-collapse-guard: windowChars ${resolved.windowChars} is smaller than ngramSize ${resolved.ngramSize}`);
+	if (!Number.isFinite(resolved.threshold) || resolved.threshold <= 0 || resolved.threshold >= 1) throw new Error(`reasoning-collapse-guard: invalid threshold ${String(resolved.threshold)} — must be strictly between 0 and 1`);
+	if (!Number.isInteger(resolved.maxBreaksPerTurn) || resolved.maxBreaksPerTurn < 1) throw new Error(`reasoning-collapse-guard: invalid maxBreaksPerTurn ${String(resolved.maxBreaksPerTurn)} — must be an integer >= 1`);
+	if (!Number.isInteger(resolved.cooldownMs) || resolved.cooldownMs < 0) throw new Error(`reasoning-collapse-guard: invalid cooldownMs ${String(resolved.cooldownMs)} — must be an integer >= 0`);
+	if (!Array.isArray(resolved.includeModels) || resolved.includeModels.some((entry) => typeof entry !== "string")) throw new Error("reasoning-collapse-guard: includeModels must be an array of strings");
+	if (typeof resolved.now !== "function") throw new Error("reasoning-collapse-guard: now must be a function");
+	return resolved;
+}
+/**
+* `1 - uniqueNgrams / totalNgrams` over the window.
+*
+* Scored over the whole window: a degenerate stream repeats within its own
+* trailing characters, so scoring part of the window would dilute the signal.
+* @param window - trailing reasoning characters.
+* @param n - n-gram size.
+* @returns collapse score in [0,1]; 0 means every n-gram is unique.
+*/
+function collapseScore(window, n) {
+	if (window.length < n) return 0;
+	const grams = /* @__PURE__ */ new Set();
+	let total = 0;
+	for (let i = 0; i + n <= window.length; i++) {
+		grams.add(window.slice(i, i + n));
+		total++;
+	}
+	if (total === 0) return 0;
+	return 1 - grams.size / total;
+}
+const RESUME_HINT = "Your previous reasoning became repetitive and was stopped before it finished. Resume from what you already established instead of restarting the analysis, and keep the rest of this response short.";
+/** The second resume message, used once a resume has also collapsed. */
+const RESUME_HINT_STRICT = "Your reasoning has now repeated across two attempts. Do not re-derive the analysis a third time. Either state the conclusion you already reached, or make the single next tool call that moves the task forward. Keep this response to a few sentences.";
+function createBreakerState() {
+	return {
+		breaksThisTurn: 0,
+		lastBreakAt: -Infinity,
+		exhausted: false,
+		resuming: false
+	};
+}
+/**
+* The resume message is a literal user message so the guard loads on every
+* generation without importing a generation-bound message factory.
+*/
+function createResumeMessage(text) {
+	return {
+		role: "user",
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+}
+function appendWindow(current, addition, limit) {
+	const combined = current + addition;
+	return combined.length > limit ? combined.slice(-limit) : combined;
+}
+/**
+* Install the reasoning-collapse guard on a Context.
+*
+* The guard is inert unless the host exposes the `llm/stream` seam, so a
+* harness without it keeps the built-in behaviour instead of failing this
+* plugin's load.
+*
+* Resuming needs the live Agent for `cancel` and `steer`, and no supported
+* generation hands the agent to `llm/stream`. `agent/created` reports it on
+* every one of them, so the guard tracks the newest agent and keys the per-turn
+* break budget on the request's own abort signal — which exists for a whole
+* turn — rather than on the agent object.
+*
+* @param ctx - plugin context.
+* @param options - see {@link GuardOptions}; validated fail-loud.
+* @returns a disposer, or undefined when the seam is unavailable.
+*/
+function installReasoningCollapseGuard(ctx, options = {}) {
+	const resolved = resolveGuardOptions(options);
+	const runtime = ctx.llm;
+	if (runtime === void 0 || typeof runtime.stream !== "function") return void 0;
+	const original = runtime.stream;
+	const watched = new Set(resolved.includeModels);
+	const breakers = /* @__PURE__ */ new WeakMap();
+	let currentAgent;
+	const releaseAgent = typeof ctx.on === "function" ? ctx.on("agent/created", ({ agent }) => {
+		currentAgent = agent;
+	}) : void 0;
+	function breakerFor(key) {
+		let state = breakers.get(key);
+		if (state === void 0) {
+			state = createBreakerState();
+			breakers.set(key, state);
+		}
+		return state;
+	}
+	function watchedModel(model) {
+		if (watched.size === 0) return true;
+		return model !== void 0 && watched.has(model);
+	}
+	/**
+	* Stop the attempt and queue at most one resume for the turn.
+	*
+	* The resume is queued on a microtask because cancellation may discard
+	* steering submitted while a turn is still unwinding; by the time the
+	* microtask runs the abort has settled, so the wake lands on a fresh turn that
+	* inherits the kept inbox.
+	*/
+	function breakOff(state, score) {
+		state.breaksThisTurn++;
+		state.lastBreakAt = resolved.now();
+		ctx.logger?.warn(`reasoning-collapse-guard: stopped degenerate reasoning (score ${score.toFixed(3)}, break ${state.breaksThisTurn}/${resolved.maxBreaksPerTurn})`);
+		const agent = currentAgent;
+		agent?.cancel?.({
+			kind: "hook",
+			reason: "reasoning-collapse-guard"
+		}, { keepInbox: true });
+		if (agent === void 0 || state.resuming) return;
+		state.resuming = true;
+		const text = state.breaksThisTurn >= 2 ? RESUME_HINT_STRICT : RESUME_HINT;
+		queueMicrotask(() => {
+			state.resuming = false;
+			agent.steer?.(createResumeMessage(text));
+		});
+	}
+	runtime.stream = function reasoningCollapseGuardStream(request, next) {
+		const state = breakerFor(request.signal ?? STATIC_KEY);
+		if (state.exhausted || !watchedModel(request.model)) return next();
+		async function* guarded() {
+			let window = "";
+			for await (const chunk of next()) {
+				if (chunk.type === "block-start") window = "";
+				if (chunk.type === "reasoning-delta" && typeof chunk.text === "string") {
+					window = appendWindow(window, chunk.text, resolved.windowChars);
+					if (window.length >= resolved.minWindowChars && resolved.now() - state.lastBreakAt >= resolved.cooldownMs) {
+						const score = collapseScore(window, resolved.ngramSize);
+						if (score >= resolved.threshold) if (state.breaksThisTurn >= resolved.maxBreaksPerTurn) state.exhausted = true;
+						else {
+							breakOff(state, score);
+							return;
+						}
+					}
+				}
+				yield chunk;
+			}
+		}
+		return guarded();
+	};
+	return () => {
+		runtime.stream = original;
+		releaseListener(releaseAgent);
+	};
+}
+/** Shared key for the rare request that carries no abort signal. */
+const STATIC_KEY = {};
+/** Cordis event handles are either a disposer function or a disposable object. */
+function releaseListener(handle) {
+	if (typeof handle === "function") {
+		handle();
+		return;
+	}
+	handle?.dispose?.();
+}
+//#endregion
 //#region src/index.ts
 const Config = z.object({
 	syncAgentPresets: z.boolean().default(true),
 	subagentModelAuthorization: z.boolean().default(true),
 	subagentModelTools: z.array(z.string()).default([]),
 	subagentModelInheritTools: z.array(z.string()).default(DEFAULT_SUBAGENT_INHERIT_TOOLS),
-	subagentModelScope: z.union([z.const("session"), z.const("preference")]).default("session")
+	subagentModelScope: z.union([z.const("session"), z.const("preference")]).default("session"),
+	reasoningCollapseGuard: z.union([z.object({}), z.const(false)]).default({})
 });
 const inject = [
 	"webServer",
@@ -36388,6 +37045,17 @@ function apply(ctx, pluginConfig = {}) {
 			});
 		}, "dsh-chatgpt-subscription: subagent model authorization");
 	});
+	if (pluginConfig.reasoningCollapseGuard !== false) {
+		const guardOptions = pluginConfig.reasoningCollapseGuard ?? {};
+		ctx.effect(() => {
+			const dispose = installReasoningCollapseGuard(ctx, guardOptions);
+			if (dispose === void 0) {
+				ctx.logger.warn("[dsh-chatgpt-subscription] reasoning-collapse guard skipped: this harness exposes no llm/stream seam");
+				return () => void 0;
+			}
+			return dispose;
+		}, "dsh-chatgpt-subscription: reasoning collapse guard");
+	}
 	const probeEnvFile = relayProbeEnvFile();
 	if (relayProbeEnabled(process.env, { envFile: probeEnvFile })) {
 		const probePath = relayProbeLogPath(process.env, { envFile: probeEnvFile });
@@ -36716,4 +37384,4 @@ function localWebServerBaseUrl(host, port) {
 	return `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}`;
 }
 //#endregion
-export { AccountPoolCore, AccountPoolStore, AntigravityAdapter, ADOPTED_CREDENTIAL_EXPIRED_HINT as CLAUDE_ADOPTED_CREDENTIAL_EXPIRED_HINT, API_BASE as CLAUDE_API_BASE, DEFAULT_VISIBLE_MODEL_IDS as CLAUDE_DEFAULT_VISIBLE_MODELS, FALLBACK_MODELS as CLAUDE_FALLBACK_MODELS, MESSAGES_PATH as CLAUDE_MESSAGES_PATH, CLAUDE_MODELS, CLAUDE_MODEL_IDS, PROVIDER_ID as CLAUDE_PROVIDER_ID, PROVIDER_NAME as CLAUDE_PROVIDER_NAME, QUOTA_CACHE_TTL_MS as CLAUDE_QUOTA_CACHE_TTL_MS, CLAUDE_REASONING_EFFORTS, ROUTE_PREFIX as CLAUDE_ROUTE_PREFIX, ClaudeAccountPool, ClaudeAdapter, FileCredentialStore as ClaudeCredentialStore, FileModelSettingsStore as ClaudeModelSettingsStore, CodexAccountPool, CodexChatGptAdapter, CommandCodeAccountPool, CommandCodeAdapter, FileCredentialStore$1 as CommandCodeCredentialStore, FileModelSettingsStore$1 as CommandCodeModelSettingsStore, Config, DEFAULT_SUBAGENT_INHERIT_TOOLS, FileCredentialStore$2 as FileCredentialStore, FileModelSettingsStore$2 as FileModelSettingsStore, KIMI_CODE_MODELS, KIMI_CODE_RETRY_POLICY_CONFIG, KimiCodeAccountPool, KimiCodeAdapter, FileCredentialStore$3 as KimiCodeCredentialStore, FileModelSettingsStore$3 as KimiCodeModelSettingsStore, LinuxFileTokenStore, AGENT_LLM_PREFIX as MINIMAX_CODE_AGENT_LLM_PREFIX, MESSAGES_PATH$1 as MINIMAX_CODE_MESSAGES_PATH, MINIMAX_CODE_MODELS, PROBE_MODEL as MINIMAX_CODE_PROBE_MODEL, MINIMAX_CODE_PROVIDER_ID, MINIMAX_CODE_PROVIDER_NAME, MINIMAX_CODE_REASONING_EFFORTS, REGION_HOSTS as MINIMAX_CODE_REGION_HOSTS, MINIMAX_CODE_RETRY_POLICY_CONFIG, MINIMAX_CODE_ROUTE_PREFIX, MacKeychainTokenStore, MinimaxCodeAccountPool, MinimaxCodeAdapter, MinimaxCodeCheckinService, MinimaxCodeCredentialStore, MinimaxCodeModelSettingsStore, OAuthService, ProxyManager, RELAY_PROBE_ENV, RELAY_PROBE_FILE_ENV, RELAY_PROBE_FILE_NAME, RELAY_PROBE_MAX_BYTES, RELAY_SOURCE_KINDS, RelayProbe, ResponsesClient, SUBAGENT_MODEL_SELECTION_NAMESPACE, SUBAGENT_POLICY_EVENT, SearchProviderSwitcher, UsageService, FALLBACK_MODELS$1 as WORKBUDDY_MODELS, WORKBUDDY_MODEL_IDS, WindowsDpapiTokenStore, WorkBuddyAdapter, WorkBuddyCheckinService, FileCredentialStore$4 as WorkBuddyCredentialStore, FileModelSettingsStore$4 as WorkBuddyModelSettingsStore, adoptedPoolAccountKey, apply, assertRequestBodyFits as assertMinimaxCodeBodyFits, assertStreamComplete as assertMinimaxCodeStreamComplete, auditChildRoutes, auditedRoutesOf, authorizedRoutesFor, beginLogin as beginClaudeLogin, beginWebLogin as beginKimiCodeLogin, beginWebLogin$1 as beginMinimaxCodeLogin, beginWebLogin$2 as beginWebLogin, buildClaudeModelOptions, buildMinimaxCodeModelOptions, buildMinimaxRequest, cancelLogin as cancelClaudeLogin, cancelWebLogin as cancelMinimaxCodeLogin, childRoutesOf, clampOutputToContext as clampMinimaxCodeOutputToContext, classifyFailure as classifyClaudeFailure, classifyKimiFailure, classifyMinimaxFailure, classifyFailure$1 as classifyWorkBuddyFailure, claudeCliVersion, claudeCodeCredentialPaths, claudeCodeCredentialPresence, codeForFailure as claudeCodeForFailure, credentialPath as claudeCredentialPath, defaultContextWindowFor as claudeDefaultContextWindow, maxOutputTokensFor as claudeMaxOutputTokens, claudeModelCanDisableThinking, modelSettingsPath as claudeModelSettingsPath, claudeModelSupportsImage, claudeModelSupportsTemperature, claudePoolPath, claudeReasoningEfforts, claudeThinkingMode, toLlmError as claudeToLlmError, clearCachedQuota, clearCachedCatalog as clearClaudeCatalog, clearCachedQuota$1 as clearClaudeQuota, clearCachedQuota$2 as clearCommandCodeQuota, clearCachedQuota$3 as clearKimiCodeQuota, clearCachedQuota$4 as clearMinimaxCodeQuota, clearCachedCatalog$1 as clearWorkBuddyCatalog, clearCachedQuota$5 as clearWorkBuddyQuota, closeMinimaxStream, codeBuddyAuthDir, codexPoolPath, commandCodeAccountKey, credentialPath$1 as commandCodeCredentialPath, modelSettingsPath$1 as commandCodeModelSettingsPath, commandCodePoolPath, contextWindowForModel, createCodexFetchProvider, createCodexImageTool, createCodexSearchProvider, createFileRelayProbeSink, createMinimaxCodeAccountsHandler, createMessage as createMinimaxCodeMessage, createPkcePair as createMinimaxCodePkcePair, createStreamState as createMinimaxCodeStreamState, createPlatformTokenStore, createSubagentAuthorization, credentialPath$2 as credentialPath, delegationDenialReason, delegationModeOf, describeCredentials as describeMinimaxCodeCredentials, detectSystemProxy, dshHomeDir, effectiveRouteOf, ensureAccessToken as ensureClaudeAccessToken, ensureAccessToken$1 as ensureKimiCodeAccessToken, ensureAccessToken$2 as ensureMinimaxCodeAccessToken, fetchAccountQuota, fetchAccountQuota$1 as fetchClaudeQuota, fetchAccountQuota$2 as fetchCommandCodeQuota, fetchAccountQuota$3 as fetchKimiCodeQuota, fetchUserInfo as fetchKimiCodeUserInfo, fetchTokenPlanQuota as fetchMinimaxCodeQuota, fetchAccountQuota$4 as fetchWorkBuddyQuota, getCachedQuota, getLoginStatus as getClaudeLoginStatus, getCachedQuota$1 as getClaudeQuota, getClaudeWebStatus, getWebLoginStatus as getCommandCodeLoginStatus, getCachedQuota$2 as getCommandCodeQuota, getCommandCodeWebStatus, getWebLoginStatus$1 as getKimiCodeLoginStatus, getCachedQuota$3 as getKimiCodeQuota, getKimiCodeWebStatus, getWebLogin as getMinimaxCodeLogin, getCachedQuota$4 as getMinimaxCodeQuota, getMinimaxCodeWebStatus, getCachedQuota$5 as getWorkBuddyQuota, getWorkBuddyWebStatus, inheritOverrideReason, inheritRouteDenialReason, inheritedRouteOf, inject, installRelayProbe, installSubagentModelAuthorization, isAdoptedClaudeCredential, isAdoptedCredentialExpired, isAdoptedPoolCredential, isClaudeReasoningEffort, isMinimaxCodeReasoningEffort, isRefreshTokenRejected as isMinimaxCodeRefreshTokenRejected, isThinkingDisabledEffort, credentialPath$3 as kimiCodeCredentialPath, kimiCodeModelDef, modelSettingsPath$2 as kimiCodeModelSettingsPath, kimiCodePoolPath, listModelIds as listMinimaxCodeModelIds, loadCatalog as loadClaudeCatalog, loadProviderModels as loadCommandCodeModels, loadProviderModels$1 as loadKimiCodeModels, loadConfigCatalog as loadWorkBuddyModels, loginAndSave, mapCodexUsage, accountFromCredentials as minimaxCodeAccountFromCredentials, accountHost as minimaxCodeAccountHost, agentBaseUrl as minimaxCodeAgentBaseUrl, authJsonPath as minimaxCodeAuthJsonPath, authStateJsonPath as minimaxCodeAuthStateJsonPath, catalogSize as minimaxCodeCatalogSize, credentialIsFresh as minimaxCodeCredentialIsFresh, effortForModel as minimaxCodeEffortForModel, minimaxHomeDir as minimaxCodeHomeDir, maxOutputTokensFor$1 as minimaxCodeMaxOutputTokens, messagesUrl as minimaxCodeMessagesUrl, minimaxCodeModelDef, minimaxCodeModelIds, minimaxCodeModelName, modelRequestHeaders as minimaxCodeModelRequestHeaders, modelSettingsPath$3 as minimaxCodeModelSettingsPath, pluginCredentialPath as minimaxCodePluginCredentialPath, minimaxCodePoolIdentity, minimaxCodePoolPath, minimaxCodePoolStatus, quotaHostCandidates as minimaxCodeQuotaHostCandidates, quotaRequestHeaders as minimaxCodeQuotaRequestHeaders, subPathOf as minimaxCodeSubPathOf, thinkingFieldFor as minimaxCodeThinkingField, tokenPlanRemainsUrl as minimaxCodeTokenPlanRemainsUrl, modelSettingsPath$4 as modelSettingsPath, normalizeDelegationToolNames, normalizeInheritToolNames, normalizeRotationStrategy, parseAllowedRoutes, parseClaudeCredentialDocument, parseClaudeCredentials, parseClaudePoolData, parseUsagePayload as parseClaudeUsagePayload, parseCodexPoolData, parseCodexUsage, parseCommandCodePoolData, parseKimiCodePoolData, parseMinimaxCodeCredentials, parseMinimaxCodePoolData, parseTokenPlanQuota as parseMinimaxCodeQuota, parseAnthropicUsage as parseMinimaxCodeUsage, parseResponsesStream, parseBilling as parseWorkBuddyBilling, parseConfigModels as parseWorkBuddyConfigModels, parseCredentialFile as parseWorkBuddyCredential, policyRoutesOf, pollWebLogin as pollMinimaxCodeLogin, probeConnection as probeClaudeConnection, processMinimaxStreamLine, readChildDescriptor, readClaudeCodeCredentials, redactToken as redactMinimaxCodeToken, refreshAntigravityToken, refreshAccessToken as refreshClaudeToken, refreshAccessToken$1 as refreshKimiCodeToken, refreshAccessToken$2 as refreshMinimaxCodeToken, refreshCredentials as refreshWorkBuddyCredentials, registerClaudePreferenceStore, registerClaudeRoutes, registerCommandCodePreferenceStore, registerCommandCodeRoutes, registerKimiCodePreferenceStore, registerKimiCodeRoutes, registerMinimaxCodePreferenceStore, registerMinimaxCodeRoutes, registerWorkBuddyPreferenceStore, registerWorkBuddyRoutes, relayProbeEnabled, relayProbeEnvFile, relayProbeEnvValue, relayProbeLogPath, requestDeviceAuthorization as requestKimiCodeDeviceAuthorization, requestDeviceAuthorization$1 as requestMinimaxCodeDeviceAuthorization, resetWebLogins as resetMinimaxCodeLogins, resolveEnabledModelIds as resolveClaudeEnabledModelIds, resolveLoginInput as resolveClaudeLoginInput, resolveClaudeModel, resolveRegion as resolveKimiCodeRegion, resolveMinimaxCodeEnabledModelIds, resolveQuotaCounts as resolveMinimaxCodeQuotaCounts, resolveWorkBuddyModel, revokeToken as revokeMinimaxCodeToken, saveApiKey as saveCommandCodeApiKey, scanCredentials as scanWorkBuddyCredentials, setClaudeCliVersion, beginWebLogin$3 as startCommandCodeLogin, subagentModelSelectionPreference, submitLoginInput as submitClaudeLoginInput, summarizeFailureBody as summarizeMinimaxCodeFailureBody, testConnection as testMinimaxCodeConnection, unauthorizedRouteReason, validateAuthorizationScope, validateDelegationToolNames, validateInheritToolNames, violationText, modelSettingsPath$5 as workBuddyModelSettingsPath, modelsForRegion as workBuddyModelsForRegion };
+export { AccountPoolCore, AccountPoolStore, AntigravityAdapter, ADOPTED_CREDENTIAL_EXPIRED_HINT as CLAUDE_ADOPTED_CREDENTIAL_EXPIRED_HINT, API_BASE as CLAUDE_API_BASE, DEFAULT_VISIBLE_MODEL_IDS as CLAUDE_DEFAULT_VISIBLE_MODELS, FALLBACK_MODELS as CLAUDE_FALLBACK_MODELS, MESSAGES_PATH as CLAUDE_MESSAGES_PATH, CLAUDE_MODELS, CLAUDE_MODEL_IDS, PROVIDER_ID as CLAUDE_PROVIDER_ID, PROVIDER_NAME as CLAUDE_PROVIDER_NAME, QUOTA_CACHE_TTL_MS as CLAUDE_QUOTA_CACHE_TTL_MS, CLAUDE_REASONING_EFFORTS, ROUTE_PREFIX as CLAUDE_ROUTE_PREFIX, ClaudeAccountPool, ClaudeAdapter, FileCredentialStore as ClaudeCredentialStore, FileModelSettingsStore as ClaudeModelSettingsStore, CodexAccountPool, CodexChatGptAdapter, CommandCodeAccountPool, CommandCodeAdapter, FileCredentialStore$1 as CommandCodeCredentialStore, FileModelSettingsStore$1 as CommandCodeModelSettingsStore, Config, DEFAULT_GUARD_OPTIONS, DEFAULT_SUBAGENT_INHERIT_TOOLS, FileCredentialStore$2 as FileCredentialStore, FileModelSettingsStore$2 as FileModelSettingsStore, KIMI_CODE_MODELS, KIMI_CODE_RETRY_POLICY_CONFIG, KimiCodeAccountPool, KimiCodeAdapter, FileCredentialStore$3 as KimiCodeCredentialStore, FileModelSettingsStore$3 as KimiCodeModelSettingsStore, LinuxFileTokenStore, AGENT_LLM_PREFIX as MINIMAX_CODE_AGENT_LLM_PREFIX, MESSAGES_PATH$1 as MINIMAX_CODE_MESSAGES_PATH, MINIMAX_CODE_MODELS, PROBE_MODEL as MINIMAX_CODE_PROBE_MODEL, MINIMAX_CODE_PROVIDER_ID, MINIMAX_CODE_PROVIDER_NAME, MINIMAX_CODE_REASONING_EFFORTS, REGION_HOSTS as MINIMAX_CODE_REGION_HOSTS, MINIMAX_CODE_RETRY_POLICY_CONFIG, MINIMAX_CODE_ROUTE_PREFIX, MacKeychainTokenStore, MinimaxCodeAccountPool, MinimaxCodeAdapter, MinimaxCodeCheckinService, MinimaxCodeCredentialStore, MinimaxCodeModelSettingsStore, OAuthService, ProxyManager, RELAY_PROBE_ENV, RELAY_PROBE_FILE_ENV, RELAY_PROBE_FILE_NAME, RELAY_PROBE_MAX_BYTES, RELAY_SOURCE_KINDS, RESUME_HINT, RESUME_HINT_STRICT, RelayProbe, ResponsesClient, SUBAGENT_MODEL_SELECTION_NAMESPACE, SUBAGENT_POLICY_EVENT, SearchProviderSwitcher, UsageService, FALLBACK_MODELS$1 as WORKBUDDY_MODELS, WORKBUDDY_MODEL_IDS, WindowsDpapiTokenStore, WorkBuddyAdapter, WorkBuddyCheckinService, FileCredentialStore$4 as WorkBuddyCredentialStore, FileModelSettingsStore$4 as WorkBuddyModelSettingsStore, adoptedPoolAccountKey, apply, assertRequestBodyFits as assertMinimaxCodeBodyFits, assertStreamComplete as assertMinimaxCodeStreamComplete, auditChildRoutes, auditedRoutesOf, authorizedRoutesFor, beginLogin as beginClaudeLogin, beginWebLogin as beginKimiCodeLogin, beginWebLogin$1 as beginMinimaxCodeLogin, beginWebLogin$2 as beginWebLogin, buildClaudeModelOptions, buildMinimaxCodeModelOptions, buildMinimaxRequest, cancelLogin as cancelClaudeLogin, cancelWebLogin as cancelMinimaxCodeLogin, childRoutesOf, clampOutputToContext as clampMinimaxCodeOutputToContext, classifyFailure as classifyClaudeFailure, classifyKimiFailure, classifyMinimaxFailure, classifyFailure$1 as classifyWorkBuddyFailure, claudeCliVersion, claudeCodeCredentialPaths, claudeCodeCredentialPresence, codeForFailure as claudeCodeForFailure, credentialPath as claudeCredentialPath, defaultContextWindowFor as claudeDefaultContextWindow, maxOutputTokensFor as claudeMaxOutputTokens, claudeModelCanDisableThinking, modelSettingsPath as claudeModelSettingsPath, claudeModelSupportsImage, claudeModelSupportsTemperature, claudePoolPath, claudeReasoningEfforts, claudeThinkingMode, toLlmError as claudeToLlmError, clearCachedQuota, clearCachedCatalog as clearClaudeCatalog, clearCachedQuota$1 as clearClaudeQuota, clearCachedQuota$2 as clearCommandCodeQuota, clearCachedQuota$3 as clearKimiCodeQuota, clearCachedQuota$4 as clearMinimaxCodeQuota, clearCachedCatalog$1 as clearWorkBuddyCatalog, clearCachedQuota$5 as clearWorkBuddyQuota, closeMinimaxStream, codeBuddyAuthDir, codexPoolPath, collapseScore, commandCodeAccountKey, credentialPath$1 as commandCodeCredentialPath, modelSettingsPath$1 as commandCodeModelSettingsPath, commandCodePoolPath, contextWindowForModel, createCodexFetchProvider, createCodexImageTool, createCodexSearchProvider, createFileRelayProbeSink, createMinimaxCodeAccountsHandler, createMessage as createMinimaxCodeMessage, createPkcePair as createMinimaxCodePkcePair, createStreamState as createMinimaxCodeStreamState, createPlatformTokenStore, createSubagentAuthorization, credentialPath$2 as credentialPath, delegationDenialReason, delegationModeOf, describeCredentials as describeMinimaxCodeCredentials, detectSystemProxy, dshHomeDir, effectiveRouteOf, ensureAccessToken as ensureClaudeAccessToken, ensureAccessToken$1 as ensureKimiCodeAccessToken, ensureAccessToken$2 as ensureMinimaxCodeAccessToken, fetchAccountQuota, fetchAccountQuota$1 as fetchClaudeQuota, fetchAccountQuota$2 as fetchCommandCodeQuota, fetchAccountQuota$3 as fetchKimiCodeQuota, fetchUserInfo as fetchKimiCodeUserInfo, fetchTokenPlanQuota as fetchMinimaxCodeQuota, fetchAccountQuota$4 as fetchWorkBuddyQuota, getCachedQuota, getLoginStatus as getClaudeLoginStatus, getCachedQuota$1 as getClaudeQuota, getClaudeWebStatus, getWebLoginStatus as getCommandCodeLoginStatus, getCachedQuota$2 as getCommandCodeQuota, getCommandCodeWebStatus, getWebLoginStatus$1 as getKimiCodeLoginStatus, getCachedQuota$3 as getKimiCodeQuota, getKimiCodeWebStatus, getWebLogin as getMinimaxCodeLogin, getCachedQuota$4 as getMinimaxCodeQuota, getMinimaxCodeWebStatus, getCachedQuota$5 as getWorkBuddyQuota, getWorkBuddyWebStatus, inheritOverrideReason, inheritRouteDenialReason, inheritedRouteOf, inject, installReasoningCollapseGuard, installRelayProbe, installSubagentModelAuthorization, isAdoptedClaudeCredential, isAdoptedCredentialExpired, isAdoptedPoolCredential, isClaudeReasoningEffort, isMinimaxCodeReasoningEffort, isRefreshTokenRejected as isMinimaxCodeRefreshTokenRejected, isThinkingDisabledEffort, credentialPath$3 as kimiCodeCredentialPath, kimiCodeModelDef, modelSettingsPath$2 as kimiCodeModelSettingsPath, kimiCodePoolPath, listModelIds as listMinimaxCodeModelIds, loadCatalog as loadClaudeCatalog, loadProviderModels as loadCommandCodeModels, loadProviderModels$1 as loadKimiCodeModels, loadConfigCatalog as loadWorkBuddyModels, loginAndSave, mapCodexUsage, accountFromCredentials as minimaxCodeAccountFromCredentials, accountHost as minimaxCodeAccountHost, agentBaseUrl as minimaxCodeAgentBaseUrl, authJsonPath as minimaxCodeAuthJsonPath, authStateJsonPath as minimaxCodeAuthStateJsonPath, catalogSize as minimaxCodeCatalogSize, credentialIsFresh as minimaxCodeCredentialIsFresh, effortForModel as minimaxCodeEffortForModel, minimaxHomeDir as minimaxCodeHomeDir, maxOutputTokensFor$1 as minimaxCodeMaxOutputTokens, messagesUrl as minimaxCodeMessagesUrl, minimaxCodeModelDef, minimaxCodeModelIds, minimaxCodeModelName, modelRequestHeaders as minimaxCodeModelRequestHeaders, modelSettingsPath$3 as minimaxCodeModelSettingsPath, pluginCredentialPath as minimaxCodePluginCredentialPath, minimaxCodePoolIdentity, minimaxCodePoolPath, minimaxCodePoolStatus, quotaHostCandidates as minimaxCodeQuotaHostCandidates, quotaRequestHeaders as minimaxCodeQuotaRequestHeaders, subPathOf as minimaxCodeSubPathOf, thinkingFieldFor as minimaxCodeThinkingField, tokenPlanRemainsUrl as minimaxCodeTokenPlanRemainsUrl, modelSettingsPath$4 as modelSettingsPath, normalizeDelegationToolNames, normalizeInheritToolNames, normalizeRotationStrategy, parseAllowedRoutes, parseClaudeCredentialDocument, parseClaudeCredentials, parseClaudePoolData, parseUsagePayload as parseClaudeUsagePayload, parseCodexPoolData, parseCodexUsage, parseCommandCodePoolData, parseKimiCodePoolData, parseMinimaxCodeCredentials, parseMinimaxCodePoolData, parseTokenPlanQuota as parseMinimaxCodeQuota, parseAnthropicUsage as parseMinimaxCodeUsage, parseResponsesStream, parseBilling as parseWorkBuddyBilling, parseConfigModels as parseWorkBuddyConfigModels, parseCredentialFile as parseWorkBuddyCredential, policyRoutesOf, pollWebLogin as pollMinimaxCodeLogin, probeConnection as probeClaudeConnection, processMinimaxStreamLine, readChildDescriptor, readClaudeCodeCredentials, redactToken as redactMinimaxCodeToken, refreshAntigravityToken, refreshAccessToken as refreshClaudeToken, refreshAccessToken$1 as refreshKimiCodeToken, refreshAccessToken$2 as refreshMinimaxCodeToken, refreshCredentials as refreshWorkBuddyCredentials, registerClaudePreferenceStore, registerClaudeRoutes, registerCommandCodePreferenceStore, registerCommandCodeRoutes, registerKimiCodePreferenceStore, registerKimiCodeRoutes, registerMinimaxCodePreferenceStore, registerMinimaxCodeRoutes, registerWorkBuddyPreferenceStore, registerWorkBuddyRoutes, relayProbeEnabled, relayProbeEnvFile, relayProbeEnvValue, relayProbeLogPath, requestDeviceAuthorization as requestKimiCodeDeviceAuthorization, requestDeviceAuthorization$1 as requestMinimaxCodeDeviceAuthorization, resetWebLogins as resetMinimaxCodeLogins, resolveEnabledModelIds as resolveClaudeEnabledModelIds, resolveLoginInput as resolveClaudeLoginInput, resolveClaudeModel, resolveGuardOptions, resolveRegion as resolveKimiCodeRegion, resolveMinimaxCodeEnabledModelIds, resolveQuotaCounts as resolveMinimaxCodeQuotaCounts, resolveWorkBuddyModel, revokeToken as revokeMinimaxCodeToken, saveApiKey as saveCommandCodeApiKey, scanCredentials as scanWorkBuddyCredentials, setClaudeCliVersion, beginWebLogin$3 as startCommandCodeLogin, subagentModelSelectionPreference, submitLoginInput as submitClaudeLoginInput, summarizeFailureBody as summarizeMinimaxCodeFailureBody, testConnection as testMinimaxCodeConnection, unauthorizedRouteReason, validateAuthorizationScope, validateDelegationToolNames, validateInheritToolNames, violationText, modelSettingsPath$5 as workBuddyModelSettingsPath, modelsForRegion as workBuddyModelsForRegion };