From 7920fc17c5d92d1c8a692e49b271bbb86b69d378 Mon Sep 17 00:00:00 2001 From: JoshRob Date: Mon, 9 Nov 2026 10:12:02 -0600 Subject: [PATCH 1/2] 2.9.0: learn tiered families from the catalog instead of a name list --- CHANGELOG.md | 8 ++ README.es.md | 9 +- README.md | 9 +- docs/MODEL-VARIANTS.md | 13 +++ package.json | 2 +- src/plugin/config/model-discovery.test.ts | 22 ++++ src/plugin/config/model-discovery.ts | 72 +++++++++++-- src/plugin/config/tiered-families.test.ts | 43 ++++++++ src/plugin/config/tiered-families.ts | 108 ++++++++++++++++++++ src/plugin/transform/model-resolver.test.ts | 21 +++- src/plugin/transform/model-resolver.ts | 18 +++- 11 files changed, 307 insertions(+), 18 deletions(-) create mode 100644 src/plugin/config/tiered-families.test.ts create mode 100644 src/plugin/config/tiered-families.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index cfd531a..2c6757d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## [2.9.0] - 2026-11-09 + +### Changed + +- **A new model family no longer needs a release.** Discovery recognised tiered families from a list (`gemini-4-argon`, `claude-sonnet/opus-5-5`) and a fixed tier vocabulary (`low|medium|high|max`). Both are learned from the catalog now: ids that share a base and differ by a thinking suffix group into one family with its variants, and the request path builds `family-` from what discovery recorded instead of matching a name list. A family that debuts `minimal` — Gemini 4 Hyperion advertises `hyperion-minimal|low|medium|high` — or a name nobody has seen works the day the account lists it. +- **Forward-only stays enforced, generically.** A versioned line still has to be newer than the curated floor, and an unknown suffix is only trusted when the catalog also lists the plain base: without that, `gemini-2.5-flash` and `gemini-2.5-pro` would group as one model with `flash` and `pro` variants. +- `docs/MODEL-VARIANTS.md` and both READMEs describe the rule instead of listing the families it covers. + ## [2.8.4] - 2026-11-09 ### Fixed diff --git a/README.es.md b/README.es.md index bbf2c1e..c199d2f 100644 --- a/README.es.md +++ b/README.es.md @@ -205,9 +205,12 @@ quejarse, por eso se queda documentado para quien tenga uno que funcione. > [!WARNING] > **Gemini 4 Argon y los dos Claude 5.5 gastan cuota mucho más rápido** que el resto de la lista: un solo turno largo puede costar lo que un día entero de Gemini 3.8 Flash. Trabaja en `low` / `medium` y guarda `high` / `max` para lo difícil. -Los cuatro primeros están hardcodeados. Argon y la familia 5.5 llegan por `model_discovery`, -que registra lo que exponga el catálogo de la cuenta — sin esperar una release. Los límites -de tokens salen del backend. +Los cuatro primeros están hardcodeados. Todo lo demás lo **aprende del catálogo de la cuenta** +`model_discovery`: los ids que comparten base y solo cambian por un sufijo de razonamiento se +vuelven una entrada con sus variantes, y el vocabulario de sufijos sale de lo que anuncia el +backend — así una familia que debute `minimal`, o un nombre que nadie ha visto, funciona sin +publicar el plugin. Las líneas con versión siguen teniendo que ser más nuevas que el piso +curado; el catálogo nunca resucita una generación vieja. Los límites de tokens salen del backend.
Configuración manual de modelos (Opcional / Avanzado) diff --git a/README.md b/README.md index ba3263e..dfa4047 100644 --- a/README.md +++ b/README.md @@ -204,9 +204,12 @@ complaint, which is why it stays documented for setups that ship a working one. > [!WARNING] > **Gemini 4 Argon and both Claude 5.5 models spend quota much faster** than the rest of the list: a single long turn can cost what a whole day of Gemini 3.8 Flash costs. Work on `low` / `medium` and keep `high` / `max` for the hard problems. -The first four are hardcoded. Argon and the 5.5 family arrive through `model_discovery`, -which registers whatever the account's own catalog exposes — no release needed. Token -limits come from the backend. +The first four are hardcoded. Everything after them is **learned from the account's +catalog** by `model_discovery`: ids that share a base and differ by a thinking suffix +become one entry with its variants, and the suffix vocabulary comes from what the backend +advertises — so a family that debuts `minimal`, or a name nobody has seen yet, works +without a plugin release. Versioned lines still have to be newer than the curated floor; +the catalog never resurrects an older generation. Token limits come from the backend.
Manual models configuration (Optional / Advanced) diff --git a/docs/MODEL-VARIANTS.md b/docs/MODEL-VARIANTS.md index bcd9c8b..e3555c3 100644 --- a/docs/MODEL-VARIANTS.md +++ b/docs/MODEL-VARIANTS.md @@ -80,6 +80,19 @@ Gemini 3 models use string-based thinking levels. Available levels differ by mod > **Note (2026-10-13):** Gemini 3.7 Flash, Gemini 3.6 Flash and Gemini 3.1 Pro moved to **Google AI Ultra / Enterprise-only** and are no longer registered by this plugin for consumer plans. Gemini 3.8 Flash is the only Gemini model available on consumer plans. > +## Families are learned, not listed + +Discovery groups the catalog by structure, not by name: ids that share a base and differ +only by a thinking suffix (`hyperion-minimal`, `hyperion-low`, ...) become one entry with a +variant per suffix, and the request path builds `family-` from what discovery +recorded. The suffix vocabulary is the backend's, so a tier that did not exist when this +plugin was built works the day an account lists it. + +Two guards keep it forward-only. A versioned line (`gemini-3.5-flash`, `claude-opus-4-6`) +still has to be newer than the curated floor. And an unknown suffix is only read as a tier +when the catalog also lists the plain base, so `gemini-2.5-flash` and `gemini-2.5-pro` +never collapse into one model with `flash` and `pro` variants. + > **Gemini 4 ("Argon") needs no plugin release.** Its ids are `gemini-4-argon-{low,medium,high}` and the grant is **per account** (measured 2026-10-31: a `free-tier` account had it, other accounts only received the `gemini-4-argon-disabled` placeholder). It is deliberately not in the curated catalog: enable [`model_discovery`](CONFIGURATION.md#model-discovery) and one `antigravity-gemini-4-argon` entry with `low`/`medium`/`high` variants is registered for the accounts that have it. Requests must carry the CLI User-Agent, which the plugin sets automatically. --- diff --git a/package.json b/package.json index e11c2d7..f09fe0b 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "opencode-antigravity-auth", - "version": "2.8.4", + "version": "2.9.0", "description": "Google Antigravity IDE OAuth auth plugin for OpenCode v2 - access Gemini 4 Argon, 3.8 Flash, and Claude models using Google credentials", "main": "./dist/index.js", "types": "./dist/index.d.ts", diff --git a/src/plugin/config/model-discovery.test.ts b/src/plugin/config/model-discovery.test.ts index 8b394e4..5ff0b92 100644 --- a/src/plugin/config/model-discovery.test.ts +++ b/src/plugin/config/model-discovery.test.ts @@ -1,3 +1,4 @@ +import { forgetTieredFamilies } from "./tiered-families" import { describe, expect, it, vi, beforeEach } from "vitest"; vi.mock("../quota", () => ({ @@ -246,3 +247,24 @@ describe("collectDiscoveredModels", () => { expect(fetchAvailableModels).not.toHaveBeenCalled(); }); }); + +describe("buildDiscoveredModels with a family nobody taught the plugin", () => { + it("groups a new family from the catalog and remembers how it encodes tiers", () => { + const models = buildDiscoveredModels([ + "hyperion", + "hyperion-minimal", + "hyperion-low", + "hyperion-medium", + "hyperion-high", + ]); + const family = models["antigravity-hyperion"]; + expect(family).toBeDefined(); + expect(Object.keys(family!.variants ?? {})).toEqual(["minimal", "low", "medium", "high"]); + forgetTieredFamilies(); + }); + + it("does not read two different model lines as tiers", () => { + const models = buildDiscoveredModels(["gemini-2.5-pro", "gemini-2.5-flash"]); + expect(models).toEqual({}); + }); +}); diff --git a/src/plugin/config/model-discovery.ts b/src/plugin/config/model-discovery.ts index 6c54bb4..7132eac 100644 --- a/src/plugin/config/model-discovery.ts +++ b/src/plugin/config/model-discovery.ts @@ -1,4 +1,5 @@ import type { OpencodeModelDefinition, OpencodeModelDefinitions, ModelVariant } from "./models"; +import { compareTiers, groupTieredFamilies, rememberTieredFamily } from "./tiered-families.js" import { OPENCODE_WHITELIST_MODELS } from "./models"; import { fetchAvailableModels } from "../quota"; import { createLogger } from "../logger"; @@ -231,7 +232,7 @@ export function displayNameForModelId(id: string): string { export function buildDiscoveredModelDefinition( id: string, metadata?: DiscoveredModelMetadata, - tiers?: readonly TierName[], + tiers?: readonly string[], ): OpencodeModelDefinition { const lower = id.toLowerCase(); const isClaude = lower.startsWith("claude-"); @@ -287,20 +288,70 @@ export function buildDiscoveredModelDefinition( * a `low|medium|high` variant picker, and the same for * `claude-sonnet-5-5-*` / `claude-opus-5-5-*`. */ +/** + * The same forward-only rule the curated floors encode, applied to families that + * were learned from the catalog: a versioned line has to be newer than the + * curated one, and a line with no version in its name (Argon, Hyperion, Carbon) + * is taken as it comes. + */ +function isForwardOnly(base: string): boolean { + const gemini = /^gemini-(\d+)(?:[.-](\d+))?/.exec(base); + if (gemini) { + const [major, minor] = [Number(gemini[1]), Number(gemini[2] ?? 0)]; + const floor = DISCOVERY_GEMINI_FLASH_FLOOR; + return major > floor.major || (major === floor.major && minor > floor.minor); + } + const claude = /^claude-(?:sonnet|opus)-(\d+)(?:-(\d+))?/.exec(base); + if (claude) { + const [major, minor] = [Number(claude[1]), Number(claude[2] ?? 0)]; + const floor = DISCOVERY_CLAUDE_FLOOR; + return major > floor.major || (major === floor.major && minor > floor.minor); + } + return true; +} + export function buildDiscoveredModels( backendIds: Iterable, metadata: Record = {}, ): OpencodeModelDefinitions { - const groups = new Map; ids: Set; sawTierless: boolean }>(); + const groups = new Map; ids: Set; sawTierless: boolean }>(); - for (const rawId of backendIds) { - const id = typeof rawId === "string" ? rawId.trim().toLowerCase() : ""; - if (!isDiscoverableModelId(id)) continue; + const all = [...backendIds].map((rawId) => (typeof rawId === "string" ? rawId.trim().toLowerCase() : "")); + // Families the catalog itself splits by tier. Learned from the ids, not from a + // list: a family that debuts a suffix nobody knew (`hyperion-minimal`) groups + // the same way as the curated ones. + const learned = groupTieredFamilies(all); + + for (const id of all) { + if (!id) continue; if (isCoveredByCuratedCatalog(id)) continue; - const family = familyIdOf(id); - const tier = tierOf(id); - const group = groups.get(family) ?? { tiers: new Set(), ids: new Set(), sawTierless: false }; + let family = familyIdOf(id); + let tier: string | undefined = tierOf(id); + let learnedFamily = false; + for (const [base, tiers] of learned) { + if (id === base) { + family = base; + tier = undefined; + learnedFamily = true; + break; + } + if (id.startsWith(`${base}-`)) { + const suffix = id.slice(base.length + 1); + if (tiers.includes(suffix)) { + family = base; + tier = suffix; + learnedFamily = true; + break; + } + } + } + + if (!learnedFamily && !isDiscoverableModelId(id)) continue; + if (learnedFamily && DISCOVERY_DENYLIST.some((pattern) => pattern.test(id))) continue; + if (learnedFamily && !isForwardOnly(family)) continue; + + const group = groups.get(family) ?? { tiers: new Set(), ids: new Set(), sawTierless: false }; if (tier) { group.tiers.add(tier); } else { @@ -312,7 +363,7 @@ export function buildDiscoveredModels( const discovered: OpencodeModelDefinitions = {}; for (const [family, group] of groups) { - const observedTiers = TIER_ORDER.filter((tier) => group.tiers.has(tier)); + const observedTiers = [...group.tiers].sort(compareTiers); // Limits are declared per concrete id, so take them from whichever id in the // group actually carries them (they are identical across tiers). const groupMetadata: DiscoveredModelMetadata | undefined = @@ -322,6 +373,9 @@ export function buildDiscoveredModels( .find((entry): entry is DiscoveredModelMetadata => Boolean(entry && (entry.maxTokens || entry.maxOutputTokens))); const definition = buildDiscoveredModelDefinition(family, groupMetadata, observedTiers); discovered[`antigravity-${family}`] = definition; + // The request path builds `family-` from this, so recording it here is + // what keeps a brand new family working without a release. + if (observedTiers.length > 0) rememberTieredFamily(family, observedTiers); } return discovered; } diff --git a/src/plugin/config/tiered-families.test.ts b/src/plugin/config/tiered-families.test.ts new file mode 100644 index 0000000..b9fa595 --- /dev/null +++ b/src/plugin/config/tiered-families.test.ts @@ -0,0 +1,43 @@ +import { beforeEach, describe, expect, test } from "vitest" +import { compareTiers, forgetTieredFamilies, groupTieredFamilies, rememberTieredFamily, tieredFamilyOf } from "./tiered-families" + +describe("TieredFamilies.groupTieredFamilies", () => { + test("learns a family from the catalog, including tiers nobody knew", () => { + const grouped = groupTieredFamilies([ + "hyperion", + "hyperion-minimal", + "hyperion-low", + "hyperion-medium", + "hyperion-high", + ]) + expect(grouped.get("hyperion")).toEqual(["minimal", "low", "medium", "high"]) + }) + + test("groups suffixed siblings even when the base is not listed", () => { + const grouped = groupTieredFamilies(["claude-sonnet-5-5-low", "claude-sonnet-5-5-high"]) + expect(grouped.get("claude-sonnet-5-5")).toEqual(["low", "high"]) + }) + + test("leaves a one-off suffix alone", () => { + const grouped = groupTieredFamilies(["claude-opus-4-6-thinking", "gemini-3-flash"]) + expect(grouped.size).toBe(0) + }) +}) + +describe("TieredFamilies.compareTiers", () => { + test("orders known tiers and keeps unknown ones after them", () => { + const tiers = ["high", "ultra", "minimal", "low"].sort(compareTiers) + expect(tiers).toEqual(["minimal", "low", "high", "ultra"]) + }) +}) + +describe("TieredFamilies.tieredFamilyOf", () => { + beforeEach(() => forgetTieredFamilies()) + + test("resolves the family from a plugin model name or a backend id", () => { + rememberTieredFamily("hyperion", ["minimal", "low", "high"]) + expect(tieredFamilyOf("antigravity-hyperion")).toEqual({ base: "hyperion", tiers: ["minimal", "low", "high"] }) + expect(tieredFamilyOf("hyperion-high")).toEqual({ base: "hyperion", tiers: ["minimal", "low", "high"] }) + expect(tieredFamilyOf("gemini-3.8-flash")).toBeUndefined() + }) +}) diff --git a/src/plugin/config/tiered-families.ts b/src/plugin/config/tiered-families.ts new file mode 100644 index 0000000..f6cb070 --- /dev/null +++ b/src/plugin/config/tiered-families.ts @@ -0,0 +1,108 @@ +export * as TieredFamilies from "./tiered-families.js" + +/** + * The backend advertises a thinking tier as an id suffix: `gemini-4-argon-high`, + * `claude-sonnet-5-5-max`, and, as new families land, suffixes nobody taught the + * plugin (`hyperion-minimal`). + * + * Two things are learned from the catalog at discovery time instead of being + * listed here: + * + * - the tier vocabulary, so a family that debuts `minimal` or `ultra` shows up; + * - how each family encodes its tiers, so the request path can build the right + * backend id without a hardcoded list of family names. + */ + +/** Order used to lay out the variant picker; unknown tiers follow, alphabetically. */ +const KNOWN_ORDER = ["minimal", "low", "medium", "high", "max"] as const + +/** Lower is cheaper. Unknown tiers sort after the known ones. */ +export function compareTiers(a: string, b: string) { + const index = (tier: string) => { + const at = (KNOWN_ORDER as readonly string[]).indexOf(tier.toLowerCase()) + return at === -1 ? KNOWN_ORDER.length : at + } + const [ia, ib] = [index(a), index(b)] + return ia === ib ? a.toLowerCase().localeCompare(b.toLowerCase()) : ia - ib +} + +/** family base -> tiers it was observed to advertise */ +const families = new Map() + +export function rememberTieredFamily(base: string, tiers: readonly string[]) { + const key = base.toLowerCase() + const merged = new Set([...(families.get(key) ?? []), ...tiers.map((tier) => tier.toLowerCase())]) + families.set(key, [...merged].sort(compareTiers)) +} + +export function forgetTieredFamilies() { + families.clear() +} + +export interface TieredFamily { + readonly base: string + readonly tiers: readonly string[] +} + +/** + * Family a model belongs to, when discovery saw the backend split it by tier. + * `antigravity-gemini-4-argon` resolves to `gemini-4-argon` with its tiers. + */ +export function tieredFamilyOf(model: string): TieredFamily | undefined { + const normalized = model.toLowerCase().replace(/^antigravity-/, "") + const tiers = families.get(normalized) + if (tiers && tiers.length > 0) return { base: normalized, tiers } + + // A variant name may arrive with the tier still attached (`gemini-4-argon-high`). + for (const [base, seen] of families) { + const suffix = normalized.startsWith(`${base}-`) ? normalized.slice(base.length + 1) : undefined + if (suffix && seen.includes(suffix)) return { base, tiers: seen } + } + return undefined +} + +/** + * Splits catalog ids into `base -> tiers` for every family the backend named more + * than once. A base counts when the catalog lists it on its own (`hyperion`) or + * when at least two ids end in a different single-word suffix + * (`hyperion-low`, `hyperion-high`), which is what keeps one-off ids such as + * `claude-opus-4-6-thinking` from being read as a tier. + */ +export function isKnownTier(suffix: string) { + return (KNOWN_ORDER as readonly string[]).includes(suffix.toLowerCase()) +} + +export function groupTieredFamilies(ids: Iterable): Map { + const byId = new Set() + for (const raw of ids) { + const id = typeof raw === "string" ? raw.trim().toLowerCase() : "" + if (id) byId.add(id) + } + + const candidates = new Map>() + for (const id of byId) { + const cut = id.lastIndexOf("-") + if (cut <= 0) continue + const base = id.slice(0, cut) + const suffix = id.slice(cut + 1) + if (!/^[a-z][a-z0-9]*$/.test(suffix)) continue + // Only a known tier, or a suffix next to a base the catalog lists on its own, + // reads as a tier. Without that, `gemini-2.5-flash` and `gemini-2.5-pro` would + // group as one family with `flash` and `pro` as variants. + if (!isKnownTier(suffix) && !byId.has(base)) continue + const set = candidates.get(base) ?? new Set() + set.add(suffix) + candidates.set(base, set) + } + + const grouped = new Map() + for (const [base, tiers] of candidates) { + const ambiguous = [...tiers].some((tier) => !isKnownTier(tier)); + // An unknown suffix is only trusted when the catalog also names the plain base + // (`hyperion` next to `hyperion-ultra`), never on its own. + if (ambiguous && !byId.has(base)) continue; + if (tiers.size < 2 && !byId.has(base)) continue; + grouped.set(base, [...tiers].sort(compareTiers)) + } + return grouped +} diff --git a/src/plugin/transform/model-resolver.test.ts b/src/plugin/transform/model-resolver.test.ts index dd2419a..d8d057a 100644 --- a/src/plugin/transform/model-resolver.test.ts +++ b/src/plugin/transform/model-resolver.test.ts @@ -9,7 +9,8 @@ import { resolveAntigravityGemini38FlashBackendModel, resolveAntigravityTieredFamilyBackendModel, isAntigravityTieredFamilyModel, -} from "./model-resolver"; +} from "./model-resolver" +import { forgetTieredFamilies, rememberTieredFamily } from "../config/tiered-families"; describe("resolveModelWithTier", () => { describe("Gemini 3 flash models (Issue #109)", () => { @@ -367,6 +368,24 @@ describe("resolveAntigravityGemini36FlashBackendModel", () => { }); describe("resolveAntigravityTieredFamilyBackendModel", () => { + test("resolves a family discovery learned, with a tier the plugin never knew", () => { + // Discovery recorded `hyperion` and the suffixes the catalog advertised. The + // request path must build the backend id from that, not from a name list here. + rememberTieredFamily("hyperion", ["minimal", "low", "medium", "high"]); + try { + expect(resolveAntigravityTieredFamilyBackendModel("antigravity-hyperion", "minimal")).toBe( + "hyperion-minimal", + ); + expect(resolveAntigravityTieredFamilyBackendModel("antigravity-hyperion", "high")).toBe( + "hyperion-high", + ); + expect(resolveAntigravityTieredFamilyBackendModel("antigravity-hyperion")).toBe("hyperion-low"); + expect(isAntigravityTieredFamilyModel("antigravity-hyperion")).toBe(true); + } finally { + forgetTieredFamilies(); + } + }); + it("appends the selected tier to the Gemini 4 Argon family", () => { expect(resolveAntigravityTieredFamilyBackendModel("antigravity-gemini-4-argon", "medium")).toBe("gemini-4-argon-medium"); expect(resolveAntigravityTieredFamilyBackendModel("gemini-4-argon", "high")).toBe("gemini-4-argon-high"); diff --git a/src/plugin/transform/model-resolver.ts b/src/plugin/transform/model-resolver.ts index 43cecc4..e77edd6 100644 --- a/src/plugin/transform/model-resolver.ts +++ b/src/plugin/transform/model-resolver.ts @@ -4,6 +4,7 @@ * Resolves model names with tier suffixes (e.g., gemini-3-pro-high, claude-opus-4-6-thinking-low) * to their actual API model names and corresponding thinking configurations. */ +import { tieredFamilyOf } from "../config/tiered-families.js" import type { ResolvedModel, ThinkingTier, GoogleSearchConfig } from "./types"; @@ -232,6 +233,20 @@ export function resolveAntigravityTieredFamilyBackendModel( thinkingLevel?: string, ): string | undefined { const modelWithoutQuota = model.replace(QUOTA_PREFIX_REGEX, "").toLowerCase(); + + // What discovery saw wins: it knows the family and the suffixes it actually + // advertises, including tiers this file never heard of. + const learned = tieredFamilyOf(modelWithoutQuota); + if (learned) { + const requested = (thinkingLevel ?? "").toLowerCase(); + const level = learned.tiers.includes(requested) + ? requested + : learned.tiers.includes("low") + ? "low" + : learned.tiers[0]!; + return `${learned.base}-${level}`; + } + const match = modelWithoutQuota.match(TIERED_FAMILY_REGEX); if (!match) { return undefined; @@ -249,7 +264,8 @@ export function resolveAntigravityTieredFamilyBackendModel( * tier as a suffix, so a variant can select it. */ export function isAntigravityTieredFamilyModel(model: string): boolean { - return TIERED_FAMILY_REGEX.test(model.replace(QUOTA_PREFIX_REGEX, "").toLowerCase()); + const normalized = model.replace(QUOTA_PREFIX_REGEX, "").toLowerCase(); + return tieredFamilyOf(normalized) !== undefined || TIERED_FAMILY_REGEX.test(normalized); } /** From 7807984c753e2e3ee601beac8e17fe7a9226bbe1 Mon Sep 17 00:00:00 2001 From: JoshRob Date: Mon, 9 Nov 2026 10:12:31 -0600 Subject: [PATCH 2/2] test: use the file's test runner import --- src/plugin/transform/model-resolver.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/plugin/transform/model-resolver.test.ts b/src/plugin/transform/model-resolver.test.ts index d8d057a..7c53a7f 100644 --- a/src/plugin/transform/model-resolver.test.ts +++ b/src/plugin/transform/model-resolver.test.ts @@ -368,7 +368,7 @@ describe("resolveAntigravityGemini36FlashBackendModel", () => { }); describe("resolveAntigravityTieredFamilyBackendModel", () => { - test("resolves a family discovery learned, with a tier the plugin never knew", () => { + it("resolves a family discovery learned, with a tier the plugin never knew", () => { // Discovery recorded `hyperion` and the suffixes the catalog advertised. The // request path must build the backend id from that, not from a name list here. rememberTieredFamily("hyperion", ["minimal", "low", "medium", "high"]);