@herbertgao/pi-extensions 2026.9.18 → 2026.9.19

package/node_modules/pi-antigravity/src/auth/accounts.ts

@@ -0,0 +1,327 @@
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { OAuthCredentials } from "@earendil-works/pi-ai";
+import { defaultProjectId } from "../client/client.js";
+import type { AntigravityApiKey, AntigravityOAuthCredentials } from "../types/types.js";
+import { refreshAntigravityToken } from "./oauth.js";
+
+const ACCOUNTS_FILE = "antigravity-accounts.json";
+const AUTH_FILE = "auth.json";
+const REFRESH_SKEW_MS = 5 * 60 * 1000;
+
+export type StoredAccount = AntigravityOAuthCredentials & {
+  accountId: string;
+  addedAt: number;
+  lastUsedAt: number;
+};
+
+type AccountsFile = {
+  version: 1;
+  activeAccountId?: string;
+  accounts: Record<string, StoredAccount>;
+};
+
+export type AccountSummary = {
+  accountId: string;
+  email?: string;
+  active: boolean;
+  lastUsedAt: number;
+};
+
+function agentDir(): string {
+  return process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+}
+
+function accountsPath(): string {
+  return join(agentDir(), ACCOUNTS_FILE);
+}
+
+function authPath(): string {
+  return join(agentDir(), AUTH_FILE);
+}
+
+function readJsonObject(path: string): Record<string, unknown> | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}
+
+function writePrivateJson(path: string, value: unknown): void {
+  const tempPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+  chmodSync(tempPath, 0o600);
+  renameSync(tempPath, path);
+  chmodSync(path, 0o600);
+}
+
+function emptyStore(): AccountsFile {
+  return { version: 1, accounts: {} };
+}
+
+function isStoredAccount(value: unknown): value is StoredAccount {
+  if (!value || typeof value !== "object") return false;
+  const account = value as Partial<StoredAccount>;
+  return typeof account.refresh === "string" && account.refresh.length > 0;
+}
+
+function normalizeStore(value: Record<string, unknown> | undefined): AccountsFile {
+  if (!value || value.version !== 1 || !value.accounts || typeof value.accounts !== "object") {
+    return emptyStore();
+  }
+  const accounts: Record<string, StoredAccount> = {};
+  for (const [key, raw] of Object.entries(value.accounts as Record<string, unknown>)) {
+    if (!isStoredAccount(raw)) continue;
+    const accountId =
+      typeof raw.accountId === "string" && raw.accountId.trim() ? raw.accountId : key;
+    accounts[accountId] = { ...raw, accountId };
+  }
+  const activeAccountId =
+    typeof value.activeAccountId === "string"
+      ? value.activeAccountId
+      : typeof value.activeEmail === "string"
+        ? value.activeEmail
+        : undefined;
+  return {
+    version: 1,
+    activeAccountId: activeAccountId && accounts[activeAccountId] ? activeAccountId : undefined,
+    accounts,
+  };
+}
+
+export function loadAccountStore(): AccountsFile {
+  return normalizeStore(readJsonObject(accountsPath()));
+}
+
+function saveAccountStore(store: AccountsFile): void {
+  writePrivateJson(accountsPath(), store);
+}
+
+function accountIdFor(credentials: OAuthCredentials): string {
+  const email = (credentials as AntigravityOAuthCredentials).email?.trim().toLowerCase();
+  if (email) return email;
+  return `account-${createHash("sha256").update(credentials.refresh).digest("hex").slice(0, 16)}`;
+}
+
+function accountFromCredentials(
+  credentials: AntigravityOAuthCredentials,
+  existing?: StoredAccount,
+): StoredAccount {
+  const now = Date.now();
+  return {
+    ...credentials,
+    accountId: existing?.accountId || accountIdFor(credentials),
+    addedAt: existing?.addedAt || now,
+    lastUsedAt: now,
+  };
+}
+
+function sortedAccounts(store: AccountsFile): StoredAccount[] {
+  return Object.values(store.accounts).sort((a, b) => {
+    if (a.addedAt !== b.addedAt) return a.addedAt - b.addedAt;
+    return a.accountId.localeCompare(b.accountId);
+  });
+}
+
+function findAccount(
+  store: AccountsFile,
+  credentials: OAuthCredentials,
+): StoredAccount | undefined {
+  const email = (credentials as AntigravityOAuthCredentials).email?.trim().toLowerCase();
+  return Object.values(store.accounts).find(
+    (account) =>
+      account.refresh === credentials.refresh ||
+      (email !== undefined && account.email?.trim().toLowerCase() === email),
+  );
+}
+
+function findAccountId(store: AccountsFile, selector: string): string | undefined {
+  const normalized = selector.trim().toLowerCase();
+  if (!normalized) return undefined;
+  const entries = sortedAccounts(store);
+  if (/^\d+$/.test(normalized)) {
+    const index = Number.parseInt(normalized, 10);
+    if (index >= 1 && index <= entries.length) return entries[index - 1]?.accountId;
+    return undefined;
+  }
+  return entries.find(
+    (account) =>
+      account.accountId.toLowerCase() === normalized ||
+      account.email?.trim().toLowerCase() === normalized,
+  )?.accountId;
+}
+
+function readAuthFile(): Record<string, unknown> {
+  const path = authPath();
+  if (!existsSync(path)) return {};
+  const parsed = readJsonObject(path);
+  if (!parsed) {
+    throw new Error("Refusing to overwrite unreadable Pi auth.json");
+  }
+  return parsed;
+}
+
+function writeActiveCredential(account: StoredAccount | undefined): void {
+  const auth = readAuthFile();
+  if (account) {
+    auth.antigravity = {
+      type: "oauth",
+      email: account.email,
+      access: account.access,
+      refresh: account.refresh,
+      expires: account.expires,
+      projectId: account.projectId,
+    };
+  } else {
+    delete auth.antigravity;
+  }
+  writePrivateJson(authPath(), auth);
+}
+
+function currentAuthCredentials(): AntigravityOAuthCredentials | undefined {
+  const current = readJsonObject(authPath())?.antigravity;
+  if (!current || typeof current !== "object") return undefined;
+  const record = current as Record<string, unknown>;
+  if (typeof record.refresh !== "string" || !record.refresh) return undefined;
+  return {
+    access: typeof record.access === "string" ? record.access : "",
+    refresh: record.refresh,
+    expires: typeof record.expires === "number" ? record.expires : 0,
+    projectId: typeof record.projectId === "string" ? record.projectId : undefined,
+    email: typeof record.email === "string" ? record.email : undefined,
+  };
+}
+
+export function syncCurrentAuth(): void {
+  const credentials = currentAuthCredentials();
+  if (!credentials) return;
+  const store = loadAccountStore();
+  const existing = findAccount(store, credentials);
+  const account = accountFromCredentials(credentials, existing);
+  store.accounts[account.accountId] = account;
+  store.activeAccountId = account.accountId;
+  saveAccountStore(store);
+}
+
+export function rememberAccount(credentials: AntigravityOAuthCredentials): StoredAccount {
+  syncCurrentAuth();
+  const store = loadAccountStore();
+  const existing = findAccount(store, credentials);
+  const account = accountFromCredentials(credentials, existing);
+  store.accounts[account.accountId] = account;
+  store.activeAccountId = account.accountId;
+  saveAccountStore(store);
+  return account;
+}
+
+export function updateRememberedAccount(
+  previous: OAuthCredentials,
+  credentials: AntigravityOAuthCredentials,
+): void {
+  const store = loadAccountStore();
+  const existing = findAccount(store, previous);
+  if (!existing) return;
+  const account = accountFromCredentials(credentials, existing);
+  delete store.accounts[existing.accountId];
+  store.accounts[account.accountId] = account;
+  if (store.activeAccountId === existing.accountId) {
+    store.activeAccountId = account.accountId;
+  }
+  saveAccountStore(store);
+}
+
+export function listAccounts(): AccountSummary[] {
+  syncCurrentAuth();
+  const store = loadAccountStore();
+  return sortedAccounts(store).map((account) => ({
+    accountId: account.accountId,
+    email: account.email,
+    active: account.accountId === store.activeAccountId,
+    lastUsedAt: account.lastUsedAt,
+  }));
+}
+
+async function ensureFresh(account: StoredAccount): Promise<StoredAccount> {
+  if (account.access && account.expires > Date.now() + REFRESH_SKEW_MS) return account;
+  return accountFromCredentials(await refreshAntigravityToken(account), account);
+}
+
+function apiKeyFor(account: StoredAccount): AntigravityApiKey {
+  const email = account.email?.trim();
+  return {
+    token: account.access,
+    projectId: account.projectId || defaultProjectId(email || "antigravity-default"),
+  };
+}
+
+export async function activateAccount(selector: string): Promise<StoredAccount> {
+  syncCurrentAuth();
+  const store = loadAccountStore();
+  const accountId = findAccountId(store, selector);
+  if (!accountId) throw new Error(`Antigravity account not found: ${selector}`);
+  const existing = store.accounts[accountId];
+  if (!existing) throw new Error(`Antigravity account not found: ${selector}`);
+  const account = await ensureFresh(existing);
+  account.lastUsedAt = Date.now();
+  store.accounts[account.accountId] = account;
+  store.activeAccountId = account.accountId;
+  saveAccountStore(store);
+  writeActiveCredential(account);
+  return account;
+}
+
+export async function removeAccount(selector: string): Promise<StoredAccount | undefined> {
+  syncCurrentAuth();
+  const store = loadAccountStore();
+  const accountId = findAccountId(store, selector);
+  if (!accountId) throw new Error(`Antigravity account not found: ${selector}`);
+  delete store.accounts[accountId];
+  let next: StoredAccount | undefined;
+  if (store.activeAccountId === accountId) {
+    next = sortedAccounts(store).sort((a, b) => b.lastUsedAt - a.lastUsedAt)[0];
+    if (next) {
+      next = await ensureFresh(next);
+      next.lastUsedAt = Date.now();
+      store.accounts[next.accountId] = next;
+    }
+    store.activeAccountId = next?.accountId;
+    writeActiveCredential(next);
+  }
+  saveAccountStore(store);
+  return next;
+}
+
+/**
+ * Switch to the next stored account that has not already been tried in this request.
+ * Used when Antigravity returns a hard quota wall (HTTP 429).
+ */
+export async function failoverToNextAccount(
+  triedAccessTokens: ReadonlySet<string>,
+): Promise<AntigravityApiKey | undefined> {
+  syncCurrentAuth();
+  const store = loadAccountStore();
+  const candidates = sortedAccounts(store).filter(
+    (account) => !triedAccessTokens.has(account.access),
+  );
+  for (const candidate of candidates) {
+    try {
+      const account = await ensureFresh(candidate);
+      if (!account.access || triedAccessTokens.has(account.access)) continue;
+      account.lastUsedAt = Date.now();
+      store.accounts[account.accountId] = account;
+      store.activeAccountId = account.accountId;
+      saveAccountStore(store);
+      writeActiveCredential(account);
+      return apiKeyFor(account);
+    } catch {
+      // Skip accounts whose refresh token is no longer valid.
+    }
+  }
+  return undefined;
+}

