🤖 fix: align GitHub Copilot model routing (#3104)

## Summary

This PR aligns GitHub Copilot model routing with the account's model
catalog. All non-Codex models use chat completions. Codex models use a
custom Responses language model that handles Copilot's SSE stream
format. Copilot can now route Anthropic and Google models (with
dot-vs-dash ID normalization). Catalog entries are hidden from the
selector.

## Background

Copilot auth persisted the signed-in user's model list, but routing
ignored it and only routed OpenAI models. Non-OpenAI Copilot models
(Claude, Gemini) were unreachable. Codex models were stuck:
`/chat/completions` rejects them, and the standard AI SDK Responses
parser can't handle Copilot's SSE stream format. Additionally, Copilot's
catalog uses dot-form Claude IDs (`claude-opus-4.6`) while Mux's
built-in models use dashes (`claude-opus-4-6`).

## Implementation

- add a custom `CopilotResponsesLanguageModel` that handles Copilot's
Responses API SSE stream directly, bypassing the AI SDK's broken parser
(following opencode's approach)
- route Codex models through the custom Responses model, all other
Copilot models through chat completions
- expand Copilot gateway routes to include `anthropic` and `google`
- normalize Claude model IDs (dot-vs-dash: `4.6` matches `4-6`) so
Copilot catalog entries match built-in models
- hide `github-copilot:*` entries from the model selector while keeping
the catalog for route gating
- check credentials before catalog availability for correct error
messages
- classify initiator from pre-normalization body for correct billing
headers
- treat malformed catalog entries as absent for self-healing

## Validation

- `make static-check`
- `bun test src/common/utils/copilot/modelRouting.test.ts
src/node/services/providerModelFactory.test.ts
src/node/services/copilot/copilotResponsesLanguageModel.test.ts
src/browser/hooks/useRouting.test.ts
src/browser/hooks/useModelsFromSettings.test.ts
src/common/routing/resolve.test.ts
src/browser/utils/compaction/suggestion.test.ts
src/common/utils/providers/gatewayModelCatalog.test.ts`

## Risks

Medium. The custom `CopilotResponsesLanguageModel` is a new language
model implementation that directly parses Copilot's SSE stream. It's
scoped to Codex-family models only to minimize blast radius. Tool call
streaming is not yet covered (text-only). Adding Anthropic/Google to
Copilot routes means users with both Copilot and direct API keys will
route through Copilot when it's prioritized (the priority system is
user-controlled and defaults to `["direct"]`).

---

_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.test.ts

@@ -432,6 +432,122 @@ describe("useModelsFromSettings provider availability gating", () => {
     expect(result.current.hiddenModelsForSelector).not.toContain(KNOWN_MODELS.HAIKU.id);
   });
 
+  test("does not treat custom gateway model entries as an exhaustive route catalog", () => {
+    providersConfig = {
+      openai: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      openrouter: {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: [OPENROUTER_OPENAI_CUSTOM_MODEL],
+      },
+    };
+    routePriority = ["openrouter", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.models).toContain(KNOWN_MODELS.GPT.id);
+    expect(result.current.hiddenModelsForSelector).not.toContain(KNOWN_MODELS.GPT.id);
+  });
+
+  test("hides models that a configured gateway does not expose", () => {
+    providersConfig = {
+      openai: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: [KNOWN_MODELS.GPT_54_MINI.providerModelId],
+      },
+    };
+    routePriority = ["github-copilot", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.models).not.toContain(KNOWN_MODELS.GPT.id);
+    expect(result.current.hiddenModelsForSelector).toContain(KNOWN_MODELS.GPT.id);
+  });
+
+  test("keeps Copilot catalogs authoritative without surfacing selector entries", () => {
+    providersConfig = {
+      openai: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: [KNOWN_MODELS.GPT_54_MINI.providerModelId],
+      },
+    };
+    routePriority = ["github-copilot", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.customModels.some((model) => model.startsWith("github-copilot:"))).toBe(
+      false
+    );
+    expect(
+      result.current.hiddenModelsForSelector.some((model) => model.startsWith("github-copilot:"))
+    ).toBe(false);
+    expect(result.current.models).not.toContain(KNOWN_MODELS.GPT.id);
+    expect(result.current.hiddenModelsForSelector).toContain(KNOWN_MODELS.GPT.id);
+  });
+
+  test("keeps models visible when a configured gateway exposes them", () => {
+    providersConfig = {
+      openai: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: [KNOWN_MODELS.GPT.providerModelId],
+      },
+    };
+    routePriority = ["github-copilot", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.models).toContain(KNOWN_MODELS.GPT.id);
+    expect(result.current.hiddenModelsForSelector).not.toContain(KNOWN_MODELS.GPT.id);
+  });
+
+  test("keeps Anthropic models visible when Copilot catalog contains dot-form IDs", () => {
+    providersConfig = {
+      anthropic: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: ["claude-opus-4.6"],
+      },
+    };
+    routePriority = ["github-copilot", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.models).toContain(KNOWN_MODELS.OPUS.id);
+    expect(result.current.hiddenModelsForSelector).not.toContain(KNOWN_MODELS.OPUS.id);
+    expect(result.current.customModels.some((model) => model.startsWith("github-copilot:"))).toBe(
+      false
+    );
+  });
+
+  test("keeps gateway-routed models visible when no gateway model list is present", () => {
+    providersConfig = {
+      openai: { apiKeySet: false, isEnabled: true, isConfigured: false },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+      },
+    };
+    routePriority = ["github-copilot", "direct"];
+
+    const { result } = renderHook(() => useModelsFromSettings());
+
+    expect(result.current.models).toContain(KNOWN_MODELS.GPT.id);
+    expect(result.current.hiddenModelsForSelector).not.toContain(KNOWN_MODELS.GPT.id);
+  });
+
   test("excludes OAuth-gated OpenAI models from hidden bucket when unconfigured", () => {
     // OpenAI is unconfigured and neither API key nor OAuth is set.
     providersConfig = {

src/browser/hooks/useModelsFromSettings.ts

@@ -21,6 +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,
+  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);
@@ -32,6 +36,8 @@ function getCustomModels(config: ProvidersConfigMap | null): string[] {
   for (const [provider, info] of Object.entries(config)) {
     // Skip mux-gateway - those models are accessed via the cloud toggle, not listed separately
     if (provider === "mux-gateway") continue;
+    // Keep github-copilot's persisted catalog for authoritative model gating, not direct selector entries.
+    if (provider === "github-copilot") continue;
     // Only surface custom models from enabled providers
     if (!info.isEnabled) continue;
     if (!info.models) continue;
@@ -50,6 +56,8 @@ function getAllCustomModels(config: ProvidersConfigMap | null): string[] {
   for (const [provider, info] of Object.entries(config)) {
     // Skip mux-gateway - those models are accessed via the cloud toggle, not listed separately
     if (provider === "mux-gateway") continue;
+    // Keep github-copilot's persisted catalog for authoritative model gating, not direct selector entries.
+    if (provider === "github-copilot") continue;
     if (!info.models) continue;
 
     for (const modelEntry of info.models) {
@@ -155,10 +163,36 @@ export function useModelsFromSettings() {
     [config]
   );
 
+  const isGatewayModelAccessible = useCallback(
+    (gateway: string, modelId: string) =>
+      isGatewayModelAccessibleFromAuthoritativeCatalog(gateway, modelId, config?.[gateway]?.models),
+    [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;
@@ -179,7 +213,19 @@ export function useModelsFromSettings() {
         return false;
       }
 
-      if (isModelAvailable(modelId, routePriority, routeOverrides, isConfigured)) {
+      if (!isAuthoritativeProviderModelAccessible(modelId)) {
+        return true;
+      }
+
+      if (
+        isModelAvailable(
+          modelId,
+          routePriority,
+          routeOverrides,
+          isConfigured,
+          isGatewayModelAccessible
+        )
+      ) {
         return false;
       }
 
@@ -205,6 +251,8 @@ export function useModelsFromSettings() {
     hiddenModels,
     effectivePolicy,
     isConfigured,
+    isGatewayModelAccessible,
+    isAuthoritativeProviderModelAccessible,
     routePriority,
     routeOverrides,
     openaiApiKeySet,
@@ -224,8 +272,16 @@ export function useModelsFromSettings() {
     const providerFiltered =
       config == null
         ? suggested
-        : suggested.filter((modelId) =>
-            isModelAvailable(modelId, routePriority, routeOverrides, isConfigured)
+        : suggested.filter(
+            (modelId) =>
+              isAuthoritativeProviderModelAccessible(modelId) &&
+              isModelAvailable(
+                modelId,
+                routePriority,
+                routeOverrides,
+                isConfigured,
+                isGatewayModelAccessible
+              )
           );
 
     if (config == null) {
@@ -263,6 +319,8 @@ export function useModelsFromSettings() {
     hiddenModels,
     effectivePolicy,
     isConfigured,
+    isGatewayModelAccessible,
+    isAuthoritativeProviderModelAccessible,
     routePriority,
     routeOverrides,
     openaiApiKeySet,

src/browser/hooks/useRouting.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { cleanup, renderHook, waitFor } from "@testing-library/react";
+import { GlobalWindow } from "happy-dom";
+import React from "react";
+
+import { APIProvider, type APIClient } from "@/browser/contexts/API";
+import { KNOWN_MODELS } from "@/common/constants/knownModels";
+import type { ProvidersConfigMap } from "@/common/orpc/types";
+
+import { useRouting } from "./useRouting";
+
+let providersConfig: ProvidersConfigMap | null = null;
+let routePriority: string[] = ["direct"];
+let routeOverrides: Record<string, string> = {};
+let configGetConfig: () => Promise<{
+  routePriority: string[];
+  routeOverrides: Record<string, string>;
+}>;
+
+async function* emptyStream() {
+  await Promise.resolve();
+  for (const item of [] as unknown[]) {
+    yield item;
+  }
+}
+
+function createStubApiClient(): APIClient {
+  return {
+    providers: {
+      getConfig: () => Promise.resolve(providersConfig),
+      onConfigChanged: () => Promise.resolve(emptyStream()),
+    },
+    config: {
+      getConfig: () => configGetConfig(),
+      onConfigChanged: () => Promise.resolve(emptyStream()),
+      updateRoutePreferences: () => Promise.resolve(undefined),
+    },
+  } as unknown as APIClient;
+}
+
+const stubClient = createStubApiClient();
+
+const wrapper: React.FC<{ children: React.ReactNode }> = (props) =>
+  React.createElement(
+    APIProvider,
+    { client: stubClient } as React.ComponentProps<typeof APIProvider>,
+    props.children
+  );
+
+describe("useRouting", () => {
+  beforeEach(() => {
+    globalThis.window = new GlobalWindow({ url: "https://mux.example.com/" }) as unknown as Window &
+      typeof globalThis;
+    globalThis.document = globalThis.window.document;
+    providersConfig = null;
+    routePriority = ["direct"];
+    routeOverrides = {};
+    configGetConfig = () => Promise.resolve({ routePriority, routeOverrides });
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  test("resolveRoute and availableRoutes honor gateway model accessibility", async () => {
+    providersConfig = {
+      openai: { apiKeySet: true, isEnabled: true, isConfigured: true },
+      "github-copilot": {
+        apiKeySet: true,
+        isEnabled: true,
+        isConfigured: true,
+        models: [KNOWN_MODELS.GPT_54_MINI.providerModelId],
+      },
+    };
+
+    const { result } = renderHook(() => useRouting(), { wrapper });
+
+    await waitFor(() => {
+      expect(
+        result.current
+          .availableRoutes(KNOWN_MODELS.GPT.id)
+          .some((route) => route.route === "github-copilot")
+      ).toBe(false);
+    });
+
+    expect(result.current.resolveRoute(KNOWN_MODELS.GPT.id)).toEqual({
+      route: "direct",
+      isAuto: true,
+      displayName: "Direct",
+    });
+  });
+});