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.mdindex 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 differentdynamic 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 modelsAntigravity rows set `ignoreCatalogReleaseDate`. `compareByReleaseDateDesc` sortsdiff --git a/packages/cli/src/model-selector-antigravity-order.test.ts b/packages/cli/src/model-selector-antigravity-order.test.tsnew file mode 100644index 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.tsindex 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.tsxnew file mode 100644index 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.tsxindex 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. */}<FilterRowvalue={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.tsindex 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.tsindex 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