dsh-agy 0.3.2 → 0.4.0

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

@@ -1091,14 +1091,23 @@ function earliestResetTime(a, b) {
 * 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`.
+*
+* Window-aware as of #56: a bucket id resolves a family only when the window it
+* describes is one `CachedQuota` can hold AND the id agrees with the token (see
+* `agreedWindowKind`). The prefix and the window were two independent decisions
+* once, and an unrecognized window still claimed a family.
 */
-function familiesForBucketId(bucketId) {
+function familiesForBucketId(bucketId, window) {
 	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 [];
+	const families = [];
+	if (id.startsWith("gemini-")) families.push("google");
+	else if (id.startsWith("3p-") || id.startsWith("third_party-")) families.push("anthropic", "openai");
+	else if (id.startsWith("claude-")) families.push("anthropic");
+	else if (id.startsWith("gpt-") || id.startsWith("openai-")) families.push("openai");
+	if (families.length === 0) return [];
+	const declared = window === void 0 ? advertisedWindowOf(id) : window.toLowerCase();
+	if (declared === void 0 || agreedWindowKind(id, declared) === void 0) return [];
+	return families;
 }
 /**
 * The families a group's LABEL covers, consulted only when no bucket id was
@@ -1124,7 +1133,6 @@ function familiesForGroupName(name) {
 	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;
 }
 /**
@@ -1145,13 +1153,44 @@ function familiesForGroupName(name) {
 function windowKind(window) {
 	return QUOTA_WINDOWS[window.toLowerCase()]?.kind;
 }
+/** The window token a bucket id advertises, when it ends with one upstream names. */
+function advertisedWindowOf(bucketId) {
+	const id = bucketId.toLowerCase();
+	const token = id.slice(id.lastIndexOf("-") + 1);
+	return QUOTA_WINDOWS[token] ? token : void 0;
+}
+/**
+* The field a window belongs in, decided from an AGREED (id, token) pair — or
+* `undefined` when the pair cannot be agreed.
+*
+* The family used to come from the bucket id's prefix while the field came from
+* the window token, as two independent decisions nothing checked against each
+* other. A bucket whose window the cache cannot hold still claimed the family,
+* and its reading was then filed by whichever field the TOKEN named. `gemini-weekly`
+* declaring `5h` is the shape that puts a multi-day weekly fraction into
+* `remainingFraction` (the 5-hour field), where `isFamilyDrained` and
+* `parseFutureResetMs` block the account for days on a window they misread.
+*
+* Refusing an unagreed pair is deliberately the strict option: the permissive
+* mapping is exactly the coupling that let two window vocabularies drift into
+* destroying a measurement. A bucket id that advertises no recognizable token is
+* held to the declared one alone, so a rename does not silently disable the cache.
+*/
+function agreedWindowKind(bucketId, window) {
+	const declared = window.toLowerCase();
+	const kind = windowKind(declared);
+	if (kind === void 0) return void 0;
+	const advertised = advertisedWindowOf(bucketId);
+	if (advertised !== void 0 && advertised !== declared) return void 0;
+	return 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);
+	for (const window of group.windows) for (const family of familiesForBucketId(window.bucketId, window.window)) add(family);
 	if (families.length === 0) for (const family of familiesForGroupName(group.name)) add(family);
 	return families;
 }
@@ -1163,9 +1202,16 @@ function familiesForGroup(group) {
 * `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.
+* Two groups can land on one family (upstream may split `3p` later), so the
+* family record keeps the MOST pressured reading of each window across those
+* groups (`Math.min` below) rather than letting the last group win — the same
+* rule the per-model merge uses.
+*
+* WITHIN one group the rule is deliberately different: `??=` keeps upstream's
+* FIRST bucket of each window, because a group is upstream's own 5h + weekly
+* pair and a duplicate would otherwise depend on upstream's ordering. "Most
+* pressured" therefore applies to two GROUPS landing on one family, not to two
+* buckets inside one group.
 */
 function ingestQuotaGroups(groups) {
 	const families = /* @__PURE__ */ new Map();
@@ -1175,7 +1221,7 @@ function ingestQuotaGroups(groups) {
 		let rolling;
 		let weekly;
 		for (const window of group.windows) {
-			const kind = windowKind(window.window);
+			const kind = agreedWindowKind(window.bucketId, window.window);
 			if (kind === "rolling") rolling ??= window;
 			else if (kind === "weekly") weekly ??= window;
 		}
@@ -1248,21 +1294,70 @@ function ingestFamilyQuotas(discovered, groups, previous) {
 	}
 	return Object.fromEntries(families);
 }
-/** The quota record for one family, or the most-pressured family when the model is unknown. */
-function familyQuotaFor(account, family) {
+/**
+* The lowest fraction a record reports across its LIVE windows — its overall
+* pressure.
+*
+* A window whose reset has already passed describes a window that no longer
+* exists, so it does not count — the same rule `isQuotaStale` applies when it
+* sizes the TTL from the selected record. Scoring a dead window would let one
+* family's expired weekly reading win the selection and represent the account,
+* masking another family's live pressure (issue #69: a dead weekly at 0.004
+* beat a live 0.2 and stretched the refresh TTL from 5 to 15 minutes).
+*
+* `undefined` means the record carries no usable LIVE reading at all, which is
+* deliberately different from a measured zero: only a real number can size a
+* refresh interval.
+*/
+function pressureScore(entry, now) {
+	const fractions = [];
+	if (typeof entry.remainingFraction === "number" && Number.isFinite(entry.remainingFraction) && !resetInPast(entry.resetTime, now)) fractions.push(entry.remainingFraction);
+	if (typeof entry.weeklyFraction === "number" && Number.isFinite(entry.weeklyFraction) && !resetInPast(entry.weeklyResetTime, now)) fractions.push(entry.weeklyFraction);
+	return fractions.length === 0 ? void 0 : Math.min(...fractions);
+}
+/**
+* The quota record for one family, or the most-pressured family when the model
+* is unknown.
+*
+* "Most pressured" compares BOTH windows and reports the record whose LOWEST
+* window is the lowest of all of them. That matters because `isQuotaStale` sizes
+* the refresh TTL from whichever record this returns: a family at 0.9 / weekly
+* 0.004 is more pressured than one at 0.2, and comparing the 5-hour fraction
+* alone picked the 0.2 record — so the weekly-driven 60s TTL was never applied
+* to the family actually being requested and a spent week was discovered late.
+*
+* A record carrying ONLY a weekly reading participates for the same reason: #48
+* produces that shape legitimately (the anthropic/openai entries of a
+* Gemini-only pool), and the old `typeof entry.remainingFraction !== 'number'`
+* guard skipped it outright, leaving the week invisible to TTL sizing.
+*
+* Selection considers LIVE windows only (`pressureScore` drops a window whose
+* reset has passed) — but the with-family path returns the record as-is either
+* way, because its consumers guard each window individually.
+*
+* @param account - the account whose cache to read.
+* @param family - the exact family's record; omit to select the most pressured.
+* @param now - current time (Unix ms), which decides whether a window is live.
+*/
+function familyQuotaFor(account, family, now = Date.now()) {
 	const cache = account.cachedQuota ?? {};
 	if (family) return cache[family];
 	let worst;
+	let worstScore;
 	for (const entry of Object.values(cache)) {
-		if (typeof entry.remainingFraction !== "number") continue;
-		if (!worst || entry.remainingFraction < (worst.remainingFraction ?? 1)) worst = entry;
+		const score = pressureScore(entry, now);
+		if (score === void 0) continue;
+		if (worstScore === void 0 || score < worstScore) {
+			worst = entry;
+			worstScore = score;
+		}
 	}
 	return worst;
 }
 /** 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 mostPressured = familyQuotaFor(account);
+	const mostPressured = familyQuotaFor(account, void 0, now);
 	const ttl = computeSoftQuotaCacheTtlMs(resetInPast(mostPressured?.resetTime, now) ? void 0 : mostPressured?.remainingFraction, resetInPast(mostPressured?.weeklyResetTime, now) ? void 0 : mostPressured?.weeklyFraction);
 	return now - account.cachedQuotaUpdatedAt > ttl;
 }
@@ -1296,26 +1391,6 @@ function resetInPast(resetTime, now) {
 	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) 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).
@@ -1350,6 +1425,32 @@ function parseFutureResetMs(resetTime, now) {
 	return reset;
 }
 /**
+* Whether the requested family on this account is effectively quota-exhausted
+* for account STEERING (affinity pins, the active-account preference): an
+* explicit quota-exhausted cooldown in force, a spent 5-hour window
+* (`remainingFraction <= 0` with a future reset), or a weekly window at or
+* below `WEEKLY_QUOTA_THRESHOLD` — a spent week refills in days, so its rule
+* mirrors `isFamilyDrained`'s weekly branch rather than the block wall.
+*
+* Deliberately a DIFFERENT predicate from the one in `pickAccount`'s `!picked`
+* branch, which applies a strict zero to BOTH windows to mirror
+* `rankPoolCandidates`' block wall when classifying `AgyPoolBlockedError`; and
+* deliberately NARROWER than `isFamilyDrained`'s 5-hour rule
+* (`SOFT_QUOTA_THRESHOLD`): account prioritization holds a chosen account
+* until it is actually spent, not until ranking would prefer another one.
+*/
+function isFamilyQuotaExhausted(account, family, now = Date.now()) {
+	if (account.cooldownReason === "quota-exhausted" && (account.coolingDownUntil ?? 0) > now) return true;
+	const quota = familyQuotaFor(account, family);
+	if (!quota) return false;
+	const spent = (fraction, resetTime, threshold = 0) => {
+		if (typeof fraction !== "number" || fraction > threshold || !resetTime) return false;
+		const resetMs = parseFutureResetMs(resetTime, now);
+		return resetMs !== void 0 && resetMs > now;
+	};
+	return spent(quota.remainingFraction, quota.resetTime, 0) || spent(quota.weeklyFraction, quota.weeklyResetTime, .01);
+}
+/**
 * Rank pool candidates for one request, mirroring AuthStorage's antigravity
 * ordering: unblocked first (earliest unblock time among blocked), hot windows
 * last, measured usage before unmeasured, required-drain descending, then
@@ -1361,10 +1462,12 @@ function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0)
 	const activePos = entries.findIndex((e) => e.index === startIndex);
 	const clampedStart = activePos >= 0 ? activePos : 0;
 	const candidates = (entries.length === 0 ? [] : [...entries.slice(clampedStart), ...entries.slice(0, clampedStart)]).map(({ account, index }, orderPos) => {
-		const quota = familyQuotaFor(account, family);
-		const remaining = quota?.remainingFraction;
+		const quota = familyQuotaFor(account, family, now);
+		const live5h = quota !== void 0 && !resetInPast(quota.resetTime, now);
+		const liveWeekly = quota !== void 0 && !resetInPast(quota.weeklyResetTime, now);
+		const remaining = live5h ? quota.remainingFraction : void 0;
 		const used = typeof remaining === "number" ? Math.min(Math.max(1 - remaining, 0), 1) : void 0;
-		const weeklyRemaining = quota?.weeklyFraction;
+		const weeklyRemaining = liveWeekly ? quota.weeklyFraction : void 0;
 		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;
@@ -1575,6 +1678,22 @@ var AgySessionManager = class AgySessionManager {
 	refreshInFlight = /* @__PURE__ */ new Map();
 	/** In-flight quota fetches keyed by account: concurrent selections share one fetchAvailableModels call. */
 	quotaRefreshInFlight = /* @__PURE__ */ new Map();
+	/**
+	* In-flight `retrieveUserQuotaSummary` probes keyed by account.
+	*
+	* ONE promise per account per cycle, shared by BOTH consumers:
+	* `refreshLimits` (display, writes `cachedLimits`) and `refreshQuotaCache`
+	* (scheduling, writes `cachedQuota`). Since #48 both read the same endpoint for
+	* the same account, so a stale account paid two round trips where one would
+	* do; `quotaRefreshInFlight` de-duplicated only WITHIN the scheduling path.
+	* Sharing makes the two caches agree on what upstream actually said.
+	*
+	* It carries the FETCH and nothing else: the invariant that `refreshLimits`
+	* must never write `cachedQuota` (which `rankPoolCandidates` turns into a
+	* `blockedUntil`) is about WHERE a result lands, and each path still decides
+	* that for itself.
+	*/
+	quotaSummaryInFlight = /* @__PURE__ */ new Map();
 	failureCounts = /* @__PURE__ */ new Map();
 	/** Accounts whose request-time project discovery already failed (no retry per request). */
 	projectRetryFailed = /* @__PURE__ */ new Set();
@@ -1682,6 +1801,28 @@ var AgySessionManager = class AgySessionManager {
 	clearAffinityForAccount(accountKey) {
 		for (const [conversation, pin] of this.affinity) if (pin.key === accountKey) this.affinity.delete(conversation);
 	}
+	/**
+	* Clear all session affinity pins.
+	*
+	* Called when an account is explicitly activated by the user, so all
+	* ongoing and upcoming conversations immediately steer to the newly
+	* activated account rather than staying pinned to the previous one.
+	*/
+	clearAllAffinity() {
+		this.affinity.clear();
+	}
+	/**
+	* Explicitly activate an account by index: sets `storage.activeIndex = index`,
+	* clears session affinity pins so conversations immediately switch to the
+	* activated account, and resets transient failure counts.
+	*/
+	async activateAccount(index) {
+		await this.store.mutate((storage) => {
+			if (index < 0 || index >= storage.accounts.length) throw new Error("account not found");
+			storage.activeIndex = index;
+		});
+		this.clearAllAffinity();
+	}
 	constructor(options) {
 		this.store = options.store;
 		this.onRotate = options.onRotate;
@@ -1786,6 +1927,49 @@ var AgySessionManager = class AgySessionManager {
 		return this.refreshToken(key, account, cached);
 	}
 	/**
+	* Probe `retrieveUserQuotaSummary` for one account, sharing ONE in-flight
+	* promise with every other caller in this cycle.
+	*
+	* Returns `[]` on any failure — the fetch itself already answers a dead
+	* endpoint with an empty list — so both consumers read "no groups" the same
+	* way. The promise is dropped as soon as it settles, so the NEXT cycle
+	* re-probes.
+	*
+	* The account's proxy is honoured here or the call would egress direct and
+	* leak the account's real IP, and one timeout bounds the whole endpoint
+	* fallback chain.
+	*/
+	probeQuotaSummary(account) {
+		const key = this.accountKey(account);
+		const existing = this.quotaSummaryInFlight.get(key);
+		if (existing) return existing;
+		const probe = (async () => {
+			try {
+				const auth = await this.accessTokenFor(account);
+				if (!auth) return [];
+				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);
+					const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+					return routed(input, {
+						...init,
+						signal
+					});
+				};
+				return await fetchQuotaSummary(auth.access, account.projectId, bounded);
+			} catch {
+				return [];
+			}
+		})();
+		this.quotaSummaryInFlight.set(key, probe);
+		const release = () => {
+			if (this.quotaSummaryInFlight.get(key) === probe) this.quotaSummaryInFlight.delete(key);
+		};
+		probe.then(release, release);
+		return probe;
+	}
+	/**
 	* Refresh the display-only 5h/weekly windows for every enabled account.
 	*
 	* SEPARATE from `refreshQuotaCache`, and deliberately so. That method writes
@@ -1833,22 +2017,7 @@ var AgySessionManager = class AgySessionManager {
 		const probes = await Promise.all(targets.map(async (account) => {
 			const key = this.accountKey(account);
 			try {
-				const auth = await this.accessTokenFor(account);
-				if (!auth) return {
-					key,
-					ok: false
-				};
-				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);
-					const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
-					return routed(input, {
-						...init,
-						signal
-					});
-				};
-				const groups = await fetchQuotaSummary(auth.access, account.projectId, bounded);
+				const groups = await this.probeQuotaSummary(account);
 				if (groups.length === 0) return {
 					key,
 					ok: false
@@ -1911,7 +2080,6 @@ var AgySessionManager = class AgySessionManager {
 					const auth = await this.accessTokenFor(account);
 					if (!auth) return null;
 					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 bounded = (input, init) => {
 						const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
@@ -1921,7 +2089,7 @@ var AgySessionManager = class AgySessionManager {
 							signal
 						});
 					};
-					const [discovered, groups] = await Promise.all([fetchAvailableModels(auth.access, account.projectId, bounded), fetchQuotaSummary(auth.access, account.projectId, bounded)]);
+					const [discovered, groups] = await Promise.all([fetchAvailableModels(auth.access, account.projectId, bounded), this.probeQuotaSummary(account)]);
 					const quotas = ingestFamilyQuotas(discovered, groups, account.cachedQuota);
 					return {
 						key,
@@ -1962,7 +2130,8 @@ var AgySessionManager = class AgySessionManager {
 	}
 	/**
 	* Pick the account for one request: the affinity pin wins while it is fresh,
-	* healthy, and not drained for the requested model; otherwise the pool is
+	* healthy, and not quota-exhausted for the requested model; the explicitly
+	* activated account wins next while it is usable; otherwise the pool is
 	* ranked by family-scoped usage (OMP-aligned) and the best candidate wins.
 	*/
 	async pickAccount(storage, model, conversationKey) {
@@ -1975,7 +2144,7 @@ var AgySessionManager = class AgySessionManager {
 			const lastIndex = storage.accounts.findIndex((a) => this.accountKey(a) === pinnedKey);
 			if (lastIndex !== -1) {
 				const last = storage.accounts[lastIndex];
-				if (last.enabled !== false && !isCoolingDown(last, now) && !isFamilyRateLimited(last, familyKey, now) && !isFamilyDrained(last, family, now)) return {
+				if (last.enabled !== false && !isCoolingDown(last, now) && !isFamilyRateLimited(last, familyKey, now) && !isFamilyQuotaExhausted(last, family, now)) return {
 					account: last,
 					index: lastIndex
 				};
@@ -1986,12 +2155,18 @@ var AgySessionManager = class AgySessionManager {
 			index
 		})).filter(({ account }) => account.enabled !== false);
 		if (eligible.length === 0) return void 0;
+		const active = storage.accounts[storage.activeIndex];
+		const isActiveUsable = (acc) => acc !== void 0 && acc.enabled !== false && !isCoolingDown(acc, now) && !isFamilyRateLimited(acc, familyKey, now) && !isFamilyQuotaExhausted(acc, family, now);
+		if (isActiveUsable(active) && this.inFlightCount(this.accountKey(active), now) < 3) return {
+			account: active,
+			index: storage.activeIndex
+		};
 		const ranked = rankPoolCandidates(eligible, model, now, storage.activeIndex);
 		const picked = ranked.find((candidate) => candidate.blockedUntil === null && this.inFlightCount(this.accountKey(candidate.account), now) < 3) ?? ranked.find((candidate) => candidate.blockedUntil === null);
 		if (!picked) {
 			const quotaExhausted = (account) => {
 				if (account.cooldownReason === "quota-exhausted" && (account.coolingDownUntil ?? 0) > now) return true;
-				const quota = familyQuotaFor(account, family);
+				const quota = familyQuotaFor(account, family, now);
 				if (!quota) return false;
 				const spent = (fraction, resetTime) => {
 					if (typeof fraction !== "number" || fraction > 0 || !resetTime) return false;
@@ -2168,6 +2343,13 @@ var AgySessionManager = class AgySessionManager {
 			if (decision.action === "revoke") {
 				this.tokenCache.delete(key);
 				this.failureCounts.delete(key);
+				const currentIndex = storage.accounts.findIndex((a) => this.accountKey(a) === key);
+				const nextIndex = pickNextAccountIndex(storage.accounts, currentIndex >= 0 ? currentIndex : storage.activeIndex, Date.now());
+				if (nextIndex !== storage.activeIndex) {
+					storage.activeIndex = nextIndex;
+					nextIndexToRotate = nextIndex;
+				}
+				this.clearAffinityForAccount(key);
 				return;
 			}
 			if (kind === "rate-limit" && info?.rateLimitCategory !== "soft_rate_limit") {
@@ -2183,7 +2365,7 @@ var AgySessionManager = class AgySessionManager {
 					}
 				}
 			}
-			if (decision.action === "rotate") {
+			if (decision.action === "rotate" || decision.action === "cool") {
 				const currentIndex = storage.accounts.findIndex((a) => this.accountKey(a) === key);
 				const familyKey = familyKeyOf(info?.model);
 				const nextIndex = pickNextAccountIndex(storage.accounts, currentIndex >= 0 ? currentIndex : storage.activeIndex, Date.now(), familyKey);
@@ -2241,7 +2423,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 { toAgyRequestBody } = await import("./translate-YhGDUuVa.mjs").then((n) => n.n);
 			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();
@@ -2684,4 +2866,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-CKWybAfc.mjs.map
+//# sourceMappingURL=accounts-BN4h0AU4.mjs.map