pi-provider-antigravity 0.6.0 → 0.7.0

package/dist/index.js

@@ -3,7 +3,7 @@ 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.28 (aidev_client; os_type=linux; arch=amd64; cl=978129418; auth_method=consumer)";
+var DEFAULT_USER_AGENT = "antigravity/cli/1.2.0 (aidev_client; os_type=linux; arch=amd64; cl=978750357; auth_method=consumer)";
 var PROVIDER_ID = "antigravity";
 async function postAntigravity({
   token,
@@ -187,10 +187,34 @@ function parseStoredCredentials(rawApiKey) {
 }
 
 // src/model-catalog.ts
+var CANONICAL_TIER_SUFFIXES = Object.freeze({
+  low: "-low",
+  medium: "-medium",
+  high: "-high"
+});
+var TIER_ALIASES = Object.freeze({
+  low: Object.freeze(["-extra-low"]),
+  medium: Object.freeze([]),
+  high: Object.freeze(["-thinking", "-agent"])
+});
+var SPECIAL_TIER_SUFFIXES = Object.freeze(["-tiered"]);
+var ALL_TIER_SUFFIXES = Object.freeze([
+  .../* @__PURE__ */ new Set([
+    ...Object.values(CANONICAL_TIER_SUFFIXES),
+    ...Object.values(TIER_ALIASES).flat(),
+    ...SPECIAL_TIER_SUFFIXES
+  ])
+]);
+var TIER_SUFFIX_PATTERN = new RegExp(
+  `-(?:${ALL_TIER_SUFFIXES.map((s) => s.replace(/^-/, "")).join("|")})$`
+);
+function tierSpellings(tier) {
+  return [CANONICAL_TIER_SUFFIXES[tier], ...TIER_ALIASES[tier]];
+}
 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)$/, "");
