🤖 fix: gate direct Copilot model entries

Apply the authoritative Copilot catalog check to direct provider model strings so hidden and custom model lists do not surface Copilot-only entries that the signed-in account cannot use. Also keep explicit gateway routing, route lists, and compaction suggestions on the same availability rules, and stabilize the useRouting hook test so it waits for loaded routing state before asserting unavailable Copilot routes are hidden.

---

_Generated with `mux` • Model: `openai:gpt-5.4` • Thinking: `xhigh` • Cost: `$23.81`_

<!-- mux-attribution: model=openai:gpt-5.4 thinking=xhigh costs=23.81 -->

Author: ibetitsmike

src/browser/hooks/useModelsFromSettings.ts

@@ -21,7 +21,10 @@ import { isModelAvailable } from "@/common/routing";
 import type { ProviderModelEntry, ProvidersConfigMap } from "@/common/orpc/types";
 import { DEFAULT_MODEL_KEY, HIDDEN_MODELS_KEY } from "@/common/constants/storage";
 
-import { isGatewayModelAccessibleFromAuthoritativeCatalog } from "@/common/utils/providers/gatewayModelCatalog";
+import {
+  isGatewayModelAccessibleFromAuthoritativeCatalog,
+  isProviderModelAccessibleFromAuthoritativeCatalog,
+} from "@/common/utils/providers/gatewayModelCatalog";
 import { getProviderModelEntryId } from "@/common/utils/providers/modelEntries";
 
 const BUILT_IN_MODELS: string[] = Object.values(KNOWN_MODELS).map((m) => m.id);
@@ -162,10 +165,30 @@ export function useModelsFromSettings() {
     [config]
   );
 
+  const isAuthoritativeProviderModelAccessible = useCallback(
+    (modelString: string) => {
+      const colonIndex = modelString.indexOf(":");
+      if (colonIndex <= 0 || colonIndex >= modelString.length - 1) {
+        return true;
+      }
+
+      const provider = modelString.slice(0, colonIndex);
+      const providerModelId = modelString.slice(colonIndex + 1);
+      return isProviderModelAccessibleFromAuthoritativeCatalog(
+        provider,
+        providerModelId,
+        config?.[provider]?.models
+      );
+    },
+    [config]
+  );
+
   const customModels = useMemo(() => {
-    const next = filterHiddenModels(getCustomModels(config), hiddenModels);
+    const next = filterHiddenModels(getCustomModels(config), hiddenModels).filter(
+      isAuthoritativeProviderModelAccessible
+    );
     return effectivePolicy ? next.filter((m) => isModelAllowedByPolicy(effectivePolicy, m)) : next;
-  }, [config, hiddenModels, effectivePolicy]);
+  }, [config, hiddenModels, effectivePolicy, isAuthoritativeProviderModelAccessible]);
 
   const openaiApiKeySet = config === null ? null : config.openai?.apiKeySet === true;
   const codexOauthSet = config === null ? null : config.openai?.codexOauthSet === true;
@@ -186,6 +209,10 @@ export function useModelsFromSettings() {
         return false;
       }
 
