@yansigit/opencodex 2.31.3 → 2.33.0

package/src/oauth/google-antigravity.ts

@@ -51,6 +51,28 @@ interface GoogleTokenPayload {
   id_token?: unknown;
 }
 
+const TERMINAL_OAUTH_ERRORS = new Set([
+  "access_denied",
+  "expired_token",
+  "invalid_grant",
+  "refresh_token_reused",
+  "refresh_token_revoked",
+  "revoked",
+  "revoked_token",
+]);
+
+export class AntigravityTokenRequestError extends Error {
+  readonly httpStatus: number;
+  readonly oauthError?: string;
+
+  constructor(httpStatus: number, oauthError?: string) {
+    super(`Antigravity token request failed: ${httpStatus}`);
+    this.name = "AntigravityTokenRequestError";
+    this.httpStatus = httpStatus;
+    if (oauthError) this.oauthError = oauthError;
+  }
+}
+
 function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
   const part = token.split(".")[1];
   if (!part) return undefined;
@@ -75,8 +97,17 @@ async function postToken(body: Record<string, string>, signal?: AbortSignal): Pr
     signal: requestSignal(signal),
   });
   if (!response.ok) {
-    // Status only — the body can carry grant/account details.
-    throw new Error(`Antigravity token request failed: ${response.status}`);
+    let oauthError: string | undefined;
+    if (response.status === 400 || response.status === 401) {
+      try {
+        const body = await response.json() as { error?: unknown };
+        const candidate = typeof body.error === "string" ? body.error.trim().toLowerCase() : "";
+        if (TERMINAL_OAUTH_ERRORS.has(candidate)) oauthError = candidate;
+      } catch {
+        /* Keep status-only errors for malformed or non-JSON responses. */
+      }
+    }
+    throw new AntigravityTokenRequestError(response.status, oauthError);
   }
   return (await response.json()) as GoogleTokenPayload;
 }
