@yansigit/opencodex 2.33.0 → 2.33.1

package/src/oauth/google-aistudio-auth.ts

@@ -0,0 +1,98 @@
+/**
+ * Google AI Studio Web-UI (SAPISIDHASH) authorization & header builder.
+ */
+
+export interface GoogleCookieJar {
+  sapisid?: string;
+  psid?: string;
+  ssid?: string;
+  hsid?: string;
+  sid?: string;
+  cookieHeader: string;
+}
+
+const DEFAULT_ORIGIN = "https://aistudio.google.com";
+
+/**
+ * Generate the Google internal SAPISIDHASH Authorization header value.
+ * Formula uses Unix seconds: "SAPISIDHASH <timestamp>_<sha1(timestamp + " " + SAPISID + " " + origin)>".
+ */
+export async function generateSapisidHash(
+  sapisid: string,
+  origin: string = DEFAULT_ORIGIN,
+  timestamp: number = Date.now()
+): Promise<string> {
+  // Callers historically passed Date.now() (milliseconds); Google expects Unix seconds.
+  const seconds = Math.floor(timestamp > 10_000_000_000 ? timestamp / 1000 : timestamp);
+  const raw = `${seconds} ${sapisid} ${origin}`;
+  const buf = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(raw));
+  const hexHash = Array.from(new Uint8Array(buf))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+  return `SAPISIDHASH ${seconds}_${hexHash}`;
+}
+
+/**
+ * Parse a raw cookie string (from browser export, header, or config) into tokens and a normalized string.
+ */
+export function parseGoogleCookieJar(cookieInput: string): GoogleCookieJar {
+  const cleanInput = (cookieInput || "").trim();
+  const jar: GoogleCookieJar = { cookieHeader: cleanInput };
+  if (!cleanInput) return jar;
+  if (/[\r\n\u0000]/.test(cleanInput)) return { cookieHeader: "" };
+
+  const parts = cleanInput.split(";").map((p) => p.trim());
+  for (const part of parts) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx === -1) continue;
+    const name = part.slice(0, eqIdx).trim();
+    const value = part.slice(eqIdx + 1).trim();
+
+    if (name === "SAPISID" || name === "__Secure-3PAPISID") {
+      jar.sapisid = value;
+    } else if (name === "__Secure-1PSID" || name === "__Secure-3PSID") {
+      jar.psid = value;
+    } else if (name === "SSID") {
+      jar.ssid = value;
+    } else if (name === "HSID") {
+      jar.hsid = value;
+    } else if (name === "SID") {
+      jar.sid = value;
+    }
+  }
+
+  return jar;
+}
+
+/**
+ * Validate whether a cookie jar contains sufficient authentication credentials.
+ */
+export function validateAiStudioCookies(jar: GoogleCookieJar): { valid: boolean; error?: string } {
+  if (!jar.sapisid || !jar.cookieHeader) {
+    return {
+      valid: false,
+      error: "Missing SAPISID cookie required for Google AI Studio authorization.",
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * Build the HTTP headers required for alkalimakersuite-pa.clients6.google.com calls.
+ */
+export async function buildAiStudioHeaders(
+  jar: GoogleCookieJar,
+  origin: string = DEFAULT_ORIGIN
+): Promise<Record<string, string>> {
+  const sapisid = jar.sapisid || "";
+  const authHeader = await generateSapisidHash(sapisid, origin);
+
+  return {
+    "Authorization": authHeader,
+    "Cookie": jar.cookieHeader,
+    "X-Goog-AuthUser": "0",
+    "Origin": origin,
+    "Referer": origin.endsWith("/") ? origin : `${origin}/`,
+    "Content-Type": "application/json",
+  };
+}

package/src/oauth/key-providers.ts

@@ -1,6 +1,7 @@
 import type { OcxProviderConfig } from "../types";
 import { deriveKeyLoginMap, enrichProviderFromRegistry, type DerivedKeyLoginProvider } from "../providers/derive";
 import { resolveProviderModelDiscoveryUrl } from "../providers/model-discovery";
+import { parseGoogleCookieJar, validateAiStudioCookies } from "./google-aistudio-auth";
 
 /**
  * API-key "login" providers: not OAuth — the flow opens the provider's dashboard so the user can
@@ -86,6 +87,13 @@ export async function validateApiKey(
       return "unknown";
     }
 
+    if (provider.adapter === "google" && provider.googleMode === "ai-studio-web") {
+      const jar = parseGoogleCookieJar(key);
+      const val = validateAiStudioCookies(jar);
+      if (!val.valid) return false;
+      return true;
+    }
+
     if (provider.adapter === "google" && (provider.googleMode ?? "ai-studio") === "ai-studio") {
       // Generative Language API rejects Bearer-wrapped API keys; probe models.list with the
       // documented x-goog-api-key header instead (pageSize=1 — validation only needs a 200).

package/src/oauth/login-cli.ts

@@ -15,6 +15,7 @@ import { codexAccountNamespaceProviderCollisionError } from "../codex/account-na
 const LIVE_RELOAD_PROVIDERS = new Set<string>([
   ...listOAuthProviders(),
   ...Object.keys(KEY_LOGIN_PROVIDERS),
+  "google-aistudio",
 ]);
 
 export function runningProxyUpdateHeaders(): Headers {
@@ -65,16 +66,80 @@ export function warnIfLiveReloadSkipped(result: LocalProviderReloadResult | null
 
 export async function handleLogin(provider?: string): Promise<void> {
   const name = (provider ?? "").trim().toLowerCase();
+  if (name === "google-aistudio" || name === "aistudio" || name === "gemini-aistudio") {
+    return handleAiStudioBridgeLogin();
+  }
   if (isPublicOAuthProvider(name)) return handleOAuthLogin(name);
   if (isKeyLoginProvider(name)) return handleKeyLogin(name);
   console.error(
     `Usage: ocx login <provider>\n` +
-      `  OAuth login:   ${listOAuthProviders().join(", ")}\n` +
+      `  OAuth / Web:   ${[...listOAuthProviders(), "google-aistudio"].join(", ")}\n` +
       `  API-key login: ${Object.keys(KEY_LOGIN_PROVIDERS).join(", ")}`,
   );
   process.exit(1);
 }
 
+async function handleAiStudioBridgeLogin(): Promise<void> {
+  const live = await findLiveProxy();
+  const port = live?.port ?? 10100;
+  const bridgeUrl = "http://127.0.0.1:" + port + "/aistudio/bridge";
+
+  console.log("\n🌐 Google AI Studio Sign-In & Session Setup:");
+  console.log("   Option 1: Paste Session Token from the Brave/Chrome extension popup (Passkey-friendly)");
+  console.log("   Option 2: Open native macOS sign-in window");
+  console.log("   Option 3: Open browser bridge page (" + bridgeUrl + ")\n");
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const choice = await new Promise<string>((res) => {
+      rl.question("Paste Session Token (or press Enter for native window): ", (ans) => res(ans.trim()));
+    });
+
+    if (choice.length > 20) {
+      const { saveAiStudioSessionFromToken } = await import("./aistudio-session-sync");
+      saveAiStudioSessionFromToken(choice);
+      console.log("\n✅ Session token imported successfully! Saved to ~/.opencodex/aistudio-session.json");
+    } else if (process.platform === "darwin") {
+      const { getAiStudioNativeDaemonSourcePath } = await import("./aistudio-native-daemon");
+      const swiftSrc = getAiStudioNativeDaemonSourcePath();
+      console.log("\n🚀 Opening native Google AI Studio login window...");
+      const proc = Bun.spawn(["swift", swiftSrc, "--login"], {
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      const code = await proc.exited;
+      if (code === 0) {
+        console.log("\n✅ Google AI Studio authenticated successfully! Session saved to ~/.opencodex/aistudio-session.json");
+      }
+    } else {
+      console.log("\n🌐 Opening bridge page in your browser: " + bridgeUrl);
+      openUrl(bridgeUrl);
+    }
+  } finally {
+    rl.close();
+  }
+
+  const config = loadConfig();
+  if (!config.providers["google-aistudio"]) {
+    config.providers["google-aistudio"] = {
+      adapter: "google",
+      googleMode: "ai-studio-web",
+      baseUrl: "https://alkalimakersuite-pa.clients6.google.com",
+      authMode: "local",
+      liveModels: false,
+      defaultModel: "gemini-3.7-flash",
+      models: ["gemini-3.7-flash", "gemini-3.1-pro-preview", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-3.5-flash"],
+    };
+    saveConfig(config);
+    console.log("\n   ✓ Configured 'google-aistudio' in ~/.opencodex/config.json");
+  }
+
+  openUrl(bridgeUrl);
+  const reload = await notifyRunningProxy("google-aistudio");
+  console.log("\n✅ Ready! Use models with 'google-aistudio' provider in your coding agents.");
+  warnIfLiveReloadSkipped(reload);
+}
+
 async function handleOAuthLogin(name: string): Promise<void> {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   try {

package/src/providers/derive.ts

@@ -49,7 +49,7 @@ export interface DerivedKeyLoginProvider {
   thinkingBudgetModels?: string[];
   escapeBuiltinToolNames?: boolean;
   openaiChatEofTolerance?: boolean;
-  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
+  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist" | "ai-studio-web";
   project?: string;
   location?: string;
 }

package/src/providers/quota.ts

@@ -16,6 +16,7 @@ import { XAI_GROK_CLIENT_VERSION, XAI_GROK_COMPATIBILITY } from "./xai-transport
 import { getProviderRegistryEntry, providerCodexAccountMode, registryEntryForProviderDestination } from "./registry";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 import { isCanonicalOpenAiForwardProvider, OPENAI_CODEX_PROVIDER_ID } from "./openai-tiers";
+import { globalAiStudioRelayHub } from "../server/aistudio-ws-hub";
 import {
   captureConfigGeneration,
   sweepExpiredOnWrite,
@@ -1401,7 +1402,12 @@ 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" || provider === "google-antigravity";
+  return (
+    provider === "anthropic" ||
+    provider === "google-antigravity" ||
+    provider === "command-code" ||
+    provider === "cursor"
+  );
 }
 
 function accountCacheKey(provider: string, accountId: string): string {
@@ -1526,6 +1532,14 @@ async function fetchAccountQuota(
         quota = await fetchAnthropicUsageQuota(token);
       } else if (provider === "google-antigravity") {
         quota = await fetchAntigravityAccountQuota(accountId);
+      } else if (provider === "command-code") {
+        const token = await getTokenForAccountQuotaProbe(provider, accountId);
+        const res = await fetchCommandCodeUsageQuota(token);
+        quota = res === TERMINAL_QUOTA_FAILURE ? null : res;
+      } else if (provider === "cursor") {
+        const token = await getTokenForAccountQuotaProbe(provider, accountId);
+        const res = await fetchCursorUsageQuota(token);
+        quota = res?.quota ?? null;
       }
       if (!quota) {
         // Preserve last-good bars and mark unavailable; advance TTL so failures
@@ -1741,8 +1755,9 @@ function parseCommandCodeWindow(value: unknown): { percent: number; resetAt?: nu
   if (!row) return null;
   const cap = toFiniteNumber(row.cap);
   const used = toFiniteNumber(row.used);
-  if (cap === undefined || used === undefined || cap <= 0 || used < 0) return null;
-  const percent = normalizePercent((used / cap) * 100);
+  const percent = cap !== undefined && used !== undefined && cap > 0 && used >= 0
+    ? normalizePercent((used / cap) * 100)
+    : normalizePercent(row.percent);
   if (percent === undefined) return null;
   const resetAt = quotaResetAt(row);
   return { percent, ...(resetAt !== undefined ? { resetAt } : {}) };
@@ -1829,11 +1844,7 @@ async function resolveCommandCodeQuotaBearer(config: OcxProviderConfig): Promise
  * usage view uses (windowLimits.fiveHour / windowLimits.weekly), plus soft
  * whoami (team orgId scoping) and subscription-scoped spend for creditsUsd.
  */
-async function fetchCommandCodeQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
-  // Never release credentials to a user-edited or lookalike provider host.
-  if (!isCanonicalCommandCodeBaseUrl(config.baseUrl)) return null;
-  const bearer = await resolveCommandCodeQuotaBearer(config);
-  if (!bearer) return null;
+async function fetchCommandCodeUsageQuota(bearer: string): Promise<ProviderQuota | null | typeof TERMINAL_QUOTA_FAILURE> {
   const whoamiBody = await fetchCommandCodeJson(COMMAND_CODE_WHOAMI_URL, bearer);
   const whoami = asRecord(whoamiBody?.data) ?? whoamiBody;
   const org = asRecord(whoami?.org);
@@ -1857,7 +1868,7 @@ async function fetchCommandCodeQuota(provider: string, config: OcxProviderConfig
   const fiveHour = parseCommandCodeWindow(limits?.fiveHour);
   const weekly = parseCommandCodeWindow(limits?.weekly);
   const creditsUsd = await fetchCommandCodeSpend(bearer, credits, orgQuery);
-  return report(provider, "command-code:credits", {
+  return {
     ...(fiveHour ? {
       fiveHourPercent: fiveHour.percent,
       ...(fiveHour.resetAt !== undefined ? { fiveHourResetAt: fiveHour.resetAt } : {}),
@@ -1868,18 +1879,21 @@ async function fetchCommandCodeQuota(provider: string, config: OcxProviderConfig
     } : {}),
     ...(creditsUsd ? { creditsUsd } : {}),
     updatedAt: Date.now(),
-  });
+  };
 }
 
-/** Cursor included usage via api2.cursor.sh (Bearer from OAuth) — unofficial, may change. */
-async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport | null> {
-  let accessToken: string;
-  try {
-    accessToken = await getValidAccessToken("cursor");
-  } catch {
-    return null;
-  }
+async function fetchCommandCodeQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
+  // Never release credentials to a user-edited or lookalike provider host.
+  if (!isCanonicalCommandCodeBaseUrl(config.baseUrl)) return null;
+  const bearer = await resolveCommandCodeQuotaBearer(config);
+  if (!bearer) return null;
+  const result = await fetchCommandCodeUsageQuota(bearer);
+  if (!result || result === TERMINAL_QUOTA_FAILURE) return result;
+  return report(provider, "command-code:credits", result);
+}
 
+/** Cursor included usage via api2.cursor.sh (Bearer from OAuth) — unofficial, may change. */
+async function fetchCursorUsageQuota(accessToken: string): Promise<{ quota: ProviderQuota; source: string } | null> {
   const authHeaders = {
     Accept: "application/json",
     Authorization: `Bearer ${accessToken}`,
@@ -1939,15 +1953,17 @@ async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport |
         }
 
         if (totalPercent !== undefined || customWindows.length > 0) {
-          const built = report(provider, "cursor:period-usage", {
-            ...(totalPercent !== undefined ? {
-              monthlyPercent: totalPercent,
-              ...(resetAt !== undefined ? { monthlyResetAt: resetAt } : {}),
-            } : {}),
-            ...(customWindows.length > 0 ? { customWindows } : {}),
-            updatedAt: Date.now(),
-          });
-          if (built) return { ...built, reverseEngineered: true };
+          return {
+            source: "cursor:period-usage",
+            quota: {
+              ...(totalPercent !== undefined ? {
+                monthlyPercent: totalPercent,
+                ...(resetAt !== undefined ? { monthlyResetAt: resetAt } : {}),
+              } : {}),
+              ...(customWindows.length > 0 ? { customWindows } : {}),
+              updatedAt: Date.now(),
+            },
+          };
         }
       }
     }
@@ -1973,12 +1989,14 @@ async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport |
             ? normalizePercent((used / limit) * 100)
             : undefined);
         if (percent !== undefined) {
-          const built = report(provider, "cursor:usage-summary", {
-            monthlyPercent: percent,
-            monthlyResetAt: normalizeResetAt(body?.billingCycleEnd),
-            updatedAt: Date.now(),
-          });
-          if (built) return { ...built, reverseEngineered: true };
+          return {
+            source: "cursor:usage-summary",
+            quota: {
+              monthlyPercent: percent,
+              monthlyResetAt: normalizeResetAt(body?.billingCycleEnd),
+              updatedAt: Date.now(),
+            },
+          };
         }
       }
     }
@@ -2027,11 +2045,26 @@ async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport |
         return Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, start.getUTCDate());
       })()
     : undefined;
