@rigelbuild/omp-catalog 18.0.3

package/src/effort.ts

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

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,178 @@
+/**
+ * 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", "alibaba-token-plan"],
+		urlMarkers: ["dashscope", "token-plan."],
+	},
+	umans: { providers: ["umans"], urlMarkers: ["api.code.umans.ai"] },
+	xiaomi: { providers: ["xiaomi"], providerPrefixes: ["xiaomi-token-plan-"], urlMarkers: ["xiaomimimo.com"] },
+	xai: { providers: ["xai", "xai-oauth"], urlMarkers: ["api.x.ai"] },
+	mistral: { providers: ["mistral"], urlMarkers: ["mistral.ai"] },
+	together: { providers: ["together"], urlMarkers: ["api.together.xyz"] },
+	baseten: { providers: ["baseten"], urlMarkers: ["baseten.co"] },
+	/** 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"] },
+	/** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+	venice: { providers: ["venice"], urlMarkers: ["api.venice.ai"] },
+	moonshotNative: { providers: ["moonshot", "kimi-code"], urlMarkers: ["api.moonshot.ai", "api.kimi.com"] },
+	/** Google AI Studio's OpenAI-compatible shim (`/v1beta/openai`) — a subset of chat-completions; rejects `store` with a 400. Native Gemini uses `google-generative-ai` api instead. */
+	googleAistudio: { providers: [], urlMarkers: ["generativelanguage.googleapis.com"] },
+	opencode: { providers: ["opencode-go", "opencode-zen"], urlMarkers: ["opencode.ai"] },
+	/** ZenMux's Anthropic-compatible proxy (`zenmux.ai/api/anthropic`) forwards to signature-enforcing Anthropic. */
+	zenmux: { providers: ["zenmux"], urlMarkers: ["zenmux.ai"] },
+	chutes: { urlMarkers: ["chutes.ai"] },
+} as const satisfies Record<string, HostClassSpec>;
+
+export type KnownHost = keyof typeof KNOWN_HOSTS;
+
+// Host checks fan out across every compatibility field for a model. Bound the
+// cache because custom providers may contribute arbitrary endpoints at runtime.
+const MAX_URL_HOST_MATCHES = 512;
+const urlHostMatches = new Map<string, Map<KnownHost, boolean>>();
+
+function getUrlHostMatches(baseUrl: string): Map<KnownHost, boolean> {
+	let matches = urlHostMatches.get(baseUrl);
+	if (matches !== undefined) return matches;
+	if (urlHostMatches.size === MAX_URL_HOST_MATCHES) urlHostMatches.clear();
+	matches = new Map<KnownHost, boolean>();
+	urlHostMatches.set(baseUrl, matches);
+	return matches;
+}
+
+/** 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 matches = getUrlHostMatches(baseUrl);
+	const cached = matches.get(host);
+	if (cached !== undefined) return cached;
+	const spec: HostClassSpec = KNOWN_HOSTS[host];
+	for (const marker of spec.urlMarkers) {
+		if (includesAsciiCaseInsensitive(baseUrl, marker)) {
+			matches.set(host, true);
+			return true;
+		}
+	}
+	matches.set(host, false);
+	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) ---
+
+/**
+ * Hostname for a Vertex AI GenerateContent / rawPredict / OpenAI-compat
+ * request for the given location.
+ *
+ * - `global` → global endpoint (`aiplatform.googleapis.com`)
+ * - `eu` / `us` multi-regions → REP endpoints (`aiplatform.{eu|us}.rep.googleapis.com`)
+ * - every other location → regional (`{location}-aiplatform.googleapis.com`)
+ *
+ * Multi-region codes do NOT follow the regional `{location}-aiplatform` pattern;
+ * interpolating them that way yields hosts like `eu-aiplatform.googleapis.com`
+ * that 404.
+ */
+export function resolveVertexEndpointHost(location: string): string {
+	if (location === "global") return "aiplatform.googleapis.com";
+	if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`;
+	return `${location}-aiplatform.googleapis.com`;
+}
+
+/** 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,242 @@
+/**
+ * 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 kindFirst = /claude-(opus|sonnet|fable|mythos)-(\d{1,2}(?:[.-]\d{1,2}){0,2})\b/.exec(modelId);
+	const versionFirst = kindFirst
+		? null
+		: /claude-(\d{1,2}(?:[.-]\d{1,2}){0,2})-(opus|sonnet|fable|mythos)\b/.exec(modelId);
+	const kind = kindFirst?.[1] ?? versionFirst?.[2];
+	const versionInput = kindFirst?.[2] ?? versionFirst?.[1];
+	if (!kind || !versionInput) {
+		return null;
+	}
+	const version = parseSemVer(versionInput);
+	if (!version) {
+		return null;
+	}
+	return { family: "anthropic", kind: kind as AnthropicKind, version };
+});
+
+/**
+ * Rolling OpenAI aliases inherit wire capabilities from their current default
+ * snapshots. Keep this map aligned with the model docs when an alias advances.
+ */
+const OPENAI_ALIAS_VERSIONS: Readonly<Record<string, string>> = {
+	"daybreak-blue-latest": "5.6",
+	"gpt-daybreak-blue-latest": "5.6",
+	"daybreak-red-latest": "5.6",
+	"gpt-daybreak-red-latest": "5.6",
+};
+
+export const parseOpenAIModel = parser((modelId): OpenAIModel | null => {
+	const aliasVersion = OPENAI_ALIAS_VERSIONS[modelId];
+	const match = aliasVersion
+		? null
+		: /gpt-(\d+(?:\.\d+){0,2})(?:-(codex-spark|codex-mini|codex-max|codex|mini|max|nano))?\b/.exec(modelId);
+	const versionInput = aliasVersion ?? match?.[1];
+	if (!versionInput) {
+		return null;
+	}
+	const version = parseSemVer(versionInput);
+	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/i.exec(modelId);
+	if (!match) {
+		return null;
+	}
+	const version = parseSemVer(match[1]);
+	if (!version) {
+		return null;
+	}
+	return {
+		family: "glm",
+		variant: (match[3]?.toLowerCase() as GlmVariant | undefined) ?? "base",
+		vision: match[2]?.toLowerCase() === "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 };
+}
+
+// Fast path for the common 1–2 component versions; anything the table misses
+// (large minors, 3-part versions) parses dynamically below so no future
+// version ever classifies as unknown (the failure class #8256 fixed).
+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);
+}
+
+const SEMVER_PATTERN = /^(\d{1,2})(?:[.-](\d{1,2}))?(?:[.-](\d{1,2}))?$/;
+
+export function parseSemVer(version: string): SemVer | null {
+	const hit = precomputeTable[version];
+	if (hit) return hit;
+	const match = SEMVER_PATTERN.exec(version);
+	if (!match) return null;
+	return createSemVer(Number(match[1]), Number(match[2] ?? 0), Number(match[3] ?? 0));
+}
+
+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;
+}

package/src/identity/dialect.ts

@@ -0,0 +1,42 @@
+import { modelFamilyToken } from "./family";
+
+export type Dialect =
+	| "glm"
+	| "hermes"
+	| "kimi"
+	| "xml"
+	| "anthropic"
+	| "deepseek"
+	| "harmony"
+	| "qwen3"
+	| "gemini"
+	| "gemma"
+	| "minimax";
+
+export const FALLBACK_DIALECT: Dialect = "xml";
+
+export function preferredDialect(modelId: string): Dialect {
+	switch (modelFamilyToken(modelId)) {
+		case "anthropic":
+			return "anthropic";
+		case "glm":
+			return "glm";
+		case "gemini":
+			return "gemini";
+		case "gemma":
+			return "gemma";
+		case "kimi":
+			return "kimi";
+		case "qwen":
+			return "qwen3";
+		case "deepseek":
+			return "deepseek";
+		case "minimax":
+			return "minimax";
+		case "openai":
+		case "gpt-oss":
+			return "harmony";
+		default:
+			return FALLBACK_DIALECT;
+	}
+}