@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/cursor/src/model-mapper.ts

@@ -1,369 +0,0 @@
-import type { ThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai/compat";
-import { CURSOR_API, CURSOR_API_BASE_URL } from "./config.js";
-import rawFallbackModels from "./cursor-models-raw.json" with { type: "json" };
-import { positiveIntOrUndefined, resolveCursorModelReferenceLimits, type CursorModelReferenceCandidate } from "./model-reference.js";
-
-export type CursorCatalogSource = "live" | "estimated";
-export type CursorEffort = "none" | "low" | "medium" | "high" | "xhigh" | "max" | "default";
-
-export interface CursorUsableModel {
-	readonly id: string;
-	readonly name?: string;
-	readonly displayName?: string;
-	readonly contextWindow?: number;
-	readonly maxTokens?: number;
-	readonly supportsReasoning?: boolean;
-	readonly supportsThinking?: boolean;
-}
-
-export interface CursorModelCatalog {
-	readonly source: CursorCatalogSource;
-	readonly fetchedAt: number;
-	readonly note?: string;
-	readonly models: readonly CursorUsableModel[];
-}
-
-export type CursorModelInput = ["text"] | ["text", "image"];
-
-export interface CursorProviderModelDefinition {
-	readonly id: string;
-	readonly name: string;
-	readonly api?: string;
-	readonly baseUrl?: string;
-	readonly reasoning: boolean;
-	readonly thinkingLevelMap?: ThinkingLevelMap;
-	readonly input: CursorModelInput;
-	readonly cost: { readonly input: number; readonly output: number; readonly cacheRead: number; readonly cacheWrite: number };
-	readonly contextWindow: number;
-	readonly maxTokens: number;
-}
-
-interface CursorVariant {
-	readonly id: string;
-	readonly baseId: string;
-	readonly displayName: string;
-	readonly effort?: CursorEffort;
-	readonly fast: boolean;
-	readonly thinking: boolean;
-	readonly contextWindow?: number;
-	readonly maxTokens?: number;
-	readonly supportsReasoning?: boolean;
-	readonly supportsThinking?: boolean;
-}
-
-interface CursorVariantGroup {
-	readonly baseId: string;
-	readonly primaryId: string;
-	readonly displayName: string;
-	readonly variants: readonly CursorVariant[];
-}
-
-const CURSOR_FALLBACK_RAW_MODELS = rawFallbackModels satisfies readonly CursorUsableModel[];
-const PARSEABLE_EFFORTS: readonly Exclude<CursorEffort, "default">[] = ["none", "low", "medium", "high", "xhigh", "max"];
-const EFFORT_ORDER: readonly CursorEffort[] = ["none", "low", "default", "medium", "high", "xhigh", "max"];
-const THINKING_LEVELS: readonly ThinkingLevel[] = ["minimal", "low", "medium", "high", "xhigh", "max"];
-const THINKING_LEVEL_EFFORT_PREFERENCES: Record<ThinkingLevel, readonly CursorEffort[]> = {
-	minimal: ["none", "low", "default"],
-	low: ["low", "none", "default"],
-	medium: ["medium", "default", "low"],
-	high: ["high", "medium", "default"],
-	xhigh: ["max", "xhigh"],
-	max: ["max"],
-};
-
-const ESTIMATED_CONTEXT_WINDOW = 200_000;
-const ESTIMATED_MAX_TOKENS = 64_000;
-
-export function createEstimatedCursorCatalog(now = Date.now()): CursorModelCatalog {
-	return {
-		source: "estimated",
-		fetchedAt: now,
-		note: "static fallback; Cursor private API metadata and limits are estimated; token costs are reported as zero for subscription usage",
-		models: CURSOR_FALLBACK_RAW_MODELS.map((model) => ({
-			...model,
-			supportsReasoning: supportsReasoningModelId(model.id),
-			...(model.id.endsWith("-thinking") || model.id.includes("-thinking-") ? { supportsThinking: true } : {}),
-		})),
-	};
-}
-
-export function mapCursorCatalogToProviderModels(catalog: CursorModelCatalog): CursorProviderModelDefinition[] {
-	const groups = groupCursorModels(catalog.models);
-	const familyReferenceVariants = cursorReferenceVariantsByBaseId(groups);
-	return groups.map((group) => {
-		const effortVariants = collectEffortVariants(group.variants, group.primaryId);
-		const supportsEffort = group.variants.some((variant) => Boolean(variant.effort)) || effortVariants.size >= 2;
-		const supportsReasoning = supportsReasoningModelId(group.primaryId);
-		const name = catalog.source === "estimated" ? `${group.displayName} (estimated)` : group.displayName;
-		// Cursor's private API omits token limits, so when neither a live nor a
-		// static explicit limit is present, derive the window/output from the
-		// bundled pi-ai model catalog before falling back to a conservative
-		// estimate. This never changes which models are registered. One-million
-		// labels are tracked across fast/thinking sibling groups for the same
-		// family so Cursor's mode suffixes do not hide the advertised long window.
-		const referenceLimits = resolveCursorModelReferenceLimits(cursorModelReferenceCandidates(group, familyReferenceVariants.get(group.baseId) ?? []));
-		return {
-			id: group.primaryId,
-			name,
-			api: CURSOR_API,
-			baseUrl: CURSOR_API_BASE_URL,
-			reasoning: supportsReasoning,
-			thinkingLevelMap: supportsEffort ? buildCursorThinkingLevelMap(group, effortVariants) : undefined,
-			input: cursorModelInput(group.primaryId),
-			cost: subscriptionCost(),
-			contextWindow: positiveIntLimit(chooseLargestNumber(group.variants.map((variant) => variant.contextWindow)) ?? referenceLimits.contextWindow, ESTIMATED_CONTEXT_WINDOW),
-			maxTokens: positiveIntLimit(chooseLargestNumber(group.variants.map((variant) => variant.maxTokens)) ?? referenceLimits.maxTokens, ESTIMATED_MAX_TOKENS),
-		};
-	});
-}
-
-function cursorModelReferenceCandidates(group: CursorVariantGroup, familyVariants: readonly CursorVariant[]): CursorModelReferenceCandidate[] {
-	return [
-		{ id: group.primaryId, displayName: group.displayName },
-		...group.variants.map((variant) => ({ id: variant.id, displayName: variant.displayName })),
-		...familyVariants.map((variant) => ({ id: variant.id, displayName: variant.displayName })),
-	];
-}
-
-function cursorReferenceVariantsByBaseId(groups: readonly CursorVariantGroup[]): ReadonlyMap<string, readonly CursorVariant[]> {
-	const variantsByBaseId = new Map<string, CursorVariant[]>();
-	for (const group of groups) {
-		const variants = variantsByBaseId.get(group.baseId) ?? [];
-		variants.push(...group.variants);
-		variantsByBaseId.set(group.baseId, variants);
-	}
-	return variantsByBaseId;
-}
-
-function positiveIntLimit(value: number | undefined, fallback: number): number {
-	// Provider registration rejects non-positive/non-integer windows and would
-	// drop the whole catalog; guarantee a valid positive integer here so limit
-	// values can never affect which Cursor models are listed.
-	return positiveIntOrUndefined(value) ?? fallback;
-}
-
-export function resolveCursorModelVariant(
-	baseModelId: string,
-	thinkingLevelMap: ThinkingLevelMap | undefined,
-	thinkingLevel: ThinkingLevel | undefined,
-): string {
-	if (!thinkingLevelMap) return baseModelId;
-	// With no explicit thinking level, fall back to the `off` default variant.
-	// Effort-only Cursor models have no real base id (Cursor lists only
-	// `gpt-5.5-medium`, never a bare `gpt-5.5`), so sending the synthesized base
-	// id makes Cursor reject the run with `not_found`; the `off` entry carries a
-	// concrete variant id to send instead.
-	const mapped = thinkingLevel ? thinkingLevelMap[thinkingLevel] : thinkingLevelMap.off;
-	if (mapped === null) {
-		const fallbackLevel = nearestSupportedThinkingLevel(thinkingLevelMap, thinkingLevel);
-		return fallbackLevel ? resolveCursorModelVariant(baseModelId, thinkingLevelMap, fallbackLevel) : baseModelId;
-	}
-	if (mapped === undefined || mapped === "default") return baseModelId;
-	if (isCursorEffort(mapped)) return replaceEffortBeforeCursorSuffix(baseModelId, mapped);
-	return mapped;
-}
-
-function nearestSupportedThinkingLevel(
-	thinkingLevelMap: ThinkingLevelMap,
-	thinkingLevel: ThinkingLevel | undefined,
-): ThinkingLevel | undefined {
-	if (!thinkingLevel) return undefined;
-	const requestedIndex = THINKING_LEVELS.indexOf(thinkingLevel);
-	if (requestedIndex === -1) return undefined;
-	for (let index = requestedIndex - 1; index >= 0; index--) {
-		const level = THINKING_LEVELS[index];
-		if (level && thinkingLevelMap[level] !== null && thinkingLevelMap[level] !== undefined) return level;
-	}
-	for (let index = requestedIndex + 1; index < THINKING_LEVELS.length; index++) {
-		const level = THINKING_LEVELS[index];
-		if (level && thinkingLevelMap[level] !== null && thinkingLevelMap[level] !== undefined) return level;
-	}
-	return undefined;
-}
-
-export function insertEffortBeforeCursorSuffix(modelId: string, effort: CursorEffort): string {
-	if (effort === "default") return modelId;
-	let base = modelId;
-	let fast = false;
-	let thinking = false;
-	if (base.endsWith("-fast")) {
-		fast = true;
-		base = base.slice(0, -"-fast".length);
-	}
-	if (base.endsWith("-thinking")) {
-		thinking = true;
-		base = base.slice(0, -"-thinking".length);
-	}
-	return `${base}-${effort}${thinking ? "-thinking" : ""}${fast ? "-fast" : ""}`;
-}
-
-function replaceEffortBeforeCursorSuffix(modelId: string, effort: CursorEffort): string {
-	if (effort === "default") return modelId;
-	const variant = parseCursorVariant({ id: modelId });
-	return `${variant.baseId}-${effort}${variant.thinking ? "-thinking" : ""}${variant.fast ? "-fast" : ""}`;
-}
-
-export function parseCursorVariant(model: CursorUsableModel): CursorVariant {
-	let base = model.id;
-	let fast = false;
-	let thinking = false;
-	if (base.endsWith("-fast")) {
-		fast = true;
-		base = base.slice(0, -"-fast".length);
-	}
-	if (base.endsWith("-thinking")) {
-		thinking = true;
-		base = base.slice(0, -"-thinking".length);
-	}
-	const effort = PARSEABLE_EFFORTS.find((candidate) => base.endsWith(`-${candidate}`));
-	if (effort) {
-		base = base.slice(0, -effort.length - 1);
-	}
-	return {
-		id: model.id,
-		baseId: base,
-		displayName: model.displayName ?? model.name ?? titleCaseModelId(base),
-		effort,
-		fast,
-		thinking,
-		contextWindow: model.contextWindow,
-		maxTokens: model.maxTokens,
-		supportsReasoning: model.supportsReasoning,
-		supportsThinking: model.supportsThinking,
-	};
-}
-
-function groupCursorModels(models: readonly CursorUsableModel[]): CursorVariantGroup[] {
-	const groups = new Map<string, CursorVariant[]>();
-	for (const model of models) {
-		const variant = parseCursorVariant(model);
-		const key = cursorVariantGroupKey(variant);
-		const existing = groups.get(key) ?? [];
-		existing.push(variant);
-		groups.set(key, existing);
-	}
-	return [...groups.values()]
-		.map((variants) => {
-			const baseId = variants[0]?.baseId ?? "cursor";
-			const primaryId = choosePrimaryId(variants, baseId);
-			return {
-				baseId,
-				primaryId,
-				displayName: chooseDisplayName(variants, baseId, primaryId),
-				variants,
-			};
-		})
-		.sort((left, right) => left.primaryId.localeCompare(right.primaryId));
-}
-
-function cursorVariantGroupKey(variant: CursorVariant): string {
-	return `${variant.baseId}|fast=${variant.fast ? "1" : "0"}|thinking=${variant.thinking ? "1" : "0"}`;
-}
-
-function collectEffortVariants(variants: readonly CursorVariant[], primaryId: string): ReadonlyMap<CursorEffort, string> {
-	const byEffort = new Map<CursorEffort, string>();
-	for (const variant of variants) {
-		const effort = variant.effort ?? (variant.id === primaryId || variant.supportsReasoning || variant.supportsThinking || variant.thinking ? "default" : undefined);
-		if (effort && !byEffort.has(effort)) byEffort.set(effort, variant.id);
-	}
-	return byEffort;
-}
-
-function buildCursorThinkingLevelMap(group: CursorVariantGroup, effortVariants: ReadonlyMap<CursorEffort, string>): ThinkingLevelMap {
-	const map = buildThinkingLevelMap(effortVariants, group.primaryId);
-	// When the group has no real base id (every Cursor variant carries an effort
-	// suffix), the synthesized primary id is not a sendable Cursor model. Record
-	// an `off` default so a no-thinking request maps to a concrete variant instead
-	// of the base id, which Cursor would reject with `not_found`. Prefer the
-	// minimal/least-effort variant because `off` means minimum reasoning.
-	const hasRealBaseId = group.variants.some((variant) => variant.id === group.primaryId);
-	if (!hasRealBaseId) {
-		const defaultVariant = map.minimal ?? map.low ?? map.medium ?? map.high ?? map.xhigh ?? map.max ?? null;
-		if (defaultVariant) map.off = defaultVariant;
-	}
-	return map;
-}
-
-function buildThinkingLevelMap(effortVariants: ReadonlyMap<CursorEffort, string>, primaryId: string): ThinkingLevelMap {
-	return {
-		minimal: chooseEffortVariant(effortVariants, THINKING_LEVEL_EFFORT_PREFERENCES.minimal, primaryId),
-		low: chooseEffortVariant(effortVariants, THINKING_LEVEL_EFFORT_PREFERENCES.low, primaryId),
-		medium: chooseEffortVariant(effortVariants, THINKING_LEVEL_EFFORT_PREFERENCES.medium, primaryId),
-		high: chooseEffortVariant(effortVariants, THINKING_LEVEL_EFFORT_PREFERENCES.high, primaryId),
-		// `xhigh` can use Cursor's strongest advertised xhigh/max variant, while
-		// `max` is distinct and must not be synthesized from an xhigh-only group.
-		xhigh: chooseCursorXhighVariant(effortVariants),
-		max: effortVariants.get("max") ?? null,
-	};
-}
-
-function chooseCursorXhighVariant(effortVariants: ReadonlyMap<CursorEffort, string>): string | null {
-	return effortVariants.get("max") ?? effortVariants.get("xhigh") ?? null;
-}
-
-function chooseEffortVariant(effortVariants: ReadonlyMap<CursorEffort, string>, preferences: readonly CursorEffort[], _primaryId: string): string | null {
-	for (const effort of preferences) {
-		const variantId = effortVariants.get(effort);
-		if (variantId) return variantId;
-	}
-	for (const effort of EFFORT_ORDER) {
-		const variantId = effortVariants.get(effort);
-		if (variantId) return variantId;
-	}
-	return null;
-}
-
-function isCursorEffort(value: string): value is CursorEffort {
-	return value === "default" || (PARSEABLE_EFFORTS as readonly string[]).includes(value);
-}
-
-function chooseLargestNumber(values: readonly (number | undefined)[]): number | undefined {
-	// Cursor's private API omits token limits; treat any non-positive value as
-	// bogus so a stray 0/negative never becomes an invalid context window.
-	const positiveValues = values.filter((value): value is number => typeof value === "number" && Number.isFinite(value) && value > 0);
-	return positiveValues.length > 0 ? Math.max(...positiveValues) : undefined;
-}
-
-function choosePrimaryId(variants: readonly CursorVariant[], baseId: string): string {
-	if (variants.some((variant) => variant.effort)) {
-		const representative = variants[0];
-		return `${baseId}${representative?.thinking ? "-thinking" : ""}${representative?.fast ? "-fast" : ""}`;
-	}
-	return variants.find((variant) => variant.id === baseId)?.id ?? variants[0]?.id ?? baseId;
-}
-
-function chooseDisplayName(variants: readonly CursorVariant[], baseId: string, primaryId: string): string {
-	return variants.find((variant) => variant.id === primaryId)?.displayName
-		?? variants.find((variant) => variant.effort === "medium")?.displayName
-		?? variants.find((variant) => !variant.effort)?.displayName
-		?? variants[0]?.displayName
-		?? titleCaseModelId(baseId);
-}
-
-function cursorModelInput(id: string): CursorModelInput {
-	return supportsImageInputModelId(id) ? ["text", "image"] : ["text"];
-}
-
-function supportsImageInputModelId(id: string): boolean {
-	const variant = parseCursorVariant({ id });
-	return variant.baseId === "grok-4.3" || /^(claude|composer|gemini|gpt|kimi)(-|$)/iu.test(variant.baseId);
-}
-
-function supportsReasoningModelId(id: string): boolean {
-	const variant = parseCursorVariant({ id });
-	if (variant.effort || variant.thinking) return true;
-	if (variant.baseId === "default") return true;
-	return /^(claude|composer|gemini|gpt|kimi)(-|$)/iu.test(variant.baseId);
-}
-
-function titleCaseModelId(id: string): string {
-	return id
-		.split(/[-_/]+/u)
-		.filter((part) => part.length > 0)
-		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-		.join(" ");
-}
-
-function subscriptionCost(): { readonly input: number; readonly output: number; readonly cacheRead: number; readonly cacheWrite: number } {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-}

package/dist/builtin/cursor/src/model-reference.ts

@@ -1,282 +0,0 @@
-import { getModels, getProviders } from "@earendil-works/pi-ai/compat";
-
-export interface CursorModelReferenceCandidate {
-	readonly id: string;
-	readonly displayName?: string;
-}
-
-export interface CursorModelReferenceLimits {
-	readonly contextWindow?: number;
-	readonly maxTokens?: number;
-}
-
-export interface CursorModelReferenceCatalogEntry {
-	readonly provider: string;
-	readonly id: string;
-	readonly name: string;
-	readonly contextWindow: number;
-	readonly maxTokens: number;
-}
-
-interface ReferenceModelLimits {
-	readonly provider: string;
-	readonly id: string;
-	readonly name: string;
-	readonly contextWindow: number;
-	readonly maxTokens: number;
-	readonly priority: number;
-}
-
-const ONE_MILLION_MODEL_NAME_CONTEXT_WINDOW = 1_000_000;
-const UNRANKED_PROVIDER_PRIORITY = 10_000;
-const CURSOR_EFFORT_SUFFIXES = ["none", "low", "medium", "high", "xhigh", "max", "default"] as const;
-const CLAUDE_FAMILY_NAMES = new Set(["fable", "haiku", "opus", "sonnet"]);
-
-const REFERENCE_PROVIDER_PRIORITY = new Map<string, number>([
-	["opencode", 0],
-	["opencode-go", 1],
-	["anthropic", 10],
-	["google", 20],
-	["google-vertex", 21],
-	["openai", 30],
-	["openai-codex", 31],
-	["azure-openai-responses", 32],
-	["xai", 40],
-	["moonshotai", 50],
-	["moonshotai-cn", 51],
-	["kimi-coding", 52],
-	["zai", 60],
-	["zai-coding-cn", 61],
-	["openrouter", 100],
-	["vercel-ai-gateway", 101],
-	["cloudflare-ai-gateway", 102],
-	["cloudflare-workers-ai", 103],
-	["github-copilot", 200],
-]);
-
-const EMPTY_REFERENCE_MODEL_INDEX: ReadonlyMap<string, readonly ReferenceModelLimits[]> = new Map();
-let referenceModelIndex: ReadonlyMap<string, readonly ReferenceModelLimits[]> | undefined;
-let referenceModelCatalogOverride: readonly CursorModelReferenceCatalogEntry[] | undefined;
-
-export function setCursorModelReferenceCatalogForTesting(models: readonly CursorModelReferenceCatalogEntry[] | undefined): void {
-	referenceModelCatalogOverride = models;
-	resetCursorModelReferenceIndex();
-}
-
-export function resetCursorModelReferenceIndex(): void {
-	referenceModelIndex = undefined;
-}
-
-export function resolveCursorModelReferenceLimits(candidates: readonly CursorModelReferenceCandidate[]): CursorModelReferenceLimits {
-	// Limit resolution must never affect which Cursor models register. Any failure
-	// (e.g. an unexpected pi-ai catalog shape at runtime) degrades to "no reference
-	// limits" so the caller keeps the model with its estimate.
-	try {
-		const explicitOneMillion = candidates.some((candidate) => hasOneMillionMarker(candidate.id) || hasOneMillionMarker(candidate.displayName ?? ""));
-		const match = findReferenceModel(cursorCandidateAliases(candidates), explicitOneMillion);
-		if (!match) {
-			return explicitOneMillion ? { contextWindow: ONE_MILLION_MODEL_NAME_CONTEXT_WINDOW } : {};
-		}
-		const contextWindow = positiveIntOrUndefined(match.contextWindow);
-		return {
-			contextWindow: explicitOneMillion && contextWindow !== undefined
-				? Math.max(contextWindow, ONE_MILLION_MODEL_NAME_CONTEXT_WINDOW)
-				: contextWindow,
-			maxTokens: positiveIntOrUndefined(match.maxTokens),
-		};
-	} catch {
-		return {};
-	}
-}
-
-export function positiveIntOrUndefined(value: number | undefined): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : undefined;
-}
-
-function findReferenceModel(aliases: readonly string[], preferOneMillion: boolean): ReferenceModelLimits | undefined {
-	const index = getReferenceModelIndex();
-	for (const alias of aliases) {
-		const matches = index.get(alias);
-		if (!matches?.[0]) continue;
-		if (preferOneMillion) {
-			const oneMillionMatch = matches.find((candidate) => candidate.contextWindow >= ONE_MILLION_MODEL_NAME_CONTEXT_WINDOW);
-			if (oneMillionMatch) return oneMillionMatch;
-		}
-		return matches[0];
-	}
-	return undefined;
-}
-
-function getReferenceModelIndex(): ReadonlyMap<string, readonly ReferenceModelLimits[]> {
-	if (referenceModelIndex) return referenceModelIndex;
-	try {
-		const mutableIndex = new Map<string, ReferenceModelLimits[]>();
-		for (const model of getReferenceModels()) {
-			for (const alias of referenceModelAliases(model)) {
-				const existing = mutableIndex.get(alias) ?? [];
-				existing.push(model);
-				mutableIndex.set(alias, existing);
-			}
-		}
-		for (const matches of mutableIndex.values()) {
-			matches.sort(compareReferenceModels);
-		}
-		referenceModelIndex = mutableIndex;
-	} catch {
-		referenceModelIndex = EMPTY_REFERENCE_MODEL_INDEX;
-	}
-	return referenceModelIndex;
-}
-
-function getReferenceModels(): ReferenceModelLimits[] {
-	return referenceModelCatalogOverride
-		? referenceModelCatalogOverride.map((model) => toReferenceModelLimits(model, referenceProviderPriority(model.provider)))
-		: getPiAiReferenceModels();
-}
-
-function getPiAiReferenceModels(): ReferenceModelLimits[] {
-	const models: ReferenceModelLimits[] = [];
-	for (const provider of getProviders()) {
-		const priority = referenceProviderPriority(provider);
-		for (const model of getModels(provider)) {
-			if (!isPositiveFiniteNumber(model.contextWindow) || !isPositiveFiniteNumber(model.maxTokens)) continue;
-			models.push(toReferenceModelLimits(model, priority));
-		}
-	}
-	return models;
-}
-
-function referenceProviderPriority(provider: string): number {
-	return REFERENCE_PROVIDER_PRIORITY.get(provider) ?? UNRANKED_PROVIDER_PRIORITY;
-}
-
-function toReferenceModelLimits(model: CursorModelReferenceCatalogEntry, priority: number): ReferenceModelLimits {
-	return {
-		provider: model.provider,
-		id: model.id,
-		name: model.name,
-		contextWindow: model.contextWindow,
-		maxTokens: model.maxTokens,
-		priority,
-	};
-}
-
-function compareReferenceModels(left: ReferenceModelLimits, right: ReferenceModelLimits): number {
-	return left.priority - right.priority
-		|| left.provider.localeCompare(right.provider)
-		|| left.id.localeCompare(right.id)
-		|| left.name.localeCompare(right.name);
-}
-
-function referenceModelAliases(model: ReferenceModelLimits): string[] {
-	const aliases = new Set<string>();
-	addNormalizedAlias(aliases, model.id);
-	addNormalizedAlias(aliases, lastPathSegment(model.id));
-	addNormalizedAlias(aliases, model.name);
-	addNormalizedAlias(aliases, displayNameTail(model.name));
-	return [...aliases];
-}
-
-function cursorCandidateAliases(candidates: readonly CursorModelReferenceCandidate[]): string[] {
-	// Match strictly on Cursor model IDs, which already carry the family and
-	// version (e.g. `gpt-5.5-high`, `claude-4.6-sonnet-medium`). Cursor display
-	// names are short and generic ("Auto", "Sonnet 4") and would produce false
-	// matches against unrelated pi-ai models, so they are not used as match keys.
-	const aliases = new Set<string>();
-	for (const candidate of candidates) {
-		for (const alias of cursorIdAliases(candidate.id)) {
-			addNormalizedAlias(aliases, alias);
-		}
-	}
-	return [...aliases];
-}
-
-function cursorIdAliases(id: string): string[] {
-	const aliases = new Set<string>([id]);
-	for (const baseAlias of cursorBaseIdAliases(id)) {
-		aliases.add(baseAlias);
-		for (const claudeAlias of cursorClaudeIdAliases(baseAlias)) {
-			aliases.add(claudeAlias);
-		}
-	}
-	return [...aliases];
-}
-
-function cursorBaseIdAliases(id: string): string[] {
-	const aliases = new Set<string>([id]);
-	const withoutModes = stripTrailingCursorModes(id);
-	aliases.add(withoutModes);
-	const withoutEffort = stripTrailingEffort(withoutModes);
-	aliases.add(withoutEffort);
-	for (const alias of [...aliases]) {
-		if (alias.endsWith("-1m")) aliases.add(alias.slice(0, -"-1m".length));
-	}
-	return [...aliases];
-}
-
-function stripTrailingCursorModes(id: string): string {
-	let result = id;
-	let changed = true;
-	while (changed) {
-		changed = false;
-		if (result.endsWith("-fast")) {
-			result = result.slice(0, -"-fast".length);
-			changed = true;
-		}
-		if (result.endsWith("-thinking")) {
-			result = result.slice(0, -"-thinking".length);
-			changed = true;
-		}
-	}
-	return result;
-}
-
-function stripTrailingEffort(id: string): string {
-	for (const effort of CURSOR_EFFORT_SUFFIXES) {
-		const suffix = `-${effort}`;
-		if (id.endsWith(suffix)) return id.slice(0, -suffix.length);
-	}
-	return id;
-}
-
-function cursorClaudeIdAliases(id: string): string[] {
-	const match = /^claude-(\d+(?:[.-]\d+)*)-([a-z]+)(?:$|-)/iu.exec(id);
-	if (!match) return [];
-	const [, version, family] = match;
-	if (!version || !family || !CLAUDE_FAMILY_NAMES.has(family.toLowerCase())) return [];
-	return [`claude-${family.toLowerCase()}-${version.replace(/[.-]/gu, "-")}`];
-}
-
-function addNormalizedAlias(aliases: Set<string>, value: string): void {
-	const normalized = normalizeReferenceKey(value);
-	if (normalized) aliases.add(normalized);
-}
-
-function normalizeReferenceKey(value: string): string | undefined {
-	const normalized = value
-		.normalize("NFKD")
-		.replace(/[\u0300-\u036f]/gu, "")
-		.toLowerCase()
-		.replace(/&/gu, " and ")
-		.replace(/[^a-z0-9]+/gu, " ")
-		.trim();
-	return normalized.length > 0 ? normalized : undefined;
-}
-
-function lastPathSegment(id: string): string {
-	const parts = id.split("/");
-	return parts[parts.length - 1] ?? id;
-}
-
-function displayNameTail(name: string): string {
-	const parts = name.split(":");
-	return parts[parts.length - 1]?.trim() ?? name;
-}
-
-function hasOneMillionMarker(value: string): boolean {
-	return /(?:^|[^a-z0-9])1\s*m(?:$|[^a-z0-9])/iu.test(value);
-}
-
-function isPositiveFiniteNumber(value: number): boolean {
-	return Number.isFinite(value) && value > 0;
-}