Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

fix(picker): list ag@ models in the order agy models prints them

Jack Rudenkod8a48196ff5c
diff --git a/ai-docs/architecture/providers/antigravity.md b/ai-docs/architecture/providers/antigravity.md
index abea60fa..31e1d770 100644
--- a/ai-docs/architecture/providers/antigravity.md
+++ b/ai-docs/architecture/providers/antigravity.md
@@ -145,6 +145,32 @@ reads it.
drops a cache fetched under another version, because that answer is a different
dynamic models catalog, not a stale copy of the same one.
+## The picker lists `agentModelSorts`, routing lists `models`
+
+`agy models` prints exactly `agentModelSorts[*].groups[*].modelIds`, in that
+order — on the 2026-10-14 account, 13 ids. The `models` dict carries more: older
+generations (`gemini-2.5-*`, `gemini-3-*`, `gemini-3.5-*`) and
+`gemini-3.8-flash-tiered`, which agy does not offer for selection.
+
+`getServedAntigravityModels` returns that list as `agentModelIds` (flattened over
+every sort and group, order kept, deduplicated). The `ag@` picker then lists
+exactly those ids that are also served and not declared excluded, in agy's order.
+When the field is absent or empty the picker falls back to every selectable served
+id, newest first — absent means unknown, not "none".
+
+**The narrowing happens in the picker, not in the discovery fetcher.**
+`fetchAntigravityModelsCatalog` still returns every selectable id; agy's ids lead
+and carry `providerOrder` (their position), the rest carry none.
+`buildRowsFromDiscovered` keeps only the rows that carry it, in that order. The
+fetcher's list is not the picker's alone: `providerServesModel` — the routing
+chain's availability filter — and `discoverContextWindow` read it too, and a
+dynamic models catalog is the one source allowed to answer "not-served", which
+REMOVES a hop. Narrowing the fetcher would have routed a bare `gemini-2.5-pro`
+past the subscription to a metered provider.
+
+Routing is unchanged: `resolveAntigravityModelId` and the transport resolve
+against the full `servedIds`, so a typed `[email protected]` still works.
+
## Ordering: cloud models catalog dates are poison for Antigravity's models
Antigravity rows set `ignoreCatalogReleaseDate`. `compareByReleaseDateDesc` sorts
diff --git a/packages/cli/src/model-selector-antigravity-order.test.ts b/packages/cli/src/model-selector-antigravity-order.test.ts
new file mode 100644
index 00000000..2435741c
--- /dev/null
+++ b/packages/cli/src/model-selector-antigravity-order.test.ts
@@ -0,0 +1,248 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { _resetAgyClientVersion } from "./auth/antigravity-client-version.js";
+import * as tokenModule from "./auth/antigravity-token.js";
+import type { AntigravityTokenDeps } from "./auth/antigravity-token.js";
+import {
+ _resetAntigravityServedModelsCache,
+ resetAntigravityUserCache,
+} from "./auth/antigravity-user.js";
+import { credentials } from "./auth/credentials/authority.js";
+import { buildDiscoveredModelOutcome } from "./model-selector.js";
+import type { CatalogClient } from "./providers/model-catalog.js";
+import {
+ type DiscoveredModel,
+ discoverProviderModelsCatalog,
+ invalidateModelDiscovery,
+ registerModelDiscoveryFetcher,
+} from "./providers/model-discovery.js";
+import type { ProviderDefinition } from "./providers/provider-definitions.js";
+import { clearRuntimeRegistry, registerRuntimeProvider } from "./providers/runtime-providers.js";
+import { _clearChatCapabilityIndex } from "./providers/transport/probe-discovery.js";
+
+const capture = JSON.parse(
+ readFileSync(
+ new URL("./auth/fixtures/antigravity-fetchAvailableModels-1.3.5.json", import.meta.url),
+ "utf8"
+ )
+);
+const agentIds: string[] = capture.agentModelSorts[0].groups[0].modelIds;
+const realFetch = globalThis.fetch;
+const realGetToken = tokenModule.getValidAntigravityAccessToken;
+const realGetRequestAuth = credentials.getRequestAuth;
+let tokenSpy: ReturnType<typeof spyOn> | undefined;
+const NOW = Date.parse("2026-10-14T00:00:00Z");
+const deps: AntigravityTokenDeps = {
+ readStore: () =>
+ "go-keyring-base64:" +
+ Buffer.from(
+ JSON.stringify({
+ token: {
+ access_token: "offline-discovery-token",
+ token_type: "Bearer",
+ refresh_token: "offline-refresh",
+ expiry: new Date(NOW + 3_600_000).toISOString(),
+ },
+ })
+ ).toString("base64"),
+ writeStore: () => {
+ throw new Error("Unexpected token write");
+ },
+ deleteStore: () => {
+ throw new Error("Unexpected token deletion");
+ },
+ runAgyRefresh: () => {
+ throw new Error("Unexpected agy refresh");
+ },
+ readAgyVersion: () => "1.3.5",
+ now: () => NOW,
+};
+const catalog: CatalogClient = {
+ async modelsByVendor() {
+ return [];
+ },
+ async vendorsForModel() {
+ return null;
+ },
+ async searchModels() {
+ return [];
+ },
+ servedByVendor() {
+ return [];
+ },
+};
+
+function resetState(): void {
+ _resetAgyClientVersion();
+ _resetAntigravityServedModelsCache();
+ resetAntigravityUserCache();
+ tokenModule._resetAntigravityTokenState();
+ invalidateModelDiscovery();
+ _clearChatCapabilityIndex();
+ clearRuntimeRegistry();
+}
+
+beforeEach(() => {
+ resetState();
+ // Substitute only the token dependency boundary. The registered production
+ // fetchAntigravityModelsCatalog still performs setup, parsing and exclusions.
+ tokenSpy = spyOn(tokenModule, "getValidAntigravityAccessToken").mockImplementation(() =>
+ realGetToken(deps)
+ );
+ credentials.getRequestAuth = mock(async () => ({
+ headers: { Authorization: "Bearer offline-discovery-token" },
+ }));
+ globalThis.fetch = mock(async () => {
+ throw new Error("Unexpected network request");
+ }) as unknown as typeof fetch;
+});
+afterEach(() => {
+ tokenSpy?.mockRestore();
+ tokenSpy = undefined;
+ credentials.getRequestAuth = realGetRequestAuth;
+ globalThis.fetch = realFetch;
+ resetState();
+});
+
+function stubAntigravityFetch() {
+ const fetchStub = mock(async (input: RequestInfo | URL, init?: RequestInit) => {
+ expect(new Headers(init?.headers).get("User-Agent")).toStartWith("antigravity/cli/1.3.5 ");
+ expect(new Headers(init?.headers).get("Authorization")).toBe("Bearer offline-discovery-token");
+ const url = String(input);
+ if (url.endsWith("/v1internal:loadCodeAssist")) {
+ return Response.json({
+ currentTier: "offline-tier",
+ cloudaicompanionProject: "offline-project",
+ });
+ }
+ if (url.endsWith("/v1internal:fetchAvailableModels")) {
+ expect(JSON.parse(String(init?.body))).toEqual({ project: "offline-project" });
+ return Response.json(capture);
+ }
+ throw new Error(`Unexpected endpoint: ${url}`);
+ });
+ globalThis.fetch = fetchStub as unknown as typeof fetch;
+ return fetchStub;
+}
+
+const PROVIDER = "test-antigravity-picker-order";
+const FORMAT = "test-antigravity-picker-order-format";
+function discoverForPicker(models: DiscoveredModel[]): void {
+ const definition: ProviderDefinition = {
+ name: PROVIDER,
+ displayName: "Offline picker order",
+ transport: "openai",
+ baseUrl: "https://picker-order.invalid",
+ apiPath: "/v1/chat/completions",
+ apiKeyEnvVar: "OFFLINE_PICKER_ORDER_KEY",
+ apiKeyDescription: "Offline only",
+ apiKeyUrl: "https://picker-order.invalid/key",
+ shortcuts: [],
+ legacyPrefixes: [],
+ modelDiscovery: { path: "", format: FORMAT as "ollama-tags" },
+ createHandler: { kind: "none", reason: "virtual", note: "Offline test" },
+ isDirectApi: true,
+ };
+ registerRuntimeProvider(definition);
+ registerModelDiscoveryFetcher(FORMAT, async () => ({
+ kind: "models",
+ models,
+ endpoint: "https://picker-order.invalid/models",
+ }));
+}
+
+describe("Antigravity discovery and picker order", () => {
+ test("B9: production discovery places all 13 agy ids but retains other selectable ids for routing", async () => {
+ const fetchStub = stubAntigravityFetch();
+ const result = await discoverProviderModelsCatalog("antigravity");
+ expect(result.kind).toBe("served");
+ if (result.kind !== "served") throw new Error(JSON.stringify(result));
+ expect(fetchStub).toHaveBeenCalledTimes(2);
+ expect(agentIds).toHaveLength(13);
+ expect(
+ result.models
+ .filter((m) => typeof m.providerOrder === "number")
+ .map((m) => [m.id, m.providerOrder])
+ ).toEqual(agentIds.map((id, index) => [id, index]));
+ const older = result.models.find((m) => m.id === "gemini-2.5-pro");
+ expect(older).toBeDefined();
+ expect(older).not.toHaveProperty("providerOrder");
+ const unplaced = result.models.filter((m) => !agentIds.includes(m.id));
+ expect(unplaced.length).toBeGreaterThan(0);
+ for (const model of unplaced) expect(model).not.toHaveProperty("providerOrder");
+ expect(result.models.some((m) => /^(chat_|tab_)/.test(m.id))).toBe(false);
+ expect(result.models.map((m) => m.id)).not.toContain("gemini-3.1-flash-image");
+ // Check every captured internal id individually; an empty list cannot pass.
+ for (const id of Object.keys(capture.models).filter((id) => /^(chat_|tab_)/.test(id))) {
+ expect(result.models.map((m) => m.id)).not.toContain(id);
+ }
+ });
+
+ test("B10: real Antigravity picker shows exactly the 13 published ids in order", async () => {
+ stubAntigravityFetch();
+ const result = await buildDiscoveredModelOutcome("antigravity", "Antigravity", catalog);
+ expect(result.kind).toBe("rows");
+ if (result.kind !== "rows") throw new Error(JSON.stringify(result));
+ expect(result.rows.map((r) => r.id)).toEqual(agentIds);
+ expect(result.providerOrdered).toBe(true);
+ expect(result.servedCount).toBeGreaterThan(result.rows.length);
+ });
+
+ test("B10: shuffled mixed discovery uses only placed rows, ordered by providerOrder", async () => {
+ discoverForPicker([
+ {
+ id: "offline-newest-unplaced",
+ releaseDate: "2026-10-14",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ {
+ id: "offline-placed-second",
+ providerOrder: 1,
+ releaseDate: "2026-10-10",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ {
+ id: "offline-placed-first",
+ providerOrder: 0,
+ releaseDate: "2026-01-01",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ ]);
+ const result = await buildDiscoveredModelOutcome(PROVIDER, "Offline picker order", catalog);
+ expect(result.kind).toBe("rows");
+ if (result.kind !== "rows") throw new Error(JSON.stringify(result));
+ expect(result.rows.map((r) => r.id)).toEqual(["offline-placed-first", "offline-placed-second"]);
+ expect(result.providerOrdered).toBe(true);
+ });
+
+ test("B10: no providerOrder keeps all rows newest-first and omits providerOrdered", async () => {
+ discoverForPicker([
+ {
+ id: "offline-old",
+ releaseDate: "2026-01-01",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ {
+ id: "offline-new",
+ releaseDate: "2026-10-14",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ {
+ id: "offline-middle",
+ releaseDate: "2026-06-01",
+ reported: "chat",
+ ignoreCatalogReleaseDate: true,
+ },
+ ]);
+ const result = await buildDiscoveredModelOutcome(PROVIDER, "Offline picker order", catalog);
+ expect(result.kind).toBe("rows");
+ if (result.kind !== "rows") throw new Error(JSON.stringify(result));
+ expect(result.rows.map((r) => r.id)).toEqual(["offline-new", "offline-middle", "offline-old"]);
+ expect(result).not.toHaveProperty("providerOrdered");
+ });
+});
diff --git a/packages/cli/src/model-selector.ts b/packages/cli/src/model-selector.ts
index a12df7f2..74bc992f 100644
--- a/packages/cli/src/model-selector.ts
+++ b/packages/cli/src/model-selector.ts
@@ -1656,7 +1656,17 @@ export const _modelsCatalogCollapse = { collapse: collapseModelsCatalog };
* notice would be noise on the majority case.
*/
export type PickerDiscoveryOutcome =
- | { kind: "rows"; rows: [ModelInfo, ...ModelInfo[]]; servedCount: number; chatCount: number }
+ | {
+ kind: "rows";
+ rows: [ModelInfo, ...ModelInfo[]];
+ servedCount: number;
+ chatCount: number;
+ /**
+ * The rows are in the provider's own picker order (`providerOrder`), not
+ * sorted, so the picker must not caption them `newest first`.
+ */
+ providerOrdered?: true;
+ }
| { kind: "all-filtered"; servedCount: number; sampleIds: string[]; fallbackRows: ModelInfo[] }
| { kind: "collapsed-empty"; servedCount: number; chatCount: number; fallbackRows: ModelInfo[] }
| { kind: "empty-models-catalog"; failure: DiscoveryFailure; fallbackRows: ModelInfo[] }
@@ -1755,7 +1765,10 @@ export async function buildDiscoveredModelOutcome(
// rather than length-checked so the non-empty tuple needs no cast to assert.
return { kind: "collapsed-empty", servedCount, chatCount, fallbackRows };
}
- return { kind: "rows", rows: [head, ...tail], servedCount, chatCount };
+ const providerOrdered = discovered.some((m) => typeof m.providerOrder === "number");
+ return providerOrdered
+ ? { kind: "rows", rows: [head, ...tail], servedCount, chatCount, providerOrdered: true }
+ : { kind: "rows", rows: [head, ...tail], servedCount, chatCount };
}
/**
@@ -1861,9 +1874,26 @@ function buildRowsFromDiscovered(
// is only a stable, deterministic input order — its widest-window-first rule
// is meaningful for probe candidates, but for a plan whose entire dynamic models catalog is
// 1M it collapses to alphabetical, which is what made the picker look unsorted.
+ //
+ // The one exception is a provider that publishes its own picker
+ // (`providerOrder`, Antigravity's `agentModelSorts`): the user asked for the
+ // list `agy models` prints — exactly those rows, in its order. The unplaced
+ // rows exist for routing, not for display; see `DiscoveredModel.providerOrder`.
+ const orderById = new Map<string, number>();
+ for (const m of discovered) {
+ if (typeof m.providerOrder === "number") orderById.set(m.id, m.providerOrder);
+ }
+ if (orderById.size > 0) return inProviderOrder(rows, orderById);
return sortModelsNewestFirst(rows);
}
+/** Only the provider-placed rows, in the provider's order. */
+function inProviderOrder(rows: ModelInfo[], orderById: Map<string, number>): ModelInfo[] {
+ return rows
+ .filter((row) => orderById.has(row.id))
+ .sort((a, b) => (orderById.get(a.id) ?? 0) - (orderById.get(b.id) ?? 0));
+}
+
/**
* Select a model from a specific provider with filterable search.
* Rely on Firebase for model data via CatalogClient — no per-provider branching.
diff --git a/packages/cli/src/picker/ModelPicker-provider-order.test.tsx b/packages/cli/src/picker/ModelPicker-provider-order.test.tsx
new file mode 100644
index 00000000..b382167a
--- /dev/null
+++ b/packages/cli/src/picker/ModelPicker-provider-order.test.tsx
@@ -0,0 +1,121 @@
+/** @jsxImportSource @opentui/react */
+import { afterEach, beforeEach, expect, mock, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import { _resetAgyClientVersion } from "../auth/antigravity-client-version.js";
+import { _resetAntigravityTokenState } from "../auth/antigravity-token.js";
+import {
+ _resetAntigravityServedModelsCache,
+ resetAntigravityUserCache,
+} from "../auth/antigravity-user.js";
+import type { ModelInfo, PickerDiscoveryOutcome } from "../model-selector.js";
+import { ModelPicker } from "./ModelPicker.js";
+import type { PickerDataSource } from "./PickerDataSource.js";
+
+const realFetch = globalThis.fetch;
+function resetState(): void {
+ _resetAgyClientVersion();
+ _resetAntigravityServedModelsCache();
+ resetAntigravityUserCache();
+ _resetAntigravityTokenState();
+}
+beforeEach(() => {
+ resetState();
+ globalThis.fetch = mock(async () => {
+ throw new Error("Unexpected network request");
+ }) as unknown as typeof fetch;
+});
+afterEach(() => {
+ globalThis.fetch = realFetch;
+ resetState();
+});
+
+function source(providerOrdered: boolean): PickerDataSource {
+ const row: ModelInfo = {
+ id: "gemini-4-argon-medium",
+ name: "gemini-4-argon-medium",
+ description: "Offline rendered model",
+ provider: "Antigravity",
+ contextLength: 1_048_576,
+ context: "1M",
+ supportsTools: true,
+ };
+ const outcome: PickerDiscoveryOutcome = {
+ kind: "rows",
+ rows: [row],
+ servedCount: 1,
+ chatCount: 1,
+ ...(providerOrdered ? { providerOrdered: true as const } : {}),
+ };
+ return {
+ providerList: () => [
+ {
+ value: "antigravity",
+ label: "Antigravity",
+ shortcut: "ag@",
+ description: "Subscription",
+ billing: "sub",
+ envVar: "",
+ hasDiscovery: true,
+ discoveryShape: "deadline",
+ },
+ ],
+ notEnabledLocalProviders: () => [],
+ displayName: () => "Antigravity",
+ async *probeCredentials(names) {
+ for (const name of names) yield [name, true] as [string, boolean];
+ },
+ async ensureCatalog() {},
+ servedModels: () => [],
+ async discoverModelsCatalog() {
+ return outcome;
+ },
+ async descriptions() {
+ return { get: () => undefined, size: 0 };
+ },
+ };
+}
+
+test.each([true, false])(
+ "B11: providerOrdered=%s controls the model filter's newest-first caption",
+ async (providerOrdered) => {
+ const { renderer, renderOnce, captureCharFrame, mockInput } = await testRender(
+ <ModelPicker source={source(providerOrdered)} onDone={() => {}} />,
+ { width: 100, height: 30 }
+ );
+ try {
+ // Let mount effects install keyboard handling before the first input.
+ await act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 30));
+ await renderOnce();
+ });
+ async function waitFor(text: string): Promise<string> {
+ for (let attempt = 0; attempt < 40; attempt++) {
+ await act(async () => {
+ await renderOnce();
+ });
+ const frame = captureCharFrame();
+ if (frame.includes(text)) return frame;
+ await act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 25));
+ });
+ }
+ throw new Error(`Picker did not paint ${text}:\n${captureCharFrame()}`);
+ }
+ await waitFor("1 of 1 have credentials");
+ await act(async () => {
+ await mockInput.pressKeys(["RETURN"]);
+ await new Promise((resolve) => setTimeout(resolve, 20));
+ });
+ // Wait for the actual model row, never for the caption being tested.
+ const frame = await waitFor("gemini-4-argon-medium");
+ expect(frame).toContain("gemini-4-argon-medium");
+ if (providerOrdered) expect(frame).not.toContain("newest first");
+ else expect(frame).toContain("newest first");
+ } finally {
+ await act(async () => {
+ renderer.destroy();
+ });
+ }
+ }
+);
diff --git a/packages/cli/src/picker/ModelPicker.tsx b/packages/cli/src/picker/ModelPicker.tsx
index 9f3de53d..81fa5114 100644
--- a/packages/cli/src/picker/ModelPicker.tsx
+++ b/packages/cli/src/picker/ModelPicker.tsx
@@ -929,11 +929,17 @@ export function ModelPicker({ source, onDone, onDiscoveryFailure }: ModelPickerP
/>
)}
+ {/* `idle=""` when the provider published its own order (Antigravity's
+ `agentModelSorts`): the rows are not sorted, so `newest first` would
+ be false — the same reason the provider list passes it. */}
<FilterRow
value={filter}
matches={shown.length}
total={list.rows.length}
width={layout.inner}
+ idle={
+ discovery.outcome?.kind === "rows" && discovery.outcome.providerOrdered ? "" : undefined
+ }
/>
<ColumnHeader layout={rowLayout} />
diff --git a/packages/cli/src/providers/model-discovery-builtins.ts b/packages/cli/src/providers/model-discovery-builtins.ts
index 7bd07187..db109d4d 100644
--- a/packages/cli/src/providers/model-discovery-builtins.ts
+++ b/packages/cli/src/providers/model-discovery-builtins.ts
@@ -122,6 +122,21 @@ function isUndeclaredEditorInternal(id: string): boolean {
* catalog — `claude-sonnet-4-6` is 250,000 from the backend against 1,000,000
* in the catalog. `resolveDiscoveredContextLength` already prefers a discovered
* window over the catalog; this is what gives it one to prefer.
+ *
+ * WHICH ids the picker shows follows agy. `agy models` prints exactly the
+ * response's `agentModelSorts` ids, in order — a curated subset of the dynamic
+ * models catalog, which also carries older generations (`gemini-2.5-*`,
+ * `gemini-3-*`). Those rows carry `providerOrder`, and the picker lists exactly
+ * the rows that do, in that order; when the field is absent (unknown, not
+ * "none") no row carries it and the picker shows every selectable id, newest
+ * first.
+ *
+ * THIS FETCHER STILL RETURNS EVERY SELECTABLE ID. It is not the picker's alone:
+ * `providerServesModel` (the routing availability filter) and
+ * `discoverContextWindow` read the same list, and a "not-served" there REMOVES
+ * the `ag@` hop from a bare name's routing chain. Narrowing the list here to
+ * agy's subset would silently route a bare `gemini-2.5-pro` past the
+ * subscription. The narrowing is the picker's, in `buildRowsFromDiscovered`.
*/
async function fetchAntigravityModelsCatalog(): Promise<FetcherResult> {
let endpoint: string | undefined;
@@ -147,18 +162,31 @@ async function fetchAntigravityModelsCatalog(): Promise<FetcherResult> {
}
const { projectId } = await setupAntigravityUser(token);
- const { servedIds, meta, excludedIds } = await getServedAntigravityModels(token, projectId);
+ const { servedIds, meta, excludedIds, agentModelIds } = await getServedAntigravityModels(
+ token,
+ projectId
+ );
// Declared first, guess second. `excludedIds` is the backend's own verdict —
// internal flags, per-feature role bindings, and retired ids (which look
// entirely normal but answer 400).
const declaredExcluded = excludedIds ?? new Set<string>();
- const selectable = servedIds.filter(
- (id) => !declaredExcluded.has(id) && !isUndeclaredEditorInternal(id)
+ // agy's own list, when the backend sent one: those ids, in agy's order,
+ // still intersected with what is served and not declared excluded — a
+ // curated id the account is not served is not a choice. They lead, each
+ // with its position; every other selectable id follows WITHOUT one, kept
+ // for routing (see above) and left out of the picker by the missing field.
+ const served = new Set(servedIds);
+ const agentSelectable = (agentModelIds ?? []).filter(
+ (id) => served.has(id) && !declaredExcluded.has(id)
+ );
+ const position = new Map(agentSelectable.map((id, index) => [id, index]));
+ const otherSelectable = servedIds.filter(
+ (id) => !position.has(id) && !declaredExcluded.has(id) && !isUndeclaredEditorInternal(id)
);
return {
kind: "models",
endpoint,
- models: selectable.map((id) => {
+ models: [...agentSelectable, ...otherSelectable].map((id) => {
const m = meta[id];
// contextWindow is left UNSET when the backend reported none
// (gemini-3.1-flash-image does), so the catalog still gets its turn rather
@@ -170,14 +198,19 @@ async function fetchAntigravityModelsCatalog(): Promise<FetcherResult> {
// and so were the undeclared editor-completion models. What remains is the
// set it offers for chat. Judged by id alone, 14 of 21 read as unknown,
// because these tuned variants are ids the cloud catalog does not carry.
+ // `providerOrder` only on agy's own ids: the rest are in `models` key
+ // order, which nobody curated.
+ const index = position.get(id);
+ const order = index === undefined ? {} : { providerOrder: index };
return m?.contextWindow
? {
id,
contextWindow: m.contextWindow,
ignoreCatalogReleaseDate: true,
reported: "chat" as const,
+ ...order,
}
- : { id, ignoreCatalogReleaseDate: true, reported: "chat" as const };
+ : { id, ignoreCatalogReleaseDate: true, reported: "chat" as const, ...order };
}),
};
} catch (err: unknown) {
diff --git a/packages/cli/src/providers/model-discovery.ts b/packages/cli/src/providers/model-discovery.ts
index 8299465d..61525985 100644
--- a/packages/cli/src/providers/model-discovery.ts
+++ b/packages/cli/src/providers/model-discovery.ts
@@ -78,6 +78,20 @@ export interface DiscoveredModel {
* "newest first".
*/
ignoreCatalogReleaseDate?: boolean;
+ /**
+ * The row's position in the provider's OWN model picker (0 = first), when the
+ * provider publishes one. When any row of a dynamic models catalog carries it,
+ * the claudish picker lists exactly the rows that do, in this order, instead
+ * of every row newest first.
+ *
+ * Antigravity is the case: `agy models` prints `agentModelSorts`, a curated
+ * subset in a curated order, and the picker is asked to match that list
+ * exactly. The rows WITHOUT it stay in the dynamic models catalog on purpose:
+ * the routing availability filter (`providerServesModel`) and
+ * `discoverContextWindow` read the same list, and a row missing there would
+ * read as "not served". Presentation only — routing never reads this field.
+ */
+ providerOrder?: number;
/**
* What the PROVIDER said about whether this model answers chat turns, when it
* said anything. Set by the discovery fetcher that holds the evidence, and read