@linxiraos/pi-catalog 1.1.7 → 1.1.8

package/src/provider-models/openai-compat.ts

@@ -1,6 +1,18 @@
 import { USER_AGENT } from "@linxiraos/pi-utils";
 import * as logger from "@linxiraos/pi-utils/logger";
+import { toClinePassPublicModelId } from "../cline-pass-model-id";
+import {
+	apiRouteExactModelIds,
+	apiRouteFor,
+	isExcludedModel,
+	isLikelyOpenAIResponsesId,
+	modelLimitsFor,
+	pricingPeerFor,
+} from "../compat/behavior";
 import { xaiResponsesReasoningEffortMap } from "../compat/openai";
+import { resolveModelPolicy } from "../compat/resolve";
+import { compareRevision, parseRevision } from "../compat/revision";
+import { billingVariantPlain, classifyModel, discoveryVocabulary } from "../compat/taxonomy";
 import {
 	DEFAULT_OPENAI_COMPATIBLE_DISCOVERY_TIMEOUT_MS,
 	fetchOpenAICompatibleModels,
@@ -10,47 +22,46 @@ import {
 import { Effort, THINKING_EFFORTS } from "../effort";
 import { FIREWORKS_FAST_SUFFIX, toFireworksPublicModelId } from "../fireworks-model-id";
 import { getBundledModelReferenceIndex } from "../identity/bundled";
-import {
-	anthropicModelSupportsThinking,
-	isGlm52ReasoningEffortModelId,
-	isGlmVisionModelId,
-	isGrokReasoningEffortCapable,
-	isKimiK3ModelId,
-	isKimiModelId,
-	isMuseSparkModelId,
-	isQwen38PlusTemplateEffortModelId,
-	isReasoningGlmModelId,
-} from "../identity/family";
 import { resolveModelReference } from "../identity/reference";
 import type { ModelManagerOptions, ModelsDevFallback } from "../model-manager";
 import { type GeneratedProvider, getBundledModels } from "../models";
-import { OPENAI_GPT_56_CYBER_STANDARD_COST, OPENAI_GPT_56_SOL_STANDARD_COST } from "../openai-pricing";
-import type {
-	Api,
-	FetchImpl,
-	LongContextTokenCost,
-	Model,
-	ModelSpec,
-	OpenAICompat,
-	Provider,
-	ThinkingConfig,
-} from "../types";
+import type { Api, FetchImpl, Model, ModelSpec, OpenAICompat, Provider, ThinkingConfig, TokenCost } from "../types";
 import { discoveryFetch, isAnthropicOAuthToken, isRecord, toBoolean, toNumber, toPositiveNumber } from "../utils";
 import { ALIBABA_TOKEN_PLAN_BASE_URL, parseAlibabaTokenPlanCredential } from "../wire/alibaba-token-plan";
+import { CLINEPASS_API_BASE_URL, clinePassClientHeaders } from "../wire/cline-pass";
 import { CLOUDFLARE_AI_GATEWAY_COMPAT_BASE_URL } from "../wire/cloudflare-ai-gateway";
 import { coreWeaveProjectHeaders } from "../wire/coreweave";
 import {
 	COPILOT_API_HEADERS,
+	COPILOT_DISCOVERY_HEADERS,
 	discoverGitHubCopilotApiEndpoint,
 	getGitHubCopilotBaseUrl,
 	isPersonalGitHubCopilotBaseUrl,
+	mergeCopilotApiHeaders,
 	parseGitHubCopilotApiKey,
 } from "../wire/github-copilot";
 import { createBundledReferenceMap, createReferenceResolver, toModelSpec } from "./bundled-references";
 import { getDefaultModelDiscoveryBaseUrl, resolveModelCacheProviderId } from "./cache-provider-id";
+import { getClinePassModelMetadata } from "./cline-pass";
 import type { ModelManagerConfig } from "./descriptor-types";
 import { filterModelsDevCatalogRows } from "./models-dev-policies";
 
+function revisionAtLeast(revision: string | undefined, floor: string): boolean {
+	if (revision === undefined) return false;
+	const parsedRevision = parseRevision(revision);
+	const parsedFloor = parseRevision(floor);
+	return (
+		parsedRevision !== undefined && parsedFloor !== undefined && compareRevision(parsedRevision, parsedFloor) >= 0
+	);
+}
+
+function isGlmReasoningIdentity(provider: string, modelId: string, floor: string): boolean {
+	const identity = classifyModel(provider, modelId, { lenient: true });
+	if (identity.class !== "glm" || !revisionAtLeast(identity.revision, floor)) return false;
+	if (identity.family === "flash") return revisionAtLeast(identity.revision, "5.3");
+	return identity.family === undefined || identity.family === "air" || identity.family === "turbo";
+}
+
 const MODELS_DEV_URL = "https://catalog.stencil.so/models.json.zstd";
 
 /** Little-endian magic number opening every zstd frame (RFC 8878). */
@@ -83,6 +94,7 @@ export interface ModelsDevModel {
 	name?: string;
 	tool_call?: boolean;
 	reasoning?: boolean;
+	reasoning_options?: Array<{ type?: string; values?: string[]; min?: number; max?: number }>;
 	limit?: {
 		context?: number;
 		output?: number;
@@ -430,7 +442,6 @@ async function fetchOllamaNativeModels(
 				provider: "ollama",
 				baseUrl,
 				reasoning: metadata.reasoning ?? false,
-				thinking: metadata.thinking,
 				input: metadata.input ?? ["text"],
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow: metadata.contextWindow,
@@ -458,7 +469,6 @@ interface OllamaResolvedMetadata {
 	maxTokens: number;
 	capabilities?: string[];
 	reasoning?: boolean;
-	thinking?: ThinkingConfig;
 	input?: ("text" | "image")[];
 }
 
@@ -467,7 +477,6 @@ interface OllamaShowMetadata {
 	maxTokens?: number;
 	capabilities?: string[];
 	reasoning?: boolean;
-	thinking?: ThinkingConfig;
 	input?: ("text" | "image")[];
 }
 
@@ -492,13 +501,6 @@ function getOllamaCapabilities(value: unknown): string[] | undefined {
 	return value.filter((item): item is string => typeof item === "string");
 }
 
-function getOllamaThinkingConfig(capabilities: string[] | undefined): ThinkingConfig | undefined {
-	if (!capabilities?.includes("thinking")) {
-		return undefined;
-	}
-	return { mode: "effort", efforts: [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High] };
-}
-
 /**
  * Query Ollama's `/api/show` endpoint for a single model and pull native
  * context and capability metadata from the response. Returns `undefined` when
@@ -526,7 +528,6 @@ async function fetchOllamaShowMetadata(
 			maxTokens: contextWindow ? OLLAMA_DEFAULT_MAX_TOKENS : undefined,
 			capabilities,
 			reasoning: capabilities ? capabilities.includes("thinking") : undefined,
-			thinking: getOllamaThinkingConfig(capabilities),
 			input: capabilities
 				? capabilities.includes("vision")
 					? (["text", "image"] as Array<"text" | "image">)
@@ -571,17 +572,6 @@ function createOllamaMetadataResolver(
 	};
 }
 
-const OPENAI_NON_RESPONSES_PREFIXES = [
-	"text-embedding",
-	"whisper-",
-	"tts-",
-	"omni-moderation",
-	"omni-transcribe",
-	"omni-speech",
-	"gpt-image-",
-	"gpt-realtime",
-] as const;
-
 function isLikelyOpenAIResponsesModelId(
 	id: string,
 	references?: ReadonlyMap<string, ModelSpec<"openai-responses">>,
@@ -593,35 +583,9 @@ function isLikelyOpenAIResponsesModelId(
 	if (references?.has(trimmed)) {
 		return true;
 	}
-	const normalized = trimmed.toLowerCase();
-	if (OPENAI_NON_RESPONSES_PREFIXES.some(prefix => normalized.startsWith(prefix))) {
-		return false;
-	}
-	if (normalized.includes("embedding")) {
-		return false;
-	}
-	return (
-		normalized.startsWith("gpt-") ||
-		normalized.startsWith("o1") ||
-		normalized.startsWith("o3") ||
-		normalized.startsWith("o4") ||
-		normalized.startsWith("chatgpt")
-	);
+	return isLikelyOpenAIResponsesId(trimmed);
 }
 
-const NANO_GPT_NON_TEXT_MODEL_TOKENS = [
-	"embedding",
-	"image",
-	"vision",
-	"audio",
-	"speech",
-	"transcribe",
-	"moderation",
-	"realtime",
-	"whisper",
-	"tts",
-] as const;
-
 /** Regex matching NanoGPT `:thinking` suffixed model IDs (with or without a level). */
 const NANO_GPT_THINKING_SUFFIX_RE = /:thinking(:[^:]+)?$/;
 
@@ -633,7 +597,7 @@ function isLikelyNanoGptTextModelId(id: string): boolean {
 	if (NANO_GPT_THINKING_SUFFIX_RE.test(normalized)) {
 		return false;
 	}
-	return !NANO_GPT_NON_TEXT_MODEL_TOKENS.some(token => normalized.includes(token));
+	return !isExcludedModel("nanogpt", normalized);
 }
 
 type SimpleProviderDiscoveryHeaders = Record<string, string> | (() => Record<string, string> | undefined);
@@ -929,30 +893,23 @@ export function umansModelManagerOptions(config?: UmansModelManagerConfig): Mode
 // ---------------------------------------------------------------------------
 
 const OPENAI_API_BASE_URL = "https://api.openai.com/v1";
-/** GPT-5.6 rates applied when a first-party request exceeds 272K input tokens. */
-export const OPENAI_GPT_56_LONG_CONTEXT_COSTS = {
-	luna: {
-		inputThreshold: 272_000,
-		input: 0.4,
-		output: 1.8,
-		cacheRead: 0.04,
-		cacheWrite: 0.5,
-	},
-	sol: {
-		inputThreshold: 272_000,
-		input: 10,
-		output: 45,
-		cacheRead: 1,
-		cacheWrite: 12.5,
-	},
-	terra: {
-		inputThreshold: 272_000,
-		input: 4,
-		output: 18,
-		cacheRead: 0.4,
-		cacheWrite: 5,
-	},
-} as const satisfies Readonly<Record<"luna" | "sol" | "terra", LongContextTokenCost>>;
+// Curated seed pricing for approval-gated aliases stencil.so does not list
+// yet; upstream catalog rows outrank these once discovery serves them.
+/** Standard GPT-5.6 Sol rates used by the Daybreak Blue aliases. */
+const OPENAI_GPT_56_SOL_STANDARD_COST = {
+	input: 5,
+	output: 30,
+	cacheRead: 0.5,
+	cacheWrite: 6.25,
+} as const satisfies TokenCost;
+
+/** Standard GPT-5.6 Cyber rates used by the Daybreak Red aliases. */
+const OPENAI_GPT_56_CYBER_STANDARD_COST = {
+	input: 12.5,
+	output: 75,
+	cacheRead: 1.25,
+	cacheWrite: 15.625,
+} as const satisfies TokenCost;
 
 export interface OpenAIModelManagerConfig {
 	apiKey?: string;
@@ -986,10 +943,9 @@ export const OPENAI_DAYBREAK_CURATED_FALLBACK_MODELS: readonly ModelSpec<"openai
 		baseUrl: OPENAI_API_BASE_URL,
 		reasoning: true,
 		input: ["text", "image"],
-		cost: {
-			...OPENAI_GPT_56_SOL_STANDARD_COST,
-			longContext: OPENAI_GPT_56_LONG_CONTEXT_COSTS.sol,
-		},
+		// The >272K long-context tier is rule-owned (`providers/openai.kdl`
+		// long-context-cost) and baked at build time.
+		cost: OPENAI_GPT_56_SOL_STANDARD_COST,
 		contextWindow: 1_050_000,
 		maxTokens: 128_000,
 	},
@@ -1019,32 +975,21 @@ export const OPENAI_DAYBREAK_CURATED_FALLBACK_MODELS: readonly ModelSpec<"openai
 	},
 ];
 
-/** First-party gpt-5.6 SKUs that accept `reasoning: { mode: "pro" }` on the Responses APIs. */
-const OPENAI_PRO_REASONING_BASE_IDS: Record<string, true> = {
-	"gpt-5.6-luna": true,
-	"gpt-5.6-sol": true,
-	"gpt-5.6-terra": true,
-};
-/**
- * Providers whose generated pro aliases this pass owns. `openai-codex` stays in
- * the sweep so stale aliases from earlier snapshots are dropped on regen, but
- * projection is `openai`-only — subscription (Codex) auth does not offer pro
- * reasoning.
- */
-const OPENAI_PRO_REASONING_SWEEP_PROVIDERS: Record<string, true> = { openai: true, "openai-codex": true };
-
 /**
  * A row this generator pass owns: one of the derived `gpt-5.6-*-pro` alias ids
  * on a swept provider that carries the generated `reasoningMode` marker.
  * A real upstream model occupying the same id has no `reasoningMode` and is
  * never touched.
+ * The reviewed base-id and sweep tables live in the compiled discovery
+ * vocabulary (`pro-reasoning-alias` / `pro-reasoning-sweep`).
  */
 function isGeneratedOpenAIProReasoningAlias(model: ModelSpec<Api>): boolean {
+	const { proReasoningAliases, proReasoningSweep } = discoveryVocabulary();
 	return (
-		OPENAI_PRO_REASONING_SWEEP_PROVIDERS[model.provider] === true &&
+		proReasoningSweep.includes(model.provider) &&
 		model.reasoningMode !== undefined &&
 		model.id.endsWith("-pro") &&
-		OPENAI_PRO_REASONING_BASE_IDS[model.id.slice(0, -"-pro".length)] === true
+		Object.values(proReasoningAliases).some(bases => bases.includes(model.id.slice(0, -"-pro".length)))
 	);
 }
 
@@ -1064,8 +1009,8 @@ export function projectOpenAIProReasoningAliases(models: readonly ModelSpec<Api>
 	const ids = new Set(kept.map(model => `${model.provider}/${model.id}`));
 	const out = [...kept];
 	for (const model of kept) {
-		if (model.provider !== "openai") continue;
-		if (!OPENAI_PRO_REASONING_BASE_IDS[model.id]) continue;
+		const bases = discoveryVocabulary().proReasoningAliases[model.provider];
+		if (!bases?.includes(model.id)) continue;
 		const aliasId = `${model.id}-pro`;
 		const aliasKey = `${model.provider}/${aliasId}`;
 		if (ids.has(aliasKey)) continue;
@@ -1197,18 +1142,6 @@ export function groqModelManagerOptions(config?: GroqModelManagerConfig): ModelM
 // 3. Cerebras
 // ---------------------------------------------------------------------------
 
-const CEREBRAS_IMAGE_INPUT_MODEL_IDS = new Set(["gemma-4-31b"]);
-
-function applyCerebrasDiscoveryOverrides(model: ModelSpec<"openai-completions">): ModelSpec<"openai-completions"> {
-	if (!CEREBRAS_IMAGE_INPUT_MODEL_IDS.has(model.id)) {
-		return model;
-	}
-	return {
-		...model,
-		input: ["text", "image"],
-	};
-}
-
 export interface CerebrasModelManagerConfig {
 	apiKey?: string;
 	baseUrl?: string;
@@ -1224,8 +1157,7 @@ export function cerebrasModelManagerOptions(
 		defaultBaseUrl: "https://api.cerebras.ai/v1",
 		config,
 		requireApiKey: true,
-		mapModel: (entry, defaults, reference) =>
-			applyCerebrasDiscoveryOverrides(mapWithBundledReference(entry, defaults, reference)),
+		mapModel: (entry, defaults, reference) => mapWithBundledReference(entry, defaults, reference),
 	});
 }
 
@@ -1534,64 +1466,31 @@ export interface XaiModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
-// xAI bills the whole request at 2x the base rates once the prompt reaches
-// 200K tokens, for every current Grok SKU that carries the two-tier card
-// (grok-4.3/4.5/4.6, every grok-4.20 variant, grok-build-0.1). Source:
-// docs.x.ai/developers/models. Computing the tier from the base keeps it in
-// lockstep with stencil.so price updates instead of a hand-maintained table.
-const XAI_LONG_CONTEXT_THRESHOLD = 200_000;
-const XAI_LONG_CONTEXT_MULTIPLIER = 2;
-
 // SuperGrok surfaces a few models under IDs that differ from their public
 // `xai` catalog equivalent, so the exact-ID price fallback misses them. Map
 // the OAuth ID to the paid ID it mirrors.
-const XAI_OAUTH_PRICE_ALIASES: Record<string, string> = {
-	"grok-4.20-multi-agent-0309": "grok-4.20-multi-agent-beta-latest",
-};
-
-function xaiHasLongContextTier(modelId: string): boolean {
-	return (
-		modelId === "grok-4.3" ||
-		modelId === "grok-4.5" ||
-		modelId === "grok-4.6" ||
-		modelId === "grok-build-0.1" ||
-		modelId.startsWith("grok-4.20")
-	);
-}
-
+// The alias map lives in the `pricing-peer` behavior rule.
 function hasTokenPrice(cost: ModelSpec["cost"]): boolean {
 	return cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
 }
 
-function withXaiLongContextTier(model: ModelSpec): ModelSpec {
-	if (!xaiHasLongContextTier(model.id) || !hasTokenPrice(model.cost)) return model;
-	const longContext: LongContextTokenCost = {
-		inputThreshold: XAI_LONG_CONTEXT_THRESHOLD,
-		inputThresholdInclusive: true,
-		input: model.cost.input * XAI_LONG_CONTEXT_MULTIPLIER,
-		output: model.cost.output * XAI_LONG_CONTEXT_MULTIPLIER,
-		cacheRead: model.cost.cacheRead * XAI_LONG_CONTEXT_MULTIPLIER,
-		cacheWrite: model.cost.cacheWrite * XAI_LONG_CONTEXT_MULTIPLIER,
-	};
-	return { ...model, cost: { ...model.cost, longContext } };
-}
-
 /**
- * Applies xAI's long-context rate card and mirrors exact public-model prices
- * onto matching SuperGrok catalog rows.
+ * Mirrors exact public-model prices onto matching SuperGrok catalog rows.
+ * The >200K long-context tier itself is rule-owned (`classes/xai.kdl`
+ * `long-context-cost` multiplier axis) and derives at build time.
  */
 export function applyXaiCatalogPricing(models: readonly ModelSpec[]): ModelSpec[] {
-	const pricedModels = models.map(model => (model.provider === "xai" ? withXaiLongContextTier(model) : model));
 	const publicCosts = new Map(
-		pricedModels
+		models
 			.filter(model => model.provider === "xai" && hasTokenPrice(model.cost))
 			.map(model => [model.id, model.cost]),
 	);
 
-	return pricedModels.map(model => {
+	return models.map(model => {
 		if (model.provider !== "xai-oauth" || hasTokenPrice(model.cost)) return model;
-		const alias = XAI_OAUTH_PRICE_ALIASES[model.id];
-		const publicCost = publicCosts.get(model.id) ?? (alias ? publicCosts.get(alias) : undefined);
+		const peer = pricingPeerFor("xai-oauth", model.id);
+		const publicCost =
+			publicCosts.get(model.id) ?? (peer && peer.peerId !== model.id ? publicCosts.get(peer.peerId) : undefined);
 		return publicCost ? { ...model, cost: { ...publicCost } } : model;
 	});
 }
@@ -1630,9 +1529,8 @@ interface XAICuratedModel {
 	/**
 	 * Whether xAI accepts the `reasoning.effort` wire param for this model.
 	 * Default true. When false: the picker hides the effort dial (via
-	 * getSupportedEfforts in model-thinking.ts) AND the wire omits the param —
-	 * both derive from `isGrokReasoningEffortCapable` (identity/family.ts), the
-	 * single allowlist shared by this curated layer and the compat builder.
+	 * getSupportedEfforts in model-thinking.ts) AND the wire omits the param.
+	 * Both read the compat engine's resolved reasoning-effort axes.
 	 */
 	supportsReasoningEffort?: boolean;
 	/**
@@ -1702,15 +1600,13 @@ export const XAI_OAUTH_CURATED_MODELS: readonly XAICuratedModel[] = [
 // xAI /v1/models returns chat, image, voice, and STT entries. Tool surfaces
 // route through dedicated tools (generate_image, tts) with their own model
 // strings; the chat picker MUST exclude these prefixes or selecting them 400s.
-const XAI_NON_CHAT_PREFIXES = ["grok-imagine-", "grok-stt-", "grok-voice-"] as const;
-
 function withXaiOAuthCompatDefaults(model: ModelSpec<"openai-responses">): ModelSpec<"openai-responses"> {
 	const compat = {
-		...(model.compat ?? {}),
+		...model.compat,
 		includeEncryptedReasoning: model.compat?.includeEncryptedReasoning ?? true,
 		filterReasoningHistory: model.compat?.filterReasoningHistory ?? false,
 		supportsImageDetailOriginal: model.compat?.supportsImageDetailOriginal ?? false,
-		omitReasoningEffort: model.compat?.omitReasoningEffort ?? !isGrokReasoningEffortCapable(model.id),
+		omitReasoningEffort: model.compat?.omitReasoningEffort ?? resolveModelPolicy(model).compat.omitReasoningEffort,
 	};
 	return { ...model, compat };
 }
@@ -1724,8 +1620,8 @@ function withXaiOAuthCompatDefaults(model: ModelSpec<"openai-responses">): Model
  * Bake first-party xAI Responses effort-dial metadata onto a catalog spec.
  *
  * models.dev marks many Grok SKUs as reasoners and the thinking rebake would
- * otherwise emit a default `minimal/low/medium/high` dial. api.x.ai only
- * accepts `reasoning.effort` for {@link isGrokReasoningEffortCapable} ids —
+ * otherwise emit a default `minimal/low/medium/high` dial. api.x.ai
+ * accepts `reasoning.effort` only for ids selected by the compat rule —
  * off-allowlist reasoners (`grok-code-fast-1`, `grok-build-0.1`,
  * `grok-4.20-0309-reasoning`, …) 400 if the param is sent. SuperGrok
  * (`xai-oauth`) already curates this via {@link mergeCuratedIntoModel}; paid
@@ -1735,9 +1631,10 @@ function withXaiOAuthCompatDefaults(model: ModelSpec<"openai-responses">): Model
  * Explicit `compat.supportsReasoningEffort` / `omitReasoningEffort` win.
  */
 export function applyXaiResponsesThinkingPolicy(model: ModelSpec<"openai-responses">): ModelSpec<"openai-responses"> {
-	const effortCapable = model.compat?.supportsReasoningEffort ?? isGrokReasoningEffortCapable(model.id);
+	const effortCapable =
+		model.compat?.supportsReasoningEffort ?? resolveModelPolicy(model).compat.supportsReasoningEffort;
 	const compat = {
-		...(model.compat ?? {}),
+		...model.compat,
 		supportsReasoningEffort: effortCapable,
 		omitReasoningEffort: model.compat?.omitReasoningEffort ?? !effortCapable,
 	};
@@ -1767,14 +1664,16 @@ export function applyXaiResponsesThinkingPolicy(model: ModelSpec<"openai-respons
 // param, so a map on those specs is dead weight.
 // The effort-dial pair (`supportsReasoningEffort`/`omitReasoningEffort`) is
 // authoritative: a stale flag on `base` (previous snapshot or dynamic fetch)
-// must not outlive an allowlist change in identity/family.ts.
+// must not outlive a compat-rule change.
 function mergeCuratedIntoModel(
 	base: ModelSpec<"openai-responses">,
 	curated: XAICuratedModel,
 ): ModelSpec<"openai-responses"> {
-	const effortCapable = curated.supportsReasoningEffort ?? isGrokReasoningEffortCapable(curated.id);
+	const effortCapable =
+		curated.supportsReasoningEffort ??
+		resolveModelPolicy({ ...base, id: curated.id, provider: "xai-oauth" }).compat.supportsReasoningEffort;
 	const compat = {
-		...(base.compat ?? {}),
+		...base.compat,
 		includeEncryptedReasoning: base.compat?.includeEncryptedReasoning ?? true,
 		filterReasoningHistory: false,
 		supportsImageDetailOriginal: base.compat?.supportsImageDetailOriginal ?? false,
@@ -1820,7 +1719,7 @@ function mergeCuratedIntoModel(
  * in original order.
  */
 function applyXAIOAuthCuration(dynamic: readonly ModelSpec<"openai-responses">[]): ModelSpec<"openai-responses">[] {
-	const filtered = dynamic.filter(e => !XAI_NON_CHAT_PREFIXES.some(p => e.id.startsWith(p)));
+	const filtered = dynamic.filter(e => !isExcludedModel("xai-oauth", e.id));
 
 	const byId = new Map<string, ModelSpec<"openai-responses">>(filtered.map(e => [e.id, e]));
 	for (const curated of XAI_OAUTH_CURATED_MODELS) {
@@ -1935,18 +1834,10 @@ export function xaiOAuthModelManagerOptions(
 // 6.4 AIML API
 // ---------------------------------------------------------------------------
 
-const AIML_API_NON_CHAT_MODEL_ID_PATTERN =
-	/(?:^|[/:._-])(?:audio|embed|embedding|embeddings|i2i|i2v|image|speech|t2i|t2v|tts|video)(?:$|[/:._-])/i;
-
-const AIML_API_NON_CHAT_MODEL_ID_SUBSTRINGS = ["dall-e", "dalle", "flux", "imagen", "sora", "veo", "whisper"] as const;
-
 export function isLikelyAimlApiChatModelId(id: string): boolean {
 	const normalized = id.trim().toLowerCase();
 	if (!normalized) return false;
-	return (
-		!AIML_API_NON_CHAT_MODEL_ID_PATTERN.test(normalized) &&
-		!AIML_API_NON_CHAT_MODEL_ID_SUBSTRINGS.some(token => normalized.includes(token))
-	);
+	return !isExcludedModel("aimlapi", normalized);
 }
 
 export interface AimlApiModelManagerConfig {
@@ -2002,35 +1893,12 @@ export interface SiliconFlowModelManagerConfig {
  * completions — and carries no per-model type field, so non-chat entries are
  * dropped by id to keep the picker usable.
  */
-const SILICONFLOW_NON_CHAT_MODEL_TOKENS = [
-	"embedding",
-	"reranker",
-	"bge-",
-	"bce-",
-	"stable-diffusion",
-	"image",
-	"flux",
-	"kolors",
-	"sensevoice",
-	"cosyvoice",
-	"fish-speech",
-	"indextts",
-	"sovits",
-	"whisper",
-	"hunyuanvideo",
-	"wan2",
-	"ltx-video",
-	"speech",
-	"moderator",
-	"tts",
-] as const;
-
 export function isLikelySiliconFlowChatModelId(id: string): boolean {
 	const normalized = id.trim().toLowerCase();
 	if (!normalized) {
 		return false;
 	}
-	return !SILICONFLOW_NON_CHAT_MODEL_TOKENS.some(token => normalized.includes(token));
+	return !isExcludedModel("siliconflow", normalized);
 }
 
 /**
@@ -2176,10 +2044,14 @@ export function zhipuCodingPlanModelManagerOptions(
 						_context: OpenAICompatibleModelMapperContext<"openai-completions">,
 					): ModelSpec<"openai-completions"> => {
 						const id = defaults.id;
+						const identity = classifyModel("zhipu-coding-plan", id, { lenient: true });
 						return {
 							...defaults,
-							reasoning: isReasoningGlmModelId(id) || id.includes("thinking"),
-							input: isGlmVisionModelId(id) ? (["text", "image"] as const) : ["text"],
+							reasoning:
+								isGlmReasoningIdentity("zhipu-coding-plan", id, "4.5") || identity.thinkingVariant === true,
+							// Vision-capable families are rule-owned (`providers/zhipu-coding-plan.kdl`
+							// input-modalities) and corrected at build time.
+							input: ["text"],
 							compat: {
 								thinkingFormat: "zai",
 								reasoningContentField: "reasoning_content",
@@ -2231,10 +2103,9 @@ export const FIREWORKS_KIMI_K27_CODE_MAX_TOKENS = 65_536;
  * Fireworks' reported `max_completion_tokens` (65,536) instead.
  */
 export function isFireworksKimiK2ModelId(modelId: string): boolean {
-	const trimmed = modelId.toLowerCase();
-	if (/kimi[-._]?k2(?:[._-]?|p)7[-._]?code/.test(trimmed)) return false;
-	if (trimmed.startsWith("kimi-k2")) return true;
-	return /\/kimi-k2(?:p\d+)?(?:[._-]|$)/.test(trimmed);
+	const identity = classifyModel("fireworks", modelId, { lenient: true });
+	if (identity.class !== "kimi" || identity.family === "k2.7-code") return false;
+	return identity.family?.startsWith("k2") === true;
 }
 
 /**
@@ -2255,7 +2126,8 @@ export function clampFireworksKimiMaxTokens(modelId: string, candidate: number |
 export const KIMI_K27_CODE_RECOMMENDED_MAX_TOKENS = 32_768;
 
 export function isKimiK27CodeModelId(modelId: string): boolean {
-	return /(?:^|\/)kimi[-._]?k2(?:[._-]?|p)7[-._]?code(?:[-._]?highspeed)?$/i.test(modelId);
+	const identity = classifyModel("fireworks", modelId, { lenient: true });
+	return identity.class === "kimi" && identity.family === "k2.7-code";
 }
 
 export function clampKimiK27CodeMaxTokens(modelId: string, candidate: number): number;
@@ -2319,7 +2191,7 @@ export function stripFireworksDeepSeekThinkingToggle(
 	model: ModelSpec<"openai-completions">,
 	publicModelId: string,
 ): ModelSpec<"openai-completions"> {
-	if (!publicModelId.startsWith("deepseek-v4")) return model;
+	if (!isDeepseekV4Generation("fireworks", publicModelId)) return model;
 	const compat = model.compat;
 	if (!compat?.extraBody || !("thinking" in compat.extraBody)) return model;
 
@@ -2582,6 +2454,304 @@ export function firepassModelManagerOptions(
 	};
 }
 
+const CLINEPASS_MODELS_URL = `${CLINEPASS_API_BASE_URL}/ai/cline/recommended-models`;
+const CLINEPASS_FALLBACK_CONTEXT_WINDOW = 128_000;
+const CLINEPASS_FALLBACK_MAX_TOKENS = 8_192;
+
+function buildClinePassFallbackModel(id: string): ModelSpec<"openai-completions"> {
+	return {
+		id,
+		name: id,
+		api: "openai-completions",
+		provider: "cline-pass",
+		baseUrl: CLINEPASS_API_BASE_URL,
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: CLINEPASS_FALLBACK_CONTEXT_WINDOW,
+		maxTokens: CLINEPASS_FALLBACK_MAX_TOKENS,
+		compat: { supportsReasoningEffort: false },
+	};
+}
+
+/**
+ * Live reference catalog mirroring Cline's own client enrichment: the official
+ * CLI fills roster metadata from OpenRouter's public `/models` catalog (their
+ * gateway routes through it), keyed by full id and by slug. Consulted only for
+ * ids the bundled reference has no real upstream entry for: the bundle stays
+ * authoritative for known ids, and unknown ids ride fresh live data instead of
+ * the conservative constants until the next regen.
+ */
+interface ClinePassLiveCatalogEntry {
+	name?: string;
+	contextWindow?: number;
+	maxTokens?: number;
+	cost?: ModelSpec<"openai-completions">["cost"];
+	reasoning?: boolean;
+	input?: ("text" | "image")[];
+}
+
+interface ClinePassLiveCatalog {
+	byId: ReadonlyMap<string, ClinePassLiveCatalogEntry>;
+	bySlug: ReadonlyMap<string, ClinePassLiveCatalogEntry>;
+}
+
+const CLINE_PASS_LIVE_CATALOG_URL = "https://openrouter.ai/api/v1/models";
+
+/** Enrichment tier, never authoritative: any failure degrades to the bundled path. */
+async function fetchClinePassLiveCatalog(fetchImpl: FetchImpl): Promise<ClinePassLiveCatalog | undefined> {
+	try {
+		const response = await withCatalogDiscoveryTimeout(5_000, signal =>
+			fetchImpl(CLINE_PASS_LIVE_CATALOG_URL, { signal }),
+		);
+		if (!response.ok) return undefined;
+		const payload: unknown = await response.json();
+		if (!isRecord(payload) || !Array.isArray(payload.data)) return undefined;
+		const byId = new Map<string, ClinePassLiveCatalogEntry>();
+		const bySlug = new Map<string, ClinePassLiveCatalogEntry>();
+		for (const raw of payload.data) {
+			if (!isRecord(raw) || typeof raw.id !== "string" || !raw.id) continue;
+			const pricing = isRecord(raw.pricing) ? raw.pricing : undefined;
+			const topProvider = isRecord(raw.top_provider) ? raw.top_provider : undefined;
+			const params = Array.isArray(raw.supported_parameters) ? raw.supported_parameters : undefined;
+			const modality = String(isRecord(raw.architecture) ? (raw.architecture.modality ?? "") : "");
+			const contextWindow = toPositiveNumber(raw.context_length, 0);
+			const maxTokens = toPositiveNumber(topProvider?.max_completion_tokens, 0);
+			const entry: ClinePassLiveCatalogEntry = {
+				...(typeof raw.name === "string" && raw.name ? { name: raw.name.replace(/^[^:]+:\s*/, "") } : {}),
+				...(contextWindow > 0 ? { contextWindow } : {}),
+				...(maxTokens > 0 ? { maxTokens } : {}),
+				...(pricing
+					? {
+							cost: {
+								input: parseFloat(String(pricing.prompt ?? "0")) * 1_000_000,
+								output: parseFloat(String(pricing.completion ?? "0")) * 1_000_000,
+								cacheRead: parseFloat(String(pricing.input_cache_read ?? "0")) * 1_000_000,
+								cacheWrite: parseFloat(String(pricing.input_cache_write ?? "0")) * 1_000_000,
+							},
+						}
+					: {}),
+				...(params ? { reasoning: params.includes("reasoning") } : {}),
+				...(modality
+					? { input: modality.includes("image") ? (["text", "image"] as const) : (["text"] as const) }
+					: {}),
+			};
+			byId.set(raw.id, entry);
+			// Cline's `buildModelsNameMap` algorithm: roster ids are lab-less slugs
+			// ("glm-5.2"), so the catalog is also keyed by its last id segment.
+			const slug = raw.id.split("/").at(-1);
+			if (slug) bySlug.set(slug, entry);
+		}
+		return byId.size > 0 ? { byId, bySlug } : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Zero legs mean "unpriced upstream", not "free" — pass models bill quota regardless. */
+function hasClinePassBillableCost(cost: ModelSpec<"openai-completions">["cost"] | undefined): boolean {
+	return cost !== undefined && (cost.input > 0 || cost.output > 0);
+}
+
+function buildCuratedClinePassModel(
+	id: string,
+	tier: "subscription" | "free",
+): ModelSpec<"openai-completions"> | undefined {
+	const metadata = getClinePassModelMetadata(id);
+	if (!metadata || metadata.tier !== tier) return undefined;
+	return {
+		...buildClinePassFallbackModel(id),
+		name: metadata.name,
+		contextWindow: metadata.contextWindow,
+		maxTokens: metadata.maxTokens,
+		input: metadata.input,
+		cost: metadata.cost,
+		reasoning: metadata.reasoning,
+		thinking: metadata.thinking,
+		compat: {
+			...(metadata.thinking === undefined ? { supportsReasoningEffort: false } : {}),
+			...(tier === "free" ? { wireModelIdMode: "raw" as const } : {}),
+		},
+	};
+}
+
+/**
+ * Subscription models bill against plan quota, not per token — but the catalog still
+ * carries the upstream list price so cost display reads as API-equivalent spend. Same
+ * policy as the codex/antigravity generator fixups and the zai PAYG descriptor swap
+ * (issue #5598: an all-$0 roster surfaces every model as "free" in the picker, which
+ * was treated as a bug there). The price comes from the bundled upstream reference,
+ * so it works offline and survives roster refreshes (`preferDiscoveryCost` never lets
+ * a zero overwrite it). Ids with no upstream reference keep the honest zero until
+ * models.dev prices them.
+ */
+function buildClinePassSubscriptionModel(
+	id: string,
+	references: ReadonlyMap<string, ModelSpec<"openai-completions">>,
+	liveCatalog?: ClinePassLiveCatalog,
+): ModelSpec<"openai-completions"> {
+	const curated = buildCuratedClinePassModel(id, "subscription");
+	if (curated) return curated;
+	const base = references.get(id) ?? buildClinePassFallbackModel(id);
+	const reference = resolveModelReference(id, getBundledModelReferenceIndex());
+	// A reference pointing back at the ClinePass bundle means the last regen
+	// knew nothing about the id and encoded fallback constants — treat as none.
+	const upstream = reference && reference.provider !== "cline-pass" ? reference : undefined;
+	// Same degeneracy on the bundle side: a bundled entry whose limits are the
+	// fallback pair was written by a regen that had no upstream data for the id.
+	const baseLimitsAreFallback =
+		base.contextWindow === CLINEPASS_FALLBACK_CONTEXT_WINDOW && base.maxTokens === CLINEPASS_FALLBACK_MAX_TOKENS;
+	if (upstream) {
+		// Known to the bundle with real limits: overlay the list price only.
+		// Otherwise full enrichment, like the free-tier path.
+		return references.has(id) && !baseLimitsAreFallback
+			? { ...base, cost: upstream.cost }
+			: {
+					...base,
+					name: references.has(id) ? base.name : upstream.name,
+					reasoning: upstream.reasoning,
+					input: upstream.input,
+					cost: upstream.cost,
+					contextWindow: upstream.contextWindow,
+					maxTokens: upstream.maxTokens,
+					...(upstream.reasoning ? {} : { thinking: undefined }),
+				};
+	}
+	const live = liveCatalog?.bySlug.get(id);
+	if (!live) return base;
+	return {
+		...base,
+		...(live.name ? { name: live.name } : {}),
+		...(live.contextWindow ? { contextWindow: live.contextWindow } : {}),
+		...(live.maxTokens ? { maxTokens: live.maxTokens } : {}),
+		...(hasClinePassBillableCost(live.cost) ? { cost: live.cost } : {}),
+		...(live.reasoning !== undefined ? { reasoning: live.reasoning } : {}),
+		...(live.input ? { input: live.input } : {}),
+		...(live.reasoning === false ? { thinking: undefined } : {}),
+	};
+}
+
+/**
+ * Free-tier entries arrive as full OpenRouter-style ids (`deepseek/deepseek-v4-flash`,
+ * `poolside/laguna-s-2.1:free`) and ride usage billing at $0 outside the subscription
+ * quota — their cost is genuinely zero, unlike the subscription roster's list-price
+ * display. Limits and modalities resolve through the bundled upstream reference (its
+ * candidate expansion treats provider prefixes and trailing `:free`-style markers as
+ * identity-preserving), so known models self-enrich offline. Compat and thinking are
+ * deliberately NOT inherited: those describe the reference's native host, while the
+ * Cline gateway dialect is resolved per provider/family. The raw wire tag is
+ * bucket-derived — the gateway already namespaces these ids, so the cline-pass prefix
+ * transform must never apply to them.
+ */
+function buildClinePassFreeModel(id: string, liveCatalog?: ClinePassLiveCatalog): ModelSpec<"openai-completions"> {
+	const curated = buildCuratedClinePassModel(id, "free");
+	if (curated) return curated;
+	const reference = resolveModelReference(id, getBundledModelReferenceIndex());
+	const upstream = reference && reference.provider !== "cline-pass" ? reference : undefined;
+	// Free ids are OpenRouter-native, so the live catalog matches by full id
+	// before falling back to the slug — the official client's own lookup order.
+	const live = liveCatalog?.byId.get(id) ?? liveCatalog?.bySlug.get(id.split("/").at(-1) ?? id);
+	// References can carry their own free markers (e.g. OpenRouter-style
+	// "Laguna S 2.1 (free)"); strip before applying our single tier suffix.
+	const baseName = (upstream?.name ?? live?.name ?? id.split("/").at(-1) ?? id)
+		.replace(/\s*\(free\)\s*$/i, "")
+		.replace(/:free$/i, "")
+		.trim();
+	const fallback = buildClinePassFallbackModel(id);
+	const reasoning = upstream?.reasoning ?? live?.reasoning ?? fallback.reasoning;
+	return {
+		...fallback,
+		name: `${baseName || id} (free)`,
+		reasoning,
+		input: upstream?.input ?? live?.input ?? fallback.input,
+		contextWindow: upstream?.contextWindow ?? live?.contextWindow ?? fallback.contextWindow,
+		maxTokens: upstream?.maxTokens ?? live?.maxTokens ?? fallback.maxTokens,
+		// A non-reasoning reference must not carry the Cline effort ladder.
+		...(reasoning ? {} : { thinking: undefined }),
+		compat: { supportsReasoningEffort: false, wireModelIdMode: "raw" },
+	};
+}
+
+async function fetchClinePassModels(
+	fetchImpl: FetchImpl,
+	references: ReadonlyMap<string, ModelSpec<"openai-completions">>,
+): Promise<ModelSpec<"openai-completions">[]> {
+	// The roster is authoritative for ids; the live reference catalog is a pure
+	// enrichment tier fetched alongside and tolerated away (offline → bundle).
+	const [response, liveCatalog] = await Promise.all([
+		withCatalogDiscoveryTimeout(5_000, signal =>
+			fetchImpl(CLINEPASS_MODELS_URL, { signal, headers: clinePassClientHeaders() }),
+		),
+		fetchClinePassLiveCatalog(fetchImpl),
+	]);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch ClinePass models: HTTP ${response.status}`);
+	}
+	const payload: unknown = await response.json();
+	if (!isRecord(payload) || !Array.isArray(payload.clinePass)) {
+		throw new Error("ClinePass model catalog response is missing clinePass");
+	}
+
+	const models = new Map<string, ModelSpec<"openai-completions">>();
+	for (const entry of payload.clinePass) {
+		if (!isRecord(entry) || typeof entry.id !== "string") {
+			continue;
+		}
+		const wireId = entry.id.trim();
+		if (!wireId.startsWith("cline-pass/")) {
+			continue;
+		}
+		const id = toClinePassPublicModelId(wireId).trim();
+		if (!id) {
+			continue;
+		}
+		models.set(id, buildClinePassSubscriptionModel(id, references, liveCatalog));
+	}
+	if (models.size === 0) {
+		throw new Error("ClinePass model catalog contains no valid model IDs");
+	}
+
+	// Free tier rides the same key and gateway at $0 outside the subscription
+	// quota. Optional overlay: entries validate individually, a cline-pass/-shaped
+	// entry belongs to the pass bucket, pass ids win any collision, and pass-first
+	// insertion order keeps the registry's first-available fallback on a
+	// subscription model.
+	const freeEntries = Array.isArray(payload.free) ? payload.free : [];
+	for (const entry of freeEntries) {
+		if (!isRecord(entry) || typeof entry.id !== "string") {
+			continue;
+		}
+		const id = entry.id.trim();
+		if (!id || id.startsWith("cline-pass/") || models.has(id)) {
+			continue;
+		}
+		models.set(id, buildClinePassFreeModel(id, liveCatalog));
+	}
+	return [...models.values()];
+}
+
+/**
+ * Cline's OpenAI-compatible `/models` route is absent, but its public
+ * recommended-models endpoint is the authoritative ClinePass roster: the
+ * `clinePass` bucket lists subscription models and the optional `free` bucket
+ * adds $0 usage-billing models selectable with the same key. Metadata resolves
+ * in three tiers: the current Cline-published metadata snapshot first, bundled
+ * upstream references and OpenRouter enrichment for future ids second, then
+ * conservative constants. Newly added ids remain usable before the next regen;
+ * known ids retain exact Cline limits, plan pricing, and reasoning controls.
+ */
+export function clinePassModelManagerOptions(config?: ModelManagerConfig): ModelManagerOptions<"openai-completions"> {
+	const references = new Map(
+		(getBundledModels("cline-pass") as Model<"openai-completions">[]).map(model => [model.id, toModelSpec(model)]),
+	);
+	const fetchImpl = discoveryFetch(config?.fetch);
+	return {
+		providerId: "cline-pass",
+		dynamicModelsAuthoritative: true,
+		fetchDynamicModels: () => fetchClinePassModels(fetchImpl, references),
+	};
+}
+
 // ---------------------------------------------------------------------------
 // 7.7 Wafer Serverless
 // ---------------------------------------------------------------------------
@@ -2629,6 +2799,8 @@ export function resolveWaferServerlessThinkingFormat(
 	modelId: string,
 	upstreamProvider: unknown,
 ): WaferThinkingFormat | undefined {
+	// residue: parses Wafer's upstream-provider metadata FIELD (vendor
+	// spellings), not a model id; the id fallback below is classify-driven.
 	const upstream = typeof upstreamProvider === "string" ? upstreamProvider.trim().toLowerCase() : "";
 	if (upstream) {
 		if (
@@ -2650,7 +2822,8 @@ export function resolveWaferServerlessThinkingFormat(
 	// Older Wafer snapshots (and some endpoint responses) do not carry the
 	// upstream-provider hint. Only GLM/Kimi need a sparse override: qwen and
 	// deepseek IDs are resolved safely by `buildOpenAICompat` from the model id.
-	return isReasoningGlmModelId(modelId.toLowerCase()) || isKimiModelId(modelId) ? "zai" : undefined;
+	const identity = classifyModel("wafer-serverless", modelId, { lenient: true });
+	return isGlmReasoningIdentity("wafer-serverless", modelId, "4.5") || identity.class === "kimi" ? "zai" : undefined;
 }
 
 function mapWaferModel(
@@ -2782,56 +2955,12 @@ function openCodeBaseUrlForApi(api: Api, basePath: string): string {
 // /v1/models discovery mapper in openCodeModelManagerOptions — the gateways
 // list ids that models.dev omits entirely (muse-spark-1.2[-contributor] on
 // opencode-go, #8957), so discovery cannot rely on bundled references alone.
-//
-// OpenCode Zen: models.dev declares minimax-m3-free (and forward-compat
-// minimax-m3) with `provider.npm = "@ai-sdk/anthropic"`, but the Zen gateway
-// only serves them at https://opencode.ai/zen/v1/chat/completions (verified
-// against the live /v1/models response — minimax-m3-free is listed there, and
-// the gateway has no /v1/messages route for it). Without this override the
-// resolver POSTs anthropic-shaped requests to /v1/messages and the UI surfaces
-// raw <invoke>/<|minimax|>/<tool_call> markup (#1617).
-const OPENCODE_ZEN_API_ID_OVERRIDES: Readonly<Record<string, Api>> = {
-	"minimax-m3": "openai-completions",
-	"minimax-m3-free": "openai-completions",
-};
-// OpenCode Go: models.dev declares minimax-m2.7 / qwen3.5-plus / qwen3.6-plus
-// (and now also minimax-m3) with `provider.npm = "@ai-sdk/anthropic"`, but
-// the OpenCode Go gateway only serves them at
-// `https://opencode.ai/zen/go/v1/chat/completions` (verified against
-// https://opencode.ai/zen/go/v1/models and the upstream endpoint table at
-// https://opencode.ai/docs/go/#endpoints — minimax-m2.5 works the same way
-// and lacks an `npm` field on models.dev so it already falls through to the
-// openai-completions default). Without this override the resolver would POST
-// anthropic-style requests to /v1/messages and the gateway would return its
-// `Page Not Found` HTML (issue #887 for the qwen/m2.7 entries; minimax-m3
-// and minimax-m3-free added under #1617 for the same root cause).
-//
-// deepseek-v4-flash is the inverse case: it falls through to
-// openai-completions by default, but the Go gateway's
-// /zen/go/v1/chat/completions route does not work for this model while
-// /zen/go/v1/responses does (user-verified against the live gateway,
-// 2026-08-08; Flash only — deepseek-v4-pro serves fine on chat completions).
-//
-// muse-spark-1.2 / muse-spark-1.2-contributor are the same inverse case, but
-// worse: models.dev does not list them under opencode-go at all, so they have
-// no bundled reference and only exist via live gateway discovery. Without the
-// discovery-side pin they default to openai-completions even though the
-// gateway only serves them at /zen/go/v1/responses (@ai-sdk/openai per
-// https://opencode.ai/docs/go/#endpoints). The completions parser then closes
-// the stream with no finish_reason on every tool-call turn (#8957).
-const OPENCODE_GO_API_ID_OVERRIDES: Readonly<Record<string, Api>> = {
-	"deepseek-v4-flash": "openai-responses",
-	"muse-spark-1.2": "openai-responses",
-	"muse-spark-1.2-contributor": "openai-responses",
-	"minimax-m2.7": "openai-completions",
-	"minimax-m3": "openai-completions",
-	"minimax-m3-free": "openai-completions",
-	"qwen3.5-plus": "openai-completions",
-	"qwen3.6-plus": "openai-completions",
-};
+// The per-id gateway-verified route pins live in the `api-routes` behavior
+// rules (`runtime/behavior.kdl`; #887, #1617, #8957).
 // Runtime-discovered rows cached before model-identity corrections retain
 // stale capability metadata until the authoritative catalog TTL expires.
 const OPENCODE_CACHE_MIGRATION_MODEL_IDS = ["glm-5.3-flash"] as const;
+const OPENCODE_ZEN_CACHE_MIGRATION_MODEL_IDS = ["gemini-3.7-flash"] as const;
 
 // Billing-variant suffixes the OpenCode gateways append to a base model id
 // without changing its transport (`deepseek-v4-flash-free`,
@@ -2862,7 +2991,13 @@ function openCodeModelManagerOptions(
 	const siblingReferences = createBundledReferenceMap<Api>(
 		providerId === "opencode-go" ? "opencode-zen" : "opencode-go",
 	);
-	const apiOverrides = providerId === "opencode-go" ? OPENCODE_GO_API_ID_OVERRIDES : OPENCODE_ZEN_API_ID_OVERRIDES;
+	const apiOverrides = (id: string): Api | undefined => {
+		// Route pins live in the `api-routes` behavior rules.
+		const route = apiRouteFor(providerId, id)?.api;
+		return route === "openai-completions" || route === "openai-responses" || route === "anthropic-messages"
+			? route
+			: undefined;
+	};
 	// Routes a discovered id with no same-provider metadata. models.dev lags
 	// the gateway (muse-spark-1.2[-contributor] shipped gateway-first, #8957),
 	// so borrow the openai-responses route from the sibling gateway or the
@@ -2881,8 +3016,8 @@ function openCodeModelManagerOptions(
 	const resolveApi = (id: string, defaultApi: Api): Api => {
 		const base = openCodeBaseModelId(id);
 		return (
-			apiOverrides[id] ??
-			(base ? apiOverrides[base] : undefined) ??
+			apiOverrides(id) ??
+			(base ? apiOverrides(base) : undefined) ??
 			references.get(id)?.api ??
 			fallbackApi(id, base) ??
 			defaultApi
@@ -2894,8 +3029,12 @@ function openCodeModelManagerOptions(
 		dynamicModelsAuthoritative: true,
 		// Per-id route pins and capability migrations are cache identity:
 		// without this, rows cached before a correction keep the stale route or
-		// thinking surface until TTL expiry (#8957, #9960).
-		dropCachedModelIdsOnStaticMismatch: [...Object.keys(apiOverrides), ...OPENCODE_CACHE_MIGRATION_MODEL_IDS],
+		// thinking surface until TTL expiry (#8957, #9960, #10543).
+		dropCachedModelIdsOnStaticMismatch: [
+			...apiRouteExactModelIds(providerId),
+			...OPENCODE_CACHE_MIGRATION_MODEL_IDS,
+			...(providerId === "opencode-zen" ? OPENCODE_ZEN_CACHE_MIGRATION_MODEL_IDS : []),
+		],
 		modelsDev: {
 			fetch: () => fetchRevalidatedWellKnownModelsWithTimeout(config?.fetch),
 			map: payload => {
@@ -2922,12 +3061,13 @@ function openCodeModelManagerOptions(
 						// stencil fallback; the fallback never selects a transport.
 						const api = resolveApi(defaults.id, defaults.api);
 						const baseUrl = openCodeBaseUrlForApi(api, basePath);
-						if (isMuseSparkModelId(defaults.id)) {
-							// Gateway lists these as bare ids with no capability
-							// metadata and no local bundled row, so the generic
-							// defaults would hide the effort dial
-							// (`reasoning: false`). Keep the pinned/fallback route
-							// and restore the documented thinking surface.
+						const lineage = museSparkLineageSpec(defaults.id);
+						if (lineage) {
+							// Gateway lists Muse Spark as bare ids with no capability
+							// metadata and often no local bundled row, so the generic
+							// defaults would hide the effort dial (`reasoning: false`).
+							// Keep the pinned/fallback route and restore the lineage's
+							// thinking surface.
 							return {
 								...(reference ?? defaults),
 								id: defaults.id,
@@ -2936,10 +3076,16 @@ function openCodeModelManagerOptions(
 								provider: providerId,
 								baseUrl,
 								reasoning: true,
-								input: reference?.input ?? ["text", "image"],
-								thinking: reference?.thinking ?? META_MUSE_SPARK_THINKING,
-								contextWindow: toPositiveNumber(entry.context_length, reference?.contextWindow ?? 1_048_576),
-								maxTokens: toPositiveNumber(entry.max_completion_tokens, reference?.maxTokens ?? 131_072),
+								input: reference?.input ?? lineage.input,
+								thinking: reference?.thinking ?? lineage.thinking,
+								contextWindow: toPositiveNumber(
+									entry.context_length,
+									reference?.contextWindow ?? lineage.contextWindow,
+								),
+								maxTokens: toPositiveNumber(
+									entry.max_completion_tokens,
+									reference?.maxTokens ?? lineage.maxTokens,
+								),
 							};
 						}
 						if (!reference) {
@@ -3015,7 +3161,9 @@ export function ollamaModelManagerOptions(config?: OllamaModelManagerConfig): Mo
 						model.contextWindow = metadata.contextWindow;
 						if (metadata.reasoning !== undefined) {
 							model.reasoning = metadata.reasoning;
-							model.thinking = metadata.thinking;
+							// The effort ladder is rule-owned (`providers/ollama.kdl`);
+							// derived at build time from the reasoning flag.
+							model.thinking = undefined;
 						}
 						if (metadata.input) {
 							model.input = metadata.input;
@@ -3117,7 +3265,7 @@ export function openrouterModelManagerOptions(
 								? topProvider.max_completion_tokens
 								: baseModel.maxTokens,
 						...(!supportsToolChoice && {
-							compat: { ...(baseModel.compat ?? {}), supportsToolChoice: false },
+							compat: { ...baseModel.compat, supportsToolChoice: false },
 						}),
 					};
 				},
@@ -3158,7 +3306,7 @@ function isZenMuxAnthropicModel(entry: OpenAICompatibleModelRecord, modelId: str
 	if (typeof entry.owned_by === "string" && entry.owned_by.toLowerCase() === "anthropic") {
 		return true;
 	}
-	return modelId.toLowerCase().startsWith("anthropic/");
+	return classifyModel("zenmux", modelId, { lenient: true }).class === "anthropic";
 }
 
 function getZenMuxPricingValue(pricings: Record<string, unknown> | undefined, key: string): number {
@@ -3352,6 +3500,20 @@ export const ALIBABA_TOKEN_PLAN_STATIC_MODELS: readonly ModelSpec<"openai-comple
 		},
 		compat: ALIBABA_TOKEN_PLAN_QWEN_EFFORT_COMPAT,
 	},
+	{
+		id: "qwen3.8-flash",
+		name: "Qwen3.8 Flash",
+		api: "openai-completions",
+		provider: "alibaba-token-plan",
+		baseUrl: ALIBABA_TOKEN_PLAN_BASE_URL,
+		reasoning: true,
+		input: ["text", "image"],
+		cost: ALIBABA_TOKEN_PLAN_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 131_072,
+		thinking: ALIBABA_TOKEN_PLAN_REASONING,
+		compat: ALIBABA_TOKEN_PLAN_COMPAT,
+	},
 	{
 		id: "qwen3.7-max",
 		name: "Qwen3.7 Max",
@@ -3430,82 +3592,9 @@ export const ALIBABA_TOKEN_PLAN_STATIC_MODELS: readonly ModelSpec<"openai-comple
 	},
 ];
 
-/**
- * Metadata for Alibaba Token Plan models that are dynamically discovered but not
- * in the static catalog. Context window and max tokens are sourced from
- * official model documentation and provider catalogs. Unknown future models
- * remain available with null limits instead of assigning unsafe guessed limits.
- */
-export interface AlibabaTokenPlanModelLimits {
-	contextWindow: number;
-	maxTokens: number;
-}
-
-export const ALIBABA_TOKEN_PLAN_DISCOVERED_MODEL_LIMITS: Readonly<Record<string, AlibabaTokenPlanModelLimits>> = {
-	"qwen3.6-plus": {
-		contextWindow: 1_000_000,
-		maxTokens: 65_536,
-	},
-	"qwen3.8-max": {
-		contextWindow: 1_000_000,
-		maxTokens: 131_072,
-	},
-	"deepseek-v4-flash": {
-		contextWindow: 1_000_000,
-		maxTokens: 384_000,
-	},
-	"deepseek-v4-flash-0731": {
-		contextWindow: 1_000_000,
-		maxTokens: 384_000,
-	},
-	"deepseek-v4-pro-0813": {
-		contextWindow: 1_000_000,
-		maxTokens: 384_000,
-	},
-	"deepseek-v3.2": {
-		contextWindow: 131_072,
-		maxTokens: 65_536,
-	},
-	"glm-5.1": {
-		contextWindow: 202_752,
-		maxTokens: 128_000,
-	},
-	"glm-5": {
-		contextWindow: 202_752,
-		maxTokens: 16_384,
-	},
-	"kimi-k2.7-code": {
-		contextWindow: 262_144,
-		maxTokens: 262_144,
-	},
-	"kimi-k2.6": {
-		contextWindow: 262_144,
-		maxTokens: 262_144,
-	},
-	"kimi-k2.5": {
-		contextWindow: 262_144,
-		maxTokens: 98_304,
-	},
-	"minimax-m2.5": {
-		contextWindow: 196_608,
-		maxTokens: 32_768,
-	},
-};
-
-const ALIBABA_TOKEN_PLAN_NON_CHAT_MODEL_PREFIXES = [
-	"fun-asr",
-	"happyhorse-",
-	"qwen-audio-",
-	"qwen-image-",
-	"text-embedding-",
-	"wan2.7-",
-] as const;
-
 function isAlibabaTokenPlanChatModelId(id: string): boolean {
 	const normalized = id.trim().toLowerCase();
-	return (
-		normalized.length > 0 && !ALIBABA_TOKEN_PLAN_NON_CHAT_MODEL_PREFIXES.some(prefix => normalized.startsWith(prefix))
-	);
+	return normalized.length > 0 && !isExcludedModel("alibaba-token-plan", normalized);
 }
 
 export interface AlibabaTokenPlanModelManagerConfig {
@@ -3547,16 +3636,18 @@ export function alibabaTokenPlanModelManagerOptions(
 							};
 						}
 						const normalizedId = defaults.id.trim().toLowerCase();
-						const limits = ALIBABA_TOKEN_PLAN_DISCOVERED_MODEL_LIMITS[normalizedId];
+						// Discovery carries no limit fields; the `model-limits` behavior
+						// rules pin values from official model documentation.
+						const limits = modelLimitsFor("alibaba-token-plan", normalizedId);
 						const enriched = limits
 							? {
 									...defaults,
-									contextWindow: limits.contextWindow,
-									maxTokens: limits.maxTokens,
+									contextWindow: limits.context ?? defaults.contextWindow,
+									maxTokens: limits.maxTokens ?? defaults.maxTokens,
 								}
 							: defaults;
 
-						if (normalizedId.startsWith("deepseek-v4")) {
+						if (isDeepseekV4Generation("alibaba-token-plan", normalizedId)) {
 							return {
 								...enriched,
 								reasoning: true,
@@ -3685,7 +3776,12 @@ function kimiSupportsReasoning(entry: OpenAICompatibleModelRecord, modelId: stri
 		case "no":
 			return false;
 		default:
-			return entry.supports_reasoning === true || modelId.includes("thinking");
+			// Without a reasoning bit, the classified thinking-variant fact names
+			// the reasoning sibling.
+			return (
+				entry.supports_reasoning === true ||
+				classifyModel("kimi-code", modelId, { lenient: true }).thinkingVariant === true
+			);
 	}
 }
 
@@ -3701,15 +3797,13 @@ function mapKimiApiFormat(protocol: unknown): OpenAICompat["kimiApiFormat"] {
  * per-family caps instead of a blanket constant. Values match models.dev's
  * `kimi-for-coding` and `moonshotai` kimi-k3 entries. See #6711.
  */
-export const KIMI_CODE_K3_MAX_TOKENS = 131_072;
-export const KIMI_CODE_FOR_CODING_MAX_TOKENS = 32_768;
-
 /** Fallback output cap for Kimi Code families without a documented ceiling (legacy K2 discovery rows). */
 export const KIMI_CODE_DEFAULT_MAX_TOKENS = 32_000;
 
 /**
- * Resolve a Kimi Code model's output ceiling from its id: `k3` / `k3-256k` ->
- * 131072, `kimi-for-coding[-highspeed]` -> 32768, everything else -> `fallback`.
+ * Resolve a Kimi Code model's output ceiling; the per-family caps are
+ * rule-owned (`runtime/behavior.kdl` model-limits), everything else ->
+ * `fallback`.
  */
 export function kimiCodeMaxTokens(modelId: string, fallback?: number): number;
 export function kimiCodeMaxTokens(modelId: string, fallback: number | null): number | null;
@@ -3717,10 +3811,7 @@ export function kimiCodeMaxTokens(
 	modelId: string,
 	fallback: number | null = KIMI_CODE_DEFAULT_MAX_TOKENS,
 ): number | null {
-	const id = modelId.toLowerCase();
-	if (id.startsWith("k3")) return KIMI_CODE_K3_MAX_TOKENS;
-	if (id.startsWith("kimi-for-coding")) return KIMI_CODE_FOR_CODING_MAX_TOKENS;
-	return fallback;
+	return modelLimitsFor("kimi-code", modelId.trim().toLowerCase())?.maxTokens ?? fallback;
 }
 
 export function kimiCodeModelManagerOptions(
@@ -3753,7 +3844,9 @@ export function kimiCodeModelManagerOptions(
 							...defaults,
 							name: typeof entry.display_name === "string" ? entry.display_name : defaults.name,
 							reasoning,
-							input: entry.supports_image_in === true || id.includes("k2.5") ? ["text", "image"] : ["text"],
+							// K2.5's misreported vision support is rule-owned
+							// (`providers/kimi-code.kdl` input-modalities).
+							input: entry.supports_image_in === true ? ["text", "image"] : ["text"],
 							contextWindow: typeof entry.context_length === "number" ? entry.context_length : 262144,
 							maxTokens: kimiCodeMaxTokens(id),
 							thinking,
@@ -3838,7 +3931,7 @@ export async function fetchLmStudioNativeModelMetadata(
 		try {
 			const response = await fetchImpl(`${nativeBaseUrl}/api/v0/models`, {
 				method: "GET",
-				headers: { Accept: "application/json", ...(options?.headers ?? {}) },
+				headers: { Accept: "application/json", ...options?.headers },
 				signal,
 			});
 			if (!response.ok) {
@@ -4189,9 +4282,10 @@ export function basetenModelManagerOptions(
 			// model. Only models with a verified Baseten reasoning policy are enabled
 			// here; an unknown model may use a different reasoning wire shape or effort
 			// vocabulary, which OMP must not guess.
+			const identity = classifyModel("baseten", defaults.id, { lenient: true });
 			const isSupportedBasetenReasoningModel =
-				isKimiK3ModelId(defaults.id) ||
-				isGlm52ReasoningEffortModelId(defaults.id) ||
+				(identity.class === "kimi" && identity.family === "k3") ||
+				isGlmReasoningIdentity("baseten", defaults.id, "5.2") ||
 				defaults.id === "openai/gpt-oss-120b" ||
 				defaults.id === "deepseek-ai/DeepSeek-V4-Pro";
 			const reasoning =
@@ -4266,55 +4360,25 @@ export function coreWeaveModelManagerOptions(
 
 const META_MODEL_API_BASE_URL = "https://api.meta.ai/v1";
 const META_MUSE_SPARK_COST = { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 } as const;
+// Contributor SKUs (`-contributor`): same model, discounted because prompts
+// are used for training.
+const META_MUSE_SPARK_CONTRIBUTOR_COST = { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 } as const;
 const META_MUSE_SPARK_THINKING: ThinkingConfig = {
 	mode: "effort",
 	efforts: [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High, Effort.XHigh],
 };
 
-export const META_MUSE_STATIC_MODELS: readonly ModelSpec<"openai-responses">[] = [
-	{
-		id: "muse-spark-1.1",
-		name: "Muse Spark 1.1",
-		api: "openai-responses",
-		provider: "meta",
-		baseUrl: META_MODEL_API_BASE_URL,
-		reasoning: true,
-		input: ["text", "image"],
-		cost: META_MUSE_SPARK_COST,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		thinking: META_MUSE_SPARK_THINKING,
-		compat: {
-			supportsReasoningEffort: true,
-			includeEncryptedReasoning: true,
-		},
-	},
-	{
-		id: "muse-spark-1.2",
-		name: "Muse Spark 1.2",
-		api: "openai-responses",
-		provider: "meta",
-		baseUrl: META_MODEL_API_BASE_URL,
-		reasoning: true,
-		input: ["text", "image"],
-		cost: META_MUSE_SPARK_COST,
-		contextWindow: 1_048_576,
-		maxTokens: 131_072,
-		thinking: META_MUSE_SPARK_THINKING,
-		compat: {
-			supportsReasoningEffort: true,
-			includeEncryptedReasoning: true,
-		},
-	},
-	{
-		id: "muse-spark-1.2-contributor",
-		name: "Muse Spark 1.2 Contributor (Data Used for Training)",
+function museSparkSpec(revision: string, tier: "standard" | "contributor"): ModelSpec<"openai-responses"> {
+	const contributor = tier === "contributor";
+	return {
+		id: contributor ? `muse-spark-${revision}-contributor` : `muse-spark-${revision}`,
+		name: contributor ? `Muse Spark ${revision} (C)` : `Muse Spark ${revision}`,
 		api: "openai-responses",
 		provider: "meta",
 		baseUrl: META_MODEL_API_BASE_URL,
 		reasoning: true,
 		input: ["text", "image"],
-		cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 },
+		cost: contributor ? META_MUSE_SPARK_CONTRIBUTOR_COST : META_MUSE_SPARK_COST,
 		contextWindow: 1_048_576,
 		maxTokens: 131_072,
 		thinking: META_MUSE_SPARK_THINKING,
@@ -4322,9 +4386,42 @@ export const META_MUSE_STATIC_MODELS: readonly ModelSpec<"openai-responses">[] =
 			supportsReasoningEffort: true,
 			includeEncryptedReasoning: true,
 		},
-	},
+	};
+}
+
+/**
+ * Muse Spark revisions served by Meta's first-party Responses API. Meta's
+ * `/v1/models` lists bare ids with no capability metadata, so every revision
+ * must be seeded here or discovery yields a text-only, non-reasoning model
+ * with an unknown context window.
+ */
+export const META_MUSE_STATIC_MODELS: readonly ModelSpec<"openai-responses">[] = [
+	museSparkSpec("1.1", "standard"),
+	museSparkSpec("1.2", "standard"),
+	museSparkSpec("1.2", "contributor"),
+	museSparkSpec("1.3", "standard"),
+	museSparkSpec("1.3", "contributor"),
 ];
 
+const META_MUSE_MODEL_BY_ID: Partial<Record<string, ModelSpec<"openai-responses">>> = Object.fromEntries(
+	META_MUSE_STATIC_MODELS.map(model => [model.id, model]),
+);
+
+/**
+ * Lineage reference for a Muse Spark revision Meta ships before the seed
+ * lists it. Every revision so far has kept the 1M window, the effort ladder,
+ * and per-tier pricing, so a new one inherits them (with its own display
+ * name) instead of surfacing as a text-only model with no limits. Only ids
+ * that classify into the `muse-spark` family with a revision qualify.
+ */
+function museSparkLineageSpec(id: string): ModelSpec<"openai-responses"> | undefined {
+	const identity = classifyModel("meta", id, { lenient: true });
+	if (identity.family !== "muse-spark" || identity.revision === undefined) return undefined;
+	const [major, minor, patch] = parseRevision(identity.revision) ?? [0, 0, 0];
+	const revision = patch === 0 ? `${major}.${minor}` : identity.revision;
+	return museSparkSpec(revision, billingVariantPlain(id) === undefined ? "standard" : "contributor");
+}
+
 // ---------------------------------------------------------------------------
 // 15.76 Amazon Bedrock Mantle
 // ---------------------------------------------------------------------------
@@ -4459,7 +4556,15 @@ export function metaModelManagerOptions(config?: MetaModelManagerConfig): ModelM
 			defaultBaseUrl: META_MODEL_API_BASE_URL,
 			config,
 			requireApiKey: true,
-			mapModel: mapWithBundledReference,
+			filterModel: (_entry, model) => !isExcludedModel("meta", model.id),
+			// The seed backs ids the bundle has not been regenerated with yet;
+			// the lineage spec backs revisions the seed has not been taught.
+			mapModel: (entry, defaults, reference) =>
+				mapWithBundledReference(
+					entry,
+					defaults,
+					reference ?? META_MUSE_MODEL_BY_ID[defaults.id] ?? museSparkLineageSpec(defaults.id),
+				),
 		}),
 		staticModels: META_MUSE_STATIC_MODELS,
 	};
@@ -4488,10 +4593,6 @@ export interface MoonshotModelManagerConfig {
  * through OpenAI-style `reasoning_effort` (see `buildOpenAICompat`).
  */
 const MOONSHOT_KIMI_K3_COST = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 0 } as const;
-const MOONSHOT_KIMI_K3_CONTEXT_WINDOW = 1_048_576;
-const MOONSHOT_KIMI_K3_MAX_TOKENS = 131_072;
-const MOONSHOT_KIMI_K3_THINKING: ThinkingConfig = { mode: "effort", efforts: [Effort.Max], requiresEffort: true };
-
 export function moonshotModelManagerOptions(
 	config?: MoonshotModelManagerConfig,
 ): ModelManagerOptions<"openai-completions"> {
@@ -4509,39 +4610,29 @@ export function moonshotModelManagerOptions(
 			const id = model.id.toLowerCase();
 			// Kimi K3 is discovered but has no bundled/models.dev reference, so the
 			// generic dynamic defaults would report it "Free" with no capabilities
-			// (#5756). Stamp the official pricing/limits when the endpoint doesn't
-			// carry them, and mark it reasoning + vision. K3 always reasons via
-			// `reasoning_effort: "max"` and does NOT use the K2.x `thinking` block,
-			// so its thinking config is the single-tier `max` scale — the wire path
-			// routes it through `reasoning_effort` (see `buildOpenAICompat`).
-			if (!reference && isKimiK3ModelId(id)) {
+			// (#5756). Modalities, limits, and the reasoning surface are rule-owned
+			// (`providers/moonshot.kdl`, `runtime/behavior.kdl` model-limits) and
+			// baked at build time; the mapper seeds only the official pricing when
+			// the endpoint reports zero cost, plus the structured reasoning fact.
+			const identity = classifyModel("moonshot", id, { lenient: true });
+			if (!reference && identity.class === "kimi" && identity.family === "k3") {
 				const isZeroCost = model.cost.input === 0 && model.cost.output === 0 && model.cost.cacheRead === 0;
+				const limits = modelLimitsFor("moonshot", id) ?? modelLimitsFor("moonshot", "kimi-k3");
 				return {
 					...model,
 					reasoning: true,
-					input: ["text", "image"],
 					cost: isZeroCost ? { ...MOONSHOT_KIMI_K3_COST } : model.cost,
-					contextWindow: model.contextWindow ?? MOONSHOT_KIMI_K3_CONTEXT_WINDOW,
-					maxTokens: model.maxTokens ?? MOONSHOT_KIMI_K3_MAX_TOKENS,
-					thinking: model.thinking ?? { ...MOONSHOT_KIMI_K3_THINKING },
+					contextWindow: model.contextWindow ?? limits?.context ?? null,
+					maxTokens: model.maxTokens ?? limits?.maxTokens ?? null,
 				};
 			}
-			// Moonshot's K2.x family (K2.5, K2.6, kimi-k2-thinking, …) is reasoning-capable
-			// and vision-capable on the native API. Without these flags the openai-completions
-			// path skips the z.ai-format `thinking` block, and Moonshot K2.6 stalls on first
-			// turn because its endpoint expects an explicit `thinking: {type}` (#2113). Match
-			// the bundled K2.5 metadata for every K2.x id we discover.
-			const isKimiK2Reasoning = id.includes("thinking") || /(^|\/)kimi-k2(?:\.\d+)?(?:[-:]|$)/.test(id);
-			const isVision = id.includes("vision") || id.includes("vl") || /(^|\/)kimi-k2(?:\.\d+)?(?:[-:]|$)/.test(id);
+			// Moonshot's K2.x generation and its thinking variants reason on the
+			// native API (#2113); the effort ladder and modalities are rule-owned
+			// and derived at build time from this flag.
+			const isKimiK2Generation = identity.class === "kimi" && identity.family?.startsWith("k2") === true;
 			return {
 				...model,
-				reasoning: isKimiK2Reasoning || model.reasoning,
-				input: isVision ? ["text", "image"] : model.input,
-				thinking:
-					model.thinking ??
-					(isKimiK2Reasoning
-						? { mode: "effort", efforts: [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High] }
-						: undefined),
+				reasoning: identity.thinkingVariant === true || isKimiK2Generation || model.reasoning,
 			};
 		},
 	});
@@ -4820,7 +4911,114 @@ export function aiandModelManagerOptions(config?: AiandModelManagerConfig): Mode
 }
 
 // ---------------------------------------------------------------------------
-// 16.7 Yolo-Auto (yolo-auto.com)
+// 16.7 Abliteration (abliteration.ai)
+// ---------------------------------------------------------------------------
+
+const ABLITERATION_DEFAULT_BASE_URL = "https://api.abliteration.ai/v1";
+const ABLITERATION_MODEL_COST = { input: 3, output: 3, cacheRead: 0.3, cacheWrite: 0 } as const;
+const ABLITERATION_LARGE_COST = { input: 5, output: 5, cacheRead: 0.5, cacheWrite: 0 } as const;
+
+function normalizeAbliterationBaseUrl(baseUrl: string | undefined): string {
+	const value = baseUrl?.trim() || ABLITERATION_DEFAULT_BASE_URL;
+	const normalized = value.replace(/\/+$/, "");
+	return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+
+function createAbliterationStaticModel(
+	id: string,
+	name: string,
+	cost: ModelSpec<"openai-responses">["cost"],
+	contextWindow: number,
+	maxTokens: number,
+	input: ModelSpec<"openai-responses">["input"],
+): ModelSpec<"openai-responses"> {
+	return {
+		id,
+		name,
+		api: "openai-responses",
+		provider: "abliteration",
+		baseUrl: ABLITERATION_DEFAULT_BASE_URL,
+		reasoning: true,
+		input: [...input],
+		cost: { ...cost },
+		contextWindow,
+		maxTokens,
+	};
+}
+
+/**
+ * Documented abliteration.ai catalog (docs.abliteration.ai/models, 2026-09)
+ * bundled so the provider is usable when generation and first boot have no
+ * live key. The `/v1/models` response is authoritative once discovery runs.
+ * Rows carry only the documented limits and pricing; the per-model reasoning
+ * ladders, alias map and wire quirks come from `rules/classes/glm.kdl` and
+ * `rules/providers/abliteration.kdl` via `buildModel`.
+ */
+export const ABLITERATION_STATIC_MODELS: readonly ModelSpec<"openai-responses">[] = [
+	createAbliterationStaticModel("abliterated-model", "Abliterated Model", ABLITERATION_MODEL_COST, 262_144, 262_134, [
+		"text",
+		"image",
+	]),
+	createAbliterationStaticModel(
+		"abliterated-model-large-v2",
+		"Abliterated Model Large V2",
+		ABLITERATION_LARGE_COST,
+		1_000_000,
+		999_990,
+		["text"],
+	),
+	createAbliterationStaticModel(
+		"abliterated-model-large",
+		"Abliterated Model Large",
+		ABLITERATION_LARGE_COST,
+		1_000_000,
+		999_990,
+		["text"],
+	),
+];
+
+const ABLITERATION_STATIC_MODEL_BY_ID = new Map(ABLITERATION_STATIC_MODELS.map(model => [model.id, model] as const));
+const ABLITERATION_STATIC_MODEL_IDS = ABLITERATION_STATIC_MODELS.map(model => model.id);
+
+export interface AbliterationModelManagerConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	fetch?: FetchImpl;
+}
+
+export function abliterationModelManagerOptions(
+	config?: AbliterationModelManagerConfig,
+): ModelManagerOptions<"openai-responses"> {
+	const apiKey = config?.apiKey;
+	const baseUrl = normalizeAbliterationBaseUrl(config?.baseUrl);
+	const references = createBundledReferenceMap<"openai-responses">("abliteration");
+	return {
+		providerId: "abliteration",
+		dynamicModelsAuthoritative: true,
+		dropCachedModelIdsOnStaticMismatch: ABLITERATION_STATIC_MODEL_IDS,
+		...(apiKey && {
+			fetchDynamicModels: () =>
+				fetchOpenAICompatibleModels({
+					api: "openai-responses",
+					provider: "abliteration",
+					baseUrl,
+					apiKey,
+					mapModel: (entry, defaults) => {
+						const reference = references.get(defaults.id) ?? ABLITERATION_STATIC_MODEL_BY_ID.get(defaults.id);
+						const model = mapWithBundledReference(entry, defaults, reference);
+						// Every abliteration.ai model reasons; `/v1/models` carries no
+						// capability metadata, so an unseeded id would otherwise lose
+						// its effort dial.
+						return reference ? model : { ...model, reasoning: true };
+					},
+					fetch: config?.fetch,
+				}),
+		}),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// 16.8 Yolo-Auto (yolo-auto.com)
 // ---------------------------------------------------------------------------
 
 const YOLO_AUTO_BASE_URL = "https://yolo-auto.com/v1";
@@ -5048,7 +5246,7 @@ export function xiaomiModelManagerOptions(
 			provider: providerId,
 			baseUrl: url,
 			apiKey,
-			filterModel: (_entry, model) => !model.id.includes("-tts") && !model.id.includes("-asr"),
+			filterModel: (_entry, model) => !isExcludedModel(providerId, model.id),
 			mapModel: (entry, defaults) => {
 				const reference = references.get(defaults.id);
 				const model = mapWithBundledReference(entry, defaults, reference);
@@ -5735,6 +5933,7 @@ export function vllmModelManagerOptions(config?: VllmModelManagerConfig): ModelM
 				apiKey,
 				mapModel: (entry, defaults) => {
 					const model = mapWithBundledReference(entry, defaults, references.get(defaults.id));
+					const identity = classifyModel("vllm", model.id, { lenient: true });
 					return {
 						...model,
 						contextWindow: toPositiveNumber(entry.max_model_len, model.contextWindow),
@@ -5742,7 +5941,8 @@ export function vllmModelManagerOptions(config?: VllmModelManagerConfig): ModelM
 						// open weights always think (the template cannot disable it), so
 						// light up the effort dial; buildModel derives the template
 						// ladder from the id + local-backend compat.
-						reasoning: model.reasoning || isQwen38PlusTemplateEffortModelId(model.id),
+						reasoning:
+							model.reasoning || (identity.class === "qwen" && revisionAtLeast(identity.revision, "3.8")),
 					};
 				},
 				fetch: config?.fetch,
@@ -5818,13 +6018,6 @@ export interface GithubCopilotModelManagerConfig {
 	fetch?: FetchImpl;
 }
 
-const COPILOT_ANTHROPIC_MODEL_PATTERN = /^claude-(haiku|sonnet|opus|fable|mythos)-\d/;
-const isCopilotResponsesModelId = (modelId: string): boolean =>
-	modelId === "grok-4.5" ||
-	modelId === "grok-4.6" ||
-	modelId.startsWith("gpt-5") ||
-	modelId.startsWith("oswe") ||
-	modelId.startsWith("mai-");
 const COPILOT_CACHE_INVALIDATED_MODEL_IDS = [
 	"grok-4.5",
 	"grok-4.5-1m",
@@ -5834,12 +6027,8 @@ const COPILOT_CACHE_INVALIDATED_MODEL_IDS = [
 ];
 
 function inferCopilotApi(modelId: string): Api {
-	if (COPILOT_ANTHROPIC_MODEL_PATTERN.test(modelId)) {
-		return "anthropic-messages";
-	}
-	if (isCopilotResponsesModelId(modelId)) {
-		return "openai-responses";
-	}
+	const route = apiRouteFor("github-copilot", modelId);
+	if (route?.api === "anthropic-messages" || route?.api === "openai-responses") return route.api;
 	return "openai-completions";
 }
 
@@ -5998,8 +6187,8 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 		providerId: "github-copilot",
 		cacheProviderId: resolveModelCacheProviderId("github-copilot", { apiKey: rawApiKey, baseUrl }),
 		dropCachedModelIdsOnStaticMismatch: COPILOT_CACHE_INVALIDATED_MODEL_IDS,
-		// COPILOT_API_HEADERS are compile-time constants (User-Agent + API
-		// version), not credentials. The cache omits all request headers for
+		// COPILOT_API_HEADERS are compile-time wire identity constants, not
+		// credentials. The cache omits all request headers for
 		// safety and can only restore them from a bundled static entry — so a
 		// Copilot model with no bundled reference (e.g. a freshly served
 		// claude-opus-5 and its synthesized -1m sibling) is dropped on offline
@@ -6019,7 +6208,7 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 					provider: "github-copilot",
 					baseUrl: requestBaseUrl,
 					apiKey,
-					headers: COPILOT_API_HEADERS,
+					headers: COPILOT_DISCOVERY_HEADERS,
 					mapModel: (
 						entry: OpenAICompatibleModelRecord,
 						defaults: ModelSpec<Api>,
@@ -6079,6 +6268,10 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 							maxTokens !== null
 								? Math.min(contextWindow, defaultContextMax + maxTokens)
 								: contextWindow;
+						const unreferencedIdentity =
+							reference === undefined && api === "anthropic-messages"
+								? classifyModel("github-copilot", defaults.id, { lenient: true })
+								: undefined;
 						const base: ModelSpec<Api> = reference
 							? {
 									...reference,
@@ -6089,10 +6282,7 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 									input,
 									contextWindow: defaultTierWindow,
 									maxTokens,
-									headers: {
-										...COPILOT_API_HEADERS,
-										...(getProviderReferences().get(defaults.id)?.headers ?? {}),
-									},
+									headers: mergeCopilotApiHeaders(getProviderReferences().get(defaults.id)?.headers),
 									...(api === "openai-completions"
 										? {
 												compat: {
@@ -6111,7 +6301,7 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 									input,
 									contextWindow: defaultTierWindow,
 									maxTokens,
-									headers: { ...COPILOT_API_HEADERS },
+									headers: mergeCopilotApiHeaders(),
 									// Copilot's `/models` advertises no reasoning bit, so a
 									// thinking-capable Claude with no bundled reference would
 									// fall back to `reasoning: false` and lose its effort dial.
@@ -6120,7 +6310,8 @@ export function githubCopilotModelManagerOptions(config?: GithubCopilotModelMana
 									// (<= 3.5) over the Messages proxy is not handed a fabricated
 									// dial it would reject; a modern reference-less model (e.g.
 									// claude-opus-5) is marked so `buildModel` derives the ladder.
-									...(api === "anthropic-messages" && anthropicModelSupportsThinking(defaults.id)
+									...(unreferencedIdentity?.class === "anthropic" &&
+									revisionAtLeast(unreferencedIdentity.revision, "3.7")
 										? { reasoning: true }
 										: {}),
 									...(api === "openai-completions"
@@ -6400,7 +6591,7 @@ function resolveApiByRules(
 
 function createOpenCodeApiResolution(
 	basePath: string,
-	idOverrides: Readonly<Record<string, Api>> = {},
+	providerId: "opencode-zen" | "opencode-go",
 ): {
 	defaultResolution: { api: Api; baseUrl: string };
 	rules: ApiResolutionRule[];
@@ -6410,8 +6601,11 @@ function createOpenCodeApiResolution(
 	// - openai-completions / openai-responses / google-generative-ai → /v1
 	// - anthropic-messages → bare basePath (the Anthropic client appends /v1/messages)
 	const baseUrlForApi = (api: Api): string => (api === "anthropic-messages" ? basePath : completionsBaseUrl);
-	const overrideRules: ApiResolutionRule[] = Object.entries(idOverrides).map(([id, api]) => ({
-		matches: modelId => modelId === id,
+	// Per-id route pins live in the `api-routes` behavior rules.
+	const overrideRules: ApiResolutionRule[] = (
+		["openai-completions", "openai-responses", "anthropic-messages"] as const
+	).map(api => ({
+		matches: modelId => apiRouteFor(providerId, modelId)?.api === api,
 		resolved: { api, baseUrl: baseUrlForApi(api) },
 	}));
 	return {
@@ -6437,19 +6631,32 @@ function createOpenCodeApiResolution(
 }
 
 // Resolver rules for the models.dev descriptor path; the per-id pins live in
-// OPENCODE_ZEN_API_ID_OVERRIDES / OPENCODE_GO_API_ID_OVERRIDES (section 8),
-// which also drive the live-discovery mapper.
-const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution(
-	"https://opencode.ai/zen",
-	OPENCODE_ZEN_API_ID_OVERRIDES,
-);
-const OPENCODE_GO_API_RESOLUTION = createOpenCodeApiResolution(
-	"https://opencode.ai/zen/go",
-	OPENCODE_GO_API_ID_OVERRIDES,
-);
+// the `api-routes` behavior rules, which also drive the live-discovery mapper.
+const OPENCODE_ZEN_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen", "opencode-zen");
+const OPENCODE_GO_API_RESOLUTION = createOpenCodeApiResolution("https://opencode.ai/zen/go", "opencode-go");
 
 const COPILOT_BASE_URL = "https://api.githubcopilot.com";
 
+const ZAI_ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
+// The `zai` catalog provider is the GLM Coding Plan: `/login zai` validates and
+// stores credentials against the coding-plan endpoint (see auth/zai.kdl), so
+// the native OpenAI transport must ride the coding-plan base rather than the
+// general PAYG `/api/paas/v4`, which would bypass plan quota or fail auth.
+const ZAI_OPENAI_BASE_URL = "https://api.z.ai/api/coding/paas/v4";
+
+/** Resolves the transport and endpoint for one Z.AI model catalog entry. */
+export function resolveZaiApi(modelId: string): { api: "anthropic-messages" | "openai-completions"; baseUrl: string } {
+	const api = apiRouteFor("zai", modelId)?.api ?? "anthropic-messages";
+	switch (api) {
+		case "anthropic-messages":
+			return { api, baseUrl: ZAI_ANTHROPIC_BASE_URL };
+		case "openai-completions":
+			return { api, baseUrl: ZAI_OPENAI_BASE_URL };
+		default:
+			throw new Error(`Unsupported Z.AI API route: ${api}`);
+	}
+}
+
 const COPILOT_DEFAULT_RESOLUTION = {
 	api: "openai-completions",
 	baseUrl: COPILOT_BASE_URL,
@@ -6457,11 +6664,11 @@ const COPILOT_DEFAULT_RESOLUTION = {
 
 const COPILOT_API_RESOLUTION_RULES: readonly ApiResolutionRule[] = [
 	{
-		matches: modelId => COPILOT_ANTHROPIC_MODEL_PATTERN.test(modelId),
+		matches: modelId => apiRouteFor("github-copilot", modelId)?.api === "anthropic-messages",
 		resolved: { api: "anthropic-messages", baseUrl: COPILOT_BASE_URL },
 	},
 	{
-		matches: isCopilotResponsesModelId,
+		matches: modelId => apiRouteFor("github-copilot", modelId)?.api === "openai-responses",
 		resolved: { api: "openai-responses", baseUrl: COPILOT_BASE_URL },
 	},
 ];
@@ -6536,11 +6743,8 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_BEDROCK: readonly ModelsDevProviderDescrip
 		api: "bedrock-converse-stream",
 		baseUrl: "https://bedrock-runtime.us-east-1.amazonaws.com",
 		filterModel: (id, m) => {
-			if (m.tool_call !== true) return false;
-			if (id.startsWith("ai21.jamba")) return false;
-			if (id.startsWith("amazon.titan-text-express") || id.startsWith("mistral.mistral-7b-instruct-v0"))
-				return false;
-			return true;
+			// Undrivable SKUs are rule-owned (`runtime/behavior.kdl` exclude-models).
+			return m.tool_call === true && !isExcludedModel("amazon-bedrock", id);
 		},
 		transformModel: (model, modelId, m) => {
 			const crossRegionId = bedrockCrossRegionId(modelId);
@@ -6555,7 +6759,10 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_BEDROCK: readonly ModelsDevProviderDescrip
 			// without these rows the catalog only has commercial geos (`us.`/`eu.`/…)
 			// and model resolution rejects the GovCloud id (or misroutes commercial
 			// geos onto us-east-1 with GovCloud credentials → 403).
-			if (modelId.startsWith("anthropic.claude-")) {
+			// Fan out only bare vendor-namespaced source ids (`anthropic.<model>`);
+			// ids already carrying a geo prefix (`us.`/`eu.`/`global.`/`au.`…)
+			// are this fan-out's own output shape.
+			if (modelId.split(".", 1)[0] === "anthropic") {
 				const displayName = toModelName(m.name, modelId);
 				return [
 					bedrockModel,
@@ -6576,19 +6783,57 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_BEDROCK: readonly ModelsDevProviderDescrip
 	},
 ];
 
+const CLINEPASS_REASONING_BUDGET_RATIOS: Readonly<Record<Effort, number>> = {
+	[Effort.Minimal]: 0.1,
+	[Effort.Low]: 0.2,
+	[Effort.Medium]: 0.5,
+	[Effort.High]: 0.8,
+	[Effort.XHigh]: 0.95,
+	[Effort.Max]: 1,
+};
+
+function buildClinePassThinking(raw: ModelsDevModel, model: ModelSpec<Api>): ThinkingConfig | undefined {
+	const effortValues = raw.reasoning_options?.find(option => option.type === "effort")?.values;
+	if (effortValues) {
+		const efforts = THINKING_EFFORTS.filter(effort => effortValues.includes(effort));
+		return efforts.length > 0 ? { mode: "effort", efforts } : undefined;
+	}
+
+	const budget = raw.reasoning_options?.find(option => option.type === "budget_tokens");
+	if (!budget) return undefined;
+	const modelMaxTokens = model.maxTokens ?? CLINEPASS_FALLBACK_MAX_TOKENS;
+	const maximum = toPositiveNumber(budget.max, modelMaxTokens) ?? modelMaxTokens;
+	const minimum = toPositiveNumber(budget.min, 1) ?? 1;
+	const scale = Math.min(modelMaxTokens, maximum);
+	return {
+		mode: "budget",
+		efforts: THINKING_EFFORTS,
+		effortBudgets: Object.fromEntries(
+			THINKING_EFFORTS.map(effort => [
+				effort,
+				Math.min(Math.max(Math.floor(scale * CLINEPASS_REASONING_BUDGET_RATIOS[effort]), minimum), maximum),
+			]),
+		),
+	};
+}
+
+/**
+ * DeepSeek's V4-generation lineage (`v4`, `v4-flash`, `v4.1-pro`) by
+ * structured family. The native roster serves only V4-era SKUs today; the
+ * `tool_call` gate on the descriptor filters the rest.
+ */
+function isDeepseekV4Generation(providerId: string, modelId: string): boolean {
+	const identity = classifyModel(providerId, modelId, { lenient: true });
+	if (identity.class !== "deepseek") return false;
+	return identity.family === "v4" || identity.family === "flash" || identity.family === "pro";
+}
+
 const MODELS_DEV_PROVIDER_DESCRIPTORS_CORE: readonly ModelsDevProviderDescriptor[] = [
 	// --- Anthropic ---
 	anthropicMessagesDescriptor("anthropic", "anthropic", "https://api.anthropic.com", {
 		filterModel: (id, m) => {
 			if (m.tool_call !== true) return false;
-			if (
-				id.startsWith("claude-3-5-haiku") ||
-				id.startsWith("claude-3-7-sonnet") ||
-				id === "claude-3-opus-20240229" ||
-				id === "claude-3-sonnet-20240229"
-			)
-				return false;
-			return true;
+			return !isExcludedModel("anthropic", id);
 		},
 	}),
 	// --- Google ---
@@ -6604,19 +6849,46 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CORE: readonly ModelsDevProviderDescriptor
 	openAiCompletionsDescriptor("groq", "groq", "https://api.groq.com/openai/v1"),
 	// --- Cerebras ---
 	openAiCompletionsDescriptor("cerebras", "cerebras", "https://api.cerebras.ai/v1"),
+	// --- ClinePass ---
+	// The live roster owns membership; this snapshot pins Cline's exact limits,
+	// pricing, modalities, and per-model reasoning controls for known ids.
+	openAiCompletionsDescriptor("cline-pass", "cline-pass", "https://api.cline.bot/api/v1", {
+		transformModel: (model, modelId, raw) => {
+			const id = toClinePassPublicModelId(modelId);
+			const metadata = getClinePassModelMetadata(id);
+			if (metadata) {
+				return {
+					...model,
+					id,
+					name: metadata.name,
+					contextWindow: metadata.contextWindow,
+					maxTokens: metadata.maxTokens,
+					input: metadata.input,
+					cost: metadata.cost,
+					reasoning: metadata.reasoning,
+					thinking: metadata.thinking,
+					compat:
+						metadata.thinking === undefined ? { ...model.compat, supportsReasoningEffort: false } : model.compat,
+				};
+			}
+			return {
+				...model,
+				id,
+				thinking: model.reasoning ? buildClinePassThinking(raw, model) : undefined,
+			};
+		},
+	}),
 	// --- Together ---
 	openAiCompletionsDescriptor("togetherai", "together", "https://api.together.xyz/v1"),
 	// --- CoreWeave Serverless Inference ---
 	openAiCompletionsDescriptor("wandb", "coreweave", "https://api.inference.wandb.ai/v1", {
 		transformModel: model => {
-			if (!model.id.startsWith("openai/gpt-oss-")) {
+			// CoreWeave's roster omits the reasoning bit for gpt-oss; flag it and
+			// let the class rules own the effort ladder.
+			if (classifyModel("coreweave", model.id, { lenient: true }).class !== "gpt-oss") {
 				return model;
 			}
-			return {
-				...model,
-				reasoning: true,
-				thinking: { mode: "effort", efforts: [Effort.Low, Effort.Medium, Effort.High] },
-			};
+			return { ...model, reasoning: true };
 		},
 	}),
 	// --- NVIDIA ---
@@ -6631,7 +6903,7 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CORE: readonly ModelsDevProviderDescriptor
 	openAiCompletionsDescriptor("deepseek", "deepseek", "https://api.deepseek.com", {
 		// Only ship the v4 family as built-ins; older deepseek-chat / deepseek-reasoner
 		// ids are kept off the catalog until the issue thread asks for them.
-		filterModel: (id, m) => m.tool_call === true && id.startsWith("deepseek-v4"),
+		filterModel: (id, m) => m.tool_call === true && isDeepseekV4Generation("deepseek", id),
 		compat: {
 			// DeepSeek V4 effort remapping is derived in model-thinking metadata; this
 			// descriptor keeps only transport-shape compat.
@@ -6662,7 +6934,9 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_CODING_PLANS: readonly ModelsDevProviderDe
 	// SKU as "Free" in `/models`. The PAYG key carries the real per-token rates for
 	// the identical model ids, so the enumerated token costs line up with the other
 	// subscription providers for comparison (issue #5598).
-	anthropicMessagesDescriptor("zai", "zai", "https://api.z.ai/api/anthropic"),
+	anthropicMessagesDescriptor("zai", "zai", ZAI_ANTHROPIC_BASE_URL, {
+		resolveApi: modelId => resolveZaiApi(modelId),
+	}),
 	// --- Umans AI ---
 	// Source the pay-as-you-go catalog: the coding-plan key publishes subscription
 	// costs as zero, while `/models/info` omits pricing entirely. The generator
@@ -6862,7 +7136,7 @@ const MODELS_DEV_PROVIDER_DESCRIPTORS_SPECIALIZED: readonly ModelsDevProviderDes
 	openAiCompletionsDescriptor("zenmux", "zenmux", ZENMUX_OPENAI_BASE_URL, {
 		filterModel: filterActiveToolCallModels,
 		resolveApi: modelId => {
-			if (modelId.startsWith("anthropic/")) {
+			if (apiRouteFor("zenmux", modelId)?.api === "anthropic-messages") {
 				return { api: "anthropic-messages" as const, baseUrl: ZENMUX_ANTHROPIC_BASE_URL };
 			}
 			return { api: "openai-completions" as const, baseUrl: ZENMUX_OPENAI_BASE_URL };