@cherrystudio/provider-registry 0.0.0-stage → 0.1.0

package/dist/bundled-providers.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bundled_providers = require("./bundled-providers-BZisTfNC.cjs");
+exports.bundledProviders = require_bundled_providers.bundledProviders;

package/dist/bundled-providers.d.cts

@@ -0,0 +1,5 @@
+import { r as RegistryCatalog } from "./registry-Di5ULW6Z.cjs";
+//#region src/bundled-providers.d.ts
+declare const bundledProviders: RegistryCatalog['providers'];
+//#endregion
+export { bundledProviders };

package/dist/bundled-providers.d.mts

@@ -0,0 +1,5 @@
+import { r as RegistryCatalog } from "./registry-BjETdicx.mjs";
+//#region src/bundled-providers.d.ts
+declare const bundledProviders: RegistryCatalog['providers'];
+//#endregion
+export { bundledProviders };

package/dist/bundled-providers.mjs

@@ -0,0 +1,2 @@
+import { t as bundledProviders } from "./bundled-providers-BiPpU5W4.mjs";
+export { bundledProviders };

package/dist/catalog-DElG_l-8.mjs

@@ -0,0 +1,369 @@
+import * as z from "zod";
+//#region src/utils/normalize.ts
+/**
+* Model ID normalization utilities.
+*
+* Extracted from base-transformer.ts so that both the importer pipeline
+* and the runtime registry lookup can share the same logic without
+* pulling in the entire importer dependency tree.
+*/
+const COMMON_AGGREGATOR_PREFIXES = [
+	"aihubmix-",
+	"aihub-",
+	"ahm-",
+	"alicloud-",
+	"azure-",
+	"baidu-",
+	"cbs-",
+	"cc-",
+	"sf-",
+	"s-",
+	"bai-",
+	"web-",
+	"deepinfra-",
+	"groq-",
+	"nvidia-",
+	"sophnet-",
+	"zai-org-",
+	"zai-",
+	"lucidquery-",
+	"lucidnova-",
+	"lucid-",
+	"siliconflow-",
+	"chutes-",
+	"huoshan-",
+	"meta-",
+	"cohere-",
+	"coding-",
+	"dmxapi-",
+	"perplexity-",
+	"ai21-",
+	"openai-",
+	"dmxapi_",
+	"aistudio_"
+];
+const PREFIX_EXPANSIONS = [["mm-", "minimax-"]];
+const COLON_VARIANT_SUFFIXES = [
+	":free",
+	":nitro",
+	":extended",
+	":beta",
+	":preview",
+	":thinking",
+	":exacto",
+	":latest",
+	":cloud"
+];
+const HYPHEN_VARIANT_SUFFIXES = [
+	"-free",
+	"-search",
+	"-online",
+	"-think",
+	"-reasoning",
+	"-classic",
+	"-low",
+	"-high",
+	"-minimal",
+	"-nothink",
+	"-no-think",
+	"-ssvip",
+	"-thinking",
+	"-nothinking",
+	"-aliyun",
+	"-huoshan",
+	"-tee",
+	"-cc",
+	"-fw",
+	"-di",
+	"-t",
+	"-reverse"
+];
+const PAREN_VARIANT_SUFFIXES = [
+	"(free)",
+	"(beta)",
+	"(preview)",
+	"(thinking)"
+];
+const PROTECTED_COMPOUND_PREFIXES = [
+	"non",
+	"no",
+	"pre",
+	"anti",
+	"post"
+];
+const PARAMETER_SIZE_PATTERN = /-(\d+(?:\.\d+)?b)(?=-|$)/i;
+const COLON_VARIANT_TAG_PATTERN = /^(?:\d+(?:[.x]\d+)*b(?:$|[-.])|q\d|iq\d|fp16|bf16|f16)/i;
+const QUANTIZATION_SUFFIXES = [
+	"-fp8",
+	"-fp16",
+	"-bf16",
+	"-awq",
+	"-int4",
+	"-int8",
+	"-gguf",
+	"-gptq"
+];
+const DATE_SNAPSHOT_PATTERN = /-20\d{2}-(?:0[1-9]|1[0-2])-(?:[0-2]\d|3[01])$|-20\d{2}(?:0[1-9]|1[0-2])(?:[0-2]\d|3[01])$|-2\d(?:0[1-9]|1[0-2])(?:[0-2]\d|3[01])$|-(?:0[1-9]|1[0-2])(?:[0-2]\d|3[01])$|-2\d(?:0[1-9]|1[0-2])$/;
+const BEDROCK_VENDOR = "anthropic|amazon|meta|google|mistralai|cohere|openai|ai21|microsoft|nvidia";
+const BEDROCK_VENDOR_DOTTED = new RegExp(`^(?:[a-z]+\\.)*(?:${`${BEDROCK_VENDOR}|deepseek|minimax|mistral|moonshot|moonshotai|qwen|writer|xai|zai`})\\.`);
+const BEDROCK_VENDOR_DASH = new RegExp(`^(?:${BEDROCK_VENDOR})-{1,2}`);
+const BEDROCK_REVISION_PATTERN = /(?:[-_]v?\d+)?:\d+$/i;
+function stripAggregatorPrefixes(modelId, additionalPrefixes = []) {
+	const allPrefixes = [...additionalPrefixes, ...COMMON_AGGREGATOR_PREFIXES];
+	let result = modelId;
+	for (const prefix of allPrefixes) if (result.startsWith(prefix)) {
+		result = result.slice(prefix.length);
+		break;
+	}
+	return result;
+}
+/**
+* Strip a Bedrock cross-vendor ARN's leading vendor prefix: region(s)+vendor dotted segments
+* (`us.anthropic.claude-…` → `claude-…`) then a vendor dash prefix (`meta-llama-…` → `llama-…`).
+* The final dotted segment must be a known Bedrock vendor, so native dotted model ids such as
+* `flux.2-pro` and versions such as `qwen3.7` are never touched.
+*/
+function stripBedrockVendorPrefix(modelId) {
+	return stripBedrockDottedVendorPrefix(modelId).replace(BEDROCK_VENDOR_DASH, "");
+}
+/**
+* The dotted half of {@link stripBedrockVendorPrefix} (`us.anthropic.claude-…` → `claude-…`), split out
+* so display-name derivation can tell how much of a raw id normalization folded away and keep the
+* prefix as a distinguishing decoration (`MiniMax.MiniMax-M2.1` vs the bare `MiniMax-M2.1`).
+*/
+function stripBedrockDottedVendorPrefix(modelId) {
+	return modelId.replace(BEDROCK_VENDOR_DOTTED, "");
+}
+/** Strip a Bedrock ARN model revision: `claude-…-v1:0` / `…:0` → bare id (keeps `whisper-v3`, no colon). */
+function stripBedrockRevision(modelId) {
+	return modelId.replace(BEDROCK_REVISION_PATTERN, "");
+}
+function expandKnownPrefixes(modelId) {
+	for (const [abbrev, canonical] of PREFIX_EXPANSIONS) if (modelId.startsWith(abbrev)) return canonical + modelId.slice(abbrev.length);
+	return modelId;
+}
+function stripVariantSuffixes(modelId, options = {}) {
+	const colonSuffixes = options.colonSuffixes ?? COLON_VARIANT_SUFFIXES;
+	const hyphenSuffixes = options.hyphenSuffixes ?? HYPHEN_VARIANT_SUFFIXES;
+	const parenSuffixes = options.parenSuffixes ?? PAREN_VARIANT_SUFFIXES;
+	if ((options.officialModelsWithSuffix ?? /* @__PURE__ */ new Set()).has(modelId)) return modelId;
+	const colonIdx = modelId.lastIndexOf(":");
+	if (colonIdx > 0) {
+		const suffix = modelId.slice(colonIdx);
+		if (colonSuffixes.includes(suffix)) return modelId.slice(0, colonIdx);
+	}
+	for (const suffix of hyphenSuffixes) if (modelId.endsWith(suffix)) {
+		const remaining = modelId.slice(0, -suffix.length);
+		if (PROTECTED_COMPOUND_PREFIXES.some((p) => remaining === p || remaining.endsWith(`-${p}`))) continue;
+		return remaining;
+	}
+	for (const suffix of parenSuffixes) if (modelId.endsWith(suffix)) {
+		let result = modelId.slice(0, -suffix.length);
+		if (result.endsWith(" ")) result = result.slice(0, -1);
+		return result;
+	}
+	return modelId;
+}
+function normalizeVersionSeparators(modelId) {
+	return modelId.replace(/(\d)[,._p](?=\d)/g, "$1-");
+}
+function stripQuantization(modelId) {
+	for (const suffix of QUANTIZATION_SUFFIXES) if (modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
+	return modelId;
+}
+function stripDateSnapshot(modelId) {
+	return modelId.replace(/@.*$/, "").replace(DATE_SNAPSHOT_PATTERN, "");
+}
+/**
+* Iterate variant → quantization → date stripping to a fixpoint. A single pass is order-dependent —
+* a trailing date shields an inner variant from the `endsWith` check (`…-thinking-2507` only exposes
+* `-thinking` after the date is gone) — so without the loop canonicalization is not idempotent.
+* SHARED by the build canonicalizer (`scripts/canonicalize.ts`) and the runtime resolver below.
+*/
+function stripVariantQuantDateSuffixes(modelId) {
+	let result = modelId;
+	for (;;) {
+		const next = stripDateSnapshot(stripQuantization(stripVariantSuffixes(result)));
+		if (next === result) return result;
+		result = next;
+	}
+}
+function extractParameterSize(modelId) {
+	const match = modelId.match(PARAMETER_SIZE_PATTERN);
+	return match ? match[1].toLowerCase() : void 0;
+}
+function stripParameterSize(modelId) {
+	return modelId.replace(PARAMETER_SIZE_PATTERN, "");
+}
+/**
+* Realign a registry-tag colon size/quant tag to the catalog's hyphen spelling: `gpt-oss:20b` →
+* `gpt-oss-20b`, `qwen2.5:7b` → `qwen2.5-7b`. Only a size/quant LEADER is realigned (see
+* COLON_VARIANT_TAG_PATTERN), so a word tag (`:free`) or a Bedrock revision (`:0`) is returned unchanged.
+* This keeps the SIZE inside the id so a size-preserving match can tell a `:20b` pull apart from its
+* `120b` sibling, instead of both collapsing to the bare family name.
+*/
+function colonVariantTagToHyphen(modelId) {
+	const colonIdx = modelId.lastIndexOf(":");
+	if (colonIdx > 0 && COLON_VARIANT_TAG_PATTERN.test(modelId.slice(colonIdx + 1))) return `${modelId.slice(0, colonIdx)}-${modelId.slice(colonIdx + 1)}`;
+	return modelId;
+}
+/**
+* Normalize a model ID to its canonical form.
+* This is the single source of truth for model ID normalization.
+*
+* `keepParameterSize` produces the SIZE-PRESERVING key: the parameter size is realigned from any colon
+* tag and kept (not stripped), so `qwen2.5:7b` → `qwen2-5-7b` and `gpt-oss-20b`/`gpt-oss-120b` stay
+* distinct. The registry loader indexes on this to resolve a registry-tagged id to its exact-size row
+* before the default (size-agnostic) key would collapse it onto a same-family sibling.
+*/
+function normalizeModelId(modelId, options = {}) {
+	const parts = modelId.split("/");
+	let baseName = parts[parts.length - 1].toLowerCase();
+	baseName = stripAggregatorPrefixes(baseName);
+	baseName = stripBedrockVendorPrefix(baseName);
+	baseName = stripBedrockRevision(baseName);
+	baseName = expandKnownPrefixes(baseName);
+	if (options.keepParameterSize) baseName = colonVariantTagToHyphen(baseName);
+	for (;;) {
+		const stripped = stripVariantQuantDateSuffixes(baseName);
+		const next = options.keepParameterSize ? stripped : stripParameterSize(stripped);
+		if (next === baseName) break;
+		baseName = next;
+	}
+	baseName = normalizeVersionSeparators(baseName);
+	baseName = baseName.replace(/_/g, "-");
+	return baseName;
+}
+//#endregion
+//#region src/registry-index.ts
+var ModelIndex = class {
+	constructor(models) {
+		this.modelById = /* @__PURE__ */ new Map();
+		this.modelByNormId = /* @__PURE__ */ new Map();
+		this.modelBySizedNorm = /* @__PURE__ */ new Map();
+		for (const m of models) {
+			this.modelById.set(m.id, m);
+			const nid = normalizeModelId(m.id);
+			if (!this.modelByNormId.has(nid)) this.modelByNormId.set(nid, m);
+			const sid = normalizeModelId(m.id, { keepParameterSize: true });
+			if (!this.modelBySizedNorm.has(sid)) this.modelBySizedNorm.set(sid, m);
+		}
+	}
+	findModel(modelId) {
+		const exact = this.modelById.get(modelId);
+		if (exact) return exact;
+		if (colonVariantTagToHyphen(modelId) !== modelId) return this.modelBySizedNorm.get(normalizeModelId(modelId, { keepParameterSize: true })) ?? null;
+		const sizedModelId = normalizeModelId(modelId, { keepParameterSize: true });
+		const sizedHit = this.modelBySizedNorm.get(sizedModelId);
+		if (sizedHit) return sizedHit;
+		if (extractParameterSize(sizedModelId)) return null;
+		return this.modelByNormId.get(normalizeModelId(modelId)) ?? null;
+	}
+};
+var ProviderModelIndex = class {
+	constructor(overrides) {
+		this.overrideByKey = /* @__PURE__ */ new Map();
+		this.overrideByNormKey = /* @__PURE__ */ new Map();
+		this.overrideBySizedNormKey = /* @__PURE__ */ new Map();
+		this.overrideByApiKey = /* @__PURE__ */ new Map();
+		this.overrideByNormApiKey = /* @__PURE__ */ new Map();
+		this.overrideBySizedNormApiKey = /* @__PURE__ */ new Map();
+		this.overridesByProvider = /* @__PURE__ */ new Map();
+		for (const pm of overrides) {
+			const key = `${pm.providerId}::${pm.modelId}`;
+			if (!this.overrideByKey.has(key) || pm.apiModelId === pm.modelId) this.overrideByKey.set(key, pm);
+			const normKey = `${pm.providerId}::${normalizeModelId(pm.modelId)}`;
+			if (!this.overrideByNormKey.has(normKey)) this.overrideByNormKey.set(normKey, pm);
+			const sizedNormKey = `${pm.providerId}::${normalizeModelId(pm.modelId, { keepParameterSize: true })}`;
+			if (!this.overrideBySizedNormKey.has(sizedNormKey) || pm.apiModelId === pm.modelId) this.overrideBySizedNormKey.set(sizedNormKey, pm);
+			if (pm.apiModelId) {
+				const apiKey = `${pm.providerId}::${pm.apiModelId}`;
+				this.overrideByApiKey.set(apiKey, pm);
+				const normApiKey = `${pm.providerId}::${normalizeModelId(pm.apiModelId)}`;
+				if (!this.overrideByNormApiKey.has(normApiKey)) this.overrideByNormApiKey.set(normApiKey, pm);
+				const sizedNormApiKey = `${pm.providerId}::${normalizeModelId(pm.apiModelId, { keepParameterSize: true })}`;
+				if (!this.overrideBySizedNormApiKey.has(sizedNormApiKey)) this.overrideBySizedNormApiKey.set(sizedNormApiKey, pm);
+			}
+			let arr = this.overridesByProvider.get(pm.providerId);
+			if (!arr) {
+				arr = [];
+				this.overridesByProvider.set(pm.providerId, arr);
+			}
+			arr.push(pm);
+		}
+	}
+	findOverride(providerId, modelId) {
+		const key = `${providerId}::${modelId}`;
+		const exact = this.overrideByKey.get(key) ?? this.overrideByApiKey.get(key);
+		if (exact) return exact;
+		const sizedModelId = normalizeModelId(modelId, { keepParameterSize: true });
+		const sizedNormKey = `${providerId}::${sizedModelId}`;
+		const sizedHit = this.overrideBySizedNormKey.get(sizedNormKey) ?? this.overrideBySizedNormApiKey.get(sizedNormKey);
+		if (sizedHit) return sizedHit;
+		if (extractParameterSize(sizedModelId)) return null;
+		const normKey = `${providerId}::${normalizeModelId(modelId)}`;
+		return this.overrideByNormKey.get(normKey) ?? this.overrideByNormApiKey.get(normKey) ?? null;
+	}
+	getOverridesForProvider(providerId) {
+		return this.overridesByProvider.get(providerId) ?? [];
+	}
+};
+//#endregion
+//#region src/catalog.ts
+/**
+* Schema-compatibility version of the registry JSON contract.
+*
+* The remote updater fetches from a `v{REGISTRY_SCHEMA_VERSION}/` path and the
+* sync CI publishes to the matching dir, so an app only ever receives data its
+* bundled schema can parse. The sync CI derives its publish dir from this
+* constant (single source of truth).
+*
+* Bump on ANY change older clients cannot parse. Since v2 that is a narrow set:
+* the schemas drop what they do not recognize instead of failing the document
+* (`schemas/forwardCompat.ts`), so **enum-vocabulary growth no longer bumps** —
+* a new modality / capability / effort is dropped by v2 clients and honored by
+* newer ones. New optional fields were always safe (`z.object` strips unknown
+* keys). Structural changes (field rename / retype / required-field removal)
+* still bump. New runtime wire behavior also gets a new stream when it requires
+* raising {@link REGISTRY_MIN_APP_VERSION}, so older streams keep their existing
+* version floor and continue receiving compatible catalog updates.
+*/
+const REGISTRY_SCHEMA_VERSION = 3;
+/**
+* Oldest application version whose runtime understands the semantic values in
+* the current remote catalog. Bump when data starts using a new adapter family,
+* endpoint type, wire behavior, or other value that older runtime code cannot execute.
+*/
+const REGISTRY_MIN_APP_VERSION = "2.1.4";
+/**
+* The three JSON data files this package emits (`packages/provider-registry/data/`).
+* The canonical definition of what a full catalog consists of — consumed by the
+* app's loader-path resolution and by the remote updater's fetch loop.
+*/
+const REGISTRY_FILES = [
+	"models.json",
+	"providers.json",
+	"provider-models.json"
+];
+/** Unsigned branch data permitted to shadow the bundle. Provider routing stays bundled. */
+const REMOTE_REGISTRY_FILES = ["models.json", "provider-models.json"];
+/**
+* Manifest published alongside each `v{N}/` catalog set (written last as the
+* completion marker). Consumed by the app's remote updater — to validate a
+* downloaded manifest and to gate a persisted override — so both parse against
+* this one schema instead of hand-rolled checks.
+*/
+const CatalogManifestSchema = z.object({
+	/** Oldest app whose runtime can interpret this catalog's semantic values. */
+	minAppVersion: z.string().min(1),
+	/** Latest released bundle this snapshot is known to be at least as new as. */
+	sourceAppVersion: z.string().min(1),
+	/** Monotonic workflow revision; clients never replace an active snapshot with an older/equal revision. */
+	revision: z.number().int().nonnegative(),
+	/** Schema version the set targets; must equal {@link REGISTRY_SCHEMA_VERSION} to be usable. */
+	schemaVersion: z.number().int(),
+	/** filename → content-hash `version`, binding the set to one published snapshot. */
+	files: z.record(z.string(), z.string())
+});
+//#endregion
+export { REMOTE_REGISTRY_FILES as a, normalizeModelId as c, stripDateSnapshot as d, stripVariantQuantDateSuffixes as f, REGISTRY_SCHEMA_VERSION as i, stripBedrockDottedVendorPrefix as l, REGISTRY_FILES as n, ModelIndex as o, REGISTRY_MIN_APP_VERSION as r, ProviderModelIndex as s, CatalogManifestSchema as t, stripBedrockRevision as u };