@linxiraos/pi-catalog 1.2.1 → 1.3.0

package/src/compat/thinking-replay.ts

@@ -0,0 +1,33 @@
+/**
+ * How a reader bills a replayed signed thinking block as input, from the
+ * `thinking-replay-tokens` rules in the compat cascade. A model line's lineage
+ * rule (`rules/classes/*.kdl`) applies on every host; readers without one are
+ * estimated from the signature's bytes.
+ */
+import { classifyModel } from "../identity";
+import { resolveCascade } from "./cascade";
+import type { ImageTokenizationTarget } from "./image-tokenization";
+
+/**
+ * `output`: the reasoning the signature carries, at the size its turn billed
+ * as output; the signature's own bytes are free. `signature`: the signature's
+ * bytes stand in for that reasoning.
+ */
+export type ThinkingReplayTokens = "output" | "signature";
+
+/** How `reader` bills replayed thinking; `signature` unless its lineage declares otherwise. */
+export function resolveThinkingReplayTokens(reader: ImageTokenizationTarget): ThinkingReplayTokens {
+	const provider = reader.provider ?? "";
+	const model = reader.id ?? "";
+	const identity = reader.identity ?? (model ? classifyModel(provider, model, { lenient: true }) : undefined);
+	const tokens = resolveCascade({
+		provider,
+		api: reader.api ?? "",
+		class: identity?.class ?? "unknown",
+		model,
+		reasoning: false,
+		...(identity?.family !== undefined && { family: identity.family }),
+		...(identity?.revision !== undefined && { revision: identity.revision }),
+	}).catalog.thinkingReplayTokens;
+	return tokens === "output" ? "output" : "signature";
+}

package/src/compat/types.d.ts

@@ -328,6 +328,8 @@ export interface CompiledBehavior {
     retryResetTimezones: CompiledRetryResetTimezone[];
     retiredProviders: string[];
     referenceIsolatedProviders: string[];
+    /** Built-in model selector chains per agent role, keyed by role in declaration order. */
+    roleDefaults: Record<string, string[]>;
 }
 /**
  * A string setting from `auth/*.kdl` that may be overridden by environment
@@ -634,6 +636,8 @@ export interface CompiledProvider {
     dynamicModelsAuthoritative?: boolean;
     /** Generator backfills never copy reasoning/input/limits from same-id rows on other hosts. */
     skipCrossProviderReferenceFills?: boolean;
+    /** Runtime discovery keeps a bundled row's display name instead of the live one. */
+    keepBundledNames?: boolean;
     /** Present only for providers enrolled in `generate-models.ts` discovery. */
     discovery?: CompiledProviderDiscovery;
     /** Non-chat model kinds mapped to their runtime transport APIs. */

package/src/compat/types.ts

@@ -352,6 +352,8 @@ export interface CompiledBehavior {
 	retryResetTimezones: CompiledRetryResetTimezone[];
 	retiredProviders: string[];
 	referenceIsolatedProviders: string[];
+	/** Built-in model selector chains per agent role, keyed by role in declaration order. */
+	roleDefaults: Record<string, string[]>;
 }
 
 /**
@@ -668,6 +670,8 @@ export interface CompiledProvider {
 	dynamicModelsAuthoritative?: boolean;
 	/** Generator backfills never copy reasoning/input/limits from same-id rows on other hosts. */
 	skipCrossProviderReferenceFills?: boolean;
+	/** Runtime discovery keeps a bundled row's display name instead of the live one. */
+	keepBundledNames?: boolean;
 	/** Present only for providers enrolled in `generate-models.ts` discovery. */
 	discovery?: CompiledProviderDiscovery;
 	/** Non-chat model kinds mapped to their runtime transport APIs. */

package/src/discovery/antigravity.d.ts

