fix(github_copilot): honor clientside api_key; non-interactive mode

The github_copilot provider ignored a caller-supplied api_key:
_get_openai_compatible_provider_info and validate_environment always took
the key from the global file-backed Authenticator, so per-request
(clientside) credentials injected by a proxy hook were silently replaced
by the shared identity (or failed outright when the token dir was
unseeded). api_base was already honored.

- chat/transformation.py: a passed api_key wins in both
  _get_openai_compatible_provider_info and validate_environment; the
  authenticator is only consulted when no key is supplied.
- embedding/transformation.py: same one-line precedence fix.
- authenticator.py: new GITHUB_COPILOT_NON_INTERACTIVE env - when set,
  get_access_token fails fast instead of starting the interactive
  device-code login (verification prompt + minutes-long poll), which
  would otherwise run inside a server request path or at Router startup
  (Router._add_deployment resolves the provider key at registration
  time). Also convert GetAccessTokenError escaping _refresh_api_key into
  GetAPIKeyError so callers' error handling applies.
- chat/transformation.py: in non-interactive mode an unseeded
  authenticator resolves to api_key=None instead of raising, so
  deployment registration at Router startup succeeds; per-request
  clientside credentials arrive later.
- tests: passed-key precedence, non-interactive resolution, error
  conversion, plus a github_copilot flavor of the clientside-credential
  per-key scoping regression (JuliaHub BerriAI#22864) covering api_key+api_base
  injection, shared api_base isolation, base_model preservation and key
  rotation.

Author: tanmaykm

litellm/llms/github_copilot/authenticator.py

@@ -15,6 +15,7 @@
     GetAPIKeyError,
     GetDeviceCodeError,
     RefreshAPIKeyError,
+    github_copilot_non_interactive,
 )
 
 # Constants (default values — overridable via environment variables at call time)
@@ -57,6 +58,15 @@ def get_access_token(self) -> str:
         except IOError:
             verbose_logger.warning("No existing access token found or error reading file")
 
+        if github_copilot_non_interactive():
+            # server deployments must never block a request on the interactive
+            # device-code login (verification-URL prompt + minutes-long poll)
+            raise GetAccessTokenError(
+                message="No GitHub Copilot access token available and interactive "
+                "device-flow login is disabled (GITHUB_COPILOT_NON_INTERACTIVE is set)",
+                status_code=401,
+            )
+
         for attempt in range(3):
             verbose_logger.debug(f"Access token acquisition attempt {attempt + 1}/3")
             try:
@@ -127,6 +137,14 @@ def get_api_key(self) -> str:
                 message=f"Failed to refresh API key: {str(e)}",
                 status_code=401,
             )
+        except GetAccessTokenError as e:
+            # _refresh_api_key calls get_access_token outside its own retry
+            # try-block, so this would otherwise escape get_api_key entirely
+            # and bypass callers' GetAPIKeyError handling
+            raise GetAPIKeyError(
+                message=f"Failed to get access token: {str(e)}",
+                status_code=401,
+            )
 
     def get_api_base(self) -> Optional[str]:
         """

litellm/llms/github_copilot/chat/transformation.py

@@ -16,6 +16,7 @@
     DEFAULT_GITHUB_COPILOT_API_BASE,
     GetAPIKeyError,
     get_copilot_default_headers,
+    github_copilot_non_interactive,
 )
 
 
@@ -42,14 +43,25 @@ def _get_openai_compatible_provider_info(
             or os.getenv("GITHUB_COPILOT_API_BASE")
             or DEFAULT_GITHUB_COPILOT_API_BASE
         )
-        try:
-            dynamic_api_key = self.authenticator.get_api_key()
-        except GetAPIKeyError as e:
-            raise AuthenticationError(
-                model=model,
-                llm_provider=custom_llm_provider,
-                message=str(e),
-            )
+        if api_key is not None:
+            # a caller-supplied (clientside / per-user) credential wins; the
+            # global file-backed authenticator is only for the local-CLI case
+            dynamic_api_key: str | None = api_key
+        else:
+            try:
+                dynamic_api_key = self.authenticator.get_api_key()
+            except GetAPIKeyError as e:
+                if github_copilot_non_interactive():
+                    # credentials are injected per request; raising here would
+                    # break deployment registration at Router startup
+                    # (Router._add_deployment resolves via get_llm_provider)
+                    dynamic_api_key = None
+                else:
+                    raise AuthenticationError(
+                        model=model,
+                        llm_provider=custom_llm_provider,
+                        message=str(e),
+                    )
         return dynamic_api_base, dynamic_api_key, custom_llm_provider
 
     def _transform_messages(
@@ -95,7 +107,7 @@ def validate_environment(
 
         # Add Copilot-specific headers (editor-version, user-agent, etc.)
         try:
-            copilot_api_key = self.authenticator.get_api_key()
+            copilot_api_key = api_key or self.authenticator.get_api_key()
             copilot_headers = get_copilot_default_headers(copilot_api_key)
             validated_headers = {**copilot_headers, **validated_headers}
         except GetAPIKeyError:

litellm/llms/github_copilot/common_utils.py

@@ -2,13 +2,28 @@
 Constants for Copilot integration
 """
 
