@herbertgao/pi-extensions 2026.9.18 → 2026.9.19

package/node_modules/pi-antigravity/src/search/search.ts

@@ -0,0 +1,325 @@
+import {
+  antigravityHeaders,
+  endpointCandidates,
+  jsonOrTextError,
+  parseApiKey,
+} from "../client/client.js";
+import { AntigravityRequestType, AntigravityUserAgent, GeminiRole } from "../types/enums.js";
+import { antigravityFetch } from "../utils/http.js";
+import { safeError } from "../utils/security.js";
+import { antigravityRequestEnvelope, isRecord } from "../utils/util.js";
+
+/** Default search engine model: fast, natively supports groundings and reasoning. */
+export const DEFAULT_SEARCH_MODEL = "gemini-3-flash";
+
+/** Fallback runtime candidates if the primary flash model is undergoing rollout or capacity limits. */
+export const SEARCH_MODEL_FALLBACKS = [
+  DEFAULT_SEARCH_MODEL,
+  "gemini-3.6-flash-low",
+  "gemini-2.5-flash",
+] as const;
+
+export const SEARCH_SYSTEM_INSTRUCTION = `You are an expert deep-research investigator and technical analyst.
+Your objective is to use Google Search Grounding to unearth rich, high-signal, multi-perspective facts.
+
+Guidelines:
+1. DO NOT settle for generic marketing summaries, public relations announcements, or shallow overviews.
+2. Formulate multiple distinct, targeted search queries covering technical architecture, specific parameters, benchmark comparisons, developer issues, pitfalls, and community feedback.
+3. Prioritize hard technical details: exact version numbers, hardware requirements, protocol constraints, benchmarks, error codes, and configuration snippets.
+4. Structure your response into clean, logical Markdown sections citing direct sources.`;
+
+export type SearchSource = {
+  title: string;
+  url: string;
+};
+
+export type SearchResult = {
+  text: string;
+  sources: SearchSource[];
+  queries: string[];
+};
+
+export type ExecuteSearchOptions = {
+  apiKey?: string;
+  query: string;
+  instruction?: string;
+  urls?: string[];
+  thinking?: boolean;
+  signal?: AbortSignal;
+};
+
+export type SearchCommandArgs = {
+  query: string;
+  urls?: string[];
+  thinking?: boolean;
+};
+
+/**
+ * Parse arguments for the interactive `/antigravity.search` command.
+ * Supports flags:
+ *   --thinking: enable deep reasoning for search planning
+ *   --url <url>: pass target URL for context analysis (can be repeated)
+ *
+ * @param args - Raw string of CLI arguments.
+ * @returns Parsed command arguments containing query, optional URLs, and thinking flag.
+ */
+export function parseSearchCommandArgs(args: string): SearchCommandArgs {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  const out: SearchCommandArgs = { query: "" };
+  const rest: string[] = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === undefined) continue;
+    const next = tokens[i + 1];
+
+    if (token === "--thinking") {
+      out.thinking = true;
+      continue;
+    }
+    if (token === "--url" && next) {
+      out.urls = out.urls ?? [];
+      out.urls.push(next);
+      i += 1;
+      continue;
+    }
+    rest.push(token);
+  }
+
+  out.query = rest.join(" ");
+  return out;
+}
+
+/**
+ * Builds the Antigravity wire request payload for Gemini Google Search Grounding.
+ * Includes the required `requestType` and `requestId` envelope fields.
+ *
+ * @param options - Options including search query, lead agent directives, target URLs, and thinking preference.
+ * @param model - Target model identifier (e.g., `gemini-3-flash`).
+ * @param projectId - Google Cloud Project ID.
+ * @returns Serialized request object matching the Antigravity wire contract.
+ */
+export function buildSearchRequest(
+  options: {
+    query: string;
+    instruction?: string;
+    urls?: string[];
+    thinking?: boolean;
+  },
+  model: string,
+  projectId: string,
+): Record<string, unknown> {
+  let systemInstructionText = SEARCH_SYSTEM_INSTRUCTION;
+  if (options.instruction?.trim()) {
+    systemInstructionText += `\n\n[SPECIFIC DIRECTIVE FROM LEAD AGENT]:\n${options.instruction.trim()}\nYou MUST strictly follow this directive during search query formulation and synthesis.`;
+  }
+
+  let prompt = options.query.trim();
+  if (options.instruction?.trim()) {
+    prompt = `[Lead Agent Directive]: ${options.instruction.trim()}\n\nSearch Query: ${prompt}`;
+  }
+  if (options.urls && options.urls.length > 0) {
+    prompt += `\n\nURLs to analyze in detail:\n${options.urls.join("\n")}`;
+  }
+
+  const tools: Array<Record<string, unknown>> = [{ googleSearch: {} }];
+  if (options.urls && options.urls.length > 0) {
+    tools.push({ urlContext: {} });
+  }
+
+  // Thinking budget: 4096 if explicitly requested, baseline 2048 to trigger multi-step search planning
+  const thinkingBudget = options.thinking ? 4096 : 2048;
+  const envelope = antigravityRequestEnvelope(model, false);
+
+  return {
+    project: projectId,
+    model,
+    request: {
+      systemInstruction: {
+        role: GeminiRole.User,
+        parts: [{ text: systemInstructionText }],
+      },
+      contents: [
+        {
+          role: GeminiRole.User,
+          parts: [{ text: prompt }],
+        },
+      ],
+      tools,
+      generationConfig: {
+        thinkingConfig: {
+          thinkingBudget,
+          includeThoughts: false,
+        },
+      },
+    },
+    requestType: AntigravityRequestType.Agent,
+    userAgent: AntigravityUserAgent.Antigravity,
+    requestId: envelope.requestId,
+  };
+}
+
+/**
+ * Parse candidate text and Grounding metadata from Antigravity API response.
+ *
+ * @param data - Raw JSON response from Antigravity generateContent API.
+ * @returns Structured SearchResult with synthesized text, web queries, and cited source URLs.
+ */
+function candidateList(data: unknown): unknown {
+  if (!isRecord(data)) return undefined;
+  if (isRecord(data.response)) return data.response.candidates;
+  return data.candidates;
+}
+
+function firstUnknownItem(value: unknown): unknown {
+  if (!Array.isArray(value)) return undefined;
+  return (value as unknown[])[0];
+}
+
+export function parseSearchResponse(data: unknown): SearchResult {
+  const result: SearchResult = { text: "", sources: [], queries: [] };
+  if (!isRecord(data)) return result;
+
+  const responseObj = isRecord(data.response) ? data.response : data;
+  const candidates = Array.isArray(responseObj.candidates)
+    ? (responseObj.candidates as unknown[])
+    : [];
+  const candidate = candidates[0];
+
+  if (!isRecord(candidate)) {
+    const errorObj = isRecord(data.error)
+      ? data.error
+      : isRecord(responseObj.error)
+        ? responseObj.error
+        : undefined;
+    const msg =
+      typeof errorObj?.message === "string"
+        ? errorObj.message
+        : "No candidate returned from Antigravity Search";
+    result.text = `Error: ${msg}`;
+    return result;
+  }
+
+  // Extract synthesized text (ignoring thinking parts)
+  const content = isRecord(candidate.content) ? candidate.content : undefined;
+  if (Array.isArray(content?.parts)) {
+    result.text = content.parts
+      .filter((p) => isRecord(p) && !p.thought && typeof p.text === "string")
+      .map((p) => (p as { text: string }).text)
+      .filter(Boolean)
+      .join("\n\n");
+  }
+
+  // Extract grounding citations & executed queries
+  const grounding = isRecord(candidate.groundingMetadata) ? candidate.groundingMetadata : undefined;
+  if (grounding) {
+    if (Array.isArray(grounding.webSearchQueries)) {
+      result.queries = grounding.webSearchQueries.filter((q): q is string => typeof q === "string");
+    }
+    if (Array.isArray(grounding.groundingChunks)) {
+      for (const chunk of grounding.groundingChunks) {
+        if (!isRecord(chunk)) continue;
+        const web = isRecord(chunk.web) ? chunk.web : undefined;
+        if (typeof web?.uri === "string") {
+          result.sources.push({
+            title: typeof web.title === "string" && web.title.trim() ? web.title.trim() : web.uri,
+            url: web.uri,
+          });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Formats structured SearchResult into clean Markdown for agent consumption.
+ *
+ * @param res - Structured search result containing text, sources, and executed queries.
+ * @returns Formatted markdown string.
+ */
+export function formatSearchResult(res: SearchResult): string {
+  const sections: string[] = [];
+
+  if (res.text) {
+    sections.push(res.text);
+  }
+
+  if (res.sources.length > 0) {
+    const list = res.sources.map((s) => `- [${s.title}](${s.url})`).join("\n");
+    sections.push(`### Sources\n${list}`);
+  }
+
+  if (res.queries.length > 0) {
+    const queries = res.queries.map((q) => `\`${q}\``).join(", ");
+    sections.push(`*Search queries: ${queries}*`);
+  }
+
+  return sections.join("\n\n");
+}
+
+/**
+ * Execute real-time Google Search grounding via Antigravity backend with automatic fallback.
+ *
+ * @param options - Execution options containing query, API credentials, and optional directives.
+ * @returns Markdown formatted search result with synthesis, citations, and search queries.
+ */
+export async function executeAntigravitySearch(options: ExecuteSearchOptions): Promise<string> {
+  const query = options.query.trim();
+  if (!query) throw new Error("Search query is required.");
+
+  const creds = parseApiKey(options.apiKey);
+  const headers = antigravityHeaders(creds.token);
+
+  let lastError = "no endpoint available";
+
+  for (const model of SEARCH_MODEL_FALLBACKS) {
+    const body = JSON.stringify(buildSearchRequest(options, model, creds.projectId));
+
+    for (const endpoint of endpointCandidates()) {
+      if (options.signal?.aborted) throw new Error("Search request was aborted");
+
+      try {
+        const response = await antigravityFetch(`${endpoint}/v1internal:generateContent`, {
+          method: "POST",
+          headers,
+          body,
+          signal: options.signal,
+        });
+
+        if (!response.ok) {
+          lastError = jsonOrTextError(await response.text()).slice(0, 400);
+          if (response.status === 404 || [429, 500, 502, 503, 504].includes(response.status)) {
+            continue; // Retry next endpoint for transient failures or missing model endpoints
+          }
+          // Fail fast on non-retryable client errors (e.g. 400 Bad Request, 401 Unauthorized, 403 Forbidden)
+          throw Object.assign(new Error(lastError), { fatal: true });
+        }
+
+        const data: unknown = await response.json();
+        const cand = firstUnknownItem(candidateList(data));
+
+        const candidateText =
+          isRecord(cand) && isRecord(cand.content) && Array.isArray(cand.content.parts)
+            ? (cand.content.parts[0] as { text?: string })?.text
+            : undefined;
+
+        // Skip responses indicating deprecated model and move to next fallback model
+        if (candidateText && candidateText.includes("is no longer available. Please switch")) {
+          lastError = `Model ${model} deprecated: ${candidateText.slice(0, 100)}`;
+          break;
+        }
+
+        const parsed = parseSearchResponse(data);
+        return formatSearchResult(parsed);
+      } catch (error) {
+        if (options.signal?.aborted) throw error;
+        if (error instanceof Error && (error as { fatal?: boolean }).fatal) throw error;
+        lastError = safeError(error).slice(0, 400);
+      }
+    }
+  }
+
+  throw new Error(`Antigravity Google Search failed: ${lastError}`);
+}

package/node_modules/pi-antigravity/src/stream/stream.ts

@@ -10,6 +10,9 @@ import {
   type Tool,
   type ToolCall,
 } from "@earendil-works/pi-ai";
+// Namespace import: transcript helpers exist on pi-ai >= 0.86; resolved at runtime.
+import * as piAi from "@earendil-works/pi-ai";
+import { failoverToNextAccount } from "../auth/accounts.js";
 import {
   antigravityHeaders,
   endpointCandidates,
@@ -71,7 +74,7 @@ import {
   resolveSessionTrajectory,
   sanitizeText,
 } from "../utils/util.js";
-import { antigravityFetch } from "../utils/http.js";
+import { antigravityFetch, prewarmConnection } from "../utils/http.js";
 
 export { ANTIGRAVITY_API };
 
@@ -82,6 +85,7 @@ const ANTIGRAVITY_SYSTEM_INSTRUCTION =
 const ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION =
   'CRITICAL: NEVER output rule checks, formatting guidelines, constraint checklists (e.g. "No emdashes"), or your thinking/personality preambles in the final response. Output only the final response.';
 
+const CONTINUATION_TEXT = "Continue the active task using the available instructions and context.";
 let toolCallCounter = 0;
 
 function sanitizeToolCallId(id: string, fallbackName?: string): string {
@@ -99,6 +103,103 @@ function toolCallIdNeeded(modelId: string, runtimeModel: string): boolean {
   );
 }
 
+interface SystemMessageLike {
+  role?: string;
+  content?: string | Array<{ type?: string; text?: string }>;
+  sections?: Record<string, unknown>;
+  toolsAdded?: Tool[];
+  toolsRemoved?: Array<{ name: string }>;
+  tools?: Tool[];
+}
+
+interface PiAiTranscriptModule {
+  getCurrentTools?: (messages: Context["messages"]) => Tool[];
+  getCurrentSystemPrompt?: (messages: Context["messages"]) => string;
+}
+
+function transcriptModule(): PiAiTranscriptModule {
+  return piAi as unknown as PiAiTranscriptModule;
+}
+
+function asSystemMessages(messages: Context["messages"] | undefined): SystemMessageLike[] {
+  return [...(messages ?? [])] as SystemMessageLike[];
+}
+
+function extractTranscriptSystemPrompt(messages: readonly SystemMessageLike[]): string {
+  const parts: string[] = [];
+  for (const message of messages) {
+    if (message?.role !== "system") continue;
+    if (message.sections && typeof message.sections === "object") {
+      const sectionParts = Object.values(message.sections).filter(
+        (value): value is string => typeof value === "string" && value.trim().length > 0,
+      );
+      if (sectionParts.length > 0) {
+        parts.push(sectionParts.join("\n\n"));
+        continue;
+      }
+    }
+    if (typeof message.content === "string" && message.content.trim()) {
+      parts.push(message.content);
+    } else if (Array.isArray(message.content)) {
+      const texts = message.content
+        .map((block) => (typeof block === "string" ? block : block?.text || ""))
+        .filter((text) => text.trim().length > 0);
+      if (texts.length > 0) parts.push(texts.join("\n\n"));
+    }
+  }
+  return parts.join("\n\n");
+}
+
+function extractTranscriptTools(messages: readonly SystemMessageLike[]): Tool[] {
+  const tools = new Map<string, Tool>();
+  for (const message of messages) {
+    if (message?.role !== "system") continue;
+    for (const tool of message.toolsRemoved ?? []) {
+      tools.delete(tool.name);
+    }
+    for (const tool of [...(message.toolsAdded ?? []), ...(message.tools ?? [])]) {
+      if (tool && typeof tool.name === "string") tools.set(tool.name, tool);
+    }
+  }
+  return [...tools.values()];
+}
+
+/**
+ * pi >= 0.86 hands providers a normalized TranscriptContext: the system prompt and
+ * tool declarations live in system messages and must be read with
+ * `getCurrentSystemPrompt()` / `getCurrentTools()`. Older releases still pass the
+ * flat Context fields. Resolve both so requests are not sent without tools.
+ */
+export function resolveCurrentSystemPrompt(context: Context): string | undefined {
+  const helper = transcriptModule().getCurrentSystemPrompt;
+  if (typeof helper === "function") {
+    try {
+      const fromHelper = helper(context.messages ?? []);
+      if (fromHelper?.trim()) return fromHelper;
+    } catch {
+      // Fall through to local replay / legacy fields.
+    }
+  }
+  const fromTranscript = extractTranscriptSystemPrompt(asSystemMessages(context.messages));
+  if (fromTranscript.trim()) return fromTranscript;
+  return context.systemPrompt;
+}
+
+export function resolveCurrentTools(context: Context): Tool[] | undefined {
+  const helper = transcriptModule().getCurrentTools;
+  if (typeof helper === "function") {
+    try {
+      const fromHelper = helper(context.messages ?? []);
+      if (fromHelper.length > 0) return fromHelper;
+    } catch {
+      // Fall through to local replay / legacy fields.
+    }
+  }
+  const fromTranscript = extractTranscriptTools(asSystemMessages(context.messages));
+  if (fromTranscript.length > 0) return fromTranscript;
+  return context.tools;
+}
+
 const base64SignaturePattern = /^[A-Za-z0-9+/]+={0,2}$/;
 function isValidThoughtSignature(signature?: string): boolean {
   if (!signature || typeof signature !== "string" || signature.length === 0) return false;
@@ -208,6 +309,7 @@ export function convertMessages(
   const requiresSig = geminiRequiresThoughtSignature(runtimeModel);
   const droppedToolCallIds = new Map<string, string>();
   for (const msg of context.messages) {
+    if ((msg.role as string) === "system") continue;
     if (msg.role === "user") {
       const parts = asTextParts(msg.content);
       appendTurn(contents, GeminiRole.User, parts);
@@ -314,6 +416,24 @@ export function convertMessages(
     }
   }
 
+  // A function-call model turn is only valid immediately after a user turn
+  // (including a function-response turn). Compacted history can drop that
+  // boundary, so restore it before applying the natural-language bridge.
+  for (let index = 0; index < contents.length; index += 1) {
+    const turn = contents[index];
+    if (
+      turn?.role === GeminiRole.Model &&
+      turn.parts.some((part) => "functionCall" in part) &&
+      contents[index - 1]?.role !== GeminiRole.User
+    ) {
+      contents.splice(index, 0, {
+        role: GeminiRole.User,
+        parts: [{ text: CONTINUATION_TEXT }],
+      });
+      index += 1;
+    }
+  }
+
   // Google Antigravity requires a natural-language user part in the request,
   // including tool-only continuation turns. Keep injected Skills in the system
   // instruction, then add this protocol bridge only when existing context gives
@@ -325,13 +445,23 @@ export function convertMessages(
   );
   if (!hasUserText && contents.length > 0) {
     const bridge = {
-      text: "Continue the active task using the available instructions and context.",
+      text: CONTINUATION_TEXT,
     };
     const userTurn = contents.find((turn) => turn.role === GeminiRole.User);
     if (userTurn) userTurn.parts.push(bridge);
     else contents.unshift({ role: GeminiRole.User, parts: [bridge] });
   }
 
+  const lastTurn = contents.at(-1);
+  if (lastTurn?.role === GeminiRole.Model) {
+    if (lastTurn.parts.some((part) => "functionCall" in part)) {
+      throw new Error(
+        "Antigravity request is missing tool result(s) for the final assistant tool call. Provide the corresponding tool result before continuing.",
+      );
+    }
+    appendTurn(contents, GeminiRole.User, [{ text: CONTINUATION_TEXT }]);
+  }
+
   return contents;
 }
 
@@ -756,8 +886,10 @@ export function buildRequest(
   const injectedSkills = context.messages.flatMap((msg) =>
     msg.role === "user" ? skillBlocks(msg.content) : [],
   );
-  const systemParts = context.systemPrompt
-    ? [{ text: sanitizeText(context.systemPrompt) }]
+  const systemPromptText = resolveCurrentSystemPrompt(context);
+  const declaredTools = resolveCurrentTools(context);
+  const systemParts = systemPromptText
+    ? [{ text: sanitizeText(systemPromptText) }]
     : [{ text: ANTIGRAVITY_SYSTEM_INSTRUCTION }, { text: ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION }];
   systemParts.push(...injectedSkills.map((skill) => ({ text: sanitizeText(skill) })));
 
@@ -767,7 +899,7 @@ export function buildRequest(
       turn.role === GeminiRole.User &&
       turn.parts.some((part) => "text" in part && Boolean(part.text.trim())),
   );
-  if (!hasUserText && (injectedSkills.length > 0 || Boolean(context.systemPrompt))) {
+  if (!hasUserText && (injectedSkills.length > 0 || Boolean(systemPromptText))) {
     contents.unshift({
       role: GeminiRole.User,
       parts: [{ text: "Apply the active system instructions." }],
@@ -795,7 +927,7 @@ export function buildRequest(
   if (Object.keys(generationConfig).length) request.generationConfig = generationConfig;
 
   const isClaude = model.id.startsWith("claude-") || runtimeModel.startsWith("claude-");
-  const tools = convertTools(context.tools, isClaude || model.id.startsWith("gpt-oss-"));
+  const tools = convertTools(declaredTools, isClaude || model.id.startsWith("gpt-oss-"));
   if (tools) {
     request.tools = tools;
   }
@@ -825,7 +957,7 @@ export function buildRequest(
       (m) => m.role === "assistant" && m.stopReason !== "error" && m.stopReason !== "aborted",
     ).length ?? 0;
 
-  const { conversationId, trajectoryId } = resolveSessionTrajectory(context);
+  const { conversationId, trajectoryId } = resolveSessionTrajectory(context, options.sessionId);
 
   const envelope = antigravityRequestEnvelope(runtimeModel, {
     isClaude,
@@ -860,6 +992,16 @@ export function mapStopReason(reason: string | undefined): StopReason {
 export function friendlyAntigravityError(status: number | undefined, text: string): string {
   const msg = redactSecrets(jsonOrTextError(text)).slice(0, 500);
   if (status === 400) {
+    if (/Requests ending with a model turn are not supported/i.test(msg)) {
+      return "Antigravity rejected an invalid conversation message boundary. Next: update the extension or add a user message / start a new session, then retry.";
+    }
+    if (
+      /function call turn comes immediately after a user turn or after a function response turn/i.test(
+        msg,
+      )
+    ) {
+      return "Antigravity rejected an invalid function-call message boundary. Next: update the extension or start a new session, then retry; re-login is not required.";
+    }
     if (/API key not valid|API_KEY_INVALID/i.test(msg)) {
       return "Antigravity login expired or credentials are invalid. Next: run /login antigravity, then retry.";
     }
@@ -895,10 +1037,20 @@ export function friendlyAntigravityError(status: number | undefined, text: strin
     if (/Individual quota reached/i.test(msg)) {
       return `Quota reached. Please wait ${wait || "for reset"}. Next: switch models or try again after reset.`;
     }
-    if (/quota/i.test(msg)) {
+    // Google answers a real quota wall with a "Resets in …" hint, but uses generic
+    // RESOURCE_EXHAUSTED ("Resource has been exhausted (e.g. check quota).") for
+    // transient throttling and capacity pressure. Classifying on the word "quota"
+    // alone wrongly marked transient throttling as a hard quota wall, disabling
+    // Pi's automatic retry backoff. Keep real quota walls non-retryable, and
+    // format transient throttling so Pi's retry mechanism engages.
+    const hardLimit =
+      Boolean(wait) ||
+      (!/rate.?limit/i.test(msg) &&
+        /quota exceeded|exceeded your|limit reached|reached your|daily limit/i.test(msg));
+    if (hardLimit) {
       return `Quota reached.${wait ? ` Please wait ${wait}.` : ""} Next: switch models or retry later.`;
     }
-    return `Rate limited by Antigravity. Next: wait a bit and retry.${wait ? ` Reset: ${wait}.` : ""}`;
+    return "Rate limited by Antigravity (429 ResourceExhausted). Next: retrying automatically; if it persists, switch models.";
   }
   if (status === 500) {
     return "Antigravity had an internal server error. Next: retry in a moment or switch models.";
@@ -1003,7 +1155,6 @@ function guardResponseBody(
     if (stallMs <= 0) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => controller.abort(stallError(stallMs)), stallMs);
-    timer.unref?.();
   };
   let streamController: ReadableStreamDefaultController<Uint8Array> | undefined;
   const abortBody = () => {
@@ -1278,10 +1429,13 @@ export function streamAntigravity(
     const startTime = Date.now();
     const output = createOutput(model);
     try {
-      const creds = parseApiKey(opts.apiKey);
+      let creds = parseApiKey(opts.apiKey);
+      const triedAccessTokens = new Set<string>([creds.token]);
+      const primaryEndpoint = endpointCandidates()[0];
+      if (primaryEndpoint) prewarmConnection(primaryEndpoint);
       // Skip loadCodeAssist roundtrip when credentials already carry a projectId.
       const warmedProject = creds.projectId ? null : await loadCodeAssist(creds.token);
-      const projectId = resolveProjectId({
+      let projectId = resolveProjectId({
         token: creds.token,
         warmedProject,
         credentialProjectId: creds.projectId,
@@ -1309,7 +1463,7 @@ export function streamAntigravity(
         runtimeCandidates.push(fallback);
       }
 
-      const requestHeaders = antigravityHeaders(creds.token);
+      let requestHeaders = antigravityHeaders(creds.token);
 
       let response: Response | undefined;
       let lastText = "";
@@ -1344,7 +1498,15 @@ export function streamAntigravity(
             setLastStatus(response.status);
             if (response.ok) break;
             lastText = await response.text();
-            if (response.status === 429 && /Individual quota reached/i.test(lastText)) break;
+            if (
+              response.status === 429 &&
+              (/Individual quota reached/i.test(lastText) ||
+                /Resets? in /i.test(lastText) ||
+                (!/rate.?limit/i.test(lastText) &&
+                  /quota exceeded|exceeded your|daily limit/i.test(lastText)))
+            ) {
+              break;
+            }
             if (![403, 404, 429, 500, 502, 503, 504].includes(response.status)) break;
           }
 
@@ -1405,6 +1567,21 @@ export function streamAntigravity(
           }
           const friendly = friendlyAntigravityError(response?.status, lastText);
           if (response?.status === 429 && /Quota reached\./i.test(friendly)) {
+            const next = await failoverToNextAccount(triedAccessTokens);
+            if (next) {
+              triedAccessTokens.add(next.token);
+              creds = next;
+              requestHeaders = antigravityHeaders(creds.token);
+              const switchedProject = creds.projectId ? null : await loadCodeAssist(creds.token);
+              projectId = resolveProjectId({
+                token: creds.token,
+                warmedProject: switchedProject,
+                credentialProjectId: creds.projectId,
+              });
+              setLastProjectId(projectId);
+              emptyAttempt = -1;
+              continue;
+            }
             throw new Error(friendly);
           }
           throw new Error(