@@ -18,6 +18,13 @@ export interface AntigravityDiscoveryApiModel {
     apiProvider?: string;
     modelProvider?: string;
     isInternal?: boolean;
+    /**
+     * Set for roster rows the backend lists but refuses to serve on this
+     * account (e.g. `gemini-4-argon-disabled`, `tagTitle: "Unavailable"`,
+     * `model: MODEL_PLACEHOLDER_M421`); a request against such an id answers
+     * `Cloud Code Assist API error (404): Requested entity was not found.`
+     */
+    disabled?: boolean;
     supportsVideo?: boolean;
 }
 /**

package/src/discovery/antigravity.ts

@@ -29,6 +29,13 @@ export interface AntigravityDiscoveryApiModel {
 	apiProvider?: string;
 	modelProvider?: string;
 	isInternal?: boolean;
+	/**
+	 * Set for roster rows the backend lists but refuses to serve on this
+	 * account (e.g. `gemini-4-argon-disabled`, `tagTitle: "Unavailable"`,
+	 * `model: MODEL_PLACEHOLDER_M421`); a request against such an id answers
+	 * `Cloud Code Assist API error (404): Requested entity was not found.`
+	 */
+	disabled?: boolean;
 	supportsVideo?: boolean;
 }
 
@@ -72,6 +79,7 @@ const AntigravityDiscoveryApiModelSchema = type({
 	"apiProvider?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
 	"modelProvider?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
 	"isInternal?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+	"disabled?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
 	"supportsVideo?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
 });
 
