pi-ui-extend 1.0.41 → 1.0.45

package/dist/app/model/model-usage-controller.js

@@ -1,5 +1,12 @@
 import { MODEL_USAGE_POLL_INTERVAL_MS, MODEL_USAGE_STATUS_TICK_MS } from "../constants.js";
 import { formatModelUsageStatusLabel, modelUsageDescriptor, queryModelUsageStatus, } from "./model-usage-status.js";
+function descriptorCacheKey(descriptor) {
+    if (!descriptor)
+        return undefined;
+    if (descriptor.kind !== "google-antigravity")
+        return descriptor.modelKey;
+    return `${descriptor.modelKey}\0${(descriptor.quotaModelCandidates ?? [descriptor.quotaModelKey]).join("|")}`;
+}
 export class AppModelUsageController {
     host;
     queryUsageStatus;
@@ -38,18 +45,20 @@ export class AppModelUsageController {
     refreshNow() {
         const session = this.host.runtimeSession();
         this.syncActiveModel(session);
-        const descriptor = modelUsageDescriptor(session?.model);
+        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
         if (!descriptor)
             return { kind: "unsupported" };
         const promise = this.refresh(true, descriptor);
         return promise ? { kind: "started", promise } : { kind: "in-flight" };
     }
     tick(force = false) {
-        this.syncActiveModel(this.host.runtimeSession());
-        const descriptor = modelUsageDescriptor(this.host.runtimeSession()?.model);
+        const session = this.host.runtimeSession();
+        this.syncActiveModel(session);
+        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
         if (!descriptor)
             return;
-        const lastAttemptAt = this.lastAttemptAt.get(descriptor.modelKey) ?? 0;
+        const cacheKey = descriptorCacheKey(descriptor);
+        const lastAttemptAt = this.lastAttemptAt.get(cacheKey) ?? 0;
         if (force || Date.now() - lastAttemptAt >= MODEL_USAGE_POLL_INTERVAL_MS) {
             this.refresh(force, descriptor);
             return;
@@ -58,10 +67,11 @@ export class AppModelUsageController {
             this.host.render();
     }
     refresh(force = false, activeDescriptor) {
-        const descriptor = activeDescriptor ?? modelUsageDescriptor(this.host.runtimeSession()?.model);
+        const session = this.host.runtimeSession();
+        const descriptor = activeDescriptor ?? modelUsageDescriptor(session?.model, session?.thinkingLevel);
         if (!descriptor)
             return undefined;
-        const modelKey = descriptor.modelKey;
+        const modelKey = descriptorCacheKey(descriptor);
         if (this.inFlightModelKeys.has(modelKey))
             return undefined;
         const lastAttemptAt = this.lastAttemptAt.get(modelKey) ?? 0;
@@ -86,7 +96,7 @@ export class AppModelUsageController {
         });
     }
     syncActiveModel(session) {
-        const nextModelKey = modelUsageDescriptor(session?.model)?.modelKey;
+        const nextModelKey = descriptorCacheKey(modelUsageDescriptor(session?.model, session?.thinkingLevel));
         if (nextModelKey === this.activeModelKey)
             return false;
         this.activeModelKey = nextModelKey;

package/dist/app/model/model-usage-status.d.ts

@@ -7,6 +7,7 @@ export type ModelUsageDescriptor = BaseModelUsageDescriptor & ({
 } | {
     readonly kind: "google-antigravity";
     readonly quotaModelKey: string;
+    readonly quotaModelCandidates?: readonly string[];
     readonly account?: AntigravityQuotaAccount;
     readonly accounts?: readonly AntigravityQuotaAccount[];
 });
@@ -96,6 +97,7 @@ type AntigravityQuotaAccount = {
     readonly cachedQuota?: AntigravityCachedQuota;
     readonly cachedQuotaUpdatedAt?: number;
     readonly projectId: string;
+    readonly managedProjectId?: string;
     readonly accountIndex?: number;
     readonly accountCount?: number;
     readonly cacheKey: string;
@@ -107,8 +109,9 @@ type GoogleQuotaResponse = {
             resetTime?: string;
         };
     }>;
+    readonly source?: "cached";
 };
-export declare function modelUsageDescriptor(model: SessionModel | undefined): ModelUsageDescriptor | undefined;
+export declare function modelUsageDescriptor(model: SessionModel | undefined, thinkingLevel?: string): ModelUsageDescriptor | undefined;
 export declare function queryModelUsageStatus(descriptor: ModelUsageDescriptor): Promise<ModelUsageStatus | undefined>;
 export declare function queryAccountUsageReport(now?: number): Promise<AccountUsageReport>;
 export declare function formatAccountUsageReport(report: AccountUsageReport, now?: number): string;

package/dist/app/model/model-usage-status.js

@@ -2,31 +2,46 @@ import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { ModelRuntime, readStoredCredential } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, ModelRuntime, readStoredCredential } from "@earendil-works/pi-coding-agent";
 import { formatCompactProgressBar } from "../../context-progress-bar.js";
 import { APP_ICONS } from "../icons.js";
 const OPENAI_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 const ZHIPU_QUOTA_URL = "https://bigmodel.cn/api/monitor/usage/quota/limit";
-const GOOGLE_QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:fetchAvailableModels";
+const GOOGLE_ANTIGRAVITY_ENDPOINT_DAILY = "https://daily-cloudcode-pa.googleapis.com";
+const GOOGLE_ANTIGRAVITY_ENDPOINT_PROD = "https://cloudcode-pa.googleapis.com";
+const GOOGLE_ANTIGRAVITY_ENDPOINTS = [GOOGLE_ANTIGRAVITY_ENDPOINT_DAILY, GOOGLE_ANTIGRAVITY_ENDPOINT_PROD];
 const GOOGLE_TOKEN_REFRESH_URL = "https://oauth2.googleapis.com/token";
-const GOOGLE_ANTIGRAVITY_USER_AGENT = "antigravity/1.11.9 windows/amd64";
+const GOOGLE_ANTIGRAVITY_CLI_VERSION = "1.1.24";
+const GOOGLE_ANTIGRAVITY_CLI_CHANGE_LIST = "974782877";
 const REQUEST_TIMEOUT_MS = 10_000;
 const DAY_SECONDS = 86_400;
 const HOUR_SECONDS = 3_600;
 const MODEL_USAGE_WARNING_MIN_USED_PERCENT = 5;
 const MODEL_USAGE_WARNING_MIN_ELAPSED_SECONDS = 6 * HOUR_SECONDS;
-const PI_AUTH_PATH = join(homedir(), ".pi", "agent", "auth.json");
 const DEFAULT_ANTIGRAVITY_PROJECT_ID = "rising-fact-p41fc";
+function normalizeGoogleAntigravityPlatform(platform = process.platform) {
+    return platform === "win32" ? "windows" : platform || "unknown";
+}
+function normalizeGoogleAntigravityArch(arch = process.arch) {
+    if (arch === "x64")
+        return "amd64";
+    if (arch === "ia32")
+        return "386";
+    return arch || "unknown";
+}
+function buildGoogleAntigravityUserAgent() {
+    return `antigravity/cli/${GOOGLE_ANTIGRAVITY_CLI_VERSION} (aidev_client; os_type=${normalizeGoogleAntigravityPlatform()}; arch=${normalizeGoogleAntigravityArch()}; cl=${GOOGLE_ANTIGRAVITY_CLI_CHANGE_LIST}; auth_method=consumer)`;
+}
 function getPiAuthPath() {
     return process.env.NODE_ENV === "test" && process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
         ? process.env.PI_TOOLS_SUITE_TEST_AUTH_PATH
-        : PI_AUTH_PATH;
+        : join(getAgentDir(), "auth.json");
 }
 const OPENAI_QUOTA_PROVIDERS = new Set(["openai", "openai-codex"]);
 const ZHIPU_QUOTA_PROVIDERS = new Set(["zai", "zhipuai-coding-plan"]);
 const ANTIGRAVITY_QUOTA_PROVIDERS = new Set(["antigravity", "google-antigravity"]);
-export function modelUsageDescriptor(model) {
+export function modelUsageDescriptor(model, thinkingLevel) {
     if (!model)
         return undefined;
     const provider = model.provider.toLowerCase();
@@ -40,10 +55,12 @@ export function modelUsageDescriptor(model) {
         const quotaModelKey = resolveAntigravityQuotaModelKey(model);
         if (!quotaModelKey)
             return undefined;
+        const quotaModelCandidates = antigravityQuotaModelCandidates(quotaModelKey, thinkingLevel);
         return {
             kind: "google-antigravity",
             modelKey: `${model.provider}/${model.id}`,
             quotaModelKey,
+            ...(quotaModelCandidates.length > 1 ? { quotaModelCandidates } : {}),
         };
     }
     return undefined;
@@ -395,8 +412,14 @@ export function resolveAntigravityQuotaModelKey(model) {
     if (normalized.includes("claude") && normalized.includes("opus") && normalized.includes("thinking")) {
         return "claude-opus-4-6-thinking";
     }
+    // Sonnet thinking rides the base claude-sonnet-4-6 quota bucket.
     if (normalized.includes("claude") && normalized.includes("sonnet"))
         return "claude-sonnet-4-6";
+    // Versioned flash generations get their own buckets; keep them ahead of the
+    // legacy gemini-3-flash alias so 3.5-3.8 don't collapse into it.
+    const versionedFlash = normalized.match(/gemini-3\.([5-8])-flash/u) ?? normalized.match(/\bg3\.([5-8])-flash\b/u);
+    if (versionedFlash)
+        return `gemini-3.${versionedFlash[1]}-flash`;
     if (normalized.includes("gemini-2.5-flash") || /\bg2[.-]?5-flash\b/u.test(normalized))
         return "gemini-2.5-flash";
     if (normalized.includes("gemini-3-flash") || /\bg3-flash\b/u.test(normalized))
@@ -407,10 +430,37 @@ export function resolveAntigravityQuotaModelKey(model) {
         return "gemini-3.1-pro-low";
     if (/\bg3(?:-pro)?\b/u.test(normalized))
         return "gemini-3.1-pro-low";
+    // GPT-OSS has no Google-side quota bucket; callers treat undefined as "no
+    // quota status for this model".
     return undefined;
 }
+function antigravityQuotaModelCandidates(quotaModelKey, thinkingLevel) {
+    const candidates = [quotaModelKey];
+    const level = thinkingLevel?.toLowerCase();
+    const tier = level === "high" || level === "xhigh" || level === "max"
+        ? "high"
+        : level === undefined || level === "medium"
+            ? "medium"
+            : "low";
+    const versionedFlash = quotaModelKey.match(/^gemini-3\.([5-8])-flash$/u);
+    if (versionedFlash) {
+        if (versionedFlash[1] === "5") {
+            candidates.push(tier === "high"
+                ? "gemini-3-flash-agent"
+                : tier === "medium"
+                    ? "gemini-3.5-flash-low"
+                    : "gemini-3.5-flash-extra-low");
+        }
+        else {
+            candidates.push(`${quotaModelKey}-${tier}`);
+        }
+    }
+    if (quotaModelKey === "gemini-3.1-pro-low" && tier === "high")
+        candidates.push("gemini-pro-agent");
+    return candidates;
+}
 export function googleAntigravityUsageStatusFromResponse(data, descriptor, now = Date.now()) {
-    const window = googleAntigravityWindowFromResponse(data, descriptor.quotaModelKey, now);
+    const window = googleAntigravityWindowFromResponse(data, descriptor.quotaModelKey, now, descriptor.quotaModelCandidates);
     if (!window)
         return undefined;
     const weekly = window.windowSeconds >= DAY_SECONDS ? window : undefined;
@@ -424,8 +474,13 @@ export function googleAntigravityUsageStatusFromResponse(data, descriptor, now =
         ...(hourly ? { hourly } : {}),
     };
 }
-function googleAntigravityWindowFromResponse(data, quotaModelKey, now) {
-    const quotaInfo = data.models[quotaModelKey]?.quotaInfo;
+function googleAntigravityWindowFromResponse(data, quotaModelKey, now, quotaModelCandidates = [quotaModelKey]) {
+    const quotaInfo = quotaModelCandidates
+        .map((candidate) => data.models[candidate]?.quotaInfo)
+        .find((candidate) => candidate !== undefined)
+        ?? (data.source === "cached" && /^gemini-3\.[5-8]-flash$/u.test(quotaModelKey)
+            ? data.models["gemini-3-flash"]?.quotaInfo
+            : undefined);
     if (!quotaInfo)
         return undefined;
     const resetAt = parseResetTime(quotaInfo.resetTime, now);
@@ -435,31 +490,112 @@ function googleAntigravityWindowFromResponse(data, quotaModelKey, now) {
         windowSeconds: Math.max(0, Math.round((resetAt - now) / 1000)),
     };
 }
+function googleAntigravityQuotaPoolForModel(quotaModelKey) {
+    return quotaModelKey.toLowerCase().includes("claude") ? "non-gemini" : "gemini";
+}
+function googleAntigravityQuotaPoolForBucket(bucketId) {
+    if (!bucketId)
+        return undefined;
+    if (bucketId.startsWith("gemini-"))
+        return "gemini";
+    if (bucketId.startsWith("3p-"))
+        return "non-gemini";
+    return undefined;
+}
+function googleAntigravityWindowFromSummaryBucket(bucket, now, windowSeconds) {
+    const remainingFraction = Number.isFinite(bucket.remainingFraction) ? bucket.remainingFraction : 0;
+    return {
+        remainingPercent: clampPercent(Math.round(remainingFraction * 100)),
+        resetAt: parseResetTime(bucket.resetTime, now),
+        windowSeconds,
+        hasKnownWindowDuration: true,
+    };
+}
+function mostConstrainedGoogleQuotaBucket(buckets) {
+    return buckets.reduce((best, bucket) => {
+        if (!best)
+            return bucket;
+        const bestRemaining = Number.isFinite(best.remainingFraction) ? best.remainingFraction : 0;
+        const nextRemaining = Number.isFinite(bucket.remainingFraction) ? bucket.remainingFraction : 0;
+        return nextRemaining < bestRemaining ? bucket : best;
+    }, undefined);
+}
+function googleAntigravityWindowsFromQuotaSummary(data, pool, now) {
+    const buckets = (data.groups ?? [])
+        .flatMap((group) => group.buckets ?? [])
+        .filter((bucket) => googleAntigravityQuotaPoolForBucket(bucket.bucketId) === pool);
+    const hourlyBucket = mostConstrainedGoogleQuotaBucket(buckets.filter((bucket) => bucket.window === "5h"));
+    const weeklyBucket = mostConstrainedGoogleQuotaBucket(buckets.filter((bucket) => bucket.window === "weekly"));
+    return {
+        ...(hourlyBucket ? { hourly: googleAntigravityWindowFromSummaryBucket(hourlyBucket, now, 5 * HOUR_SECONDS) } : {}),
+        ...(weeklyBucket ? { weekly: googleAntigravityWindowFromSummaryBucket(weeklyBucket, now, 7 * DAY_SECONDS) } : {}),
+    };
+}
+function aggregateGoogleAntigravityWindows(windows) {
+    if (windows.length === 0)
+        return undefined;
+    const hasKnownWindowDuration = windows.every((window) => window.hasKnownWindowDuration === true);
+    return {
+        remainingPercent: clampPercent(Math.round(windows.reduce((sum, window) => sum + window.remainingPercent, 0) / windows.length)),
+        resetAt: Math.min(...windows.map((window) => window.resetAt)),
+        windowSeconds: hasKnownWindowDuration
+            ? windows[0]?.windowSeconds ?? 0
+            : Math.min(...windows.map((window) => window.windowSeconds)),
+        ...(hasKnownWindowDuration ? { hasKnownWindowDuration: true } : {}),
+    };
+}
 async function queryGoogleAntigravityModelUsage(descriptor) {
     const now = Date.now();
-    const accounts = await readAllAntigravityQuotaAccounts();
+    const accounts = await readAllAntigravityQuotaAccounts(descriptor.modelKey);
     if (accounts.length === 0)
         return undefined;
-    const windows = (await Promise.all(accounts.map(async (account) => {
+    const pool = googleAntigravityQuotaPoolForModel(descriptor.quotaModelKey);
+    const accountWindows = (await Promise.all(accounts.map(async (account) => {
+        try {
+            const summary = await fetchGoogleAntigravityQuotaSummaryForAccount(account);
+            const summaryWindows = googleAntigravityWindowsFromQuotaSummary(summary, pool, now);
+            if (summaryWindows.hourly || summaryWindows.weekly)
+                return summaryWindows;
+        }
+        catch {
+            // Current Antigravity exposes retrieveUserQuotaSummary, but older or
+            // partially rolled-out backends may not. Fall through to the legacy
+            // per-model quota response before consulting cached provider data.
+        }
         try {
             const response = await fetchGoogleAntigravityQuotaForAccount(account, now);
-            return googleAntigravityWindowFromResponse(response, descriptor.quotaModelKey, now);
+            const liveWindow = googleAntigravityWindowFromResponse(response, descriptor.quotaModelKey, now, descriptor.quotaModelCandidates);
+            if (liveWindow)
+                return { legacy: liveWindow };
+            // Google may successfully return fetchAvailableModels while omitting
+            // the quotaInfo bucket for a current versioned Flash route. Antigravity
+            // stores the last provider-observed aggregate buckets on each account;
+            // use that cached shared Flash quota when live data has no matching key.
+            const cachedResponse = googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now);
+            const cachedWindow = cachedResponse
+                ? googleAntigravityWindowFromResponse(cachedResponse, descriptor.quotaModelKey, now, descriptor.quotaModelCandidates)
+                : undefined;
+            if (!cachedWindow)
+                return undefined;
+            return { legacy: cachedWindow };
         }
         catch {
             return undefined;
         }
-    }))).filter((window) => window !== undefined);
-    if (windows.length === 0)
+    }))).filter((windows) => windows !== undefined);
+    if (accountWindows.length === 0)
+        return undefined;
+    let hourly = aggregateGoogleAntigravityWindows(accountWindows.map((windows) => windows.hourly).filter((window) => window !== undefined));
+    let weekly = aggregateGoogleAntigravityWindows(accountWindows.map((windows) => windows.weekly).filter((window) => window !== undefined));
+    const legacy = aggregateGoogleAntigravityWindows(accountWindows.map((windows) => windows.legacy).filter((window) => window !== undefined));
+    if (!hourly && !weekly && legacy) {
+        if (legacy.windowSeconds >= DAY_SECONDS)
+            weekly = legacy;
+        else
+            hourly = legacy;
+    }
+    if (!hourly && !weekly)
         return undefined;
-    const resetAt = Math.min(...windows.map((window) => window.resetAt));
-    const windowSeconds = Math.max(0, Math.round((resetAt - now) / 1000));
-    const aggregateWindow = {
-        remainingPercent: clampPercent(Math.round(windows.reduce((sum, window) => sum + window.remainingPercent, 0) / windows.length)),
-        resetAt,
-        windowSeconds,
-    };
-    const weekly = aggregateWindow.windowSeconds >= DAY_SECONDS ? aggregateWindow : undefined;
-    const hourly = weekly ? undefined : aggregateWindow;
     return {
         modelKey: descriptor.modelKey,
         provider: "google-antigravity",
@@ -474,6 +610,10 @@ const GOOGLE_ACCOUNT_QUOTA_WINDOWS = [
     { label: "Claude Sonnet", quotaModelKey: "claude-sonnet-4-6" },
     { label: "G2.5 Flash", quotaModelKey: "gemini-2.5-flash" },
     { label: "G3 Flash", quotaModelKey: "gemini-3-flash" },
+    { label: "G3.5 Flash", quotaModelKey: "gemini-3.5-flash" },
+    { label: "G3.6 Flash", quotaModelKey: "gemini-3.6-flash" },
+    { label: "G3.7 Flash", quotaModelKey: "gemini-3.7-flash" },
+    { label: "G3.8 Flash", quotaModelKey: "gemini-3.8-flash" },
     { label: "G3 Pro", quotaModelKey: "gemini-3.1-pro-low" },
 ];
 async function queryGoogleAntigravityAccountUsage(now) {
@@ -500,8 +640,10 @@ async function queryGoogleAntigravityAccountUsage(now) {
     }));
     return results;
 }
-async function readAllAntigravityQuotaAccounts() {
-    const credential = (await readPiAuth()).antigravity;
+async function readAllAntigravityQuotaAccounts(modelKey = "antigravity/") {
+    const auth = await readPiAuth();
+    const provider = modelKey.slice(0, modelKey.indexOf("/")).toLowerCase();
+    const credential = auth[provider] ?? auth.antigravity;
     if (!credential)
         return [];
     const credentialClient = getGoogleOAuthClientCredentials(credential);
@@ -513,6 +655,7 @@ async function readAllAntigravityQuotaAccounts() {
             ...(credential.email ? { fallbackEmail: credential.email } : {}),
             ...(credentialClient ? { clientCredentials: credentialClient } : {}),
             ...(accountIndex === activeIndex && activeAccess ? { accessToken: activeAccess.accessToken } : {}),
+            ...(accountIndex === activeIndex && activeAccess?.projectId ? { accessProjectId: activeAccess.projectId } : {}),
             accountIndex,
             accountCount: accounts.length,
         })).filter((account) => account !== undefined);
@@ -523,6 +666,7 @@ async function readAllAntigravityQuotaAccounts() {
         ...(credential.email ? { fallbackEmail: credential.email } : {}),
         ...(credentialClient ? { clientCredentials: credentialClient } : {}),
         ...(fallbackAccess ? { accessToken: fallbackAccess.accessToken } : {}),
+        ...(fallbackAccess?.projectId ? { accessProjectId: fallbackAccess.projectId } : {}),
     }) : undefined;
     return account ? [account] : [];
 }
@@ -556,7 +700,10 @@ function getGoogleOAuthClientCredentials(...sources) {
         if (clientId)
             return { clientId, ...(clientSecret ? { clientSecret } : {}) };
     }
-    return undefined;
+    const clientId = process.env.PI_ANTIGRAVITY_GOOGLE_CLIENT_ID?.trim();
+    const clientSecret = process.env.PI_ANTIGRAVITY_GOOGLE_CLIENT_SECRET?.trim();
+    if (clientId)
+        return { clientId, ...(clientSecret ? { clientSecret } : {}) };
 }
 function storedAntigravityAccounts(credential) {
     return Array.isArray(credential.accounts)
@@ -585,11 +732,12 @@ function antigravityQuotaAccount(account, options = {}) {
     if (!refreshToken)
         return undefined;
     const email = account.email || options.fallbackEmail;
-    const projectId = account.projectId || account.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID;
+    const projectId = options.accessProjectId || account.projectId || account.managedProjectId || DEFAULT_ANTIGRAVITY_PROJECT_ID;
     const clientCredentials = getGoogleOAuthClientCredentials(account, options.clientCredentials);
     return {
         refreshToken,
         projectId,
+        ...(account.managedProjectId ? { managedProjectId: account.managedProjectId } : {}),
         cacheKey: email ? email.toLowerCase() : shortHash(refreshToken),
         ...(options.accessToken ? { accessToken: options.accessToken } : {}),
         ...(clientCredentials ? { clientId: clientCredentials.clientId } : {}),
@@ -608,7 +756,7 @@ function googleQuotaResponseFromCachedQuota(cachedQuota, cachedQuotaUpdatedAt, n
     addCachedQuotaModels(models, cachedQuota.claude, ["claude-opus-4-6-thinking", "claude-sonnet-4-6"], cachedQuotaUpdatedAt, now);
     addCachedQuotaModels(models, cachedQuota["gemini-flash"], ["gemini-2.5-flash", "gemini-3-flash"], cachedQuotaUpdatedAt, now);
     addCachedQuotaModels(models, cachedQuota["gemini-pro"], ["gemini-3.1-pro-low"], cachedQuotaUpdatedAt, now);
-    return Object.keys(models).length > 0 ? { models } : undefined;
+    return Object.keys(models).length > 0 ? { models, source: "cached" } : undefined;
 }
 function addCachedQuotaModels(models, quota, quotaModelKeys, cachedQuotaUpdatedAt, now) {
     if (!quota)
@@ -669,15 +817,44 @@ function shortHash(value) {
     return createHash("sha256").update(value).digest("hex").slice(0, 12);
 }
 async function fetchGoogleAntigravityQuotaForAccount(account, now = Date.now()) {
-    if (account.accessToken)
-        return await fetchGoogleAntigravityQuota(account.accessToken, account.projectId);
-    if (account.clientId) {
-        const { accessToken } = await refreshGoogleAntigravityAccessToken(account);
-        return await fetchGoogleAntigravityQuota(accessToken, account.projectId);
+    let liveError;
+    try {
+        return await fetchWithGoogleAntigravityAccountAccess(account, (accessToken) => fetchGoogleAntigravityQuota(accessToken, account.projectId));
+    }
+    catch (error) {
+        liveError = error;
     }
     const cachedResponse = googleQuotaResponseFromCachedQuota(account.cachedQuota, account.cachedQuotaUpdatedAt, now);
     if (cachedResponse)
         return cachedResponse;
+    if (liveError)
+        throw liveError;
+    throw new Error("Missing Google OAuth client credentials, cannot query live Antigravity quota.");
+}
+async function fetchGoogleAntigravityQuotaSummaryForAccount(account) {
+    return await fetchWithGoogleAntigravityAccountAccess(account, (accessToken) => fetchGoogleAntigravityQuotaSummary(accessToken, account));
+}
+async function fetchWithGoogleAntigravityAccountAccess(account, fetcher) {
+    let lastError;
+    if (account.accessToken) {
+        try {
+            return await fetcher(account.accessToken);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (account.clientId) {
+        try {
+            const { accessToken } = await refreshGoogleAntigravityAccessToken(account);
+            return await fetcher(accessToken);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (lastError)
+        throw lastError;
     throw new Error("Missing Google OAuth client credentials, cannot query live Antigravity quota.");
 }
 async function refreshGoogleAntigravityAccessToken(account) {
@@ -704,21 +881,68 @@ async function refreshGoogleAntigravityAccessToken(account) {
         throw new Error("Google token refresh did not return an access token.");
     return { accessToken: data.access_token };
 }
+function googleAntigravityQuotaHeaders(accessToken) {
+    return {
+        "User-Agent": buildGoogleAntigravityUserAgent(),
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "Accept-Encoding": "gzip",
+    };
+}
+async function fetchGoogleAntigravityQuotaSummary(accessToken, account) {
+    const errors = [];
+    const primaryProjectId = account.managedProjectId || account.projectId;
+    let primaryGot403 = false;
+    const tryProject = async (projectId) => {
+        for (const endpoint of GOOGLE_ANTIGRAVITY_ENDPOINTS) {
+            const response = await fetchWithTimeout(`${endpoint}/v1internal:retrieveUserQuotaSummary`, {
+                method: "POST",
+                headers: googleAntigravityQuotaHeaders(accessToken),
+                body: JSON.stringify({ project: projectId }),
+            });
+            if (response.ok)
+                return response.json();
+            if (response.status === 403)
+                primaryGot403 = true;
+            const errorText = await response.text().catch(() => "");
+            errors.push(`retrieveUserQuotaSummary ${response.status} at ${endpoint}${errorText ? `: ${errorText.slice(0, 200)}` : ""}`);
+        }
+        return undefined;
+    };
+    const primary = await tryProject(primaryProjectId);
+    if (primary)
+        return primary;
+    if (primaryGot403 && account.managedProjectId && account.projectId !== account.managedProjectId) {
+        const fallback = await tryProject(account.projectId);
+        if (fallback)
+            return fallback;
+    }
+    throw new Error(errors.join("; ") || "Google Antigravity quota summary request failed");
+}
 async function fetchGoogleAntigravityQuota(accessToken, projectId) {
-    const response = await fetchWithTimeout(GOOGLE_QUOTA_API_URL, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${accessToken}`,
-            "User-Agent": GOOGLE_ANTIGRAVITY_USER_AGENT,
-        },
-        body: JSON.stringify({ project: projectId }),
-    });
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Google quota request failed (${response.status}): ${errorText}`);
+    const errors = [];
+    for (const endpoint of GOOGLE_ANTIGRAVITY_ENDPOINTS) {
+        const url = `${endpoint}/v1internal:fetchAvailableModels`;
+        const response = await fetchWithTimeout(url, {
+            method: "POST",
+            headers: googleAntigravityQuotaHeaders(accessToken),
+            body: JSON.stringify({ project: projectId }),
+        });
+        if (response.ok)
+            return response.json();
+        if (response.status === 403 && projectId) {
+            const retry = await fetchWithTimeout(url, {
+                method: "POST",
+                headers: googleAntigravityQuotaHeaders(accessToken),
+                body: JSON.stringify({}),
+            });
+            if (retry.ok)
+                return retry.json();
+        }
+        const errorText = await response.text().catch(() => "");
+        errors.push(`fetchAvailableModels ${response.status} at ${endpoint}${errorText ? `: ${errorText.slice(0, 200)}` : ""}`);
     }
-    return response.json();
+    throw new Error(errors.join("; ") || "Google Antigravity quota request failed");
 }
 function parseResetTime(value, now) {
     if (!value)

package/dist/app/popup/menu-items-controller.d.ts

@@ -1,11 +1,18 @@
 import type { AgentSessionRuntime, SessionInfo } from "@earendil-works/pi-coding-agent";
 import type { PopupMenuItem } from "../../ui.js";
-import type { Entry, ModelMenuValue, QueueMessageMenuValue, ResumeMenuValue, SessionModel, SlashCommand, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
+import type { Entry, ModelMenuValue, QueueMessageMenuValue, ResumeMenuValue, SessionModel, SlashCommand, ThinkingLevel, ThinkingMenuValue, UserMessageJumpMenuValue, UserMessageMenuValue } from "../types.js";
 export type AppMenuItemsControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
+    draftModelState?(): {
+        models: readonly SessionModel[];
+        modelRef?: string;
+        thinkingLevel?: ThinkingLevel;
+    } | undefined;
+    visibleModels(): readonly string[] | undefined;
     getBuiltinSlashCommands(): readonly SlashCommand[];
     getEntries(): readonly Entry[];
     getResumeSessions(): readonly SessionInfo[];
+    getOpenSessionPaths?(): readonly string[];
 };
 export declare class AppMenuItemsController {
     private readonly host;
@@ -18,17 +25,20 @@ export declare class AppMenuItemsController {
     getSlashCommandMatches(query: string, limit?: number): import("../../fuzzy.js").FuzzyMatch<SlashCommand>[];
     getSlashCommandMenuItems(query: string): PopupMenuItem<SlashCommand>[];
     modelRef(model: SessionModel): string;
-    getModelMenuItems(query: string): PopupMenuItem<ModelMenuValue>[];
+    getModelMenuItems(query: string, includeHidden?: boolean): PopupMenuItem<ModelMenuValue>[];
     getThinkingMenuItems(query: string): PopupMenuItem<ThinkingMenuValue>[];
     getUserMessageMenuItems(): PopupMenuItem<UserMessageMenuValue>[];
     getUserMessageJumpMenuItems(query: string): PopupMenuItem<UserMessageJumpMenuValue>[];
     isUserMessageJumpLoading(): boolean;
     refreshUserMessageJumpMenuItems(): Promise<void>;
     getQueueMessageMenuItems(): PopupMenuItem<QueueMessageMenuValue>[];
-    getResumeMenuItems(query: string, limit?: number): PopupMenuItem<ResumeMenuValue>[];
+    getResumeMenuItems(query: string, limit?: number, options?: {
+        draft?: boolean;
+    }): PopupMenuItem<ResumeMenuValue>[];
     private getResumeMenuItemsLoader;
     private getAllSlashCommands;
     private isCurrentModel;
+    private isVisibleModel;
     private getModelMenuModels;
     private thinkingLevelDescription;
 }