feat(github_copilot): per-user GitHub OAuth connections for Copilot credentials

litellm-proxy-extras/litellm_proxy_extras/migrations/20261008120000_user_provider_credentials/migration.sql

@@ -0,0 +1,18 @@
+-- CreateTable
+CREATE TABLE IF NOT EXISTS "LiteLLM_UserProviderCredentials" (
+    "id" TEXT NOT NULL,
+    "user_id" TEXT NOT NULL,
+    "credential_name" TEXT NOT NULL,
+    "provider" TEXT NOT NULL,
+    "credential_b64" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "LiteLLM_UserProviderCredentials_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX IF NOT EXISTS "LiteLLM_UserProviderCredentials_user_id_credential_name_key" ON "LiteLLM_UserProviderCredentials"("user_id", "credential_name");
+
+-- CreateIndex
+CREATE INDEX IF NOT EXISTS "LiteLLM_UserProviderCredentials_credential_name_idx" ON "LiteLLM_UserProviderCredentials"("credential_name");

litellm-proxy-extras/litellm_proxy_extras/schema.prisma

@@ -453,6 +453,20 @@ model LiteLLM_MCPUserCredentials {
   @@unique([user_id, server_id])
 }
 
+// Per-user provider connections (e.g. GitHub Copilot OAuth) keyed by credential name
+model LiteLLM_UserProviderCredentials {
+  id               String   @id @default(uuid())
+  user_id          String
+  credential_name  String
+  provider         String
+  credential_b64   String
+  created_at       DateTime @default(now()) @map("created_at")
+  updated_at       DateTime @default(now()) @updatedAt @map("updated_at")
+
+  @@unique([user_id, credential_name])
+  @@index([credential_name])
+}
+
 // Per-user environment variable values for MCP servers.
 // values_b64 is an encrypted JSON object: {VAR_NAME: "value", ...}.
 model LiteLLM_MCPUserEnvVars {

litellm/__init__.py

@@ -1396,6 +1396,8 @@ def _build_models_by_provider() -> dict:
 from .llms.custom_httpx.async_client_cleanup import close_litellm_async_clients
 from .exceptions import (
     AuthenticationError,
+    CallerCredentialAuthenticationError as CallerCredentialAuthenticationError,
+    CallerCredentialRateLimitError as CallerCredentialRateLimitError,
     InvalidRequestError,
     BadRequestError,
     ImageFetchError,

litellm/caching/caching_handler.py

@@ -107,11 +107,15 @@ def _drop_logging_obj_from_kwargs(request_kwargs: dict[str, object]) -> dict[str
 
 
 def _is_response_cache_excluded(model: str | None, kwargs: Mapping[str, object]) -> bool:
+    from litellm.llms.github_copilot.per_user_auth import is_github_copilot_per_user_request
+
     custom_llm_provider: Final = kwargs.get("custom_llm_provider")
     model_provider: Final = model.split("/", maxsplit=1)[0] if model is not None else None
     return (
-        isinstance(custom_llm_provider, str) and custom_llm_provider in RESPONSE_CACHE_EXCLUDED_PROVIDERS
-    ) or model_provider in RESPONSE_CACHE_EXCLUDED_PROVIDERS
+        (isinstance(custom_llm_provider, str) and custom_llm_provider in RESPONSE_CACHE_EXCLUDED_PROVIDERS)
+        or model_provider in RESPONSE_CACHE_EXCLUDED_PROVIDERS
+        or is_github_copilot_per_user_request(kwargs)
+    )
 
 
 def _is_chat_completion_cached_dict(cached_result: dict) -> bool:
@@ -317,6 +321,7 @@ async def async_get_cache(
             None
         """
         if _is_response_cache_excluded(model=model, kwargs=kwargs):
+            self.request_kwargs = _drop_logging_obj_from_kwargs(kwargs)
             return None
 
         # Check if caching should be performed BEFORE doing expensive operations
@@ -444,6 +449,7 @@ def sync_get_cache(
 
         # Check if caching should be performed BEFORE doing expensive kwargs copy
         if _is_response_cache_excluded(model=model, kwargs=kwargs):
+            self.request_kwargs = _drop_logging_obj_from_kwargs(kwargs)
             return CachingHandlerResponse(cached_result=None)
         if litellm.cache is not None and self._is_call_type_supported_by_cache(original_function=original_function):
             args = args or ()
@@ -867,11 +873,11 @@ async def _retrieve_from_cache(
             new_kwargs.pop("metadata", None)
         model_value: Final = new_kwargs.get("model")
         model: Final = model_value if isinstance(model_value, str) else None
+        self.request_kwargs = _drop_logging_obj_from_kwargs(new_kwargs)
         if _is_response_cache_excluded(model=model, kwargs=new_kwargs):
             return None
         if new_kwargs.get("stream") is True and "cache_key" not in new_kwargs:
             new_kwargs["cache_key"] = litellm.cache.get_cache_key(**new_kwargs)
-        self.request_kwargs = _drop_logging_obj_from_kwargs(new_kwargs)
         cached_result: object | None = None
         if call_type == CallTypes.aembedding.value:
             new_kwargs["input"] = self.handle_kwargs_input_list_or_str(new_kwargs)

litellm/constants.py

@@ -13,6 +13,13 @@
 # Replies depend on the caller's delegated identity, which response-cache keys do not include.
 RESPONSE_CACHE_EXCLUDED_PROVIDERS: Final = frozenset({"microsoft_365_copilot"})
 MICROSOFT_365_COPILOT_DEFAULT_TIME_ZONE: Final = "UTC"
+GITHUB_COPILOT_PER_USER_AUTH_TYPE: Final = "per_user_oauth"
+GITHUB_COPILOT_AUTH_TYPE_KEY: Final = "github_copilot_auth_type"
+GITHUB_COPILOT_USER_TOKEN_SAFETY_MARGIN_SECONDS: Final = 60
+GITHUB_COPILOT_USER_CREDENTIAL_CACHE_TTL_SECONDS: Final = 60
+GITHUB_COPILOT_DEVICE_FLOW_CACHE_PREFIX: Final = "github_copilot_device_flow"
+USER_PROVIDER_CREDENTIAL_CACHE_PREFIX: Final = "user_provider_credential"
+USER_PROVIDER_CREDENTIAL_NOT_CONNECTED: Final = "__not_connected__"
 SERVER_STREAMING_CLASSIFICATION_KEY: Final = "litellm_server_streaming_classification"
 
 

litellm/exceptions.py

@@ -172,6 +172,12 @@ def __repr__(self):
         return _message
 
 
+class CallerCredentialAuthenticationError(AuthenticationError):
+    """401 raised when the CALLING user's own stored provider credential is
+    missing or rejected (e.g. a per-user OAuth connection). Scoped to one
+    caller's credential, so routers must not cool down the shared deployment."""
+
+
 # raise when invalid models passed, example gpt-8
 class NotFoundError(openai.NotFoundError):
     def __init__(
@@ -531,6 +537,12 @@ def __repr__(self):
         return _message
 
 
+class CallerCredentialRateLimitError(RateLimitError):
+    """429 raised when a per-user credential exchange is rate limited by the
+    provider (e.g. GitHub's token endpoint). Scoped to one caller's
+    credential, so routers must not cool down the shared deployment."""
+
+
 # sub class of rate limit error - meant to give more granularity for error handling context window exceeded errors
 class ContextWindowExceededError(BadRequestError):
     def __init__(

litellm/integrations/otel/model/spans.py

@@ -293,6 +293,7 @@ class PostgresOperation:
         "LiteLLM_BackgroundInteractionSettlement",
         "LiteLLM_ErrorLogs",
         "LiteLLM_UserNotifications",
+        "LiteLLM_UserProviderCredentials",
         "LiteLLM_TeamMembership",
         "LiteLLM_OrganizationMembership",
         "LiteLLM_InvitationLink",

litellm/litellm_core_utils/credential_accessor.py

@@ -15,7 +15,9 @@ def find_credential(credential_name: str) -> CredentialItem | None:
         )
 
     @staticmethod
-    def get_credential_values(credential_name: str) -> dict:
+    def get_credential_values(
+        credential_name: str,
+    ) -> dict[str, object]:  # mutable-ok: callers merge the returned credential map
         """Safe accessor for credentials."""
 
         credential: Final = CredentialAccessor.find_credential(credential_name)

litellm/litellm_core_utils/get_litellm_params.py

@@ -75,6 +75,8 @@
             "itpm",
             "otpm",
             "use_xai_oauth",
+            "github_copilot_auth_type",
+            "github_copilot_user_session",
             "fireworks_forward_user_id",
             PROVIDER_AFFINITY_HEADER_KWARG_KEY,
         }

litellm/litellm_core_utils/get_llm_provider_logic.py

@@ -795,13 +795,36 @@ def _get_openai_compatible_provider_info(
         api_base = api_base or get_secret("GALADRIEL_API_BASE") or "https://api.galadriel.com/v1"
         dynamic_api_key = api_key or get_secret_str("GALADRIEL_API_KEY")
     elif custom_llm_provider == "github_copilot":
-        (
-            api_base,
-            dynamic_api_key,
-            custom_llm_provider,
-        ) = litellm.GithubCopilotConfig().get_openai_compatible_provider_info(
-            model, api_base, api_key, custom_llm_provider
+        from litellm.llms.github_copilot.common_utils import DEFAULT_GITHUB_COPILOT_API_BASE
+        from litellm.llms.github_copilot.per_user_auth import (
+            github_copilot_per_user_credential_name,
+            github_copilot_user_session_from,
+        )
+
+        user_session: Final = github_copilot_user_session_from(
+            cast("dict[str, object]", litellm_params)  # cast-ok: litellm_params arrives as an untyped request dict
         )
+        if user_session is not None:
+            api_base = user_session.api_base  # rebind-ok: resolves provider args in place
+            dynamic_api_key = user_session.token  # rebind-ok: resolves provider args in place
+        elif (
+            github_copilot_per_user_credential_name(
+                cast("dict[str, object]", litellm_params)  # cast-ok: untyped params dict
+            )
+            is not None
+        ):
+            # per-user deployments resolve no token at provider-info time; the
+            # caller's session supplies base + key per request
+            api_base = api_base or DEFAULT_GITHUB_COPILOT_API_BASE  # rebind-ok: resolves provider args in place
+            dynamic_api_key = None  # rebind-ok: resolves provider args in place
+        else:
+            (
+                api_base,  # rebind-ok: resolves provider args in place
+                dynamic_api_key,  # rebind-ok: resolves provider args in place
+                custom_llm_provider,  # rebind-ok: resolves provider args in place
+            ) = litellm.GithubCopilotConfig().get_openai_compatible_provider_info(
+                model, api_base, api_key, custom_llm_provider
+            )
     elif custom_llm_provider == "chatgpt":
         (
             api_base,

litellm/llms/anthropic/pass_through/messages/handler.py

@@ -7,7 +7,7 @@
 
 import asyncio
 import contextvars
-from collections.abc import AsyncIterator, Coroutine, Iterator
+from collections.abc import AsyncIterator, Coroutine, Iterator, Sequence
 from functools import partial
 from typing import Any, Final, cast
 
@@ -23,6 +23,7 @@
 from litellm.llms.base_llm.chat.transformation import BaseLLMException
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.llms.custom_httpx.llm_http_handler import BaseLLMHTTPHandler
+from litellm.types.llms.anthropic import AllAnthropicToolsValues
 from litellm.types.llms.anthropic_messages.anthropic_request import AnthropicMetadata
 from litellm.types.llms.anthropic_messages.anthropic_response import (
     AnthropicMessagesResponse,
@@ -467,6 +468,7 @@ def anthropic_messages_handler(
         custom_llm_provider=custom_llm_provider,
         api_base=litellm_params.api_base,
         api_key=litellm_params.api_key,
+        litellm_params=litellm_params,
     )
 
     # Store agentic loop params in logging object for agentic hooks
@@ -513,7 +515,9 @@ def anthropic_messages_handler(
                 metadata=metadata,
                 stop_sequences=stop_sequences,
                 stream=stream,
-                system=system,
+                system=cast(  # cast-ok: anthropic accepts list system blocks; handler signature is narrower
+                    "str | None", system
+                ),
                 temperature=temperature,
                 thinking=thinking,
                 tool_choice=tool_choice,
@@ -557,11 +561,15 @@ def anthropic_messages_handler(
                 metadata=metadata,
                 stop_sequences=stop_sequences,
                 stream=stream,
-                system=system,
+                system=cast(  # cast-ok: anthropic accepts list system blocks; handler signature is narrower
+                    "str | None", system
+                ),
                 temperature=temperature,
                 thinking=thinking,
                 tool_choice=tool_choice,
-                tools=tools,
+                tools=cast(  # cast-ok: dict tools already fit the handler's union
+                    "list[AllAnthropicToolsValues | dict[str, object]] | None", tools
+                ),
                 top_k=top_k,
                 top_p=top_p,
                 _is_async=is_async,
@@ -583,11 +591,13 @@ def anthropic_messages_handler(
             metadata=metadata,
             stop_sequences=stop_sequences,
             stream=stream,
-            system=system,
+            system=cast(  # cast-ok: anthropic accepts list system blocks; handler signature is narrower
+                "str | None", system
+            ),
             temperature=temperature,
             thinking=thinking,
             tool_choice=tool_choice,
-            tools=tools,
+            tools=cast("list[dict[str, object]] | None", tools),  # cast-ok: dict tools fit the adapter's declared union
             top_k=top_k,
             top_p=top_p,
             _is_async=is_async,
@@ -619,7 +629,12 @@ def anthropic_messages_handler(
     )
     return base_llm_http_handler.anthropic_messages_handler(
         model=model,
-        messages=strip_provider_specific_fields_from_anthropic_messages(messages),
+        messages=cast(  # cast-ok: anthropic messages are dicts at runtime
+            "list[dict[str, object]]",
+            strip_provider_specific_fields_from_anthropic_messages(
+                cast(Sequence[object], messages)  # cast-ok: anthropic payloads arrive as untyped dicts
+            ),
+        ),
         anthropic_messages_provider_config=anthropic_messages_provider_config,
         anthropic_messages_optional_request_params=dict(anthropic_messages_optional_request_params),
         _is_async=is_async,

litellm/llms/github_copilot/authenticator.py

@@ -45,6 +45,22 @@ class _AccessTokenPoll(TypedDict):
 _ACCESS_TOKEN_POLL: Final = TypeAdapter(_AccessTokenPoll)
 
 
+def github_api_headers(
+    access_token: str | None = None,
+) -> dict[str, str]:  # mutable-ok: returned straight into httpx handlers whose headers params require dict
+    headers: Final = {
+        "accept": "application/json",
+        "editor-version": "vscode/1.85.1",
+        "editor-plugin-version": "copilot/1.155.0",
+        "user-agent": "GithubCopilot/1.155.0",
+        "accept-encoding": "gzip,deflate,br",
+        "content-type": "application/json",
+    }
+    if access_token:
+        headers["authorization"] = f"token {access_token}"
+    return headers
+
+
 class Authenticator:
     def __init__(self) -> None:
         """Initialize the GitHub Copilot authenticator with configurable token paths."""
@@ -230,21 +246,7 @@ def _get_github_headers(self, access_token: str | None = None) -> dict[str, str]
         Returns:
             Dict[str, str]: Headers for GitHub API requests.
         """
-        headers: Final = {
-            "accept": "application/json",
-            "editor-version": "vscode/1.85.1",
-            "editor-plugin-version": "copilot/1.155.0",
-            "user-agent": "GithubCopilot/1.155.0",
-            "accept-encoding": "gzip,deflate,br",
-        }
-
-        if access_token:
-            headers["authorization"] = f"token {access_token}"
-
-        if "content-type" not in headers:
-            headers["content-type"] = "application/json"
-
-        return headers
+        return github_api_headers(access_token)
 
     def _get_device_code(self) -> _DeviceCode:
         """