@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

package/node_modules/pi-antigravity/src/types/enums.ts

@@ -0,0 +1,42 @@
+export enum ThinkingEffort {
+  Off = "off",
+  Minimal = "minimal",
+  Low = "low",
+  Medium = "medium",
+  High = "high",
+  Xhigh = "xhigh",
+}
+
+export enum ToolChoice {
+  Auto = "auto",
+  None = "none",
+  Any = "any",
+  Required = "required",
+}
+
+export enum GeminiToolCallingMode {
+  None = "NONE",
+  Any = "ANY",
+  Auto = "AUTO",
+  Validated = "VALIDATED",
+}
+
+export enum GeminiRole {
+  User = "user",
+  Model = "model",
+}
+
+export enum AntigravityRequestType {
+  Agent = "agent",
+}
+
+export enum AntigravityUserAgent {
+  Antigravity = "antigravity",
+}
+
+export enum StopReason {
+  Stop = "stop",
+  Length = "length",
+  ToolUse = "toolUse",
+  Error = "error",
+}

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

@@ -0,0 +1,2 @@
+export * from "./enums.js";
+export * from "./types.js";

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

@@ -0,0 +1,292 @@
+import type { Server } from "node:http";
+import type {
+  OAuthCredentials,
+  SimpleStreamOptions,
+  TextContent,
+  ThinkingContent,
+  ToolCall,
+} from "@earendil-works/pi-ai";
+import type {
+  AntigravityRequestType,
+  AntigravityUserAgent,
+  GeminiRole,
+  GeminiToolCallingMode,
+  ThinkingEffort,
+  ToolChoice,
+} from "./enums.js";
+
+// OAuth & Auth Types
+export type AntigravityOAuthCredentials = OAuthCredentials & {
+  projectId?: string;
+  email?: string;
+};
+
+export type AntigravityApiKey = {
+  token: string;
+  projectId: string;
+};
+
+export type DynamicModelInfo = {
+  id: string;
+  experiments?: string[];
+  apiProvider?: string;
+  modelProvider?: string;
+  model?: string;
+};
+
+export type CallbackServer = {
+  server: Server;
+  waitForCode: () => Promise<{ code: string; state: string }>;
+  cleanup: () => void;
+};
+
+// Model Types
+export type AntigravityRouting = {
+  off?: string;
+  routing?: Partial<Record<ThinkingEffort, string>>;
+  defaultRequestId?: string;
+};
+
+// Stream & API Types
+export const ANTIGRAVITY_API = "antigravity-api" as const;
+export type AntigravityApi = typeof ANTIGRAVITY_API;
+
+export type AntigravityStreamOptions = Omit<SimpleStreamOptions, "toolChoice"> & {
+  toolChoice?: ToolChoice | `${ToolChoice}`;
+};
+
+export type GeminiTextPart = { text: string; thoughtSignature?: string };
+export type GeminiInlineDataPart = { inlineData: { mimeType: string; data: string } };
+export type GeminiThoughtPart = {
+  thought: true;
+  text: string;
+  thoughtSignature?: string;
+};
+export type GeminiFunctionCallPart = {
+  functionCall: {
+    name: string;
+    args: Record<string, unknown>;
+    id?: string;
+  };
+  thoughtSignature?: string;
+};
+export type GeminiFunctionResponsePart = {
+  functionResponse: {
+    name: string;
+    response: { error: string } | { output: string };
+    id?: string;
+  };
+};
+export type GeminiPart =
+  | GeminiTextPart
+  | GeminiInlineDataPart
+  | GeminiThoughtPart
+  | GeminiFunctionCallPart
+  | GeminiFunctionResponsePart;
+
+export type GeminiContent = {
+  role: GeminiRole;
+  parts: GeminiPart[];
+};
+
+export type GeminiFunctionDeclaration = {
+  name: string;
+  description: string;
+  parameters?: unknown;
+  parametersJsonSchema?: unknown;
+};
+
+export type GeminiToolConfig = {
+  functionCallingConfig: {
+    mode: GeminiToolCallingMode;
+  };
+};
+
+export type ThinkingWire = {
+  includeThoughts: boolean;
+  thinkingBudget: number;
+};
+
+export type GeminiGenerationConfig = {
+  temperature?: number;
+  maxOutputTokens?: number;
+  thinkingConfig?: ThinkingWire;
+};
+
+export type GeminiRequestBody = {
+  contents: GeminiContent[];
+  systemInstruction: {
+    role: GeminiRole.User;
+    parts: GeminiTextPart[];
+  };
+  generationConfig?: GeminiGenerationConfig;
+  tools?: { functionDeclarations: GeminiFunctionDeclaration[] }[];
+  toolConfig?: GeminiToolConfig;
+  sessionId?: string;
+  labels?: Record<string, string>;
+};
+
+export type AntigravityGenerateRequest = {
+  project: string;
+  model: string;
+  request: GeminiRequestBody;
+  requestType: AntigravityRequestType.Agent;
+  userAgent: AntigravityUserAgent.Antigravity;
+  requestId: string;
+};
+
+export type StreamPart = {
+  text?: string;
+  thought?: boolean;
+  thoughtSignature?: string;
+  functionCall?: {
+    id?: string;
+    name?: string;
+    args?: Record<string, unknown>;
+  };
+};
+
+export type StreamUsageMetadata = {
+  promptTokenCount?: number;
+  cachedContentTokenCount?: number;
+  candidatesTokenCount?: number;
+  thoughtsTokenCount?: number;
+  totalTokenCount?: number;
+};
+
+export type StreamCandidate = {
+  content?: { parts?: StreamPart[] };
+  finishReason?: string;
+};
+
+export type StreamResponseData = {
+  candidates?: StreamCandidate[];
+  usageMetadata?: StreamUsageMetadata;
+};
+
+export type StreamChunk = StreamResponseData & {
+  error?: { message?: string };
+  response?: StreamResponseData;
+};
+
+export type LooseImageBlock = {
+  type: "image";
+  data?: string;
+  mimeType?: string;
+  mediaType?: string;
+  source?: { data?: string; mediaType?: string };
+};
+
+export type ContentBlock = TextContent | ThinkingContent | ToolCall | LooseImageBlock;
+
+export type ActiveTextBlock = TextContent;
+export type ActiveThinkingBlock = ThinkingContent;
+export type ActiveBlock = ActiveTextBlock | ActiveThinkingBlock;
+
+// Usage & Quota Types
+export type QuotaBucket = {
+  bucketId: string;
+  displayName: string;
+  window?: string;
+  resetTime?: string;
+  description?: string;
+  remainingFraction: number;
+};
+
+export type QuotaGroup = {
+  displayName: string;
+  description?: string;
+  buckets: QuotaBucket[];
+};
+
+export type ModelQuotaRow = {
+  modelId: string;
+  displayName?: string;
+  remainingFraction?: number;
+  resetTime?: string;
+  modelProvider?: string;
+  supportsThinking?: boolean;
+  supportsImages?: boolean;
+  recommended?: boolean;
+};
+
+export type TierInfo = {
+  id?: string;
+  name?: string;
+  description?: string;
+};
+
+export type AccountUsage = {
+  projectId: string;
+  endpoint: string;
+  email?: string;
+  productTier?: TierInfo;
+  paidTier?: TierInfo;
+  planLabel?: string;
+  groups: QuotaGroup[];
+  groupDescription?: string;
+  /** Set when the (subscription-gated) quota-summary RPC was unavailable, e.g. free-tier SUBSCRIPTION_REQUIRED. */
+  quotaSummaryError?: string;
+  models: ModelQuotaRow[];
+  defaultAgentModelId?: string;
+  fetchedAt: number;
+};
+
+export type ApiErrorBody = {
+  error?: { message?: string };
+  raw?: string;
+};
+
+export type QuotaBucketRaw = {
+  bucketId?: unknown;
+  displayName?: unknown;
+  window?: unknown;
+  resetTime?: unknown;
+  description?: unknown;
+  remainingFraction?: unknown;
+};
+
+export type QuotaGroupRaw = {
+  displayName?: unknown;
+  description?: unknown;
+  buckets?: QuotaBucketRaw[];
+};
+
+export type QuotaSummaryRaw = {
+  description?: unknown;
+  groups?: QuotaGroupRaw[];
+};
+
+export type ModelInfoRaw = {
+  isInternal?: unknown;
+  displayName?: unknown;
+  label?: unknown;
+  modelName?: unknown;
+  model?: unknown;
+  modelProvider?: unknown;
+  apiProvider?: unknown;
+  supportsThinking?: unknown;
+  supportsImages?: unknown;
+  recommended?: unknown;
+  quotaInfo?: {
+    remainingFraction?: unknown;
+    resetTime?: unknown;
+  };
+};
+
+export type AvailableModelsRaw = {
+  models?: Record<string, ModelInfoRaw>;
+  defaultAgentModelId?: unknown;
+  defaultAgentModel?: unknown;
+};
+
+export type TierRaw = {
+  id?: unknown;
+  name?: unknown;
+  description?: unknown;
+};
+
+export type LoadCodeAssistRaw = {
+  currentTier?: TierRaw;
+  paidTier?: TierRaw;
+};

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

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

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