-  const built = report(provider, "cursor:auth-usage", {
-    monthlyPercent: percent,
-    ...(monthlyResetAt !== undefined ? { monthlyResetAt } : {}),
-    updatedAt: Date.now(),
-  });
+  return {
+    source: "cursor:auth-usage",
+    quota: {
+      monthlyPercent: percent,
+      ...(monthlyResetAt !== undefined ? { monthlyResetAt } : {}),
+      updatedAt: Date.now(),
+    },
+  };
+}
+
+async function fetchCursorQuota(provider: string): Promise<ProviderQuotaReport | null> {
+  let accessToken: string;
+  try {
+    accessToken = await getValidAccessToken("cursor");
+  } catch {
+    return null;
+  }
+  const result = await fetchCursorUsageQuota(accessToken);
+  if (!result) return null;
+  const built = report(provider, result.source, result.quota);
   return built ? { ...built, reverseEngineered: true } : null;
 }
 
@@ -2219,6 +2252,22 @@ async function fetchAntigravityQuota(provider: string, config: OcxProviderConfig
   });
 }
 
+async function fetchAiStudioQuota(name: string, provider: OcxProviderConfig): Promise<ProviderQuotaReport | null> {
+  const active = globalAiStudioRelayHub.hasActiveSessions();
+  const sessionCount = globalAiStudioRelayHub.getActiveSessionCount();
+  const now = Date.now();
+
+  return {
+    provider: name,
+    label: "Google AI Studio (Web)",
+    source: active ? `Browser Relay (${sessionCount} active tab${sessionCount > 1 ? "s" : ""})` : "Browser Relay (Disconnected)",
+    updatedAt: now,
+    quota: {
+      updatedAt: now,
+    },
+  };
+}
+
 async function maybeFetchProviderQuota(
   name: string,
   provider: OcxProviderConfig,
@@ -2294,6 +2343,9 @@ async function maybeFetchProviderQuota(
     if ((provider.authMode ?? "key") === "key" && name === "neuralwatt") {
       return fetchNeuralwattQuota(name, provider);
     }
+    if (provider.googleMode === "ai-studio-web" || name === "google-aistudio") {
+      return fetchAiStudioQuota(name, provider);
+    }
     return null;
   } catch {
     return null;

package/src/providers/registry.ts

@@ -299,7 +299,7 @@ export interface ProviderRegistryEntry {
   jawcodeBundle?: string;
   extraMetadataAliases?: string[];
   metadataModelIdNormalize?: MetadataModelIdNormalize;
-  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist";
+  googleMode?: "ai-studio" | "vertex" | "cloud-code-assist" | "ai-studio-web";
   project?: string;
   location?: string;
 }
@@ -1599,6 +1599,27 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   // 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", 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: "google-aistudio",
+    label: "Google AI Studio (Web)",
+    adapter: "google",
+    baseUrl: "https://alkalimakersuite-pa.clients6.google.com",
+    authKind: "local",
+    keyOptional: true,
+    featured: true,
+    dashboardPreset: true,
+    dashboardUrl: "https://aistudio.google.com",
+    defaultModel: "gemini-3.7-flash",
+    models: ["gemini-3.7-flash", "gemini-3.1-pro-preview", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-3.5-flash"],
+    liveModels: false,
+    // Conservative pacing for a browser-backed subscription session: avoid bursts while
+    // keeping interactive coding-agent requests usable. Jitter reduces synchronized retries.
+    requestPacing: { enabled: true, requestsPerMinute: 8, minIntervalMs: 7_500, jitterMs: 1_500 },
+    googleMode: "ai-studio-web",
+    jawcodeBundle: "google",
+    extraMetadataAliases: ["aistudio", "gemini-aistudio"],
+    note: "Relays prompts through your active Google AI Studio / Google AI Pro browser session at /aistudio/bridge (default proxy port 10100).",
+  },
   { 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" },
@@ -2913,8 +2934,8 @@ export function providerCodexAccountMode(id: string, provider?: OcxProviderConfi
  */
 export function effectiveGoogleMode(
   providerId: string,
-  prov: { adapter?: string; googleMode?: "ai-studio" | "vertex" | "cloud-code-assist" },
-): "ai-studio" | "vertex" | "cloud-code-assist" | null {
+  prov: { adapter?: string; googleMode?: "ai-studio" | "vertex" | "cloud-code-assist" | "ai-studio-web" },
+): "ai-studio" | "vertex" | "cloud-code-assist" | "ai-studio-web" | null {
   if (prov.adapter !== "google") return null;
   return prov.googleMode ?? getProviderRegistryEntry(providerId)?.googleMode ?? "ai-studio";
 }

package/src/router.ts

@@ -398,6 +398,9 @@ export function routedProviderConfig(providerName: string, provider: OcxProvider
     authMode: canonicalAuthMode,
     apiKey: resolvedApiKey,
     ...(staticModelCatalog ? { liveModels: false } : {}),
+    ...(provider.requestPacing === undefined && registryEntry.requestPacing
+      ? { requestPacing: structuredClone(registryEntry.requestPacing) }
+      : {}),
     ...(headers ? { headers } : {}),
     // Backfill the Google wire mode + Vertex project/location from the registry when the user
     // config omits them, so a minimal `google-vertex`/`google-antigravity` entry still routes

package/src/routing/account-pool/cooldown.ts

@@ -63,6 +63,14 @@ export function clearCooldownState(poolKey?: string): void {
   registryByPool.delete(poolKey);
 }
 
+export function clearPoolAccountCooldown(poolKey: string, accountId: string): boolean {
+  const registry = registryByPool.get(poolKey);
+  if (!registry) return false;
+  const existed = registry.get(accountId) !== null;
+  registry.clear(accountId);
+  return existed;
+}
+
 export function parseRetryAfterMs(
   value: string | null | undefined,
   now = Date.now(),

package/src/routing/account-pool/index.ts

@@ -26,6 +26,7 @@ export {
   STICK_WAIT_MAX_MS,
   classifyPoolHttpStatus,
   clearCooldownState,
+  clearPoolAccountCooldown,
   getPoolCooldownRegistry,
   isAccountInCooldown,
   isAccountPoolEligible,