OmniRoute/tests/unit/providers-page-utils.test.ts

import test from "node:test";
import assert from "node:assert/strict";

const providerPageUtils =
  await import("../../src/app/(dashboard)/dashboard/providers/providerPageUtils.ts");
const providerPageStorage =
  await import("../../src/app/(dashboard)/dashboard/providers/providerPageStorage.ts");
const providers = await import("../../src/shared/constants/providers.ts");
const providerCatalog = await import("../../src/lib/providers/catalog.ts");

test("merged OAuth providers keep free-tier providers in the OAuth section", () => {
  const statsCalls = [];
  const getProviderStats = (providerId, authType) => {
    statsCalls.push({ providerId, authType });
    return { total: authType === "free" ? 1 : 0 };
  };

  const mockOauthProviders = { claude: { name: "Claude" } };
  const mockFreeProviders = { qoder: { name: "Qoder" } };

  const entries = providerPageUtils.buildMergedOAuthProviderEntries(
    mockOauthProviders,
    mockFreeProviders,
    getProviderStats
  );

  const oauthIds = Object.keys(mockOauthProviders);
  const freeIds = Object.keys(mockFreeProviders);

  assert.deepEqual(
    entries.slice(0, oauthIds.length).map((entry) => entry.providerId),
    oauthIds
  );
  assert.deepEqual(
    entries.slice(oauthIds.length).map((entry) => entry.providerId),
    freeIds
  );

  const freeEntry = entries.find((entry) => entry.providerId === freeIds[0]);
  assert.ok(freeEntry, "Should find the free entry");
  assert.equal(freeEntry.displayAuthType, "oauth");
  assert.equal(freeEntry.toggleAuthType, "free");
  assert.equal(
    statsCalls.some((call) => call.providerId === freeIds[0] && call.authType === "free"),
    true
  );
});