@@ -221,7 +252,11 @@ export async function loginAntigravity(ctrl: OAuthController, opts?: { forceAcco
   return new AntigravityOAuthFlow(ctrl, opts).login();
 }
 
-export async function refreshAntigravityToken(refreshToken: string, signal?: AbortSignal): Promise<OAuthCredentials> {
+export async function refreshAntigravityToken(
+  refreshToken: string,
+  signal?: AbortSignal,
+  previousCredential?: OAuthCredentials,
+): Promise<OAuthCredentials> {
   if (!refreshToken) throw new Error("Antigravity credentials are expired and do not include a refresh token");
   const payload = await postToken({
     grant_type: "refresh_token",
@@ -230,8 +265,10 @@ export async function refreshAntigravityToken(refreshToken: string, signal?: Abo
     refresh_token: refreshToken,
   }, signal);
   const creds = credentialsFromPayload(payload, refreshToken);
-  // Re-discover the project on refresh so a newly-onboarded account fills in projectId.
-  const projectId = await discoverAntigravityProject(creds.access, signal).catch(() => undefined);
+  // Project discovery is onboarding work, not ordinary token renewal. Preserve the existing
+  // account-scoped project id and avoid an extra authenticated CCA call when it is present.
+  const projectId = previousCredential?.projectId
+    ?? await discoverAntigravityProject(creds.access, signal).catch(() => undefined);
   return projectId ? { ...creds, projectId } : creds;
 }
 

package/src/oauth/health.ts

@@ -3,7 +3,7 @@ import { getAnthropicAccountHealthSnapshot } from "./anthropic-routing";
 import { isAccountNeedsReauth } from "../codex/account-runtime-state";
 import { getCodexAccountCredential, listCodexAccountIds } from "../codex/account-store";
 import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
-import { readRuntimePort } from "../config";
+import { readRuntimePort } from "../config/process-state";
 import { LOCAL_MANAGEMENT_READ_PATHS } from "../lib/local-management-capability";
 import { maskAccountId } from "../lib/privacy";
 import { findLiveProxy } from "../server/proxy-liveness";

package/src/oauth/index.ts

@@ -10,7 +10,7 @@ import { ANTHROPIC_OAUTH_BETA, AnthropicTokenError, loginAnthropic, refreshAnthr
 import { loginKimi, refreshKimiToken } from "./kimi";
 import { loginNous, NousTokenError, refreshNousToken, clearNousRefreshIntent, RefreshIntentIOError } from "./nous";
 import { loginChatGPT, refreshChatGPTToken } from "./chatgpt";
-import { loginAntigravity, refreshAntigravityToken } from "./google-antigravity";
+import { AntigravityTokenRequestError, loginAntigravity, refreshAntigravityToken } from "./google-antigravity";
 import { loginCursor, refreshCursorToken } from "./cursor";
 import { loginGithubCopilot, refreshGithubCopilotToken, validateCopilotApiBaseUrl } from "./github-copilot";
 import { loginCommandCode, refreshCommandCodeToken } from "./command-code";
@@ -222,6 +222,7 @@ export const OAUTH_PROVIDERS: Record<string, OAuthProviderDef> = {
     refresh: refreshAntigravityToken,
     providerConfig: oauthConfig("google-antigravity"),
     defaultModel: oauthDefaultModel("google-antigravity"),
+    defaultRefreshPolicy: "lazy-only",
   },
   cursor: {
     login: (ctrl, opts) => loginCursor(ctrl, undefined, { forceLogin: opts?.forceLogin }),
@@ -466,8 +467,16 @@ export async function getValidAccessTokenSnapshot(provider: string): Promise<OAu
   return resolveAccessSnapshotForAccount(provider, set.activeAccountId);
 }
 
+/** Resolve a specific stored account without consulting or changing the active account. */
+export async function getValidAccessTokenSnapshotForAccount(
+  provider: string,
+  accountId: string,
+): Promise<OAuthAccessSnapshot> {
+  return resolveAccessSnapshotForAccount(provider, accountId);
+}
+
 /** Providers whose upstream-401 replay path may force a snapshot refresh. */
-const FORCE_REFRESH_PROVIDERS = new Set(["xai", "github-copilot", "kiro"]);
+const FORCE_REFRESH_PROVIDERS = new Set(["xai", "github-copilot", "kiro", "google-antigravity"]);
 
 export async function forceRefreshOAuthAccessSnapshot(
   rejected: OAuthAccessSnapshot,
@@ -501,6 +510,9 @@ function isTerminalRefreshError(err: unknown): boolean {
     || msg.includes("expired_token");
 }
 function terminal(error:unknown):boolean{
+  if (error instanceof AntigravityTokenRequestError) {
+    return (error.httpStatus === 400 || error.httpStatus === 401) && error.oauthError !== undefined;
+  }
   if(error instanceof XaiTokenRequestError)return ["invalid_grant","refresh_token_reused","revoked_token"].includes(error.oauthError??"");
   if(error instanceof AnthropicTokenError)return (error.httpStatus===400||error.httpStatus===401)&&["invalid_grant","refresh_token_reused","revoked","revoked_token","refresh_token_revoked"].includes(error.oauthError??"");
   if(error instanceof KiroTokenRefreshError)return (error.httpStatus===400||error.httpStatus===401)&&error.oauthError!==undefined;
@@ -630,7 +642,7 @@ export async function refreshAnthropicAccountWithLock(
       writeOAuthRefreshIntent(provider, accountId, generation, now(), deps.flight?.flightId);
       if (deps.signal?.aborted) throw deps.signal.reason;
       if (deps.flight) deps.flight.dispatched = true;
-      const fresh = merged(await def.refresh(stored.refresh, deps.signal), stored);
+      const fresh = merged(await def.refresh(stored.refresh, deps.signal, stored), stored);
       const outcome = await mergeAccountCredential(provider, accountId, fresh, {
         expectedGeneration: generation,
         afterPrePersistRead: deps.afterPrePersistRead,

package/src/oauth/kimi.ts

@@ -209,7 +209,15 @@ async function pollForToken(deviceCode: string, intervalMs: number, expiresInMs:
 
 export async function loginKimi(ctrl: OAuthController): Promise<OAuthCredentials> {
   const device = await requestDeviceAuthorization();
-  ctrl.onAuth?.({ url: device.verificationUriComplete, instructions: `Enter code: ${device.userCode}` });
+  // `deviceCode` carries the human-typed user code, matching the other device
+  // providers. It is also what tells the management login route this is a device
+  // flow, so a provider-supplied verification URI is no longer handed to a local
+  // browser spawn — the URL stays visible and copyable in every login surface.
+  ctrl.onAuth?.({
+    url: device.verificationUriComplete,
+    instructions: `Enter code: ${device.userCode}`,
+    deviceCode: device.userCode,
+  });
   return pollForToken(device.deviceCode, device.intervalMs, device.expiresInMs, ctrl.signal);
 }
 

package/src/oauth/open-browser-choice.ts

@@ -0,0 +1,26 @@
+import type { OcxConfig } from "../types";
+
+/**
+ * Whether a login should open a browser on the machine running the proxy.
+ *
+ * Both login routes share this so the two surfaces cannot drift: a per-request
+ * `openBrowser` beats the persisted setting, and the persisted setting beats
+ * the historical default. It lives in `src/oauth/` rather than beside either
+ * route because `src/codex/auth-api.ts` and
+ * `src/server/management/oauth-account-routes.ts` both already import from
+ * here, so no new edge is added to the import graph.
+ *
+ * The default is the important part. An operator who upgrades and configures
+ * nothing must see exactly what they saw before, so only an explicit `false`
+ * declines — `undefined`, `true`, and a malformed value all open.
+ *
+ * A malformed request field is ignored rather than rejected on purpose: this is
+ * a display preference, and no login should fail because of one.
+ */
+export function shouldOpenBrowserForLogin(
+  requested: unknown,
+  config: Pick<OcxConfig, "oauthOpenBrowser">,
+): boolean {
+  if (typeof requested === "boolean") return requested;
+  return config.oauthOpenBrowser !== false;
+}

package/src/oauth/store.ts

@@ -593,9 +593,11 @@ export async function upsertCredentialByIdentity(
 
 /** Remove the ACTIVE account; remaining accounts promote the first one. */
 export async function removeCredential(provider: string): Promise<void> {
+  let removedAccountId: string | undefined;
   await mutateStore(store => {
     const set = store[provider];
     if (!set) return;
+    removedAccountId = set.activeAccountId;
     set.accounts = set.accounts.filter(a => a.id !== set.activeAccountId);
     if (set.accounts.length === 0) {
       delete store[provider];
@@ -603,6 +605,10 @@ export async function removeCredential(provider: string): Promise<void> {
     }
     set.activeAccountId = set.accounts[0]!.id;
   }, [provider]);
+  if (provider === "google-antigravity" && removedAccountId) {
+    const { clearAntigravityRoutingStateForAccount } = await import("./antigravity-routing");
+    clearAntigravityRoutingStateForAccount(removedAccountId);
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/providers/antigravity-quota.ts

@@ -90,7 +90,9 @@ function candidateModelName(record: Record<string, unknown>): string {
     ?? record.modelName
     ?? record.model
     ?? record.name
-    ?? record.displayName;
+    ?? record.displayName
+    ?? record.modelFamily
+    ?? record.model_family;
   return typeof explicit === "string" ? explicit.toLowerCase() : "";
 }
 

package/src/providers/api-keys.ts

@@ -8,6 +8,7 @@
  */
 import { createHash } from "node:crypto";
 import { saveConfigPreservingClaudeCode } from "../config";
+import { isAzureIdentityProvider } from "../config/provider-validation";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 
 export interface ProviderApiKeyInfo {
@@ -36,7 +37,7 @@ export function apiKeyPoolEntryId(key: string): string {
 
 /** True for providers whose upstream auth is a configured API key (not oauth/forward). */
 export function isKeyAuthProvider(provider: OcxProviderConfig): boolean {
-  return provider.authMode !== "oauth" && provider.authMode !== "forward";
+  return !isAzureIdentityProvider(provider) && provider.authMode !== "oauth" && provider.authMode !== "forward";
 }
 
 /** Trim and reject blank / CRLF-bearing secrets. Shared by pool writes and OAuth upsert. */

package/src/providers/auto-compact-budget.ts

@@ -0,0 +1,65 @@
+import { SUPPORTED_NATIVE_OPENAI_SLUGS } from "../codex/catalog/native-models";
+import { redactSecretString } from "../lib/redact";
+
+const RESERVED_OBJECT_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+function positiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+/**
+ * Resolve a client-facing soft compaction budget without changing any hard
+ * model limit. Configuration and measured input ceilings may only lower the
+ * default 90% envelope.
+ */
+export function clampAutoCompactTokenLimit(
+  contextWindow: number,
+  maxInputTokens?: number,
+  configuredLimit?: number,
+): number {
+  const candidates = [Math.floor(contextWindow * 0.9), contextWindow];
+  if (positiveSafeInteger(maxInputTokens)) candidates.push(maxInputTokens);
+  if (positiveSafeInteger(configuredLimit)) candidates.push(configuredLimit);
+  return Math.min(...candidates);
+}
+
+export type AutoCompactBudgetValidationOptions = Readonly<{
+  /** PATCH accepts null for whole-map and per-key deletion. */
+  allowTombstones?: boolean;
+  /** The canonical ChatGPT provider accepts only exact supported native ids. */
+  requireNativeIds?: boolean;
+}>;
+
+/** Shared config/load/management boundary for per-model soft budgets. */
+export function modelAutoCompactTokenLimitsConfigError(
+  value: unknown,
+  options: AutoCompactBudgetValidationOptions = {},
+): string | null {
+  const field = "modelAutoCompactTokenLimits";
+  if (value === undefined || (options.allowTombstones && value === null)) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return `${field} must be a plain object${options.allowTombstones ? " or null" : ""}`;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return `${field} must be a plain object with own properties`;
+  }
+  for (const [modelId, entry] of Object.entries(value as Record<string, unknown>)) {
+    const safeModelId = JSON.stringify(redactSecretString(modelId));
+    if (!modelId.trim()) return `${field} keys must be nonblank model ids`;
+    if (RESERVED_OBJECT_KEYS.has(modelId)) {
+      return `${field} key ${safeModelId} is reserved`;
+    }
+    if (options.requireNativeIds
+      && (modelId.includes("/") || !SUPPORTED_NATIVE_OPENAI_SLUGS.has(modelId))) {
+      return `${field} key ${safeModelId} must be an exact supported native model id`;
+    }
+    if (options.allowTombstones && entry === null) continue;
+    if (!positiveSafeInteger(entry)) {
+      return `${field}[${safeModelId}] must be a positive safe integer${
+        options.allowTombstones ? " or null" : ""
+      }`;
+    }
+  }
+  return null;
+}

package/src/providers/derive.ts

@@ -1,4 +1,5 @@
 import type { CodexAccountMode, OcxProviderConfig } from "../types";
+import { isAzureIdentityProvider } from "../config/provider-validation";
 import { cloneFastWire } from "./fastwire";
 import {
   PROVIDER_REGISTRY,
@@ -226,6 +227,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.modelSuffixBracketStrip !== undefined ? { modelSuffixBracketStrip: entry.modelSuffixBracketStrip } : {}),
     ...(entry.staticHeaders ? { headers: { ...entry.staticHeaders } } : {}),
     ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
+    ...(entry.requestPacing ? { requestPacing: structuredClone(entry.requestPacing) } : {}),
     ...(entry.models ? { models: [...entry.models] } : {}),
     ...(liveModels !== undefined ? { liveModels } : {}),
     ...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
@@ -416,6 +418,7 @@ export function hasLegacyClinePassReasoningEfforts(name: string, prov: OcxProvid
 }
 
 export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig): void {
+  if (isAzureIdentityProvider(prov)) prov.liveModels = false;
   const entry = PROVIDER_REGISTRY.find(row => row.id === name);
   if (!entry || !providerMatchesRegistryTransportWithStaticGuards(name, prov)) {
     // Name lookup failed, but the row may still point at a vendor route we know. #1100 was
@@ -438,6 +441,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   repairStaticModelCatalogProvider(name, prov);
   if (prov.apiKeyTransport === undefined && seed.apiKeyTransport !== undefined) prov.apiKeyTransport = seed.apiKeyTransport;
   if (!prov.defaultModel && seed.defaultModel) prov.defaultModel = seed.defaultModel;
+  if (prov.requestPacing === undefined && seed.requestPacing) prov.requestPacing = structuredClone(seed.requestPacing);
   if (prov.responsesPath === undefined && seed.responsesPath !== undefined) prov.responsesPath = seed.responsesPath;
   // Fill mode only when absent: an explicit persisted `direct` must never be overwritten.
   if (prov.codexAccountMode === undefined && seed.codexAccountMode !== undefined) prov.codexAccountMode = seed.codexAccountMode;

package/src/providers/key-failover.ts

@@ -9,6 +9,7 @@
  * Modelled after src/codex/routing.ts cooldown logic but scoped to plain API-key pools.
  */
 import { saveConfigPreservingClaudeCode } from "../config";
+import { isAzureIdentityProvider } from "../config/provider-validation";
 import type { OcxConfig, OcxProviderConfig, RateLimitRetryPolicy } from "../types";
 import { resolveProviderTransport, type OcxProviderTransport } from "./xai-transport";
 import { sweepExpiredOnWrite } from "../lib/state-store-sweeper";
@@ -84,6 +85,7 @@ function isKeyInCooldown(providerName: string, keyId: string, now = Date.now()):
  * Returns true only for key-auth providers with 2+ pool entries.
  */
 export function hasKeyPoolFailover(provider: OcxProviderConfig): boolean {
+  if (isAzureIdentityProvider(provider)) return false;
   if (provider.authMode === "oauth" || provider.authMode === "forward") return false;
   return (provider.apiKeyPool?.length ?? 0) >= 2;
 }
@@ -96,7 +98,7 @@ export function hasKeyPoolFailover(provider: OcxProviderConfig): boolean {
  * callers never re-check fields.
  */
 export function rateLimitRetryPolicyFor(
-  provider: Pick<OcxProviderConfig, "retryOn429" | "authMode">,
+  provider: Pick<OcxProviderConfig, "retryOn429" | "authMode" | "adapter" | "azureCredential">,
 ): Required<RateLimitRetryPolicy> | null {
   const policy = provider.retryOn429;
   if (!policy || policy.enabled === false) return null;
@@ -105,6 +107,7 @@ export function rateLimitRetryPolicyFor(
   // same token, local runtimes have no remote key to preserve, and unknown/custom values are
   // rejected rather than guessed at.
   if (provider.authMode !== undefined && provider.authMode !== "key") return null;
+  if (isAzureIdentityProvider(provider)) return null;
   return {
     enabled: policy.enabled ?? DEFAULT_RATE_LIMIT_RETRY.enabled,
     attempts: policy.attempts ?? DEFAULT_RATE_LIMIT_RETRY.attempts,
@@ -153,6 +156,7 @@ export function rotateKeyOn429(
 ): OcxProviderConfig | null {
   const provider = config.providers[providerName];
   if (!provider) return null;
+  if (isAzureIdentityProvider(provider)) return null;
   if (provider.authMode === "oauth" || provider.authMode === "forward") return null;
 
   const pool = provider.apiKeyPool;

package/src/providers/openai-tiers.ts

@@ -237,6 +237,7 @@ function hasKnownLegacyOpenAiReference(config: OcxConfig): boolean {
     || matchesList(config.subagentModels)
     || (config.subagentRoles ?? []).some(role => matches(role.model))
     || matches(config.injectionModel)
+    || matches(config.v2NativeParentOverride?.model)
     || matches(config.shadowCallIntercept?.model)
     || matches(config.webSearchSidecar?.model)
     || matches(config.visionSidecar?.model)
@@ -260,6 +261,9 @@ function rewriteLegacyOpenAiReferences(config: OcxConfig, warnings: string[]): v
     }
   }
   if (config.injectionModel) config.injectionModel = rewriteLegacyOpenAiSelectedId(config.injectionModel);
+  if (config.v2NativeParentOverride?.model) {
+    config.v2NativeParentOverride.model = rewriteLegacyOpenAiSelectedId(config.v2NativeParentOverride.model);
+  }
   if (config.shadowCallIntercept?.model) {
     config.shadowCallIntercept.model = rewriteLegacyOpenAiSelectedId(config.shadowCallIntercept.model);
   }
@@ -305,6 +309,7 @@ function isKnownLegacyValuePath(path: readonly string[]): boolean {
   if (/^providers\.(openai|openai-multi)\.selectedModels\.\d+$/.test(joined)) return true;
   return new Set([
     "injectionModel",
+    "v2NativeParentOverride.model",
     "shadowCallIntercept.model",
     "webSearchSidecar.model",
     "visionSidecar.model",

package/src/providers/provider-id-rewrite.ts

@@ -82,6 +82,7 @@ export function rewriteProviderReferences(config: OcxConfig, from: string, to: s
 
   const scalarOwners: Array<[Record<string, unknown> | undefined, string]> = [
     [config as unknown as Record<string, unknown>, "injectionModel"],
+    [config.v2NativeParentOverride as Record<string, unknown> | undefined, "model"],
     [config.shadowCallIntercept as Record<string, unknown> | undefined, "model"],
     [config.webSearchSidecar as Record<string, unknown> | undefined, "model"],
     [config.visionSidecar as Record<string, unknown> | undefined, "model"],

package/src/providers/quota.ts

@@ -8,7 +8,7 @@ import { isMainAccountIdentityGenerationLive } from "../codex/main-account-cache
 import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
 import { codexPlanKey } from "../codex/plan";
 import { resolveEnvValue } from "../config";
-import { getValidAccessToken, getValidAccessTokenForAccount } from "../oauth";
+import { getValidAccessToken, getValidAccessTokenForAccount, getValidAccessTokenSnapshot, getValidAccessTokenSnapshotForAccount, type OAuthAccessSnapshot } from "../oauth";
 import { getAccountCredential, getAccountSet, getCredential } from "../oauth/store";
 import { antigravityUserAgent } from "../adapters/client-fingerprint";
 import { apiKeyPoolEntryId } from "./api-keys";
@@ -34,6 +34,7 @@ import {
   isTerminalAntigravityQuotaStatus,
 } from "./antigravity-quota";
 import { antigravityHostCandidates, isAntigravityHttpsHost } from "../adapters/google-antigravity-hosts";
+import { providerTlsFetch } from "../lib/provider-tls-profile";
 
 /** Match oauth/index REFRESH_SKEW_MS — use stored access without refresh when still fresh. */
 const ACCOUNT_TOKEN_SKEW_MS = 60_000;
@@ -1400,7 +1401,7 @@ export interface ProviderAccountQuota {
 
 /** Providers whose per-account quota can be probed. Extend as other OAuth APIs are covered. */
 export function supportsPerAccountQuota(provider: string): boolean {
-  return provider === "anthropic";
+  return provider === "anthropic" || provider === "google-antigravity";
 }
 
 function accountCacheKey(provider: string, accountId: string): string {
@@ -1519,8 +1520,13 @@ async function fetchAccountQuota(
 
   const probe = (async (): Promise<AccountQuotaCacheEntry> => {
     try {
-      const token = await getTokenForAccountQuotaProbe(provider, accountId);
-      const quota = await fetchAnthropicUsageQuota(token);
+      let quota: ProviderQuota | null = null;
+      if (provider === "anthropic") {
+        const token = await getTokenForAccountQuotaProbe(provider, accountId);
+        quota = await fetchAnthropicUsageQuota(token);
+      } else if (provider === "google-antigravity") {
+        quota = await fetchAntigravityAccountQuota(accountId);
+      }
       if (!quota) {
         // Preserve last-good bars and mark unavailable; advance TTL so failures
         // negative-cache instead of re-probing on every GUI poll.
@@ -2077,23 +2083,63 @@ function antigravityUsedPercent(quotaInfo: Record<string, unknown>): number | un
   return normalizePercent(100 - remaining);
 }
 
+async function fetchAntigravityAccountQuota(accountId: string): Promise<ProviderQuota | null> {
+  let snapshot: OAuthAccessSnapshot;
+  try {
+    snapshot = await getValidAccessTokenSnapshotForAccount("google-antigravity", accountId);
+  } catch {
+    return null;
+  }
+  if (!snapshot.projectId) return null;
+  const entry = getProviderRegistryEntry("google-antigravity");
+  const baseUrl = (entry?.baseUrl || "https://daily-cloudcode-pa.googleapis.com").replace(/\/+$/, "");
+  const providerConfig: Pick<OcxProviderConfig, "adapter" | "authMode" | "baseUrl" | "googleMode" | "tlsProfile"> = {
+    adapter: "google",
+    authMode: "oauth",
+    googleMode: "cloud-code-assist",
+    baseUrl,
+  };
+  const fetchImpl = providerTlsFetch("google-antigravity", providerConfig, globalThis.fetch);
+  let liveQuota: ProviderQuota | null;
+  try {
+    liveQuota = await fetchAntigravityLiveQuota({
+      accessToken: snapshot.accessToken,
+      projectId: snapshot.projectId,
+      baseUrl,
+      timeoutMs: REQUEST_TIMEOUT_MS,
+      fetchImpl,
+    });
+  } catch (error) {
+    if (error instanceof AntigravityQuotaRpcError && isTerminalAntigravityQuotaStatus(error.status)) {
+      return null;
+    }
+    liveQuota = null;
+  }
+  if (!liveQuota) return null;
+  return {
+    ...liveQuota,
+    updatedAt: Date.now(),
+  };
+}
+
 async function fetchAntigravityQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
-  const credential = getCredential("google-antigravity");
-  if (!credential?.projectId) return null;
-  let accessToken: string;
+  let snapshot: OAuthAccessSnapshot;
   try {
-    accessToken = await getValidAccessToken("google-antigravity");
+    snapshot = await getValidAccessTokenSnapshot("google-antigravity");
   } catch {
     return null;
   }
+  if (!snapshot.projectId) return null;
   const baseUrl = (config.baseUrl || "https://daily-cloudcode-pa.googleapis.com").replace(/\/+$/, "");
+  const fetchImpl = providerTlsFetch(provider, config, globalThis.fetch);
   let liveQuota: ProviderQuota | null;
   try {
     liveQuota = await fetchAntigravityLiveQuota({
-      accessToken,
-      projectId: credential.projectId,
+      accessToken: snapshot.accessToken,
+      projectId: snapshot.projectId,
       baseUrl,
       timeoutMs: REQUEST_TIMEOUT_MS,
+      fetchImpl,
     });
   } catch (error) {
     if (error instanceof AntigravityQuotaRpcError && isTerminalAntigravityQuotaStatus(error.status)) {
@@ -2106,15 +2152,15 @@ async function fetchAntigravityQuota(provider: string, config: OcxProviderConfig
   for (const [index, host] of antigravityHostCandidates(baseUrl).entries()) {
     if (!isAntigravityHttpsHost(host)) continue;
     try {
-      const response = await fetch(`${host}/v1internal:fetchAvailableModels`, {
+      const response = await fetchImpl(`${host}/v1internal:fetchAvailableModels`, {
         method: "POST",
         headers: {
           Accept: "application/json",
           "Content-Type": "application/json",
           "User-Agent": antigravityUserAgent(),
-          Authorization: `Bearer ${accessToken}`,
+          Authorization: `Bearer ${snapshot.accessToken}`,
         },
-        body: JSON.stringify({ project: credential.projectId }),
+        body: JSON.stringify({ project: snapshot.projectId }),
         redirect: "error",
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
       });

package/src/providers/registry.ts

@@ -161,6 +161,7 @@ export interface ProviderRegistryEntry {
   note?: string;
   dashboardUrl?: string;
   defaultModel?: string;
+  requestPacing?: OcxProviderConfig["requestPacing"];
   models?: string[];
   liveModels?: boolean;
   /**
@@ -442,7 +443,7 @@ const THINKING_TOGGLE_MAP: Record<string, string> = {
   max: "enabled",
 };
 const OPENCODE_GO_THINKING_TOGGLE_MODELS = [
-  "mimo-v2.5", "mimo-v2.5-pro", "mimo-v2-omni", "mimo-v2-pro", "glm-5", "glm-5.1",
+  "mimo-v2.5", "mimo-v2.5-pro", "glm-5", "glm-5.1",
 ];
 /**
  * Zhipu's domestic BigModel platform. Text families first, then the vision member: modalities are
@@ -1597,7 +1598,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   // 2026-07-10: defaultModel is frozen pending Vertex-specific Tier-2 evidence; Gemini API
   // evidence from ai.google.dev does not establish Vertex publisher availability.
   { id: "google-vertex", label: "Google Vertex AI", adapter: "google", baseUrl: "https://aiplatform.googleapis.com", authKind: "key", dashboardUrl: "https://console.cloud.google.com/vertex-ai", defaultModel: "gemini-3-pro", googleMode: "vertex", jawcodeBundle: "google", extraMetadataAliases: ["gemini-vertex"] },
-  { id: "google-antigravity", label: "Google Antigravity", adapter: "google", baseUrl: "https://daily-cloudcode-pa.googleapis.com", authKind: "oauth", allowBaseUrlOverride: true, dashboardUrl: "https://antigravity.google", models: ANTIGRAVITY_MODELS, liveModels: true, defaultModel: "gemini-3.7-flash", modelContextWindows: ANTIGRAVITY_MODEL_CONTEXT_WINDOWS, modelInputModalities: ANTIGRAVITY_MODEL_INPUT_MODALITIES, modelReasoningEfforts: ANTIGRAVITY_MODEL_EFFORTS, googleMode: "cloud-code-assist", jawcodeBundle: "google", extraMetadataAliases: ["antigravity", "gemini-antigravity"] },
+  { id: "google-antigravity", label: "Google Antigravity", adapter: "google", baseUrl: "https://daily-cloudcode-pa.googleapis.com", authKind: "oauth", allowBaseUrlOverride: true, dashboardUrl: "https://antigravity.google", models: ANTIGRAVITY_MODELS, liveModels: true, defaultModel: "gemini-3.7-flash", requestPacing: { enabled: true, requestsPerMinute: 30, minIntervalMs: 2_000, jitterMs: 500 }, modelContextWindows: ANTIGRAVITY_MODEL_CONTEXT_WINDOWS, modelInputModalities: ANTIGRAVITY_MODEL_INPUT_MODALITIES, modelReasoningEfforts: ANTIGRAVITY_MODEL_EFFORTS, googleMode: "cloud-code-assist", jawcodeBundle: "google", extraMetadataAliases: ["antigravity", "gemini-antigravity"] },
   { id: "azure-openai", label: "Azure OpenAI", adapter: "azure-openai", baseUrl: "https://{resource}.openai.azure.com/openai", authKind: "key", featured: true, dashboardUrl: "https://portal.azure.com" },
   { id: "ollama", label: "Ollama (local)", adapter: "openai-chat", baseUrl: "http://localhost:11434/v1", authKind: "local", allowPrivateNetworkByDefault: true, allowBaseUrlOverride: true, featured: true, note: "Local — key usually blank" },
   { id: "vllm", label: "vLLM (local)", adapter: "openai-chat", baseUrl: "http://localhost:8000/v1", authKind: "local", allowPrivateNetworkByDefault: true, allowBaseUrlOverride: true, featured: true, note: "Local — key usually blank" },
@@ -1867,6 +1868,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     liveModels: true,
     preserveCustomDestination: true,
     defaultModel: "deepseek/deepseek-v4-flash",
+    promptCacheKey: true,
     // The default is also the cold-start seed: live discovery failure must not empty the catalog
     // for a freshly configured provider with no stale cache (issue #308 pattern).
     models: ["deepseek/deepseek-v4-flash"],