@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/cursor-BgOuV7Qf.mjs

@@ -0,0 +1,794 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import "./src-BhinCSpi.mjs";
+import { c as compareRevision, u as parseRevision } from "./cascade-BWjRTD1q.mjs";
+import { t as slugify } from "./slugify-ynYWBIA5.mjs";
+import { L as THINKING_EFFORTS, o as resolveCatalogAxes, s as resolveModelPolicy } from "./id-EJwVLDHE.mjs";
+import { i as datedCost, l as classifyModel, s as parseDatedCostCards } from "./pricing-DusBEhwm.mjs";
+import { i as create, l as toBinary, r as reviewedVariantFamilyId, s as fromBinary, t as collapseVariants } from "./collapse-_nkb2dn7.mjs";
+import { r as toModelSpec } from "./bundled-references-CrQ4dQcT.mjs";
+import { r as getBundledModels } from "./models-DCpDT_im.mjs";
+import { Ar as CURSOR_DEFAULT_BASE_URL, Dr as CURSOR_AVAILABLE_MODELS_PATH, Fr as cursorClientHeaders, Mr as CURSOR_GET_USABLE_MODELS_PATH, ct as GetUsableModelsRequestSchema, jr as CURSOR_GET_DEFAULT_MODEL_PATH, lt as GetUsableModelsResponseSchema, m as AvailableModelsResponseSchema, ot as GetDefaultModelForCliRequestSchema, p as AvailableModelsRequestSchema, st as GetDefaultModelForCliResponseSchema } from "./cursor-proto-BuNTjX3L.mjs";
+import { type } from "@oh-my-pi/omptype";
+import * as http2$1 from "node:http2";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/discovery/cursor.ts
+const DEFAULT_CONTEXT_WINDOW = 2e5;
+const DEFAULT_MAX_TOKENS = 64e3;
+/**
+* `GetUsableModels` carries no context-window field, so the 1M ceiling is
+* recovered from the signals Cursor does send:
+* - display-name labels ("Opus 5 1M", "GPT-5.5 1M High") across families,
+* - natively 1M families Cursor serves unlabeled (Kimi K3, GLM 5.2+),
+* - the max-mode flag on Claude/Gemini ids, whose max-mode ceiling is 1M.
+*/
+const CURSOR_1M_CONTEXT_WINDOW = 1e6;
+const CURSOR_1M_NAME_PATTERN = /\b1m\b/i;
+const OptionalDisplayNameSchema = type("unknown").pipe((raw) => typeof raw === "string" ? raw : void 0);
+const CursorAliasesSchema = type("unknown").pipe((raw) => {
+	if (Array.isArray(raw)) return raw.filter((alias) => typeof alias === "string");
+	return [];
+});
+const CursorModelDetailsSchema = type({
+	modelId: "string",
+	displayName: OptionalDisplayNameSchema.default(void 0),
+	displayNameShort: OptionalDisplayNameSchema.default(void 0),
+	displayModelId: OptionalDisplayNameSchema.default(void 0),
+	aliases: CursorAliasesSchema.default(() => []),
+	"thinkingDetails?": "unknown",
+	maxMode: "boolean = false"
+});
+const CursorModelsInnerSchema = type("unknown[]");
+const ResilientCursorModelsSchema = type("unknown").pipe((raw) => {
+	const out = CursorModelsInnerSchema(raw);
+	return out instanceof type.errors ? [] : out;
+});
+const CursorDecodedResponseSchema = type({ models: ResilientCursorModelsSchema.default(() => []) });
+/**
+* Joins Cursor's account-scoped model RPCs:
+* - `AvailableModels` supplies rich base models, parameter axes, variants,
+*   capabilities, aliases, and cost-multiplier metadata.
+* - `GetUsableModels` supplies the exact legacy wire slugs the account can run.
+* - `GetDefaultModelForCli` identifies the account's current default.
+*
+* Per-token rates come from the reviewed `providers/cursor.kdl` rate card and
+* the bundled rows; discovery only scales them by a variant's declared multiplier.
+*
+* Returns `null` unless at least one model-list RPC (`GetUsableModels` or
+* `AvailableModels`) decoded. A successful empty catalog returns `[]`,
+* preserving model-manager retry and fallback semantics.
+*/
+async function fetchCursorUsableModels(options) {
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const baseUrl = (options.baseUrl ?? "https://api2.cursor.sh").replace(/\/+$/, "");
+	const usableRequest = create(GetUsableModelsRequestSchema, { customModelIds: normalizeCustomModelIds(options.customModelIds) });
+	const availableRequest = create(AvailableModelsRequestSchema, {
+		includeLongContextModels: true,
+		useModelParameters: true,
+		doNotUseMarkdown: true,
+		useCloudAgentEffortModes: true
+	});
+	const defaultRequest = create(GetDefaultModelForCliRequestSchema, {});
+	const [usablePayload, availablePayload, defaultPayload] = await Promise.all([
+		fetchCursorUnary(baseUrl, CURSOR_GET_USABLE_MODELS_PATH, toBinary(GetUsableModelsRequestSchema, usableRequest), options, timeoutMs),
+		fetchCursorUnary(baseUrl, CURSOR_AVAILABLE_MODELS_PATH, toBinary(AvailableModelsRequestSchema, availableRequest), options, Math.min(timeoutMs, 2e3)),
+		fetchCursorUnary(baseUrl, CURSOR_GET_DEFAULT_MODEL_PATH, toBinary(GetDefaultModelForCliRequestSchema, defaultRequest), options, timeoutMs)
+	]);
+	const usable = decodeUnary(GetUsableModelsResponseSchema, usablePayload);
+	const available = decodeUnary(AvailableModelsResponseSchema, availablePayload);
+	if (usable === null && available === null) return null;
+	const defaultModel = decodeUnary(GetDefaultModelForCliResponseSchema, defaultPayload)?.model;
+	const parsedUsable = CursorDecodedResponseSchema(usable);
+	const references = createCursorReferenceMap();
+	const legacyModels = parsedUsable instanceof type.errors ? [] : normalizeCursorModels(parsedUsable.models, options.baseUrl, references);
+	const usableModelIds = usable === null ? void 0 : new Set(legacyModels.map((model) => model.id));
+	if (!available || available.models.length === 0) return legacyModels;
+	const richModels = normalizeRichCursorModels(available.models, usableModelIds, options.baseUrl, references, defaultModel?.modelId, defaultModel?.maxMode);
+	const richCatalogIds = collectRichCursorCatalogIds(available.models);
+	const representedIds = /* @__PURE__ */ new Set();
+	for (const model of richModels) {
+		representedIds.add(model.id);
+		representedIds.add(model.requestModelId ?? model.id);
+		for (const routeId of Object.keys(model.cursorModelRoutes ?? {})) representedIds.add(routeId);
+	}
+	for (const model of legacyModels) if (!representedIds.has(model.id) && !richCatalogIds.has(model.id)) richModels.push(model);
+	return richModels.sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* One unary RPC under a single deadline. HTTP/1.1 fetch goes first; the
+* HTTP/2 Connect retry runs only after a transport-level failure (h2-only
+* endpoints) and only with the remaining budget. An HTTP response of any
+* status, or a deadline abort, is final.
+*/
+async function fetchCursorUnary(baseUrl, path, body, options, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	const signal = AbortSignal.timeout(timeoutMs);
+	let response;
+	try {
+		response = await fetch(new URL(path, baseUrl), {
+			method: "POST",
+			headers: {
+				...cursorClientHeaders(options.apiKey, { clientVersion: options.clientVersion }),
+				"connect-protocol-version": "1",
+				"x-request-id": crypto.randomUUID()
+			},
+			body,
+			signal
+		});
+	} catch {
+		const remainingMs = deadline - Date.now();
+		if (signal.aborted || remainingMs <= 0) return null;
+		return fetchViaHttp2(baseUrl, path, body, options, remainingMs);
+	}
+	if (!response.ok) return null;
+	try {
+		return new Uint8Array(await response.arrayBuffer());
+	} catch {
+		return null;
+	}
+}
+/** HTTP/2 transport used by Cursor's unary protobuf RPCs. */
+async function fetchViaHttp2(baseUrl, path, body, options, timeoutMs) {
+	const { promise, resolve } = Promise.withResolvers();
+	const client = http2$1.connect(baseUrl);
+	let settled = false;
+	const finish = (value) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		client.close();
+		resolve(value);
+	};
+	const timer = setTimeout(() => {
+		client.destroy();
+		finish(null);
+	}, timeoutMs);
+	client.on("error", () => finish(null));
+	const req = client.request({
+		":method": "POST",
+		":path": path,
+		te: "trailers",
+		...cursorClientHeaders(options.apiKey, { clientVersion: options.clientVersion }),
+		"connect-protocol-version": "1",
+		"x-request-id": crypto.randomUUID()
+	});
+	const chunks = [];
+	req.on("data", (chunk) => chunks.push(chunk));
+	req.on("end", () => finish(new Uint8Array(Buffer.concat(chunks))));
+	req.on("error", () => finish(null));
+	req.on("response", (headers) => {
+		const status = Number(headers[":status"] ?? 0);
+		if (status < 200 || status >= 300) finish(null);
+	});
+	req.end(Buffer.from(body));
+	return promise;
+}
+function normalizeCustomModelIds(customModelIds) {
+	if (!customModelIds) return [];
+	const normalized = /* @__PURE__ */ new Set();
+	for (const value of customModelIds) {
+		if (typeof value !== "string") continue;
+		const trimmed = value.trim();
+		if (!trimmed) continue;
+		normalized.add(trimmed);
+	}
+	return [...normalized];
+}
+function createCursorReferenceMap() {
+	const references = /* @__PURE__ */ new Map();
+	for (const model of getBundledModels("cursor")) references.set(model.id, toModelSpec(model));
+	return references;
+}
+function decodeUnary(schema, payload) {
+	if (payload === null) return null;
+	const body = decodeConnectUnaryBody(payload) ?? payload;
+	try {
+		return fromBinary(schema, body);
+	} catch {
+		return null;
+	}
+}
+function decodeConnectUnaryBody(payload) {
+	if (payload.length < 5) return null;
+	let offset = 0;
+	while (offset + 5 <= payload.length) {
+		const flags = payload[offset];
+		const messageLength = new DataView(payload.buffer, payload.byteOffset + offset, payload.byteLength - offset).getUint32(1, false);
+		const frameEnd = offset + 5 + messageLength;
+		if (frameEnd > payload.length) return null;
+		if ((flags & 1) !== 0) return null;
+		if (!((flags & 2) !== 0)) return payload.subarray(offset + 5, frameEnd);
+		offset = frameEnd;
+	}
+	return null;
+}
+function isCursorKimiK3(id) {
+	const identity = classifyModel("cursor", id, { lenient: true });
+	return identity.class === "kimi" && identity.family === "k3";
+}
+function isCursorVersionedGrok(id) {
+	const identity = classifyModel("cursor", id, { lenient: true });
+	if (identity.class !== "xai" || identity.revision === void 0) return false;
+	const revision = parseRevision(identity.revision);
+	const floor = parseRevision("4");
+	return revision !== void 0 && floor !== void 0 && compareRevision(revision, floor) >= 0;
+}
+function isCursorGlm52CodingModel(id) {
+	const identity = classifyModel("cursor", id, { lenient: true });
+	if (identity.class !== "glm" || identity.revision === void 0) return false;
+	if (identity.family !== void 0 && identity.family !== "air" && identity.family !== "turbo") return false;
+	const revision = parseRevision(identity.revision);
+	const floor = parseRevision("5.2");
+	return revision !== void 0 && floor !== void 0 && compareRevision(revision, floor) >= 0;
+}
+function collectRichCursorCatalogIds(models) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const details of models) {
+		const baseId = details.name.trim();
+		if (baseId) ids.add(baseId);
+		for (const id of [...details.legacySlugs, ...details.idAliases]) if (id.trim()) ids.add(id.trim());
+		for (const [index, variant] of details.variants.entries()) {
+			const parameterSuffix = variant.parameterValues.map((parameter) => ({
+				id: parameter.id.trim(),
+				value: parameter.value.trim()
+			})).filter((parameter) => parameter.id.length > 0).map((parameter) => `${parameter.id}=${parameter.value}`).join(",");
+			const id = variant.legacySlug?.trim() || variant.variantStringRepresentation?.trim() || (parameterSuffix ? `${baseId}@${parameterSuffix}` : `${baseId}@variant-${index + 1}`);
+			if (id) ids.add(id);
+		}
+	}
+	return ids;
+}
+const CURSOR_REASONING_PARAMETER_IDS = /* @__PURE__ */ new Set([
+	"effort",
+	"reasoning",
+	"reasoning_effort",
+	"thinking",
+	"thinking_effort"
+]);
+/** The declared definition value a variant parameter selects, when Cursor defines one. */
+function cursorParameterValue(details, parameter) {
+	const definition = details.parameterDefinitions.find((candidate) => candidate.id === parameter.id);
+	if (!definition) return void 0;
+	const booleanValue = definition.parameterType?.booleanParameter?.values.find((candidate) => candidate.value === parameter.value);
+	const enumValue = definition.parameterType?.enumParameter?.values.find((candidate) => candidate.value === parameter.value);
+	const selected = booleanValue ?? enumValue;
+	if (!selected) return void 0;
+	return {
+		increasesModelCost: selected.increasesModelCost,
+		markdownTooltip: enumValue?.markdownTooltip,
+		definitionTooltip: definition.markdownTooltip
+	};
+}
+function cursorVariantCostMultiplier(details, entry) {
+	let multiplier = 1;
+	for (const parameter of entry.parameters) {
+		const selected = cursorParameterValue(details, parameter);
+		if (selected?.increasesModelCost !== true) continue;
+		for (const description of [selected.markdownTooltip, selected.definitionTooltip]) {
+			const match = description ? /\b(\d+(?:\.\d+)?)\s*[x×](?![a-z])/i.exec(description) : void 0;
+			if (!match?.[1]) continue;
+			const parameterMultiplier = Number(match[1]);
+			if (Number.isFinite(parameterMultiplier) && parameterMultiplier > 0) {
+				multiplier *= parameterMultiplier;
+				break;
+			}
+		}
+	}
+	return multiplier;
+}
+function scaleTokenCost(cost, multiplier) {
+	if (multiplier === 1) return cost;
+	const scale = (card) => ({
+		...card,
+		input: card.input * multiplier,
+		output: card.output * multiplier,
+		cacheRead: card.cacheRead * multiplier,
+		cacheWrite: card.cacheWrite * multiplier
+	});
+	const effectiveRates = cost.timeBased?.effectiveRates;
+	return {
+		...scale({
+			input: cost.input,
+			output: cost.output,
+			cacheRead: cost.cacheRead,
+			cacheWrite: cost.cacheWrite
+		}),
+		...cost.timeBased && { timeBased: {
+			...cost.timeBased,
+			...effectiveRates && { effectiveRates: effectiveRates.map(scale) }
+		} }
+	};
+}
+/**
+* Price a rich variant from the reviewed `providers/cursor.kdl` rate card,
+* which keys on Cursor wire slugs (`claude-opus-4-8-high`, `gpt-5.4`). Cursor
+* bills per price class — the values of the model's cost-bearing parameters
+* (`fast`, `context`) — not per effort or thinking toggle, so every slug in
+* the variant's own class shares its price. The lane id leads the own-class
+* slugs: `buildModel` later resolves the same card by lane id, so a lane-keyed
+* `cost-patch` must win here too or the two would disagree. Multiplier rule:
+* - `cost-patch` on an own-class slug is that class's reviewed price and is
+*   final, even for fast classes (`claude-opus-4-7-high-fast` $30/$150);
+* - `cost-fallback` rows, and any base-class slug or the model name, carry the
+*   base card, scaled by the declared multiplier (`cursorVariantCostMultiplier`).
+*/
+function resolveRichCursorCardCost(details, entry, laneId) {
+	const costAxes = details.parameterDefinitions.filter((definition) => [...definition.parameterType?.booleanParameter?.values ?? [], ...definition.parameterType?.enumParameter?.values ?? []].some((value) => value.increasesModelCost === true)).map((definition) => definition.id);
+	const priceClass = (parameters) => costAxes.map((id) => parameters.find((parameter) => parameter.id === id)?.value ?? "").join("\0");
+	const entryClass = priceClass(entry.parameters);
+	const ownSlugs = [laneId, entry.id];
+	const baseSlugs = [details.name.trim()];
+	for (const variant of details.variants) {
+		const slug = variant.legacySlug?.trim();
+		if (!slug) continue;
+		const parameters = variant.parameterValues.map((parameter) => ({
+			id: parameter.id.trim(),
+			value: parameter.value.trim()
+		}));
+		if (priceClass(parameters) === entryClass) ownSlugs.push(slug);
+		else if (!parameters.some((parameter) => cursorParameterValue(details, parameter)?.increasesModelCost === true)) baseSlugs.push(slug);
+	}
+	let base;
+	for (const slug of ownSlugs) {
+		const card = resolveCursorCardAxes(slug);
+		if (card.patch) return card.patch;
+		base ??= card.fallback;
+	}
+	for (const slug of baseSlugs) {
+		if (base) break;
+		const card = resolveCursorCardAxes(slug);
+		base = card.patch ?? card.fallback;
+	}
+	return base && scaleTokenCost(base, cursorVariantCostMultiplier(details, entry));
+}
+function resolveCursorCardAxes(slug) {
+	const axes = resolveCatalogAxes({
+		id: slug,
+		name: slug,
+		api: "cursor-agent",
+		provider: "cursor",
+		baseUrl: CURSOR_DEFAULT_BASE_URL,
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS
+	});
+	const card = (payload, axis) => {
+		if (typeof payload !== "object" || payload === null) return void 0;
+		const field = (key) => {
+			const value = Reflect.get(payload, key);
+			return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+		};
+		const input = field("input");
+		const output = field("output");
+		if (input === void 0 || output === void 0) return void 0;
+		return datedCost({
+			input,
+			output,
+			cacheRead: field("cacheRead") ?? 0,
+			cacheWrite: field("cacheWrite") ?? 0
+		}, parseDatedCostCards(payload, axis));
+	};
+	return {
+		patch: card(axes.costPatch, "cost-patch"),
+		fallback: card(axes.costFallback, "cost-fallback")
+	};
+}
+function normalizeRichCursorModels(models, usableModelIds, baseUrlOverride, references, defaultModelId, defaultMaxMode) {
+	const normalized = [];
+	for (const details of models) {
+		const baseId = details.name.trim();
+		if (!baseId || details.supportsAgent === false || details.isChatOnly === true) continue;
+		if (details.requiresDataRetention === true) continue;
+		const variants = normalizeRichCursorVariants(details, baseId, usableModelIds);
+		if (variants.length === 0) continue;
+		const defaultRank = (entry) => entry.variant?.isDefaultNonMaxConfig === true ? 0 : entry.variant?.isDefaultMaxConfig === true ? 1 : 2;
+		const parameterDefaults = /* @__PURE__ */ new Map();
+		for (const entry of variants.toSorted((left, right) => defaultRank(left) - defaultRank(right))) for (const parameter of cursorLaneParameters(entry.parameters)) if (!parameterDefaults.has(parameter.id)) parameterDefaults.set(parameter.id, parameter.value);
+		const lanes = /* @__PURE__ */ new Map();
+		for (const entry of variants) {
+			const dimensions = cursorLaneParameters(entry.parameters);
+			const key = JSON.stringify([dimensions, entry.variant?.isMaxMode === true]);
+			const lane = lanes.get(key);
+			if (lane) lane.push(entry);
+			else lanes.set(key, [entry]);
+		}
+		const claimedLaneIds = /* @__PURE__ */ new Set();
+		for (const entries of lanes.values()) {
+			const first = entries[0];
+			if (!first) continue;
+			const richLaneId = cursorLaneId(baseId, cursorLaneParameters(first.parameters), parameterDefaults, first.variant?.isMaxMode === true, claimedLaneIds);
+			const laneName = cursorLaneName(details, richLaneId, baseId);
+			const laneId = reviewedCursorLaneId(entries, claimedLaneIds) ?? richLaneId;
+			normalized.push(...buildRichCursorLane(details, entries, laneId, laneName, baseUrlOverride, references, defaultModelId, defaultMaxMode));
+		}
+	}
+	return normalized.sort((a, b) => a.id.localeCompare(b.id));
+}
+function normalizeRichCursorVariants(details, baseId, usableModelIds) {
+	if (details.variants.length === 0) {
+		const candidates = [
+			baseId,
+			...details.legacySlugs,
+			...details.idAliases
+		];
+		if (usableModelIds !== void 0 && !candidates.some((id) => usableModelIds.has(id))) return [];
+		return [{
+			id: baseId,
+			parameters: [],
+			variant: void 0,
+			effort: void 0
+		}];
+	}
+	const variants = [];
+	const seenRoutes = /* @__PURE__ */ new Set();
+	for (const [index, variant] of details.variants.entries()) {
+		if (isRichVariantBlocked(details, variant)) continue;
+		const parameters = variant.parameterValues.map((parameter) => ({
+			id: parameter.id.trim(),
+			value: parameter.value.trim()
+		})).filter((parameter) => parameter.id.length > 0);
+		const parameterSuffix = parameters.map((parameter) => `${parameter.id}=${parameter.value}`).join(",");
+		const id = variant.legacySlug?.trim() || variant.variantStringRepresentation?.trim() || (parameterSuffix ? `${baseId}@${parameterSuffix}` : `${baseId}@variant-${index + 1}`);
+		const entitlementIds = [
+			variant.legacySlug?.trim(),
+			id,
+			baseId,
+			...details.idAliases
+		].filter((candidate) => Boolean(candidate));
+		if (usableModelIds !== void 0 && !entitlementIds.some((candidate) => usableModelIds.has(candidate))) continue;
+		const routeSignature = `${parameterSuffix}\u0000${variant.isMaxMode === true ? "max" : "standard"}`;
+		if (seenRoutes.has(routeSignature)) continue;
+		seenRoutes.add(routeSignature);
+		variants.push({
+			id,
+			parameters,
+			variant,
+			effort: cursorVariantEffort(parameters)
+		});
+	}
+	return variants;
+}
+function cursorVariantEffort(parameters) {
+	const thinking = parameters.find((parameter) => parameter.id === "thinking")?.value.toLowerCase();
+	if (thinking === "false" || thinking === "off" || thinking === "none") return "off";
+	const rawEffort = parameters.find((parameter) => [
+		"reasoning",
+		"reasoning_effort",
+		"thinking_effort",
+		"effort"
+	].includes(parameter.id))?.value;
+	if (rawEffort === void 0) return void 0;
+	const normalized = rawEffort.toLowerCase().replace(/[_\s]+/g, "-");
+	if (normalized === "none" || normalized === "off" || normalized === "disabled") return "off";
+	if (normalized === "minimal" || normalized === "low" || normalized === "medium" || normalized === "high" || normalized === "xhigh" || normalized === "max") return normalized;
+	if (normalized === "extra-high") return "xhigh";
+}
+function cursorLaneParameters(parameters) {
+	return parameters.filter((parameter) => !CURSOR_REASONING_PARAMETER_IDS.has(parameter.id));
+}
+function cursorLaneId(baseId, parameters, defaults, isMaxMode, claimed) {
+	const suffixes = [];
+	for (const parameter of parameters) {
+		const id = slugify(parameter.id);
+		const value = slugify(parameter.value);
+		if (!id || !value || parameter.value === "false") continue;
+		if (parameter.value === "true") suffixes.push(id);
+		else if (parameter.value === defaults.get(parameter.id)) continue;
+		else if (parameter.id === "context") suffixes.push(value);
+		else suffixes.push(`${id}-${value}`);
+	}
+	const root = [baseId, ...suffixes].join("-");
+	let candidate = root;
+	if (claimed.has(candidate)) candidate = `${root}-${isMaxMode ? "max-mode" : "standard"}`;
+	let duplicate = 2;
+	while (claimed.has(candidate)) {
+		candidate = `${root}-${duplicate}`;
+		duplicate += 1;
+	}
+	claimed.add(candidate);
+	return candidate;
+}
+/**
+* The reviewed collapse family owning a lane's legacy slugs, when exactly one
+* family claims any of them (slugs no family lists, e.g. a newly added tier,
+* stay in the lane). `AvailableModels` names Grok 4.5/4.6 `grok-4.6` while its
+* slugs are `cursor-grok-4.6-*`; reusing the family id keeps the lane id equal
+* to the `GetUsableModels`-only fallback and the bundled catalog, so a selector
+* survives whichever RPC answered.
+*/
+function reviewedCursorLaneId(entries, claimed) {
+	let familyId;
+	for (const entry of entries) {
+		const slug = entry.variant?.legacySlug?.trim();
+		const owner = slug ? reviewedVariantFamilyId("cursor", slug) : void 0;
+		if (owner === void 0) continue;
+		if (familyId !== void 0 && owner !== familyId) return void 0;
+		familyId = owner;
+	}
+	if (familyId === void 0 || claimed.has(familyId)) return void 0;
+	claimed.add(familyId);
+	return familyId;
+}
+function cursorLaneName(details, laneId, baseId) {
+	const baseName = details.clientDisplayName?.trim() || details.serverModelName?.trim() || details.name.trim() || baseId;
+	const suffix = laneId.slice(baseId.length).replace(/^-/, "").split("-").filter(Boolean).map((part) => part === "1m" ? "1M" : part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+	return suffix ? `${baseName} ${suffix}` : baseName;
+}
+function buildRichCursorLane(details, entries, laneId, laneName, baseUrlOverride, references, defaultModelId, defaultMaxMode) {
+	const isThinkingToggle = (entry) => entry.effort === void 0 && entry.parameters.some((parameter) => parameter.id === "thinking" && parameter.value.toLowerCase() === "true");
+	const selectedByEffort = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const slot = entry.effort ?? (isThinkingToggle(entry) ? "thinking" : "fixed");
+		const current = selectedByEffort.get(slot);
+		if (current === void 0 || cursorVariantPreference(details, entry, defaultModelId, defaultMaxMode) > cursorVariantPreference(details, current, defaultModelId, defaultMaxMode)) selectedByEffort.set(slot, entry);
+	}
+	const selected = [...selectedByEffort.values()];
+	if (selected.length === 0) return [];
+	const routeKeys = /* @__PURE__ */ new Map();
+	const usedRouteKeys = /* @__PURE__ */ new Set();
+	const routes = {};
+	for (const entry of selected) {
+		let routeKey = entry.id;
+		if (usedRouteKeys.has(routeKey)) routeKey = entry.variant?.variantStringRepresentation?.trim() || `${entry.id}@${entry.parameters.map((parameter) => `${parameter.id}=${parameter.value}`).join(",")}`;
+		let duplicate = 2;
+		const root = routeKey;
+		while (usedRouteKeys.has(routeKey)) {
+			routeKey = `${root}#${duplicate}`;
+			duplicate += 1;
+		}
+		usedRouteKeys.add(routeKey);
+		routeKeys.set(entry, routeKey);
+		routes[routeKey] = {
+			modelId: details.name.trim(),
+			parameters: entry.parameters,
+			...entry.variant?.isMaxMode === void 0 ? void 0 : { maxMode: entry.variant.isMaxMode }
+		};
+	}
+	const members = [];
+	const routing = {};
+	let defaultMember;
+	let thinkingToggleMember;
+	for (const entry of selected) {
+		const routeKey = routeKeys.get(entry);
+		if (!routeKey) continue;
+		const variant = entry.variant;
+		const reference = references.get(entry.id) ?? references.get(details.name.trim()) ?? details.legacySlugs.map((id) => references.get(id)).find((candidate) => candidate !== void 0);
+		const isMaxMode = variant?.isMaxMode ?? false;
+		const contextParameter = entry.parameters.find((parameter) => parameter.id === "context")?.value;
+		const discoveredContextWindow = parseCursorContextWindow(contextParameter) ?? (isMaxMode ? details.contextTokenLimitForMaxMode : details.contextTokenLimit) ?? details.autoContextExtendedMaxTokens ?? details.autoContextMaxTokens;
+		const fallbackContext = reference?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
+		const input = details.supportsImages === void 0 ? resolveCursorInput(entry.id, reference?.input) : details.supportsImages ? ["text", "image"] : ["text"];
+		const isProviderDefault = isCursorProviderDefault(details, entry, defaultModelId, defaultMaxMode);
+		const reasoning = entry.effort === "off" ? false : entry.effort !== void 0 || isThinkingToggle(entry) ? true : details.supportsThinking ?? reference?.reasoning ?? false;
+		const referenceCost = reference && (reference.cost.input !== 0 || reference.cost.output !== 0) ? reference === references.get(entry.id) ? reference.cost : scaleTokenCost(reference.cost, cursorVariantCostMultiplier(details, entry)) : void 0;
+		const cost = resolveRichCursorCardCost(details, entry, laneId) ?? referenceCost ?? {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		};
+		members.push({
+			...reference ?? {
+				id: routeKey,
+				name: laneName,
+				api: "cursor-agent",
+				provider: "cursor",
+				baseUrl: baseUrlOverride ?? "https://api2.cursor.sh",
+				reasoning,
+				input,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0
+				},
+				contextWindow: fallbackContext,
+				maxTokens: DEFAULT_MAX_TOKENS
+			},
+			id: routeKey,
+			name: laneName,
+			baseUrl: baseUrlOverride ?? reference?.baseUrl ?? "https://api2.cursor.sh",
+			reasoning,
+			input,
+			cost,
+			supportsTools: details.supportsAgent ?? reference?.supportsTools,
+			contextWindow: discoveredContextWindow ?? fallbackContext,
+			cursorMaxMode: isMaxMode,
+			cursorModelParameters: entry.parameters,
+			cursorModelRoutes: routes,
+			cursorPrice: details.price,
+			cursorRequiresDataRetention: details.requiresDataRetention,
+			cursorSupportsAgent: details.supportsAgent,
+			cursorSupportsSandboxing: details.supportsSandboxing,
+			isRecommended: isProviderDefault || details.defaultOn,
+			description: variant?.tagline ?? details.tagline ?? cursorTooltipBlurb(variant?.tooltipData?.markdownContent) ?? cursorTooltipBlurb(details.tooltipData?.markdownContent) ?? reference?.description
+		});
+		if (entry.effort !== void 0) routing[entry.effort] = routeKey;
+		else if (isThinkingToggle(entry)) thinkingToggleMember = members.at(-1);
+		if (isProviderDefault) defaultMember = routeKey;
+	}
+	if (members.length === 0) return [];
+	const toggleEfforts = [];
+	if (thinkingToggleMember) {
+		const { compat: _compat, ...policySpec } = thinkingToggleMember;
+		const surfaceEfforts = thinkingToggleMember.thinking?.efforts.length ? thinkingToggleMember.thinking.efforts : resolveModelPolicy({
+			...policySpec,
+			reasoning: true,
+			thinking: void 0
+		}).thinking?.efforts ?? [];
+		for (const effort of surfaceEfforts) {
+			if (routing[effort] !== void 0) continue;
+			routing[effort] = thinkingToggleMember.id;
+			toggleEfforts.push(effort);
+		}
+	}
+	defaultMember ??= selected.filter((entry) => entry.variant?.isDefaultNonMaxConfig === true || entry.variant?.isDefaultMaxConfig === true).map((entry) => routeKeys.get(entry)).find((routeKey) => routeKey !== void 0);
+	defaultMember ??= routing.off ?? members[0]?.id;
+	const efforts = THINKING_EFFORTS.filter((effort) => routing[effort] !== void 0);
+	const family = {
+		id: laneId,
+		name: laneName,
+		members: members.map((member) => member.id),
+		routing,
+		...defaultMember === void 0 ? void 0 : { defaultMember },
+		...efforts.length === 0 ? void 0 : { thinking: {
+			mode: "effort",
+			efforts,
+			...routing.off === void 0 ? { requiresEffort: true } : {},
+			...defaultMember === void 0 || toggleEfforts.length > 0 ? void 0 : { defaultLevel: efforts.find((effort) => routing[effort] === defaultMember) }
+		} }
+	};
+	return collapseVariants(members, { table: { families: [family] } });
+}
+/**
+* The one-line model blurb from Cursor's IDE tooltip. The tooltip is HTML for
+* Cursor's editor (`<br />` separators, a bold title, context/effort lines,
+* styled warning spans); the model's prose sentence is the second segment.
+* Context and effort are already separate model fields, so the rest is dropped.
+*/
+function cursorTooltipBlurb(markdown) {
+	if (!markdown) return void 0;
+	const segments = markdown.split(/<br\s*\/?>/i).map((segment) => segment.replace(/<[^>]+>/g, "").replace(/[*_`]/g, "").trim()).filter((segment) => segment.length > 0);
+	return segments[1] ?? segments[0];
+}
+function cursorVariantPreference(details, entry, defaultModelId, defaultMaxMode) {
+	if (isCursorProviderDefault(details, entry, defaultModelId, defaultMaxMode)) return 3;
+	if (entry.variant?.isDefaultNonMaxConfig === true || entry.variant?.isDefaultMaxConfig === true) return 2;
+	return 1;
+}
+function isCursorProviderDefault(details, entry, defaultModelId, defaultMaxMode) {
+	const variant = entry.variant;
+	if (defaultModelId !== void 0) {
+		if (defaultModelId === entry.id) return defaultMaxMode === void 0 || defaultMaxMode === (variant?.isMaxMode ?? false);
+		if (defaultModelId !== details.name && !details.legacySlugs.includes(defaultModelId) && !details.idAliases.includes(defaultModelId)) return false;
+		if (variant === void 0) return true;
+		return defaultMaxMode === true ? variant.isDefaultMaxConfig === true : variant.isDefaultNonMaxConfig === true;
+	}
+	if (!details.defaultOn) return false;
+	return variant === void 0 || variant.isDefaultNonMaxConfig === true || variant.isDefaultMaxConfig === true;
+}
+function parseCursorContextWindow(value) {
+	if (!value) return void 0;
+	const match = /^(\d+(?:\.\d+)?)([km])?$/i.exec(value.trim());
+	if (!match?.[1]) return void 0;
+	const amount = Number(match[1]);
+	if (!Number.isFinite(amount) || amount <= 0) return void 0;
+	const unit = match[2]?.toLowerCase();
+	return Math.round(amount * (unit === "m" ? 1e6 : unit === "k" ? 1e3 : 1));
+}
+function isRichVariantBlocked(details, variant) {
+	for (const parameter of variant.parameterValues) {
+		const definition = details.parameterDefinitions.find((candidate) => candidate.id === parameter.id);
+		if ([...definition?.parameterType?.booleanParameter?.values ?? [], ...definition?.parameterType?.enumParameter?.values ?? []].find((candidate) => candidate.value === parameter.value)?.blockedByAdminAllowlist === true) return true;
+	}
+	return false;
+}
+function normalizeCursorModels(models, baseUrlOverride, references) {
+	if (!models || models.length === 0) return [];
+	const byId = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const normalized = normalizeCursorModel(model, baseUrlOverride, references);
+		if (!normalized) continue;
+		byId.set(normalized.id, normalized);
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function normalizeCursorModel(model, baseUrlOverride, references) {
+	const parsedModel = CursorModelDetailsSchema(model);
+	if (parsedModel instanceof type.errors) return null;
+	const details = parsedModel;
+	const id = details.modelId.trim();
+	if (!id) return null;
+	const name = pickModelDisplayName(details, id);
+	const reference = references.get(id);
+	const reasoning = isCursorKimiK3(id) || isCursorVersionedGrok(id) || Boolean(details.thinkingDetails) || reference?.reasoning === true;
+	if (reference) return {
+		...reference,
+		id,
+		name,
+		baseUrl: baseUrlOverride ?? reference.baseUrl,
+		reasoning,
+		input: resolveCursorInput(id, reference.input),
+		contextWindow: resolveCursorContextWindow(details, id, reference.contextWindow),
+		cursorMaxMode: details.maxMode
+	};
+	return {
+		id,
+		name,
+		api: "cursor-agent",
+		provider: "cursor",
+		baseUrl: baseUrlOverride ?? "https://api2.cursor.sh",
+		reasoning,
+		input: resolveCursorInput(id),
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: resolveCursorContextWindow(details, id, DEFAULT_CONTEXT_WINDOW),
+		maxTokens: DEFAULT_MAX_TOKENS,
+		cursorMaxMode: details.maxMode
+	};
+}
+/**
+* Context window for a discovered Cursor model: the 1M ceiling when any 1M
+* signal fires (never below a larger bundled reference), else the fallback.
+*/
+function resolveCursorContextWindow(model, id, fallback) {
+	const labeled1M = CURSOR_1M_NAME_PATTERN.test(id) || [
+		model.displayName,
+		model.displayNameShort,
+		model.displayModelId,
+		...model.aliases
+	].some((candidate) => typeof candidate === "string" && CURSOR_1M_NAME_PATTERN.test(candidate));
+	const identity = classifyModel("cursor", id, { lenient: true });
+	const maxMode1M = model.maxMode && (identity.class === "anthropic" || identity.class === "gemini");
+	if (labeled1M || isCursorNative1MModelId(id) || maxMode1M) return Math.max(fallback ?? 0, CURSOR_1M_CONTEXT_WINDOW);
+	return fallback;
+}
+/**
+* Natively 1M-context families Cursor serves without a "1M" label: GLM 5.2+
+* base/air/turbo coding SKUs (structured family and revision gates exclude
+* vision and sub-1M variants). K3 — including Cursor's bare `k3` alias — is
+* rule-owned via `context-window-floor` in `providers/cursor.kdl`.
+*/
+function isCursorNative1MModelId(id) {
+	return isCursorGlm52CodingModel(id);
+}
+function pickModelDisplayName(model, fallbackId) {
+	const candidates = [
+		model.displayName,
+		model.displayNameShort,
+		model.displayModelId,
+		...model.aliases,
+		fallbackId
+	];
+	for (const candidate of candidates) {
+		if (typeof candidate !== "string") continue;
+		const trimmed = candidate.trim();
+		if (trimmed) return trimmed;
+	}
+	return fallbackId;
+}
+/**
+* Resolves input modalities from a bundled reference when available. The
+* Cursor-verified families (K3, grok-4, composer-2.5) are rule-owned via
+* `input-modalities` in `providers/cursor.kdl` and corrected at build time.
+* Without a reference, families whose native catalogs are multimodal
+* (anthropic, gemini, openai) fall back to id classification.
+*/
+function resolveCursorInput(id, referenceInput) {
+	if (referenceInput) return referenceInput;
+	const identity = classifyModel("cursor", id, { lenient: true });
+	if (identity.class === "anthropic" || identity.class === "gemini" || identity.class === "openai") return ["text", "image"];
+	return ["text"];
+}
+//#endregion
+export { fetchCursorUsableModels, resolveCursorInput };