test("configured-only filter keeps only providers with saved connections", () => {
  const entries = [
    {
      providerId: "claude",
      provider: { id: "claude" },
      stats: { total: 2 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "codex",
      provider: { id: "codex" },
      stats: { total: 0 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "cursor",
      provider: { id: "cursor" },
      stats: { total: 1 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
  ];

  const visible = providerPageUtils.filterConfiguredProviderEntries(entries, true);

  assert.deepEqual(
    visible.map((entry) => entry.providerId),
    ["claude", "cursor"]
  );
  assert.equal(providerPageUtils.filterConfiguredProviderEntries(entries, false).length, 3);
});

test("configured-only filter keeps no-auth providers even without a saved connection (#3290)", () => {
  const entries = [
    {
      providerId: "claude",
      provider: { id: "claude" },
      stats: { total: 0 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "opencode",
      provider: { id: "opencode" },
      stats: { total: 0 },
      displayAuthType: "no-auth",
      toggleAuthType: "no-auth",
    },
    {
      providerId: "duckduckgo-web",
      provider: { id: "duckduckgo-web" },
      stats: { total: 0 },
      displayAuthType: "no-auth",
      toggleAuthType: "no-auth",
    },
  ];

  // no-auth providers never create a DB connection row (total === 0) but are
  // always usable and appear in /v1/models — they must survive the filter.
  const visible = providerPageUtils.filterConfiguredProviderEntries(entries, true);
  assert.deepEqual(
    visible.map((entry) => entry.providerId),
    ["duckduckgo-web", "opencode"]
  );
});

test("compact provider entries dedupe providers and move no-auth entries to the end", () => {
  const openRouterFromFree = {
    providerId: "openrouter",
    provider: { id: "openrouter", name: "OpenRouter" },
    stats: { total: 1 },
    displayAuthType: "apikey",
    toggleAuthType: "apikey",
  };
  const openRouterFromAggregator = {
    providerId: "openrouter",
    provider: { id: "openrouter", name: "OpenRouter" },
    stats: { total: 1 },
    displayAuthType: "apikey",
    toggleAuthType: "apikey",
  };
  const claude = {
    providerId: "claude",
    provider: { id: "claude", name: "Claude" },
    stats: { total: 1 },
    displayAuthType: "oauth",
    toggleAuthType: "oauth",
  };
  const opencode = {
    providerId: "opencode",
    provider: { id: "opencode", name: "OpenCode" },
    stats: { total: 0 },
    displayAuthType: "no-auth",
    toggleAuthType: "no-auth",
  };

  const visible = providerPageUtils.buildCompactProviderEntries(
    [[opencode, openRouterFromFree], [claude, openRouterFromAggregator], [opencode]],
    { deferNoAuth: true }
  );

  assert.deepEqual(
    visible.map((entry) => entry.providerId),
    ["openrouter", "claude", "opencode"]
  );
  assert.equal(visible.filter((entry) => entry.providerId === "openrouter").length, 1);
});

test("compact provider entries prefer non-no-auth duplicates over deferred no-auth entries", () => {
  const noAuthEntry = {
    providerId: "opencode",
    provider: { id: "opencode", name: "OpenCode" },
    stats: { total: 0 },
    displayAuthType: "no-auth",
    toggleAuthType: "no-auth",
  };
  const configuredEntry = {
    providerId: "opencode",
    provider: { id: "opencode", name: "OpenCode" },
    stats: { total: 1 },
    displayAuthType: "apikey",
    toggleAuthType: "apikey",
  };

  const visible = providerPageUtils.buildCompactProviderEntries(
    [[noAuthEntry], [configuredEntry]],
    { deferNoAuth: true }
  );

  assert.equal(visible.length, 1);
  assert.equal(visible[0].providerId, "opencode");
  assert.equal(visible[0].displayAuthType, "apikey");
});

test("search filter matches provider name and id case-insensitively", () => {
  const entries = [
    {
      providerId: "claude",
      provider: { id: "claude", name: "Claude" },
      stats: { total: 2 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "openai",
      provider: { id: "openai", name: "OpenAI" },
      stats: { total: 1 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "gemini",
      provider: { id: "gemini", name: "Google Gemini" },
      stats: { total: 1 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
  ];

  const byName = providerPageUtils.filterConfiguredProviderEntries(entries, false, "claude");
  assert.deepEqual(
    byName.map((e) => e.providerId),
    ["claude"]
  );

  const byNameCaseInsensitive = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    "OPENAI"
  );
  assert.deepEqual(
    byNameCaseInsensitive.map((e) => e.providerId),
    ["openai"]
  );

  const byPartialName = providerPageUtils.filterConfiguredProviderEntries(entries, false, "google");
  assert.deepEqual(
    byPartialName.map((e) => e.providerId),
    ["gemini"]
  );

  const byId = providerPageUtils.filterConfiguredProviderEntries(entries, false, "gem");
  assert.deepEqual(
    byId.map((e) => e.providerId),
    ["gemini"]
  );

  const noMatch = providerPageUtils.filterConfiguredProviderEntries(entries, false, "xyz");
  assert.equal(noMatch.length, 0);

  const emptySearch = providerPageUtils.filterConfiguredProviderEntries(entries, false, "");
  assert.equal(emptySearch.length, 3);

  const whitespaceSearch = providerPageUtils.filterConfiguredProviderEntries(entries, false, "   ");
  assert.equal(whitespaceSearch.length, 3);
});

test("search and configured-only filters work together", () => {
  const entries = [
    {
      providerId: "claude",
      provider: { id: "claude", name: "Claude" },
      stats: { total: 2 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "openai",
      provider: { id: "openai", name: "OpenAI" },
      stats: { total: 0 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
    {
      providerId: "gemini",
      provider: { id: "gemini", name: "Google Gemini" },
      stats: { total: 1 },
      displayAuthType: "oauth",
      toggleAuthType: "oauth",
    },
  ];

  const configuredAndSearched = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    true,
    "claude"
  );
  assert.deepEqual(
    configuredAndSearched.map((e) => e.providerId),
    ["claude"]
  );

  const configuredButNoMatch = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    true,
    "openai"
  );
  assert.equal(configuredButNoMatch.length, 0);
});

test("configured-only preference parser only enables explicit true values", () => {
  assert.equal(providerPageStorage.parseConfiguredOnlyPreference("true"), true);
  assert.equal(providerPageStorage.parseConfiguredOnlyPreference("false"), false);
  assert.equal(providerPageStorage.parseConfiguredOnlyPreference(null), false);
  assert.equal(providerPageStorage.parseConfiguredOnlyPreference(undefined), false);
});

test("provider display mode preference parser accepts only known modes", () => {
  assert.equal(providerPageStorage.parseProviderDisplayModePreference("all"), "all");
  assert.equal(providerPageStorage.parseProviderDisplayModePreference("configured"), "configured");
  assert.equal(providerPageStorage.parseProviderDisplayModePreference("compact"), "compact");
  assert.equal(providerPageStorage.parseProviderDisplayModePreference("true"), null);
  assert.equal(providerPageStorage.parseProviderDisplayModePreference(null), null);
});

test("configured-only filter is ignored before the first provider is connected", () => {
  assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(true, 0), false);
  assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(false, 0), false);
  assert.equal(providerPageUtils.shouldApplyConfiguredOnlyFilter(true, 1), true);
});

test("compact display mode always uses the configured provider set", () => {
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("all", 0), false);
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("all", 2), false);
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("configured", 0), false);
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("configured", 2), true);
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("compact", 0), true);
  assert.equal(providerPageUtils.shouldFilterProviderEntriesForDisplayMode("compact", 2), true);
});

test("first-provider hint is shown only when no providers are connected and search is empty", () => {
  assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, ""), true);
  assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, "   "), true);
  assert.equal(providerPageUtils.shouldShowFirstProviderHint(0, "codex"), false);
  assert.equal(providerPageUtils.shouldShowFirstProviderHint(1, ""), false);
});