package/node_modules/pi-antigravity/src/auth/index.ts

@@ -12,3 +12,12 @@ export {
   OAUTH_CALLBACK_TIMEOUT_MS,
 } from "./oauth.js";
 export type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth.js";
+export {
+  activateAccount,
+  failoverToNextAccount,
+  listAccounts,
+  rememberAccount,
+  removeAccount,
+  updateRememberedAccount,
+} from "./accounts.js";
+export type { AccountSummary, StoredAccount } from "./accounts.js";

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

@@ -61,7 +61,7 @@ export function endpointCandidates(): string[] {
 }
 
 const DEFAULT_USER_AGENT =
-  "antigravity/cli/1.1.23 (aidev_client; os_type=linux; arch=amd64; cl=974125021; auth_method=consumer)";
+  "antigravity/cli/1.2.4 (aidev_client; os_type=linux; arch=amd64; cl=982146307; auth_method=consumer)";
 
 /** Default User-Agent matching pure Antigravity CLI wire fingerprint. */
 export function defaultUserAgent(): string {

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

@@ -42,15 +42,15 @@ export type ImageGenerateRequest = {
   project: string;
   model: string;
   request: {
-    contents: Array<{ role: GeminiRole.User; parts: Array<{ text: string }> }>;
-    systemInstruction: { role: GeminiRole.User; parts: Array<{ text: string }> };
+    contents: Array<{ role: "user"; parts: Array<{ text: string }> }>;
+    systemInstruction: { role: "user"; parts: Array<{ text: string }> };
     generationConfig: {
       imageConfig: { aspectRatio: string };
       candidateCount: number;
     };
   };
-  requestType: AntigravityRequestType.Agent;
-  userAgent: AntigravityUserAgent.Antigravity;
+  requestType: "agent";
+  userAgent: "antigravity";
   requestId: string;
 };
 

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

@@ -1,8 +1,19 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { StringEnum, Type } from "@earendil-works/pi-ai";
-import { registerApiProvider } from "@earendil-works/pi-ai/compat";
-import { getApiKey, loginAntigravity, refreshAntigravityToken } from "./auth/index.js";
-import { DEFAULT_ENDPOINT, endpointCandidates } from "./client/index.js";
+// Namespace import: Oh My Pi rewrites this specifier onto bundled pi-ai, which
+// does not export registerApiProvider. A static named import fails plugin load.
+import * as piAiCompat from "@earendil-works/pi-ai/compat";
+import {
+  activateAccount,
+  getApiKey,
+  listAccounts,
+  loginAntigravity,
+  rememberAccount,
+  refreshAntigravityToken,
+  removeAccount,
+  updateRememberedAccount,
+} from "./auth/index.js";
+import { DEFAULT_ENDPOINT } from "./client/index.js";
 import { getLastDiagnostics, runWithDiagnostics } from "./diagnostics/index.js";
 import {
   DEFAULT_IMAGE_MODEL,
@@ -10,6 +21,7 @@ import {
   IMAGE_ASPECT_RATIOS,
   parseImageCommandArgs,
 } from "./image/index.js";
+import { executeAntigravitySearch, parseSearchCommandArgs } from "./search/index.js";
 import {
   applyAntigravityCatalog,
   discoverAntigravityModels,
@@ -26,7 +38,7 @@ import {
   formatUsageSummary,
   resolveApiKeyFromContext,
 } from "./usage/index.js";
-import { prewarmConnection, redactSecrets } from "./utils/index.js";
+import { redactSecrets, maskEmail } from "./utils/index.js";
 
 /**
  * Pi's interactive `notify` writes into the chat transcript. `console.log` in that
@@ -45,6 +57,22 @@ function emitCommandOutput(
   else console.log(text);
 }
 
+async function loginAndRemember(
+  callbacks: Parameters<typeof loginAntigravity>[0],
+): ReturnType<typeof loginAntigravity> {
+  const credentials = await loginAntigravity(callbacks);
+  rememberAccount(credentials);
+  return credentials;
+}
+
+async function refreshAndRemember(
+  credentials: Parameters<typeof refreshAntigravityToken>[0],
+): ReturnType<typeof refreshAntigravityToken> {
+  const refreshed = await refreshAntigravityToken(credentials);
+  updateRememberedAccount(credentials, refreshed);
+  return refreshed;
+}
+
 async function withUsage(
   ctx: ExtensionCommandContext,
   fn: (usage: Awaited<ReturnType<typeof fetchAccountUsage>>) => string,
@@ -68,17 +96,29 @@ async function withUsage(
   }
 }
 
-export default function (pi: ExtensionAPI): void {
-  // Open the TLS connection up front so the first message of a session does not pay
-  // the handshake. Opt out with ANTIGRAVITY_NO_PREWARM=1.
-  const primaryEndpoint = endpointCandidates()[0];
-  if (primaryEndpoint) prewarmConnection(primaryEndpoint);
+type CompatApiProviderRegistrar = (provider: {
+  api: typeof ANTIGRAVITY_API;
+  stream: typeof streamAntigravity;
+  streamSimple: typeof streamAntigravity;
+}) => void;
 
-  registerApiProvider({
+/**
+ * Pi dispatches custom APIs through the compat registry. Oh My Pi does not
+ * export `registerApiProvider` and registers the stream inside `registerProvider`.
+ */
+function registerCompatApiProvider(): void {
+  const register = (piAiCompat as { registerApiProvider?: CompatApiProviderRegistrar })
+    .registerApiProvider;
+  if (typeof register !== "function") return;
+  register({
     api: ANTIGRAVITY_API,
     stream: streamAntigravity,
     streamSimple: streamAntigravity,
   });
+}
+
+export default function (pi: ExtensionAPI): void {
+  registerCompatApiProvider();
 
   const initialCatalog = getCurrentAntigravityCatalog();
 
@@ -90,8 +130,8 @@ export default function (pi: ExtensionAPI): void {
     refreshModels: refreshAntigravityModels,
     oauth: {
       name: PROVIDER_NAME,
-      login: loginAntigravity,
-      refreshToken: refreshAntigravityToken,
+      login: loginAndRemember,
+      refreshToken: refreshAndRemember,
       getApiKey,
     },
     streamSimple: streamAntigravity,
@@ -112,6 +152,51 @@ export default function (pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand("antigravity.accounts", {
+    description: "List, switch, or remove linked Antigravity Google accounts",
+    handler: async (args, ctx) => {
+      const command = args.trim();
+      try {
+        if (command.startsWith("switch ")) {
+          const account = await activateAccount(command.slice("switch ".length));
+          emitCommandOutput(
+            ctx,
+            `Active Antigravity account: ${account.email || account.accountId}`,
+          );
+          return;
+        }
+        if (command.startsWith("remove ")) {
+          const remaining = await removeAccount(command.slice("remove ".length));
+          const next = remaining
+            ? ` Active account is now ${remaining.email || remaining.accountId}.`
+            : "";
+          emitCommandOutput(ctx, `Antigravity account removed.${next}`);
+          return;
+        }
+        const accounts = listAccounts();
+        if (accounts.length === 0) {
+          emitCommandOutput(
+            ctx,
+            "No linked Antigravity accounts. Run /login antigravity to add one.",
+            "warning",
+          );
+          return;
+        }
+        const lines = accounts.map(
+          (account, index) =>
+            `${account.active ? "* " : "  "}${index + 1}. ${account.email || account.accountId}`,
+        );
+        emitCommandOutput(
+          ctx,
+          `${lines.join("\n")}\nUse /antigravity.accounts switch <index|email> or /antigravity.accounts remove <index|email>.`,
+        );
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        emitCommandOutput(ctx, msg, "error");
+      }
+    },
+  });
+
   pi.registerCommand("antigravity.refresh", {
     description: "Force refresh Antigravity dynamic model catalog",
     handler: async (_args, ctx) => {
@@ -163,6 +248,12 @@ export default function (pi: ExtensionAPI): void {
     description: "Show sanitized Antigravity provider diagnostics",
     handler: async (_args, ctx) => {
       const d = getLastDiagnostics();
+      const accounts = listAccounts();
+      const active = accounts.find((account) => account.active);
+      const activeLabel = active
+        ? maskEmail(active.email) ||
+          (active.accountId.includes("@") ? maskEmail(active.accountId) : active.accountId)
+        : "none";
       const lines = [
         `provider=${PROVIDER_ID}`,
         `lastResolvedRuntimeModel=${d.resolvedRuntimeModel || "none"}`,
@@ -171,12 +262,14 @@ export default function (pi: ExtensionAPI): void {
         `lastEndpoint=${d.endpoint || "none"}`,
         `lastStatus=${d.status ?? "none"}`,
         `lastProjectId=${d.projectId || "none"}`,
+        `linkedAccounts=${accounts.length || "none"}`,
+        `activeAccount=${activeLabel || "none"}`,
         ...(d.latencyMs !== undefined ? [`lastLatencyMs=${d.latencyMs}`] : []),
         `toolSchemaWarnings=${d.toolSchemaWarnings || "none"}`,
         `lastError=${d.error ? redactSecrets(d.error) : "none"}`,
         "transport=native-streamSimple",
         "runtimeCli=not-used",
-        "commands=/antigravity.usage /antigravity.models /antigravity.refresh /antigravity.doctor /antigravity.image",
+        "commands=/antigravity.usage /antigravity.models /antigravity.accounts /antigravity.refresh /antigravity.doctor /antigravity.image /antigravity.search",
       ];
       emitCommandOutput(ctx, `Antigravity doctor\n${lines.join("\n")}`);
     },
@@ -222,6 +315,44 @@ export default function (pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand("antigravity.search", {
+    description:
+      "Search the web via Antigravity Grounding (usage: /antigravity.search [--thinking] [--url <url>] <query>)",
+    handler: async (args, ctx) => {
+      const parsed = parseSearchCommandArgs(args || "");
+      if (!parsed.query) {
+        emitCommandOutput(
+          ctx,
+          "Usage: /antigravity.search [--thinking] [--url <url>] <query>",
+          "warning",
+        );
+        return;
+      }
+      try {
+        const apiKey = await resolveApiKeyFromContext(ctx);
+        if (!apiKey) {
+          emitCommandOutput(
+            ctx,
+            "No Antigravity credentials. Run /login antigravity first.",
+            "warning",
+          );
+          return;
+        }
+        if (ctx.hasUI) ctx.ui.notify("Searching Google via Antigravity Grounding…", "info");
+        const result = await executeAntigravitySearch({
+          apiKey,
+          query: parsed.query,
+          urls: parsed.urls,
+          thinking: parsed.thinking,
+        });
+        emitCommandOutput(ctx, result);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        emitCommandOutput(ctx, `Antigravity search failed: ${redactSecrets(msg)}`, "warning");
+      }
+    },
+  });
+
   pi.registerTool({
     name: "generate_image",
     label: "Generate image",
@@ -277,4 +408,63 @@ export default function (pi: ExtensionAPI): void {
       };
     },
   });
+
+  pi.registerTool({
+    name: "google_search",
+    label: "Google Search",
+    description:
+      "Search the web using Google Search via Antigravity Grounding powered by Gemini 3 Flash. Returns real-time web results with multi-angle deep search and source citations. Use this whenever current, real-time information or web research is needed.",
+    promptSnippet: "Real-time Google Search grounding via Antigravity (Gemini 3 Flash)",
+    promptGuidelines: [
+      "Use google_search when you need real-time, up-to-date web information, latest news, documentation, or fact checking.",
+      "Pass specific URLs into the urls array if you want the search engine to fetch and analyze specific pages.",
+      "Set instruction to provide special research directives from the lead agent (e.g. focus on issues, compare benchmarks, restrict time range).",
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: "Search query or question." }),
+      instruction: Type.Optional(
+        Type.String({
+          description:
+            "Specific directive or focus from the lead agent (e.g., '重点关注英文社区近七天的讨论', 'focus on GitHub issues and benchmarks', 'ignore marketing announcements').",
+        }),
+      ),
+      urls: Type.Optional(
+        Type.Array(Type.String(), {
+          description: "Optional specific URLs to fetch and analyze alongside the search.",
+        }),
+      ),
+      thinking: Type.Optional(
+        Type.Boolean({
+          description: "Enable deeper thinking for complex analysis (default: false).",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const apiKey = await ctx.modelRegistry.getApiKeyForProvider("antigravity");
+      if (!apiKey) {
+        throw new Error("No Antigravity credentials. Run /login antigravity first.");
+      }
+      onUpdate?.({
+        content: [{ type: "text", text: `Searching Google for: "${params.query}"…` }],
+        details: {},
+      });
+      try {
+        const result = await executeAntigravitySearch({
+          apiKey,
+          query: params.query,
+          instruction: params.instruction,
+          urls: params.urls,
+          thinking: params.thinking,
+          signal,
+        });
+        return {
+          content: [{ type: "text", text: result }],
+          details: {},
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new Error(redactSecrets(msg), { cause: error });
+      }
+    },
+  });
 }

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

@@ -0,0 +1 @@
+export * from "./search.js";