mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-07-26 09:52:11 +03:00
75b52e2867
OC 1.17.8+ native-adapter gate (Ji() in bundled client) rejects any
model whose providerID is not exactly 'openai', 'anthropic', or does
not start with 'opencode'. The plugin's default providerId ('omniroute')
fails this gate, so every model dispatch returns 'Unable to determine
provider'. Auto-prefix in resolveOmniRoutePluginOptions so existing
opencode.json configs (providerId: 'omniroute') keep working without
user-facing changes — internally every catalog key, ModelV2 field,
and auth hook sees 'opencode-omniroute'.
The prefix also fixes the auth.json key mismatch: the resolved
(opencode-omniroute) key is what OC 1.17.8+ dispatcher reads when
looking up credentials.
1069 lines
41 KiB
TypeScript
1069 lines
41 KiB
TypeScript
/**
|
|
* Features-block tests.
|
|
*
|
|
* Covers the v0.1.0 `features` toggle block + the enrichment / compression
|
|
* metadata fetchers + the MCP auto-emit branch on the config hook.
|
|
*
|
|
* Surfaces tested:
|
|
* - `parseOmniRoutePluginOptions({ features: ... })` → schema accept/reject
|
|
* - `applyEnrichment(model, entry)` → mutation semantics
|
|
* - `formatCompressionPipeline(steps)` → display formatting
|
|
* - `createOmniRouteProviderHook` with mocked
|
|
* `enrichmentFetcher` / `compressionMetaFetcher` → overlay applied,
|
|
* off-by-default
|
|
* gating works.
|
|
* - `createOmniRouteConfigHook` with `features.mcpAutoEmit:true`
|
|
* → emits mcp entry
|
|
* → falls back to
|
|
* provider apiKey
|
|
* when mcpToken
|
|
* is unset
|
|
* → respects operator
|
|
* override
|
|
* → no emit when
|
|
* mcpAutoEmit is
|
|
* false / unset
|
|
*/
|
|
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
applyEnrichment,
|
|
applyProviderTag,
|
|
buildAliasIndex,
|
|
buildCanonicalToAliasMap,
|
|
canonicalDedupSet,
|
|
createOmniRouteConfigHook,
|
|
createOmniRouteProviderHook,
|
|
defaultOmniRouteEnrichmentFetcher,
|
|
defaultOmniRouteCompressionMetaFetcher,
|
|
formatCompressionPipeline,
|
|
lookupEnrichment,
|
|
parseOmniRoutePluginOptions,
|
|
PROVIDER_TAG_SEPARATOR,
|
|
resolveProviderTagEntry,
|
|
type OmniRouteEnrichmentMap,
|
|
type OmniRouteCompressionCombo,
|
|
type OmniRouteRawModelEntry,
|
|
} from "../src/index.js";
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Zod schema — features block
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("parseOmniRoutePluginOptions: empty features object → preserved", () => {
|
|
const r = parseOmniRoutePluginOptions({ features: {} });
|
|
assert.deepEqual(r, { features: {} });
|
|
});
|
|
|
|
test("parseOmniRoutePluginOptions: all boolean features set → preserved", () => {
|
|
const r = parseOmniRoutePluginOptions({
|
|
features: {
|
|
combos: true,
|
|
enrichment: true,
|
|
compressionMetadata: true,
|
|
geminiSanitization: true,
|
|
mcpAutoEmit: true,
|
|
fetchInterceptor: true,
|
|
},
|
|
});
|
|
assert.equal(r.features?.combos, true);
|
|
assert.equal(r.features?.enrichment, true);
|
|
assert.equal(r.features?.compressionMetadata, true);
|
|
assert.equal(r.features?.mcpAutoEmit, true);
|
|
});
|
|
|
|
test("parseOmniRoutePluginOptions: mcpToken string → preserved", () => {
|
|
const r = parseOmniRoutePluginOptions({
|
|
features: { mcpAutoEmit: true, mcpToken: "sk-mcp-only-token-12345" },
|
|
});
|
|
assert.equal(r.features?.mcpToken, "sk-mcp-only-token-12345");
|
|
});
|
|
|
|
test("parseOmniRoutePluginOptions: unknown features key → throws (strict)", () => {
|
|
assert.throws(
|
|
() =>
|
|
parseOmniRoutePluginOptions({
|
|
features: { combos: true, unknown_field: "oops" },
|
|
}),
|
|
/Invalid @omniroute\/opencode-plugin options/
|
|
);
|
|
});
|
|
|
|
test("parseOmniRoutePluginOptions: non-boolean for boolean feature → throws", () => {
|
|
assert.throws(
|
|
() =>
|
|
parseOmniRoutePluginOptions({
|
|
features: { combos: "yes" as unknown as boolean },
|
|
}),
|
|
/Invalid @omniroute\/opencode-plugin options/
|
|
);
|
|
});
|
|
|
|
test("parseOmniRoutePluginOptions: empty mcpToken → throws (min 1)", () => {
|
|
assert.throws(
|
|
() => parseOmniRoutePluginOptions({ features: { mcpToken: "" } }),
|
|
/Invalid @omniroute\/opencode-plugin options/
|
|
);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// applyEnrichment
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
const baseModel = () => ({
|
|
id: "claude-sonnet-4-6",
|
|
name: "claude-sonnet-4-6",
|
|
capabilities: {
|
|
temperature: true,
|
|
reasoning: false,
|
|
attachment: false,
|
|
toolcall: false,
|
|
input: { text: true, audio: false, image: false, video: false, pdf: false },
|
|
output: { text: true, audio: false, image: false, video: false, pdf: false },
|
|
interleaved: false,
|
|
},
|
|
cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
|
|
limit: { context: 200000, output: 64000 },
|
|
status: "active" as const,
|
|
options: {},
|
|
headers: {},
|
|
release_date: "",
|
|
providerID: "omniroute",
|
|
api: {
|
|
id: "openai-compatible" as const,
|
|
url: "https://or.example.com/v1",
|
|
npm: "@ai-sdk/openai-compatible",
|
|
},
|
|
});
|
|
|
|
test("applyEnrichment: undefined entry → no-op", () => {
|
|
const m = baseModel();
|
|
const orig = JSON.parse(JSON.stringify(m));
|
|
applyEnrichment(m as never, undefined);
|
|
assert.deepEqual(m, orig);
|
|
});
|
|
|
|
test("applyEnrichment: name overlay applied", () => {
|
|
const m = baseModel();
|
|
applyEnrichment(m as never, { name: "Claude Sonnet 4.6" });
|
|
assert.equal(m.name, "Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyEnrichment: empty name string ignored", () => {
|
|
const m = baseModel();
|
|
applyEnrichment(m as never, { name: " " });
|
|
assert.equal(m.name, "claude-sonnet-4-6"); // raw id untouched
|
|
});
|
|
|
|
test("applyEnrichment: pricing fields applied to cost", () => {
|
|
const m = baseModel();
|
|
applyEnrichment(m as never, {
|
|
pricing: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
|
|
});
|
|
assert.equal(m.cost.input, 3);
|
|
assert.equal(m.cost.output, 15);
|
|
assert.equal(m.cost.cache.read, 0.3);
|
|
assert.equal(m.cost.cache.write, 3.75);
|
|
});
|
|
|
|
test("applyEnrichment: partial pricing preserves untouched fields", () => {
|
|
const m = baseModel();
|
|
m.cost = { input: 1, output: 2, cache: { read: 0.1, write: 0.2 } };
|
|
applyEnrichment(m as never, { pricing: { input: 99 } });
|
|
assert.equal(m.cost.input, 99);
|
|
assert.equal(m.cost.output, 2);
|
|
assert.equal(m.cost.cache.read, 0.1);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// applyProviderTag (Option E)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("applyProviderTag: PROVIDER_TAG_SEPARATOR is hyphen with surrounding spaces", () => {
|
|
assert.equal(PROVIDER_TAG_SEPARATOR, " - ");
|
|
});
|
|
|
|
test("applyProviderTag: undefined enrichment → no-op", () => {
|
|
const m = baseModel();
|
|
m.name = "Claude Sonnet 4.6";
|
|
applyProviderTag(m as never, undefined);
|
|
assert.equal(m.name, "Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyProviderTag: providerDisplayName present (short) → label prefix prepended", () => {
|
|
const m = baseModel();
|
|
m.name = "Claude Sonnet 4.6";
|
|
applyProviderTag(m as never, { providerDisplayName: "Claude" });
|
|
assert.equal(m.name, "Claude - Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyProviderTag: providerDisplayName too long → falls back to UPPER(alias) prefix", () => {
|
|
const m = baseModel();
|
|
m.name = "GPT 5";
|
|
applyProviderTag(m as never, {
|
|
providerDisplayName: "GitHub Models",
|
|
providerAlias: "ghm",
|
|
});
|
|
assert.equal(m.name, "GHM - GPT 5");
|
|
});
|
|
|
|
test("applyProviderTag: long displayName + no alias → uses long label rather than dropping prefix", () => {
|
|
const m = baseModel();
|
|
m.name = "GPT 5";
|
|
applyProviderTag(m as never, { providerDisplayName: "GitHub Models" });
|
|
assert.equal(m.name, "GitHub Models - GPT 5");
|
|
});
|
|
|
|
test("applyProviderTag: only providerAlias known → UPPER(alias) prefix", () => {
|
|
const m = baseModel();
|
|
m.name = "Claude Sonnet 4.6";
|
|
applyProviderTag(m as never, { providerAlias: "cc" });
|
|
assert.equal(m.name, "CC - Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyProviderTag: long alias (no displayName) → title-case fallback, not shouty UPPER", () => {
|
|
const m = baseModel();
|
|
m.name = "Gemini 2.5 Flash";
|
|
applyProviderTag(m as never, { providerAlias: "antigravity" });
|
|
assert.equal(m.name, "Antigravity - Gemini 2.5 Flash");
|
|
});
|
|
|
|
test("applyProviderTag: displayName fits new 12-char cap → used verbatim (AssemblyAI/Antigravity)", () => {
|
|
const m1 = baseModel();
|
|
m1.name = "Universal 2 (Transcription)";
|
|
applyProviderTag(m1 as never, { providerDisplayName: "AssemblyAI", providerAlias: "aai" });
|
|
assert.equal(m1.name, "AssemblyAI - Universal 2 (Transcription)");
|
|
|
|
const m2 = baseModel();
|
|
m2.name = "Gemini 2.5 Flash";
|
|
applyProviderTag(m2 as never, {
|
|
providerDisplayName: "Antigravity",
|
|
providerAlias: "antigravity",
|
|
});
|
|
assert.equal(m2.name, "Antigravity - Gemini 2.5 Flash");
|
|
});
|
|
|
|
test("applyProviderTag: empty/whitespace providerDisplayName + no alias → no-op", () => {
|
|
const m = baseModel();
|
|
m.name = "Claude Sonnet 4.6";
|
|
applyProviderTag(m as never, { providerDisplayName: " " });
|
|
assert.equal(m.name, "Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyProviderTag: idempotent — second call doesn't double-prefix", () => {
|
|
const m = baseModel();
|
|
m.name = "Claude Sonnet 4.6";
|
|
applyProviderTag(m as never, { providerDisplayName: "Claude" });
|
|
applyProviderTag(m as never, { providerDisplayName: "Claude" });
|
|
applyProviderTag(m as never, { providerDisplayName: "Claude" });
|
|
assert.equal(m.name, "Claude - Claude Sonnet 4.6");
|
|
});
|
|
|
|
test("applyProviderTag: distinct providers for same model id → two separate prefixes", () => {
|
|
const a = baseModel();
|
|
a.name = "Claude Opus 4.7";
|
|
applyProviderTag(a as never, { providerDisplayName: "Claude" });
|
|
assert.equal(a.name, "Claude - Claude Opus 4.7");
|
|
|
|
const b = baseModel();
|
|
b.name = "Claude Opus 4.7";
|
|
applyProviderTag(b as never, { providerDisplayName: "Kiro" });
|
|
assert.equal(b.name, "Kiro - Claude Opus 4.7");
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// formatCompressionPipeline
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("formatCompressionPipeline: empty pipeline → empty string", () => {
|
|
assert.equal(formatCompressionPipeline([]), "");
|
|
});
|
|
|
|
test("formatCompressionPipeline: single step with intensity → emoji", () => {
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "caveman", intensity: "full" }]),
|
|
"[caveman\u{1F7E0}]"
|
|
);
|
|
});
|
|
|
|
test("formatCompressionPipeline: multi-step pipeline → emoji per step", () => {
|
|
assert.equal(
|
|
formatCompressionPipeline([
|
|
{ engine: "rtk", intensity: "standard" },
|
|
{ engine: "caveman", intensity: "full" },
|
|
]),
|
|
"[rtk\u{1F7E1} → caveman\u{1F7E0}]"
|
|
);
|
|
});
|
|
|
|
test("formatCompressionPipeline: step without intensity → engine bare", () => {
|
|
assert.equal(formatCompressionPipeline([{ engine: "rtk" }]), "[rtk]");
|
|
});
|
|
|
|
test("formatCompressionPipeline: ultra → red", () => {
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "caveman", intensity: "ultra" }]),
|
|
"[caveman\u{1F534}]"
|
|
);
|
|
});
|
|
|
|
test("formatCompressionPipeline: lite/minimal → green", () => {
|
|
assert.equal(formatCompressionPipeline([{ engine: "rtk", intensity: "lite" }]), "[rtk\u{1F7E2}]");
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "rtk", intensity: "minimal" }]),
|
|
"[rtk\u{1F7E2}]"
|
|
);
|
|
});
|
|
|
|
test("formatCompressionPipeline: intensity case-insensitive", () => {
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "caveman", intensity: "ULTRA" }]),
|
|
"[caveman\u{1F534}]"
|
|
);
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "caveman", intensity: "Standard" }]),
|
|
"[caveman\u{1F7E1}]"
|
|
);
|
|
});
|
|
|
|
test("formatCompressionPipeline: unknown intensity falls back to raw text", () => {
|
|
assert.equal(
|
|
formatCompressionPipeline([{ engine: "rtk", intensity: "custom-thing" }]),
|
|
"[rtk:custom-thing]"
|
|
);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Provider hook — enrichment applied via injected fetcher
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
const SAMPLE_RAW: OmniRouteRawModelEntry[] = [
|
|
{
|
|
id: "claude-sonnet-4-6",
|
|
object: "model",
|
|
created: 0,
|
|
owned_by: "anthropic",
|
|
permission: [],
|
|
root: "claude-sonnet-4-6",
|
|
parent: null,
|
|
context_length: 200000,
|
|
max_output_tokens: 64000,
|
|
input_modalities: ["text", "image"],
|
|
output_modalities: ["text"],
|
|
capabilities: { tool_calling: true, reasoning: true, vision: true, thinking: true },
|
|
},
|
|
];
|
|
|
|
const apiAuth = (key: string) => ({ type: "api" as const, key });
|
|
|
|
test("provider hook: enrichment fetcher called when features.enrichment !== false", async () => {
|
|
let called = 0;
|
|
const enrichment: OmniRouteEnrichmentMap = new Map([
|
|
["claude-sonnet-4-6", { name: "Claude Sonnet 4.6", pricing: { input: 3, output: 15 } }],
|
|
]);
|
|
const hook = createOmniRouteProviderHook(
|
|
{ providerId: "omniroute", baseURL: "https://or.example.com/v1" },
|
|
{
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
enrichmentFetcher: async () => {
|
|
called++;
|
|
return enrichment;
|
|
},
|
|
}
|
|
);
|
|
const out = await hook.models!({} as never, { auth: apiAuth("sk") as never });
|
|
assert.equal(called, 1, "enrichment fetcher called once");
|
|
const m = out["opencode-omniroute/claude-sonnet-4-6"];
|
|
assert.equal(m.name, "Claude Sonnet 4.6", "enrichment name overlay applied");
|
|
assert.equal(m.cost.input, 3, "enrichment pricing applied");
|
|
assert.equal(m.cost.output, 15);
|
|
});
|
|
|
|
test("provider hook: enrichment fetcher NOT called when features.enrichment:false", async () => {
|
|
let called = 0;
|
|
const hook = createOmniRouteProviderHook(
|
|
{
|
|
providerId: "omniroute",
|
|
baseURL: "https://or.example.com/v1",
|
|
features: { enrichment: false },
|
|
},
|
|
{
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
enrichmentFetcher: async () => {
|
|
called++;
|
|
return new Map();
|
|
},
|
|
}
|
|
);
|
|
const out = await hook.models!({} as never, { auth: apiAuth("sk") as never });
|
|
assert.equal(called, 0, "enrichment fetcher NOT called when gated off");
|
|
assert.equal(
|
|
out["opencode-omniroute/claude-sonnet-4-6"].name,
|
|
"claude-sonnet-4-6",
|
|
"raw id preserved"
|
|
);
|
|
});
|
|
|
|
test("provider hook: compression metadata fetcher NOT called by default (opt-in)", async () => {
|
|
let called = 0;
|
|
const hook = createOmniRouteProviderHook(
|
|
{ providerId: "omniroute", baseURL: "https://or.example.com/v1" },
|
|
{
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
enrichmentFetcher: async () => new Map(),
|
|
compressionMetaFetcher: async () => {
|
|
called++;
|
|
return [];
|
|
},
|
|
}
|
|
);
|
|
await hook.models!({} as never, { auth: apiAuth("sk") as never });
|
|
assert.equal(called, 0, "compression metadata is opt-in (features.compressionMetadata:true)");
|
|
});
|
|
|
|
test("provider hook: compression metadata fetcher called when opted in", async () => {
|
|
let called = 0;
|
|
const compressionCombos: OmniRouteCompressionCombo[] = [
|
|
{
|
|
id: "default-caveman",
|
|
name: "Standard Savings",
|
|
pipeline: [
|
|
{ engine: "rtk", intensity: "standard" },
|
|
{ engine: "caveman", intensity: "full" },
|
|
],
|
|
isDefault: true,
|
|
},
|
|
];
|
|
const hook = createOmniRouteProviderHook(
|
|
{
|
|
providerId: "omniroute",
|
|
baseURL: "https://or.example.com/v1",
|
|
features: { compressionMetadata: true },
|
|
},
|
|
{
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [
|
|
{
|
|
id: "claude-primary",
|
|
name: "Claude Primary",
|
|
models: [{ id: "step-1", model: "claude-sonnet-4-6" }],
|
|
},
|
|
],
|
|
enrichmentFetcher: async () => new Map(),
|
|
compressionMetaFetcher: async () => {
|
|
called++;
|
|
return compressionCombos;
|
|
},
|
|
}
|
|
);
|
|
const out = await hook.models!({} as never, { auth: apiAuth("sk") as never });
|
|
assert.equal(called, 1, "compression metadata fetcher called");
|
|
const combo = out["opencode-omniroute/claude-primary"];
|
|
assert.ok(combo, "combo entry present");
|
|
assert.match(
|
|
combo.name,
|
|
/\[rtk\u{1F7E1} → caveman\u{1F7E0}\]/u,
|
|
"combo name decorated with emoji pipeline (rtk:standard=🟡, caveman:full=🟠)"
|
|
);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Config hook — MCP auto-emit
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
const stubAuthJson = (apiKey: string) => async () => ({
|
|
"opencode-omniroute": { type: "api" as const, key: apiKey },
|
|
});
|
|
|
|
test("config hook: MCP auto-emit OFF by default (no mcp entry)", async () => {
|
|
const hook = createOmniRouteConfigHook(
|
|
{ providerId: "omniroute", baseURL: "https://or.example.com/v1" },
|
|
{
|
|
readAuthJson: stubAuthJson("sk-prod"),
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
logger: { warn: () => {} },
|
|
}
|
|
);
|
|
const input: { provider?: Record<string, unknown>; mcp?: Record<string, unknown> } = {};
|
|
await hook(input as never);
|
|
assert.ok(input.provider?.["opencode-omniroute"], "provider block written");
|
|
assert.equal(input.mcp, undefined, "no mcp block written");
|
|
});
|
|
|
|
test("config hook: features.mcpAutoEmit:true writes mcp entry with provider apiKey", async () => {
|
|
const hook = createOmniRouteConfigHook(
|
|
{
|
|
providerId: "omniroute",
|
|
baseURL: "https://or.example.com/v1",
|
|
features: { mcpAutoEmit: true },
|
|
},
|
|
{
|
|
readAuthJson: stubAuthJson("sk-prod-key"),
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
logger: { warn: () => {} },
|
|
}
|
|
);
|
|
const input: { provider?: Record<string, unknown>; mcp?: Record<string, unknown> } = {};
|
|
await hook(input as never);
|
|
const entry = input.mcp?.["opencode-omniroute"] as
|
|
| { type: string; url: string; enabled: boolean; headers: Record<string, string> }
|
|
| undefined;
|
|
assert.ok(entry, "mcp entry written");
|
|
assert.equal(entry.type, "remote");
|
|
assert.equal(
|
|
entry.url,
|
|
"https://or.example.com/api/mcp/stream",
|
|
"baseURL /v1 stripped to /api/mcp/stream"
|
|
);
|
|
assert.equal(entry.enabled, true);
|
|
assert.equal(entry.headers.Authorization, "Bearer sk-prod-key");
|
|
});
|
|
|
|
test("config hook: features.mcpToken overrides provider apiKey in mcp Bearer", async () => {
|
|
const hook = createOmniRouteConfigHook(
|
|
{
|
|
providerId: "omniroute",
|
|
baseURL: "https://or.example.com/v1",
|
|
features: { mcpAutoEmit: true, mcpToken: "sk-mcp-narrower" },
|
|
},
|
|
{
|
|
readAuthJson: stubAuthJson("sk-chat"),
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
logger: { warn: () => {} },
|
|
}
|
|
);
|
|
const input: { provider?: Record<string, unknown>; mcp?: Record<string, unknown> } = {};
|
|
await hook(input as never);
|
|
const entry = input.mcp?.["opencode-omniroute"] as { headers: Record<string, string> };
|
|
assert.equal(
|
|
entry.headers.Authorization,
|
|
"Bearer sk-mcp-narrower",
|
|
"mcpToken takes precedence over apiKey"
|
|
);
|
|
});
|
|
|
|
test("config hook: existing operator mcp.<providerId> wins (no overwrite)", async () => {
|
|
const hook = createOmniRouteConfigHook(
|
|
{
|
|
providerId: "omniroute",
|
|
baseURL: "https://or.example.com/v1",
|
|
features: { mcpAutoEmit: true },
|
|
},
|
|
{
|
|
readAuthJson: stubAuthJson("sk-prod"),
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
logger: { warn: () => {} },
|
|
}
|
|
);
|
|
const input: { provider?: Record<string, unknown>; mcp?: Record<string, unknown> } = {
|
|
mcp: { "opencode-omniroute": { type: "custom-user-entry", url: "https://manual.example/mcp" } },
|
|
};
|
|
await hook(input as never);
|
|
assert.deepEqual(
|
|
input.mcp?.["opencode-omniroute"],
|
|
{ type: "custom-user-entry", url: "https://manual.example/mcp" },
|
|
"operator override preserved"
|
|
);
|
|
});
|
|
|
|
test("config hook: features.mcpAutoEmit:true with /v1 in baseURL → strips correctly", async () => {
|
|
const hook = createOmniRouteConfigHook(
|
|
{
|
|
providerId: "omniroute-preprod",
|
|
baseURL: "https://or-preprod.example.com/v1",
|
|
features: { mcpAutoEmit: true },
|
|
},
|
|
{
|
|
readAuthJson: async () => ({
|
|
"opencode-omniroute-preprod": { type: "api" as const, key: "sk-preprod" },
|
|
}),
|
|
fetcher: async () => SAMPLE_RAW,
|
|
combosFetcher: async () => [],
|
|
logger: { warn: () => {} },
|
|
}
|
|
);
|
|
const input: { provider?: Record<string, unknown>; mcp?: Record<string, unknown> } = {};
|
|
await hook(input as never);
|
|
const entry = input.mcp?.["opencode-omniroute-preprod"] as { url: string };
|
|
assert.equal(
|
|
entry.url,
|
|
"https://or-preprod.example.com/api/mcp/stream",
|
|
"/v1 stripped, /api/mcp/stream appended"
|
|
);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Default fetchers — soft-fail behavior (no real network)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("defaultOmniRouteEnrichmentFetcher: empty baseURL → empty map", async () => {
|
|
const m = await defaultOmniRouteEnrichmentFetcher("", "sk", 100);
|
|
assert.equal(m.size, 0);
|
|
});
|
|
|
|
test("defaultOmniRouteEnrichmentFetcher: empty apiKey → empty map", async () => {
|
|
const m = await defaultOmniRouteEnrichmentFetcher("https://or.example.com", "", 100);
|
|
assert.equal(m.size, 0);
|
|
});
|
|
|
|
test("defaultOmniRouteCompressionMetaFetcher: empty baseURL → empty array", async () => {
|
|
const arr = await defaultOmniRouteCompressionMetaFetcher("", "sk", 100);
|
|
assert.equal(arr.length, 0);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Default enrichment fetcher — joins /api/pricing/models (names) with
|
|
// /api/pricing (per-model per-million-token pricing). The two endpoints are
|
|
// fetched independently; either may soft-fail. Verified via a stub fetch
|
|
// installed on globalThis.
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("defaultOmniRouteEnrichmentFetcher: merges names from /api/pricing/models and prices from /api/pricing", async () => {
|
|
const origFetch = globalThis.fetch;
|
|
const calls: string[] = [];
|
|
globalThis.fetch = (async (input: unknown) => {
|
|
const url = typeof input === "string" ? input : (input as { url: string }).url;
|
|
calls.push(url);
|
|
if (url.endsWith("/api/pricing/models")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
cc: {
|
|
id: "cc",
|
|
alias: "cc",
|
|
name: "Cc",
|
|
models: [
|
|
{ id: "claude-opus-4-7", name: "Claude Opus 4.7", custom: false },
|
|
{ id: "claude-sonnet-4-6", name: "Claude 4.6 Sonnet", custom: false },
|
|
],
|
|
},
|
|
}),
|
|
{ status: 200, headers: { "Content-Type": "application/json" } }
|
|
);
|
|
}
|
|
if (url.endsWith("/api/pricing")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
cc: {
|
|
"claude-opus-4-7": {
|
|
input: 5,
|
|
output: 25,
|
|
cached: 0.5,
|
|
cache_creation: 6.25,
|
|
reasoning: 25,
|
|
},
|
|
"claude-sonnet-4-6": {
|
|
input: 3,
|
|
output: 15,
|
|
},
|
|
},
|
|
}),
|
|
{ status: 200, headers: { "Content-Type": "application/json" } }
|
|
);
|
|
}
|
|
return new Response("not found", { status: 404 });
|
|
}) as typeof fetch;
|
|
|
|
try {
|
|
const map = await defaultOmniRouteEnrichmentFetcher(
|
|
"https://or.example.com/v1",
|
|
"sk-test",
|
|
5_000
|
|
);
|
|
assert.ok(
|
|
calls.some((u) => u.endsWith("/api/pricing/models")),
|
|
"catalog endpoint hit"
|
|
);
|
|
assert.ok(
|
|
calls.some((u) => u.endsWith("/api/pricing")),
|
|
"pricing endpoint hit"
|
|
);
|
|
const opus = map.get("cc/claude-opus-4-7");
|
|
assert.ok(opus, "namespaced entry present");
|
|
assert.equal(opus?.name, "Claude Opus 4.7", "name from /api/pricing/models");
|
|
assert.equal(opus?.pricing?.input, 5, "input price merged");
|
|
assert.equal(opus?.pricing?.output, 25, "output price merged");
|
|
assert.equal(opus?.pricing?.cacheRead, 0.5, "cached → cacheRead alias");
|
|
assert.equal(opus?.pricing?.cacheWrite, 6.25, "cache_creation → cacheWrite alias");
|
|
const opusBare = map.get("claude-opus-4-7");
|
|
assert.ok(opusBare, "bare id entry present (collision-avoidance)");
|
|
assert.equal(opusBare?.name, "Claude Opus 4.7");
|
|
assert.equal(opusBare?.pricing?.input, 5);
|
|
const sonnet = map.get("cc/claude-sonnet-4-6");
|
|
assert.equal(sonnet?.name, "Claude 4.6 Sonnet");
|
|
assert.equal(sonnet?.pricing?.input, 3);
|
|
assert.equal(sonnet?.pricing?.output, 15);
|
|
assert.equal(sonnet?.pricing?.cacheRead, undefined, "no cached key → no cacheRead");
|
|
} finally {
|
|
globalThis.fetch = origFetch;
|
|
}
|
|
});
|
|
|
|
test("defaultOmniRouteEnrichmentFetcher: name-only when pricing endpoint 5xxs", async () => {
|
|
const origFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (input: unknown) => {
|
|
const url = typeof input === "string" ? input : (input as { url: string }).url;
|
|
if (url.endsWith("/api/pricing/models")) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
cc: { models: [{ id: "claude-opus-4-7", name: "Claude Opus 4.7", custom: false }] },
|
|
}),
|
|
{ status: 200, headers: { "Content-Type": "application/json" } }
|
|
);
|
|
}
|
|
return new Response("boom", { status: 500 });
|
|
}) as typeof fetch;
|
|
try {
|
|
const map = await defaultOmniRouteEnrichmentFetcher("https://or.example.com", "sk-test", 5_000);
|
|
const opus = map.get("cc/claude-opus-4-7");
|
|
assert.equal(opus?.name, "Claude Opus 4.7", "name still present");
|
|
assert.equal(opus?.pricing, undefined, "no pricing when /api/pricing fails");
|
|
} finally {
|
|
globalThis.fetch = origFetch;
|
|
}
|
|
});
|
|
|
|
test("defaultOmniRouteEnrichmentFetcher: pricing-only when catalog endpoint 5xxs", async () => {
|
|
const origFetch = globalThis.fetch;
|
|
globalThis.fetch = (async (input: unknown) => {
|
|
const url = typeof input === "string" ? input : (input as { url: string }).url;
|
|
if (url.endsWith("/api/pricing")) {
|
|
return new Response(JSON.stringify({ cc: { "claude-opus-4-7": { input: 5, output: 25 } } }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
return new Response("boom", { status: 500 });
|
|
}) as typeof fetch;
|
|
try {
|
|
const map = await defaultOmniRouteEnrichmentFetcher("https://or.example.com", "sk-test", 5_000);
|
|
const opus = map.get("cc/claude-opus-4-7");
|
|
assert.equal(opus?.pricing?.input, 5);
|
|
assert.equal(opus?.pricing?.output, 25);
|
|
assert.equal(opus?.name, undefined, "no name when catalog endpoint fails");
|
|
} finally {
|
|
globalThis.fetch = origFetch;
|
|
}
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// Canonical-twin dedup + alias-fallback lookup
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
function makeEnrichmentMap(
|
|
entries: Array<{
|
|
key: string;
|
|
name?: string;
|
|
providerAlias?: string;
|
|
providerCanonical?: string;
|
|
providerDisplayName?: string;
|
|
}>
|
|
): OmniRouteEnrichmentMap {
|
|
const map: OmniRouteEnrichmentMap = new Map();
|
|
for (const e of entries) {
|
|
map.set(e.key, {
|
|
name: e.name,
|
|
providerAlias: e.providerAlias,
|
|
providerCanonical: e.providerCanonical,
|
|
providerDisplayName: e.providerDisplayName,
|
|
});
|
|
}
|
|
return map;
|
|
}
|
|
|
|
test("buildCanonicalToAliasMap: maps canonical → alias when both present and distinct", () => {
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
{ key: "cx/gpt-5.5", providerAlias: "cx", providerCanonical: "codex" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
assert.equal(c2a.get("claude"), "cc");
|
|
assert.equal(c2a.get("codex"), "cx");
|
|
assert.equal(c2a.size, 2);
|
|
});
|
|
|
|
test("buildCanonicalToAliasMap: skips entries where alias === canonical (e.g. kiro)", () => {
|
|
const map = makeEnrichmentMap([
|
|
{ key: "kiro/claude-sonnet-4", providerAlias: "kiro", providerCanonical: "kiro" },
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
assert.equal(c2a.has("kiro"), false);
|
|
assert.equal(c2a.get("claude"), "cc");
|
|
assert.equal(c2a.size, 1);
|
|
});
|
|
|
|
test("buildCanonicalToAliasMap: undefined enrichment → empty map", () => {
|
|
const c2a = buildCanonicalToAliasMap(undefined);
|
|
assert.equal(c2a.size, 0);
|
|
});
|
|
|
|
test("buildCanonicalToAliasMap: first-wins on duplicate canonical", () => {
|
|
// Two aliases claiming same canonical — first registration wins.
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
{ key: "anthropic/claude-opus-4-7", providerAlias: "anthropic", providerCanonical: "claude" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
assert.equal(c2a.get("claude"), "cc");
|
|
});
|
|
|
|
test("lookupEnrichment: direct hit", () => {
|
|
const map = makeEnrichmentMap([{ key: "cc/claude-opus-4-7", name: "Claude Opus 4.7" }]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const hit = lookupEnrichment("cc/claude-opus-4-7", map, c2a);
|
|
assert.equal(hit?.name, "Claude Opus 4.7");
|
|
});
|
|
|
|
test("lookupEnrichment: canonical → alias fallback hits", () => {
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "cc/claude-opus-4-7",
|
|
name: "Claude Opus 4.7",
|
|
providerAlias: "cc",
|
|
providerCanonical: "claude",
|
|
},
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
// Caller asks for `claude/claude-opus-4-7` — should resolve via alias `cc`.
|
|
const hit = lookupEnrichment("claude/claude-opus-4-7", map, c2a);
|
|
assert.equal(hit?.name, "Claude Opus 4.7");
|
|
});
|
|
|
|
test("lookupEnrichment: short-alias (e.g. dg/nova-3) → bare-id fallback hits", () => {
|
|
// Fetcher writes both alias-key AND bare-id key. If alias isn't a known
|
|
// prefix in canonicalToAlias (no canonical mapping), bare-id fallback
|
|
// still rescues the row.
|
|
const map = makeEnrichmentMap([
|
|
{ key: "deepgram/nova-3", name: "Nova 3 (Transcription)" },
|
|
{ key: "nova-3", name: "Nova 3 (Transcription)" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
// `dg/nova-3` is the raw id — prefix `dg` not in canonicalToAlias map,
|
|
// but bare `nova-3` is. Bare fallback hits.
|
|
const hit = lookupEnrichment("dg/nova-3", map, c2a);
|
|
assert.equal(hit?.name, "Nova 3 (Transcription)");
|
|
});
|
|
|
|
test("lookupEnrichment: nothing matches → undefined", () => {
|
|
const map = makeEnrichmentMap([{ key: "cc/claude-opus-4-7", name: "Claude Opus 4.7" }]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const hit = lookupEnrichment("qoder/unknown-model", map, c2a);
|
|
assert.equal(hit, undefined);
|
|
});
|
|
|
|
test("lookupEnrichment: undefined enrichment map → undefined", () => {
|
|
const c2a = new Map<string, string>();
|
|
const hit = lookupEnrichment("cc/claude-opus-4-7", undefined, c2a);
|
|
assert.equal(hit, undefined);
|
|
});
|
|
|
|
test("canonicalDedupSet: drops canonical row when alias twin present", () => {
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const raw: OmniRouteRawModelEntry[] = [
|
|
{ id: "cc/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
{ id: "claude/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
];
|
|
const drop = canonicalDedupSet(raw, c2a);
|
|
assert.equal(drop.has("claude/claude-opus-4-7"), true);
|
|
assert.equal(drop.has("cc/claude-opus-4-7"), false);
|
|
assert.equal(drop.size, 1);
|
|
});
|
|
|
|
test("canonicalDedupSet: keeps standalone canonical row (no alias twin) — never hides a model", () => {
|
|
// Only canonical row present, no alias twin. Must NOT drop — otherwise
|
|
// we'd hide the model entirely from the catalog.
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const raw: OmniRouteRawModelEntry[] = [
|
|
{ id: "claude/claude-opus-99" } as OmniRouteRawModelEntry, // canonical only — no `cc/claude-opus-99`
|
|
];
|
|
const drop = canonicalDedupSet(raw, c2a);
|
|
assert.equal(drop.size, 0);
|
|
});
|
|
|
|
test("canonicalDedupSet: no enrichment / empty canonicalToAlias → no drops", () => {
|
|
const raw: OmniRouteRawModelEntry[] = [
|
|
{ id: "claude/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
{ id: "cc/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
];
|
|
const drop = canonicalDedupSet(raw, new Map());
|
|
assert.equal(drop.size, 0);
|
|
});
|
|
|
|
test("canonicalDedupSet: multi-provider — drops all canonical twins where alias exists", () => {
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cc/claude-opus-4-7", providerAlias: "cc", providerCanonical: "claude" },
|
|
{ key: "cx/gpt-5.5", providerAlias: "cx", providerCanonical: "codex" },
|
|
{ key: "pol/openai-large", providerAlias: "pol", providerCanonical: "pollinations" },
|
|
]);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const raw: OmniRouteRawModelEntry[] = [
|
|
{ id: "cc/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
{ id: "claude/claude-opus-4-7" } as OmniRouteRawModelEntry,
|
|
{ id: "cx/gpt-5.5" } as OmniRouteRawModelEntry,
|
|
{ id: "codex/gpt-5.5" } as OmniRouteRawModelEntry,
|
|
{ id: "pol/openai-large" } as OmniRouteRawModelEntry,
|
|
{ id: "pollinations/openai-large" } as OmniRouteRawModelEntry,
|
|
];
|
|
const drop = canonicalDedupSet(raw, c2a);
|
|
assert.equal(drop.has("claude/claude-opus-4-7"), true);
|
|
assert.equal(drop.has("codex/gpt-5.5"), true);
|
|
assert.equal(drop.has("pollinations/openai-large"), true);
|
|
assert.equal(drop.size, 3);
|
|
});
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
// buildAliasIndex + resolveProviderTagEntry — generic provider-prefix fallback
|
|
// (rescues `cohere/*` + `pollinations/*` rows where direct enrichment misses)
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
test("buildAliasIndex: indexes one entry per alias (first-wins on duplicates)", () => {
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "cohere/command-a",
|
|
providerAlias: "cohere",
|
|
providerCanonical: "cohere",
|
|
providerDisplayName: "Cohere",
|
|
},
|
|
{
|
|
key: "cohere/embed-v4",
|
|
providerAlias: "cohere",
|
|
providerCanonical: "cohere",
|
|
providerDisplayName: "Cohere",
|
|
},
|
|
{
|
|
key: "cc/claude-opus-4-7",
|
|
providerAlias: "cc",
|
|
providerCanonical: "claude",
|
|
providerDisplayName: "Claude",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
assert.equal(idx.size, 2);
|
|
assert.equal(idx.get("cohere")?.providerDisplayName, "Cohere");
|
|
assert.equal(idx.get("cc")?.providerDisplayName, "Claude");
|
|
});
|
|
|
|
test("buildAliasIndex: upgrades to first entry with non-empty providerDisplayName", () => {
|
|
const map = makeEnrichmentMap([
|
|
{ key: "cohere/a", providerAlias: "cohere", providerCanonical: "cohere" }, // no displayName
|
|
{
|
|
key: "cohere/b",
|
|
providerAlias: "cohere",
|
|
providerCanonical: "cohere",
|
|
providerDisplayName: "Cohere",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
assert.equal(idx.get("cohere")?.providerDisplayName, "Cohere");
|
|
});
|
|
|
|
test("buildAliasIndex: skips entries with no providerAlias", () => {
|
|
const map = makeEnrichmentMap([{ key: "orphan", providerCanonical: "something" }]);
|
|
assert.equal(buildAliasIndex(map).size, 0);
|
|
});
|
|
|
|
test("buildAliasIndex: undefined enrichment → empty map", () => {
|
|
assert.equal(buildAliasIndex(undefined).size, 0);
|
|
});
|
|
|
|
test("resolveProviderTagEntry: direct match returns the direct entry as-is", () => {
|
|
const direct = { providerAlias: "cc", providerDisplayName: "Claude" };
|
|
const idx = new Map();
|
|
const out = resolveProviderTagEntry("cc/claude-opus-4-7", direct, idx);
|
|
assert.equal(out, direct);
|
|
});
|
|
|
|
test("resolveProviderTagEntry: no direct, alias matches → synthesised entry from alias slot", () => {
|
|
// cohere class: direct lookup misses (model not in curated 10) but
|
|
// alias=cohere maps to the cohere slot in /api/pricing/models.
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "cohere/command-a",
|
|
providerAlias: "cohere",
|
|
providerCanonical: "cohere",
|
|
providerDisplayName: "Cohere",
|
|
name: "Command A",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
const out = resolveProviderTagEntry("cohere/rerank-multilingual-v3.0", undefined, idx);
|
|
assert.equal(out?.providerAlias, "cohere");
|
|
assert.equal(out?.providerDisplayName, "Cohere");
|
|
// Crucially: synthesised entry must NOT carry the slot's name (would
|
|
// overwrite the per-model name with the alias label).
|
|
assert.equal(out?.name, undefined);
|
|
});
|
|
|
|
test("resolveProviderTagEntry: canonical prefix → alias fallback (pollinations → pol)", () => {
|
|
// pollinations class: raw id uses canonical name `pollinations/`, but
|
|
// /api/pricing/models keys it under alias `pol`. canonicalToAlias map
|
|
// bridges the gap.
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "pol/openai-large",
|
|
providerAlias: "pol",
|
|
providerCanonical: "pollinations",
|
|
providerDisplayName: "Pollinations",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
const c2a = buildCanonicalToAliasMap(map);
|
|
const out = resolveProviderTagEntry("pollinations/klein", undefined, idx, c2a);
|
|
assert.equal(out?.providerAlias, "pol");
|
|
assert.equal(out?.providerCanonical, "pollinations");
|
|
assert.equal(out?.providerDisplayName, "Pollinations");
|
|
});
|
|
|
|
test("resolveProviderTagEntry: no prefix and no direct → returns direct (undefined)", () => {
|
|
const idx = new Map();
|
|
const out = resolveProviderTagEntry("bareid", undefined, idx);
|
|
assert.equal(out, undefined);
|
|
});
|
|
|
|
test("resolveProviderTagEntry: prefix unknown to alias index → returns direct (undefined)", () => {
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "cc/x",
|
|
providerAlias: "cc",
|
|
providerCanonical: "claude",
|
|
providerDisplayName: "Claude",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
const out = resolveProviderTagEntry("unknownprovider/some-model", undefined, idx);
|
|
assert.equal(out, undefined);
|
|
});
|
|
|
|
test("resolveProviderTagEntry: direct present but empty alias+display → still tries fallback", () => {
|
|
// direct hit exists but carries no useful prefix metadata (degenerate
|
|
// case from a partially-populated enrichment). Should still upgrade
|
|
// via alias index.
|
|
const direct = { name: "Some Model" };
|
|
const map = makeEnrichmentMap([
|
|
{
|
|
key: "cohere/x",
|
|
providerAlias: "cohere",
|
|
providerCanonical: "cohere",
|
|
providerDisplayName: "Cohere",
|
|
},
|
|
]);
|
|
const idx = buildAliasIndex(map);
|
|
const out = resolveProviderTagEntry("cohere/rerank-v4.0", direct, idx);
|
|
assert.equal(out?.providerDisplayName, "Cohere");
|
|
});
|