test("configured-only preference storage round-trips correctly", () => {
  const storage = new Map();
  const mockStorage = {
    getItem(key) {
      return storage.has(key) ? storage.get(key) : null;
    },
    setItem(key, value) {
      storage.set(key, value);
    },
    removeItem(key) {
      storage.delete(key);
    },
  };

  assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), false);

  providerPageStorage.writeConfiguredOnlyPreference(true, mockStorage);
  assert.equal(storage.get(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), "true");
  assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), true);

  providerPageStorage.writeConfiguredOnlyPreference(false, mockStorage);
  assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);
  assert.equal(providerPageStorage.readConfiguredOnlyPreference(mockStorage), false);
});

test("provider display mode storage round-trips and migrates the old configured-only key", () => {
  const storage = new Map();
  const mockStorage = {
    getItem(key) {
      return storage.has(key) ? storage.get(key) : null;
    },
    setItem(key, value) {
      storage.set(key, value);
    },
    removeItem(key) {
      storage.delete(key);
    },
  };

  assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "all");

  storage.set(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY, "true");
  assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "configured");
  assert.equal(storage.get(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), "configured");
  assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);

  providerPageStorage.writeProviderDisplayModePreference("compact", mockStorage);
  assert.equal(storage.get(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), "compact");
  assert.equal(storage.has(providerPageStorage.SHOW_CONFIGURED_ONLY_STORAGE_KEY), false);
  assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "compact");

  providerPageStorage.writeProviderDisplayModePreference("all", mockStorage);
  assert.equal(storage.has(providerPageStorage.PROVIDER_DISPLAY_MODE_STORAGE_KEY), false);
  assert.equal(providerPageStorage.readProviderDisplayModePreference(mockStorage), "all");
});

