{
+ try {
+ const { getPricingForModel } = await import("@/lib/db/settings");
+ const db = await getPricingForModel(provider, model);
+ const input = Number((db as { input?: unknown } | null)?.input);
+ const output = Number((db as { output?: unknown } | null)?.output);
+ if (Number.isFinite(input) && input >= 0) {
+ const out = Number.isFinite(output) && output >= 0 ? output : input;
+ // Same thresholds as the sync path below; a DB $0 lands FREE by threshold
+ // (the DB carries no isFree flag of its own).
+ let tier: ProviderTier;
+ if (input <= currentConfig.defaults.freeThreshold) tier = PROVIDER_TIER.FREE;
+ else if (input <= currentConfig.defaults.cheapThreshold) tier = PROVIDER_TIER.CHEAP;
+ else tier = PROVIDER_TIER.PREMIUM;
+ const sync = getModelPricing(provider, model); // keeps freeQuotaLimit when DB is mute
+ const assignment: TierAssignment = {
+ provider,
+ model,
+ tier,
+ reason: `DB cost-based: $${input}/M input`,
+ costPer1MInput: input,
+ costPer1MOutput: out,
+ hasFreeTier: input === 0,
+ freeQuotaLimit: sync.freeQuotaLimit,
+ };
+ tierCache.set(cacheKey(provider, model), assignment);
+ return assignment;
+ }
+ } catch {
+ // fall through to sync
+ }
+ tierAsyncFallbackTotal++;
+ return classifyTier(provider, model);
+}
diff --git a/package.json b/package.json
index 5cbcf71b42b..e8f33893543 100644
--- a/package.json
+++ b/package.json
@@ -181,6 +181,7 @@
"check:model-lifecycle": "node --import tsx/esm scripts/check/check-model-lifecycle.mjs",
"check:provider-consistency": "bun scripts/check/check-provider-consistency.ts",
"check:provider-assets": "node scripts/check/check-provider-assets.mjs",
+ "check:provider-order-sync": "node scripts/check/check-provider-order-sync.mjs",
"check:provider-asset-provenance": "node scripts/check/check-provider-asset-provenance.mjs",
"check:nvidia-catalog-drift": "node --import tsx/esm scripts/check/check-nvidia-catalog-drift.ts",
"check:fetch-targets": "node scripts/check/check-fetch-targets.mjs",
@@ -264,6 +265,7 @@
"coverage:report": "cross-env NODE_OPTIONS=--max-old-space-size=8192 c8 report --merge-async --output-dir coverage --exclude=tests/** --exclude=**/*.test.* --reporter=text --reporter=text-summary --reporter=html --reporter=json-summary --reporter=lcov",
"coverage:summary": "node scripts/check/test-report-summary.mjs --input coverage/coverage-summary.json --output coverage/coverage-report.md",
"check:pr-test-policy": "node scripts/check/check-pr-test-policy.mjs",
+ "check:pricing-freshness": "node scripts/check/check-pricing-freshness.mjs",
"coverage:report:legacy": "c8 report --output-dir coverage --exclude=open-sse --reporter=text --reporter=text-summary",
"test:all": "npm run test:unit && npm run test:vitest && npm run test:vitest:ui && npm run test:ecosystem && npm run test:e2e",
"check": "npm run lint && npm run test",
diff --git a/scripts/check/check-docs-counts-sync.mjs b/scripts/check/check-docs-counts-sync.mjs
index 4e74d304647..116d33bcc6e 100644
--- a/scripts/check/check-docs-counts-sync.mjs
+++ b/scripts/check/check-docs-counts-sync.mjs
@@ -185,6 +185,9 @@ export function tallyDrift(checks, getContent) {
function readCodeFacts() {
const script = [
'import {computeFreeModelTotals,FREE_MODEL_BUDGETS} from "./open-sse/config/freeModelCatalog.ts";',
+ 'import {FREE_TIER_PROVIDER_SET} from "./open-sse/config/freeTierProviders.ts";',
+ 'import {generateProviderPluginManifest} from "./open-sse/config/providerPluginManifestRegistry.ts";',
+ 'import {REGISTRY} from "./open-sse/config/providers/index.ts";',
'import {MODE_PACKS} from "./open-sse/services/autoCombo/modePacks.ts";',
'import {ENGINE_IDS} from "./open-sse/services/compression/engineCatalog.ts";',
'import {CLI_TOOLS} from "./src/shared/constants/cliTools.ts";',
@@ -232,7 +235,10 @@ function readCodeFacts() {
"mcpTools:countUniqueMcpTools(cols),mcpScopes:sc.size,providers:pids.size,freeForever:ff.size,",
"modePacks:Object.keys(MODE_PACKS),",
"hardStop:FREE_MODEL_BUDGETS.filter(e=>e.hardStopGuaranteed===true).length,",
- "trainsOnPrompts:FREE_MODEL_BUDGETS.filter(e=>e.trainsOnPrompts===true).length}));",
+ "trainsOnPrompts:FREE_MODEL_BUDGETS.filter(e=>e.trainsOnPrompts===true).length,",
+ "freeTierCount:FREE_TIER_PROVIDER_SET.size,",
+ "freeTierReg:FREE_TIER_PROVIDER_SET.size-[...FREE_TIER_PROVIDER_SET].filter(x=>!(x in REGISTRY)).length,",
+ 'manifestFreeTier:generateProviderPluginManifest().providers.filter(p=>p.capabilities.includes("free-tier")).length}));',
].join("");
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "docs-counts-"));
try {
@@ -608,6 +614,22 @@ export function buildChecks() {
files: ["docs/routing/AUTO-COMBO.md"],
validate: makeModePackNamesValidator(packs),
},
+ {
+ // Every pack must pin `quality` explicitly (6 pins, 0.02/0.03) so
+ // no pack silently inherits a future DEFAULT. Validates live code,
+ // not docs — the gate loops `files` content through `validate`.
+ label: "mode packs pin quality explicitly (live code)",
+ actual: 6,
+ docKey: "packs quality pins",
+ strict: true,
+ files: ["open-sse/services/autoCombo/modePacks.ts"],
+ validate: (content) => {
+ const pins = (content.match(/^\s*quality:\s*0\.0\d,?\s*$/gm) ?? []).length;
+ return pins >= 6
+ ? { ok: true, detail: `${pins} quality pins` }
+ : { ok: false, detail: `only ${pins} quality pins — every pack must pin quality` };
+ },
+ },
{
label: "Provider reference total (doc vs live modules)",
actual: f.providers,
@@ -616,6 +638,23 @@ export function buildChecks() {
files: ["docs/reference/PROVIDER_REFERENCE.md"],
validate: makeProviderReferenceValidator(f.providers),
},
+ // Gate: manifest emission vs catalogue intersection. Both numbers are
+ // live code facts from the same spawnSync computeur. The catalogue can
+ // name providers the registry does not serve yet (arcee-ai at
+ // 9d1a896c6), so the leaf raw size is informational — the gate
+ // compares the intersected count, never the raw size, and the script
+ // itself always exists so tallyDrift runs validate (skips null only).
+ {
+ label: "Manifest free-tier capability count (live code)",
+ actual: f.manifestFreeTier,
+ docKey: "free-tier capability",
+ strict: true,
+ files: ["scripts/check/check-docs-counts-sync.mjs"],
+ validate: () => ({
+ ok: f.manifestFreeTier === f.freeTierReg,
+ detail: `manifest ${f.manifestFreeTier} vs leaf∩registry ${f.freeTierReg} (leaf ${f.freeTierCount})`,
+ }),
+ },
{
label: "SVG canonical numbers (live code)",
actual:
diff --git a/scripts/check/check-pricing-freshness.mjs b/scripts/check/check-pricing-freshness.mjs
new file mode 100644
index 00000000000..075077d13d7
--- /dev/null
+++ b/scripts/check/check-pricing-freshness.mjs
@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+// STRICT gate: KNOWN_MODEL_PRICING must have been touched within PRICING_STALE_AFTER_DAYS,
+// or tiers silently drift from real prices. Exits 1 on stale, 0 on fresh.
+// Run: node scripts/check/check-pricing-freshness.mjs
+import { execFileSync } from "node:child_process";
+
+const PRICING_STALE_AFTER_DAYS = 90;
+const TARGET = "open-sse/services/providerCostData.ts";
+
+function lastTouchDays() {
+ const out = execFileSync("git", ["log", "--follow", "-1", "--format=%ct", "--", TARGET], {
+ encoding: "utf8",
+ }).trim();
+ const touched = Number(out);
+ if (!Number.isFinite(touched) || touched <= 0) return Infinity;
+ return (Date.now() / 1000 - touched) / 86400;
+}
+
+const days = lastTouchDays();
+if (days > PRICING_STALE_AFTER_DAYS) {
+ console.error(
+ `STALE: ${TARGET} untouched for ${Math.floor(days)}d (> ${PRICING_STALE_AFTER_DAYS}d) — refresh prices or bump the gate with justification`
+ );
+ process.exit(1);
+}
+console.log(`pricing fresh: ${TARGET} touched ${Math.floor(days)}d ago`);
diff --git a/scripts/check/check-provider-order-sync.mjs b/scripts/check/check-provider-order-sync.mjs
new file mode 100644
index 00000000000..303ca4d43f1
--- /dev/null
+++ b/scripts/check/check-provider-order-sync.mjs
@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// Checks the canonical provider order stays single-sourced.
+//
+// STRICT (blocking, exit 1): the order derivation exists exactly once
+// (canonicalProviderOrder.ts); catalogOrder.ts and comboSort.ts re-export it
+// (grep-negative for a local Object.keys(OAUTH derivation); re-export present);
+// the xao alias stays declared under xai-oauth; the unknown-provider contract
+// (?? Infinity + codeUnitCompare) stays live.
+// INFORMATIVE (warn only, always exit 0): dashboard quota ranks in
+// ProviderLimits/constants.ts are a separate display order — a registry id
+// missing there is fine when the provider has no quota surface.
+// Run: node scripts/check/check-provider-order-sync.mjs
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, "..", "..");
+const read = (p) => fs.readFileSync(path.join(ROOT, p), "utf8");
+let failures = 0;
+const fail = (msg) => {
+ failures += 1;
+ console.error(`[provider-order-sync] FAIL ${msg}`);
+};
+
+// 1+2. Leaf uniqueness.
+for (const f of ["src/app/api/v1/models/catalogOrder.ts", "src/lib/combos/comboSort.ts"]) {
+ if (read(f).includes("Object.keys(OAUTH")) {
+ fail(`${f} defines its own order derivation (import the leaf instead)`);
+ }
+}
+// 3. xao alias form.
+const oauth = read("src/shared/constants/providers/oauth.ts");
+if (!/"xai-oauth":\s*\{[^}]*alias:\s*"xao"/s.test(oauth)) {
+ fail(`oauth.ts: "xai-oauth" entry lost its alias:"xao"`);
+}
+// 4. Unknown contract alive.
+if (!read("src/shared/constants/canonicalProviderOrder.ts").includes("?? Infinity")) {
+ fail(`canonicalProviderOrder.ts lost the ?? Infinity unknown contract`);
+}
+if (!read("src/app/api/v1/models/catalogOrder.ts").includes("codeUnitCompare")) {
+ fail(`catalogOrder.ts lost the codeUnitCompare unknown-branch`);
+}
+// 5. Re-export intact.
+if (!read("src/lib/combos/comboSort.ts").includes("CANONICAL_PROVIDER_ORDER as PROVIDER_ORDER")) {
+ fail(`comboSort.ts lost the PROVIDER_ORDER re-export`);
+}
+
+// Informative dashboard check (never fails).
+try {
+ const dash = read("src/app/(dashboard)/dashboard/usage/components/ProviderLimits/constants.ts");
+ const ids = new Set();
+ // NOTE: apikey/index.ts is a barrel (imports + spreads, zero literal entries),
+ // so glob the family files instead.
+ const apikeyFiles = fs
+ .readdirSync(path.join(ROOT, "src/shared/constants/providers/apikey"))
+ .filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts"))
+ .map((f) => `src/shared/constants/providers/apikey/${f}`);
+ for (const f of [
+ "src/shared/constants/providers/oauth.ts",
+ "src/shared/constants/providers/noauth.ts",
+ ...apikeyFiles,
+ ]) {
+ let src;
+ try {
+ src = read(f);
+ } catch {
+ continue;
+ }
+ for (const m of src.matchAll(/^ "([^"]+)": \{$/gm)) ids.add(m[1]);
+ }
+ for (const id of [...ids].sort()) {
+ if (!dash.includes(`"${id}"`) && !dash.includes(`${id}:`)) {
+ console.log(
+ `[provider-order-sync] warn: ${id} has no dashboard quota rank (ok if no quota surface)`
+ );
+ }
+ }
+} catch (e) {
+ console.log(`[provider-order-sync] warn: dashboard check skipped (${String(e).slice(0, 120)})`);
+}
+
+if (failures > 0) {
+ process.exit(1);
+}
+console.log("[provider-order-sync] OK — single source + alias form + unknown contract");
diff --git a/scripts/quality/run-all-gates.mjs b/scripts/quality/run-all-gates.mjs
index 409c8c1d292..aa6b68ea90a 100644
--- a/scripts/quality/run-all-gates.mjs
+++ b/scripts/quality/run-all-gates.mjs
@@ -29,6 +29,8 @@ const GATES = [
// Group B — fast (<5s)
{ name: "check:provider-consistency", cmd: ["node", "--import", "tsx", "scripts/check/check-provider-consistency.ts"] },
{ name: "check:provider-assets", cmd: ["node", "scripts/check/check-provider-assets.mjs"] },
+ { name: "check:pricing-freshness", cmd: ["node", "scripts/check/check-pricing-freshness.mjs"] },
+ { name: "check:provider-order-sync", cmd: ["node", "scripts/check/check-provider-order-sync.mjs"] },
{ name: "check:public-creds", cmd: ["node", "scripts/check/check-public-creds.mjs"] },
{ name: "check:error-helper", cmd: ["node", "scripts/check/check-error-helper.mjs"] },
{ name: "check:fetch-targets", cmd: ["node", "scripts/check/check-fetch-targets.mjs"] },
diff --git a/src/app/(dashboard)/dashboard/providers/[id]/components/modals/QuotaScrapingFields.tsx b/src/app/(dashboard)/dashboard/providers/[id]/components/modals/QuotaScrapingFields.tsx
index 240eafea50c..9fe727f0450 100644
--- a/src/app/(dashboard)/dashboard/providers/[id]/components/modals/QuotaScrapingFields.tsx
+++ b/src/app/(dashboard)/dashboard/providers/[id]/components/modals/QuotaScrapingFields.tsx
@@ -1,6 +1,7 @@
"use client";
import { Input } from "@/shared/components";
+import { getProviderConnectionFamilyIds } from "@/shared/constants/providers";
import { providerText, type ProviderMessageTranslator } from "../../providerPageHelpers";
import {
@@ -54,7 +55,7 @@ export default function QuotaScrapingFields({
);
}
- if (provider === "alibaba" || provider === "alibaba-cn") {
+ if (getProviderConnectionFamilyIds("alibaba").includes(provider)) {
return (
= { session: 0, weekly: 1, mcp_monthly: 2 };
@@ -10,7 +11,7 @@ const CODEX_QUOTA_ORDER: Record = {
banked_reset_credits: 4,
};
const GLM_FAMILY_PROVIDERS = ["glm", "glm-cn", "glmt", "opencode-go"];
-const KIMI_CODING_PROVIDERS = ["kimi-coding", "kimi-coding-apikey"];
+const KIMI_CODING_PROVIDERS: readonly string[] = getProviderConnectionFamilyIds("kimi-coding");
/**
* Providers whose quotas already get a deterministic fixed-window order below
diff --git a/src/app/api/models/openrouter-catalog/route.ts b/src/app/api/models/openrouter-catalog/route.ts
index dcb8656cd1c..058c72939dd 100644
--- a/src/app/api/models/openrouter-catalog/route.ts
+++ b/src/app/api/models/openrouter-catalog/route.ts
@@ -10,7 +10,7 @@ import { NextRequest, NextResponse } from "next/server";
import { isAuthenticated } from "@/shared/utils/apiAuth";
import { getOpenRouterCatalog, refreshOpenRouterCatalog } from "@/lib/catalog/openrouterCatalog";
import { getSettings } from "@/lib/db/settings";
-import { isFreeModel } from "@/shared/utils/freeModels";
+import { isFreeForProvider } from "@/shared/utils/freeModels";
export async function GET(req: NextRequest) {
// Require authentication (dashboard/API key)
@@ -29,7 +29,9 @@ export async function GET(req: NextRequest) {
hidePaid = settings?.hidePaidModels === true;
} catch {}
const applyFilter = (data: T[]): T[] =>
- hidePaid ? data.filter((m) => isFreeModel("or", m as { id: string; pricing?: unknown })) : data;
+ hidePaid
+ ? data.filter((m) => isFreeForProvider("openrouter", m as { id: string; pricing?: unknown }))
+ : data;
const forceRefresh = req.nextUrl.searchParams.get("refresh") === "true";
diff --git a/src/app/api/providers/[id]/models/route.ts b/src/app/api/providers/[id]/models/route.ts
index bcf5de3e941..c09a2636b7d 100755
--- a/src/app/api/providers/[id]/models/route.ts
+++ b/src/app/api/providers/[id]/models/route.ts
@@ -1,5 +1,6 @@
import { NextResponse } from "next/server";
import {
+ getProviderConnectionFamilyIds,
isClaudeCodeCompatibleProvider,
isAnthropicCompatibleProvider,
isOpenAICompatibleProvider,
@@ -2343,7 +2344,7 @@ export async function GET(
const data = await response.json();
let pageModels = config.parseResponse(data);
- if (provider === "alibaba" || provider === "alibaba-cn") {
+ if (getProviderConnectionFamilyIds("alibaba").includes(provider)) {
const { parseAlibabaModelStudioModelsForConnection } =
await import("./discovery/providerModelsConfig.ts");
pageModels = parseAlibabaModelStudioModelsForConnection(
@@ -2372,7 +2373,7 @@ export async function GET(
);
}
- if (provider === "alibaba" || provider === "alibaba-cn") {
+ if (getProviderConnectionFamilyIds("alibaba").includes(provider)) {
const { shouldUseLiveAlibabaFreeModelDiscovery } =
await import("@omniroute/open-sse/services/alibabaFreeTier.ts");
const { scheduleAlibabaFreeTierProbeRefresh } =
diff --git a/src/app/api/v1/models/catalog.ts b/src/app/api/v1/models/catalog.ts
index 3e60e8bea25..075f7c27825 100644
--- a/src/app/api/v1/models/catalog.ts
+++ b/src/app/api/v1/models/catalog.ts
@@ -122,7 +122,7 @@ import {
} from "./catalogRequest";
import { incrementCcDiscoveryHitCount } from "@/lib/db/ccDiscoveryMetrics";
import { isUnifiedChatSourceModelSelectable } from "./catalogModelPolicy";
-import { isFreeModel } from "@/shared/utils/freeModels";
+import { isFreeForProvider } from "@/shared/utils/freeModels";
import { isModelExposureAllowed } from "@/shared/utils/modelExposureList";
import { isCodexDiscoveryModelExcluded } from "@/shared/services/codexDiscoveryPolicy";
import { buildErrorBody } from "@omniroute/open-sse/utils/error";
@@ -350,11 +350,9 @@ async function buildUnifiedModelsResponseCore(
): boolean => {
if (!hidePaid) return false;
const provider = aliasToProviderId[providerKey] || providerKey;
- // isFree:true is the first door — custom row kept even when its provider is outside FREE_MODEL_BUDGETS.
- if (isFreeModel(provider, { id: modelId, pricing: pricing as any, isFree })) return false;
- // hidePaid is on and model is non-free → hidden. No need to consult FREE_MODEL_BUDGETS
- // separately: paid on a free-capable provider stays hidden, free on a non-budget provider
- // already returned above.
+ // fetched: free only when provider has a documented free tier — catalog hit or guarded heuristics (`:free`/`0`/`isFree:true`); fetched isFree:true not trusted alone
+ if (isFreeForProvider(provider, { id: modelId, pricing: pricing as any, isFree }))
+ return false;
return true;
};
// #11481: opt-in explicit model exposure allow/deny list — same call sites
@@ -1659,10 +1657,10 @@ async function buildUnifiedModelsResponseCore(
if (model.isHidden === true) continue;
if (isModelHiddenBulk(providerId, modelId, canonicalProviderId)) continue;
if (isExcludedByProviderConnections(canonicalProviderId, modelId)) continue;
- // #6328: apply hidePaidModels to user-defined custom rows too.
- // Custom entries do not carry pricing, so shouldHidePaid() decides
- // via FREE_MODEL_IDS_BY_PROVIDER — matches synced/PROVIDER_MODELS.
+ // #6328: apply hidePaidModels to user-defined custom rows too. A local custom
+ // row flagged isFree:true stays trusted, even outside the free-tier catalog.
if (
+ (model as { isFree?: unknown }).isFree !== true &&
shouldHidePaid(
canonicalProviderId,
modelId,
diff --git a/src/app/api/v1/models/catalogOrder.ts b/src/app/api/v1/models/catalogOrder.ts
index c0793911e88..7e0bfce672f 100644
--- a/src/app/api/v1/models/catalogOrder.ts
+++ b/src/app/api/v1/models/catalogOrder.ts
@@ -24,14 +24,7 @@
* effort-variant scoping, and Claude-mirror gating are untouched. Pure; no DB/IO.
*/
-import { OAUTH_PROVIDERS, NOAUTH_PROVIDERS, APIKEY_PROVIDERS } from "@/shared/constants/providers";
-
-/** Canonical provider precedence, keyed by provider id (not alias). Built once. */
-const CANONICAL_PROVIDER_ORDER: readonly string[] = [
- ...Object.keys(OAUTH_PROVIDERS),
- ...Object.keys(NOAUTH_PROVIDERS),
- ...Object.keys(APIKEY_PROVIDERS),
-];
+import { COMBO_GROUP, groupSortPriority } from "@/shared/constants/canonicalProviderOrder";
/**
* Locale-independent code-unit comparator. UTF-16 code units put uppercase A-Z
@@ -41,9 +34,6 @@ function codeUnitCompare(a: string, b: string): number {
return a < b ? -1 : a > b ? 1 : 0;
}
-/** Combo bucket key, distinct from any real provider id. */
-const COMBO_GROUP = " combo";
-
/**
* Grouping key for a catalog row: "combo" for combo-owned rows, else owned_by
* (canonical identity). Rows with no usable owned_by fall back to the id-prefix;
@@ -59,16 +49,6 @@ function modelGroupKey(model: Record): string {
return slash > 0 ? id.slice(0, slash) : id;
}
-/**
- * Sort priority for a group key: combo first, then registry precedence, then
- * unknown groups (rank Infinity, ordered among themselves by code unit).
- */
-function groupSortPriority(groupKey: string): number {
- if (groupKey === COMBO_GROUP) return -1;
- const idx = CANONICAL_PROVIDER_ORDER.indexOf(groupKey);
- return idx >= 0 ? idx : Infinity;
-}
-
/**
* Stable provider-grouped sort. Does not mutate the input. Deterministic for a
* given input array.
diff --git a/src/lib/combos/comboSort.ts b/src/lib/combos/comboSort.ts
index 977c45b93c0..316c23b875d 100644
--- a/src/lib/combos/comboSort.ts
+++ b/src/lib/combos/comboSort.ts
@@ -1,5 +1,5 @@
// src/lib/combos/comboSort.ts
-import { OAUTH_PROVIDERS, NOAUTH_PROVIDERS, APIKEY_PROVIDERS } from "@/shared/constants/providers";
+import { CANONICAL_PROVIDER_ORDER, providerRank } from "@/shared/constants/canonicalProviderOrder";
import type { ComboStep } from "@/lib/combos/steps";
export type { ComboStep };
@@ -17,13 +17,8 @@ export function isValidSortMethod(raw: unknown): raw is SortMethod {
return VALID_SORT_METHODS.has(raw as string);
}
-// Mirrors CANONICAL_PROVIDER_ORDER from src/app/api/v1/models/catalogOrder.ts — keep in sync.
-// Both are derived from OAUTH+NOAUTH+APIKEY keys; drift would silently diverge catalog vs combo order.
-export const PROVIDER_ORDER: readonly string[] = [
- ...Object.keys(OAUTH_PROVIDERS),
- ...Object.keys(NOAUTH_PROVIDERS),
- ...Object.keys(APIKEY_PROVIDERS),
-];
+// Single source: re-exported from canonicalProviderOrder (was a duplicated derivation).
+export { CANONICAL_PROVIDER_ORDER as PROVIDER_ORDER };
const REFERENCE_SENTINEL = " combo-ref"; // sorts after any real provider id
@@ -40,12 +35,6 @@ function nameKey(step: ComboStep): string {
return step.comboName; // combo-ref
}
-/** Stable index for provider ordering; unknown providers go after the known list. */
-function providerRank(providerId: string): number {
- const idx = PROVIDER_ORDER.indexOf(providerId);
- return idx === -1 ? PROVIDER_ORDER.length : idx;
-}
-
/** Synchronous sorts: manual (noop), provider, name. Stable. */
export function sortComboStepsSync(
steps: ComboStep[],
diff --git a/src/lib/db/settings/pricing.ts b/src/lib/db/settings/pricing.ts
index b0f7dd1b74b..e2496550a27 100644
--- a/src/lib/db/settings/pricing.ts
+++ b/src/lib/db/settings/pricing.ts
@@ -13,6 +13,16 @@ type PricingByProvider = Record;
export type PricingSource = "default" | "litellm" | "modelsDev" | "user";
export type PricingSourceMap = Record>;
+async function touchPricing(): Promise {
+ invalidateDbCache("pricing");
+ try {
+ const { clearTierCache } = await import("@omniroute/open-sse/services/tierResolver");
+ clearTierCache();
+ } catch {
+ // fail-open: a missed tier invalidation must never break a price write
+ }
+}
+
function readPricingNamespace(
db: ReturnType,
namespace: string
@@ -195,7 +205,7 @@ export async function updatePricing(pricingData: PricingByProvider) {
});
tx();
backupDbFile("pre-write");
- invalidateDbCache("pricing"); // Bust the pricing read cache
+ await touchPricing();
const updated: PricingByProvider = {};
const allRows = db.prepare("SELECT key, value FROM key_value WHERE namespace = 'pricing'").all();
for (const row of allRows) {
@@ -234,6 +244,7 @@ export async function resetPricing(provider: string, model?: string) {
}
backupDbFile("pre-write");
+ await touchPricing();
const allRows = db.prepare("SELECT key, value FROM key_value WHERE namespace = 'pricing'").all();
const result: Record = {};
for (const row of allRows) {
@@ -250,5 +261,6 @@ export async function resetAllPricing() {
const db = getDbInstance();
db.prepare("DELETE FROM key_value WHERE namespace = 'pricing'").run();
backupDbFile("pre-write");
+ await touchPricing();
return {};
}
diff --git a/src/shared/constants/canonicalProviderOrder.ts b/src/shared/constants/canonicalProviderOrder.ts
new file mode 100644
index 00000000000..9ec86ea4d65
--- /dev/null
+++ b/src/shared/constants/canonicalProviderOrder.ts
@@ -0,0 +1,48 @@
+import { OAUTH_PROVIDERS } from "@/shared/constants/providers/oauth";
+import { NOAUTH_PROVIDERS } from "@/shared/constants/providers/noauth";
+import { APIKEY_PROVIDERS } from "@/shared/constants/providers/apikey";
+
+/** Registry-canonical provider precedence: OAUTH -> NOAUTH -> APIKEY (canonical keys, not aliases). */
+export const CANONICAL_PROVIDER_ORDER: readonly string[] = [
+ ...Object.keys(OAUTH_PROVIDERS),
+ ...Object.keys(NOAUTH_PROVIDERS),
+ ...Object.keys(APIKEY_PROVIDERS),
+];
+
+// Single load-time pass (never resolve per sorted item: getProviderByAlias loops
+// ~10 sections x providers, which costs more than the indexOf it replaces on ~1k catalog rows).
+function buildRankResolved(): ReadonlyMap {
+ const rank = new Map();
+ CANONICAL_PROVIDER_ORDER.forEach((id, i) => rank.set(id, i));
+ // Canonical keys win over homonym aliases (m-a: ~17 aliases like minimax-cn
+ // are also canonical keys — an alias must never steal a canonical slot).
+ const canonicals = new Set(CANONICAL_PROVIDER_ORDER);
+ for (const def of Object.values({
+ ...OAUTH_PROVIDERS,
+ ...NOAUTH_PROVIDERS,
+ ...APIKEY_PROVIDERS,
+ })) {
+ const a = (def as { id: string; alias?: string }).alias;
+ if (typeof a === "string" && a.length > 0 && !canonicals.has(a) && rank.has(def.id)) {
+ rank.set(a, rank.get(def.id) as number);
+ }
+ }
+ return rank;
+}
+
+const RANK_RESOLVED: ReadonlyMap = buildRankResolved();
+
+/** Finite rank (combos): alias resolved, unknown -> length (existing comboSort contract). */
+export function providerRank(providerId: string): number {
+ return RANK_RESOLVED.get(providerId) ?? CANONICAL_PROVIDER_ORDER.length;
+}
+
+/** Combo bucket key, distinct from any real provider id. Single definition (was also in catalogOrder.ts:45). */
+export const COMBO_GROUP = " combo";
+
+/** Catalog priority: combo first, then registry precedence, unknown -> Infinity (code-unit branch stays live). */
+export function groupSortPriority(groupKey: string): number {
+ if (groupKey === COMBO_GROUP) return -1;
+ const r = RANK_RESOLVED.get(groupKey);
+ return r ?? Infinity;
+}
diff --git a/src/shared/utils/freeModels.ts b/src/shared/utils/freeModels.ts
index 5f1f1c4a63c..279e8cc2951 100644
--- a/src/shared/utils/freeModels.ts
+++ b/src/shared/utils/freeModels.ts
@@ -29,10 +29,10 @@ import { AI_MODELS } from "@/shared/constants/models";
* import modal's preview disagree with the import route that runs on click.
*
* A provider is considered to "have free models" when it appears in the
- * documented free-tier catalog (`FREE_MODEL_BUDGETS`). A single model is
- * considered free when its id carries the OpenRouter-style `:free` suffix, when
- * both its prompt and completion prices are zero, or when its id is listed as a
- * free model for that provider in the catalog.
+ * documented free-tier catalog (`FREE_MODEL_BUDGETS`). A single model is considered free when — for a provider with a documented
+ * free tier — its id carries the OpenRouter-style `:free` suffix or both its
+ * prompt and completion prices are zero (guarded heuristics), or when its id
+ * is listed as a free model for that provider in the shipped catalog.
*
* The catalog also records the regime of every entry via `freeType`
* (`FreeModelFreeType`). A regime can retire a free tier behind a paid key
@@ -84,21 +84,34 @@ export interface FreeModelCandidate {
isFree?: boolean;
}
-/** Whether a single fetched model qualifies as free for the given provider (id or alias). */
-export function isFreeModel(provider: string, model: FreeModelCandidate): boolean {
+/** Shipped-catalog entry for this provider (id or alias): trusted on its own. */
+function isCatalogFreeModel(provider: string, modelId: unknown): boolean {
+ if (typeof modelId !== "string") return false;
+ return (
+ FREE_MODEL_IDS_BY_PROVIDER.get(provider)?.has(modelId) === true ||
+ FREE_MODEL_IDS_BY_PROVIDER.get(resolveProviderId(provider))?.has(modelId) === true
+ );
+}
+
+/** Payload-supplied free signals: `isFree:true`, a `:free` id suffix, or zero prices. */
+function hasPayloadFreeSignal(model: FreeModelCandidate): boolean {
if (model.isFree === true) return true;
if (typeof model.id === "string" && model.id.endsWith(":free")) return true;
- if (isZeroPrice(model.pricing?.prompt) && isZeroPrice(model.pricing?.completion)) return true;
- if (typeof model.id === "string") {
- const canonical = resolveProviderId(provider);
- if (
- FREE_MODEL_IDS_BY_PROVIDER.get(provider)?.has(model.id) ||
- FREE_MODEL_IDS_BY_PROVIDER.get(canonical)?.has(model.id)
- ) {
- return true;
- }
- }
- return false;
+ return isZeroPrice(model.pricing?.prompt) && isZeroPrice(model.pricing?.completion);
+}
+
+/**
+ * Whether a single fetched model qualifies as free for the given provider (id or alias): a
+ * shipped-catalog entry, or a payload signal on a provider with a documented free tier.
+ */
+export function isFreeModel(provider: string, model: FreeModelCandidate): boolean {
+ if (isCatalogFreeModel(provider, model.id)) return true;
+ return providerHasFreeModels(provider) && hasPayloadFreeSignal(model);
+}
+
+/** Reusable free predicate for fetched payloads — provider must have a documented free tier. */
+export function isFreeForProvider(provider: string, model: FreeModelCandidate): boolean {
+ return providerHasFreeModels(provider) && isFreeModel(provider, model);
}
export interface SelectModelsForImportResult {
@@ -191,7 +204,7 @@ export function matchesOnlyPaidModels(pattern: string): boolean {
const fullId = `${m.provider}/${m.model}`;
if (!regex.test(fullId)) continue;
matched = true;
- if (isFreeModel(m.provider, { id: m.model })) return false;
+ if (isFreeForProvider(m.provider, { id: m.model })) return false;
}
return matched;
}
diff --git a/tests/integration/manifest-routing.test.ts b/tests/integration/manifest-routing.test.ts
index 458b9af4ad9..878eda7efb5 100644
--- a/tests/integration/manifest-routing.test.ts
+++ b/tests/integration/manifest-routing.test.ts
@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
import { generateRoutingHints } from "../../open-sse/services/manifestAdapter.ts";
test("manifest routing generates hints without error", async () => {
- const hints = generateRoutingHints([], {
+ const hints = await generateRoutingHints([], {
messages: [{ content: "Test" }],
});
assert.equal(hints.specificityLevel, "trivial");
@@ -11,7 +11,7 @@ test("manifest routing generates hints without error", async () => {
});
test("manifest routing failure gracefully falls back - empty targets handled", async () => {
- const hints = generateRoutingHints([], {
+ const hints = await generateRoutingHints([], {
messages: [{ content: "Hello world" }],
});
assert.equal(hints.eligibleTargets.length, 0);
@@ -20,7 +20,7 @@ test("manifest routing failure gracefully falls back - empty targets handled", a
});
test("specificity score is non-negative and bounded", async () => {
- const hints = generateRoutingHints([], {
+ const hints = await generateRoutingHints([], {
messages: [{ content: "Hello" }],
});
assert.ok(hints.specificity.score >= 0);
@@ -28,7 +28,7 @@ test("specificity score is non-negative and bounded", async () => {
});
test("routing hints contain all required fields", async () => {
- const hints = generateRoutingHints([], {
+ const hints = await generateRoutingHints([], {
messages: [{ content: "Test message" }],
});
assert.ok("specificityLevel" in hints);
@@ -40,7 +40,7 @@ test("routing hints contain all required fields", async () => {
});
test("trivial query recommends free tier", async () => {
- const hints = generateRoutingHints([], {
+ const hints = await generateRoutingHints([], {
messages: [{ content: "Hello" }],
});
assert.equal(hints.recommendedMinTier, "free");
diff --git a/tests/unit/auto-combo-budget.test.ts b/tests/unit/auto-combo-budget.test.ts
new file mode 100644
index 00000000000..1e9313ba58f
--- /dev/null
+++ b/tests/unit/auto-combo-budget.test.ts
@@ -0,0 +1,57 @@
+// tests/unit/auto-combo-budget.test.ts
+import test from "node:test";
+import assert from "node:assert/strict";
+import { selectProvider } from "../../open-sse/services/autoCombo/engine.ts";
+import { getSelfHealingManager } from "../../open-sse/services/autoCombo/selfHealing.ts";
+import { DEFAULT_WEIGHTS } from "../../open-sse/services/autoCombo/scoring.ts";
+
+const healer = getSelfHealingManager();
+test.beforeEach(() => {
+ healer.exclusions.clear();
+ healer.incidentMode = false;
+});
+
+function config(over: Record = {}) {
+ return {
+ id: "budget-probe",
+ name: "Budget Probe",
+ type: "auto",
+ candidatePool: [],
+ weights: DEFAULT_WEIGHTS,
+ explorationRate: 0,
+ ...over,
+ } as never;
+}
+
+function cand(provider: string, model: string, cost: number) {
+ return {
+ provider,
+ model,
+ quotaRemaining: 95,
+ quotaTotal: 100,
+ circuitBreakerState: "CLOSED",
+ costPer1MTokens: cost,
+ p95LatencyMs: 120,
+ latencyStdDev: 8,
+ } as never;
+}
+
+test("default budget math is unchanged without the new field", () => {
+ const c = [cand("openai", "gpt-4o", 5)];
+ const r = selectProvider(config({ budgetCap: 1 }), c);
+ assert.equal(r.provider, "openai"); // (5/1M)*1000 = $0.005 < $1
+});
+
+test("32k estimated tokens enforce a 32x tighter budget", () => {
+ const c = [cand("openai", "gpt-4o", 5)];
+ // (5/1M)*32000 = $0.16 — exceeds a $0.01 cap only when tokens are honored.
+ // Message verified: "No candidate fits within the configured budget cap…" (engine.ts:59-62).
+ assert.throws(
+ () =>
+ selectProvider(
+ config({ budgetCap: 0.01, budgetFallback: "strict", estimatedInputTokens: 32000 }),
+ c
+ ),
+ /budget cap/i
+ );
+});
diff --git a/tests/unit/auto-combos-suffixes-4235.test.ts b/tests/unit/auto-combos-suffixes-4235.test.ts
index e09e7e9a469..c67ebf383fb 100644
--- a/tests/unit/auto-combos-suffixes-4235.test.ts
+++ b/tests/unit/auto-combos-suffixes-4235.test.ts
@@ -88,6 +88,16 @@ test("#4235 reliability-first mode pack exists and is normalized", () => {
assert.ok(pack.health >= 0.3, "reliability-first leans on circuit-breaker health");
});
+test("every pack carries quality>0 and reliability>0", () => {
+ for (const [name, w] of Object.entries(modePacks.MODE_PACKS)) {
+ const weights = w as { quality?: unknown; reliability?: unknown } & Record;
+ assert.ok(Number(weights.quality) > 0, `${name} quality>0`);
+ assert.ok(Number(weights.reliability) > 0, `${name} reliability>0`);
+ const sum = Object.values(weights).reduce((a: number, b: unknown) => a + Number(b), 0);
+ assert.ok(Math.abs(sum - 0.9999) < 0.002, `${name} sum ~0.9999 got ${sum}`);
+ }
+});
+
test("#4235 createBuiltinAutoCombo composes tier weights for auto/coding:fast", async () => {
const combo = await builtinCatalog.createBuiltinAutoCombo("auto/coding:fast", "coding:fast");
assert.equal(combo.id, "auto/coding:fast");
diff --git a/tests/unit/canonical-provider-order.test.ts b/tests/unit/canonical-provider-order.test.ts
new file mode 100644
index 00000000000..ab5d93fa080
--- /dev/null
+++ b/tests/unit/canonical-provider-order.test.ts
@@ -0,0 +1,59 @@
+// tests/unit/canonical-provider-order.test.ts
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+ CANONICAL_PROVIDER_ORDER,
+ COMBO_GROUP,
+ groupSortPriority,
+ providerRank,
+} from "@/shared/constants/canonicalProviderOrder";
+import { OAUTH_PROVIDERS } from "@/shared/constants/providers/oauth";
+import { NOAUTH_PROVIDERS } from "@/shared/constants/providers/noauth";
+import { APIKEY_PROVIDERS } from "@/shared/constants/providers/apikey";
+import { PROVIDER_ORDER } from "@/lib/combos/comboSort";
+
+describe("canonical provider order", () => {
+ it("matches the registry derivation OAUTH -> NOAUTH -> APIKEY", () => {
+ assert.deepEqual(
+ [...CANONICAL_PROVIDER_ORDER],
+ [
+ ...Object.keys(OAUTH_PROVIDERS),
+ ...Object.keys(NOAUTH_PROVIDERS),
+ ...Object.keys(APIKEY_PROVIDERS),
+ ]
+ );
+ });
+
+ it("resolves the xao alias to the xai-oauth rank", () => {
+ assert.ok(CANONICAL_PROVIDER_ORDER.includes("xai-oauth"));
+ assert.equal(providerRank("xao"), providerRank("xai-oauth"));
+ });
+
+ it("keeps the catalog unknown contract (Infinity, combo first)", () => {
+ assert.equal(groupSortPriority(COMBO_GROUP), -1);
+ assert.equal(groupSortPriority("zzz-no-such-provider"), Infinity);
+ });
+
+ it("keeps the combos unknown contract (length)", () => {
+ assert.equal(providerRank("zzz-no-such-provider"), CANONICAL_PROVIDER_ORDER.length);
+ });
+
+ it("is shared by reference with comboSort", () => {
+ assert.equal(PROVIDER_ORDER, CANONICAL_PROVIDER_ORDER);
+ });
+
+ it("resolves every declared alias to its canonical rank", () => {
+ const seen = new Set();
+ for (const def of Object.values({
+ ...OAUTH_PROVIDERS,
+ ...NOAUTH_PROVIDERS,
+ ...APIKEY_PROVIDERS,
+ }) as { id: string; alias?: string }[]) {
+ if (typeof def.alias === "string" && def.alias.length > 0 && !seen.has(def.alias)) {
+ seen.add(def.alias);
+ assert.equal(providerRank(def.alias), providerRank(def.id));
+ }
+ }
+ assert.ok(seen.size > 0);
+ });
+});
diff --git a/tests/unit/check-docs-counts-quality-pinning.test.ts b/tests/unit/check-docs-counts-quality-pinning.test.ts
new file mode 100644
index 00000000000..d759f544ad8
--- /dev/null
+++ b/tests/unit/check-docs-counts-quality-pinning.test.ts
@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { MODE_PACKS } from "../../open-sse/services/autoCombo/modePacks.ts";
+
+// Every pack pins quality explicitly so none silently inherits a future DEFAULT.
+// Locks, not TDD: green on existing behavior, break on silent regression.
+
+test("every pack pins quality explicitly (no silent DEFAULT inheritance)", () => {
+ for (const [name, pack] of Object.entries(MODE_PACKS)) {
+ assert.ok(
+ typeof (pack as { quality?: unknown }).quality === "number",
+ `${name} must pin quality`
+ );
+ }
+});
+
+test("scoring fallback stays neutral (no DEFAULT inheritance)", () => {
+ const src = readFileSync("open-sse/services/autoCombo/scoring.ts", "utf8");
+ assert.match(src, /weights\.quality \?\? 0\)/);
+ assert.match(src, /factors\.quality \?\? 0\.5\)/);
+});
diff --git a/tests/unit/check-docs-counts-sync.test.ts b/tests/unit/check-docs-counts-sync.test.ts
index 7bafffec8c6..a01ff43d4f8 100644
--- a/tests/unit/check-docs-counts-sync.test.ts
+++ b/tests/unit/check-docs-counts-sync.test.ts
@@ -20,6 +20,7 @@ const tally = tallyDrift as (
docKey: string;
strict: boolean;
files: string[];
+ validate?: (content: string) => { ok: boolean; detail: string };
}[],
getContent: (file: string) => string | null
) => { strict: number; soft: number; lines: string[] };
@@ -568,3 +569,60 @@ test("neither claim fires on the other numbers the page is full of", () => {
assert.equal(makeValidator(7, HARD_STOP_CLAIM)(page).ok, true);
assert.equal(makeValidator(13, TRAINING_CLAIM)(page).ok, true);
});
+
+function freeTierCheck(freeTierCount: number, manifestFreeTier: number, freeTierReg?: number) {
+ const reg = freeTierReg ?? freeTierCount;
+ return {
+ label: "Manifest free-tier capability count (live code)",
+ actual: manifestFreeTier,
+ docKey: "free-tier capability",
+ strict: true,
+ files: ["scripts/check/check-docs-counts-sync.mjs"],
+ validate: () => ({
+ ok: manifestFreeTier === reg,
+ detail: `manifest ${manifestFreeTier} vs leaf∩registry ${reg} (leaf ${freeTierCount})`,
+ }),
+ };
+}
+
+test("gate flags STRICT when manifest free-tier count differs from leaf∩registry", () => {
+ const r = tally([freeTierCheck(5, 4, 5)], () => "live");
+ assert.equal(r.strict, 1);
+});
+
+test("gate passes when counts agree", () => {
+ const r = tally([freeTierCheck(5, 5, 5)], () => "live");
+ assert.equal(r.strict, 0);
+});
+
+test("gate passes on the arcee-ai shape: leaf=5, reg=4, manifest=4 (catalogue-only leaf)", () => {
+ // arcee-ai is in FREE_TIER_PROVIDER_SET (leaf) but absent from REGISTRY, so the
+ // prod gate compares the manifest against the intersection (reg), not the raw leaf.
+ const r = tally([freeTierCheck(5, 4, 4)], () => "live");
+ assert.equal(r.strict, 0);
+ // ...while the same manifest against the raw leaf (reg=leaf=5) must stay red.
+ const stale = tally([freeTierCheck(5, 4, 5)], () => "live");
+ assert.equal(stale.strict, 1);
+});
+
+test("gate skips when readCodeFacts fails (actual 0 fallback)", () => {
+ const r = tally(
+ [
+ {
+ label: "Code-derived counts",
+ actual: 0,
+ docKey: "code facts",
+ strict: false,
+ files: [] as string[],
+ },
+ ],
+ () => "live"
+ );
+ assert.equal(r.strict, 0);
+});
+
+test("buildChecks contains a free-tier gate", async () => {
+ const { buildChecks } = await import("../../scripts/check/check-docs-counts-sync.mjs");
+ const checks = (buildChecks as () => { label: string }[])();
+ assert.ok(checks.some((c) => c.label.includes("free-tier")));
+});
diff --git a/tests/unit/combo-auto-tier.test.ts b/tests/unit/combo-auto-tier.test.ts
new file mode 100644
index 00000000000..67a1bea460c
--- /dev/null
+++ b/tests/unit/combo-auto-tier.test.ts
@@ -0,0 +1,38 @@
+// tests/unit/combo-auto-tier.test.ts — runner node:test
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { calculateTierScore } from "../../open-sse/services/autoCombo/scoring.ts";
+
+describe("combo auto tier projection", () => {
+ it("ultra > pro > standard > free discriminant (order only, no absolutes)", () => {
+ const ultra = calculateTierScore("ultra", 86400);
+ const pro = calculateTierScore("pro", 86400);
+ const std = calculateTierScore("standard", 86400);
+ const free = calculateTierScore("free", 86400);
+ // Formula is base*0.8 + resetBonus*0.2 — assert order, never absolute values
+ assert.ok(ultra > pro && pro > std && std > free);
+ });
+ it("unknown tier falls back to standard base (order preserved)", () => {
+ const undef = calculateTierScore(undefined, 86400);
+ const std = calculateTierScore("standard", 86400);
+ assert.equal(undef, std);
+ });
+ it("resetBonus short interval higher than long (same tier)", () => {
+ const sShort = calculateTierScore("standard", 3600);
+ const sLong = calculateTierScore("standard", 86400);
+ assert.ok(sShort > sLong);
+ });
+ it("projected tier discriminates vs neutral (shared helper, no file read)", async () => {
+ // Imports the SAME pure helper combo.ts uses — no local
+ // mirror, so prod/test divergence fails here instead of shipping green.
+ const { projectAccountTier } = await import("../../open-sse/services/autoCombo/scoring.ts");
+ const sUltra = calculateTierScore(projectAccountTier({ accountTier: "ultra" }), 86400);
+ const sNeutral = calculateTierScore(projectAccountTier({}), 86400);
+ const sPsd = calculateTierScore(
+ projectAccountTier({ providerSpecificData: { accountTier: "pro" } }),
+ 86400
+ );
+ assert.ok(sUltra > sNeutral, `ultra ${sUltra} should exceed neutral ${sNeutral}`);
+ assert.ok(sPsd > sNeutral, `psd-pro ${sPsd} should exceed neutral ${sNeutral}`);
+ });
+});
diff --git a/tests/unit/combo-bootstrap-latency.test.ts b/tests/unit/combo-bootstrap-latency.test.ts
new file mode 100644
index 00000000000..0499d7c36a5
--- /dev/null
+++ b/tests/unit/combo-bootstrap-latency.test.ts
@@ -0,0 +1,53 @@
+// tests/unit/combo-bootstrap-latency.test.ts
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+// Median helper lives in combo.ts; import it directly (export it non-default).
+import {
+ poolMedianP95Ms,
+ bootstrapMs,
+ shouldWarnBootstrap,
+ resetBootstrapCounters,
+ bootstrapLatencyHits,
+ bootstrapLatencyTotal,
+} from "../../open-sse/services/combo.ts";
+
+test("median ignores corrupt entries", () => {
+ const m = poolMedianP95Ms({
+ "a/x": { p95LatencyMs: 1000 },
+ "b/y": { p95LatencyMs: NaN },
+ "c/z": { p95LatencyMs: -5 },
+ "d/w": { p95LatencyMs: 3000 },
+ } as never);
+ assert.equal(m, 1000);
+});
+
+test("empty stats yield undefined (caller falls back to 1500, no cold-start alarm)", () => {
+ assert.equal(poolMedianP95Ms({}), undefined);
+});
+
+test("counters start at zero", () => {
+ resetBootstrapCounters();
+ assert.equal(bootstrapLatencyHits, 0);
+ assert.equal(bootstrapLatencyTotal, 0);
+});
+
+test("table hit bumps Total but not Hits; miss bumps both", () => {
+ resetBootstrapCounters();
+ assert.equal(bootstrapMs("gpt-4o-mini", 9999), 2764); // table hit
+ assert.equal(bootstrapLatencyTotal, 1);
+ assert.equal(bootstrapLatencyHits, 0);
+ assert.equal(bootstrapMs("some-new-model-xyz", 1234), 1234); // miss -> median
+ assert.equal(bootstrapLatencyTotal, 2);
+ assert.equal(bootstrapLatencyHits, 1);
+ assert.equal(bootstrapMs("another-new-model", undefined), 1500); // miss, no median
+ resetBootstrapCounters();
+});
+
+test("warn gate is pure: cold start and low ratio stay silent, dominant warns once", () => {
+ assert.equal(shouldWarnBootstrap(10, 10, false, 9999, 0), false); // cold start
+ assert.equal(shouldWarnBootstrap(2, 10, true, 9999, 0), false); // ratio <= 0.3
+ assert.equal(shouldWarnBootstrap(5, 10, true, 9999, 0), false); // throttled 1h
+ assert.equal(shouldWarnBootstrap(5, 10, true, 3600_001, 0), true); // window elapsed
+ assert.equal(shouldWarnBootstrap(5, 10, true, 9999, 9000), false); // throttled 1h
+});
diff --git a/tests/unit/complexity-router.test.ts b/tests/unit/complexity-router.test.ts
index 7a6e6745c75..de7b565d75a 100644
--- a/tests/unit/complexity-router.test.ts
+++ b/tests/unit/complexity-router.test.ts
@@ -78,8 +78,8 @@ test("classifyRequestComplexity — tool schemas escalate the tier above free",
assert.notEqual(c.recommendedTier, "free", "tool-using requests must not route to the free tier");
});
-test("buildComplexityRoutingHint — a tool-using request floors the hint tier above free", () => {
- const hint = buildComplexityRoutingHint(
+test("buildComplexityRoutingHint — a tool-using request floors the hint tier above free", async () => {
+ const hint = await buildComplexityRoutingHint(
modelTargets(),
{
messages: [{ role: "user", content: "weather?" }],
@@ -96,8 +96,8 @@ test("buildComplexityRoutingHint — a tool-using request floors the hint tier a
);
});
-test("buildComplexityRoutingHint — a null body is safe and still builds a tier-neutral hint", () => {
- const hint = buildComplexityRoutingHint(modelTargets(), null, NOOP_LOG);
+test("buildComplexityRoutingHint — a null body is safe and still builds a tier-neutral hint", async () => {
+ const hint = await buildComplexityRoutingHint(modelTargets(), null, NOOP_LOG);
assert.ok(hint, "a null body must not throw — messages default to [] and a hint is built");
if (!hint) return;
assert.ok(
diff --git a/tests/unit/free-models-isfree.test.ts b/tests/unit/free-models-isfree.test.ts
index 53217ace478..775df3f7784 100644
--- a/tests/unit/free-models-isfree.test.ts
+++ b/tests/unit/free-models-isfree.test.ts
@@ -3,10 +3,12 @@ import assert from "node:assert/strict";
import { isFreeModel, providerHasFreeModels } from "../../src/shared/utils/freeModels.ts";
describe("isFreeModel isFree opt-in", () => {
- it("isFree:true → free even without :free/pricing/catalog", () => {
- assert.equal(isFreeModel("any", { id: "x", isFree: true }), true);
- assert.equal(isFreeModel("openai", { id: "gpt-4o", isFree: true }), true);
- assert.equal(isFreeModel("local", { id: "my-model", isFree: true }), true);
+ it("isFree:true fetched → free only for a provider with a documented free tier", async () => {
+ const { FREE_MODEL_BUDGETS } = await import("@omniroute/open-sse/config/freeModelCatalog");
+ const freeProvider = FREE_MODEL_BUDGETS[0].provider;
+ assert.equal(isFreeModel("any", { id: "x", isFree: true }), false);
+ assert.equal(isFreeModel("local", { id: "my-model", isFree: true }), false);
+ assert.equal(isFreeModel(freeProvider, { id: "x", isFree: true }), true);
});
it("isFree:false/null/undefined/1/'true' → not free (strict ===true)", () => {
const junk: unknown[] = [false, null, undefined, 1, "true"];
@@ -22,9 +24,42 @@ describe("isFreeModel isFree opt-in", () => {
assert.equal(providerHasFreeModels("local"), false);
assert.equal(providerHasFreeModels("openai"), providerHasFreeModels("openai"));
});
- it(":free and pricing 0 still work when isFree absent", () => {
- assert.equal(isFreeModel("any", { id: "foo:free" }), true);
- assert.equal(isFreeModel("any", { id: "foo", pricing: { prompt: 0, completion: 0 } }), true);
+ it(":free and pricing 0 still work when isFree absent — only for free-tier providers", async () => {
+ const { FREE_MODEL_BUDGETS } = await import("@omniroute/open-sse/config/freeModelCatalog");
+ const freeProvider = FREE_MODEL_BUDGETS[0].provider;
+ assert.equal(isFreeModel("any", { id: "foo:free" }), false);
+ assert.equal(isFreeModel("local", { id: "foo", pricing: { prompt: 0, completion: 0 } }), false);
+ assert.equal(isFreeModel(freeProvider, { id: "foo:free" }), true);
+ assert.equal(
+ isFreeModel(freeProvider, { id: "foo", pricing: { prompt: 0, completion: 0 } }),
+ true
+ );
assert.equal(isFreeModel("any", { id: "foo", pricing: { prompt: 0, completion: 1 } }), false);
});
+ it("selectModelsForImport matches isFreeForProvider on every catalogued free model", async () => {
+ // FREE_MODEL_IDS_BY_PROVIDER is module-private, so rebuild (provider, id) pairs from the
+ // exported FREE_MODEL_BUDGETS: every budgeted provider has a documented free tier.
+ const { FREE_MODEL_BUDGETS } = await import("@omniroute/open-sse/config/freeModelCatalog");
+ const { selectModelsForImport, isFreeForProvider } =
+ await import("../../src/shared/utils/freeModels.ts");
+ for (const { provider } of FREE_MODEL_BUDGETS) {
+ const m = { id: `${provider}/probe-lock`, pricing: { prompt: 0, completion: 0 } };
+ const expected = isFreeForProvider(provider, m);
+ const { models } = selectModelsForImport(provider, [m], true);
+ assert.equal(models.length, expected ? 1 : 0, `${provider}/probe-lock`);
+ }
+ });
+ it("selectModelsForImport drops zero-price models on providers without documented free tier", async () => {
+ // "local" has no documented free tier, so its zero-price model is not free.
+ const { selectModelsForImport, providerHasFreeModels } =
+ await import("../../src/shared/utils/freeModels.ts");
+ assert.equal(providerHasFreeModels("local"), false);
+ const { models, freeFilterEmpty } = selectModelsForImport(
+ "local",
+ [{ id: "local/x", pricing: { prompt: 0, completion: 0 } }],
+ true
+ );
+ assert.deepEqual(models, []);
+ assert.equal(freeFilterEmpty, true);
+ });
});
diff --git a/tests/unit/free-tier-providers.test.ts b/tests/unit/free-tier-providers.test.ts
new file mode 100644
index 00000000000..bac7e062254
--- /dev/null
+++ b/tests/unit/free-tier-providers.test.ts
@@ -0,0 +1,27 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+ FREE_TIER_PROVIDER_SET,
+ hasFreeTierProvider,
+} from "../../open-sse/config/freeTierProviders.ts";
+
+describe("freeTierProviders leaf", () => {
+ it("contains a known free provider", () => {
+ assert.equal(hasFreeTierProvider("api-airforce"), true);
+ });
+ it("contains the documented alias target lookup (af is resolved by caller via entry.alias)", () => {
+ // The leaf stores canonical ids; alias resolution happens in capabilitiesFor
+ // via entry.alias. Document the contract: leaf answers ids, caller passes both.
+ assert.equal(FREE_TIER_PROVIDER_SET.size > 0, true);
+ });
+ it("rejects non-string input", () => {
+ assert.equal(hasFreeTierProvider(undefined), false);
+ assert.equal(hasFreeTierProvider(null), false);
+ });
+ it("keeps pollinations free despite discontinued entries", () => {
+ assert.equal(hasFreeTierProvider("pollinations"), true);
+ });
+ it("excludes a provider with no free models", () => {
+ assert.equal(hasFreeTierProvider("definitely-not-a-provider-xyz"), false);
+ });
+});
diff --git a/tests/unit/pricing-fallback.test.ts b/tests/unit/pricing-fallback.test.ts
new file mode 100644
index 00000000000..13e2f4fffca
--- /dev/null
+++ b/tests/unit/pricing-fallback.test.ts
@@ -0,0 +1,33 @@
+// tests/unit/pricing-fallback.test.ts
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { getModelPricing, KNOWN_MODEL_PRICING } from "../../open-sse/services/providerCostData.ts";
+
+// `ai21/jamba-large-1.7` is a documented free model (FREE_MODEL_BUDGETS,
+// one-time-initial) that is NOT in the table (grep jamba -> 0 hit).
+// `openai/gpt-4o` is paid. Fixtures are verbatim catalog ids — never a suffixed
+// invention (Set.has is exact: a mutilated id is no longer in the catalog).
+test("off-table free model is free, never premium-priced", () => {
+ const p = getModelPricing("ai21", "jamba-large-1.7");
+ assert.equal(p.isFree, true);
+ assert.equal(p.inputCostPer1M, 0);
+ assert.equal(p.outputCostPer1M, 0);
+});
+
+test("prefixed model id still resolves through the catalog", () => {
+ const p = getModelPricing("ai21", "ai21/jamba-large-1.7");
+ assert.equal(p.isFree, true);
+});
+
+test("off-table paid model keeps the conservative fallback", () => {
+ const p = getModelPricing("openai", "gpt-9-never-existed");
+ assert.equal(p.isFree, false);
+ assert.equal(p.inputCostPer1M, 5.0);
+ assert.equal(p.outputCostPer1M, 15.0);
+});
+
+test("table hits are untouched", () => {
+ assert.equal(Object.keys(KNOWN_MODEL_PRICING).length, 21);
+ assert.deepEqual(getModelPricing("openai", "gpt-4o"), KNOWN_MODEL_PRICING["gpt-4o"]);
+ assert.deepEqual(getModelPricing("longcat", "LongCat-2.0"), KNOWN_MODEL_PRICING["longcat-2.0"]);
+});
diff --git a/tests/unit/provider-plugin-manifest.test.ts b/tests/unit/provider-plugin-manifest.test.ts
index c1db75bc82b..85ebba8d1e3 100644
--- a/tests/unit/provider-plugin-manifest.test.ts
+++ b/tests/unit/provider-plugin-manifest.test.ts
@@ -8,6 +8,7 @@ import {
import type { RegistryEntry } from "../../open-sse/config/providers/shared.ts";
import { USAGE_FETCHER_PROVIDERS } from "../../open-sse/services/usage/fetcherProviders.ts";
import { USAGE_SUPPORTED_PROVIDERS } from "../../open-sse/services/usage/supportedProviders.ts";
+import { hasFreeTierProvider } from "../../open-sse/config/freeTierProviders.ts";
const registryFixture: Record = {
openai: {
@@ -261,3 +262,138 @@ test("usage-supported matches only on id, not alias (#10078)", () => {
);
assert.ok(entry.capabilities.includes("usage-fetch"));
});
+
+test("manifest emits free-tier for a provider with documented free models", () => {
+ const entry = getProviderPluginManifestEntryFromRegistry(
+ {
+ ...registryFixture,
+ "api-airforce": {
+ id: "api-airforce",
+ alias: "af",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://api.airforce/v1/chat/completions",
+ authType: "apikey",
+ authHeader: "bearer",
+ defaultContextLength: 128000,
+ models: [{ id: "x-ai/grok-3", name: "Grok-3 (Free)" }],
+ },
+ "legacy-free": {
+ id: "legacy-free",
+ alias: "api-airforce",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://legacy.example/v1",
+ authType: "apikey",
+ authHeader: "bearer",
+ models: [{ id: "legacy-model", name: "Legacy" }],
+ },
+ "definitely-not-a-provider-xyz": {
+ id: "definitely-not-a-provider-xyz",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://xyz.example/v1",
+ authType: "apikey",
+ authHeader: "bearer",
+ models: [{ id: "xyz-model", name: "Xyz" }],
+ },
+ pollinations: {
+ id: "pollinations",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://text.pollinations.ai/v1",
+ authType: "optional",
+ authHeader: "bearer",
+ models: [{ id: "openai", name: "OpenAI (free)" }],
+ },
+ },
+ "api-airforce"
+ );
+ assert.ok(entry);
+ assert.ok(entry.capabilities.includes("free-tier"));
+});
+
+test("manifest emits free-tier via alias-only branch (id outside set, alias inside)", () => {
+ assert.equal(hasFreeTierProvider("legacy-free"), false);
+ assert.equal(hasFreeTierProvider("api-airforce"), true);
+ const entry = getProviderPluginManifestEntryFromRegistry(
+ {
+ ...registryFixture,
+ "legacy-free": {
+ id: "legacy-free",
+ alias: "api-airforce",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://legacy.example/v1",
+ authType: "apikey",
+ authHeader: "bearer",
+ models: [{ id: "legacy-model", name: "Legacy" }],
+ },
+ },
+ "legacy-free"
+ );
+ assert.ok(entry);
+ assert.ok(entry.capabilities.includes("free-tier"));
+});
+
+test("manifest omits free-tier for a provider with no free models", () => {
+ const entry = getProviderPluginManifestEntryFromRegistry(
+ {
+ ...registryFixture,
+ "definitely-not-a-provider-xyz": {
+ id: "definitely-not-a-provider-xyz",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://xyz.example/v1",
+ authType: "apikey",
+ authHeader: "bearer",
+ models: [{ id: "xyz-model", name: "Xyz" }],
+ },
+ },
+ "definitely-not-a-provider-xyz"
+ );
+ assert.ok(entry);
+ assert.equal(entry.capabilities.includes("free-tier"), false);
+});
+
+test("manifest emits free-tier for pollinations despite discontinued rows", () => {
+ const entry = getProviderPluginManifestEntryFromRegistry(
+ {
+ ...registryFixture,
+ pollinations: {
+ id: "pollinations",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://text.pollinations.ai/v1",
+ authType: "optional",
+ authHeader: "bearer",
+ models: [{ id: "openai", name: "OpenAI (free)" }],
+ },
+ },
+ "pollinations"
+ );
+ assert.ok(entry);
+ assert.ok(entry.capabilities.includes("free-tier"));
+});
+
+test("free-tier capability keeps capabilities sorted", () => {
+ const entry = getProviderPluginManifestEntryFromRegistry(
+ {
+ ...registryFixture,
+ "api-airforce": {
+ id: "api-airforce",
+ alias: "af",
+ format: "openai",
+ executor: "default",
+ baseUrl: "https://api.airforce/v1/chat/completions",
+ authType: "apikey",
+ authHeader: "bearer",
+ defaultContextLength: 128000,
+ models: [{ id: "x-ai/grok-3", name: "Grok-3 (Free)" }],
+ },
+ },
+ "api-airforce"
+ );
+ assert.ok(entry);
+ assert.deepEqual(entry.capabilities, [...entry.capabilities].sort());
+});
diff --git a/tests/unit/tier-pricing-cache.test.ts b/tests/unit/tier-pricing-cache.test.ts
new file mode 100644
index 00000000000..844cfaafa63
--- /dev/null
+++ b/tests/unit/tier-pricing-cache.test.ts
@@ -0,0 +1,50 @@
+// tests/unit/tier-pricing-cache.test.ts
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+ classifyTier,
+ classifyTierAsync,
+ clearTierCache,
+} from "../../open-sse/services/tierResolver.ts";
+import { updatePricing, resetPricing, resetAllPricing } from "../../src/lib/db/settings/pricing.ts";
+
+test.beforeEach(() => clearTierCache());
+
+test("async tier reflects a DB price write without restart", async () => {
+ try {
+ await updatePricing({ testprov: { "testmodel-cache-1": { input: 0, output: 0 } } });
+ const a = await classifyTierAsync("testprov", "testmodel-cache-1");
+ assert.equal(a.tier, "free");
+ } finally {
+ await resetPricing("testprov", "testmodel-cache-1");
+ }
+});
+
+test("resetAllPricing (full wipe, no read-cache bust) also falls back cleanly", async () => {
+ try {
+ await updatePricing({ testprov: { "testmodel-cache-2": { input: 0, output: 0 } } });
+ assert.equal((await classifyTierAsync("testprov", "testmodel-cache-2")).tier, "free");
+ await resetAllPricing();
+ const back = await classifyTierAsync("testprov", "testmodel-cache-2");
+ assert.equal(back.tier, classifyTier("testprov", "testmodel-cache-2").tier);
+ } finally {
+ await resetPricing("testprov");
+ }
+});
+
+test("async tier falls back to sync when DB is down", async () => {
+ const a = await classifyTierAsync("openai", "gpt-4o");
+ assert.deepEqual(a, classifyTier("openai", "gpt-4o"));
+});
+
+test("sync tier keeps serving the table while DB changes", async () => {
+ // Fictitious model on a real provider: never pollutes shared state if cleanup fails.
+ const before = classifyTier("openai", "gpt-9-never-existed");
+ try {
+ await updatePricing({ openai: { "gpt-9-never-existed": { input: 0, output: 0 } } });
+ const during = classifyTier("openai", "gpt-9-never-existed");
+ assert.equal(during.tier, before.tier); // sync path untouched by DB
+ } finally {
+ await resetPricing("openai", "gpt-9-never-existed");
+ }
+});
diff --git a/tests/unit/virtualFactory-snapshot-breaker.test.ts b/tests/unit/virtualFactory-snapshot-breaker.test.ts
new file mode 100644
index 00000000000..fb046abe959
--- /dev/null
+++ b/tests/unit/virtualFactory-snapshot-breaker.test.ts
@@ -0,0 +1,90 @@
+// tests/unit/virtualFactory-snapshot-breaker.test.ts
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+ computeSnapshotWeights,
+ type VirtualAutoComboCandidate,
+} from "../../open-sse/services/autoCombo/virtualFactory.ts";
+import type { ScoringWeights } from "../../open-sse/services/autoCombo/scoring.ts";
+
+describe("computeSnapshotWeights breaker and quality", () => {
+ const weights: ScoringWeights = {
+ quota: 0.1,
+ health: 0.3,
+ costInv: 0.05,
+ latencyInv: 0.05,
+ taskFit: 0.05,
+ stability: 0.05,
+ tierPriority: 0.05,
+ tierAffinity: 0,
+ specificityMatch: 0,
+ contextAffinity: 0,
+ sessionAvailability: 0.05,
+ resetWindowAffinity: 0,
+ connectionDensity: 0.05,
+ quality: 0.1,
+ reliability: 0,
+ } as ScoringWeights;
+ type BreakerMap = ReadonlyMap;
+ it("OPEN scores lower than CLOSED (same quality)", () => {
+ const c: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ quality: 0.8,
+ };
+ const open: BreakerMap = new Map([["openai", "OPEN"]]);
+ const closed: BreakerMap = new Map([["openai", "CLOSED"]]);
+ const sOpen = computeSnapshotWeights([c], weights, open).get("openai/gpt-4o")!;
+ const sClosed = computeSnapshotWeights([c], weights, closed).get("openai/gpt-4o")!;
+ assert.ok(sClosed > sOpen, `closed ${sClosed} should > open ${sOpen}`);
+ });
+ it("HALF_OPEN is midpoint, absent breaker → neutral 0.5", () => {
+ const c: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ };
+ const half: BreakerMap = new Map([["openai", "HALF_OPEN"]]);
+ const sHalf = computeSnapshotWeights([c], weights, half).get("openai/gpt-4o")!;
+ const sNone = computeSnapshotWeights([c], weights).get("openai/gpt-4o")!;
+ const sOpen = computeSnapshotWeights(
+ [c],
+ weights,
+ new Map([["openai", "OPEN"]]) as BreakerMap
+ ).get("openai/gpt-4o")!;
+ const sClosed = computeSnapshotWeights(
+ [c],
+ weights,
+ new Map([["openai", "CLOSED"]]) as BreakerMap
+ ).get("openai/gpt-4o")!;
+ assert.ok(sHalf > sOpen && sHalf < sClosed);
+ // absent → existing 0.5* health — between open and closed
+ assert.ok(sNone > sOpen && sNone < sClosed);
+ });
+ it("quality cold 0.5 vs hot 0.9 discriminant when weights.quality>0", () => {
+ const cold: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ quality: undefined,
+ };
+ const hot: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ quality: 0.9,
+ };
+ const sCold = computeSnapshotWeights([cold], weights).get("openai/gpt-4o")!;
+ const sHot = computeSnapshotWeights([hot], weights).get("openai/gpt-4o")!;
+ assert.ok(sHot > sCold);
+ });
+});
diff --git a/tests/unit/virtualFactory-snapshot-quality.test.ts b/tests/unit/virtualFactory-snapshot-quality.test.ts
new file mode 100644
index 00000000000..7aee2c6a857
--- /dev/null
+++ b/tests/unit/virtualFactory-snapshot-quality.test.ts
@@ -0,0 +1,75 @@
+// tests/unit/virtualFactory-snapshot-quality.test.ts
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+ computeSnapshotWeights,
+ type VirtualAutoComboCandidate,
+} from "../../open-sse/services/autoCombo/virtualFactory.ts";
+import type { ScoringWeights } from "../../open-sse/services/autoCombo/scoring.ts";
+import { createModelCapabilityResolutionSnapshot } from "../../src/lib/modelCapabilities.ts";
+
+describe("virtualFactory snapshot quality", () => {
+ it("factory-built candidate carries finite quality (attach path, both pools)", async () => {
+ // Exercises the REAL hydration path: push a raw candidate through
+ // attachPreparedCapabilityValues:547-598 (covers regular + family pools —
+ // both go through attach, so one call proves both).
+ const { attachPreparedCapabilityValues } =
+ await import("../../open-sse/services/autoCombo/virtualFactory.ts");
+ const raw: VirtualAutoComboCandidate[] = [
+ {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ },
+ ];
+ const state = {
+ byTarget: new Map(),
+ resolvedSinceYield: 0,
+ resolutionSnapshot: createModelCapabilityResolutionSnapshot(),
+ };
+ const out = await attachPreparedCapabilityValues(raw, state);
+ const q = out[0]?.quality;
+ assert.ok(
+ typeof q === "number" && Number.isFinite(q) && q >= 0 && q <= 1,
+ `quality ${q} must be finite 0..1`
+ );
+ });
+ it("hot quality outranks cold through computeSnapshotWeights", () => {
+ const weights = {
+ quota: 0.1,
+ health: 0.1,
+ quality: 0.3,
+ taskFit: 0,
+ stability: 0,
+ tierPriority: 0,
+ costInv: 0,
+ latencyInv: 0,
+ } as ScoringWeights;
+ const cold: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ quality: 0.5,
+ };
+ const hot: VirtualAutoComboCandidate = {
+ provider: "openai",
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ connectionId: null,
+ costPer1MTokens: 5,
+ quality: 0.9,
+ };
+ const sCold = computeSnapshotWeights([cold], weights).get("openai/gpt-4o")!;
+ const sHot = computeSnapshotWeights([hot], weights).get("openai/gpt-4o")!;
+ assert.ok(sHot > sCold, `hot ${sHot} should exceed cold ${sCold}`);
+ });
+ it("hydration stores a finite 0..1 quality (not NaN)", async () => {
+ const { getQualityScore } = await import("../../open-sse/services/routing/quality.ts");
+ const q = getQualityScore("openai", "gpt-4o");
+ assert.ok(typeof q === "number" && Number.isFinite(q) && q >= 0 && q <= 1);
+ });
+});
diff --git a/tests/unit/virtualFactory-valuation.test.ts b/tests/unit/virtualFactory-valuation.test.ts
new file mode 100644
index 00000000000..79f9665c1f5
--- /dev/null
+++ b/tests/unit/virtualFactory-valuation.test.ts
@@ -0,0 +1,47 @@
+// tests/unit/virtualFactory-valuation.test.ts (part 1 — reliability)
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { computeSnapshotWeights } from "../../open-sse/services/autoCombo/virtualFactory.ts";
+import { resolveVirtualCost } from "../../open-sse/services/providerCostData.ts";
+import { DEFAULT_WEIGHTS } from "../../open-sse/services/autoCombo/scoring.ts";
+
+function candidate(over: Record = {}) {
+ return {
+ provider: "openai",
+ connectionId: null,
+ model: "gpt-4o",
+ modelStr: "openai/gpt-4o",
+ costPer1MTokens: 5,
+ ...over,
+ } as never;
+}
+
+test("absent failure rate reads fully reliable (neutral 1)", () => {
+ const weights = { ...DEFAULT_WEIGHTS, reliability: 0.2 };
+ const scores = computeSnapshotWeights([candidate()], weights);
+ const base = computeSnapshotWeights([candidate()], { ...DEFAULT_WEIGHTS, reliability: 0 });
+ const delta0 = scores.get("openai/gpt-4o")! - base.get("openai/gpt-4o")!;
+ assert.ok(Math.abs(delta0 - 0.2) < 1e-9, `expected 0.2, got ${delta0}`);
+});
+
+test("failureRate 0.2 scales the reliability weight to 0.8", () => {
+ const weights = { ...DEFAULT_WEIGHTS, reliability: 0.2 };
+ const scores = computeSnapshotWeights([candidate({ failureRate: 0.2 })], weights);
+ const base = computeSnapshotWeights([candidate()], { ...DEFAULT_WEIGHTS, reliability: 0 });
+ const delta = scores.get("openai/gpt-4o")! - base.get("openai/gpt-4o")!;
+ assert.ok(Math.abs(delta - 0.16) < 1e-9, `expected 0.16, got ${delta}`);
+});
+
+test("errorRate backs up a missing failureRate", () => {
+ const weights = { ...DEFAULT_WEIGHTS, reliability: 0.2 };
+ const scores = computeSnapshotWeights([candidate({ errorRate: 0.5 })], weights);
+ const base = computeSnapshotWeights([candidate()], { ...DEFAULT_WEIGHTS, reliability: 0 });
+ const delta = scores.get("openai/gpt-4o")! - base.get("openai/gpt-4o")!;
+ assert.ok(Math.abs(delta - 0.1) < 1e-9, `expected 0.1, got ${delta}`);
+});
+
+test("virtual cost helper returns real table costs, not zero", () => {
+ assert.equal(resolveVirtualCost("openai", "gpt-4o"), 2.5);
+ assert.equal(resolveVirtualCost("ai21", "jamba-large-1.7"), 0); // catalog free
+ assert.equal(resolveVirtualCost("openai", "gpt-9-never-existed"), 5.0); // conservative fallback
+});