+  return runtimeId.replace(TIER_SUFFIX_PATTERN, "");
 }
 function classifyModelFamily(modelId) {
   const bare = ((modelId || "").split("/").pop() || "").toLowerCase();
@@ -206,37 +230,6 @@ function isCompatibleFamily(msgModel, targetModelId) {
   if (msgFamily !== "unknown" && msgFamily === classifyModelFamily(targetModelId)) return true;
   return extractBaseModelId(msgModel) === extractBaseModelId(targetModelId);
 }
-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 };
-}
 function buildThinkingMap(models) {
   return Object.fromEntries(
     models.map((m) => [
@@ -248,87 +241,110 @@ function buildThinkingMap(models) {
     ])
   );
 }
-var activeStore = {
-  enums: {},
-  runtimeIds: [],
-  thinking: {},
-  deprecated: {},
-  version: 0
-};
-function getCatalogSnapshot() {
+function snapshotFromCatalog(catalog) {
   return {
-    enums: { ...activeStore.enums },
-    runtimeIds: [...activeStore.runtimeIds],
+    enums: { ...catalog.modelEnums },
+    runtimeIds: [...new Set(catalog.models.map((m) => m.id))],
+    thinking: buildThinkingMap(catalog.models),
+    deprecated: { ...catalog.deprecated ?? {} }
+  };
+}
+function copySnapshot(snapshot) {
+  return {
+    enums: { ...snapshot.enums },
+    runtimeIds: [...snapshot.runtimeIds],
     thinking: Object.fromEntries(
-      Object.entries(activeStore.thinking ?? {}).map(([id, info]) => [id, { ...info }])
+      Object.entries(snapshot.thinking).map(([id, info]) => [id, { ...info }])
     ),
-    deprecated: { ...activeStore.deprecated ?? {} },
-    version: activeStore.version
+    deprecated: { ...snapshot.deprecated }
   };
 }
-function updateCatalogStore(enums, runtimeIds, thinking = {}, deprecated = {}) {
-  activeStore = {
-    enums: { ...enums },
-    runtimeIds: [...new Set(runtimeIds)],
-    thinking: { ...thinking },
-    deprecated: { ...deprecated },
-    version: activeStore.version + 1
+var EMPTY_SNAPSHOT = () => ({ enums: {}, runtimeIds: [], thinking: {}, deprecated: {} });
+function createCatalogStore() {
+  let generation = { snapshot: EMPTY_SNAPSHOT(), version: 0 };
+  return {
+    generation: () => ({ ...generation, snapshot: copySnapshot(generation.snapshot) }),
+    record: (catalog) => {
+      generation = {
+        snapshot: snapshotFromCatalog(catalog),
+        items: catalog,
+        version: generation.version + 1
+      };
+    },
+    // Version 0 means no fetch has landed in this process, so nothing here can
+    // be fresher than the persist: an older file must never replace a recorded
+    // generation (the refresh path calls this on every start, including after
+    // a successful fetch in the same process).
+    restore: (snapshot) => {
+      if (generation.version > 0) return;
+      generation = { snapshot: copySnapshot(snapshot), version: 0 };
+    }
   };
 }
-var lastCatalog;
-function ingestCatalog(catalog) {
-  updateCatalogStore(
-    catalog.modelEnums,
-    catalog.models.map((m) => m.id),
-    buildThinkingMap(catalog.models),
-    catalog.deprecated || {}
-  );
-  lastCatalog = catalog;
+function toPersistedSnapshot(snapshot) {
+  return {
+    modelEnums: { ...snapshot.enums },
+    runtimeIds: [...snapshot.runtimeIds],
+    thinking: { ...snapshot.thinking },
+    deprecated: { ...snapshot.deprecated }
+  };
+}
+function isStringRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
-function getStoredCatalog() {
-  return lastCatalog;
+function isThinkingRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry));
 }
-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")) {
+function fromPersistedSnapshot(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const entry = raw;
+  const enums = isStringRecord(entry.modelEnums) ? entry.modelEnums : void 0;
+  const runtimeIds = Array.isArray(entry.runtimeIds) ? entry.runtimeIds.filter((id) => typeof id === "string") : void 0;
+  const thinking = isThinkingRecord(entry.thinking) ? entry.thinking : void 0;
+  const deprecated = isStringRecord(entry.deprecated) ? entry.deprecated : void 0;
+  if (!enums && !runtimeIds && !thinking && !deprecated) return void 0;
+  return { enums: enums ?? {}, runtimeIds: runtimeIds ?? [], thinking: thinking ?? {}, deprecated: deprecated ?? {} };
+}
+var TIER_FALLBACKS = Object.freeze({
+  minimal: Object.freeze(["-low", "-extra-low", ""]),
+  low: Object.freeze(["-extra-low", ""]),
+  medium: Object.freeze(["", "-high"]),
+  // Gemini 3.1 Pro lists no -medium: up to high, never down
+  high: Object.freeze(["-thinking", "-agent", ""]),
+  // Claude's high tier is -thinking
+  xhigh: Object.freeze(["-high", "-thinking", "-agent", ""]),
+  max: Object.freeze(["-high", "-thinking", "-agent", ""])
+});
+var DEFAULT_TIER_ORDER = Object.freeze([
+  CANONICAL_TIER_SUFFIXES.high,
+  ...TIER_ALIASES.high,
+  ""
+]);
+function tierCandidateOrder(effort) {
+  if (!effort) return DEFAULT_TIER_ORDER;
+  const canonical = effort in CANONICAL_TIER_SUFFIXES ? [CANONICAL_TIER_SUFFIXES[effort]] : [`-${effort}`];
+  const fallbacks = TIER_FALLBACKS[effort] ?? DEFAULT_TIER_ORDER;
+  return [.../* @__PURE__ */ new Set([...canonical, ...fallbacks])];
+}
+function resolveRuntimeModelId(modelId, effort, availableRuntimeIds) {
+  if (ALL_TIER_SUFFIXES.some((suffix) => modelId.endsWith(suffix))) {
     return modelId;
   }
-  const isOff = effort === "off" || effort === "none";
-  const isLow = isOff || effort === "low" || effort === "minimal";
-  const isMedium = effort === "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 (availableRuntimeIds.length > 0) {
+    const variants = new Set(availableRuntimeIds.filter((id) => extractBaseModelId(id) === modelId));
+    const order = tierCandidateOrder(effort);
+    for (const suffix of order) {
+      if (variants.has(`${modelId}${suffix}`)) {
+        return `${modelId}${suffix}`;
       }
     }
-  }
-  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`;
+    if (variants.size === 1) {
+      return [...variants][0];
+    }
   }
   return modelId;
 }
-function resolveModelPlan(publicModelId, effort, snapshot = getCatalogSnapshot()) {
+function resolveModelPlan(publicModelId, effort, snapshot) {
   const runtimeModelId = followRenames(
     resolveRuntimeModelId(publicModelId, effort, snapshot.runtimeIds),
     snapshot
@@ -336,14 +352,14 @@ function resolveModelPlan(publicModelId, effort, snapshot = getCatalogSnapshot()
   const modelEnum = snapshot.enums[runtimeModelId];
   if (!modelEnum) {
     throw new Error(
-      `Unknown model "${runtimeModelId}" (not in catalog snapshot v${snapshot.version}). Run /antigravity refresh and pick a current model.`
+      `Unknown model "${runtimeModelId}" (not in the current catalog snapshot). Run /antigravity refresh and pick a current model.`
     );
   }
   const family = classifyModelFamily(runtimeModelId);
   return {
     runtimeModelId,
     modelEnum,
-    thinkingConfig: resolveThinkingConfig(runtimeModelId, effort, snapshot),
+    thinkingConfig: resolveThinkingConfig(runtimeModelId, snapshot),
     isNonGemini: family !== "gemini",
     isClaude: family === "claude"
   };
@@ -359,29 +375,27 @@ function followRenames(runtimeModelId, snapshot) {
   }
   return current;
 }
-function resolveThinkingConfig(runtimeModelId, effort, snapshot = getCatalogSnapshot()) {
-  if (effort === "off" || effort === "none") {
-    return { includeThoughts: false, thinkingBudget: 0 };
-  }
-  const info = snapshot.thinking?.[runtimeModelId];
-  if (info) {
-    if (typeof info.budget === "number") {
-      return { includeThoughts: true, thinkingBudget: info.budget };
-    }
-    if (!info.supportsThinking) {
-      return { includeThoughts: false, thinkingBudget: 0 };
-    }
-  }
-  return getThinkingConfig(runtimeModelId, effort);
+function resolveThinkingConfig(runtimeModelId, snapshot) {
+  const budget = snapshot.thinking[runtimeModelId]?.budget;
+  return typeof budget === "number" ? { includeThoughts: true, thinkingBudget: budget } : { includeThoughts: false, thinkingBudget: 0 };
 }
 function estimateModelCost(_baseId) {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
 function synthesizeDynamicModel(baseId, items) {
   const repItem = items.find((it) => it.id === `${baseId}-high` || it.id === baseId) || items[0];
+  const hasVariant = (suffixes) => items.some((it) => suffixes.some((suffix) => it.id.endsWith(suffix)));
+  const thinkingLevelMap = {
+    off: null,
+    minimal: null,
+    ...hasVariant(tierSpellings("low")) ? {} : { low: null },
+    ...hasVariant(tierSpellings("medium")) ? {} : { medium: null },
+    ...hasVariant(tierSpellings("high")) || items.some((it) => it.id === baseId) ? {} : { high: null }
+  };
+  const family = classifyModelFamily(baseId);
   const isFlash = baseId.includes("flash");
-  const isClaude = baseId.startsWith("claude-");
-  const isGpt = baseId.startsWith("gpt-");
+  const isClaude = family === "claude";
+  const isGpt = family === "gpt";
   const defaultContext = isFlash ? 1048576 : isClaude ? 25e4 : isGpt ? 128e3 : 1048576;
   const defaultMaxOutput = isClaude ? 64e3 : isGpt ? 32768 : 65536;
   return {
@@ -391,6 +405,7 @@ function synthesizeDynamicModel(baseId, items) {
     api: "antigravity-api",
     baseUrl: DEFAULT_ENDPOINT,
     reasoning: repItem?.supportsThinking ?? true,
+    thinkingLevelMap,
     input: repItem?.supportsImages ? ["text", "image"] : ["text"],
     cost: estimateModelCost(baseId),
     contextWindow: repItem?.maxTokens || defaultContext,
@@ -485,53 +500,44 @@ function formatModelsList(catalog) {
 }
 
 // src/catalog-refresh.ts
-async function refreshCatalog(context) {
-  const storedEnums = context.stored?.["pi-provider-antigravity"]?.modelEnums;
-  const storedRuntimeIds = context.stored?.["pi-provider-antigravity"]?.runtimeIds;
-  const storedThinking = context.stored?.["pi-provider-antigravity"]?.thinking;
-  const storedDeprecated = context.stored?.["pi-provider-antigravity"]?.deprecated;
-  if ((storedEnums || storedRuntimeIds || storedThinking || storedDeprecated) && getCatalogSnapshot().version === 0) {
-    updateCatalogStore(storedEnums || {}, storedRuntimeIds || [], storedThinking || {}, storedDeprecated || {});
-  }
+var PRIVATE_SNAPSHOT_KEY = "pi-provider-antigravity";
+async function refreshCatalog(context, store) {
+  const persisted = fromPersistedSnapshot(context.stored?.[PRIVATE_SNAPSHOT_KEY]);
+  if (persisted) store.restore(persisted);
+  const storedModels = () => [...context.stored?.models ?? []];
   if (!context.allowNetwork) {
-    return context.stored?.models || [];
+    return storedModels();
   }
   try {
-    const apiKey = context.credential?.access;
+    const credential = context.credential;
+    const apiKey = credential?.type === "oauth" ? credential.access : void 0;
     if (!apiKey) {
-      return context.stored?.models || [];
+      return storedModels();
     }
     const { token, projectId } = parseStoredCredentials(apiKey);
     const catalog = await fetchAvailableModelsCatalog(token, projectId, context.signal);
-    ingestCatalog(catalog);
+    store.record(catalog);
     const dynamicModels = buildDynamicPublicModels(catalog);
     if (context.publish) {
-      const snap = getCatalogSnapshot();
       await context.publish({
         persist: {
           models: dynamicModels,
           checkedAt: Date.now(),
-          "pi-provider-antigravity": {
-            modelEnums: { ...snap.enums },
-            runtimeIds: [...snap.runtimeIds],
-            thinking: { ...snap.thinking ?? {} },
-            deprecated: { ...snap.deprecated ?? {} }
-          }
+          [PRIVATE_SNAPSHOT_KEY]: toPersistedSnapshot(store.generation().snapshot)
         }
       });
     }
     return dynamicModels;
   } catch {
-    return context.stored?.models || [];
+    return storedModels();
   }
 }
-async function refreshCatalogGeneration(doRefresh) {
-  const before = getCatalogSnapshot().version;
+async function refreshCatalogGeneration(store, doRefresh) {
+  const versionBefore = store.generation().version;
   await doRefresh();
-  const catalog = getStoredCatalog();
-  if (!catalog) return { status: "failed" };
-  if (getCatalogSnapshot().version === before) return { status: "stale", catalog };
-  return { status: "fresh", catalog };
+  const { items, version } = store.generation();
+  if (!items) return { status: "failed" };
+  return { status: version === versionBefore ? "stale" : "fresh", catalog: items };
 }
 function parseAvailableModels(data) {
   const models = [];
@@ -795,6 +801,46 @@ function validPairs(raw) {
   }
   return Object.keys(pairs).length > 0 ? pairs : void 0;
 }
+var FOOTER_MODES = Object.freeze({
+  off: {
+    key: "off",
+    label: "Off",
+    note: "",
+    render: () => ({})
+  },
+  smart: {
+    key: "smart",
+    label: "Smart",
+    note: "Picks whichever window runs out first (5h or weekly), weighting the weekly pool by a ratio learned from your usage",
+    render: (summary, modelId, ratio = DEFAULT_WEEKLY_TO_5H_RATIO) => {
+      if (!summary) return {};
+      const plain = buildQuotaFooter(summary, modelId, ratio);
+      return { plain, colored: colorizeQuotaFooter(plain) };
+    }
+  },
+  all: {
+    key: "all",
+    label: "All",
+    note: "Lists every window of the pool backing the current model (5h or weekly)",
+    render: (summary, modelId) => {
+      if (!summary) return {};
+      const plain = buildQuotaFooterBoth(summary, modelId);
+      return { plain, colored: colorizeQuotaFooterBoth(plain) };
+    }
+  }
+});
+var FOOTER_MODE_OPTIONS = Object.freeze(
+  Object.keys(FOOTER_MODES)
+);
+var FOOTER_MODE_NOTES = Object.freeze(
+  Object.fromEntries(
+    Object.entries(FOOTER_MODES).filter(([, def]) => def.note.length > 0).map(([key, def]) => [key, def.note])
+  )
+);
+function normalizeFooterMode(value) {
+  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return v in FOOTER_MODES ? v : void 0;
+}
 function isAntigravityModel(model) {
   return model?.provider === PROVIDER_ID;
 }
@@ -804,11 +850,8 @@ function paintQuotaStatus(coord, ctx) {
     ctx.ui.setStatus(QUOTA_STATUS_KEY, void 0);
     return;
   }
-  const plain = coord.footerFor(ctx.model?.id, mode);
-  ctx.ui.setStatus(
-    QUOTA_STATUS_KEY,
-    mode === "all" ? colorizeQuotaFooterBoth(plain) : colorizeQuotaFooter(plain)
-  );
+  const { colored } = coord.renderFooter(ctx.model?.id, mode);
+  ctx.ui.setStatus(QUOTA_STATUS_KEY, colored);
 }
 var QuotaStatusCoordinator = class {
   summary;
@@ -830,8 +873,10 @@ var QuotaStatusCoordinator = class {
     return this.store.loadMode();
   }
   footerFor(modelId, mode = "smart") {
-    if (!this.summary || mode === "off") return void 0;
-    return mode === "all" ? buildQuotaFooterBoth(this.summary, modelId) : buildQuotaFooter(this.summary, modelId, this.weeklyTo5hRatio);
+    return FOOTER_MODES[mode]?.render(this.summary, modelId, this.weeklyTo5hRatio).plain;
+  }
+  renderFooter(modelId, mode = "smart") {
+    return FOOTER_MODES[mode]?.render(this.summary, modelId, this.weeklyTo5hRatio) ?? {};
   }
   get isFresh() {
     return !!this.summary && Date.now() - this.fetchedAt < QUOTA_REFRESH_INTERVAL_MS;
@@ -947,10 +992,6 @@ function saveProviderConfig(file, data) {
     return false;
   }
 }
-function normalizeFooterMode(value) {
-  const v = typeof value === "string" ? value.trim().toLowerCase() : "";
-  return v === "off" || v === "smart" || v === "all" ? v : void 0;
-}
 function resolveFooterMode(config) {
   return normalizeFooterMode(config?.settings?.quotaFooter) ?? "off";
 }
@@ -989,12 +1030,9 @@ var SETTINGS_FIELDS = Object.freeze([
     key: "quotaFooter",
     label: "Quota footer",
     description: "Show remaining quota in the footer",
-    options: ["off", "smart", "all"],
+    options: FOOTER_MODE_OPTIONS,
     defaultValue: "off",
-    optionNotes: {
-      smart: "Picks whichever window runs out first (5h or weekly), weighting the weekly pool by a ratio learned from your usage",
-      all: "Lists every window of the pool backing the current model (5h or weekly)"
-    },
+    optionNotes: FOOTER_MODE_NOTES,
     onChange: async (ctx, quotaStatus) => {
       if (!quotaStatus) return;
       if (quotaStatus.mode() !== "off") await quotaStatus.refresh(ctx, { ignoreMode: true });
@@ -1020,10 +1058,11 @@ async function applySettingValue(field, value, file, ctx, quotaStatus) {
   return true;
 }
 function previewQuotaFooterText(coord, modelId, mode) {
-  if (!coord || mode === "off") return void 0;
-  const plain = coord.footerFor(modelId, mode === "all" ? "all" : "smart");
-  if (!plain) return void 0;
-  const colored = mode === "all" ? colorizeQuotaFooterBoth(plain) : colorizeQuotaFooter(plain);
+  if (!coord) return void 0;
+  const normalized = normalizeFooterMode(mode);
+  if (!normalized || normalized === "off") return void 0;
+  const { colored } = coord.renderFooter(modelId, normalized);
+  if (!colored) return void 0;
   return ANSI_FG_RESET + colored;
 }
 function buildSettingsItems(config, fields = SETTINGS_FIELDS) {
@@ -1152,6 +1191,7 @@ function createSseFeed() {
     input: 0,
     output: 0,
     cacheRead: 0,
+    reasoning: 0,
     total: 0
   };
   let stopReason = "stop";
@@ -1166,18 +1206,23 @@ function createSseFeed() {
   });
   const attachLoneSignature = () => {
     if (!lastThoughtSignature) return;
+    const attached = content.some(
+      (b) => b.type === "thinking" ? Boolean(b.thinkingSignature) : b.type === "toolCall" ? Boolean(b.thoughtSignature) : b.type === "text" ? Boolean(b.textSignature) : false
+    );
+    if (attached) return;
     const thinking = content.find((b) => b.type === "thinking");
-    if (thinking && !thinking.thinkingSignature) {
-      thinking.thinkingSignature = lastThoughtSignature;
-    } else if (!thinking) {
-      for (let i = content.length - 1; i >= 0; i--) {
-        const block = content[i];
-        if (block?.type === "text" && !block.textSignature) {
-          block.textSignature = lastThoughtSignature;
-          break;
-        }
+    if (thinking) {
+      if (!thinking.thinkingSignature) thinking.thinkingSignature = lastThoughtSignature;
+      return;
+    }
+    for (let i = content.length - 1; i >= 0; i--) {
+      const block = content[i];
+      if (block?.type === "text" && !block.textSignature) {
+        block.textSignature = lastThoughtSignature;
+        return;
       }
     }
+    content.push({ type: "text", text: "", textSignature: lastThoughtSignature });
   };
   const closeOpenBlock = (events) => {
     if (openType === null) return;
@@ -1211,6 +1256,7 @@ function createSseFeed() {
       const candidates = typeof um.candidatesTokenCount === "number" ? um.candidatesTokenCount : 0;
       const thoughts = typeof um.thoughtsTokenCount === "number" ? um.thoughtsTokenCount : 0;
       usage.output = candidates + thoughts;
+      usage.reasoning = thoughts;
       if (typeof um.totalTokenCount === "number") usage.total = um.totalTokenCount;
     }
     const candidate = response.candidates?.[0];
@@ -1226,6 +1272,8 @@ function createSseFeed() {
         lastThoughtSignature = part.thoughtSignature;
       }
       if (part.thought) {
+        const delta = part.text || "";
+        if (delta === "" && openType !== "thinking") continue;
         if (openType !== "thinking") {
           closeOpenBlock(events);
           content.push({ type: "thinking", thinking: "" });
@@ -1234,7 +1282,6 @@ function createSseFeed() {
         }
         const block = content[content.length - 1];
         if (block?.type !== "thinking") continue;
-        const delta = part.text || "";
         block.thinking += delta;
         if (part.thoughtSignature) {
           block.thinkingSignature = part.thoughtSignature;
@@ -1264,6 +1311,7 @@ function createSseFeed() {
         });
         events.push({ type: "toolcall_end", contentIndex, toolCall: block });
       } else if (part.text !== void 0) {
+        if (part.text === "" && openType !== "text") continue;
         if (openType !== "text") {
           closeOpenBlock(events);
           content.push({ type: "text", text: "" });
@@ -1411,6 +1459,7 @@ function translateTurnTrace(context, runtimeModelId) {
   const contents = [];
   const messages = context.messages || [];
   const isGeminiRequest = classifyModelFamily(runtimeModelId) === "gemini";
+  const isGptRequest = classifyModelFamily(runtimeModelId) === "gpt";
   for (const msg of messages) {
     if (msg.role === "user") {
       const parts = [];
@@ -1464,6 +1513,7 @@ function translateTurnTrace(context, runtimeModelId) {
           } else if (item.type === "thinking") {
             const candidateSig = item.thinkingSignature;
             const isForeignReasoning = !isSameProviderAndModel || typeof candidateSig === "string" && candidateSig.trim().startsWith("{");
+            if (isGptRequest && !isForeignReasoning) continue;
             if (!isForeignReasoning) {
               const part = {
                 thought: true,
@@ -1601,7 +1651,9 @@ function buildAntigravityRequestBody(params) {
   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 requestIndex = contents.filter(
+    (c) => c.role === "model" && !c.parts?.some((p) => p.functionResponse)
+  ).length;
   const requestId = `agent/${sessionId}/${Date.now()}/${trajectoryId}/${contents.length}`;
   const modelEnum = plan.modelEnum;
   const labels = {
@@ -1655,7 +1707,7 @@ function buildAntigravityRequestBody(params) {
 }
 
 // src/stream.ts
-function streamAntigravity(model, context, options) {
+function streamAntigravity(model, context, options, store) {
   const stream = createAssistantMessageEventStream();
   (async () => {
     const output = {
@@ -1684,7 +1736,7 @@ function streamAntigravity(model, context, options) {
       const { token, projectId } = parseStoredCredentials(rawApiKey);
       const effort = options?.reasoning;
       const trajectoryId = options && "trajectoryId" in options && typeof options.trajectoryId === "string" ? options.trajectoryId : void 0;
-      const snapshot = getCatalogSnapshot();
+      const snapshot = store.generation().snapshot;
       const plan = resolveModelPlan(model.id, effort, snapshot);
       const requestBody = buildAntigravityRequestBody({
         projectId,
@@ -1716,6 +1768,7 @@ function streamAntigravity(model, context, options) {
         output.usage.input = fed.usage.input;
         output.usage.cacheRead = fed.usage.cacheRead;
         output.usage.output = fed.usage.output;
+        output.usage.reasoning = fed.usage.reasoning;
         output.usage.totalTokens = fed.usage.total;
         if (model.cost) {
           const c = model.cost;
@@ -1759,13 +1812,75 @@ function streamAntigravity(model, context, options) {
 }
 
 // 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  settings Pick provider settings: Enter cycles values (alias: setting)\n  login    Run /login antigravity";
+var SUBCOMMANDS = Object.freeze([
+  {
+    name: "usage",
+    description: "Show 5h and weekly quota pool limits",
+    run: async ({ ctx, quotaStatus }) => runUsageSubcommand(ctx, quotaStatus)
+  },
+  {
+    name: "models",
+    description: "List recommended models with context window and remaining quota",
+    aliases: Object.freeze(["model"]),
+    run: async ({ ctx, store }) => runModelsSubcommand(ctx, store)
+  },
+  {
+    name: "refresh",
+    description: "Force refresh model catalog",
+    run: async ({ ctx, store }) => runRefreshSubcommand(ctx, store)
+  },
+  {
+    name: "settings",
+    description: "Pick provider settings: Enter cycles values",
+    aliases: Object.freeze(["setting"]),
+    run: async ({ ctx, quotaStatus }) => openSettings(ctx, quotaStatus)
+  },
+  {
+    name: "login",
+    description: "Run /login antigravity",
+    run: ({ ctx }) => runLoginSubcommand(ctx)
+  }
+]);
+function buildUsageText(commands = SUBCOMMANDS) {
+  const maxNameLen = Math.max(...commands.map((c) => c.name.length));
+  const lines = commands.map((c) => {
+    const aliasPart = c.aliases?.length ? ` (alias: ${c.aliases.join(", ")})` : "";
+    return `  ${c.name.padEnd(maxNameLen)} ${c.description}${aliasPart}`;
+  });
+  return `Usage: /antigravity <command>
+
+Commands:
+${lines.join("\n")}`;
+}
+var USAGE_TEXT = buildUsageText();
+function completeSubcommands(prefix, commands = SUBCOMMANDS) {
+  const trimmed = prefix.trim();
+  if (trimmed === "") {
+    return commands.map((s) => ({ value: s.name, label: s.name, description: s.description }));
+  }
+  if (/\s/.test(trimmed)) return null;
+  const lower = trimmed.toLowerCase();
+  return commands.filter((s) => s.name.startsWith(lower)).map((s) => ({
+    value: s.name,
+    label: s.name,
+    description: s.description
+  }));
+}
+function parseAntigravitySubcommand(args, commands = SUBCOMMANDS) {
+  const sub = (args || "").trim().toLowerCase();
+  for (const cmd of commands) {
+    if (cmd.name === sub || cmd.aliases?.includes(sub)) {
+      return cmd.name;
+    }
+  }
+  return sub;
+}
 async function resolveToken(ctx) {
   const apiKey = await ctx.modelRegistry?.getApiKeyForProvider?.(PROVIDER_ID);
   if (!apiKey) return null;
   return parseStoredCredentials(apiKey);
 }
-async function runModelsSubcommand(ctx) {
+async function runModelsSubcommand(ctx, store) {
   if (await resolveToken(ctx) === null) {
     emitOutput(ctx, "Not logged in. Run /login antigravity first.", "warning");
     return;
@@ -1773,6 +1888,7 @@ async function runModelsSubcommand(ctx) {
   try {
     if (ctx.hasUI) ctx.ui.notify("Fetching available models\u2026", "info");
     const { status, catalog } = await refreshCatalogGeneration(
+      store,
       () => ctx.modelRegistry?.refresh?.({ force: true, providers: [PROVIDER_ID], signal: ctx.signal })
     );
     if (status === "failed" || !catalog) {
@@ -1788,12 +1904,6 @@ async function runModelsSubcommand(ctx) {
     emitOutput(ctx, `Failed to fetch models: ${err.message}`, "error");
   }
 }
-function parseAntigravitySubcommand(args) {
-  const sub = (args || "").trim().toLowerCase();
-  if (sub === "model") return "models";
-  if (sub === "setting") return "settings";
-  return sub;
-}
 async function runUsageSubcommand(ctx, quotaStatus) {
   if (await resolveToken(ctx) === null) {
     emitOutput(ctx, "Not logged in. Run /login antigravity first.", "warning");
@@ -1816,46 +1926,38 @@ async function runUsageSubcommand(ctx, quotaStatus) {
     emitOutput(ctx, `Failed to fetch usage: ${err.message}`, "error");
   }
 }
-async function runAntigravitySubcommand(args, ctx, quotaStatus) {
-  const parts = (args || "").trim().split(/\s+/).filter(Boolean);
-  const sub = parseAntigravitySubcommand(parts[0] || "");
-  if (sub === "usage") {
-    await runUsageSubcommand(ctx, quotaStatus);
-    return;
-  }
-  if (sub === "models") {
-    await runModelsSubcommand(ctx);
-    return;
-  }
-  if (sub === "settings") {
-    await openSettings(ctx, quotaStatus);
-    return;
-  }
-  if (sub === "refresh") {
-    try {
-      if (ctx.hasUI) ctx.ui.notify("Refreshing models\u2026", "info");
-      const { status } = await refreshCatalogGeneration(
-        () => ctx.modelRegistry?.refresh?.({ force: true, providers: [PROVIDER_ID], signal: ctx.signal })
-      );
-      if (status === "fresh") {
-        emitOutput(ctx, "Antigravity models refreshed successfully.");
-      } else if (status === "stale") {
-        emitOutput(ctx, "Failed to refresh models, keeping last known list.", "warning");
-      } else {
-        emitOutput(ctx, "Failed to refresh models: no new generation received.", "error");
-      }
-    } 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");
+async function runRefreshSubcommand(ctx, store) {
+  try {
+    if (ctx.hasUI) ctx.ui.notify("Refreshing models\u2026", "info");
+    const { status } = await refreshCatalogGeneration(
+      store,
+      () => ctx.modelRegistry?.refresh?.({ force: true, providers: [PROVIDER_ID], signal: ctx.signal })
+    );
+    if (status === "fresh") {
+      emitOutput(ctx, "Antigravity models refreshed successfully.");
+    } else if (status === "stale") {
+      emitOutput(ctx, "Failed to refresh models, keeping last known list.", "warning");
     } else {
-      emitOutput(ctx, "Please run /login antigravity to authenticate.");
+      emitOutput(ctx, "Failed to refresh models: no new generation received.", "error");
     }
+  } catch (err) {
+    emitOutput(ctx, `Failed to refresh: ${err.message}`, "error");
+  }
+}
+function runLoginSubcommand(ctx) {
+  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.");
+  }
+}
+async function runAntigravitySubcommand(args, ctx, quotaStatus, store) {
+  const parts = (args || "").trim().split(/\s+/).filter(Boolean);
+  const sub = parseAntigravitySubcommand(parts[0] || "");
+  const cmd = SUBCOMMANDS.find((c) => c.name === sub);
+  if (cmd) {
+    await cmd.run({ ctx, quotaStatus, store });
     return;
   }
   emitOutput(ctx, USAGE_TEXT);
@@ -1863,15 +1965,9 @@ async function runAntigravitySubcommand(args, ctx, quotaStatus) {
 
 // src/index.ts
 var PROVIDER_NAME = "Antigravity";
-var SUBCOMMANDS = [
-  { name: "usage", description: "Show 5h and weekly quota pool limits" },
-  { name: "models", description: "List recommended models with context window and remaining quota" },
-  { name: "refresh", description: "Force refresh model catalog" },
-  { name: "settings", description: "Pick provider settings: Enter cycles values" },
-  { name: "login", description: "Run /login antigravity" }
-];
 function index_default(pi) {
   const quotaStatus = new QuotaStatusCoordinator(fileQuotaStatusStore());
+  const catalog = createCatalogStore();
   pi.registerProvider(PROVIDER_ID, {
     name: PROVIDER_NAME,
     baseUrl: DEFAULT_ENDPOINT,
@@ -1884,26 +1980,14 @@ function index_default(pi) {
       refreshToken: refreshAntigravityToken,
       getApiKey
     },
-    streamSimple: streamAntigravity,
-    refreshModels: async (context) => refreshCatalog(context)
+    streamSimple: (model, context, options) => streamAntigravity(model, context, options, catalog),
+    refreshModels: async (context) => refreshCatalog(context, catalog)
   });
   pi.registerCommand("antigravity", {
     description: "Antigravity quota, models and settings",
-    getArgumentCompletions: (prefix) => {
-      const trimmed = prefix.trim();
-      if (trimmed === "") {
-        return SUBCOMMANDS.map((s) => ({ value: s.name, label: s.name, description: s.description }));
-      }
-      if (/\s/.test(trimmed)) return null;
-      const lower = trimmed.toLowerCase();
-      return SUBCOMMANDS.filter((s) => s.name.startsWith(lower)).map((s) => ({
-        value: s.name,
-        label: s.name,
-        description: s.description
-      }));
-    },
+    getArgumentCompletions: (prefix) => completeSubcommands(prefix),
     handler: async (args, ctx) => {
-      await runAntigravitySubcommand(args, ctx, quotaStatus);
+      await runAntigravitySubcommand(args, ctx, quotaStatus, catalog);
     }
   });
   pi.on("session_start", async (_event, ctx) => {