test("static catalog entries resolve local, search, audio, web-cookie and upstream providers", () => {
  const freeProvider = providerPageUtils.resolveDashboardProviderInfo("amazon-q");
  const localProvider = providerPageUtils.resolveDashboardProviderInfo("sdwebui");
  const localChatProvider = providerPageUtils.resolveDashboardProviderInfo("lm-studio");
  const lemonadeProvider = providerPageUtils.resolveDashboardProviderInfo("lemonade");
  const searchProvider = providerPageUtils.resolveDashboardProviderInfo("brave-search");
  const youcomSearchProvider = providerPageUtils.resolveDashboardProviderInfo("youcom-search");
  const audioProvider = providerPageUtils.resolveDashboardProviderInfo("assemblyai");
  const awsPollyProvider = providerPageUtils.resolveDashboardProviderInfo("aws-polly");
  const webCookieProvider = providerPageUtils.resolveDashboardProviderInfo("grok-web");
  const apiKeyProvider = providerPageUtils.resolveDashboardProviderInfo("synthetic");
  const gitlabProvider = providerPageUtils.resolveDashboardProviderInfo("gitlab");
  const gitlabDuoProvider = providerPageUtils.resolveDashboardProviderInfo("gitlab-duo");
  const chutesProvider = providerPageUtils.resolveDashboardProviderInfo("chutes");
  const datarobotProvider = providerPageUtils.resolveDashboardProviderInfo("datarobot");
  const clarifaiProvider = providerPageUtils.resolveDashboardProviderInfo("clarifai");
  const empowerProvider = providerPageUtils.resolveDashboardProviderInfo("empower");
  const nousProvider = providerPageUtils.resolveDashboardProviderInfo("nous-research");
  const poeProvider = providerPageUtils.resolveDashboardProviderInfo("poe");
  const azureOpenAiProvider = providerPageUtils.resolveDashboardProviderInfo("azure-openai");
  const azureAiProvider = providerPageUtils.resolveDashboardProviderInfo("azure-ai");
  const watsonxProvider = providerPageUtils.resolveDashboardProviderInfo("watsonx");
  const ociProvider = providerPageUtils.resolveDashboardProviderInfo("oci");
  const sapProvider = providerPageUtils.resolveDashboardProviderInfo("sap");
  const modalProvider = providerPageUtils.resolveDashboardProviderInfo("modal");
  const rekaProvider = providerPageUtils.resolveDashboardProviderInfo("reka");
  const nlpCloudProvider = providerPageUtils.resolveDashboardProviderInfo("nlpcloud");
  const runwayProvider = providerPageUtils.resolveDashboardProviderInfo("runwayml");
  const embeddingProvider = providerPageUtils.resolveDashboardProviderInfo("voyage-ai");
  const rerankProvider = providerPageUtils.resolveDashboardProviderInfo("jina-ai");
  const perplexityWebProvider = providerPageUtils.resolveDashboardProviderInfo("perplexity-web");
  const blackboxWebProvider = providerPageUtils.resolveDashboardProviderInfo("blackbox-web");
  const museSparkWebProvider = providerPageUtils.resolveDashboardProviderInfo("muse-spark-web");
  const upstreamProvider = providerPageUtils.resolveDashboardProviderInfo("cliproxyapi");

  assert.equal(freeProvider?.category, "oauth");
  assert.equal(freeProvider?.name, providers.OAUTH_PROVIDERS["amazon-q"].name);

  assert.equal(localProvider?.category, "local");
  assert.equal(localProvider?.name, providers.LOCAL_PROVIDERS.sdwebui.name);
  assert.equal(localChatProvider?.category, "local");
  assert.equal(localChatProvider?.name, providers.LOCAL_PROVIDERS["lm-studio"].name);
  assert.equal(lemonadeProvider?.category, "local");
  assert.equal(lemonadeProvider?.name, providers.LOCAL_PROVIDERS.lemonade.name);

  assert.equal(searchProvider?.category, "search");
  assert.equal(searchProvider?.name, providers.SEARCH_PROVIDERS["brave-search"].name);
  assert.equal(youcomSearchProvider?.category, "search");
  assert.equal(youcomSearchProvider?.name, providers.SEARCH_PROVIDERS["youcom-search"].name);

  assert.equal(audioProvider?.category, "audio");
  assert.equal(audioProvider?.name, providers.AUDIO_ONLY_PROVIDERS.assemblyai.name);
  assert.equal(awsPollyProvider?.category, "audio");
  assert.equal(awsPollyProvider?.name, providers.AUDIO_ONLY_PROVIDERS["aws-polly"].name);

  assert.equal(apiKeyProvider?.category, "apikey");
  assert.equal(apiKeyProvider?.name, providers.APIKEY_PROVIDERS.synthetic.name);
  assert.equal(gitlabProvider?.category, "apikey");
  assert.equal(gitlabProvider?.name, providers.APIKEY_PROVIDERS.gitlab.name);
  assert.equal(gitlabDuoProvider?.category, "oauth");
  assert.equal(gitlabDuoProvider?.name, providers.OAUTH_PROVIDERS["gitlab-duo"].name);
  assert.equal(chutesProvider?.category, "apikey");
  assert.equal(chutesProvider?.name, providers.APIKEY_PROVIDERS.chutes.name);
  assert.equal(datarobotProvider?.category, "apikey");
  assert.equal(datarobotProvider?.name, providers.APIKEY_PROVIDERS.datarobot.name);
  assert.equal(clarifaiProvider?.category, "apikey");
  assert.equal(clarifaiProvider?.name, providers.APIKEY_PROVIDERS.clarifai.name);
  assert.equal(empowerProvider?.category, "apikey");
  assert.equal(empowerProvider?.name, providers.APIKEY_PROVIDERS.empower.name);
  assert.equal(nousProvider?.category, "apikey");
  assert.equal(nousProvider?.name, providers.APIKEY_PROVIDERS["nous-research"].name);
  assert.equal(poeProvider?.category, "apikey");
  assert.equal(poeProvider?.name, providers.APIKEY_PROVIDERS.poe.name);
  assert.equal(azureOpenAiProvider?.category, "apikey");
  assert.equal(azureOpenAiProvider?.name, providers.APIKEY_PROVIDERS["azure-openai"].name);
  assert.equal(azureAiProvider?.category, "apikey");
  assert.equal(azureAiProvider?.name, providers.APIKEY_PROVIDERS["azure-ai"].name);
  assert.equal(watsonxProvider?.category, "apikey");
  assert.equal(watsonxProvider?.name, providers.APIKEY_PROVIDERS.watsonx.name);
  assert.equal(ociProvider?.category, "apikey");
  assert.equal(ociProvider?.name, providers.APIKEY_PROVIDERS.oci.name);
  assert.equal(sapProvider?.category, "apikey");
  assert.equal(sapProvider?.name, providers.APIKEY_PROVIDERS.sap.name);
  assert.equal(modalProvider?.category, "apikey");
  assert.equal(modalProvider?.name, providers.APIKEY_PROVIDERS.modal.name);
  assert.equal(rekaProvider?.category, "apikey");
  assert.equal(rekaProvider?.name, providers.APIKEY_PROVIDERS.reka.name);
  assert.equal(nlpCloudProvider?.category, "apikey");
  assert.equal(nlpCloudProvider?.name, providers.APIKEY_PROVIDERS.nlpcloud.name);
  assert.equal(runwayProvider?.category, "apikey");
  assert.equal(runwayProvider?.name, providers.APIKEY_PROVIDERS.runwayml.name);

  assert.equal(embeddingProvider?.category, "apikey");
  assert.equal(embeddingProvider?.name, providers.APIKEY_PROVIDERS["voyage-ai"].name);

  assert.equal(rerankProvider?.category, "apikey");
  assert.equal(rerankProvider?.name, providers.APIKEY_PROVIDERS["jina-ai"].name);

  assert.equal(webCookieProvider?.category, "web-cookie");
  assert.equal(webCookieProvider?.name, providers.WEB_COOKIE_PROVIDERS["grok-web"].name);

  assert.equal(perplexityWebProvider?.category, "web-cookie");
  assert.equal(perplexityWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["perplexity-web"].name);

  assert.equal(blackboxWebProvider?.category, "web-cookie");
  assert.equal(blackboxWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["blackbox-web"].name);

  assert.equal(museSparkWebProvider?.category, "web-cookie");
  assert.equal(museSparkWebProvider?.name, providers.WEB_COOKIE_PROVIDERS["muse-spark-web"].name);

  assert.equal(upstreamProvider?.category, "upstream-proxy");
  assert.equal(
    upstreamProvider?.name,
    providerCatalog.STATIC_PROVIDER_CATALOG_GROUPS["upstream-proxy"].providers.cliproxyapi.name
  );
});

