pi-provider-antigravity 0.1.0

package/dist/index.js

@@ -0,0 +1,1430 @@
+// src/auth.ts
+import { createHash, randomBytes } from "node:crypto";
+
+// src/protocol.ts
+var DEFAULT_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+var DEFAULT_USER_AGENT = "antigravity/cli/1.1.26 (aidev_client; os_type=linux; arch=amd64; cl=976013059; auth_method=consumer)";
+var PROVIDER_ID = "antigravity";
+function buildAntigravityHeaders(token, userAgent = DEFAULT_USER_AGENT) {
+  return {
+    Host: "daily-cloudcode-pa.googleapis.com",
+    "User-Agent": userAgent,
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`
+  };
+}
+
+// src/auth.ts
+var REDIRECT_URI = "https://antigravity.google/oauth-callback";
+var AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var OAUTH_CALLBACK_TIMEOUT_MS = 5 * 60 * 1e3;
+var SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile",
+  "https://www.googleapis.com/auth/cclog",
+  "https://www.googleapis.com/auth/experimentsandconfigs",
+  "https://www.googleapis.com/auth/aicode",
+  "openid"
+];
+var CLIENT_ID = process.env.ANTIGRAVITY_CLIENT_ID || Buffer.from(
+  "MTA3MTAwNjA2MDU5MS10bWhzc2luMmgyMWxjcmUyMzV2dG9sb2poNGc0MDNlcC5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbQ==",
+  "base64"
+).toString("utf-8");
+var CLIENT_SECRET = process.env.ANTIGRAVITY_CLIENT_SECRET || Buffer.from("R09DU1BYLUs1OEZXUjQ4NkxkTEoxbUxCOHNYQzR6NnFEQWY=", "base64").toString("utf-8");
+function base64Url(buf) {
+  return buf.toString("base64url");
+}
+function extractCodeFromInput(rawInput) {
+  let code = rawInput.trim();
+  if (!code) {
+    throw new Error("No authorization code provided");
+  }
+  if (code.startsWith("code=")) {
+    code = code.slice(5).trim();
+    if (!code) {
+      throw new Error("No authorization code provided");
+    }
+  }
+  if (/[\s:?#&=%+]/.test(code)) {
+    throw new Error("Invalid authorization code: paste the code value itself, not the callback URL");
+  }
+  return code;
+}
+function generatePKCE() {
+  const verifier = base64Url(randomBytes(32));
+  const challenge = base64Url(createHash("sha256").update(verifier).digest());
+  return { verifier, challenge };
+}
+async function fetchProjectId(token, endpoint = DEFAULT_ENDPOINT) {
+  try {
+    const res = await fetch(`${endpoint}/v1internal:loadCodeAssist`, {
+      method: "POST",
+      headers: buildAntigravityHeaders(token),
+      body: JSON.stringify({ metadata: { ideType: "ANTIGRAVITY" } })
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (data.cloudaicompanionProject) {
+        return data.cloudaicompanionProject;
+      }
+    }
+  } catch {
+  }
+  return "aicode-consumers";
+}
+async function loginAntigravity(callbacks) {
+  const { verifier, challenge } = generatePKCE();
+  const state = randomBytes(16).toString("hex");
+  const authParams = new URLSearchParams({
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri: REDIRECT_URI,
+    scope: SCOPES.join(" "),
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state,
+    access_type: "offline",
+    prompt: "consent"
+  });
+  const authUrl = `${AUTH_URL}?${authParams.toString()}`;
+  callbacks.onAuth({ url: authUrl });
+  const manualPromptPromise = (async () => {
+    const input = await callbacks.onPrompt({
+      message: "Paste authorization code from browser:"
+    });
+    return extractCodeFromInput(input);
+  })();
+  const timeout = new Promise(
+    (_, rej) => setTimeout(() => rej(new Error("Timed out waiting for authorization code (5 minutes)")), OAUTH_CALLBACK_TIMEOUT_MS)
+  );
+  const code = await Promise.race([manualPromptPromise, timeout]);
+  const tokenParams = new URLSearchParams({
+    client_id: CLIENT_ID,
+    client_secret: CLIENT_SECRET,
+    code,
+    grant_type: "authorization_code",
+    redirect_uri: REDIRECT_URI,
+    code_verifier: verifier
+  });
+  const tokenRes = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: tokenParams.toString()
+  });
+  if (!tokenRes.ok) {
+    const errText = await tokenRes.text();
+    throw new Error(`Failed to exchange token (${tokenRes.status}): ${errText}`);
+  }
+  const tokens = await tokenRes.json();
+  const projectId = await fetchProjectId(tokens.access_token);
+  return {
+    refresh: tokens.refresh_token || "",
+    access: JSON.stringify({ token: tokens.access_token, projectId }),
+    expires: Date.now() + (tokens.expires_in || 3600) * 1e3
+  };
+}
+async function refreshAntigravityToken(credentials, signal) {
+  const params = new URLSearchParams({
+    client_id: CLIENT_ID,
+    client_secret: CLIENT_SECRET,
+    refresh_token: credentials.refresh,
+    grant_type: "refresh_token"
+  });
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: params.toString(),
+    signal
+  });
+  if (!res.ok) {
+    const errText = await res.text();
+    throw new Error(`Failed to refresh token (${res.status}): ${errText}`);
+  }
+  const tokens = await res.json();
+  let existingProjectId = "aicode-consumers";
+  try {
+    const parsed = JSON.parse(credentials.access);
+    if (parsed.projectId) existingProjectId = parsed.projectId;
+  } catch {
+  }
+  return {
+    refresh: tokens.refresh_token || credentials.refresh,
+    access: JSON.stringify({ token: tokens.access_token, projectId: existingProjectId }),
+    expires: Date.now() + (tokens.expires_in || 3600) * 1e3
+  };
+}
+function getApiKey(credentials) {
+  return credentials.access;
+}
+function parseStoredCredentials(rawApiKey) {
+  try {
+    const parsed = JSON.parse(rawApiKey);
+    if (parsed.token) {
+      return { token: parsed.token, projectId: parsed.projectId || "aicode-consumers" };
+    }
+  } catch {
+  }
+  return { token: rawApiKey, projectId: "aicode-consumers" };
+}
+
+// src/catalog.ts
+function extractBaseModelId(runtimeId) {
+  if (runtimeId === "gemini-pro-agent") return "gemini-3.1-pro";
+  if (runtimeId.startsWith("gemini-3.1-pro-")) return "gemini-3.1-pro";
+  return runtimeId.replace(/-(?:high|medium|low|tiered|thinking|agent|extra-low)$/, "");
+}
+var STATIC_MODEL_ENUMS = {
+  // Gemini 3.8 Flash
+  "gemini-3.8-flash": "MODEL_PLACEHOLDER_M318",
+  "gemini-3.8-flash-high": "MODEL_PLACEHOLDER_M318",
+  "gemini-3.8-flash-medium": "MODEL_PLACEHOLDER_M319",
+  "gemini-3.8-flash-low": "MODEL_PLACEHOLDER_M320",
+  "gemini-3.8-flash-tiered": "MODEL_PLACEHOLDER_M322",
+  // Gemini 3.7 Flash
+  "gemini-3.7-flash": "MODEL_PLACEHOLDER_M298",
+  "gemini-3.7-flash-high": "MODEL_PLACEHOLDER_M298",
+  "gemini-3.7-flash-medium": "MODEL_PLACEHOLDER_M299",
+  "gemini-3.7-flash-low": "MODEL_PLACEHOLDER_M300",
+  "gemini-3.7-flash-tiered": "MODEL_PLACEHOLDER_M301",
+  // Gemini 3.6 Flash
+  "gemini-3.6-flash": "MODEL_PLACEHOLDER_M71",
+  "gemini-3.6-flash-high": "MODEL_PLACEHOLDER_M71",
+  "gemini-3.6-flash-medium": "MODEL_PLACEHOLDER_M72",
+  "gemini-3.6-flash-low": "MODEL_PLACEHOLDER_M73",
+  // Gemini 3.5 Flash
+  "gemini-3.5-flash": "MODEL_PLACEHOLDER_M84",
+  "gemini-3.5-flash-low": "MODEL_PLACEHOLDER_M20",
+  "gemini-3.5-flash-extra-low": "MODEL_PLACEHOLDER_M187",
+  "gemini-3-flash-agent": "MODEL_PLACEHOLDER_M84",
+  // Gemini 3.1 Pro
+  "gemini-3.1-pro": "MODEL_PLACEHOLDER_M16",
+  "gemini-3.1-pro-high": "MODEL_PLACEHOLDER_M37",
+  "gemini-3.1-pro-low": "MODEL_PLACEHOLDER_M36",
+  "gemini-pro-agent": "MODEL_PLACEHOLDER_M16",
+  // Claude
+  "claude-sonnet-4-6": "MODEL_PLACEHOLDER_M35",
+  "claude-opus-4-6": "MODEL_PLACEHOLDER_M26",
+  "claude-opus-4-6-thinking": "MODEL_PLACEHOLDER_M26",
+  // GPT-OSS
+  "gpt-oss-120b": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM",
+  "gpt-oss-120b-medium": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM"
+};
+function getThinkingConfig(modelId, effort) {
+  const isOff = effort === "off" || effort === "none";
+  if (isOff) {
+    return { includeThoughts: false, thinkingBudget: 0 };
+  }
+  if (modelId.includes("flash")) {
+    if (effort === "high" || effort === "xhigh" || modelId.endsWith("-high") || modelId.endsWith("-agent")) {
+      return { includeThoughts: true, thinkingBudget: -1 };
+    }
+    if (effort === "medium" || modelId.endsWith("-medium")) {
+      return { includeThoughts: true, thinkingBudget: 4e3 };
+    }
+    if (effort === "low" || effort === "minimal" || modelId.endsWith("-low")) {
+      return { includeThoughts: true, thinkingBudget: 1e3 };
+    }
+    return { includeThoughts: true, thinkingBudget: -1 };
+  }
+  if (modelId.includes("pro")) {
+    if (effort === "low" || effort === "minimal" || modelId.endsWith("-low")) {
+      return { includeThoughts: true, thinkingBudget: 1001 };
+    }
+    return { includeThoughts: true, thinkingBudget: 10001 };
+  }
+  if (modelId.startsWith("claude-")) {
+    return { includeThoughts: true, thinkingBudget: 1024 };
+  }
+  if (modelId.startsWith("gpt-oss-")) {
+    return { includeThoughts: true, thinkingBudget: 8192 };
+  }
+  return { includeThoughts: true, thinkingBudget: -1 };
+}
+var activeStore = {
+  enums: { ...STATIC_MODEL_ENUMS },
+  runtimeIds: [],
+  version: 0
+};
+function getCatalogSnapshot() {
+  return {
+    enums: { ...activeStore.enums },
+    runtimeIds: [...activeStore.runtimeIds],
+    version: activeStore.version
+  };
+}
+function updateCatalogStore(enums, runtimeIds) {
+  activeStore = {
+    enums: { ...STATIC_MODEL_ENUMS, ...activeStore.enums, ...enums },
+    runtimeIds: [.../* @__PURE__ */ new Set([...activeStore.runtimeIds, ...runtimeIds])],
+    version: activeStore.version + 1
+  };
+}
+function resolveRuntimeModelId(modelId, effort, availableRuntimeIds = activeStore.runtimeIds) {
+  if (modelId.endsWith("-high") || modelId.endsWith("-medium") || modelId.endsWith("-low") || modelId.endsWith("-thinking") || modelId.endsWith("-agent") || modelId.endsWith("-extra-low") || modelId.endsWith("-tiered")) {
+    return modelId;
+  }
+  const isOff = effort === "off" || effort === "none";
+  const isLow = isOff || effort === "low" || effort === "minimal";
+  const isMedium = effort === "medium";
+  if (modelId === "gemini-3.8-flash") {
+    if (isLow) return "gemini-3.8-flash-low";
+    if (isMedium) return "gemini-3.8-flash-medium";
+    return "gemini-3.8-flash-high";
+  }
+  if (modelId === "gemini-3.7-flash") {
+    if (isLow) return "gemini-3.7-flash-low";
+    if (isMedium) return "gemini-3.7-flash-medium";
+    return "gemini-3.7-flash-high";
+  }
+  if (modelId === "gemini-3.6-flash") {
+    if (isLow) return "gemini-3.6-flash-low";
+    if (isMedium) return "gemini-3.6-flash-medium";
+    return "gemini-3.6-flash-high";
+  }
+  if (modelId === "gemini-3.5-flash") {
+    if (isLow) return "gemini-3.5-flash-extra-low";
+    if (isMedium) return "gemini-3.5-flash-low";
+    return "gemini-3-flash-agent";
+  }
+  if (modelId === "gemini-3.1-pro") {
+    if (effort === "high" || effort === "xhigh") return "gemini-pro-agent";
+    return "gemini-3.1-pro-low";
+  }
+  if (modelId === "claude-opus-4-6") {
+    return "claude-opus-4-6-thinking";
+  }
+  if (modelId === "claude-sonnet-4-6") {
+    return "claude-sonnet-4-6";
+  }
+  if (modelId === "gpt-oss-120b") {
+    return "gpt-oss-120b-medium";
+  }
+  if (Array.isArray(availableRuntimeIds) && availableRuntimeIds.length > 0) {
+    const candidates = [];
+    if (isLow) {
+      candidates.push(`${modelId}-low`, `${modelId}-extra-low`, modelId);
+    } else if (isMedium) {
+      candidates.push(`${modelId}-medium`, modelId);
+    } else {
+      candidates.push(`${modelId}-high`, `${modelId}-thinking`, `${modelId}-agent`, modelId);
+    }
+    for (const cand of candidates) {
+      if (availableRuntimeIds.includes(cand)) {
+        return cand;
+      }
+    }
+  }
+  if (modelId.includes("flash")) {
+    if (isLow) return `${modelId}-low`;
+    if (isMedium) return `${modelId}-medium`;
+    return `${modelId}-high`;
+  }
+  if (modelId.includes("pro")) {
+    if (isLow) return `${modelId}-low`;
+    return `${modelId}-high`;
+  }
+  if (modelId.startsWith("claude-")) {
+    if (modelId.includes("opus")) return `${modelId}-thinking`;
+    return modelId;
+  }
+  if (modelId.startsWith("gpt-")) {
+    return `${modelId}-medium`;
+  }
+  return modelId;
+}
+function resolveModelPlan(publicModelId, effort, snapshot = getCatalogSnapshot()) {
+  const runtimeModelId = resolveRuntimeModelId(publicModelId, effort, snapshot.runtimeIds);
+  return {
+    runtimeModelId,
+    modelEnum: snapshot.enums[runtimeModelId] || "",
+    thinkingConfig: getThinkingConfig(runtimeModelId, effort),
+    isNonGemini: !runtimeModelId.startsWith("gemini-"),
+    isClaude: runtimeModelId.startsWith("claude-")
+  };
+}
+function formatModelDisplayName(baseId, rawDisplayName) {
+  if (rawDisplayName) {
+    const cleaned = rawDisplayName.replace(/\s*\([^)]*\)/g, "").trim();
+    if (cleaned.length > 0) {
+      return cleaned;
+    }
+  }
+  const words = baseId.split("-").map((w) => {
+    if (/^\d+(\.\d+)?$/.test(w)) return w;
+    return w.charAt(0).toUpperCase() + w.slice(1);
+  });
+  return words.join(" ");
+}
+function estimateModelCost(baseId) {
+  if (baseId.includes("flash")) {
+    return { input: 0.1, output: 0.4, cacheRead: 0.025, cacheWrite: 0.1 };
+  }
+  if (baseId.includes("pro")) {
+    return { input: 1.25, output: 5, cacheRead: 0.3, cacheWrite: 1.25 };
+  }
+  if (baseId.startsWith("claude-opus")) {
+    return { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 };
+  }
+  if (baseId.startsWith("claude-")) {
+    return { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+  }
+  if (baseId.startsWith("gpt-oss-")) {
+    return { input: 0.5, output: 2, cacheRead: 0.1, cacheWrite: 0.5 };
+  }
+  return { input: 1, output: 5, cacheRead: 0.25, cacheWrite: 1 };
+}
+function synthesizeDynamicModel(baseId, items) {
+  const repItem = items.find((it) => it.id === `${baseId}-high` || it.id === baseId) || items[0];
+  const isFlash = baseId.includes("flash");
+  const isClaude = baseId.startsWith("claude-");
+  const isGpt = baseId.startsWith("gpt-");
+  const defaultContext = isFlash ? 1048576 : isClaude ? 2e5 : isGpt ? 128e3 : 1048576;
+  const defaultMaxOutput = isGpt ? 32768 : 65536;
+  return {
+    id: baseId,
+    name: formatModelDisplayName(baseId, repItem?.displayName),
+    provider: PROVIDER_ID,
+    api: "antigravity-api",
+    baseUrl: DEFAULT_ENDPOINT,
+    reasoning: repItem?.supportsThinking ?? true,
+    input: repItem?.supportsImages ? ["text", "image"] : ["text"],
+    cost: estimateModelCost(baseId),
+    contextWindow: repItem?.maxTokens || defaultContext,
+    maxTokens: repItem?.maxOutputTokens || defaultMaxOutput
+  };
+}
+function buildDynamicPublicModels(catalog) {
+  if (!catalog || !Array.isArray(catalog.models) || catalog.models.length === 0) {
+    return [];
+  }
+  const agentSortIds = catalog.agentModelSorts;
+  const eligibleItems = Array.isArray(agentSortIds) && agentSortIds.length > 0 ? catalog.models.filter((m) => agentSortIds.includes(m.id)) : catalog.models;
+  const runtimeGroups = /* @__PURE__ */ new Map();
+  for (const item of eligibleItems) {
+    const baseId = extractBaseModelId(item.id);
+    const list = runtimeGroups.get(baseId) || [];
+    list.push(item);
+    runtimeGroups.set(baseId, list);
+  }
+  const orderedBaseIds = [];
+  if (Array.isArray(agentSortIds)) {
+    for (const sortId of agentSortIds) {
+      const baseId = extractBaseModelId(sortId);
+      if (runtimeGroups.has(baseId) && !orderedBaseIds.includes(baseId)) {
+        orderedBaseIds.push(baseId);
+      }
+    }
+  }
+  for (const baseId of runtimeGroups.keys()) {
+    if (!orderedBaseIds.includes(baseId)) {
+      orderedBaseIds.push(baseId);
+    }
+  }
+  return orderedBaseIds.map((baseId) => synthesizeDynamicModel(baseId, runtimeGroups.get(baseId)));
+}
+async function refreshCatalog(context) {
+  const storedEnums = context.stored?.["pi-provider-antigravity"]?.modelEnums;
+  const storedRuntimeIds = context.stored?.["pi-provider-antigravity"]?.runtimeIds;
+  if (storedEnums || storedRuntimeIds) {
+    updateCatalogStore(storedEnums || {}, storedRuntimeIds || []);
+  }
+  if (!context.allowNetwork) {
+    return context.stored?.models || [];
+  }
+  try {
+    const apiKey = context.credential?.access;
+    if (!apiKey) {
+      return context.stored?.models || [];
+    }
+    const { token, projectId } = parseStoredCredentials(apiKey);
+    const catalog = await fetchAvailableModelsCatalog(token, projectId, DEFAULT_ENDPOINT, context.signal);
+    updateCatalogStore(catalog.modelEnums, catalog.models.map((m) => m.id));
+    const dynamicModels = buildDynamicPublicModels(catalog);
+    if (context.publish) {
+      await context.publish({
+        persist: {
+          models: dynamicModels,
+          checkedAt: Date.now(),
+          "pi-provider-antigravity": {
+            modelEnums: catalog.modelEnums,
+            runtimeIds: catalog.models.map((m) => m.id)
+          }
+        }
+      });
+    }
+    return dynamicModels;
+  } catch {
+    return context.stored?.models || [];
+  }
+}
+function parseAvailableModels(data) {
+  const models = [];
+  const modelEnums = {};
+  const modelsObj = data.models || {};
+  for (const [id, info] of Object.entries(modelsObj)) {
+    if (id.startsWith("tab_") || id.startsWith("chat_")) continue;
+    const modelEnum = typeof info.model === "string" ? info.model : void 0;
+    if (modelEnum) {
+      modelEnums[id] = modelEnum;
+    }
+    const quotaInfo = info.quotaInfo || {};
+    models.push({
+      id,
+      displayName: info.displayName || info.label || id,
+      modelEnum,
+      remainingFraction: quotaInfo.remainingFraction,
+      resetTime: quotaInfo.resetTime,
+      supportsThinking: Boolean(info.supportsThinking),
+      supportsImages: Boolean(info.supportsImages),
+      maxTokens: typeof info.maxTokens === "number" ? info.maxTokens : void 0,
+      maxOutputTokens: typeof info.maxOutputTokens === "number" ? info.maxOutputTokens : void 0
+    });
+  }
+  const agentModelSorts = [];
+  if (Array.isArray(data.agentModelSorts)) {
+    for (const sortGroup of data.agentModelSorts) {
+      if (Array.isArray(sortGroup.groups)) {
+        for (const group of sortGroup.groups) {
+          if (Array.isArray(group.modelIds)) {
+            agentModelSorts.push(...group.modelIds);
+          }
+        }
+      }
+    }
+  }
+  models.sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    models,
+    modelEnums,
+    ...agentModelSorts.length > 0 ? { agentModelSorts } : {}
+  };
+}
+async function fetchAvailableModelsCatalog(token, projectId = "aicode-consumers", endpoint = DEFAULT_ENDPOINT, signal) {
+  const res = await fetch(`${endpoint}/v1internal:fetchAvailableModels`, {
+    method: "POST",
+    headers: buildAntigravityHeaders(token),
+    body: JSON.stringify({ project: projectId }),
+    signal
+  });
+  if (!res.ok) {
+    const errText = await res.text();
+    throw new Error(`Failed to fetch models (${res.status}): ${errText}`);
+  }
+  const json = await res.json();
+  return parseAvailableModels(json);
+}
+function formatTokenCount(n) {
+  if (typeof n !== "number") return "n/a";
+  if (n % 1048576 === 0) return `${n / 1048576}M`;
+  if (n % 1024 === 0) return `${n / 1024}k`;
+  if (n % 1e3 === 0) return `${n / 1e3}k`;
+  return `${Math.round(n / 1024)}k`;
+}
+function formatModelsList(catalog) {
+  const sorts = catalog.agentModelSorts;
+  const recommendedOnly = Array.isArray(sorts) && sorts.length > 0;
+  const rank = new Map((sorts || []).map((id, i) => [id, i]));
+  const models = (recommendedOnly ? catalog.models.filter((m) => rank.has(m.id)) : catalog.models.slice()).sort(
+    (a, b) => (rank.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (rank.get(b.id) ?? Number.MAX_SAFE_INTEGER) || a.id.localeCompare(b.id)
+  );
+  const rows = models.map((m) => {
+    const flags = [];
+    if (m.supportsThinking) flags.push("thinking");
+    if (m.supportsImages) flags.push("images");
+    return {
+      id: m.id,
+      name: formatModelDisplayName(m.id, m.displayName || m.id),
+      ctx: `${formatTokenCount(m.maxTokens)}/${formatTokenCount(m.maxOutputTokens)}`,
+      feat: flags.length > 0 ? flags.join(", ") : "-",
+      rem: typeof m.remainingFraction === "number" ? `${Math.round(m.remainingFraction * 100)}%` : "N/A"
+    };
+  });
+  const headers = { id: "Model", name: "Name", ctx: "Context", feat: "Features", rem: "Rem" };
+  const w = {
+    id: Math.max(headers.id.length, ...rows.map((r) => r.id.length)),
+    name: Math.max(headers.name.length, ...rows.map((r) => r.name.length)),
+    ctx: Math.max(headers.ctx.length, ...rows.map((r) => r.ctx.length)),
+    feat: Math.max(headers.feat.length, ...rows.map((r) => r.feat.length))
+  };
+  const lines = [
+    `Available Antigravity Models (${models.length}${recommendedOnly ? " recommended" : ""}):`,
+    `  ${headers.id.padEnd(w.id)}  ${headers.name.padEnd(w.name)}  ${headers.ctx.padEnd(w.ctx)}  ${headers.feat.padEnd(w.feat)}  ${headers.rem}`
+  ];
+  for (const r of rows) {
+    lines.push(
+      `  ${r.id.padEnd(w.id)}  ${r.name.padEnd(w.name)}  ${r.ctx.padEnd(w.ctx)}  ${r.feat.padEnd(w.feat)}  ${r.rem.padStart(4)}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/stream.ts
+import {
+  createAssistantMessageEventStream
+} from "@earendil-works/pi-ai";
+
+// src/parser.ts
+function createSseFeed() {
+  const content = [];
+  const usage = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    total: 0
+  };
+  let stopReason = "stop";
+  let lastThoughtSignature;
+  let buffer = "";
+  let openType = null;
+  const snapshot = (events) => ({
+    events,
+    usage: { ...usage },
+    stopReason,
+    ...lastThoughtSignature ? { thoughtSignature: lastThoughtSignature } : {}
+  });
+  const closeOpenBlock = (events) => {
+    if (openType === null) return;
+    const index = content.length - 1;
+    const block = content[index];
+    if (openType === "thinking") {
+      events.push({ kind: "thinking_end", index, content: block.thinking || "" });
+    } else {
+      events.push({ kind: "text_end", index, content: block.text || "" });
+    }
+    openType = null;
+  };
+  const processLine = (rawLine, events) => {
+    const line = rawLine.trim();
+    if (!line.startsWith("data:")) return;
+    const dataStr = line.slice(5).trim();
+    if (!dataStr || dataStr === "[DONE]") return;
+    let payload;
+    try {
+      payload = JSON.parse(dataStr);
+    } catch {
+      return;
+    }
+    const response = payload.response || payload;
+    if (response.usageMetadata) {
+      const um = response.usageMetadata;
+      const promptTokens = typeof um.promptTokenCount === "number" ? um.promptTokenCount : 0;
+      const cacheRead = typeof um.cachedContentTokenCount === "number" ? um.cachedContentTokenCount : 0;
+      usage.input = Math.max(0, promptTokens - cacheRead);
+      usage.cacheRead = cacheRead;
+      if (typeof um.candidatesTokenCount === "number") usage.output = um.candidatesTokenCount;
+      if (typeof um.totalTokenCount === "number") usage.total = um.totalTokenCount;
+    }
+    const candidate = response.candidates?.[0];
+    if (!candidate) return;
+    if (candidate.finishReason === "MAX_TOKENS") {
+      stopReason = "length";
+    } else if (candidate.finishReason === "SAFETY") {
+      stopReason = "error";
+    }
+    const parts = candidate.content?.parts || [];
+    for (const part of parts) {
+      if (part.thoughtSignature) {
+        lastThoughtSignature = part.thoughtSignature;
+      }
+      if (part.thought) {
+        if (openType !== "thinking") {
+          closeOpenBlock(events);
+          content.push({ type: "thinking", thinking: "" });
+          events.push({ kind: "thinking_start", index: content.length - 1 });
+          openType = "thinking";
+        }
+        const block = content[content.length - 1];
+        const delta = part.text || "";
+        block.thinking = (block.thinking || "") + delta;
+        if (part.thoughtSignature) {
+          block.thoughtSignature = part.thoughtSignature;
+        }
+        events.push({
+          kind: "thinking_delta",
+          index: content.length - 1,
+          delta,
+          ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
+        });
+      } else if (part.functionCall) {
+        closeOpenBlock(events);
+        stopReason = "toolUse";
+        const block = {
+          type: "toolCall",
+          id: part.functionCall.id || `call_${content.length}`,
+          name: part.functionCall.name,
+          arguments: part.functionCall.args || {},
+          thoughtSignature: part.thoughtSignature || lastThoughtSignature
+        };
+        content.push(block);
+        events.push({ kind: "toolCall", index: content.length - 1, block });
+      } else if (part.text !== void 0) {
+        if (openType !== "text") {
+          closeOpenBlock(events);
+          content.push({ type: "text", text: "" });
+          events.push({ kind: "text_start", index: content.length - 1 });
+          openType = "text";
+        }
+        const block = content[content.length - 1];
+        block.text = (block.text || "") + part.text;
+        events.push({ kind: "text_delta", index: content.length - 1, delta: part.text });
+      }
+    }
+  };
+  return {
+    feed(chunk) {
+      const events = [];
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const rawLine of lines) processLine(rawLine, events);
+      return snapshot(events);
+    },
+    close() {
+      const events = [];
+      if (buffer.trim() !== "") processLine(buffer, events);
+      buffer = "";
+      closeOpenBlock(events);
+      return snapshot(events);
+    },
+    result() {
+      return {
+        content,
+        usage: { ...usage },
+        stopReason
+      };
+    }
+  };
+}
+
+// src/builder.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+var BASE64_SIGNATURE_PATTERN = /^[A-Za-z0-9+/_-]+={0,2}$/;
+function isValidThoughtSignature(sig) {
+  if (typeof sig !== "string" || sig.length === 0) return false;
+  if (sig.includes("=") && sig.length % 4 !== 0) return false;
+  return BASE64_SIGNATURE_PATTERN.test(sig);
+}
+function resolveThoughtSignature(isSameProviderAndModel, sig) {
+  if (!isSameProviderAndModel) return void 0;
+  return isValidThoughtSignature(sig) ? sig : void 0;
+}
+function isCompatibleModelFamily(msgModel, targetModelId) {
+  if (!msgModel || !targetModelId) return true;
+  if (msgModel === targetModelId) return true;
+  const isMsgGemini = msgModel.startsWith("gemini-");
+  const isTargetGemini = targetModelId.startsWith("gemini-");
+  if (isMsgGemini && isTargetGemini) return true;
+  const isMsgClaude = msgModel.startsWith("claude-");
+  const isTargetClaude = targetModelId.startsWith("claude-");
+  if (isMsgClaude && isTargetClaude) return true;
+  const isMsgGpt = msgModel.startsWith("gpt-");
+  const isTargetGpt = targetModelId.startsWith("gpt-");
+  if (isMsgGpt && isTargetGpt) return true;
+  return extractBaseModelId(msgModel) === extractBaseModelId(targetModelId);
+}
+function deriveSessionId(context, explicitSessionId) {
+  if (explicitSessionId && typeof explicitSessionId === "string" && explicitSessionId.trim().length > 0) {
+    return explicitSessionId.trim();
+  }
+  const firstMsg = context.messages?.[0];
+  if (!firstMsg) {
+    return randomUUID();
+  }
+  const seedContent = typeof firstMsg.content === "string" ? firstMsg.content : JSON.stringify(firstMsg.content || "");
+  const hash = createHash2("sha256").update(`antigravity:conversation:${seedContent}`).digest().subarray(0, 16);
+  hash[6] = hash[6] & 15 | 64;
+  hash[8] = hash[8] & 63 | 128;
+  const hex = [...hash].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function resolveSessionTrajectory(sessionId) {
+  const bytes = createHash2("sha1").update(`antigravity:${sessionId}`).digest().subarray(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function resolveNumericSessionId(sessionId) {
+  if (/^-?\d+$/.test(sessionId)) {
+    return sessionId;
+  }
+  const hash = createHash2("sha256").update(`antigravity:session:${sessionId}`).digest();
+  return hash.readBigInt64BE(0).toString();
+}
+function normalizeToolCallId(id) {
+  if (!id || typeof id !== "string") return id;
+  return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+var CUSTOM_TOOL_SCHEMA_ALLOW = /* @__PURE__ */ new Set([
+  "type",
+  "description",
+  "properties",
+  "required",
+  "items",
+  "enum"
+]);
+function stripMetaSchema(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+  const omit = /* @__PURE__ */ new Set(["$schema", "$id", "$defs", "definitions"]);
+  const out = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (!omit.has(key)) out[key] = stripMetaSchema(value);
+  }
+  return out;
+}
+function normalizeCustomToolSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(normalizeCustomToolSchema);
+  const s = schema;
+  const out = {};
+  for (const [key, value] of Object.entries(s)) {
+    if (!CUSTOM_TOOL_SCHEMA_ALLOW.has(key)) {
+      if (key === "const" && s.enum === void 0 && typeof value === "string") {
+        out.enum = [value];
+      }
+      continue;
+    }
+    if (key === "type" && Array.isArray(value)) {
+      const scalar = value.find((e) => typeof e === "string" && e !== "null");
+      if (scalar) out.type = scalar;
+      continue;
+    }
+    if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = normalizeCustomToolSchema(propSchema);
+      }
+      out.properties = props;
+      continue;
+    }
+    if (key === "enum" && Array.isArray(value) && !value.every((e) => typeof e === "string")) {
+      continue;
+    }
+    out[key] = normalizeCustomToolSchema(value);
+  }
+  return out;
+}
+function convertTools(tools, useLegacyParameters = false) {
+  if (!tools?.length) return void 0;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => {
+        const schema = stripMetaSchema(tool.parameters) || { type: "object", properties: {} };
+        return {
+          name: tool.name,
+          description: tool.description,
+          ...useLegacyParameters ? { parameters: normalizeCustomToolSchema(schema) } : { parametersJsonSchema: schema }
+        };
+      })
+    }
+  ];
+}
+function translateTurnTrace(context, runtimeModelId) {
+  const contents = [];
+  const messages = context.messages || [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const parts = [];
+      if (typeof msg.content === "string") {
+        parts.push({ text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type === "text") {
+            parts.push({ text: item.text });
+          } else if (item.type === "image") {
+            parts.push({
+              inlineData: {
+                mimeType: item.mimeType || "image/png",
+                data: item.data
+              }
+            });
+          }
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role: "user", parts });
+      }
+    } else if (msg.role === "assistant") {
+      if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+        continue;
+      }
+      const isSameProvider = !msg.provider || msg.provider === PROVIDER_ID;
+      const isSameModel = isCompatibleModelFamily(msg.model, runtimeModelId);
+      const isSameProviderAndModel = isSameProvider && isSameModel;
+      const parts = [];
+      if (typeof msg.content === "string") {
+        parts.push({ text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type === "text") {
+            const part = { text: item.text };
+            const sig = resolveThoughtSignature(
+              isSameProviderAndModel,
+              item.thoughtSignature || item.textSignature
+            );
+            if (sig) {
+              part.thoughtSignature = sig;
+            }
+            parts.push(part);
+          } else if (item.type === "thinking") {
+            const candidateSig = item.thoughtSignature || item.thinkingSignature || msg.thoughtSignature;
+            const isForeignReasoning = !isSameProviderAndModel || typeof candidateSig === "string" && candidateSig.trim().startsWith("{");
+            if (!isForeignReasoning) {
+              const part = {
+                thought: true,
+                text: item.thinking || ""
+              };
+              const sig = resolveThoughtSignature(true, candidateSig);
+              if (sig) {
+                part.thoughtSignature = sig;
+              }
+              parts.push(part);
+            } else {
+              let text = item.thinking || "";
+              if (!text && typeof candidateSig === "string" && candidateSig.trim().startsWith("{")) {
+                try {
+                  const parsed = JSON.parse(candidateSig);
+                  if (Array.isArray(parsed.summary)) {
+                    text = parsed.summary.filter((s) => s && typeof s.text === "string").map((s) => s.text).join("\n");
+                  }
+                } catch {
+                }
+              }
+              if (text && text.trim() !== "") {
+                parts.push({ text });
+              }
+            }
+          } else if (item.type === "tool_use" || item.type === "toolCall") {
+            const part = {
+              functionCall: {
+                id: normalizeToolCallId(item.id),
+                name: item.name,
+                args: item.input || item.arguments || {}
+              }
+            };
+            const sig = resolveThoughtSignature(
+              isSameProviderAndModel,
+              item.thoughtSignature || msg.thoughtSignature
+            );
+            if (sig) {
+              part.thoughtSignature = sig;
+            }
+            parts.push(part);
+          }
+        }
+      }
+      if (parts.length > 0) {
+        const msgSig = resolveThoughtSignature(
+          isSameProviderAndModel,
+          msg.thoughtSignature
+        );
+        if (msgSig && !parts.some((p) => p.thoughtSignature)) {
+          parts[parts.length - 1].thoughtSignature = msgSig;
+        }
+        contents.push({ role: "model", parts });
+      }
+    } else if (msg.role === "toolResult") {
+      let toolName = msg.toolName || msg.name;
+      if (!toolName && (msg.toolCallId || msg.id)) {
+        const rawTargetId = msg.toolCallId || msg.id;
+        const normTargetId = normalizeToolCallId(rawTargetId);
+        for (const prev of messages) {
+          if (prev.role === "assistant" && Array.isArray(prev.content)) {
+            const found = prev.content.find(
+              (c) => (c.type === "tool_use" || c.type === "toolCall") && (c.id === rawTargetId || normalizeToolCallId(c.id) === normTargetId)
+            );
+            if (found) {
+              toolName = found.name;
+              break;
+            }
+          }
+        }
+      }
+      let toolText = "";
+      const imageParts = [];
+      if (Array.isArray(msg.content)) {
+        const textParts = [];
+        for (const c of msg.content) {
+          if (typeof c === "string") {
+            textParts.push(c);
+          } else if (c.type === "text") {
+            textParts.push(c.text);
+          } else if (c.type === "image") {
+            imageParts.push({
+              inlineData: {
+                mimeType: c.mimeType || "image/png",
+                data: c.data
+              }
+            });
+          } else {
+            textParts.push(JSON.stringify(c));
+          }
+        }
+        toolText = textParts.join("\n");
+      } else if (typeof msg.content === "string") {
+        toolText = msg.content;
+      } else if (msg.content) {
+        toolText = JSON.stringify(msg.content);
+      }
+      const responseObj = { output: toolText };
+      const functionResponse = {
+        name: toolName || "tool",
+        response: responseObj
+      };
+      const rawCallId = msg.toolCallId || msg.id;
+      const callId = normalizeToolCallId(rawCallId);
+      if (callId) {
+        functionResponse.id = callId;
+      }
+      if (imageParts.length > 0) {
+        functionResponse.parts = imageParts;
+      }
+      contents.push({
+        role: "model",
+        parts: [{ functionResponse }]
+      });
+    }
+  }
+  if (contents.length > 0) {
+    const lastContent = contents[contents.length - 1];
+    if (lastContent.role === "model" && !lastContent.parts?.some((p) => p.functionResponse)) {
+      contents.push({
+        role: "user",
+        parts: [{ text: "continue" }]
+      });
+    }
+  }
+  return contents;
+}
+function buildAntigravityRequestBody(params) {
+  const {
+    projectId,
+    plan,
+    context,
+    maxOutputTokens = 65536
+  } = params;
+  const runtimeModelId = plan.runtimeModelId;
+  const sessionId = deriveSessionId(context, params.sessionId);
+  const trajectoryId = params.trajectoryId && typeof params.trajectoryId === "string" && params.trajectoryId.trim().length > 0 ? params.trajectoryId.trim() : resolveSessionTrajectory(sessionId);
+  const contents = translateTurnTrace(context, runtimeModelId);
+  const requestIndex = context.messages.filter((m) => m.role === "assistant").length;
+  const requestId = `agent/${sessionId}/${Date.now()}/${trajectoryId}/${contents.length}`;
+  const modelEnum = plan.modelEnum;
+  const labels = {
+    last_step_index: String(Math.max(0, contents.length - 1)),
+    model_enum: modelEnum,
+    request_id: `${trajectoryId}-${requestIndex}`,
+    trajectory_id: trajectoryId,
+    used_claude: String(plan.isClaude),
+    used_claude_conservative: String(plan.isClaude),
+    used_non_gemini_model: String(plan.isNonGemini)
+  };
+  const generationConfig = {
+    maxOutputTokens,
+    thinkingConfig: plan.thinkingConfig
+  };
+  const request = {
+    contents
+  };
+  if (context.systemPrompt) {
+    request.systemInstruction = {
+      role: "user",
+      parts: [{ text: context.systemPrompt }]
+    };
+  }
+  const tools = convertTools(context.tools, plan.isNonGemini);
+  if (tools) {
+    request.tools = tools;
+  }
+  if (params.toolChoice && params.toolChoice !== "auto" && params.toolChoice !== "Auto") {
+    let mode = "AUTO";
+    const tc = String(params.toolChoice).toLowerCase();
+    if (tc === "none") mode = "NONE";
+    else if (tc === "any" || tc === "required") mode = "ANY";
+    request.toolConfig = {
+      functionCallingConfig: {
+        mode
+      }
+    };
+  }
+  request.labels = labels;
+  request.generationConfig = generationConfig;
+  request.sessionId = resolveNumericSessionId(sessionId);
+  return {
+    project: projectId,
+    requestId,
+    request,
+    model: runtimeModelId,
+    userAgent: "antigravity",
+    requestType: "agent"
+  };
+}
+
+// src/stream.ts
+function streamAntigravity(model, context, options) {
+  const stream = createAssistantMessageEventStream();
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    try {
+      stream.push({ type: "start", partial: output });
+      const rawApiKey = options?.apiKey;
+      if (!rawApiKey) {
+        throw new Error("Missing Antigravity credentials. Run /login antigravity first.");
+      }
+      const { token, projectId } = parseStoredCredentials(rawApiKey);
+      const effort = options?.reasoning || options?.reasoningEffort || options?.thinking;
+      const snapshot = getCatalogSnapshot();
+      const plan = resolveModelPlan(model.id, effort, snapshot);
+      const requestBody = buildAntigravityRequestBody({
+        projectId,
+        plan,
+        context,
+        sessionId: options?.sessionId,
+        trajectoryId: options?.trajectoryId,
+        maxOutputTokens: model.maxTokens,
+        toolChoice: options?.toolChoice
+      });
+      const res = await fetch(`${DEFAULT_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`, {
+        method: "POST",
+        headers: buildAntigravityHeaders(token),
+        body: JSON.stringify(requestBody),
+        signal: options?.signal
+      });
+      if (!res.ok) {
+        const errText = await res.text();
+        throw new Error(`Antigravity stream failed (${res.status}): ${errText}`);
+      }
+      if (!res.body) {
+        throw new Error("No response stream received from Antigravity.");
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      const feed = createSseFeed();
+      const applyUsage = (u) => {
+        output.usage.input = u.input;
+        output.usage.cacheRead = u.cacheRead;
+        output.usage.output = u.output;
+        output.usage.totalTokens = u.total;
+        if (model.cost) {
+          const c = model.cost;
+          const inputCost = output.usage.input * (c.input || 0) / 1e6;
+          const outputCost = output.usage.output * (c.output || 0) / 1e6;
+          const cacheCost = output.usage.cacheRead * (c.cacheRead || 0) / 1e6;
+          output.usage.cost = {
+            input: inputCost,
+            output: outputCost,
+            cacheRead: cacheCost,
+            cacheWrite: 0,
+            total: inputCost + outputCost + cacheCost
+          };
+        }
+      };
+      const applyStopReason = (r) => {
+        if (r === "stop") {
+          if (output.stopReason === "pending") output.stopReason = "stop";
+        } else {
+          output.stopReason = r;
+        }
+      };
+      const translate = (events) => {
+        for (const ev of events) {
+          if (ev.kind === "text_start" || ev.kind === "thinking_start") {
+            const isThinking = ev.kind === "thinking_start";
+            output.content.push(
+              isThinking ? { type: "thinking", thinking: "" } : { type: "text", text: "" }
+            );
+            stream.push(
+              isThinking ? { type: "thinking_start", contentIndex: ev.index, partial: output } : { type: "text_start", contentIndex: ev.index, partial: output }
+            );
+          } else if (ev.kind === "text_delta" || ev.kind === "thinking_delta") {
+            const block = output.content[ev.index];
+            if (ev.kind === "text_delta") {
+              block.text += ev.delta;
+              stream.push({ type: "text_delta", contentIndex: ev.index, delta: ev.delta, partial: output });
+            } else {
+              block.thinking += ev.delta;
+              if (ev.thoughtSignature) block.thoughtSignature = ev.thoughtSignature;
+              stream.push({ type: "thinking_delta", contentIndex: ev.index, delta: ev.delta, partial: output });
+            }
+          } else if (ev.kind === "text_end" || ev.kind === "thinking_end") {
+            stream.push(
+              ev.kind === "text_end" ? { type: "text_end", contentIndex: ev.index, content: ev.content, partial: output } : { type: "thinking_end", contentIndex: ev.index, content: ev.content, partial: output }
+            );
+          } else if (ev.kind === "toolCall") {
+            const toolCall = {
+              type: "toolCall",
+              id: ev.block.id || `call_${output.content.length}`,
+              name: ev.block.name,
+              arguments: ev.block.arguments || {},
+              thoughtSignature: ev.block.thoughtSignature
+            };
+            output.content.push(toolCall);
+            stream.push({ type: "toolcall_start", contentIndex: ev.index, partial: output });
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex: ev.index,
+              delta: JSON.stringify(toolCall.arguments),
+              partial: output
+            });
+            stream.push({
+              type: "toolcall_end",
+              contentIndex: ev.index,
+              toolCall,
+              partial: output
+            });
+          }
+        }
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const fed = feed.feed(decoder.decode(value, { stream: true }));
+        applyUsage(fed.usage);
+        applyStopReason(fed.stopReason);
+        translate(fed.events);
+      }
+      const closing = feed.close();
+      applyUsage(closing.usage);
+      applyStopReason(closing.stopReason);
+      translate(closing.events);
+      if (closing.thoughtSignature) {
+        const thinkingBlock = output.content.find((c) => c.type === "thinking");
+        if (thinkingBlock && !thinkingBlock.thoughtSignature) {
+          thinkingBlock.thoughtSignature = closing.thoughtSignature;
+        }
+        output.thoughtSignature = closing.thoughtSignature;
+      }
+      const doneReason = output.stopReason === "toolUse" || output.stopReason === "length" ? output.stopReason : "stop";
+      stream.push({
+        type: "done",
+        reason: doneReason,
+        message: output
+      });
+      stream.end();
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+  return stream;
+}
+
+// src/quota.ts
+function renderProgressBar(fraction, width = 10) {
+  const clamped = Math.max(0, Math.min(1, fraction));
+  const filled = Math.round(clamped * width);
+  return `[${"#".repeat(filled)}${"-".repeat(width - filled)}]`;
+}
+var QUOTA_WINDOW_RANK = {
+  "5h": 0,
+  weekly: 1,
+  other: 2
+};
+function classifyQuotaWindow(bucket) {
+  const s = `${bucket.window || ""} ${bucket.displayName || ""} ${bucket.bucketId || ""}`.toLowerCase();
+  if (s.includes("5h") || s.includes("five") || s.includes("rolling")) return "5h";
+  if (s.includes("week")) return "weekly";
+  return "other";
+}
+function shortWindowLabel(bucket, kind) {
+  if (kind === "5h") return "5h";
+  if (kind === "weekly") return "Wk";
+  return bucket.displayName || bucket.bucketId || "Quota";
+}
+function sortQuotaBuckets(buckets) {
+  return buckets.slice().sort((a, b) => QUOTA_WINDOW_RANK[classifyQuotaWindow(a)] - QUOTA_WINDOW_RANK[classifyQuotaWindow(b)]);
+}
+function formatResetRemaining(resetTime) {
+  if (!resetTime) return null;
+  const ts = Date.parse(resetTime);
+  if (!Number.isFinite(ts)) return null;
+  const delta = ts - Date.now();
+  if (delta <= 0) return "ready";
+  const totalMin = Math.ceil(delta / 6e4);
+  const days = Math.floor(totalMin / (60 * 24));
+  const hours = Math.floor(totalMin % (60 * 24) / 60);
+  const mins = totalMin % 60;
+  if (days > 0) return `in ${days}d ${hours}h`;
+  if (hours > 0) return `in ${hours}h ${mins}m`;
+  return `in ${mins}m`;
+}
+function parseQuotaSummary(data) {
+  const groups = [];
+  for (const g of data.groups || []) {
+    const buckets = [];
+    for (const b of g.buckets || []) {
+      buckets.push({
+        bucketId: b.bucketId || "unknown",
+        displayName: b.displayName || b.bucketId || "Limit",
+        window: b.window,
+        resetTime: b.resetTime,
+        description: b.description,
+        remainingFraction: typeof b.remainingFraction === "number" ? b.remainingFraction : 1
+      });
+    }
+    groups.push({
+      displayName: g.displayName || "Quota Group",
+      description: g.description,
+      buckets
+    });
+  }
+  return {
+    groups,
+    description: data.description
+  };
+}
+function formatQuotaSummary(summary) {
+  const lines = [];
+  for (const group of summary.groups) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`${group.displayName}`);
+    for (const b of sortQuotaBuckets(group.buckets)) {
+      const pct = Math.round(b.remainingFraction * 100);
+      const label = shortWindowLabel(b, classifyQuotaWindow(b)).padEnd(3);
+      const reset = formatResetRemaining(b.resetTime);
+      const suffix = reset && pct < 100 ? ` (${reset})` : "";
+      lines.push(`  ${label} ${renderProgressBar(b.remainingFraction)} ${String(pct).padStart(3)}% left${suffix}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function fetchQuotaSummary(token, projectId = "aicode-consumers", endpoint = DEFAULT_ENDPOINT, signal) {
+  const res = await fetch(`${endpoint}/v1internal:retrieveUserQuotaSummary`, {
+    method: "POST",
+    headers: buildAntigravityHeaders(token),
+    body: JSON.stringify({ project: projectId }),
+    signal
+  });
+  if (!res.ok) {
+    const errText = await res.text();
+    throw new Error(`Failed to fetch quota summary (${res.status}): ${errText}`);
+  }
+  const json = await res.json();
+  return parseQuotaSummary(json);
+}
+
+// src/commands.ts
+var USAGE_TEXT = "Usage: /antigravity <command>\n\nCommands:\n  usage    Show 5h and weekly quota pool limits\n  models   List recommended models with context window and remaining quota (alias: model)\n  refresh  Force refresh model catalog\n  login    Run /login antigravity";
+var FETCH_SUBCOMMANDS = {
+  usage: {
+    progress: "Fetching quota summary\u2026",
+    errLabel: "usage",
+    run: (token, projectId, signal) => fetchQuotaSummary(token, projectId, DEFAULT_ENDPOINT, signal).then(formatQuotaSummary)
+  },
+  models: {
+    progress: "Fetching available models\u2026",
+    errLabel: "models",
+    run: (token, projectId, signal) => fetchAvailableModelsCatalog(token, projectId, DEFAULT_ENDPOINT, signal).then(formatModelsList)
+  }
+};
+function emitOutput(ctx, text, type = "info") {
+  if (ctx.hasUI) {
+    ctx.ui.notify(text, type);
+  } else {
+    if (type === "error" || type === "warning") console.error(text);
+    else console.log(text);
+  }
+}
+async function resolveToken(ctx) {
+  const apiKey = await ctx.modelRegistry?.getApiKeyForProvider?.(PROVIDER_ID);
+  if (!apiKey) return null;
+  return parseStoredCredentials(apiKey);
+}
+async function runWithToken(ctx, cmd) {
+  const creds = await resolveToken(ctx);
+  if (!creds) {
+    emitOutput(ctx, "Not logged in. Run /login antigravity first.", "warning");
+    return;
+  }
+  try {
+    if (ctx.hasUI) ctx.ui.notify(cmd.progress, "info");
+    emitOutput(ctx, await cmd.run(creds.token, creds.projectId, ctx.signal));
+  } catch (err) {
+    emitOutput(ctx, `Failed to fetch ${cmd.errLabel}: ${err.message}`, "error");
+  }
+}
+function parseAntigravitySubcommand(args) {
+  const sub = (args || "").trim().toLowerCase();
+  return sub === "model" ? "models" : sub;
+}
+async function runAntigravitySubcommand(args, ctx) {
+  const sub = parseAntigravitySubcommand(args);
+  const fetchCmd = FETCH_SUBCOMMANDS[sub];
+  if (fetchCmd) {
+    await runWithToken(ctx, fetchCmd);
+    return;
+  }
+  if (sub === "refresh") {
+    try {
+      if (ctx.hasUI) ctx.ui.notify("Refreshing models\u2026", "info");
+      await ctx.modelRegistry?.refresh?.({ force: true, providers: [PROVIDER_ID], signal: ctx.signal });
+      emitOutput(ctx, "Antigravity models refreshed successfully.");
+    } catch (err) {
+      emitOutput(ctx, `Failed to refresh: ${err.message}`, "error");
+    }
+    return;
+  }
+  if (sub === "login") {
+    if (ctx.hasUI) {
+      ctx.ui.setEditorText("/login antigravity");
+      ctx.ui.notify("Press Enter to log in to Antigravity.", "info");
+    } else {
+      emitOutput(ctx, "Please run /login antigravity to authenticate.");
+    }
+    return;
+  }
+  emitOutput(ctx, USAGE_TEXT);
+}
+
+// src/index.ts
+var PROVIDER_NAME = "Antigravity";
+function index_default(pi) {
+  pi.registerProvider(PROVIDER_ID, {
+    name: PROVIDER_NAME,
+    baseUrl: DEFAULT_ENDPOINT,
+    api: "antigravity-api",
+    models: [],
+    // Purely dynamic provider per Pi SDK architecture
+    oauth: {
+      name: PROVIDER_NAME,
+      login: loginAntigravity,
+      refreshToken: refreshAntigravityToken,
+      getApiKey
+    },
+    streamSimple: streamAntigravity,
+    refreshModels: async (context) => refreshCatalog(context)
+  });
+  pi.registerCommand("antigravity", {
+    description: "Antigravity provider commands (/antigravity [usage|models|refresh|login])",
+    handler: async (args, ctx) => {
+      await runAntigravitySubcommand(args, ctx);
+    }
+  });
+}
+export {
+  PROVIDER_ID,
+  PROVIDER_NAME,
+  index_default as default,
+  extractBaseModelId
+};
+//# sourceMappingURL=index.js.map