@@ -0,0 +1,371 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  antigravityHeaders,
+  endpointCandidates,
+  extractProjectId,
+  fetchAvailableModelsCatalog,
+  parseApiKey,
+  resolveProjectId,
+} from "../client/client.js";
+import {
+  setLastEndpoint,
+  setLastError,
+  setLastProjectId,
+  setLastStatus,
+} from "../diagnostics/diagnostics.js";
+import { isRecord } from "../utils/util.js";
+import { safeError } from "../utils/security.js";
+import { antigravityFetch } from "../utils/http.js";
+import type {
+  AccountUsage,
+  ApiErrorBody,
+  AvailableModelsRaw,
+  LoadCodeAssistRaw,
+  ModelQuotaRow,
+  QuotaBucket,
+  QuotaGroup,
+  QuotaSummaryRaw,
+  TierInfo,
+  TierRaw,
+} from "../types/types.js";
+
+function clampFraction(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+
+function remainingPercent(remaining?: number): number | undefined {
+  if (remaining === undefined) return undefined;
+  return Math.round(remaining * 1000) / 10;
+}
+
+function progressBar(remaining?: number, width = 20): string {
+  if (remaining === undefined) return `[${"?".repeat(width)}]`;
+  const filled = Math.max(0, Math.min(width, Math.round(remaining * width)));
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+}
+
+function formatReset(resetTime?: string): string {
+  if (!resetTime) return "n/a";
+  const ts = Date.parse(resetTime);
+  if (!Number.isFinite(ts)) return resetTime;
+  const delta = ts - Date.now();
+  if (delta <= 0) return "now";
+  const totalMin = Math.round(delta / 60000);
+  const days = Math.floor(totalMin / (60 * 24));
+  const hours = Math.floor((totalMin % (60 * 24)) / 60);
+  const mins = totalMin % 60;
+  if (days > 0) return `${days}d ${hours}h`;
+  if (hours > 0) return `${hours}h ${mins}m`;
+  return `${mins}m`;
+}
+
+function jsonHeaders(token: string): Record<string, string> {
+  return {
+    ...antigravityHeaders(token),
+    Accept: "application/json",
+  };
+}
+
+async function postJson(
+  path: string,
+  token: string,
+  body: Record<string, unknown>,
+): Promise<{ endpoint: string; status: number; data: unknown }> {
+  let lastErrorText = "";
+  for (const endpoint of endpointCandidates()) {
+    try {
+      const res = await antigravityFetch(`${endpoint}${path}`, {
+        method: "POST",
+        headers: jsonHeaders(token),
+        body: JSON.stringify(body),
+      });
+      setLastEndpoint(endpoint);
+      setLastStatus(res.status);
+      const text = await res.text();
+      let data: unknown;
+      try {
+        data = JSON.parse(text) as unknown;
+      } catch {
+        data = { raw: text } satisfies ApiErrorBody;
+      }
+      if (!res.ok) {
+        const errorBody = isRecord(data) ? (data as ApiErrorBody) : undefined;
+        lastErrorText =
+          typeof errorBody?.error?.message === "string" ? errorBody.error.message : text;
+        if (![403, 404, 429, 500, 502, 503, 504].includes(res.status)) {
+          throw new Error(`${path} failed (${String(res.status)}): ${lastErrorText.slice(0, 300)}`);
+        }
+        continue;
+      }
+      return { endpoint, status: res.status, data };
+    } catch (error) {
+      lastErrorText = safeError(error);
+      setLastError(lastErrorText);
+    }
+  }
+  throw new Error(`${path} failed: ${lastErrorText || "no endpoint available"}`);
+}
+
+function parseQuotaSummary(data: unknown): { groups: QuotaGroup[]; description?: string } {
+  const summary = (isRecord(data) ? data : {}) as QuotaSummaryRaw;
+  const groups: QuotaGroup[] = [];
+  for (const group of summary.groups || []) {
+    const buckets: QuotaBucket[] = [];
+    for (const bucket of group.buckets || []) {
+      const remaining = clampFraction(bucket.remainingFraction);
+      if (remaining === undefined && !bucket.bucketId) continue;
+      buckets.push({
+        bucketId: String(bucket.bucketId || bucket.displayName || "unknown"),
+        displayName: String(bucket.displayName || bucket.bucketId || "Limit"),
+        window: bucket.window ? String(bucket.window) : undefined,
+        resetTime: bucket.resetTime ? String(bucket.resetTime) : undefined,
+        description: bucket.description ? String(bucket.description) : undefined,
+        remainingFraction: remaining ?? 0,
+      });
+    }
+    if (!buckets.length && !group.displayName) continue;
+    groups.push({
+      displayName: String(group.displayName || "Quota group"),
+      description: group.description ? String(group.description) : undefined,
+      buckets,
+    });
+  }
+  return {
+    groups,
+    description: summary.description ? String(summary.description) : undefined,
+  };
+}
+
+function parseModels(data: unknown): {
+  models: ModelQuotaRow[];
+  defaultAgentModelId?: string;
+} {
+  const raw = (isRecord(data) ? data : {}) as AvailableModelsRaw;
+  const modelsObj = raw.models && isRecord(raw.models) ? raw.models : {};
+  const models: ModelQuotaRow[] = [];
+  for (const [modelId, info] of Object.entries(modelsObj)) {
+    if (!info || !isRecord(info)) continue;
+    if (info.isInternal || String(modelId).startsWith("chat_")) continue;
+    const qi = isRecord(info.quotaInfo) ? info.quotaInfo : {};
+    models.push({
+      modelId,
+      displayName:
+        typeof info.displayName === "string"
+          ? info.displayName
+          : typeof info.label === "string"
+            ? info.label
+            : typeof info.modelName === "string"
+              ? info.modelName
+              : undefined,
+      remainingFraction: clampFraction(qi.remainingFraction),
+      resetTime: qi.resetTime ? String(qi.resetTime) : undefined,
+      modelProvider:
+        typeof info.modelProvider === "string"
+          ? info.modelProvider
+          : typeof info.apiProvider === "string"
+            ? info.apiProvider
+            : undefined,
+      supportsThinking: !!info.supportsThinking,
+      supportsImages: !!info.supportsImages,
+      recommended: !!info.recommended,
+    });
+  }
+  models.sort((a, b) => a.modelId.localeCompare(b.modelId));
+  return {
+    models,
+    defaultAgentModelId:
+      raw.defaultAgentModelId || raw.defaultAgentModel
+        ? String(raw.defaultAgentModelId || raw.defaultAgentModel)
+        : undefined,
+  };
+}
+
+function parseTier(value: unknown): TierInfo | undefined {
+  if (!isRecord(value)) return undefined;
+  const tier = value as TierRaw;
+  if (!tier.id && !tier.name) return undefined;
+  return {
+    id: tier.id ? String(tier.id) : undefined,
+    name: tier.name ? String(tier.name) : undefined,
+    description: tier.description ? String(tier.description) : undefined,
+  };
+}
+
+async function loadCodeAssistSafe(token: string) {
+  try {
+    return await postJson("/v1internal:loadCodeAssist", token, {
+      metadata: {
+        ideType: "ANTIGRAVITY",
+        platform: "PLATFORM_UNSPECIFIED",
+        pluginType: "GEMINI",
+      },
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The user-quota-summary RPC is gated behind a paid subscription: free-tier
+ * accounts get 403 SUBSCRIPTION_REQUIRED (#3501). It is best-effort diagnostics
+ * only — never let it block the rest of the account data (models, tier, project).
+ */
+async function fetchQuotaSummarySafe(token: string): Promise<
+  | { ok: true; result: { endpoint: string; status: number; data: unknown } }
+  | {
+      ok: false;
+      error: string;
+    }
+> {
+  try {
+    return { ok: true, result: await postJson("/v1internal:retrieveUserQuotaSummary", token, {}) };
+  } catch (error) {
+    const msg = safeError(error);
+    setLastError(msg);
+    return { ok: false, error: msg };
+  }
+}
+
+export async function fetchAccountUsage(apiKeyRaw?: string): Promise<AccountUsage> {
+  const creds = parseApiKey(apiKeyRaw);
+  const initialProjectId =
+    creds.projectId ||
+    resolveProjectId({
+      token: creds.token,
+      credentialProjectId: creds.projectId,
+    });
+
+  // Fetch loadCodeAssist, quota summary, and available models all in parallel
+  // to minimize command execution latency.
+  const [assistResult, summaryRes, available] = await Promise.all([
+    loadCodeAssistSafe(creds.token),
+    fetchQuotaSummarySafe(creds.token),
+    fetchAvailableModelsCatalog(creds.token, initialProjectId),
+  ]);
+
+  // Derive project ID from the loadCodeAssist response or stored project ID.
+  const discoveredProject = assistResult ? extractProjectId(assistResult.data) : undefined;
+  const projectId = resolveProjectId({
+    token: creds.token,
+    warmedProject: discoveredProject ?? null,
+    credentialProjectId: creds.projectId,
+  });
+  setLastProjectId(projectId);
+
+  const summary = summaryRes.ok ? summaryRes.result : null;
+  const quotaSummaryError = summaryRes.ok ? undefined : summaryRes.error;
+  const { groups, description } = summary
+    ? parseQuotaSummary(summary.data)
+    : { groups: [], description: undefined };
+  const { models, defaultAgentModelId } = parseModels(available.data);
+
+  const assistData = (isRecord(assistResult?.data) ? assistResult.data : {}) as LoadCodeAssistRaw;
+  const productTier = parseTier(assistData.currentTier);
+  const paidTier = parseTier(assistData.paidTier);
+
+  // Google returns currentTier=free-tier even for Google AI Pro accounts.
+  // The real subscription lives in paidTier (e.g. g1-pro-tier / Google AI Pro).
+  const planLabel = paidTier?.name
+    ? `${paidTier.name}${paidTier.id ? ` (${paidTier.id})` : ""}`
+    : productTier?.name
+      ? `${productTier.name}${productTier.id ? ` (${productTier.id})` : ""}`
+      : undefined;
+
+  return {
+    projectId,
+    endpoint: summary?.endpoint ?? available.endpoint ?? assistResult?.endpoint,
+    productTier,
+    paidTier,
+    planLabel,
+    groups,
+    groupDescription: description,
+    quotaSummaryError,
+    models,
+    defaultAgentModelId,
+    fetchedAt: Date.now(),
+  };
+}
+
+function quotaErrorNote(msg: string): string {
+  if (/SUBSCRIPTION_REQUIRED|#3501|(?:lack|missing).*license/i.test(msg)) {
+    return "Aggregate quota summary needs a paid subscription (free-tier can't use that endpoint). Per-model usage is still available via /antigravity.models.";
+  }
+  return `Aggregate quota summary unavailable: ${msg.slice(0, 160)}`;
+}
+
+export function formatUsageSummary(usage: AccountUsage): string {
+  const lines: string[] = [];
+
+  if (usage.planLabel) lines.push(usage.planLabel);
+
+  if (!usage.groups.length) {
+    if (usage.quotaSummaryError) {
+      lines.push(quotaErrorNote(usage.quotaSummaryError));
+    } else {
+      lines.push("No quota groups returned.");
+    }
+    return lines.join("\n");
+  }
+
+  for (const group of usage.groups) {
+    if (lines.length) lines.push("");
+    lines.push(group.displayName);
+    for (const bucket of group.buckets) {
+      const rem = remainingPercent(bucket.remainingFraction);
+      lines.push(
+        `  ${progressBar(bucket.remainingFraction)} ${bucket.displayName}: ${rem ?? "?"}% left · resets ${formatReset(bucket.resetTime)}`,
+      );
+    }
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+export function formatModelsList(usage: AccountUsage, opts?: { all?: boolean }): string {
+  const lines: string[] = [];
+  lines.push("Antigravity available models");
+  lines.push(`project=${usage.projectId}`);
+  if (usage.defaultAgentModelId) lines.push(`defaultAgentModel=${usage.defaultAgentModelId}`);
+  lines.push("");
+
+  const rows = opts?.all
+    ? usage.models
+    : usage.models.filter((m) => !/tab_|chat_/i.test(m.modelId));
+
+  if (!rows.length) {
+    lines.push("No models returned.");
+    return lines.join("\n");
+  }
+
+  const maxId = Math.max(...rows.map((m) => m.modelId.length), 8);
+  for (const m of rows) {
+    const rem = remainingPercent(m.remainingFraction);
+    const flags = [
+      m.recommended ? "recommended" : "",
+      m.supportsThinking ? "thinking" : "",
+      m.supportsImages ? "images" : "",
+    ]
+      .filter(Boolean)
+      .join(",");
+    const name = m.displayName && m.displayName !== m.modelId ? `  ${m.displayName}` : "";
+    lines.push(
+      `${m.modelId.padEnd(maxId)}  rem ${rem === undefined ? "  ?" : String(rem).padStart(5)}%  reset ${formatReset(m.resetTime).padEnd(8)}${flags ? `  [${flags}]` : ""}${name}`,
+    );
+  }
+  lines.push("");
+  lines.push("Note: remaining % is pool-shared (not a private per-model budget).");
+  return lines.join("\n");
+}
+
+export async function resolveApiKeyFromContext(
+  ctx: ExtensionCommandContext,
+): Promise<string | undefined> {
+  try {
+    return await ctx.modelRegistry.getApiKeyForProvider("antigravity");
+  } catch {
+    return undefined;
+  }
+}