test("managed provider connection ids include supported static categories and exclude upstream proxy", () => {
  assert.equal(providerCatalog.isManagedProviderConnectionId("qoder"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("synthetic"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("gitlab"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("thebai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("fenayai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("chutes"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("datarobot"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("clarifai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("empower"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("nous-research"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("poe"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("azure-openai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("azure-ai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("bedrock"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("watsonx"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("oci"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("sap"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("modal"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("reka"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("nlpcloud"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("runwayml"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("voyage-ai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("jina-ai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("sdwebui"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("lm-studio"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("vllm"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("lemonade"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("assemblyai"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("aws-polly"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("grok-web"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("perplexity-web"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("blackbox-web"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("muse-spark-web"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("brave-search"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("youcom-search"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("cliproxyapi"), false);
  assert.equal(providerCatalog.isManagedProviderConnectionId("claude"), false);
  assert.equal(providerCatalog.isManagedProviderConnectionId("jules"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("devin"), true);
  assert.equal(providerCatalog.isManagedProviderConnectionId("codex-cloud"), true);
});

test("grok-web taxonomy stays web-cookie only and does not leak into api-key entries", () => {
  assert.equal("grok-web" in providers.APIKEY_PROVIDERS, false);
  assert.equal("grok-web" in providers.WEB_COOKIE_PROVIDERS, true);
  assert.equal("sdwebui" in providers.APIKEY_PROVIDERS, false);
  assert.equal("sdwebui" in providers.LOCAL_PROVIDERS, true);
  assert.equal("lm-studio" in providers.APIKEY_PROVIDERS, false);
  assert.equal("lm-studio" in providers.LOCAL_PROVIDERS, true);
  assert.equal("vllm" in providers.APIKEY_PROVIDERS, false);
  assert.equal("vllm" in providers.LOCAL_PROVIDERS, true);
  assert.equal("lemonade" in providers.APIKEY_PROVIDERS, false);
  assert.equal("lemonade" in providers.LOCAL_PROVIDERS, true);
  assert.equal("comfyui" in providers.APIKEY_PROVIDERS, false);
  assert.equal("comfyui" in providers.LOCAL_PROVIDERS, true);
  assert.equal("blackbox-web" in providers.APIKEY_PROVIDERS, false);
  assert.equal("blackbox-web" in providers.WEB_COOKIE_PROVIDERS, true);
  assert.equal("muse-spark-web" in providers.APIKEY_PROVIDERS, false);
  assert.equal("muse-spark-web" in providers.WEB_COOKIE_PROVIDERS, true);
  assert.equal("synthetic" in providers.APIKEY_PROVIDERS, true);
  assert.equal("gitlab" in providers.APIKEY_PROVIDERS, true);
  assert.equal("gitlab-duo" in providers.OAUTH_PROVIDERS, true);
  assert.equal("thebai" in providers.APIKEY_PROVIDERS, true);
  assert.equal("fenayai" in providers.APIKEY_PROVIDERS, true);
  assert.equal("chutes" in providers.APIKEY_PROVIDERS, true);
  assert.equal("datarobot" in providers.APIKEY_PROVIDERS, true);
  assert.equal("clarifai" in providers.APIKEY_PROVIDERS, true);
  assert.equal("empower" in providers.APIKEY_PROVIDERS, true);
  assert.equal("nous-research" in providers.APIKEY_PROVIDERS, true);
  assert.equal("poe" in providers.APIKEY_PROVIDERS, true);
  assert.equal("azure-ai" in providers.APIKEY_PROVIDERS, true);
  assert.equal("bedrock" in providers.APIKEY_PROVIDERS, true);
  assert.equal("watsonx" in providers.APIKEY_PROVIDERS, true);
  assert.equal("oci" in providers.APIKEY_PROVIDERS, true);
  assert.equal("sap" in providers.APIKEY_PROVIDERS, true);
  assert.equal("modal" in providers.APIKEY_PROVIDERS, true);
  assert.equal("reka" in providers.APIKEY_PROVIDERS, true);
  assert.equal("nlpcloud" in providers.APIKEY_PROVIDERS, true);
  assert.equal("runwayml" in providers.APIKEY_PROVIDERS, true);
  assert.equal("voyage-ai" in providers.APIKEY_PROVIDERS, true);
  assert.equal("jina-ai" in providers.APIKEY_PROVIDERS, true);

  const apiKeyEntries = providerPageUtils.buildStaticProviderEntries("apikey", () => ({
    total: 0,
  }));
  const localEntries = providerPageUtils.buildStaticProviderEntries("local", () => ({
    total: 0,
  }));
  const webCookieEntries = providerPageUtils.buildStaticProviderEntries("web-cookie", () => ({
    total: 0,
  }));

  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "sdwebui"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "comfyui"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "lm-studio"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "vllm"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "lemonade"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "grok-web"),
    false
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "synthetic"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "gitlab"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "thebai"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "fenayai"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "chutes"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "datarobot"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "clarifai"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "empower"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "nous-research"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "poe"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "azure-ai"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "bedrock"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "watsonx"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "oci"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "sap"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "modal"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "reka"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "nlpcloud"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "runwayml"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "voyage-ai"),
    true
  );
  assert.equal(
    apiKeyEntries.some((entry) => entry.providerId === "jina-ai"),
    true
  );
  assert.equal(
    localEntries.some((entry) => entry.providerId === "sdwebui"),
    true
  );
  assert.equal(
    localEntries.some((entry) => entry.providerId === "comfyui"),
    true
  );
  assert.equal(
    localEntries.some((entry) => entry.providerId === "lm-studio"),
    true
  );
  assert.equal(
    localEntries.some((entry) => entry.providerId === "vllm"),
    true
  );
  assert.equal(
    localEntries.some((entry) => entry.providerId === "lemonade"),
    true
  );
  assert.equal(
    webCookieEntries.some((entry) => entry.providerId === "grok-web"),
    true
  );
  assert.equal(
    webCookieEntries.some((entry) => entry.providerId === "blackbox-web"),
    true
  );
  assert.equal(
    webCookieEntries.some((entry) => entry.providerId === "muse-spark-web"),
    true
  );
});

test("compatible catalog entries keep dynamic compatible metadata", () => {
  const compatibleProvider = providerPageUtils.resolveDashboardProviderInfo(
    "openai-compatible-lab",
    {
      providerNode: {
        id: "openai-compatible-lab",
        type: "openai-compatible",
        apiType: "responses",
        baseUrl: "https://example.test",
        iconUrl: "https://cdn.example.com/icons/lab.png",
      },
      compatibleLabels: {
        ccCompatibleName: "CC Compatible",
        anthropicCompatibleName: "Anthropic Compatible",
        openAiCompatibleName: "OpenAI Compatible",
      },
    }
  );

  assert.equal(compatibleProvider?.category, "compatible");
  assert.equal(compatibleProvider?.displayAuthType, "compatible");
  assert.equal(compatibleProvider?.toggleAuthType, "apikey");
  assert.equal(compatibleProvider?.apiType, "responses");
  assert.equal(compatibleProvider?.baseUrl, "https://example.test");
  // #2166: custom remote icon URL passthrough.
  assert.equal(compatibleProvider?.iconUrl, "https://cdn.example.com/icons/lab.png");
});

test("model search filter matches providers by model id", async () => {
  const { getModelsByProviderId } = await import("../../src/shared/constants/models.ts");

  const entries = [
    {
      providerId: "trae",
      provider: { name: "Trae" },
      stats: { total: 0 },
      displayAuthType: "oauth" as const,
      toggleAuthType: "oauth" as const,
    },
    {
      providerId: "openai",
      provider: { name: "OpenAI" },
      stats: { total: 1 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
    {
      providerId: "minimax",
      provider: { name: "MiniMax" },
      stats: { total: 1 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
    {
      providerId: "nonexistent-provider-xyz",
      provider: { name: "No Models" },
      stats: { total: 0 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
  ];

  // "minimax-m3" model id exists in trae, opencode, bazaarlink, cerebras
  const byModelId = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "minimax-m3"
  );
  const matchedIds = byModelId.map((e) => e.providerId);
  assert.ok(matchedIds.includes("trae"), "trae should match minimax-m3 by model id");
  assert.ok(!matchedIds.includes("openai"), "openai should not match minimax-m3");

  // "MiniMax-M3" model id exists in minimax provider itself (different casing)
  // getModelsByProviderId("minimax") should include MiniMax-M3
  const minimaxModels = getModelsByProviderId("minimax");
  const hasMinimaxM3 = minimaxModels.some((m) => m.id === "MiniMax-M3");
  if (hasMinimaxM3) {
    const byMinimaxM3 = providerPageUtils.filterConfiguredProviderEntries(
      entries,
      false,
      undefined,
      undefined,
      "MiniMax-M3"
    );
    assert.ok(
      byMinimaxM3.map((e) => e.providerId).includes("minimax"),
      "minimax should match MiniMax-M3 by model id"
    );
  }

  // Provider with no models shouldn't match
  const byNonexistentModel = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "model-that-does-not-exist"
  );
  assert.equal(byNonexistentModel.length, 0);

  // Empty model search returns all
  const byEmptyModel = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    ""
  );
  assert.equal(byEmptyModel.length, entries.length);

  // Whitespace-only model search returns all
  const byWhitespaceModel = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "   "
  );
  assert.equal(byWhitespaceModel.length, entries.length);
});

test("model search filter matches by model name", () => {
  const entries = [
    {
      providerId: "minimax",
      provider: { name: "MiniMax" },
      stats: { total: 0 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
    {
      providerId: "openai",
      provider: { name: "OpenAI" },
      stats: { total: 1 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
  ];

  // "MiniMax M3" is the model name for the MiniMax provider's MiniMax-M3 model
  const byName = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "MiniMax M3"
  );
  assert.ok(
    byName.map((e) => e.providerId).includes("minimax"),
    "minimax should match by model name 'MiniMax M3'"
  );
  assert.ok(
    !byName.map((e) => e.providerId).includes("openai"),
    "openai should not match 'MiniMax M3'"
  );
});

test("model search filter combines with configured-only and text search", () => {
  const entries = [
    {
      providerId: "trae",
      provider: { name: "Trae" },
      stats: { total: 1 },
      displayAuthType: "oauth" as const,
      toggleAuthType: "oauth" as const,
    },
    {
      providerId: "opencode",
      provider: { name: "OpenCode" },
      stats: { total: 0 },
      displayAuthType: "no-auth" as const,
      toggleAuthType: "no-auth" as const,
    },
    {
      providerId: "minimax",
      provider: { name: "MiniMax" },
      stats: { total: 0 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
    {
      providerId: "openai",
      provider: { name: "OpenAI" },
      stats: { total: 1 },
      displayAuthType: "apikey" as const,
      toggleAuthType: "apikey" as const,
    },
  ];

  // Model filter + configured-only: only configured providers with minimax-m3
  const modelAndConfigured = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    true,
    undefined,
    undefined,
    "minimax-m3"
  );
  const modelAndConfigIds = modelAndConfigured.map((e) => e.providerId);
  // trae has minimax-m3 AND is configured (total > 0)
  assert.ok(modelAndConfigIds.includes("trae"), "configured trae should match minimax-m3");
  // opencode has minimax-m3 but is no-auth (always visible regardless of configured filter)
  // bazaarlink is not in our test entries
  assert.ok(
    !modelAndConfigIds.includes("openai"),
    "openai should not match minimax-m3 model filter"
  );

  // Model filter + text search: both must match (AND logic)
  const modelAndSearch = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    "Trae",
    undefined,
    "minimax-m3"
  );
  assert.deepEqual(
    modelAndSearch.map((e) => e.providerId),
    ["trae"],
    "only trae matches both search 'Trae' AND model 'minimax-m3'"
  );

  // Model filter that matches nothing with valid text search
  const noModelMatch = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "nonexistent-model-xyz"
  );
  assert.equal(noModelMatch.length, 0);
});

test("model search filter is case-insensitive and partial-match", () => {
  const entries = [
    {
      providerId: "trae",
      provider: { name: "Trae" },
      stats: { total: 0 },
      displayAuthType: "oauth" as const,
      toggleAuthType: "oauth" as const,
    },
  ];

  // Case insensitive
  const byUppercase = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "MINIMAX-M3"
  );
  assert.equal(byUppercase.length, 1, "model search should be case-insensitive");

  // Partial match
  const byPartial = providerPageUtils.filterConfiguredProviderEntries(
    entries,
    false,
    undefined,
    undefined,
    "minimax"
  );
  assert.equal(byPartial.length, 1, "partial model id 'minimax' should match 'minimax-m3'");
});

// #4613: buildCompatibleProviderGroups partitions provider nodes into the
// openai-compatible / anthropic-compatible / claude-code-compatible buckets the
// providers page renders. The memoization in page.tsx wraps this pure helper, so
// guarding the partition logic here is the regression that matters (Rule #18).
test("buildCompatibleProviderGroups partitions nodes by type + claude-code prefix", () => {
  const labels = {
    openaiCompatibleName: "OpenAI-compatible",
    anthropicCompatibleName: "Anthropic-compatible",
    claudeCodeCompatibleName: "Claude Code-compatible",
  };

  const groups = providerPageUtils.buildCompatibleProviderGroups(
    [
      {
        id: "my-oai",
        name: "My OAI",
        type: "openai-compatible",
        apiType: "responses",
        iconUrl: "https://cdn.example.com/icons/my-oai.png",
      },
      { id: "my-anthropic", name: "My Claude", type: "anthropic-compatible" },
      { id: "anthropic-compatible-cc-acme", name: "Acme CC", type: "anthropic-compatible" },
      { id: "ignored-node", name: "Ignored", type: "unsupported-provider" },
      // name omitted → falls back to the provided label
      { id: "anon-oai", type: "openai-compatible" },
    ],
    labels
  );

  assert.deepEqual(
    groups.openai.map((p) => p.id),
    ["my-oai", "anon-oai"],
    "openai-compatible nodes land in the openai bucket"
  );
  assert.equal(groups.openai[0].apiType, "responses", "apiType is preserved");
  assert.equal(
    groups.openai[1].name,
    labels.openaiCompatibleName,
    "missing name falls back to the openai-compatible label"
  );

  // #2166: custom remote icon URL passthrough.
  assert.equal(
    groups.openai[0].iconUrl,
    "https://cdn.example.com/icons/my-oai.png",
    "iconUrl is preserved for nodes that set it"
  );
  assert.equal(groups.openai[1].iconUrl, undefined, "iconUrl is undefined when the node has none");

  assert.deepEqual(
    groups.anthropic.map((p) => p.id),
    ["my-anthropic"],
    "plain anthropic-compatible nodes land in the anthropic bucket"
  );

  assert.deepEqual(
    groups.claudeCode.map((p) => p.id),
    ["anthropic-compatible-cc-acme"],
    "anthropic-compatible nodes with the cc- prefix land in the claudeCode bucket"
  );
});

test("connectionMatchesProviderCard counts a dual-auth provider's PAT (apikey) connection on its OAuth card", () => {
  const { connectionMatchesProviderCard } = providerPageUtils;

  // qoder is OAuth-categorized but its working auth is a PAT (authType "apikey").
  // Regression: the OAuth card must count the PAT connection, else the dashboard
  // shows a connected qoder as "not connected".
  assert.equal(
    connectionMatchesProviderCard({ provider: "qoder", authType: "apikey" }, "qoder", "oauth"),
    true
  );
  assert.equal(
    connectionMatchesProviderCard({ provider: "kiro", authType: "api_key" }, "kiro", "oauth"),
    true
  );
  assert.equal(
    connectionMatchesProviderCard({ provider: "qoder", authType: "oauth" }, "qoder", "oauth"),
    true
  );
  // A normal OAuth-only provider must NOT count an apikey connection on its OAuth card.
  assert.equal(
    connectionMatchesProviderCard({ provider: "claude", authType: "apikey" }, "claude", "oauth"),
    false
  );
  assert.equal(
    connectionMatchesProviderCard({ provider: "claude", authType: "oauth" }, "claude", "oauth"),
    true
  );

  // Provider mismatch and the "free" card (counts everything) behave as expected.
  assert.equal(
    connectionMatchesProviderCard({ provider: "openai", authType: "apikey" }, "qoder", "oauth"),
    false
  );
  assert.equal(
    connectionMatchesProviderCard({ provider: "qoder", authType: "apikey" }, "qoder", "free"),
    true
  );

  // Defensive: a null/undefined connection must not throw (gemini-code-assist).
  assert.equal(connectionMatchesProviderCard(null, "qoder", "oauth"), false);
  assert.equal(connectionMatchesProviderCard(undefined, "qoder", "oauth"), false);
});