@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

package/node_modules/pi-antigravity/src/models/discovery.ts

@@ -0,0 +1,154 @@
+import type {
+  Api,
+  Credential,
+  Model,
+  ModelsStoreEntry,
+  RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { getApiKey } from "../auth/index.js";
+import { DEFAULT_ENDPOINT, fetchAvailableModelsCatalog, parseApiKey } from "../client/index.js";
+import { ANTIGRAVITY_API } from "../types/types.js";
+import { antigravityEnv, isRecord } from "../utils/util.js";
+import { buildAntigravityCatalog, resolvedCatalog, type AntigravityCatalog } from "./grouping.js";
+import {
+  ANTIGRAVITY_MODELS,
+  ANTIGRAVITY_ROUTING,
+  applyAntigravityCatalog,
+  getCurrentAntigravityCatalog,
+  registerDiscoveredModelEnums,
+  restoreDynamicModelEnums,
+  snapshotDynamicModelEnums,
+} from "./models.js";
+
+export const DEFAULT_CATALOG_REFRESH_INTERVAL_MS = 4 * 60 * 60 * 1000;
+export const ANTIGRAVITY_PERSIST_KEY = "pi-antigravity";
+
+type PersistedAntigravityCatalog = {
+  catalog: AntigravityCatalog;
+  checkedAt: number;
+  modelEnums: Record<string, string>;
+};
+
+export function getCatalogRefreshIntervalMs(): number {
+  const envVal =
+    antigravityEnv("CATALOG_REFRESH_INTERVAL_MS") ?? antigravityEnv("REFRESH_INTERVAL_MS");
+  if (envVal) {
+    const parsed = Number.parseInt(envVal, 10);
+    if (!Number.isNaN(parsed) && parsed >= 0) return parsed;
+  }
+  return DEFAULT_CATALOG_REFRESH_INTERVAL_MS;
+}
+
+const fallbackCatalog = (): AntigravityCatalog => ({
+  models: ANTIGRAVITY_MODELS,
+  routing: { ...ANTIGRAVITY_ROUTING },
+});
+
+/** Restore provider state supplied by Pi before checking offline mode or refresh TTL. */
+export function hydrateAntigravityCatalog(stored: unknown): number {
+  if (!isRecord(stored)) return 0;
+  const persisted = stored[ANTIGRAVITY_PERSIST_KEY];
+  if (!isRecord(persisted)) return 0;
+
+  if (isStringMap(persisted.modelEnums)) restoreDynamicModelEnums(persisted.modelEnums);
+  if (isCatalog(persisted.catalog)) applyAntigravityCatalog(persisted.catalog);
+  return typeof persisted.checkedAt === "number" && persisted.checkedAt > 0
+    ? persisted.checkedAt
+    : 0;
+}
+
+export async function discoverAntigravityModels(
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<AntigravityCatalog> {
+  const creds = parseApiKey(apiKey);
+  const available = await fetchAvailableModelsCatalog(creds.token, creds.projectId, signal);
+  const models = available.data.models;
+  if (!models || Object.keys(models).length === 0) {
+    return { models: [], routing: {} };
+  }
+  registerDiscoveredModelEnums(models);
+  return buildAntigravityCatalog(models, fallbackCatalog());
+}
+
+export async function refreshAntigravityModels(
+  context: RefreshModelsContext,
+): Promise<ProviderModelConfig[]> {
+  const checkedAt = hydrateAntigravityCatalog(context.stored);
+  const current = getCurrentAntigravityCatalog();
+  if (!context.allowNetwork) return current.models;
+
+  const apiKey = apiKeyFromCredential(context.credential);
+  if (!apiKey || context.signal.aborted) return current.models;
+
+  const now = Date.now();
+  if (
+    !context.force &&
+    checkedAt > 0 &&
+    now >= checkedAt &&
+    now - checkedAt < getCatalogRefreshIntervalMs()
+  ) {
+    return current.models;
+  }
+
+  try {
+    const discovered = await discoverAntigravityModels(apiKey, context.signal);
+    if (context.signal.aborted) return current.models;
+    const next = resolvedCatalog(discovered, current);
+    if (next.models.length > 0 && discovered.models.length > 0) {
+      applyAntigravityCatalog(next);
+      const refreshedAt = Date.now();
+      await context.publish({
+        persist: {
+          models: toStoredModels(next.models),
+          [ANTIGRAVITY_PERSIST_KEY]: {
+            catalog: next,
+            checkedAt: refreshedAt,
+            modelEnums: snapshotDynamicModelEnums(),
+          } satisfies PersistedAntigravityCatalog,
+        } as unknown as ModelsStoreEntry,
+      });
+      return next.models;
+    }
+  } catch (error) {
+    // Keep last-known-good models; a failed refresh must not wipe the catalog.
+    // Forced/manual refreshes must still report the failure to their caller.
+    if (context.force) throw error;
+  }
+
+  return getCurrentAntigravityCatalog().models;
+}
+
+function isCatalog(value: unknown): value is AntigravityCatalog {
+  return (
+    isRecord(value) &&
+    Array.isArray(value.models) &&
+    value.models.length > 0 &&
+    isRecord(value.routing)
+  );
+}
+
+function isStringMap(value: unknown): value is Record<string, string> {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+
+function apiKeyFromCredential(credential: Credential | undefined): string | undefined {
+  if (!credential) return undefined;
+  if (credential.type === "api_key") {
+    return typeof credential.key === "string" && credential.key ? credential.key : undefined;
+  }
+  if (credential.type === "oauth" && typeof credential.access === "string") {
+    return getApiKey(credential);
+  }
+  return undefined;
+}
+
+function toStoredModels(models: ProviderModelConfig[]): Model<Api>[] {
+  return models.map((model) => ({
+    ...model,
+    api: ANTIGRAVITY_API,
+    provider: "antigravity",
+    baseUrl: DEFAULT_ENDPOINT,
+  }));
+}

package/node_modules/pi-antigravity/src/models/grouping.ts

@@ -0,0 +1,424 @@
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { ThinkingEffort } from "../types/enums.js";
+import type { AntigravityRouting, ModelInfoRaw } from "../types/types.js";
+
+export type AntigravityCatalog = {
+  models: ProviderModelConfig[];
+  routing: Record<string, AntigravityRouting>;
+};
+
+type ThinkingLevel = ThinkingEffort;
+
+type RuntimeGroup = {
+  publicId: string;
+  variants: Partial<Record<ThinkingLevel, string>>;
+  unsuffixed?: string;
+  displayNames: string[];
+  /** Catalog capability: true/false when advertised, undefined when omitted. */
+  supportsThinking?: boolean;
+  supportsImages?: boolean;
+};
+
+const THINKING_SUFFIXES: Array<{ suffix: string; level: ThinkingLevel }> = [
+  { suffix: "extra-low", level: ThinkingEffort.Low },
+  { suffix: "extra-high", level: ThinkingEffort.Xhigh },
+  { suffix: "thinking", level: ThinkingEffort.High },
+  { suffix: "minimal", level: ThinkingEffort.Minimal },
+  { suffix: "medium", level: ThinkingEffort.Medium },
+  { suffix: "high", level: ThinkingEffort.High },
+  { suffix: "low", level: ThinkingEffort.Low },
+];
+
+const DISPLAY_LEVELS: Array<{ pattern: RegExp; level: ThinkingLevel }> = [
+  { pattern: /\(\s*extra\s*low\s*\)/i, level: ThinkingEffort.Low },
+  { pattern: /\(\s*extra\s*high\s*\)/i, level: ThinkingEffort.Xhigh },
+  { pattern: /\(\s*thinking\s*\)/i, level: ThinkingEffort.High },
+  { pattern: /\(\s*minimal\s*\)/i, level: ThinkingEffort.Minimal },
+  { pattern: /\(\s*medium\s*\)/i, level: ThinkingEffort.Medium },
+  { pattern: /\(\s*high\s*\)/i, level: ThinkingEffort.High },
+  { pattern: /\(\s*low\s*\)/i, level: ThinkingEffort.Low },
+];
+
+/** Known backend aliases whose runtime IDs do not share a thinking suffix with the public family. */
+const RUNTIME_ALIASES: Record<string, { publicId: string; level: ThinkingLevel }> = {
+  "gemini-3-flash-agent": { publicId: "gemini-3.5-flash", level: ThinkingEffort.High },
+  "gemini-pro-agent": { publicId: "gemini-3.1-pro", level: ThinkingEffort.High },
+};
+
+const PI_LEVELS = [
+  ThinkingEffort.Off,
+  ThinkingEffort.Minimal,
+  ThinkingEffort.Low,
+  ThinkingEffort.Medium,
+  ThinkingEffort.High,
+  ThinkingEffort.Xhigh,
+  "max",
+] as const;
+
+const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+
+export function isSelectableRuntimeModelId(id: string): boolean {
+  if (!/^(gemini-|claude-|gpt-oss-)/i.test(id) || /\s/.test(id) || /^MODEL_/i.test(id)) {
+    return false;
+  }
+  if (/^(chat_|tab_)/i.test(id)) return false;
+  if (/image/i.test(id)) return false;
+  return true;
+}
+
+export function resolvedCatalog(
+  discovered: AntigravityCatalog | undefined,
+  current: AntigravityCatalog,
+): AntigravityCatalog {
+  if (discovered && discovered.models.length > 0) return discovered;
+  return current;
+}
+
+export function buildAntigravityCatalog(
+  rawModels: Record<string, ModelInfoRaw>,
+  fallback: AntigravityCatalog,
+): AntigravityCatalog {
+  const groups = new Map<string, RuntimeGroup>();
+
+  for (const [runtimeId, info] of Object.entries(rawModels)) {
+    if (!isSelectableRuntimeModelId(runtimeId)) continue;
+    if (info?.isInternal) continue;
+
+    const displayName = modelDisplayName(info);
+    if (runtimeId.endsWith("-tiered")) {
+      const baseId = runtimeId.slice(0, -"-tiered".length);
+      const group = ensureGroup(groups, baseId);
+      absorbMetadata(group, info, displayName);
+      if (!group.unsuffixed) group.unsuffixed = runtimeId;
+      continue;
+    }
+
+    const alias = RUNTIME_ALIASES[runtimeId];
+    const suffix = alias ? undefined : parseThinkingSuffix(runtimeId);
+    const publicId = alias?.publicId ?? suffix?.baseId ?? runtimeId;
+    const group = ensureGroup(groups, publicId);
+    absorbMetadata(group, info, displayName);
+
+    const level = alias?.level ?? levelFromDisplayName(displayName) ?? suffix?.level;
+    if (level) group.variants[level] = runtimeId;
+    else group.unsuffixed = runtimeId;
+  }
+
+  mergeAgentSingletons(groups);
+
+  if (groups.size === 0) return fallback;
+
+  const models: ProviderModelConfig[] = [];
+  const routing: Record<string, AntigravityRouting> = {};
+
+  for (const group of groups.values()) {
+    const fallbackModel = fallback.models.find((model) => model.id === group.publicId);
+    const fallbackRouting = fallback.routing[group.publicId];
+    if (fallbackModel && fallbackRouting) {
+      models.push(fallbackModel);
+      routing[group.publicId] = fallbackRouting;
+      continue;
+    }
+
+    const synthesized = synthesizeModel(group, fallback.models);
+    models.push(synthesized.model);
+    routing[group.publicId] = synthesized.routing;
+  }
+
+  for (const fallbackModel of fallback.models) {
+    if (routing[fallbackModel.id]) continue;
+    const fallbackRouting = fallback.routing[fallbackModel.id];
+    if (!fallbackRouting) continue;
+    models.push(fallbackModel);
+    routing[fallbackModel.id] = fallbackRouting;
+  }
+
+  models.sort(comparePublicModels);
+  return { models, routing };
+}
+
+function ensureGroup(groups: Map<string, RuntimeGroup>, publicId: string): RuntimeGroup {
+  const existing = groups.get(publicId);
+  if (existing) return existing;
+  const created: RuntimeGroup = {
+    publicId,
+    variants: {},
+    displayNames: [],
+  };
+  groups.set(publicId, created);
+  return created;
+}
+
+function absorbMetadata(
+  group: RuntimeGroup,
+  info: ModelInfoRaw | undefined,
+  displayName: string | undefined,
+): void {
+  if (displayName) group.displayNames.push(displayName);
+  if (info?.supportsThinking === true) group.supportsThinking = true;
+  else if (info?.supportsThinking === false && group.supportsThinking !== true) {
+    group.supportsThinking = false;
+  }
+  if (info?.supportsImages === true) group.supportsImages = true;
+  if (info?.supportsImages === false && group.supportsImages === undefined) {
+    group.supportsImages = false;
+  }
+}
+
+function mergeAgentSingletons(groups: Map<string, RuntimeGroup>): void {
+  for (const [publicId, group] of [...groups.entries()]) {
+    if (!publicId.endsWith("-agent")) continue;
+    if (Object.keys(group.variants).length > 0) continue;
+    const family = displayFamily(group.displayNames[0]);
+    if (!family) continue;
+    const target = [...groups.values()].find(
+      (candidate) =>
+        candidate.publicId !== publicId &&
+        candidate.displayNames.some((name) => displayFamily(name) === family),
+    );
+    if (!target || !group.unsuffixed) continue;
+    const level = levelFromDisplayName(group.displayNames[0]) ?? ThinkingEffort.High;
+    target.variants[level] = group.unsuffixed;
+    absorbMetadata(target, { supportsThinking: group.supportsThinking }, group.displayNames[0]);
+    groups.delete(publicId);
+  }
+}
+
+function parseThinkingSuffix(
+  runtimeId: string,
+): { baseId: string; level: ThinkingLevel } | undefined {
+  const lower = runtimeId.toLowerCase();
+  for (const { suffix, level } of THINKING_SUFFIXES) {
+    if (lower.endsWith(`-${suffix}`)) {
+      return { baseId: runtimeId.slice(0, -(suffix.length + 1)), level };
+    }
+  }
+  return undefined;
+}
+
+function levelFromDisplayName(displayName: string | undefined): ThinkingLevel | undefined {
+  if (!displayName) return undefined;
+  for (const { pattern, level } of DISPLAY_LEVELS) {
+    if (pattern.test(displayName)) return level;
+  }
+  return undefined;
+}
+
+function modelDisplayName(info: ModelInfoRaw | undefined): string | undefined {
+  if (!info) return undefined;
+  if (typeof info.displayName === "string" && info.displayName) return info.displayName;
+  if (typeof info.label === "string" && info.label) return info.label;
+  if (typeof info.modelName === "string" && info.modelName) return info.modelName;
+  return undefined;
+}
+
+function displayFamily(displayName: string | undefined): string | undefined {
+  if (!displayName) return undefined;
+  return displayName
+    .replace(/\s*\((?:extra\s*low|extra\s*high|low|medium|high|minimal|thinking)\)\s*$/i, "")
+    .trim()
+    .toLowerCase();
+}
+
+function synthesizeModel(
+  group: RuntimeGroup,
+  fallbackModels: ProviderModelConfig[],
+): { model: ProviderModelConfig; routing: AntigravityRouting } {
+  const template = familyTemplate(group.publicId, fallbackModels);
+  const advertisedLevels = advertisedThinkingLevels(group);
+  const routing = routingFromVariants(group.publicId, group.variants, group.unsuffixed);
+  const supportsImages = group.supportsImages ?? template?.input.includes("image") ?? true;
+  const reasoning =
+    advertisedLevels.size > 0 ||
+    group.supportsThinking === true ||
+    (group.supportsThinking === undefined && Boolean(template?.reasoning));
+  return {
+    model: {
+      id: group.publicId,
+      name: publicModelName(group),
+      reasoning,
+      thinkingLevelMap: reasoning ? thinkingLevelMapFromLevels(advertisedLevels) : undefined,
+      input: supportsImages ? ["text", "image"] : ["text"],
+      cost: template?.cost ?? ZERO_COST,
+      contextWindow: template?.contextWindow ?? 128000,
+      maxTokens: template?.maxTokens ?? 8192,
+    },
+    routing,
+  };
+}
+
+function advertisedThinkingLevels(group: RuntimeGroup): Set<string> {
+  const levels = new Set(Object.keys(group.variants));
+  if (levels.size > 0) return levels;
+  // Explicit false from the catalog must not grow a fake High control.
+  if (group.supportsThinking === false) return levels;
+  if (group.supportsThinking === true || group.unsuffixed) {
+    levels.add(ThinkingEffort.High);
+  }
+  return levels;
+}
+
+function routingFromVariants(
+  publicId: string,
+  variants: Partial<Record<ThinkingLevel, string>>,
+  unsuffixed?: string,
+): AntigravityRouting {
+  const defaultRequestId =
+    variants[ThinkingEffort.Low] ??
+    variants[ThinkingEffort.Minimal] ??
+    variants[ThinkingEffort.Medium] ??
+    variants[ThinkingEffort.High] ??
+    unsuffixed ??
+    publicId;
+
+  const pick = (...keys: ThinkingLevel[]): string => {
+    for (const key of keys) {
+      const id = variants[key];
+      if (id) return id;
+    }
+    return unsuffixed ?? defaultRequestId;
+  };
+
+  return {
+    off: pick(
+      ThinkingEffort.Low,
+      ThinkingEffort.Minimal,
+      ThinkingEffort.Medium,
+      ThinkingEffort.High,
+    ),
+    routing: {
+      minimal: pick(
+        ThinkingEffort.Minimal,
+        ThinkingEffort.Low,
+        ThinkingEffort.Medium,
+        ThinkingEffort.High,
+      ),
+      low: pick(
+        ThinkingEffort.Low,
+        ThinkingEffort.Minimal,
+        ThinkingEffort.Medium,
+        ThinkingEffort.High,
+      ),
+      medium: pick(
+        ThinkingEffort.Medium,
+        ThinkingEffort.Low,
+        ThinkingEffort.High,
+        ThinkingEffort.Minimal,
+      ),
+      high: pick(
+        ThinkingEffort.High,
+        ThinkingEffort.Medium,
+        ThinkingEffort.Low,
+        ThinkingEffort.Minimal,
+      ),
+      xhigh: pick(
+        ThinkingEffort.Xhigh,
+        ThinkingEffort.High,
+        ThinkingEffort.Medium,
+        ThinkingEffort.Low,
+      ),
+    },
+    defaultRequestId,
+  };
+}
+
+function thinkingLevelMapFromLevels(levels: Set<string>): ProviderModelConfig["thinkingLevelMap"] {
+  const map: NonNullable<ProviderModelConfig["thinkingLevelMap"]> = {};
+  for (const level of PI_LEVELS) {
+    map[level] = levels.has(level) ? level : null;
+  }
+  if (levels.size === 0) map.high = "high";
+  return map;
+}
+
+function familyTemplate(
+  publicId: string,
+  fallbackModels: ProviderModelConfig[],
+): ProviderModelConfig | undefined {
+  if (/^gemini-.*-flash/i.test(publicId)) {
+    return fallbackModels.find((model) => /^gemini-.*-flash/i.test(model.id));
+  }
+  if (/^gemini-.*-pro/i.test(publicId)) {
+    return fallbackModels.find((model) => /^gemini-.*-pro/i.test(model.id));
+  }
+  if (publicId.startsWith("claude-opus")) {
+    return fallbackModels.find((model) => model.id.startsWith("claude-opus"));
+  }
+  if (publicId.startsWith("claude-")) {
+    return (
+      fallbackModels.find((model) => model.id.startsWith("claude-sonnet")) ??
+      fallbackModels.find((model) => model.id.startsWith("claude-"))
+    );
+  }
+  if (publicId.startsWith("gpt-oss")) {
+    return fallbackModels.find((model) => model.id.startsWith("gpt-oss"));
+  }
+  if (publicId.startsWith("gemini-")) {
+    return fallbackModels.find((model) => model.id.startsWith("gemini-"));
+  }
+  return undefined;
+}
+
+function publicModelName(group: RuntimeGroup): string {
+  const family = group.displayNames.map((name) => displayFamily(name)).find(Boolean);
+  if (family) {
+    return `${titleCase(family)} (Antigravity)`;
+  }
+  return `${humanizePublicId(group.publicId)} (Antigravity)`;
+}
+
+function titleCase(value: string): string {
+  return value.replace(/\b([a-z])/g, (char) => char.toUpperCase());
+}
+
+export function humanizePublicId(id: string): string {
+  const tokens = id.split("-");
+  const words: string[] = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    const next = tokens[i + 1];
+    if (token === "gpt" && next === "oss") {
+      words.push("GPT-OSS");
+      i++;
+      continue;
+    }
+    if (/^\d+$/.test(token) && next && /^\d+$/.test(next)) {
+      words.push(`${token}.${next}`);
+      i++;
+      continue;
+    }
+    if (/^\d/.test(token)) {
+      words.push(token.toUpperCase());
+      continue;
+    }
+    words.push(token.charAt(0).toUpperCase() + token.slice(1));
+  }
+  return words.join(" ");
+}
+
+function parseGeminiVersion(id: string): number {
+  const match = id.match(/^gemini-(\d+)(?:\.(\d+))?/i);
+  if (!match) return 0;
+  return Number(match[1]) * 1000 + Number(match[2] || 0);
+}
+
+function comparePublicModels(a: ProviderModelConfig, b: ProviderModelConfig): number {
+  const rankA = modelRank(a.id);
+  const rankB = modelRank(b.id);
+  if (rankA[0] !== rankB[0]) return rankA[0] - rankB[0];
+  if (rankA[1] !== rankB[1]) return rankA[1] - rankB[1];
+  return a.id.localeCompare(b.id);
+}
+
+function modelRank(id: string): [number, number] {
+  const version = parseGeminiVersion(id);
+  if (/^gemini-.*flash/i.test(id) && !/pro/i.test(id)) return [0, -version];
+  if (id.startsWith("claude-opus")) return [1, 0];
+  if (id.startsWith("claude-sonnet")) return [2, 0];
+  if (id.startsWith("claude-")) return [3, 0];
+  if (/^gemini-.*pro/i.test(id)) return [4, -version];
+  if (id.startsWith("gemini-")) return [5, -version];
+  if (id.startsWith("gpt-oss")) return [6, 0];
+  return [7, 0];
+}

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

@@ -0,0 +1,3 @@
+export * from "./models.js";
+export * from "./grouping.js";
+export * from "./discovery.js";