@@ -188,6 +196,11 @@ export async function fetchAntigravityDiscoveryModels(
 			if (model.isInternal === true) {
 				continue;
 			}
+			// Rows the backend marks unavailable are listed but 404 on inference;
+			// discovery is authoritative, so drop them instead of offering a dead id.
+			if (model.disabled === true) {
+				continue;
+			}
 
 			const supportsImages = model.supportsImages === true;
 			models.push({

package/src/discovery/codex.ts

@@ -69,7 +69,6 @@ const codexModelEntrySchema = type({
 	"priority?": "unknown",
 	"prefer_websockets?": "unknown",
 	"use_responses_lite?": "unknown",
-	"tool_mode?": "unknown",
 	"available_access_programs?": "unknown",
 	"service_tiers?": "unknown",
 });
@@ -302,7 +301,6 @@ interface ParsedCodexModelEntry {
 	input: ("text" | "image")[];
 	preferWebsockets: boolean;
 	useResponsesLite: boolean;
-	toolMode: boolean;
 	priority: number;
 	/** Advertised tier ids; `undefined` when the entry has no `service_tiers` array. */
 	serviceTiers: string[] | undefined;
@@ -356,7 +354,6 @@ function parseCodexModelEntry(entry: unknown): ParsedCodexModelEntry | null {
 		input: normalizeInputModalities(payload.input_modalities),
 		preferWebsockets: toBoolean(payload.prefer_websockets) === true,
 		useResponsesLite: toBoolean(payload.use_responses_lite) === true,
-		toolMode: payload.tool_mode === "code_mode_only",
 		priority: toFiniteNumber(payload.priority) ?? Number.MAX_SAFE_INTEGER,
 		serviceTiers,
 	};
@@ -422,7 +419,6 @@ function buildNormalizedCodexModel(
 			maxTokens,
 			...(parsed.preferWebsockets ? { preferWebsockets: true } : {}),
 			...(parsed.useResponsesLite ? { useResponsesLite: true } : {}),
-			...(parsed.toolMode ? { toolMode: "code_mode_only" as const } : {}),
 			...(parsed.serviceTiers !== undefined ? { serviceTiers: parsed.serviceTiers } : {}),
 			...(parsed.priority !== Number.MAX_SAFE_INTEGER ? { priority: parsed.priority } : {}),
 		},

package/src/discovery/cursor.ts

@@ -1,13 +1,15 @@
 import * as http2 from "node:http2";
 import { type } from "@linxiraos/pi-omptype";
+import { slugify } from "@linxiraos/pi-utils";
 import { collapseVariants, type EffortVariantFamily, reviewedVariantFamilyId } from "../compat/collapse";
 import { compareRevision, parseRevision } from "../compat/revision";
 import { resolveCatalogAxes, resolveModelPolicy } from "../compat/resolve";
 import { classifyModel } from "../compat/taxonomy";
 import { Effort, THINKING_EFFORTS } from "../effort";
 import { getBundledModels } from "../models";
+import { datedCost, parseDatedCostCards } from "../pricing";
 import { toModelSpec } from "../provider-models/bundled-references";
-import type { CursorModelRoute, Model, ModelSpec, TokenCost } from "../types";
+import type { CursorModelRoute, Model, ModelCost, ModelSpec, TokenCost } from "../types";
 import {
 	CURSOR_AVAILABLE_MODELS_PATH,
 	CURSOR_DEFAULT_BASE_URL,
@@ -435,13 +437,21 @@ function cursorVariantCostMultiplier(
 	return multiplier;
 }
 
-function scaleTokenCost(cost: TokenCost, multiplier: number): TokenCost {
+function scaleTokenCost(cost: ModelCost, multiplier: number): ModelCost {
 	if (multiplier === 1) return cost;
+	const scale = <T extends TokenCost>(card: T): T => ({
+		...card,
+		input: card.input * multiplier,
+		output: card.output * multiplier,
+		cacheRead: card.cacheRead * multiplier,
+		cacheWrite: card.cacheWrite * multiplier,
+	});
+	const effectiveRates = cost.timeBased?.effectiveRates;
 	return {
-		input: cost.input * multiplier,
-		output: cost.output * multiplier,
-		cacheRead: cost.cacheRead * multiplier,
-		cacheWrite: cost.cacheWrite * multiplier,
+		...scale({ input: cost.input, output: cost.output, cacheRead: cost.cacheRead, cacheWrite: cost.cacheWrite }),
+		...(cost.timeBased && {
+			timeBased: { ...cost.timeBased, ...(effectiveRates && { effectiveRates: effectiveRates.map(scale) }) },
+		}),
 	};
 }
 
@@ -462,7 +472,7 @@ function resolveRichCursorCardCost(
 	details: AvailableModelsResponse_ModelDetails,
 	entry: NormalizedRichVariant,
 	laneId: string,
-): TokenCost | undefined {
+): ModelCost | undefined {
 	const costAxes = details.parameterDefinitions
 		.filter(definition =>
 			[
@@ -503,7 +513,7 @@ function resolveRichCursorCardCost(
 	return base && scaleTokenCost(base, cursorVariantCostMultiplier(details, entry));
 }
 
-function resolveCursorCardAxes(slug: string): { patch?: TokenCost; fallback?: TokenCost } {
+function resolveCursorCardAxes(slug: string): { patch?: ModelCost; fallback?: ModelCost } {
 	const axes = resolveCatalogAxes({
 		id: slug,
 		name: slug,
@@ -516,7 +526,9 @@ function resolveCursorCardAxes(slug: string): { patch?: TokenCost; fallback?: To
 		contextWindow: DEFAULT_CONTEXT_WINDOW,
 		maxTokens: DEFAULT_MAX_TOKENS,
 	});
-	const card = (payload: unknown): TokenCost | undefined => {
+	// Dated cards ride along as a schedule, so a lane priced from a sibling
+	// slug's card (whose own id no rule matches) still changes price on time.
+	const card = (payload: unknown, axis: "cost-patch" | "cost-fallback"): ModelCost | undefined => {
 		if (typeof payload !== "object" || payload === null) return undefined;
 		const field = (key: string): number | undefined => {
 			const value = Reflect.get(payload, key);
@@ -525,9 +537,12 @@ function resolveCursorCardAxes(slug: string): { patch?: TokenCost; fallback?: To
 		const input = field("input");
 		const output = field("output");
 		if (input === undefined || output === undefined) return undefined;
-		return { input, output, cacheRead: field("cacheRead") ?? 0, cacheWrite: field("cacheWrite") ?? 0 };
+		return datedCost(
+			{ input, output, cacheRead: field("cacheRead") ?? 0, cacheWrite: field("cacheWrite") ?? 0 },
+			parseDatedCostCards(payload, axis),
+		);
 	};
-	return { patch: card(axes.costPatch), fallback: card(axes.costFallback) };
+	return { patch: card(axes.costPatch, "cost-patch"), fallback: card(axes.costFallback, "cost-fallback") };
 }
 
 function normalizeRichCursorModels(
@@ -679,8 +694,8 @@ function cursorLaneId(
 ): string {
 	const suffixes: string[] = [];
 	for (const parameter of parameters) {
-		const id = sanitizeCursorLanePart(parameter.id);
-		const value = sanitizeCursorLanePart(parameter.value);
+		const id = slugify(parameter.id);
+		const value = slugify(parameter.value);
 		// Boolean lanes are named by their `true` side regardless of variant
 		// order: Cursor lists `composer-2.5`'s Fast variant first, and treating
 		// that as the default would hand the bare id to the Fast route.
@@ -729,13 +744,6 @@ function reviewedCursorLaneId(entries: readonly NormalizedRichVariant[], claimed
 	return familyId;
 }
 
-function sanitizeCursorLanePart(value: string): string {
-	return value
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "");
-}
-
 function cursorLaneName(details: AvailableModelsResponse_ModelDetails, laneId: string, baseId: string): string {
 	const baseName =
 		details.clientDisplayName?.trim() || details.serverModelName?.trim() || details.name.trim() || baseId;

package/src/discovery/devin.ts

@@ -1,4 +1,4 @@
-import { logger } from "@linxiraos/pi-utils";
+import { logger, slugify } from "@linxiraos/pi-utils";
 import { collapseVariants, type EffortVariantFamily } from "../compat/collapse";
 import { Effort, THINKING_EFFORTS } from "../effort";
 import type { DevinCompat, FetchImpl, ModelCost, ModelSpec } from "../types";
@@ -106,8 +106,8 @@ function devinCostDenominatorTokens(denominator: string): number {
 /**
  * Per-million-token rates from the config's cost dimensions. `COST_FUZZY` marks
  * an estimated rate, not a different unit, so both kinds are read. `cacheWrite`
- * has no Cascade dimension — Devin bills cache writes at the input rate — and
- * stays 0.
+ * has no Cascade dimension and stays 0; the provider's `cache-write-rate` rules
+ * supply Devin's published rate.
  *
  * Composite configs (`fusion`) flatten their own rate card plus every
  * dispatched component's card into one `modelDimensions` list. A `Sidekick`
@@ -229,10 +229,7 @@ function collectDevinFamilyLane(lanes: Map<string, DevinFamilyLane>, config: Cli
 	if (thinking === false) effort = "off";
 
 	// Family label as an ZETA id: "GPT-5.6 Sol" -> "gpt-5-6-sol".
-	const baseId = label
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "");
+	const baseId = slugify(label);
 	if (!baseId) return;
 	const laneId = `${baseId}${oneMillionContext ? "-1m" : ""}${fast ? "-fast" : ""}`;
 	let lane = lanes.get(laneId);
@@ -478,7 +475,9 @@ function devinFusionLeadUid(uid: string, liveUids: ReadonlyMap<string, unknown>)
 /**
  * Point a Fusion pairing at its lead. zeta runs only the lead (the sidekick is
  * paired by the native client), so the limits and pricing a caller budgets
- * against are the lead's, not the composite card's.
+ * against are the lead's, not the composite card's. The composite uid names no
+ * model, so `buildModel` resolves the row under its `requestModelId` and the
+ * lead's catalog rules (cache-write rate, long-context tier) apply there.
  */
 function routeDevinFusionLead(spec: ModelSpec<"devin-agent">, lead: ModelSpec<"devin-agent">): void {
 	spec.requestModelId = lead.id;

package/src/model-cache.d.ts

@@ -20,6 +20,13 @@ export interface CacheEntry<TApi extends Api = Api> {
     models: Model<TApi>[];
     fresh: boolean;
     authoritative: boolean;
+    /**
+     * `authoritative` of the payload row itself, ignoring the
+     * `model_cache_refresh` side row. A failed refresh flips only the side row
+     * (freshness plus retry backoff), so this keeps answering "were `models`
+     * written by an authoritative discovery result?" after such a write.
+     */
+    payloadAuthoritative: boolean;
     updatedAt: number;
     /** Model ids whose live headers were intentionally omitted from disk. */
     headerOmittedModelIds: readonly string[];

package/src/model-cache.ts

@@ -145,6 +145,13 @@ export interface CacheEntry<TApi extends Api = Api> {
 	models: Model<TApi>[];
 	fresh: boolean;
 	authoritative: boolean;
+	/**
+	 * `authoritative` of the payload row itself, ignoring the
+	 * `model_cache_refresh` side row. A failed refresh flips only the side row
+	 * (freshness plus retry backoff), so this keeps answering "were `models`
+	 * written by an authoritative discovery result?" after such a write.
+	 */
+	payloadAuthoritative: boolean;
 	updatedAt: number;
 	/** Model ids whose live headers were intentionally omitted from disk. */
 	headerOmittedModelIds: readonly string[];
@@ -596,6 +603,7 @@ function parseCacheRow<TApi extends Api>(
 		models,
 		fresh,
 		authoritative,
+		payloadAuthoritative: row.authoritative === 1,
 		updatedAt,
 		headerOmittedModelIds,
 		unrestorableHeaderModelIds,

package/src/model-manager.d.ts

@@ -51,6 +51,12 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
      * a zero discovery price is treated as unknown and the bundled rate is kept.
      */
     dynamicCostAuthoritative?: boolean;
+    /**
+     * When true, a static row's display name wins over the cached or live row
+     * for the same id, so a model keeps one name before and after discovery.
+     * Set from the provider's `keep-bundled-names` catalog entry.
+     */
+    keepStaticNames?: boolean;
     /**
      * When true, a fresh cache never satisfies an online-eligible refresh: the
      * dynamic fetch always runs (an explicit `"offline"` strategy is still

package/src/model-manager.ts

@@ -73,6 +73,12 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 	 * a zero discovery price is treated as unknown and the bundled rate is kept.
 	 */
 	dynamicCostAuthoritative?: boolean;
+	/**
+	 * When true, a static row's display name wins over the cached or live row
+	 * for the same id, so a model keeps one name before and after discovery.
+	 * Set from the provider's `keep-bundled-names` catalog entry.
+	 */
+	keepStaticNames?: boolean;
 	/**
 	 * When true, a fresh cache never satisfies an online-eligible refresh: the
 	 * dynamic fetch always runs (an explicit `"offline"` strategy is still
@@ -254,11 +260,14 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	const staticModels = options.staticModels
 		? materializeStaticModels<TApi>(options.staticModels)
 		: (getBundledModels(options.providerId as GeneratedProvider) as Model<TApi>[]);
-	const additiveStaticModelIds =
+	const modelsDevAdditiveStaticModelIds =
 		options.modelsDev?.additiveOnly && staticModels.length > 0
 			? new Set(staticModels.map(model => model.id))
 			: undefined;
 	const cache = readModelCache<TApi>(cacheProviderId, ttlMs, now, dbPath);
+	const dynamicModelsAuthoritative = options.dynamicModelsAuthoritative ?? false;
+	const isAuthoritativeDynamicCache = dynamicModelsAuthoritative && (cache?.payloadAuthoritative ?? false);
+	const cacheAdditiveStaticModelIds = isAuthoritativeDynamicCache ? undefined : modelsDevAdditiveStaticModelIds;
 	const restoredCache = restoreCachedModelHeaders(
 		cache?.models ?? [],
 		staticModels,
@@ -270,11 +279,11 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	);
 	const usableCachedModels = restoredCache.models.filter(model => !restoredCache.unresolvedModelIds.has(model.id));
 	const cacheHasUnresolvedHeaders = restoredCache.unresolvedModelIds.size > 0;
-	const dynamicModelsAuthoritative = options.dynamicModelsAuthoritative ?? false;
 	const mergeAuthority: DynamicMergeAuthority = {
 		input: options.dynamicInputAuthoritative ?? false,
 		reasoning: options.dynamicReasoningAuthoritative ?? false,
 		cost: options.dynamicCostAuthoritative ?? false,
+		staticNames: options.keepStaticNames ? new Map(staticModels.map(model => [model.id, model.name])) : undefined,
 	};
 	const cacheDropIds = options.dropCachedModelIdsOnStaticMismatch;
 	const staticCatalogFingerprint = fingerprintStaticModels(staticModels, dynamicModelsAuthoritative);
@@ -315,10 +324,10 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		cacheFingerprintMatches &&
 		!cacheHasUnresolvedHeaders
 	) {
-		const cacheContribution = additiveStaticModelIds
-			? restoredCache.models.filter(model => !additiveStaticModelIds.has(model.id))
+		const cacheContribution = cacheAdditiveStaticModelIds
+			? restoredCache.models.filter(model => !cacheAdditiveStaticModelIds.has(model.id))
 			: restoredCache.models;
-		const cachedModels = additiveStaticModelIds
+		const cachedModels = cacheAdditiveStaticModelIds
 			? mergeCatalogMetrics(
 					mergeDynamicModels(staticModels, cacheContribution, mergeAuthority),
 					restoredCache.models,
@@ -338,8 +347,8 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		: [null, null];
 	const modelsDevFetchSucceeded = fetchedModelsDevModels !== null;
 	const normalizedModelsDevModels = fetchedModelsDevModels?.models ?? [];
-	const modelsDevModels = additiveStaticModelIds
-		? normalizedModelsDevModels.filter(model => !additiveStaticModelIds.has(model.id))
+	const modelsDevModels = modelsDevAdditiveStaticModelIds
+		? normalizedModelsDevModels.filter(model => !modelsDevAdditiveStaticModelIds.has(model.id))
 		: normalizedModelsDevModels;
 	const shouldUseFreshCacheAsAuthoritative =
 		strategy === "online-if-uncached" && hasUsableFreshCache && hasAuthoritativeCache;
@@ -359,10 +368,8 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 				cacheFingerprintMatches,
 				options.dropCachedModelIdsOnStaticMismatch,
 			);
-	// Additive shared-catalog rows may only introduce IDs. Apply that boundary
-	// to cache fallback too, including snapshots written by an older binary.
-	const cacheModels = additiveStaticModelIds
-		? preparedCacheModels.filter(model => !additiveStaticModelIds.has(model.id))
+	const cacheModels = cacheAdditiveStaticModelIds
+		? preparedCacheModels.filter(model => !cacheAdditiveStaticModelIds.has(model.id))
 		: preparedCacheModels;
 	const dynamicModels = fetchedDynamicModels?.models ?? [];
 	// A successful empty endpoint result stays authoritative for THIS cycle (so an
@@ -383,7 +390,9 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		fetchedModelsDevModels?.explicitKindModels,
 	);
 	const catalogMetricsSource = modelsDevFetchSucceeded ? normalizedModelsDevModels : preparedCacheModels;
-	const mergedWithCatalogMetrics = additiveStaticModelIds
+	const mergedWithCatalogMetrics = (
+		modelsDevFetchSucceeded ? modelsDevAdditiveStaticModelIds : cacheAdditiveStaticModelIds
+	)
 		? mergeCatalogMetrics(mergedWithModelsDev, catalogMetricsSource)
 		: mergedWithModelsDev;
 	const mergedModels = mergeDynamicModels(
@@ -393,7 +402,11 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		fetchedDynamicModels?.explicitKindModels,
 	);
 	const models = collapseBuiltVariants(
-		authoritativeDynamicFetchSucceeded ? retainModelIds(mergedModels, dynamicModels) : mergedModels,
+		authoritativeDynamicFetchSucceeded
+			? retainModelIds(mergedModels, dynamicModels)
+			: !dynamicFetchSucceeded && isAuthoritativeDynamicCache && usableCachedModels.length > 0
+				? retainModelIds(mergedModels, usableCachedModels)
+				: mergedModels,
 	);
 	const resolutionAuthoritative = !hasRemoteFetcher || remoteResolutionComplete || shouldUseFreshCacheAsAuthoritative;
 	const remoteUpdatedAt = anyRemoteFetchSucceeded ? now() : undefined;
@@ -438,15 +451,18 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 				cacheFingerprintMatches,
 				options.dropCachedModelIdsOnStaticMismatch,
 			);
-			const latestCacheModels = additiveStaticModelIds
-				? preparedLatestCacheModels.filter(model => !additiveStaticModelIds.has(model.id))
+			const latestCacheModels = cacheAdditiveStaticModelIds
+				? preparedLatestCacheModels.filter(model => !cacheAdditiveStaticModelIds.has(model.id))
 				: preparedLatestCacheModels;
+			const mergedFallbackModels = mergeDynamicModels(
+				mergeDynamicModels(staticModels, latestCacheModels, mergeAuthority),
+				modelsDevModels,
+				mergeAuthority,
+			);
 			const fallbackSnapshotModels = collapseBuiltVariants(
-				mergeDynamicModels(
-					mergeDynamicModels(staticModels, latestCacheModels, mergeAuthority),
-					modelsDevModels,
-					mergeAuthority,
-				),
+				isAuthoritativeDynamicCache && latestUsableCacheModels.length > 0
+					? retainModelIds(mergedFallbackModels, latestUsableCacheModels)
+					: mergedFallbackModels,
 			);
 			if (fallbackSnapshotModels.length > 0 || latestCache !== null || cache !== null) {
 				writeModelCache(
@@ -582,6 +598,8 @@ interface DynamicMergeAuthority {
 	readonly input: boolean;
 	readonly reasoning: boolean;
 	readonly cost: boolean;
+	/** Static display names by id that override dynamic rows (`keepStaticNames`). */
+	readonly staticNames: ReadonlyMap<string, string> | undefined;
 }
 
 function mergeDynamicModels<TApi extends Api>(
@@ -694,7 +712,9 @@ function mergeDynamicModel<TApi extends Api>(
 	return buildModel({
 		...existingModel,
 		...dynamicModel,
-		name: preferDiscoveryName(dynamicModel.name, existingModel.name, dynamicModel.id),
+		name:
+			authority.staticNames?.get(dynamicModel.id) ??
+			preferDiscoveryName(dynamicModel.name, existingModel.name, dynamicModel.id),
 		reasoning,
 		...(trustsOwnThinking ? { thinking: dynamicModel.thinking } : {}),
 		input: supportsImage ? ["text", "image"] : ["text"],

package/src/model-thinking.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Thinking metadata: runtime field-read helpers.
+ *
+ * Derivation lives in the compat engine (`compat/resolve`) and runs exactly
+ * once per model — from `buildModel` for dynamic specs and from the catalog
+ * generator for bundled entries. Everything here reads baked fields only: no
+ * id parsing, no host matching, no compat detection per request.
+ */
+import { Effort } from "./effort";
+import type { Api, Model, ModelSpec, ThinkingConfig } from "./types";
+/**
+ * Runtime helpers read baked metadata only, so they accept both pre-build
+ * specs and built models.
+ */
+type ApiModel<TApi extends Api = Api> = ModelSpec<TApi> | Model<TApi>;
+/**
+ * Returns the supported thinking efforts declared on the model metadata.
+ * Empty for non-reasoning models and for reasoning models without a
+ * controllable effort surface (`thinking: undefined`).
+ */
+export declare function getSupportedEfforts<TApi extends Api>(model: ApiModel<TApi>): readonly Effort[];
+/**
+ * Neutral view of a model whose thinking ladder is unverified: `reasoning: false`
+ * and no ladder. Re-entering policy resolution starts from it (the ladder is
+ * derived output, not authored input), and requests without an effort send it so
+ * no reasoning or disable fields reach an upstream that may reject them.
+ */
+export declare function withoutUnverifiedThinking<T extends {
+    reasoning: boolean;
+    thinking?: ThinkingConfig;
+}>(model: T): T;
+/**
+ * Clamps a requested thinking level against explicit model metadata.
+ *
+ * Non-reasoning models always resolve to `undefined`.
+ */
+export declare function clampThinkingLevelForModel<TApi extends Api>(model: ApiModel<TApi> | undefined, requested: Effort | undefined): Effort | undefined;
+export declare function requireSupportedEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): Effort;
+/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values.
+ * When a collapsed family routes `minimal` onto the same wire id as `low`
+ * (Antigravity Gemini 3.6/3.7 Flash), emit `LOW` — Cloud Code Assist rejects
+ * `MINIMAL` on those `-low` SKUs.
+ */
+export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(effort: Effort, model?: ApiModel<TApi>): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/**
+ * Maps a normalized thinking effort to Anthropic adaptive effort values via
+ * the model's baked `thinking.effortMap` (identity for unmapped efforts).
+ *
+ * The Anthropic adaptive wire vocabulary has no `minimal` tier (valid values:
+ * `low`, `medium`, `high`, `xhigh`, `max`); a model ladder that exposes
+ * `minimal` — custom `anthropic-messages` providers do, unlike the built-in
+ * Claude ladders — would otherwise serialize `output_config.effort: "minimal"`
+ * and 400 (`level "minimal" not supported`). Clamp it to the lowest real tier,
+ * mirroring {@link mapEffortToGoogleThinkingLevel}'s `minimal` handling.
+ */
+export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max" | "adaptive";
+/**
+ * Resolves the upstream wire model id for a request at the given effort
+ * (`undefined` = thinking off). Collapsed effort-tier variants route through
+ * `thinking.effortRouting`; everything else falls back to
+ * `requestModelId ?? id`.
+ */
+export declare function resolveWireModelId<TApi extends Api>(model: ApiModel<TApi>, effort: Effort | undefined): string;
+/**
+ * Lowest supported effort in canonical order — the clamp target for
+ * thinking-off requests on `thinking.requiresEffort` models.
+ */
+export declare function minimumSupportedEffort<TApi extends Api>(model: ApiModel<TApi>): Effort | undefined;
+/**
+ * Clamp target for effort-less requests on `thinking.requiresEffort` models:
+ * the effort whose wire route equals the model's default wire id
+ * (`requestModelId`), so a collapsed row clamps to the tier it already
+ * advertises as its default rather than the numerically lowest supported tier
+ * (e.g. Cursor Grok 4.5/4.6 default to `medium`, the only tier the Start plan
+ * serves). Falls back to {@link minimumSupportedEffort} when no route matches
+ * the default id — families whose default already is the minimum, or that
+ * expose no routing, are unaffected.
+ */
+export declare function defaultSupportedEffort<TApi extends Api>(model: ApiModel<TApi>): Effort | undefined;
+export {};

package/src/model-thinking.ts

@@ -7,7 +7,7 @@
  * id parsing, no host matching, no compat detection per request.
  */
 import { Effort, THINKING_EFFORTS } from "./effort";
-import type { Api, Model, ModelSpec } from "./types";
+import type { Api, Model, ModelSpec, ThinkingConfig } from "./types";
 
 /**
  * Runtime helpers read baked metadata only, so they accept both pre-build
@@ -27,6 +27,18 @@ export function getSupportedEfforts<TApi extends Api>(model: ApiModel<TApi>): re
 	return model.thinking?.efforts ?? [];
 }
 
+/**
+ * Neutral view of a model whose thinking ladder is unverified: `reasoning: false`
+ * and no ladder. Re-entering policy resolution starts from it (the ladder is
+ * derived output, not authored input), and requests without an effort send it so
+ * no reasoning or disable fields reach an upstream that may reject them.
+ */
+export function withoutUnverifiedThinking<T extends { reasoning: boolean; thinking?: ThinkingConfig }>(model: T): T {
+	if (!model.thinking?.unverified) return model;
+	const { thinking: _derived, ...rest } = model;
+	return { ...rest, reasoning: false } as T;
+}
+
 /**
  * Clamps a requested thinking level against explicit model metadata.
  *

package/src/model-tokenizer.ts

@@ -49,6 +49,11 @@ function glmTokenizer(identity: ModelIdentity): ModelTokenizer | undefined {
 	return identity.class === "glm" && revisionAtLeast(identity.revision, "5") ? "glm5" : undefined;
 }
 
+// GPT-5 and later bill text in o200k_base; older generations (cl100k GPT-4, unparsed gpt-4o) keep the estimate.
+function openAITokenizer(identity: ModelIdentity): ModelTokenizer | undefined {
+	return identity.class === "openai" && revisionAtLeast(identity.revision, "5") ? "o200k" : undefined;
+}
+
 /**
  * Resolve the exact locally embedded tokenizer for a canonical model id.
  *
@@ -68,7 +73,8 @@ export function resolveModelTokenizer(modelId: string, provider = ""): ModelToke
 		qwenTokenizer(identity) ??
 		deepSeekTokenizer(identity) ??
 		kimiTokenizer(identity) ??
-		glmTokenizer(identity);
+		glmTokenizer(identity) ??
+		openAITokenizer(identity);
 	if (modelTokenizerCache.size === MAX_TOKENIZER_CACHE_ENTRIES) modelTokenizerCache.clear();
 	modelTokenizerCache.set(cacheKey, tokenizer ?? null);
 	return tokenizer;