dsh-agy 0.3.0 → 0.3.2

package/README.md

@@ -20,8 +20,8 @@ fingerprinting, and both CLI and web management.
   rate limits, per-account cooldown to the real reset time, per-account device
   fingerprints.
 - **Inline Settings UI**: an Antigravity section inside DSH Settings with four
-  tabs — accounts (login, activation, per-model quota bars, test calls,
-  fingerprint and proxy management), models (per-model visibility), usage
+  tabs — accounts (login, activation, grouped 5-hour/weekly quota windows, test
+  calls, fingerprint and proxy management), models (per-model visibility), usage
   (cumulative token and request statistics), and credentials (import/export).
   No separate page: the surface only exists where DSH Settings does.
 - **Model visibility toggles**: hide individual models from the DSH model
@@ -37,10 +37,14 @@ fingerprinting, and both CLI and web management.
 
 ## Screenshots
 
-The Antigravity section inside DSH Settings — accounts, per-model quota, and
-one-shot model tests:
+The Antigravity section inside DSH Settings. Account emails and project names are
+redacted.
 
-![dsh-agy settings](https://raw.githubusercontent.com/chaos-03x/dsh-agy/main/assets/screenshot_en.png)
+| Accounts | Models |
+|:---:|:---:|
+| ![accounts](https://raw.githubusercontent.com/chaos-03x/dsh-agy/main/assets/en_accounts.png) | ![models](https://raw.githubusercontent.com/chaos-03x/dsh-agy/main/assets/en_models.png) |
+| **Limits** — 5-hour and weekly windows | **Usage** — cumulative, per-model and per-account |
+| ![limits](https://raw.githubusercontent.com/chaos-03x/dsh-agy/main/assets/en_limits.png) | ![usage](https://raw.githubusercontent.com/chaos-03x/dsh-agy/main/assets/en_usage.png) |
 
 ## Quickstart
 
@@ -193,6 +197,26 @@ reset with headroom left are used first ("use it or lose it"), near-exhausted
 families are avoided, and exhausted families block the account until the real
 reset time.
 
+Each family is measured on **both** of its windows, because they refill on
+different clocks:
+
+| Window | Refills | Exhausted when | Blocks until |
+|---|---|---|---|
+| Rolling 5-hour | every 5 hours | below 15% left | the 5-hour reset |
+| Weekly | every 7 days | 1% or less left | the **weekly** reset |
+
+The two gates are independent. A family can sit at 90% of its 5-hour budget
+while its week is spent — four 5-hour refills do not return a weekly budget —
+so a week-exhausted account is rotated away instead of being selected and
+failing. The thresholds are deliberately different (15% of five hours is ~45
+minutes of runway; 1% of a week is ~1.7 hours): judging the 5-hour window too
+late costs a wait of at most five hours, while judging the week too late parks
+the account for days.
+
+The weekly reading comes only from `retrieveUserQuotaSummary` — the per-model
+`fetchAvailableModels` probe has no window field at all — and a probe that
+reports neither window cannot erase a known-drained one.
+
 429 (Too Many Requests) responses:
 
 | Category | Behavior |

package/lib/{accounts-CkaHhb5H.mjs → accounts-CKWybAfc.mjs}

@@ -1,4 +1,4 @@
-import { _ as setResolvedAgyVersion, a as AGY_PLATFORM_ENUM, b as isProxyRouted, d as antigravityUserAgent, g as resolveAgyClientCredentials, l as OAUTH_TOKEN_URL, p as currentAgyVersion, t as AGY_CLIENT_ID, v as AgyAuthError, y as AgyPoolBlockedError } from "./constants-Db4tmyfb.mjs";
+import { _ as setResolvedAgyVersion, a as AGY_PLATFORM_ENUM, b as QUOTA_WINDOWS, d as antigravityUserAgent, g as resolveAgyClientCredentials, l as OAUTH_TOKEN_URL, p as currentAgyVersion, t as AGY_CLIENT_ID, v as AgyAuthError, x as isProxyRouted, y as AgyPoolBlockedError } from "./constants-BpyRirvk.mjs";
 import { a as probeFetch, l as redactCredentials, o as proxiedFetch, r as isProxyUnreachableError, t as accountFetch } from "./proxy-DfaL73mL.mjs";
 import { i as generateAntigravityRequestId, r as deriveAntigravitySessionId } from "./identity-Ci8EGc1F.mjs";
 import { i as parseRefreshParts, n as calculateTokenExpiry, r as formatRefreshParts, t as accessTokenExpired } from "./auth-DPPVFwio.mjs";
@@ -552,8 +552,6 @@ const BACKOFF_TIERS_MS = [
 	3e4,
 	6e4
 ];
-/** Below this remaining fraction the account is treated as soft-quota-exhausted. */
-const SOFT_QUOTA_THRESHOLD = .15;
 function backoffFor(consecutiveFailures, maxJitterMs = 1e3) {
 	const index = Math.min(Math.max(consecutiveFailures, 0), BACKOFF_TIERS_MS.length - 1);
 	return (BACKOFF_TIERS_MS[index] ?? BACKOFF_TIERS_MS[BACKOFF_TIERS_MS.length - 1]) + Math.floor(Math.random() * maxJitterMs);
@@ -725,11 +723,28 @@ function pickNextAccountIndex(accounts, currentIndex, now = Date.now(), modelOrF
 	if (enabled.length === 0) return currentIndex;
 	return (enabled.find((e) => e.index > currentIndex) ?? enabled[0]).index;
 }
-/** Build the soft-quota cache TTL: short when low, long when healthy. */
-function computeSoftQuotaCacheTtlMs(remainingFraction, now = Date.now()) {
-	if (typeof remainingFraction !== "number") return 6e5;
-	if (remainingFraction < .15) return 6e4;
-	if (remainingFraction < .5) return 3e5;
+/**
+* Build the soft-quota cache TTL: short when low, long when healthy.
+*
+* Driven by the MOST pressured of the two windows, because they drain on
+* different clocks: an account sitting at 90% of its 5-hour bucket but 2% of its
+* week still has to be re-measured on the short interval, or a weekly exhaustion
+* is discovered only when a request fails.
+*
+* `weeklyFraction` is the optional SECOND parameter, so the two fractions sit
+* adjacent.
+*
+* Takes NO timestamp on purpose: deciding which fractions are still meaningful is
+* `isQuotaStale`'s job, because a window whose reset has passed must not drive the
+* interval either. It applies that guard before calling in here, so both
+* arguments this function sees describe windows that still exist.
+*/
+function computeSoftQuotaCacheTtlMs(remainingFraction, weeklyFraction) {
+	if (typeof remainingFraction === "number" && remainingFraction < .15) return 6e4;
+	if (typeof weeklyFraction === "number" && weeklyFraction <= .01) return 6e4;
+	if (typeof remainingFraction !== "number" && typeof weeklyFraction !== "number") return 6e5;
+	if (typeof remainingFraction === "number" && remainingFraction < .5) return 3e5;
+	if (typeof weeklyFraction === "number" && weeklyFraction < .2) return 3e5;
 	return 9e5;
 }
 //#endregion
@@ -1065,12 +1080,149 @@ function earliestResetTime(a, b) {
 	return ta <= tb ? a : b;
 }
 /**
-* Aggregate a fetchAvailableModels response into per-family quota records:
-* the family's remaining fraction is its most-pressured model's, and the
-* reset time is the earliest across the family (the bottleneck resets first).
+* The families a quota group's WINDOW BUCKET ID belongs to.
+*
+* `retrieveUserQuotaSummary` labels its buckets with upstream's own counters —
+* measured ids are `gemini-5h`, `gemini-weekly`, `3p-5h`, `3p-weekly` — which
+* is the same taxonomy `modelFamilyOf` mirrors. Reading the bucket id is
+* therefore a machine-readable lookup rather than a guess at a human label.
+*
+* `3p-` maps to TWO families on purpose, and that is not a shortcut: upstream
+* counts Claude and GPT under one third-party counter, so the weekly budget
+* belongs to both. No model-id prefix rule can recover that split, which is why
+* the mapping lives here rather than in `modelFamilyOf`.
+*/
+function familiesForBucketId(bucketId) {
+	const id = bucketId.toLowerCase();
+	if (id.startsWith("gemini-")) return ["google"];
+	if (id.startsWith("3p-") || id.startsWith("third_party-")) return ["anthropic", "openai"];
+	if (id.startsWith("claude-")) return ["anthropic"];
+	if (id.startsWith("gpt-") || id.startsWith("openai-")) return ["openai"];
+	return [];
+}
+/**
+* The families a group's LABEL covers, consulted only when no bucket id was
+* recognizable.
+*
+* Upstream's groups are its own taxonomy, not ours, and the measured labels are
+* `Gemini Models` and `Claude and GPT models` — the second spans two families,
+* so this is a 1-to-N mapping. It is a FALLBACK, not the primary rule: matching
+* words in a display string is the fragile half, and it survives only so that a
+* bucket id upstream renames still lands somewhere sensible.
+*
+* A label naming nothing we recognize maps to NO family deliberately.
+* Attributing an unknown group's budget to `google` would block healthy
+* accounts; leaving it unmapped only means that family stays unmeasured, which
+* is exactly the state before this function existed.
+*/
+function familiesForGroupName(name) {
+	const label = name.toLowerCase();
+	const families = [];
+	if (label.includes("gemini") || label.includes("google")) families.push("google");
+	const claude = label.includes("claude");
+	const gpt = label.includes("gpt");
+	if (claude && gpt) families.push("anthropic", "openai");
+	else if (claude) families.push("anthropic");
+	else if (gpt) families.push("openai");
+	else if (families.length === 0 && (label.includes("3p") || label.includes("third"))) families.push("anthropic", "openai");
+	return families;
+}
+/**
+* Which of the two tracked windows an upstream token names, or `undefined` for a
+* token `CachedQuota` has no field for (`daily`, `monthly`).
+*
+* Read from `QUOTA_WINDOWS` (`types.ts`), the SAME table `adapter/quota-summary`
+* orders windows by. These were two independent tables once, and the gap between
+* them was a real defect: `daily` was orderable in the parser but unknown here, so
+* the group materialized an empty record that overwrote a live measurement. One
+* table makes that drift structurally impossible rather than merely tested for.
+*
+* Lookup is exact on the measured vocabulary (`5h`, `weekly`). A variant spelling
+* therefore classifies as unknown — which is safe, because the guard in
+* `ingestQuotaGroups` then skips the record rather than emptying it, and the
+* per-model probe still supplies the 5-hour reading.
+*/
+function windowKind(window) {
+	return QUOTA_WINDOWS[window.toLowerCase()]?.kind;
+}
+/** The families one group belongs to: its bucket ids first, its label second. */
+function familiesForGroup(group) {
+	const families = [];
+	const add = (family) => {
+		if (!families.includes(family)) families.push(family);
+	};
+	for (const window of group.windows) for (const family of familiesForBucketId(window.bucketId)) add(family);
+	if (families.length === 0) for (const family of familiesForGroupName(group.name)) add(family);
+	return families;
+}
+/**
+* Aggregate the grouped `retrieveUserQuotaSummary` windows into per-family
+* records — the ONLY source of the weekly window.
+*
+* `fetchAvailableModels` cannot supply it: its `quotaInfo` carries exactly
+* `remainingFraction` and `resetTime`, with no window field at all, which is why
+* a weekly limit used to be invisible to rotation.
+*
+* Two groups can land on one family (upstream may split `3p` later), so each
+* window keeps the MOST pressured reading rather than letting the last group
+* win — the same rule the per-model merge below uses.
+*/
+function ingestQuotaGroups(groups) {
+	const families = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const keys = familiesForGroup(group);
+		if (keys.length === 0) continue;
+		let rolling;
+		let weekly;
+		for (const window of group.windows) {
+			const kind = windowKind(window.window);
+			if (kind === "rolling") rolling ??= window;
+			else if (kind === "weekly") weekly ??= window;
+		}
+		for (const key of keys) {
+			const current = families.get(key);
+			const record = { ...current };
+			if (typeof rolling?.remainingFraction === "number") {
+				record.remainingFraction = current?.remainingFraction === void 0 ? rolling.remainingFraction : Math.min(current.remainingFraction, rolling.remainingFraction);
+				const resetTime = earliestResetTime(current?.resetTime, rolling.resetTime ?? void 0);
+				if (resetTime) record.resetTime = resetTime;
+			}
+			if (typeof weekly?.remainingFraction === "number") {
+				record.weeklyFraction = current?.weeklyFraction === void 0 ? weekly.remainingFraction : Math.min(current.weeklyFraction, weekly.remainingFraction);
+				const weeklyResetTime = earliestResetTime(current?.weeklyResetTime, weekly.resetTime ?? void 0);
+				if (weeklyResetTime) record.weeklyResetTime = weeklyResetTime;
+			}
+			if (record.remainingFraction === void 0 && record.weeklyFraction === void 0 && !current) continue;
+			families.set(key, record);
+		}
+	}
+	return Object.fromEntries(families);
+}
+/**
+* Aggregate a `fetchAvailableModels` response, and when available the grouped
+* `retrieveUserQuotaSummary` windows, into per-family quota records.
+*
+* The two sources describe the same counters from different angles, so they are
+* merged rather than kept apart:
+*   - per MODEL `quotaInfo.remainingFraction` is the rolling 5-hour counter, and
+*     the family takes its most-pressured model (the bottleneck resets first);
+*   - per GROUP summary windows add the weekly budget, which has no per-model
+*     representation at all.
+*
+* `previous` is the account's existing cache, and it exists so a probe that
+* reports only one of the two windows cannot ERASE the other. The measured
+* reason: `fetchQuotaSummary` returns `[]` instead of throwing, so without the
+* carry-forward one timing-out endpoint would drop a known-drained weekly window
+* and put an exhausted account straight back into rotation.
+*
+* Carrying that value is safe next to a fresh 5-hour reading because it keeps its
+* own `weeklyResetTime`: once that moment passes, `isFamilyDrained` and
+* `parseFutureResetMs` both ignore the reading, so a stale weekly cannot outlive
+* the window it describes.
 */
-function ingestFamilyQuotas(discovered) {
+function ingestFamilyQuotas(discovered, groups, previous) {
 	const families = /* @__PURE__ */ new Map();
+	if (groups && groups.length > 0) for (const [key, quota] of Object.entries(ingestQuotaGroups(groups))) families.set(key, { ...quota });
 	for (const [modelId, entry] of Object.entries(discovered.models ?? {})) {
 		const remaining = entry.quotaInfo?.remainingFraction;
 		if (typeof remaining !== "number" || !Number.isFinite(remaining)) continue;
@@ -1078,11 +1230,22 @@ function ingestFamilyQuotas(discovered) {
 		const current = families.get(key);
 		const resetTime = earliestResetTime(current?.resetTime, entry.quotaInfo?.resetTime);
 		families.set(key, {
-			remainingFraction: current ? Math.min(current.remainingFraction ?? 1, remaining) : remaining,
+			...current,
+			remainingFraction: current?.remainingFraction === void 0 ? remaining : Math.min(current.remainingFraction, remaining),
 			...resetTime ? { resetTime } : {},
 			modelCount: (current?.modelCount ?? 0) + 1
 		});
 	}
+	if (previous) for (const [key, prev] of Object.entries(previous)) {
+		const current = families.get(key);
+		if (prev.weeklyFraction === void 0) continue;
+		if (current?.weeklyFraction !== void 0) continue;
+		families.set(key, {
+			...current,
+			weeklyFraction: prev.weeklyFraction,
+			...current?.weeklyResetTime === void 0 && prev.weeklyResetTime !== void 0 ? { weeklyResetTime: prev.weeklyResetTime } : {}
+		});
+	}
 	return Object.fromEntries(families);
 }
 /** The quota record for one family, or the most-pressured family when the model is unknown. */
@@ -1099,7 +1262,8 @@ function familyQuotaFor(account, family) {
 /** Whether the account's quota cache needs a refresh (missing, or past its health-based TTL). */
 function isQuotaStale(account, now = Date.now()) {
 	if (!account.cachedQuota || !account.cachedQuotaUpdatedAt) return true;
-	const ttl = computeSoftQuotaCacheTtlMs(familyQuotaFor(account)?.remainingFraction);
+	const mostPressured = familyQuotaFor(account);
+	const ttl = computeSoftQuotaCacheTtlMs(resetInPast(mostPressured?.resetTime, now) ? void 0 : mostPressured?.remainingFraction, resetInPast(mostPressured?.weeklyResetTime, now) ? void 0 : mostPressured?.weeklyFraction);
 	return now - account.cachedQuotaUpdatedAt > ttl;
 }
 /** How long a measured 5h/weekly window snapshot stays fresh. */
@@ -1125,20 +1289,46 @@ function isLimitsStale(account, now = Date.now()) {
 	if (typeof updatedAt !== "number" || !Number.isFinite(updatedAt)) return true;
 	return now - updatedAt > LIMITS_CACHE_TTL_MS;
 }
-/** Whether the requested family on this account is soft-quota-exhausted (below the pre-check threshold). */
+/** Whether a reset moment has already passed. An absent or malformed one has not. */
+function resetInPast(resetTime, now) {
+	if (!resetTime) return false;
+	const reset = Date.parse(resetTime);
+	return !Number.isNaN(reset) && reset <= now;
+}
+/**
+* Whether the requested family on this account is soft-quota-exhausted.
+*
+* BOTH windows are checked, because they refill on different clocks. The 5-hour
+* bucket can be nearly empty while the weekly budget is untouched, and the
+* reverse — a spent weekly budget stays spent across four 5-hour refills. Before
+* this, only the 5-hour reading was consulted, so an account whose week was over
+* kept being selected until a real request failed.
+*
+* A window whose reset has already passed is IGNORED rather than read: its
+* fraction describes a window that no longer exists, so the account stays
+* selectable until the next measurement replaces the stale value.
+*/
 function isFamilyDrained(account, family, now = Date.now()) {
 	const quota = familyQuotaFor(account, family);
-	if (!quota || typeof quota.remainingFraction !== "number") return false;
-	if (quota.resetTime) {
-		const reset = Date.parse(quota.resetTime);
-		if (!Number.isNaN(reset) && reset <= now) return false;
-	}
-	return quota.remainingFraction < SOFT_QUOTA_THRESHOLD;
+	if (!quota) return false;
+	if (typeof quota.remainingFraction === "number" && !resetInPast(quota.resetTime, now) && quota.remainingFraction < .15) return true;
+	if (typeof quota.weeklyFraction === "number" && !resetInPast(quota.weeklyResetTime, now) && quota.weeklyFraction <= .01) return true;
+	return false;
 }
 /**
 * Required drain rate: headroomFraction / remainingHours — how fast the
 * family's remaining quota must be consumed to avoid expiring unused at its
 * reset (mirrors AuthStorage.#computeWindowRequiredDrain with a daily window).
+*
+* DELIBERATELY FIVE-HOUR ONLY, and this is a decision rather than an omission.
+* The weekly window influences `blockedUntil` and `hot` instead of the ranking
+* ORDER, because a week is not a spend-by deadline: the `DAY_MS` clamp below
+* caps the horizon at 24h, so a weekly reset ~5 days out would report ~24h of
+* urgency for a budget that cannot be spent faster to any benefit — and every
+* family would then be ranked by a number that no longer distinguishes them.
+* Making this weekly-aware therefore means replacing that clamp with a horizon
+* the weekly window can actually express, not adding a second fraction to the
+* numerator.
 */
 function requiredDrainFor(quota, now = Date.now()) {
 	const remaining = quota?.remainingFraction;
@@ -1174,13 +1364,17 @@ function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0)
 		const quota = familyQuotaFor(account, family);
 		const remaining = quota?.remainingFraction;
 		const used = typeof remaining === "number" ? Math.min(Math.max(1 - remaining, 0), 1) : void 0;
+		const weeklyRemaining = quota?.weeklyFraction;
+		const weeklyUsed = typeof weeklyRemaining === "number" ? Math.min(Math.max(1 - weeklyRemaining, 0), 1) : void 0;
 		let blockedUntil = null;
 		if (account.coolingDownUntil && account.coolingDownUntil > now) blockedUntil = account.coolingDownUntil;
 		const familyLimit = account.rateLimitResetTimes?.[familyKeyOf(modelId)];
 		if (familyLimit !== void 0 && familyLimit > now) blockedUntil = blockedUntil === null ? familyLimit : Math.max(blockedUntil, familyLimit);
-		if (blockedUntil === null && quota && typeof remaining === "number" && remaining <= 0) {
-			const resetMs = parseFutureResetMs(quota.resetTime, now);
+		if (blockedUntil === null && quota) {
+			const resetMs = typeof remaining === "number" && remaining <= 0 ? parseFutureResetMs(quota.resetTime, now) : void 0;
 			if (resetMs !== void 0) blockedUntil = resetMs;
+			const weeklyResetMs = typeof weeklyRemaining === "number" && weeklyRemaining <= 0 ? parseFutureResetMs(quota.weeklyResetTime, now) : void 0;
+			if (weeklyResetMs !== void 0) blockedUntil = blockedUntil === null ? weeklyResetMs : Math.max(blockedUntil, weeklyResetMs);
 		}
 		return {
 			account,
@@ -1189,8 +1383,8 @@ function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0)
 			blockedUntil,
 			usedFraction: used,
 			requiredDrain: requiredDrainFor(quota, now),
-			hot: used !== void 0 && used >= .85,
-			measured: used !== void 0
+			hot: used !== void 0 && used >= .85 || weeklyUsed !== void 0 && weeklyUsed >= .85,
+			measured: used !== void 0 || weeklyUsed !== void 0
 		};
 	});
 	candidates.sort((left, right) => {
@@ -1644,7 +1838,7 @@ var AgySessionManager = class AgySessionManager {
 					key,
 					ok: false
 				};
-				const { fetchQuotaSummary } = await import("./quota-summary-5CypVffd.mjs");
+				const { fetchQuotaSummary } = await import("./quota-summary-adID82I2.mjs");
 				const routed = accountFetch({ proxyUrl: account.proxy });
 				const bounded = (input, init) => {
 					const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
@@ -1716,16 +1910,19 @@ var AgySessionManager = class AgySessionManager {
 				try {
 					const auth = await this.accessTokenFor(account);
 					if (!auth) return null;
-					const { fetchAvailableModels } = await import("./models-BGuwl50d.mjs").then((n) => n.r);
+					const { fetchAvailableModels } = await import("./models-Qn0-sh6X.mjs").then((n) => n.r);
+					const { fetchQuotaSummary } = await import("./quota-summary-adID82I2.mjs");
 					const routed = accountFetch({ proxyUrl: account.proxy });
-					const quotas = ingestFamilyQuotas(await fetchAvailableModels(auth.access, account.projectId, (input, init) => {
+					const bounded = (input, init) => {
 						const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
 						const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
 						return routed(input, {
 							...init,
 							signal
 						});
-					}));
+					};
+					const [discovered, groups] = await Promise.all([fetchAvailableModels(auth.access, account.projectId, bounded), fetchQuotaSummary(auth.access, account.projectId, bounded)]);
+					const quotas = ingestFamilyQuotas(discovered, groups, account.cachedQuota);
 					return {
 						key,
 						quotas,
@@ -1795,9 +1992,13 @@ var AgySessionManager = class AgySessionManager {
 			const quotaExhausted = (account) => {
 				if (account.cooldownReason === "quota-exhausted" && (account.coolingDownUntil ?? 0) > now) return true;
 				const quota = familyQuotaFor(account, family);
-				if ((quota?.remainingFraction ?? 1) > 0 || !quota?.resetTime) return false;
-				const resetAt = Date.parse(quota.resetTime);
-				return !Number.isNaN(resetAt) && resetAt > now;
+				if (!quota) return false;
+				const spent = (fraction, resetTime) => {
+					if (typeof fraction !== "number" || fraction > 0 || !resetTime) return false;
+					const resetAt = Date.parse(resetTime);
+					return !Number.isNaN(resetAt) && resetAt > now;
+				};
+				return spent(quota.remainingFraction, quota.resetTime) || spent(quota.weeklyFraction, quota.weeklyResetTime);
 			};
 			const retryable = ranked.filter((candidate) => !quotaExhausted(candidate.account));
 			const blocked = retryable.length > 0 ? retryable : ranked;
@@ -1885,7 +2086,7 @@ var AgySessionManager = class AgySessionManager {
 			}
 			const key = this.accountKey(picked.account);
 			if (!picked.account.projectId && !this.projectRetryFailed.has(key)) try {
-				const { loadCodeAssist } = await import("./exchange-yZPIZumk.mjs").then((n) => n.n);
+				const { loadCodeAssist } = await import("./exchange-LzEyxve1.mjs").then((n) => n.n);
 				const { projectId } = await loadCodeAssist(auth.access, { proxyUrl: picked.account.proxy });
 				if (projectId) {
 					await this.store.mutate((s) => {
@@ -2041,7 +2242,7 @@ var AgySessionManager = class AgySessionManager {
 		try {
 			const account = session.account.email ?? session.account.id;
 			const { toAgyRequestBody } = await import("./translate-BQu8HLvB.mjs").then((n) => n.n);
-			const { fetchAgyFirstOk } = await import("./constants-Db4tmyfb.mjs").then((n) => n.f);
+			const { fetchAgyFirstOk } = await import("./constants-BpyRirvk.mjs").then((n) => n.f);
 			const { parseAgySse } = await import("./parse-Bs4rPkHA.mjs").then((n) => n.n);
 			const requestId = generateAntigravityRequestId();
 			const body = toAgyRequestBody({
@@ -2483,4 +2684,4 @@ var JsonAccountStore = class {
 //#endregion
 export { resolveMasterKeyCodec as _, generateFingerprint as a, describeFetchError as b, resolveAntigravityVersionBounded as c, MASTER_KEY_REF as d, createAesGcmCodec as f, resolveDshHome as g, persistMasterKey as h, isAgyDisabled as i, clearExpiredState as l, loadMasterKey as m, maskProxyUrl as n, recordFingerprintVersion as o, deriveKey as p, AgySessionManager as r, resolveAntigravityVersion as s, JsonAccountStore as t, pickProbeProxyUrl as u, classifyFetchError as v, isSessionAccumulationOverflow as x, classifyHttpError as y };
 
-//# sourceMappingURL=accounts-CkaHhb5H.mjs.map
+//# sourceMappingURL=accounts-CKWybAfc.mjs.map