jeopi-catalog 16.2.13

package/src/discovery/index.ts

@@ -0,0 +1,5 @@
+export * from "./antigravity";
+export * from "./codex";
+export * from "./gemini";
+export * from "./gitlab-duo-workflow";
+export * from "./openai-compatible";

package/src/discovery/openai-compatible.ts

@@ -0,0 +1,249 @@
+import { type } from "arktype";
+import type { Api, FetchImpl, ModelSpec, Provider } from "../types";
+import { discoveryFetch } from "../utils";
+
+const MODELS_PATH = "/models";
+
+/**
+ * Uses a cancellable timer rather than the native abort-timeout helper so
+ * successful fast discovery requests do not leave armed timeout signals for
+ * concurrent GC to trip over later.
+ */
+async function withOpenAICompatibleDiscoveryTimeout<T>(
+	timeoutMs: number,
+	run: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+	const controller = new AbortController();
+	const timer = setTimeout(
+		() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")),
+		timeoutMs,
+	);
+	try {
+		return await run(controller.signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+/**
+ * Minimal OpenAI-style model entry shape consumed by discovery.
+ *
+ * Providers may return additional fields; this type only captures
+ * fields that are useful for generic normalization.
+ */
+export interface OpenAICompatibleModelRecord {
+	id?: unknown;
+	name?: unknown;
+	object?: unknown;
+	owned_by?: unknown;
+	[key: string]: unknown;
+}
+
+/**
+ * Tolerant envelope for OpenAI-compatible `/models` responses.
+ *
+ * Common providers return `{ data: [...] }`, but variants such as
+ * `{ models: [...] }`, `{ result: [...] }`, or direct arrays are also
+ * accepted during extraction.
+ */
+export interface OpenAICompatibleModelsEnvelope {
+	data?: unknown;
+	models?: unknown;
+	result?: unknown;
+	items?: unknown;
+	[key: string]: unknown;
+}
+
+const openAICompatibleModelRecordSchema = type({
+	id: "string >= 1",
+	"name?": "string | null",
+	"object?": "unknown",
+	"owned_by?": "unknown",
+});
+
+const openAICompatibleModelsEnvelopeSchema = type({
+	"data?": "unknown",
+	"models?": "unknown",
+	"result?": "unknown",
+	"items?": "unknown",
+});
+
+const openAICompatibleModelsPayloadSchema = type("unknown[]").or(openAICompatibleModelsEnvelopeSchema);
+
+type ParsedOpenAICompatibleModelRecord = typeof openAICompatibleModelRecordSchema.infer;
+/**
+ * Context passed to custom OpenAI-compatible model mappers.
+ */
+export interface OpenAICompatibleModelMapperContext<TApi extends Api> {
+	api: TApi;
+	provider: Provider;
+	baseUrl: string;
+}
+
+/**
+ * Options for fetching and normalizing OpenAI-compatible `/models` catalogs.
+ */
+export interface FetchOpenAICompatibleModelsOptions<TApi extends Api> {
+	/** API type assigned to normalized models. */
+	api: TApi;
+	/** Provider id assigned to normalized models. */
+	provider: Provider;
+	/** Provider base URL used for both fetch and normalized model records. */
+	baseUrl: string;
+	/** Optional bearer token for Authorization header. */
+	apiKey?: string;
+	/** Additional request headers. */
+	headers?: Record<string, string>;
+	/** Optional AbortSignal for request cancellation; caller owns its lifecycle. */
+	signal?: AbortSignal;
+	/** Optional cancellable request timeout used when `signal` is omitted. */
+	timeoutMs?: number;
+	/** Optional fetch implementation override for testing/custom runtimes. */
+	fetch?: FetchImpl;
+	/**
+	 * Optional post-normalization filter.
+	 * Return false to skip a model.
+	 */
+	filterModel?: (entry: OpenAICompatibleModelRecord, model: ModelSpec<TApi>) => boolean;
+	/**
+	 * Optional mapper override for provider-specific quirks.
+	 * Return null to skip a model.
+	 */
+	mapModel?: (
+		entry: OpenAICompatibleModelRecord,
+		defaults: ModelSpec<TApi>,
+		context: OpenAICompatibleModelMapperContext<TApi>,
+	) => ModelSpec<TApi> | null;
+}
+
+/**
+ * Fetches and normalizes an OpenAI-compatible `/models` catalog.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export async function fetchOpenAICompatibleModels<TApi extends Api>(
+	options: FetchOpenAICompatibleModelsOptions<TApi>,
+): Promise<ModelSpec<TApi>[] | null> {
+	const baseUrl = normalizeBaseUrl(options.baseUrl);
+	if (!baseUrl) {
+		return null;
+	}
+
+	const requestHeaders: Record<string, string> = {
+		Accept: "application/json",
+		...options.headers,
+	};
+	if (options.apiKey) {
+		requestHeaders.Authorization = `Bearer ${options.apiKey}`;
+	}
+
+	const fetchImpl = discoveryFetch(options.fetch);
+	const fetchPayload = async (signal?: AbortSignal): Promise<unknown | null> => {
+		let response: Response;
+		try {
+			response = await fetchImpl(`${baseUrl}${MODELS_PATH}`, {
+				method: "GET",
+				headers: requestHeaders,
+				signal,
+			});
+		} catch {
+			return null;
+		}
+
+		if (!response.ok) {
+			return null;
+		}
+
+		try {
+			return await response.json();
+		} catch {
+			return null;
+		}
+	};
+	const payload =
+		options.signal !== undefined
+			? await fetchPayload(options.signal)
+			: options.timeoutMs !== undefined
+				? await withOpenAICompatibleDiscoveryTimeout(options.timeoutMs, fetchPayload)
+				: await fetchPayload();
+	if (payload === null) {
+		return null;
+	}
+
+	const entries = extractModelEntries(payload);
+	if (entries === null) {
+		return null;
+	}
+
+	const context: OpenAICompatibleModelMapperContext<TApi> = {
+		api: options.api,
+		provider: options.provider,
+		baseUrl,
+	};
+
+	const deduped = new Map<string, ModelSpec<TApi>>();
+	for (const entry of entries) {
+		const defaults: ModelSpec<TApi> = {
+			id: entry.id,
+			name: typeof entry.name === "string" && entry.name.length > 0 ? entry.name : entry.id,
+			api: options.api,
+			provider: options.provider,
+			baseUrl,
+			reasoning: false,
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: null,
+			maxTokens: null,
+		};
+
+		// `mapModel` returning null skips the entry (documented contract); only a
+		// missing mapper falls back to the defaults.
+		const mapped = options.mapModel ? options.mapModel(entry, defaults, context) : defaults;
+		if (!mapped || typeof mapped.id !== "string" || mapped.id.length === 0) {
+			continue;
+		}
+		if (options.filterModel && !options.filterModel(entry, mapped)) {
+			continue;
+		}
+		deduped.set(mapped.id, mapped);
+	}
+
+	return Array.from(deduped.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.trim();
+	if (!trimmed) {
+		return "";
+	}
+	return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+
+function extractModelEntries(payload: unknown): ParsedOpenAICompatibleModelRecord[] | null {
+	return extractModelEntriesFromNode(payload);
+}
+
+function extractModelEntriesFromNode(node: unknown): ParsedOpenAICompatibleModelRecord[] | null {
+	const parsedPayload = openAICompatibleModelsPayloadSchema(node);
+	if (parsedPayload instanceof type.errors) {
+		return null;
+	}
+	if (Array.isArray(parsedPayload)) {
+		const parsedEntries = parsedPayload
+			.map(entry => openAICompatibleModelRecordSchema(entry))
+			.flatMap(entry => (entry instanceof type.errors ? [] : [entry]));
+		return parsedEntries;
+	}
+	for (const candidate of [parsedPayload.data, parsedPayload.models, parsedPayload.result, parsedPayload.items]) {
+		if (candidate === undefined) {
+			continue;
+		}
+		const nested = extractModelEntriesFromNode(candidate);
+		if (nested !== null) {
+			return nested;
+		}
+	}
+
+	return null;
+}

package/src/effort.ts

@@ -0,0 +1,16 @@
+/** User-facing thinking levels, ordered least to most intensive. */
+export const enum Effort {
+	Minimal = "minimal",
+	Low = "low",
+	Medium = "medium",
+	High = "high",
+	XHigh = "xhigh",
+}
+
+export const THINKING_EFFORTS: readonly Effort[] = [
+	Effort.Minimal,
+	Effort.Low,
+	Effort.Medium,
+	Effort.High,
+	Effort.XHigh,
+];

package/src/fireworks-model-id.ts

@@ -0,0 +1,50 @@
+const FIREWORKS_WIRE_PREFIX = "accounts/fireworks/models/";
+const FIREPASS_WIRE_PREFIX = "accounts/fireworks/routers/";
+const VERSION_SEPARATOR_PATTERN = /(?<=\d)p(?=\d)/g;
+const VERSION_DOT_PATTERN = /(?<=\d)\.(?=\d)/g;
+
+export function toFireworksPublicModelId(modelId: string): string {
+	const stripped = modelId.startsWith(FIREWORKS_WIRE_PREFIX) ? modelId.slice(FIREWORKS_WIRE_PREFIX.length) : modelId;
+	return stripped.replace(VERSION_SEPARATOR_PATTERN, ".");
+}
+
+export function toFireworksWireModelId(modelId: string): string {
+	const stripped = modelId.startsWith(FIREWORKS_WIRE_PREFIX) ? modelId.slice(FIREWORKS_WIRE_PREFIX.length) : modelId;
+	return `${FIREWORKS_WIRE_PREFIX}${stripped.replace(VERSION_DOT_PATTERN, "p")}`;
+}
+
+/**
+ * Fire Pass exposes its Kimi K2.6 Turbo subscription through a dedicated router
+ * endpoint at `accounts/fireworks/routers/<id>` rather than the `models/` namespace.
+ * We keep a friendly public id (e.g. `kimi-k2.6-turbo`) in the catalog and translate
+ * to the wire form (`accounts/fireworks/routers/kimi-k2p6-turbo`) at request time.
+ */
+export function toFirepassPublicModelId(modelId: string): string {
+	const stripped = modelId.startsWith(FIREPASS_WIRE_PREFIX) ? modelId.slice(FIREPASS_WIRE_PREFIX.length) : modelId;
+	return stripped.replace(VERSION_SEPARATOR_PATTERN, ".");
+}
+
+export function toFirepassWireModelId(modelId: string): string {
+	const stripped = modelId.startsWith(FIREPASS_WIRE_PREFIX) ? modelId.slice(FIREPASS_WIRE_PREFIX.length) : modelId;
+	return `${FIREPASS_WIRE_PREFIX}${stripped.replace(VERSION_DOT_PATTERN, "p")}`;
+}
+
+/**
+ * Public-id suffix marking a Fireworks "Fast" serving-path variant. Fast is a
+ * higher-throughput route (100+ tok/s) exposed under a dedicated router id
+ * (`accounts/fireworks/routers/<id>-fast`), not a separate model — same weights,
+ * higher price, no Priority tier. We keep a friendly `<id>-fast` public id and
+ * translate it to the router wire form at request time (compat
+ * `wireModelIdMode: "firepass"`). See https://docs.fireworks.ai/serverless/serving-paths.
+ */
+export const FIREWORKS_FAST_SUFFIX = "-fast";
+
+/** True for a Fireworks public model id that selects the Fast serving path. */
+export function isFireworksFastModelId(modelId: string): boolean {
+	return modelId.endsWith(FIREWORKS_FAST_SUFFIX);
+}
+
+/** Strip the Fast suffix to recover the base (Standard-tier) model id. */
+export function toFireworksBaseModelId(modelId: string): string {
+	return modelId.endsWith(FIREWORKS_FAST_SUFFIX) ? modelId.slice(0, -FIREWORKS_FAST_SUFFIX.length) : modelId;
+}

package/src/hosts.ts

@@ -0,0 +1,129 @@
+/**
+ * Known model-endpoint host classification — the single vocabulary for the
+ * `provider === id || baseUrl.includes(marker)` idiom that gates wire-level
+ * behavior (compat detection, routing, header shaping, watchdog floors).
+ *
+ * Markers are case-insensitive substrings matched against the base URL, NOT
+ * parsed hostnames: proxies regularly embed the upstream host in a path
+ * segment, and the historical call sites all used substring semantics.
+ * Callers that need strict hostname matching — where a substring false
+ * positive is dangerous, e.g. the Anthropic official-endpoint OAuth gate —
+ * parse the URL and compare the hostname themselves.
+ */
+
+interface HostClassSpec {
+	/** Provider ids that imply this host class regardless of baseUrl. */
+	readonly providers?: readonly string[];
+	/** Provider-id prefixes that imply this host class (e.g. `xiaomi-token-plan-`). */
+	readonly providerPrefixes?: readonly string[];
+	/** Lowercase ASCII substrings matched case-insensitively against the base URL. */
+	readonly urlMarkers: readonly string[];
+	// Strict hostname matching is intentionally not modeled here: the one
+	// auth-sensitive consumer (Anthropic official-endpoint) parses the URL
+	// itself; every other call site is benign and uses substring matching.
+}
+
+export const KNOWN_HOSTS = {
+	openai: { providers: ["openai"], urlMarkers: ["api.openai.com"] },
+	azureOpenAI: {
+		providers: ["azure"],
+		urlMarkers: [".openai.azure.com", "azure.com/openai", "models.inference.ai.azure.com"],
+	},
+	openrouter: { providers: ["openrouter"], urlMarkers: ["openrouter.ai"] },
+	vercelAIGateway: { providers: ["vercel-ai-gateway"], urlMarkers: ["ai-gateway.vercel.sh"] },
+	githubCopilot: { providers: ["github-copilot"], urlMarkers: ["githubcopilot.com", "copilot-api."] },
+	anthropic: { providers: ["anthropic"], urlMarkers: ["api.anthropic.com"] },
+	/** DeepSeek's first-party API only — gates direct-API quirks (max_tokens field, thinking extraBody). */
+	deepseekDirect: { providers: ["deepseek"], urlMarkers: ["api.deepseek.com"] },
+	/** Any DeepSeek-operated host (first-party API, web-chat fronts). Wider than `deepseekDirect` on purpose. */
+	deepseekFamily: { providers: ["deepseek"], urlMarkers: ["deepseek.com"] },
+	cerebras: { providers: ["cerebras"], urlMarkers: ["cerebras.ai"] },
+	zai: { providers: ["zai"], urlMarkers: ["api.z.ai"] },
+	zhipu: { providers: ["zhipu-coding-plan"], urlMarkers: ["open.bigmodel.cn"] },
+	kilo: { providers: ["kilo"], urlMarkers: ["api.kilo.ai"] },
+	alibabaDashscope: { providers: ["alibaba-coding-plan"], urlMarkers: ["dashscope"] },
+	umans: { providers: ["umans"], urlMarkers: ["api.code.umans.ai"] },
+	xiaomi: { providers: ["xiaomi"], providerPrefixes: ["xiaomi-token-plan-"], urlMarkers: ["xiaomimimo.com"] },
+	xai: { providers: ["xai"], urlMarkers: ["api.x.ai"] },
+	mistral: { providers: ["mistral"], urlMarkers: ["mistral.ai"] },
+	together: { providers: ["together"], urlMarkers: ["api.together.xyz"] },
+	/** URL-only on purpose: the `fireworks`/`firepass` providers route per-model and not every model is Fireworks-shaped. */
+	fireworks: { urlMarkers: ["fireworks.ai"] },
+	groq: { providers: ["groq"], urlMarkers: ["api.groq.com"] },
+	minimax: {
+		providers: ["minimax", "minimax-code", "minimax-code-cn"],
+		urlMarkers: ["api.minimax.io", "api.minimaxi.com"],
+	},
+	qwenPortal: { providers: ["qwen-portal"], urlMarkers: ["portal.qwen.ai"] },
+	/** NVIDIA NIM (`integrate.api.nvidia.com`). Qwen NIM endpoints take `chat_template_kwargs.enable_thinking`, never top-level `enable_thinking`. */
+	nvidia: { providers: ["nvidia"], urlMarkers: ["integrate.api.nvidia.com"] },
+	moonshotNative: { providers: ["moonshot", "kimi-code"], urlMarkers: ["api.moonshot.ai", "api.kimi.com"] },
+	opencode: { providers: ["opencode-go", "opencode-zen"], urlMarkers: ["opencode.ai"] },
+	chutes: { urlMarkers: ["chutes.ai"] },
+} as const satisfies Record<string, HostClassSpec>;
+
+export type KnownHost = keyof typeof KNOWN_HOSTS;
+
+/** URL-only host check (for call sites that have no provider id, e.g. raw env config). */
+export function hostMatchesUrl(baseUrl: string | undefined, host: KnownHost): boolean {
+	if (!baseUrl) return false;
+	const spec: HostClassSpec = KNOWN_HOSTS[host];
+	for (const marker of spec.urlMarkers) {
+		if (includesAsciiCaseInsensitive(baseUrl, marker)) return true;
+	}
+	return false;
+}
+
+/** Provider-or-URL host check — the canonical `provider === id || baseUrl.includes(marker)` idiom. */
+export function modelMatchesHost(model: { provider: string; baseUrl: string }, host: KnownHost): boolean {
+	const spec: HostClassSpec = KNOWN_HOSTS[host];
+	if (spec.providers) {
+		for (const provider of spec.providers) {
+			if (model.provider === provider) return true;
+		}
+	}
+	if (spec.providerPrefixes) {
+		for (const prefix of spec.providerPrefixes) {
+			if (model.provider.startsWith(prefix)) return true;
+		}
+	}
+	return hostMatchesUrl(model.baseUrl, host);
+}
+
+function includesAsciiCaseInsensitive(value: string, lowerNeedle: string): boolean {
+	const needleLength = lowerNeedle.length;
+	const end = value.length - needleLength;
+	for (let start = 0; start <= end; start++) {
+		let offset = 0;
+		for (; offset < needleLength; offset++) {
+			if ((value.charCodeAt(start + offset) | 0x20) !== lowerNeedle.charCodeAt(offset)) break;
+		}
+		if (offset === needleLength) return true;
+	}
+	return false;
+}
+
+// --- Endpoint-shape predicates (URL path/verb shapes, not vendor hosts) ---
+
+/** Vertex AI express-mode OpenAI-compatible endpoint (`…/endpoints/openapi`). */
+export function isVertexExpressOpenAIUrl(baseUrl: string): boolean {
+	return baseUrl.includes("/endpoints/openapi");
+}
+
+/** Vertex AI Anthropic raw-predict endpoints (`:streamRawPredict` / `:rawPredict`). */
+export function isVertexRawPredictUrl(baseUrl: string): boolean {
+	return baseUrl.includes(":streamRawPredict") || baseUrl.includes(":rawPredict");
+}
+
+/** Azure OpenAI deployment-scoped path (`…/deployments/<name>/…`). */
+export function isAzureDeploymentsUrl(baseUrl: string): boolean {
+	return baseUrl.includes("/deployments/");
+}
+
+/** Alibaba DashScope consumer `compatible-mode` endpoint (rejects multimodal arrays for some text-only SKUs). */
+export function isDashscopeCompatibleModeUrl(baseUrl: string): boolean {
+	const normalized = baseUrl.toLowerCase();
+	return (
+		normalized.includes("dashscope") && normalized.includes("aliyuncs.com") && normalized.includes("/compatible-mode")
+	);
+}

package/src/identity/bundled.ts

@@ -0,0 +1,28 @@
+/**
+ * Memoized proxy-reference index over the bundled model catalog.
+ *
+ * Lazy: walking every bundled model (~12K) triggers thinking enrichment, so the
+ * walk is deferred off module load and performed once. Consumers that need
+ * non-bundled reference data use the pure builder directly
+ * ({@link buildModelReferenceIndex}).
+ */
+import { getBundledModels, getBundledProviders } from "../models";
+import type { Api, Model } from "../types";
+import { buildModelReferenceIndex, type ModelReferenceIndex } from "./reference";
+
+let bundledModels: readonly Model<Api>[] | undefined;
+
+function getBundledModelList(): readonly Model<Api>[] {
+	bundledModels ??= getBundledProviders().flatMap(
+		provider => getBundledModels(provider as Parameters<typeof getBundledModels>[0]) as Model<Api>[],
+	);
+	return bundledModels;
+}
+
+let referenceIndex: ModelReferenceIndex | undefined;
+
+/** Proxy-reference index over the bundled catalog. */
+export function getBundledModelReferenceIndex(): ModelReferenceIndex {
+	referenceIndex ??= buildModelReferenceIndex(getBundledModelList());
+	return referenceIndex;
+}

package/src/identity/classify.ts

@@ -0,0 +1,214 @@
+/**
+ * Model-id classification: parse a model id into its family (gemini / anthropic /
+ * openai), kind/variant, and version. This is the shared layer both catalog
+ * policy rules (`model-thinking.ts`) and downstream consumers build on —
+ * classification lives here, the rules that consume it stay with their domain.
+ */
+
+export type SemVer = {
+	major: number;
+	minor: number;
+	patch: number;
+};
+
+export type GeminiKind = "pro" | "flash";
+export type AnthropicKind = "opus" | "sonnet" | "fable" | "mythos";
+export type OpenAIVariant = "base" | "codex" | "codex-max" | "codex-mini" | "codex-spark" | "mini" | "max" | "nano";
+export type GlmVariant = "base" | "air" | "turbo" | "flash" | "flashx" | "preview";
+
+export interface GeminiModel {
+	family: "gemini";
+	kind: GeminiKind;
+	version: SemVer;
+}
+
+export interface AnthropicModel {
+	family: "anthropic";
+	kind: AnthropicKind;
+	version: SemVer;
+}
+
+export interface OpenAIModel {
+	family: "openai";
+	variant: OpenAIVariant;
+	version: SemVer;
+}
+
+export interface GlmModel {
+	family: "glm";
+	/** Suffix variant (`-air`, `-turbo`, `-flash`, `-flashx`, `-preview`); `base` when none. */
+	variant: GlmVariant;
+	/** Vision SKU — the `v` that attaches directly to the version (`glm-4v`, `glm-4.5v`). */
+	vision: boolean;
+	version: SemVer;
+}
+
+export interface UnknownModel {
+	family: "unknown";
+	id: string;
+}
+
+export type ParsedModel = GeminiModel | AnthropicModel | OpenAIModel | UnknownModel;
+
+/** Strip a provider namespace prefix (`openai/gpt-5.4` → `gpt-5.4`). */
+// Cache keyed by model id (a bounded set of bundled/aggregator ids), so no eviction is needed.
+const bareModelIdCache = new Map<string, string>();
+export function bareModelId(modelId: string): string {
+	const cached = bareModelIdCache.get(modelId);
+	if (cached !== undefined) return cached;
+	const p = modelId.lastIndexOf("/");
+	const result = p !== -1 ? modelId.slice(p + 1) : modelId;
+	bareModelIdCache.set(modelId, result);
+	return result;
+}
+
+export function parseKnownModel(modelId: string): ParsedModel {
+	const canonicalId = bareModelId(modelId);
+	return (
+		parseGeminiModel(canonicalId) ??
+		parseAnthropicModel(canonicalId) ??
+		parseOpenAIModel(canonicalId) ?? { family: "unknown", id: canonicalId }
+	);
+}
+
+/**
+ * Wrap a parse function in a per-id memo cache. Caches the `null` result too, so
+ * repeated misses (the common case — ids of other families) stay O(1) and never
+ * re-run the regex/semver work.
+ */
+function parser<T>(parse: (modelId: string) => T | null): (modelId: string) => T | null {
+	const cache = new Map<string, T | null>();
+	return modelId => {
+		const hit = cache.get(modelId);
+		if (hit !== undefined || cache.has(modelId)) {
+			return hit ?? null;
+		}
+		const result = parse(modelId);
+		cache.set(modelId, result);
+		return result;
+	};
+}
+
+const GEMINI_SUFFIX = "-preview";
+export const parseGeminiModel = parser((modelId): GeminiModel | null => {
+	if (modelId.endsWith(GEMINI_SUFFIX)) {
+		modelId = modelId.slice(0, -GEMINI_SUFFIX.length);
+	}
+	const match = /gemini-(\d+(?:\.\d+){0,2})-(pro|flash)\b/.exec(modelId);
+	if (!match) {
+		return null;
+	}
+	const version = parseSemVer(match[1]);
+	if (!version) {
+		return null;
+	}
+	return { family: "gemini", kind: match[2] as GeminiKind, version };
+});
+
+export const parseAnthropicModel = parser((modelId): AnthropicModel | null => {
+	const match = /claude-(opus|sonnet|fable|mythos)-(\d{1,2}(?:[.-]\d{1,2}){0,2})\b/.exec(modelId);
+	if (!match) {
+		return null;
+	}
+	const version = parseSemVer(match[2]);
+	if (!version) {
+		return null;
+	}
+	return { family: "anthropic", kind: match[1] as AnthropicKind, version };
+});
+
+export const parseOpenAIModel = parser((modelId): OpenAIModel | null => {
+	const match = /gpt-(\d+(?:\.\d+){0,2})(?:-(codex-spark|codex-mini|codex-max|codex|mini|max|nano))?\b/.exec(modelId);
+	if (!match) {
+		return null;
+	}
+	const version = parseSemVer(match[1]);
+	if (!version) {
+		return null;
+	}
+	return { family: "openai", variant: (match[2] as OpenAIVariant | undefined) ?? "base", version };
+});
+
+/**
+ * Parse a GLM (Zhipu / Z.AI) model id into family + variant + vision + version.
+ * Shape: `glm-<version>[v][-<variant>]` — e.g. `glm-4.5`, `glm-4.5-air`,
+ * `glm-5-turbo`, `glm-4.5v`, `glm-5-preview`. The `v` (vision) attaches to the
+ * version; other variants are `-` suffixes. Standalone like `parseAnthropicModel`
+ * is used in family.ts — GLM needs no global thinking policy, so it stays out of
+ * `parseKnownModel`.
+ */
+export const parseGlmModel = parser((modelId): GlmModel | null => {
+	const match = /glm-(\d{1,2}(?:\.\d+)?)(v)?(?:-(air|turbo|flashx|flash|preview))?\b/.exec(modelId);
+	if (!match) {
+		return null;
+	}
+	const version = parseSemVer(match[1]);
+	if (!version) {
+		return null;
+	}
+	return {
+		family: "glm",
+		variant: (match[3] as GlmVariant | undefined) ?? "base",
+		vision: match[2] === "v",
+		version,
+	};
+});
+
+export function isFableOrMythos(kind: AnthropicKind): boolean {
+	return kind === "fable" || kind === "mythos";
+}
+
+/**
+ * Returns true if the parsed Anthropic model is part of the adaptive-thinking
+ * Claude generation at or above a specific capability threshold.
+ * - Opus has a configurable minimum version floor (e.g. "4.6", "4.7", "4.8").
+ * - Sonnet, Fable, and Mythos all require version 5 or higher.
+ */
+export function isAnthropicAdaptiveGenAtLeast(parsed: AnthropicModel, opusMin: "4.6" | "4.7" | "4.8"): boolean {
+	if (parsed.kind === "opus") {
+		return semverGte(parsed.version, opusMin);
+	}
+	// Sonnet 5+, Fable 5+, Mythos 5+, and any future gen-5+ models
+	return semverGte(parsed.version, "5");
+}
+
+function createSemVer(major: number, minor: number, patch = 0): SemVer {
+	return { major, minor, patch };
+}
+
+// extend this table if we need anything more than 9.10
+const precomputeTable: Record<string, SemVer> = {};
+for (let major = 0; major <= 9; major++) {
+	for (let minor = 0; minor <= 10; minor++) {
+		const version = createSemVer(major, minor, 0);
+		precomputeTable[`${major}.${minor}`] = version;
+		precomputeTable[`${major}-${minor}`] = version;
+	}
+	precomputeTable[`${major}`] = createSemVer(major, 0, 0);
+}
+
+export function parseSemVer(version: string): SemVer | null {
+	return precomputeTable[version] ?? null;
+}
+
+export function semverGte(left: SemVer | string, right: SemVer | string): boolean {
+	return compareSemVer(left, right) >= 0;
+}
+
+export function semverEqual(left: SemVer | string, right: SemVer | string): boolean {
+	return compareSemVer(left, right) === 0;
+}
+
+export function compareSemVer(left: SemVer | string | null, right: SemVer | string | null): number {
+	left = typeof left === "string" ? parseSemVer(left) : left;
+	right = typeof right === "string" ? parseSemVer(right) : right;
+	if (!left || !right) return (left ? 1 : 0) - (right ? 1 : 0);
+
+	if (left.major !== right.major) {
+		return left.major - right.major;
+	}
+	if (left.minor !== right.minor) {
+		return left.minor - right.minor;
+	}
+	return left.patch - right.patch;
+}