+import os
 from typing import Optional, Union
 from uuid import uuid4
 
 import httpx
 
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 
+
+def github_copilot_non_interactive() -> bool:
+    """
+    True when the interactive device-code login must never run (server
+    deployments where per-user credentials are injected per request as
+    clientside api_key/api_base instead of coming from the token files).
+    """
+    return os.getenv("GITHUB_COPILOT_NON_INTERACTIVE", "").strip().lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+
+
 # Constants
 COPILOT_VERSION = "0.26.7"
 EDITOR_PLUGIN_VERSION = f"copilot-chat/{COPILOT_VERSION}"

litellm/llms/github_copilot/embedding/transformation.py

@@ -60,8 +60,9 @@ def validate_environment(
         Validate environment and set up headers for GitHub Copilot API.
         """
         try:
-            # Get GitHub Copilot API key via OAuth
-            api_key = self.authenticator.get_api_key()
+            # Get GitHub Copilot API key: a caller-supplied (clientside /
+            # per-user) credential wins over the file-backed authenticator
+            api_key = api_key or self.authenticator.get_api_key()
 
             if not api_key:
                 raise AuthenticationError(

tests/local_testing/test_router_utils.py

@@ -518,6 +518,73 @@ def mk(key):
     assert id_a not in router.clientside_credential_last_used  # side dict cleaned
 
 
+def test_router_clientside_credential_scoping_github_copilot(monkeypatch):
+    """
+    github_copilot flavor of the per-key scoping regression (JuliaHub #22864):
+    per-user Copilot keys are injected as clientside api_key AND api_base, the
+    config deployment carries no api_key at all, and two users can share the
+    same api_base (same Copilot plan) while holding different keys.
+    """
+    # Router._add_deployment resolves the provider key at registration time;
+    # without this, an unseeded authenticator would start the interactive
+    # device-code login (and then fail Router init).
+    monkeypatch.setenv("GITHUB_COPILOT_NON_INTERACTIVE", "1")
+    base = {
+        "model_name": "claude-sonnet-4.6",
+        "litellm_params": {
+            "model": "github_copilot/claude-sonnet-4.6",
+            # no api_key: per-user credentials are injected per request
+        },
+        "model_info": {"id": "copilot-base-1", "base_model": "claude-sonnet-4-6"},
+    }
+    router = Router(model_list=[base])
+    shared_base = "https://api.individual.githubcopilot.com"
+
+    def mk(key):
+        return router._handle_clientside_credential(
+            deployment=base,
+            kwargs={
+                "api_key": key,
+                "api_base": shared_base,
+                "metadata": {"model_group": "claude-sonnet-4.6"},
+            },
+            function_name="acompletion",
+        )
+
+    dep_a, dep_b = mk("COPILOT_KEY_A"), mk("COPILOT_KEY_B")
+    assert len(router.get_model_list()) == 3
+
+    # synthetic deployments keep the config model_info (base_model pricing)
+    # alongside the clientside_credential marker
+    assert dep_a.model_info.base_model == "claude-sonnet-4-6"
+    assert dep_a.model_info.clientside_credential is True
+
+    def candidate_keys(request_kwargs):
+        _, healthy = router._common_checks_available_deployment(
+            model="claude-sonnet-4.6", request_kwargs=request_kwargs
+        )
+        return {
+            d["litellm_params"].get("api_key") for d in healthy
+        }  # config deployment contributes None
+
+    # no-key request (e.g. token counting / health check): config only
+    assert candidate_keys({}) == {None}
+    # same api_base, different keys: each user sees only their own synthetic
+    assert candidate_keys({"api_key": "COPILOT_KEY_A", "api_base": shared_base}) == {
+        None,
+        "COPILOT_KEY_A",
+    }
+    assert candidate_keys({"api_key": "COPILOT_KEY_B", "api_base": shared_base}) == {
+        None,
+        "COPILOT_KEY_B",
+    }
+    # key rotation (same user, new minted key): old synthetic no longer visible
+    mk("COPILOT_KEY_A_ROTATED")
+    assert candidate_keys(
+        {"api_key": "COPILOT_KEY_A_ROTATED", "api_base": shared_base}
+    ) == {None, "COPILOT_KEY_A_ROTATED"}
+
+
 def test_router_get_async_openai_model_client():
     router = Router(
         model_list=[

tests/test_litellm/llms/github_copilot/test_github_copilot_authenticator.py

@@ -103,6 +103,32 @@ def test_get_access_token_failure(self, authenticator):
                 authenticator.get_access_token()
             assert authenticator._login.call_count == 3
 
+    def test_get_access_token_non_interactive(self, authenticator, monkeypatch):
+        """Non-interactive mode must fail fast instead of starting the
+        interactive device-code login when no token file exists."""
+        monkeypatch.setenv("GITHUB_COPILOT_NON_INTERACTIVE", "1")
+        with (
+            patch.object(authenticator, "_login") as mock_login,
+            patch("builtins.open", side_effect=IOError),
+        ):
+            with pytest.raises(GetAccessTokenError):
+                authenticator.get_access_token()
+            mock_login.assert_not_called()
+
+    def test_get_api_key_wraps_access_token_error(self, authenticator):
+        """A GetAccessTokenError escaping _refresh_api_key must surface as
+        GetAPIKeyError so callers' error handling applies."""
+        with (
+            patch.object(
+                authenticator,
+                "_refresh_api_key",
+                side_effect=GetAccessTokenError(message="no token", status_code=401),
+            ),
+            patch("builtins.open", side_effect=IOError),
+        ):
+            with pytest.raises(GetAPIKeyError):
+                authenticator.get_api_key()
+
     def test_get_api_key_from_file(self, authenticator):
         """Test retrieving an API key from a file."""
         future_time = (datetime.now() + timedelta(hours=1)).timestamp()

tests/test_litellm/llms/github_copilot/test_github_copilot_transformation.py

@@ -93,6 +93,100 @@ def test_github_copilot_config_get_openai_compatible_provider_info():
     assert "Failed to get API key" in str(excinfo.value)
 
 
+def test_github_copilot_provider_info_honors_clientside_api_key():
+    """A caller-supplied api_key must win over the global authenticator
+    (per-user Copilot keys are injected as clientside credentials)."""
+    config = GithubCopilotConfig()
+    config.authenticator = MagicMock()
+    config.authenticator.get_api_base.return_value = None
+
+    (
+        api_base,
+        dynamic_api_key,
+        custom_llm_provider,
+    ) = config._get_openai_compatible_provider_info(
+        model="github_copilot/gpt-4",
+        api_base="https://api.individual.githubcopilot.com",
+        api_key="user-copilot-key",
+        custom_llm_provider="github_copilot",
+    )
+
+    assert dynamic_api_key == "user-copilot-key"
+    assert api_base == "https://api.individual.githubcopilot.com"
+    config.authenticator.get_api_key.assert_not_called()
+
+    # even with an unseeded authenticator (raises), a passed api_key must work
+    config.authenticator.get_api_key.side_effect = GetAPIKeyError(
+        message="unseeded",
+        status_code=401,
+    )
+    (
+        _,
+        dynamic_api_key,
+        _,
+    ) = config._get_openai_compatible_provider_info(
+        model="github_copilot/gpt-4",
+        api_base=None,
+        api_key="user-copilot-key",
+        custom_llm_provider="github_copilot",
+    )
+    assert dynamic_api_key == "user-copilot-key"
+
+
+def test_github_copilot_provider_info_non_interactive_returns_none(monkeypatch):
+    """In non-interactive mode an unseeded authenticator must resolve to a
+    None api_key (deployment registration at Router startup must not fail;
+    per-request clientside credentials arrive later)."""
+    monkeypatch.setenv("GITHUB_COPILOT_NON_INTERACTIVE", "1")
+    config = GithubCopilotConfig()
+    config.authenticator = MagicMock()
+    config.authenticator.get_api_base.return_value = None
+    config.authenticator.get_api_key.side_effect = GetAPIKeyError(
+        message="unseeded",
+        status_code=401,
+    )
+
+    (
+        api_base,
+        dynamic_api_key,
+        custom_llm_provider,
+    ) = config._get_openai_compatible_provider_info(
+        model="github_copilot/gpt-4",
+        api_base=None,
+        api_key=None,
+        custom_llm_provider="github_copilot",
+    )
+
+    assert dynamic_api_key is None
+    assert api_base == "https://api.githubcopilot.com"
+
+
+def test_github_copilot_validate_environment_uses_clientside_api_key():
+    """validate_environment must build the Copilot default headers from a
+    passed api_key without consulting the (possibly unseeded) authenticator."""
+    config = GithubCopilotConfig()
+    config.authenticator = MagicMock()
+    config.authenticator.get_api_key.side_effect = GetAPIKeyError(
+        message="unseeded",
+        status_code=401,
+    )
+
+    headers = config.validate_environment(
+        headers={},
+        model="github_copilot/gpt-4",
+        messages=[{"role": "user", "content": "hi"}],
+        optional_params={},
+        litellm_params={},
+        api_key="user-copilot-key",
+        api_base="https://api.individual.githubcopilot.com",
+    )
+
+    assert headers["Authorization"] == "Bearer user-copilot-key"
+    assert headers["copilot-integration-id"] == "vscode-chat"
+    assert "editor-version" in headers
+    config.authenticator.get_api_key.assert_not_called()
+
+
 @patch("litellm.llms.github_copilot.authenticator.Authenticator.get_api_key")
 @patch("litellm.main.openai_chat_completions.completion")
 @patch("litellm.llms.openai.openai.OpenAIChatCompletion.completion")