+      if (!isAuthoritativeProviderModelAccessible(modelId)) {
+        return true;
+      }
+
       if (
         isModelAvailable(
           modelId,
@@ -221,6 +248,7 @@ export function useModelsFromSettings() {
     effectivePolicy,
     isConfigured,
     isGatewayModelAccessible,
+    isAuthoritativeProviderModelAccessible,
     routePriority,
     routeOverrides,
     openaiApiKeySet,
@@ -240,14 +268,16 @@ export function useModelsFromSettings() {
     const providerFiltered =
       config == null
         ? suggested
-        : suggested.filter((modelId) =>
-            isModelAvailable(
-              modelId,
-              routePriority,
-              routeOverrides,
-              isConfigured,
-              isGatewayModelAccessible
-            )
+        : suggested.filter(
+            (modelId) =>
+              isAuthoritativeProviderModelAccessible(modelId) &&
+              isModelAvailable(
+                modelId,
+                routePriority,
+                routeOverrides,
+                isConfigured,
+                isGatewayModelAccessible
+              )
           );
 
     if (config == null) {
@@ -286,6 +316,7 @@ export function useModelsFromSettings() {
     effectivePolicy,
     isConfigured,
     isGatewayModelAccessible,
+    isAuthoritativeProviderModelAccessible,
     routePriority,
     routeOverrides,
     openaiApiKeySet,

src/browser/hooks/useRouting.test.ts

@@ -68,18 +68,18 @@ describe("useRouting", () => {
         models: [KNOWN_MODELS.GPT_54_MINI.providerModelId],
       },
     };
+    routePriority = ["github-copilot", "direct"];
 
     const { result } = renderHook(() => useRouting(), { wrapper });
 
-    await waitFor(() =>
+    await waitFor(() => {
+      expect(result.current.routePriority).toEqual(["github-copilot", "direct"]);
       expect(
         result.current
           .availableRoutes(KNOWN_MODELS.GPT.id)
           .some((route) => route.route === "github-copilot")
-      ).toBe(true)
-    );
-
-    result.current.setRoutePreferences(["github-copilot", "direct"], {});
+      ).toBe(false);
+    });
 
     expect(result.current.resolveRoute(KNOWN_MODELS.GPT.id)).toEqual({
       route: "direct",

src/browser/utils/compaction/suggestion.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test";
+
+import { KNOWN_MODELS } from "@/common/constants/knownModels";
+import type { ProvidersConfigMap } from "@/common/orpc/types";
+
+import { getExplicitCompactionSuggestion } from "./suggestion";
+
+const COPILOT_ONLY_PROVIDERS_CONFIG: ProvidersConfigMap = {
+  "github-copilot": {
+    apiKeySet: true,
+    isEnabled: true,
+    isConfigured: true,
+    models: [KNOWN_MODELS.GPT_54_MINI.providerModelId],
+  },
+};
+
+const COPILOT_ONLY_OPTIONS = {
+  providersConfig: COPILOT_ONLY_PROVIDERS_CONFIG,
+  policy: null,
+  routePriority: ["direct"],
+  routeOverrides: {},
+};
+
+describe("getExplicitCompactionSuggestion", () => {
+  test("rejects explicit Copilot models missing from the authoritative catalog", () => {
+    expect(
+      getExplicitCompactionSuggestion({
+        ...COPILOT_ONLY_OPTIONS,
+        modelId: `github-copilot:${KNOWN_MODELS.GPT.providerModelId}`,
+      })
+    ).toBeNull();
+  });
+
+  test("keeps explicit Copilot models that the authoritative catalog exposes", () => {
+    expect(
+      getExplicitCompactionSuggestion({
+        ...COPILOT_ONLY_OPTIONS,
+        modelId: `github-copilot:${KNOWN_MODELS.GPT_54_MINI.providerModelId}`,
+      })
+    ).toMatchObject({
+      kind: "preferred",
+      modelId: `github-copilot:${KNOWN_MODELS.GPT_54_MINI.providerModelId}`,
+    });
+  });
+});

src/browser/utils/compaction/suggestion.ts

@@ -10,7 +10,10 @@ import { isModelAvailable } from "@/common/routing";
 import type { EffectivePolicy, ProvidersConfigMap } from "@/common/orpc/types";
 import { normalizeToCanonical } from "@/common/utils/ai/models";
 import { formatModelDisplayName } from "@/common/utils/ai/modelDisplay";
-import { isGatewayModelAccessibleFromAuthoritativeCatalog } from "@/common/utils/providers/gatewayModelCatalog";
+import {
+  isGatewayModelAccessibleFromAuthoritativeCatalog,
+  isProviderModelAccessibleFromAuthoritativeCatalog,
+} from "@/common/utils/providers/gatewayModelCatalog";
 import { getModelStats } from "@/common/utils/tokens/modelStats";
 
 export interface CompactionSuggestion {
@@ -47,6 +50,26 @@ function buildIsGatewayModelAccessible(
     );
 }
 
+function buildIsAuthoritativeProviderModelAccessible(
+  providersConfig: ProvidersConfigMap | null
+): (modelString: string) => boolean {
+  return (modelString: string) => {
+    const normalized = normalizeToCanonical(modelString);
+    const colonIndex = normalized.indexOf(":");
+    if (colonIndex <= 0 || colonIndex >= normalized.length - 1) {
+      return true;
+    }
+
+    const provider = normalized.slice(0, colonIndex);
+    const providerModelId = normalized.slice(colonIndex + 1);
+    return isProviderModelAccessibleFromAuthoritativeCatalog(
+      provider,
+      providerModelId,
+      providersConfig?.[provider]?.models
+    );
+  };
+}
+
 export interface CompactionRouteOptions {
   routePriority: string[];
   routeOverrides: Record<string, string>;
@@ -70,6 +93,13 @@ export function getExplicitCompactionSuggestion(
   const normalized = normalizeToCanonical(modelId);
   const isConfigured = buildIsConfigured(options.providersConfig);
   const isGatewayModelAccessible = buildIsGatewayModelAccessible(options.providersConfig);
+  const isAuthoritativeProviderModelAccessible = buildIsAuthoritativeProviderModelAccessible(
+    options.providersConfig
+  );
+  if (!isAuthoritativeProviderModelAccessible(normalized)) {
+    return null;
+  }
+
   if (
     !isModelAvailable(
       normalized,

src/common/routing/resolve.test.ts

@@ -6,6 +6,7 @@ const MODEL = "anthropic:claude-opus-4-6";
 const OPENAI_MODEL = "openai:gpt-5.4";
 
 const EXPLICIT_GATEWAY_MODEL = "openrouter:openai/gpt-5";
+const EXPLICIT_COPILOT_MODEL = "github-copilot:gpt-5.4";
 
 function createIsConfigured(configuredProviders: string[]): (provider: string) => boolean {
   const configuredSet = new Set(configuredProviders);
@@ -157,6 +158,19 @@ describe("resolveRoute", () => {
     expect(resolved.routeModelId).toBe("gpt-5");
   });
 
+  test("falls back from explicit gateway input when the explicit route rejects the model", () => {
+    const resolved = resolveRoute(
+      EXPLICIT_GATEWAY_MODEL,
+      ["direct"],
+      {},
+      createIsConfigured(["openrouter", "openai"]),
+      createIsGatewayModelAccessible([["openrouter", "openai/gpt-5"]])
+    );
+
+    expect(resolved.routeProvider).toBe("openai");
+    expect(resolved.routeModelId).toBe("gpt-5");
+  });
+
   test("supports per-model override to specific gateway", () => {
     const resolved = resolveRoute(
       MODEL,
@@ -334,6 +348,17 @@ describe("isModelAvailable", () => {
     ).toBe(true);
   });
 
+  test("returns false for explicit gateway models when the configured gateway rejects the model", () => {
+    expect(
+      isModelAvailableForRoutes({
+        modelId: EXPLICIT_COPILOT_MODEL,
+        configuredProviders: ["github-copilot"],
+        routePriority: ["direct"],
+        isGatewayModelAccessible: createIsGatewayModelAccessible([["github-copilot", "gpt-5.4"]]),
+      })
+    ).toBe(false);
+  });
+
   test("returns true when gateway route is configured", () => {
     expect(
       isModelAvailableForRoutes({
@@ -503,6 +528,16 @@ describe("availableRoutes", () => {
     ]);
   });
 
+  test("excludes direct routes for explicit gateway models that the catalog rejects", () => {
+    const routes = availableRoutes(
+      EXPLICIT_COPILOT_MODEL,
+      createIsConfigured(["github-copilot"]),
+      createIsGatewayModelAccessible([["github-copilot", "gpt-5.4"]])
+    );
+
+    expect(routes).toEqual([]);
+  });
+
   test("excludes gateway routes that cannot access the model", () => {
     const routes = availableRoutes(
       OPENAI_MODEL,

src/common/routing/resolve.ts

@@ -117,17 +117,42 @@ function gatewayRouteContext(
 function getConfiguredDirectRouteContext(
   modelInput: string,
   parsed: ReturnType<typeof parseRoutingInput>,
-  isConfigured: (provider: string) => boolean
+  isConfigured: (provider: string) => boolean,
+  isGatewayModelAccessible?: GatewayModelAccessibility
 ): RouteContext | null {
-  return isConfigured(parsed.origin) ? directRouteContext(modelInput, parsed) : null;
+  if (!isConfigured(parsed.origin)) {
+    return null;
+  }
+
+  if (
+    getProviderDefinition(parsed.origin)?.kind === "gateway" &&
+    isGatewayModelAccessible &&
+    !isGatewayModelAccessible(parsed.origin, parsed.originModelId)
+  ) {
+    return null;
+  }
+
+  return directRouteContext(modelInput, parsed);
 }
 
 function getConfiguredExplicitGatewayRouteContext(
   modelInput: string,
   parsed: ReturnType<typeof parseRoutingInput>,
-  isConfigured: (provider: string) => boolean
+  isConfigured: (provider: string) => boolean,
+  isGatewayModelAccessible?: GatewayModelAccessibility
 ): RouteContext | null {
-  if (parsed.explicitGateway == null || !isConfigured(parsed.explicitGateway)) {
+  if (parsed.explicitGateway == null || parsed.explicitGatewayModelId == null) {
+    return null;
+  }
+
+  if (!isConfigured(parsed.explicitGateway)) {
+    return null;
+  }
+
+  if (
+    isGatewayModelAccessible &&
+    !isGatewayModelAccessible(parsed.explicitGateway, parsed.explicitGatewayModelId)
+  ) {
     return null;
   }
 
@@ -174,7 +199,12 @@ function findActiveRouteContext(
   // to canonical override/priority routing so the underlying model
   // stays reachable via other configured routes.
   if (parsed.explicitGateway != null) {
-    const explicit = getConfiguredExplicitGatewayRouteContext(modelInput, parsed, isConfigured);
+    const explicit = getConfiguredExplicitGatewayRouteContext(
+      modelInput,
+      parsed,
+      isConfigured,
+      isGatewayModelAccessible
+    );
     if (explicit) {
       return explicit;
     }
@@ -187,7 +217,12 @@ function findActiveRouteContext(
   const canonicalKey = getCanonicalRouteKey(parsed);
   const override = routeOverrides[canonicalKey];
   if (override === "direct" || override === parsed.origin) {
-    const direct = getConfiguredDirectRouteContext(modelInput, parsed, isConfigured);
+    const direct = getConfiguredDirectRouteContext(
+      modelInput,
+      parsed,
+      isConfigured,
+      isGatewayModelAccessible
+    );
     if (direct) {
       return direct;
     }
@@ -211,7 +246,12 @@ function findActiveRouteContext(
   // 2. Walk routePriority
   for (const route of routePriority) {
     if (route === "direct") {
-      const direct = getConfiguredDirectRouteContext(modelInput, parsed, isConfigured);
+      const direct = getConfiguredDirectRouteContext(
+        modelInput,
+        parsed,
+        isConfigured,
+        isGatewayModelAccessible
+      );
       if (direct) {
         return direct;
       }
@@ -310,7 +350,11 @@ export function availableRoutes(
 
   // Add direct route
   const originDefinition = getProviderDefinition(parsed.origin);
-  if (originDefinition) {
+  const directIsAccessible =
+    originDefinition?.kind !== "gateway" ||
+    !isGatewayModelAccessible ||
+    isGatewayModelAccessible(parsed.origin, parsed.originModelId);
+  if (originDefinition && directIsAccessible) {
     routes.push({
       route: "direct",
       displayName: `Direct (${originDefinition.displayName})`,