fix(antigravity): restore concrete models with ACP 1.4

apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts

@@ -173,13 +173,17 @@ export function makeAntigravityAcpAdapterFlavor(
     applyModelSelection: Effect.fn("AntigravityAdapterV2.applyModelSelection")(function* ({
       runtime,
       modelSelection,
+      startResult,
+      allowUnavailableModel,
     }) {
       const defaultModel = yield* options.defaultModel;
       return yield* applyAntigravityAcpModelSelection({
         runtime,
+        models: startResult.sessionSetupResult.models,
         model:
           modelSelection.model === ANTIGRAVITY_DEFAULT_MODEL ? undefined : modelSelection.model,
         defaultModel,
+        allowUnavailableModel,
         mapError: (cause) => cause,
       });
     }),

apps/server/src/provider/AntigravityProvider.test.ts

@@ -28,6 +28,10 @@ import {
   buildAntigravityModelsFromSession,
   makeAntigravityProvider,
 } from "./AntigravityProvider.ts";
+import { antigravity140Session } from "./acp/antigravity140.fixture.ts";
+import { antigravityThirdPartySession } from "./acp/antigravityThirdParty.fixture.ts";
+
+import { antigravity141Session } from "./acp/antigravity141.fixture.ts";
 
 const decodeSettings = Schema.decodeSync(AntigravitySettings);
 const instanceId = ProviderInstanceId.make("antigravity-test");
@@ -178,6 +182,69 @@ const makeHarness = Effect.fn("makeAntigravityProviderHarness")(function* (
 });
 
 describe("Antigravity model catalog", () => {
+  it("preserves every concrete ID in the real Linux ACP 1.4.1 API-key advertisement", () => {
+    const models = buildAntigravityModelsFromSession(antigravity141Session);
+    expect(models.map((model) => model.slug)).toEqual(
+      antigravity141Session.models.availableModels.map((model) => model.modelId),
+    );
+    expect(models).toHaveLength(14);
+    expect(models.find((model) => model.isDefault)?.slug).toBe("gemini-3.8-flash-high");
+  });
+
+  it.each([
+    {
+      name: "family without thinking",
+      configOptions: antigravity140Session.configOptions.slice(0, 1),
+    },
+    {
+      name: "thinking without family",
+      configOptions: antigravity140Session.configOptions.slice(1),
+    },
+    { name: "no config", configOptions: [] },
+  ])("synthetic ACP 1.4.0 catalog: $name", ({ configOptions }) => {
+    const models = buildAntigravityModelsFromSession({ ...antigravity140Session, configOptions });
+    expect(models.map((model) => model.slug)).toEqual(
+      antigravity140Session.models.availableModels.map((model) => model.modelId),
+    );
+  });
+
+  it("synthetic ACP 1.4.0 catalog deduplicates IDs, ignores blanks, and keeps renamed display names", () => {
+    const models = buildAntigravityModelsFromSession({
+      ...antigravity140Session,
+      models: {
+        currentModelId: "removed",
+        availableModels: [
+          { modelId: "gemini-3.8-flash-low", name: "Renamed Low" },
+          ...antigravity140Session.models.availableModels,
+          { modelId: " ", name: "Blank" },
+        ],
+      },
+    });
+    expect(models.map((model) => model.slug)).toEqual([
+      "gemini-3.8-flash-low",
+      "gemini-3.8-flash-high",
+      "gemini-3.8-flash-medium",
+    ]);
+    expect(models[0]?.name).toBe("Renamed Low");
+    expect(models.some((model) => model.isDefault)).toBe(false);
+    expect(
+      buildAntigravityModelsFromSession({
+        ...antigravity140Session,
+        models: { ...antigravity140Session.models, availableModels: [] },
+      }),
+    ).toEqual([]);
+  });
+
+  it("synthetic ACP 1.4.0 ignores non-select options in the model category", () => {
+    const models = buildAntigravityModelsFromSession({
+      configOptions: [
+        { id: "other", name: "Other", type: "boolean", category: "model", currentValue: false },
+        modelConfig,
+      ],
+    });
+    expect(models.map((model) => model.slug)).toEqual(modelOptions.map((model) => model.value));
+  });
+
   it("uses legacy session models only when model config is absent", () => {
     const fromLegacy = buildAntigravityModelsFromSession({
       models: sessionSetupResult.models,
@@ -217,6 +284,114 @@ describe("Antigravity model catalog", () => {
 });
 
 it.layer(layerTest)("Antigravity provider snapshots", (it) => {
+  it.effect("keeps concrete ACP 1.4 models when grouped config options are updated", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeHarness();
+        yield* harness.initialize;
+        yield* harness.provider.onSessionStarted({
+          ...started,
+          sessionSetupResult: antigravity140Session,
+        });
+        const snapshot = yield* harness.provider.snapshot.getSnapshot;
+        expect(snapshot.models.map((model) => [model.slug, model.name])).toEqual([
+          ["gemini-3.8-flash-high", "Gemini 3.8 Flash (High)"],
+          ["gemini-3.8-flash-medium", "Gemini 3.8 Flash (Medium)"],
+          ["gemini-3.8-flash-low", "Gemini 3.8 Flash (Low)"],
+        ]);
+        expect(snapshot.models.find((model) => model.isDefault)?.slug).toBe(
+          "gemini-3.8-flash-high",
+        );
+        yield* harness.provider.onConfigOptionsUpdated(
+          antigravity140Session.configOptions.map((option) =>
+            option.id === "thinking_level" ? { ...option, currentValue: "low" } : option,
+          ),
+        );
+        expect((yield* harness.provider.snapshot.getSnapshot).models).toEqual(snapshot.models);
+        yield* harness.provider.onSessionStarted(started);
+        yield* harness.provider.onConfigOptionsUpdated([
+          { ...modelConfig, options: modelOptions.slice(0, 1) },
+        ]);
+        expect((yield* harness.provider.snapshot.getSnapshot).models).toHaveLength(1);
+      }),
+    ),
+  );
+
+  it.effect(
+    "synthetic ACP 1.4.0 cache keeps the catalog when thinking disappears during selection",
+    () =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const harness = yield* makeHarness();
+          yield* harness.initialize;
+          yield* harness.provider.onSessionStarted({
+            ...started,
+            sessionSetupResult: antigravity140Session,
+          });
+          const before = (yield* harness.provider.snapshot.getSnapshot).models;
+          yield* harness.provider.onConfigOptionsUpdated(
+            antigravity140Session.configOptions.slice(0, 1),
+          );
+          expect((yield* harness.provider.snapshot.getSnapshot).models).toEqual(before);
+        }),
+      ),
+  );
+
+  it.effect.each(["gpt-oss-120b-medium", "claude-sonnet-5-5-low"])(
+    "keeps every concrete family when %s omits thinking_level",
+    (currentModelId) =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const harness = yield* makeHarness();
+          yield* harness.initialize;
+          const setup = {
+            ...antigravityThirdPartySession,
+            models: { ...antigravityThirdPartySession.models, currentModelId },
+            configOptions: antigravityThirdPartySession.configOptions.map((option) => ({
+              ...option,
+              currentValue: currentModelId,
+            })),
+          };
+          yield* harness.provider.onSessionStarted({ ...started, sessionSetupResult: setup });
+          const snapshot = yield* harness.provider.snapshot.getSnapshot;
+          expect(snapshot.models.map((model) => [model.slug, model.name])).toEqual(
+            setup.models.availableModels.map((model) => [model.modelId, model.name]),
+          );
+          expect(snapshot.models.find((model) => model.isDefault)?.slug).toBe(currentModelId);
+          yield* harness.provider.onConfigOptionsUpdated(antigravity140Session.configOptions);
+          yield* harness.provider.onConfigOptionsUpdated(setup.configOptions);
+          expect((yield* harness.provider.snapshot.getSnapshot).models).toEqual(snapshot.models);
+        }),
+      ),
+  );
+
+  it.effect("does not restore removed concrete models after a session refresh", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const harness = yield* makeHarness();
+        yield* harness.initialize;
+        yield* harness.provider.onSessionStarted({
+          ...started,
+          sessionSetupResult: antigravity140Session,
+        });
+        yield* harness.provider.onSessionStarted({
+          ...started,
+          sessionSetupResult: {
+            ...antigravity140Session,
+            models: {
+              ...antigravity140Session.models,
+              availableModels: antigravity140Session.models.availableModels.slice(0, 1),
+            },
+          },
+        });
+        yield* harness.provider.onConfigOptionsUpdated(antigravity140Session.configOptions);
+        expect(
+          (yield* harness.provider.snapshot.getSnapshot).models.map((model) => model.slug),
+        ).toEqual(["gemini-3.8-flash-high"]);
+      }),
+    ),
+  );
+
   it.effect("does not probe or run helper safety checks while disabled", () =>
     Effect.scoped(
       Effect.gen(function* () {

apps/server/src/provider/AntigravityProvider.ts

@@ -31,6 +31,7 @@ import {
   type ServerProviderDraft,
 } from "@t3tools/provider-core/server/snapshotProbe";
 import { resolveUsageLimitsAfterProbe } from "@t3tools/provider-core/server/usageLimits";
+import { antigravityModelConfig, antigravitySessionModels } from "./acp/AntigravityAcpSupport.ts";
 
 const EMPTY_MODEL_CAPABILITIES = createModelCapabilities({ optionDescriptors: [] });
 const MAX_WORKSPACE_SNAPSHOTS = 32;
@@ -47,9 +48,9 @@ type SessionSetupResult = Pick<
 export function buildAntigravityModelsFromSession(
   setup: SessionSetupResult,
 ): ReadonlyArray<ServerProviderModel> {
-  const config = setup.configOptions?.find(
-    (option) => option.id === "model" || option.category === "model",
-  );
+  const config = antigravitySessionModels(setup)
+    ? undefined
+    : antigravityModelConfig(setup.configOptions ?? []);
   const currentValue =
     config?.type === "select" ? config.currentValue : setup.models?.currentModelId;
   const entries =
@@ -115,6 +116,7 @@ function isMissingInstallation(error: EffectAcpErrors.AcpError | ProviderSetupEr
 interface AntigravityProviderState {
   readonly draft: ServerProviderDraft;
   readonly authRevision: number;
+  readonly sessionModels: EffectAcpSchema.SessionModelState | null;
 }
 
 interface AntigravityProviderOptions {
@@ -159,6 +161,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
   const metadata = yield* SubscriptionRef.make<AntigravityProviderState>({
     draft: initialDraft,
     authRevision: 0,
+    sessionModels: null,
   });
   // Preserve disk-discovered skills when callbacks replace workspace commands; the registry will not rescan them.
   const discoveredSkills = new Map<string, ServerProvider["skills"]>();
@@ -286,6 +289,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
       const workspace = cwd ? workspaces.find((entry) => entry.cwd === cwd) : undefined;
       return {
         authRevision: state.authRevision + 1,
+        sessionModels: antigravitySessionModels(started.sessionSetupResult),
         draft: {
           ...draft,
           installed: true,
@@ -324,9 +328,12 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
   const onConfigOptionsUpdated = Effect.fn("AntigravityProvider.onConfigOptionsUpdated")(function* (
     configOptions: ReadonlyArray<EffectAcpSchema.SessionConfigOption>,
   ) {
-    const models = buildAntigravityModelsFromSession({ configOptions });
     yield* SubscriptionRef.update(metadata, (state) => {
       if (state.draft.auth.status !== "authenticated") return state;
+      const models = buildAntigravityModelsFromSession({
+        configOptions,
+        models: state.sessionModels,
+      });
       return { ...state, draft: { ...state.draft, models } };
     });
   });
@@ -375,6 +382,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func
       (state) =>
         ({
           authRevision: state.authRevision + 1,
+          sessionModels: null,
           draft: {
             ...state.draft,
             auth: { status: "unauthenticated" },

apps/server/src/provider/Drivers/antigravityUsageModels.ts

@@ -0,0 +1,68 @@
+interface AntigravityUsageModelDescriptor {
+  readonly family: "gemini" | "claude" | "gpt-oss";
+  readonly rateModel: string;
+  readonly thinkingLevels: readonly string[];
+  // Logical groups, not wire bucket IDs or a reset-cadence policy.
+  readonly usageBucket: "gemini" | "claude-gpt" | "argon";
+  readonly idAliases: readonly number[];
+}
+
+const LEGACY_THINKING_LEVELS = ["low", "medium", "high"] as const;
+
+function model(
+  family: AntigravityUsageModelDescriptor["family"],
+  rateModel: string,
+  idAliases: readonly number[],
+  thinkingLevels: readonly string[] = LEGACY_THINKING_LEVELS,
+  usageBucket: AntigravityUsageModelDescriptor["usageBucket"] = family === "gemini"
+    ? "gemini"
+    : "claude-gpt",
+): AntigravityUsageModelDescriptor {
+  return { family, rateModel, idAliases, thinkingLevels, usageBucket };
+}
+
+// Historical numeric aliases and effort normalization are retained from the reader.
+// This is usage identity, never a selectable-model catalog or account advertisement.
+const MODELS = [
+  model("gemini", "gemini-2.5-pro", [246]),
+  model("gemini", "gemini-2.5-flash", [312]),
+  model("gemini", "gemini-2.5-flash-thinking", [313, 329]),
+  model("gemini", "gemini-2.5-flash-lite", [330]),
+  model("claude", "claude-sonnet-4", [281, 282]),
+  model("claude", "claude-opus-4", [290, 291]),
+  model("claude", "claude-sonnet-4-5", [333, 334]),
+  model("claude", "claude-haiku-4-5", [340, 341]),
+  model("claude", "claude-opus-4-6", [1026]),
+  model("claude", "claude-sonnet-4-6", [1035]),
+  model("gemini", "gemini-3-pro", []),
+  model("gemini", "gemini-3.1-pro", [1016, 1036, 1037]),
+  model("gemini", "gemini-3-flash-preview", [1018, 1084, 1047]),
+  // ACP 1.4 capture: antigravity140.fixture.ts. No captured numeric IDs for new models.
+  model("gemini", "gemini-3.8-flash", [], ["low", "medium", "high"]),
+  // https://discuss.ai.google.dev/t/argon-on-antigravity/189395/2 (separate Pro quota)
+  // https://discuss.ai.google.dev/t/google-loads-of-people-need-answers-for-the-new-completely-destroyed-antigravity/189699/4 (Argon Medium/High)
+  // https://antigravity.google/docs/models (Claude 5.5, GPT-OSS)
+  model("gemini", "gemini-4-argon", [], ["medium", "high"], "argon"),
+  model("gpt-oss", "gpt-oss-120b", [], ["medium"]),
+  model("claude", "claude-sonnet-5-5", [], []),
+  model("claude", "claude-opus-5-5", [], []),
+];
+
+const MODELS_BY_ID = new Map(
+  MODELS.flatMap((descriptor) => descriptor.idAliases.map((id) => [id, descriptor] as const)),
+);
+const MODELS_BY_NAME = new Map(
+  MODELS.flatMap((descriptor) =>
+    [
+      descriptor.rateModel,
+      ...descriptor.thinkingLevels.map((level) => `${descriptor.rateModel}-${level}`),
+    ].map((name) => [name, descriptor] as const),
+  ),
+);
+
+export const antigravityUsageModelFromId = (id: number): string | undefined =>
+  MODELS_BY_ID.get(id)?.rateModel;
+
+export const findAntigravityUsageModel = (
+  name: string,
+): AntigravityUsageModelDescriptor | undefined => MODELS_BY_NAME.get(name);