@omniroute/opencode-plugin/tests/features.test.ts

/**
 * 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");
});