Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

fix: support copilot oauth sessions

JerrettDavis79895813504e
diff --git a/headroom/cli/wrap.py b/headroom/cli/wrap.py
index b991595c1..6fbec6551 100644
--- a/headroom/cli/wrap.py
+++ b/headroom/cli/wrap.py
@@ -36,6 +36,9 @@ if sys.platform == "win32" and hasattr(sys.stdout, "buffer"):
import click
+from headroom.copilot_auth import DEFAULT_API_URL as COPILOT_API_URL
+from headroom.copilot_auth import has_oauth_auth, resolve_client_bearer_token
+
from .main import main
@@ -85,6 +88,7 @@ def _start_proxy(
backend: str | None = None,
anyllm_provider: str | None = None,
region: str | None = None,
+ openai_api_url: str | None = None,
) -> subprocess.Popen:
"""Start Headroom proxy as a background subprocess.
@@ -124,6 +128,9 @@ def _start_proxy(
if _region:
cmd.extend(["--region", _region])
+ if openai_api_url:
+ cmd.extend(["--openai-api-url", openai_api_url])
+
log_path = _get_log_path()
log_file = open(log_path, "a") # noqa: SIM115
@@ -694,6 +701,26 @@ def _copilot_model_configured(copilot_args: tuple[str, ...], env: dict[str, str]
return False
+def _should_use_copilot_oauth(
+ *,
+ backend: str | None,
+ provider_type: str,
+ env: dict[str, str],
+) -> bool:
+ """Prefer existing Copilot auth when the requested routing supports it."""
+
+ if env.get("COPILOT_PROVIDER_API_KEY") or env.get("COPILOT_PROVIDER_BEARER_TOKEN"):
+ return False
+ if provider_type == "anthropic":
+ return False
+
+ effective_backend = backend or os.environ.get("HEADROOM_BACKEND")
+ if effective_backend not in (None, "", "anthropic"):
+ return False
+
+ return has_oauth_auth()
+
+
def _ensure_proxy(
port: int,
no_proxy: bool,
@@ -705,6 +732,7 @@ def _ensure_proxy(
backend: str | None = None,
anyllm_provider: str | None = None,
region: str | None = None,
+ openai_api_url: str | None = None,
) -> subprocess.Popen | None:
"""Start or verify proxy. Returns process handle if we started it."""
if not no_proxy:
@@ -780,6 +808,7 @@ def _ensure_proxy(
backend=backend,
anyllm_provider=anyllm_provider,
region=region,
+ openai_api_url=openai_api_url,
)
click.echo(f" Proxy ready on http://127.0.0.1:{port}")
return proc
@@ -847,6 +876,7 @@ def _launch_tool(
backend: str | None = None,
anyllm_provider: str | None = None,
region: str | None = None,
+ openai_api_url: str | None = None,
) -> None:
"""Common logic: start proxy, launch tool, clean up."""
proxy_holder: list[subprocess.Popen | None] = [None]
@@ -872,6 +902,7 @@ def _launch_tool(
backend=backend,
anyllm_provider=anyllm_provider,
region=region,
+ openai_api_url=openai_api_url,
)
if code_graph:
@@ -1412,58 +1443,81 @@ def copilot(
_inject_rtk_instructions(copilot_instructions, verbose=verbose)
env = os.environ.copy()
- env["COPILOT_PROVIDER_TYPE"] = effective_provider_type
env.pop("COPILOT_PROVIDER_WIRE_API", None)
+ openai_api_url: str | None = None
- # Copilot BYOK requires COPILOT_PROVIDER_API_KEY — propagate from the
- # user's existing provider key so they don't have to set it twice.
- # Note: `headroom wrap copilot` uses Copilot's BYOK mode, which bypasses
- # GitHub's Copilot API and talks directly to the model provider through
- # the Headroom proxy. This requires the provider's own API key — a GitHub
- # Copilot subscription alone is not sufficient for BYOK mode.
- if not env.get("COPILOT_PROVIDER_API_KEY"):
- if effective_provider_type == "anthropic":
- _key = env.get("ANTHROPIC_API_KEY", "")
- else:
- _key = env.get("OPENAI_API_KEY", "")
- if _key:
- env["COPILOT_PROVIDER_API_KEY"] = _key
+ if _should_use_copilot_oauth(
+ backend=effective_backend,
+ provider_type=provider_type,
+ env=env,
+ ):
+ client_bearer = resolve_client_bearer_token()
+ if not client_bearer:
+ raise click.ClickException(
+ "GitHub Copilot auth was detected but no reusable bearer token could be resolved."
+ )
- env_vars_display: list[str]
- if effective_provider_type == "anthropic":
- env["COPILOT_PROVIDER_BASE_URL"] = f"http://127.0.0.1:{port}"
- env_vars_display = [
- "COPILOT_PROVIDER_TYPE=anthropic",
- f"COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:{port}",
- ]
- else:
- effective_wire_api = wire_api or "completions"
+ env["COPILOT_PROVIDER_TYPE"] = "openai"
env["COPILOT_PROVIDER_BASE_URL"] = f"http://127.0.0.1:{port}/v1"
- env["COPILOT_PROVIDER_WIRE_API"] = effective_wire_api
+ env["COPILOT_PROVIDER_WIRE_API"] = wire_api or "completions"
+ env["COPILOT_PROVIDER_BEARER_TOKEN"] = client_bearer
+ env.pop("COPILOT_PROVIDER_API_KEY", None)
env_vars_display = [
"COPILOT_PROVIDER_TYPE=openai",
f"COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:{port}/v1",
- f"COPILOT_PROVIDER_WIRE_API={effective_wire_api}",
+ f"COPILOT_PROVIDER_WIRE_API={env['COPILOT_PROVIDER_WIRE_API']}",
+ "COPILOT_AUTH_MODE=github-oauth",
]
+ openai_api_url = COPILOT_API_URL
+ else:
+ env["COPILOT_PROVIDER_TYPE"] = effective_provider_type
- if not env.get("COPILOT_PROVIDER_API_KEY"):
- src = "ANTHROPIC_API_KEY" if effective_provider_type == "anthropic" else "OPENAI_API_KEY"
- click.echo(
- f"\n Error: Copilot BYOK mode requires a provider API key.\n"
- f" `headroom wrap copilot` uses Copilot's BYOK mode, which bypasses GitHub's\n"
- f" Copilot API and routes requests directly to the model provider through the\n"
- f" Headroom proxy. A GitHub Copilot subscription alone is not sufficient.\n\n"
- f" Set one of:\n"
- f" export {src}=sk-... # recommended\n"
- f" export COPILOT_PROVIDER_API_KEY=sk-... # also works\n"
- )
- raise SystemExit(1)
+ # Copilot BYOK requires COPILOT_PROVIDER_API_KEY — propagate from the
+ # user's existing provider key so they don't have to set it twice.
+ if not env.get("COPILOT_PROVIDER_API_KEY"):
+ if effective_provider_type == "anthropic":
+ _key = env.get("ANTHROPIC_API_KEY", "")
+ else:
+ _key = env.get("OPENAI_API_KEY", "")
+ if _key:
+ env["COPILOT_PROVIDER_API_KEY"] = _key
- if not _copilot_model_configured(copilot_args, env):
- click.echo(
- " Note: Copilot BYOK requires a model. Pass `--model <name>` "
- "or set `COPILOT_MODEL` / `COPILOT_PROVIDER_MODEL_ID`."
- )
+ if effective_provider_type == "anthropic":
+ env["COPILOT_PROVIDER_BASE_URL"] = f"http://127.0.0.1:{port}"
+ env_vars_display = [
+ "COPILOT_PROVIDER_TYPE=anthropic",
+ f"COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:{port}",
+ ]
+ else:
+ effective_wire_api = wire_api or "completions"
+ env["COPILOT_PROVIDER_BASE_URL"] = f"http://127.0.0.1:{port}/v1"
+ env["COPILOT_PROVIDER_WIRE_API"] = effective_wire_api
+ env_vars_display = [
+ "COPILOT_PROVIDER_TYPE=openai",
+ f"COPILOT_PROVIDER_BASE_URL=http://127.0.0.1:{port}/v1",
+ f"COPILOT_PROVIDER_WIRE_API={effective_wire_api}",
+ ]
+
+ if not env.get("COPILOT_PROVIDER_API_KEY"):
+ src = (
+ "ANTHROPIC_API_KEY" if effective_provider_type == "anthropic" else "OPENAI_API_KEY"
+ )
+ click.echo(
+ f"\n Error: Copilot BYOK mode requires a provider API key.\n"
+ f" No reusable GitHub Copilot OAuth session was found, so Headroom fell back to\n"
+ f" Copilot's BYOK provider mode. That mode bypasses GitHub's Copilot API and\n"
+ f" routes requests directly to the model provider through the Headroom proxy.\n\n"
+ f" Set one of:\n"
+ f" export {src}=sk-... # recommended\n"
+ f" export COPILOT_PROVIDER_API_KEY=sk-... # also works\n"
+ )
+ raise SystemExit(1)
+
+ if not _copilot_model_configured(copilot_args, env):
+ click.echo(
+ " Note: Copilot BYOK requires a model. Pass `--model <name>` "
+ "or set `COPILOT_MODEL` / `COPILOT_PROVIDER_MODEL_ID`."
+ )
_launch_tool(
binary=copilot_bin,
@@ -1479,6 +1533,7 @@ def copilot(
backend=backend,
anyllm_provider=anyllm_provider,
region=region,
+ openai_api_url=openai_api_url,
)
diff --git a/headroom/copilot_auth.py b/headroom/copilot_auth.py
new file mode 100644
index 000000000..d31f56e19
--- /dev/null
+++ b/headroom/copilot_auth.py
@@ -0,0 +1,306 @@
+"""GitHub Copilot OAuth discovery and API-token exchange helpers."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from urllib import error as urllib_error
+from urllib import request as urllib_request
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_API_URL = "https://api.githubcopilot.com"
+DEFAULT_TOKEN_EXCHANGE_URL = "https://api.github.com/copilot_internal/v2/token"
+DEFAULT_GITHUB_HOST = "github.com"
+_TOKEN_EXPIRY_BUFFER_S = 60
+_DEFAULT_EDITOR_VERSION = "vscode/1.104.1"
+_DEFAULT_USER_AGENT = "GitHubCopilotChat/0.1"
+
+_API_TOKEN_ENV_VARS = (
+ "GITHUB_COPILOT_API_TOKEN",
+ "COPILOT_PROVIDER_BEARER_TOKEN",
+)
+_OAUTH_TOKEN_ENV_VARS = (
+ "GITHUB_COPILOT_GITHUB_TOKEN",
+ "GITHUB_COPILOT_TOKEN",
+ "GITHUB_TOKEN",
+ "COPILOT_GITHUB_TOKEN",
+)
+_OAUTH_TOKEN_KEYS = (
+ "oauth_token",
+ "oauthToken",
+ "token",
+ "access_token",
+ "accessToken",
+)
+_EXPIRY_KEYS = ("expires_at", "expiresAt", "expiry", "expires")
+
+
+@dataclass(frozen=True)
+class CopilotAPIToken:
+ """Short-lived API token exchanged from a GitHub OAuth token."""
+
+ token: str
+ expires_at: float
+ api_url: str = DEFAULT_API_URL
+ refresh_in: int | None = None
+ sku: str | None = None
+
+ @property
+ def is_valid(self) -> bool:
+ return time.time() < (self.expires_at - _TOKEN_EXPIRY_BUFFER_S)
+
+
+def _github_host() -> str:
+ return (os.environ.get("GITHUB_COPILOT_HOST") or DEFAULT_GITHUB_HOST).strip().lower()
+
+
+def _token_exchange_url() -> str:
+ return os.environ.get("GITHUB_COPILOT_TOKEN_EXCHANGE_URL", DEFAULT_TOKEN_EXCHANGE_URL).strip()
+
+
+def _resolve_token_file_paths() -> list[Path]:
+ override = os.environ.get("GITHUB_COPILOT_TOKEN_FILE", "").strip()
+ if override:
+ return [Path(override).expanduser()]
+
+ paths: list[Path] = []
+ local_appdata = os.environ.get("LOCALAPPDATA", "").strip()
+ if local_appdata:
+ base = Path(local_appdata) / "github-copilot"
+ paths.extend([base / "apps.json", base / "hosts.json"])
+
+ config_base = Path.home() / ".config" / "github-copilot"
+ paths.extend([config_base / "apps.json", config_base / "hosts.json"])
+ return paths
+
+
+def _parse_expiry(value: Any) -> float | None:
+ if value in (None, ""):
+ return None
+
+ if isinstance(value, int | float):
+ number = float(value)
+ if number > 10_000_000_000:
+ return number / 1000.0
+ return number
+
+ if isinstance(value, str):
+ raw = value.strip()
+ if not raw:
+ return None
+ if raw.isdigit():
+ return _parse_expiry(int(raw))
+ try:
+ normalized = raw.replace("Z", "+00:00")
+ return datetime.fromisoformat(normalized).timestamp()
+ except ValueError:
+ return None
+
+ return None
+
+
+def _entry_expired(entry: dict[str, Any]) -> bool:
+ for key in _EXPIRY_KEYS:
+ expiry = _parse_expiry(entry.get(key))
+ if expiry is None:
+ continue
+ return time.time() >= (expiry - _TOKEN_EXPIRY_BUFFER_S)
+ return False
+
+
+def _extract_oauth_token(entry: dict[str, Any]) -> str | None:
+ if _entry_expired(entry):
+ return None
+
+ for key in _OAUTH_TOKEN_KEYS:
+ value = entry.get(key)
+ if isinstance(value, str) and value.strip():
+ return value.strip()
+
+ for value in entry.values():
+ if isinstance(value, dict):
+ nested = _extract_oauth_token(value)
+ if nested:
+ return nested
+
+ return None
+
+
+def _iter_file_entries(payload: Any) -> list[tuple[str, dict[str, Any]]]:
+ entries: list[tuple[str, dict[str, Any]]] = []
+ if isinstance(payload, dict):
+ for key, value in payload.items():
+ if isinstance(value, dict):
+ entries.append((str(key), value))
+ elif isinstance(payload, list):
+ for idx, value in enumerate(payload):
+ if isinstance(value, dict):
+ key = str(value.get("host") or value.get("githubHost") or idx)
+ entries.append((key, value))
+ return entries
+
+
+def read_cached_oauth_token() -> str | None:
+ """Return a GitHub OAuth token for Copilot, if one is available."""
+
+ for env_var in _OAUTH_TOKEN_ENV_VARS:
+ token = os.environ.get(env_var, "").strip()
+ if token:
+ return token
+
+ host = _github_host()
+ for path in _resolve_token_file_paths():
+ try:
+ payload = json.loads(path.read_text(encoding="utf-8"))
+ except FileNotFoundError:
+ continue
+ except Exception as exc:
+ logger.debug("Unable to read Copilot credentials file %s: %s", path, exc)
+ continue
+
+ for key, entry in _iter_file_entries(payload):
+ if host not in key.lower():
+ continue
+ cached_token = _extract_oauth_token(entry)
+ if cached_token:
+ return cached_token
+
+ return None
+
+
+def resolve_client_bearer_token() -> str | None:
+ """Return a bearer token suitable for satisfying Copilot provider auth checks."""
+
+ for env_var in _API_TOKEN_ENV_VARS:
+ token = os.environ.get(env_var, "").strip()
+ if token:
+ return token
+ return read_cached_oauth_token()
+
+
+def has_oauth_auth() -> bool:
+ """Return True when existing Copilot auth can be reused."""
+
+ return resolve_client_bearer_token() is not None
+
+
+def is_copilot_api_url(url: str | None) -> bool:
+ """Return True when the upstream URL points at GitHub Copilot."""
+
+ if not url:
+ return False
+ parsed = urlparse(url)
+ host = parsed.netloc.lower() or parsed.path.lower()
+ return "githubcopilot.com" in host
+
+
+class CopilotTokenProvider:
+ """Resolve and cache short-lived Copilot API tokens."""
+
+ def __init__(self) -> None:
+ self._lock = asyncio.Lock()
+ self._cached: CopilotAPIToken | None = None
+
+ async def get_api_token(self) -> CopilotAPIToken:
+ explicit_api_token = os.environ.get("GITHUB_COPILOT_API_TOKEN", "").strip()
+ if explicit_api_token:
+ return CopilotAPIToken(
+ token=explicit_api_token,
+ expires_at=time.time() + 3600,
+ api_url=os.environ.get("GITHUB_COPILOT_API_URL", DEFAULT_API_URL).strip()
+ or DEFAULT_API_URL,
+ )
+
+ cached = self._cached
+ if cached is not None and cached.is_valid:
+ return cached
+
+ async with self._lock:
+ cached = self._cached
+ if cached is not None and cached.is_valid:
+ return cached
+
+ oauth_token = read_cached_oauth_token()
+ if not oauth_token:
+ raise RuntimeError("No GitHub Copilot OAuth token is available.")
+
+ exchanged = await self._exchange_token(oauth_token)
+ self._cached = exchanged
+ return exchanged
+
+ async def _exchange_token(self, oauth_token: str) -> CopilotAPIToken:
+ headers = {
+ "Authorization": f"token {oauth_token}",
+ "Accept": "application/json",
+ "Editor-Version": os.environ.get(
+ "GITHUB_COPILOT_EDITOR_VERSION", _DEFAULT_EDITOR_VERSION
+ ),
+ "User-Agent": _DEFAULT_USER_AGENT,
+ }
+ payload = await asyncio.to_thread(self._exchange_token_sync, headers)
+ token = str(payload.get("token") or "").strip()
+ if not token:
+ raise RuntimeError("Copilot token exchange returned an empty token.")
+
+ expires_at = _parse_expiry(payload.get("expires_at")) or (time.time() + 1800)
+ raw_endpoints = payload.get("endpoints")
+ endpoints: dict[str, Any] = raw_endpoints if isinstance(raw_endpoints, dict) else {}
+ api_url = str(endpoints.get("api") or DEFAULT_API_URL).strip() or DEFAULT_API_URL
+ refresh_in = payload.get("refresh_in")
+ sku = payload.get("sku")
+ return CopilotAPIToken(
+ token=token,
+ expires_at=expires_at,
+ api_url=api_url,
+ refresh_in=int(refresh_in) if isinstance(refresh_in, int | float) else None,
+ sku=str(sku) if isinstance(sku, str) and sku.strip() else None,
+ )
+
+ @staticmethod
+ def _exchange_token_sync(headers: dict[str, str]) -> dict[str, Any]:
+ request = urllib_request.Request(_token_exchange_url(), headers=headers, method="GET")
+ try:
+ with urllib_request.urlopen(request, timeout=10.0) as response:
+ payload = json.loads(response.read().decode("utf-8"))
+ return payload if isinstance(payload, dict) else {}
+ except urllib_error.HTTPError as exc:
+ body = exc.read().decode("utf-8", errors="replace")
+ raise RuntimeError(
+ f"Copilot token exchange failed with HTTP {exc.code}: {body}"
+ ) from exc
+
+
+_provider: CopilotTokenProvider | None = None
+
+
+def get_copilot_token_provider() -> CopilotTokenProvider:
+ """Return the shared Copilot token provider."""
+
+ global _provider
+ if _provider is None:
+ _provider = CopilotTokenProvider()
+ return _provider
+
+
+async def apply_copilot_api_auth(headers: dict[str, str], *, url: str) -> dict[str, str]:
+ """Replace Authorization with a fresh Copilot API token when targeting Copilot."""
+
+ resolved = dict(headers)
+ if not is_copilot_api_url(url):
+ return resolved
+
+ token = await get_copilot_token_provider().get_api_token()
+ for key in list(resolved):
+ if key.lower() == "authorization":
+ resolved.pop(key)
+ resolved["Authorization"] = f"Bearer {token.token}"
+ return resolved
diff --git a/headroom/proxy/handlers/openai.py b/headroom/proxy/handlers/openai.py
index 457849ebf..e80dbc5de 100644
--- a/headroom/proxy/handlers/openai.py
+++ b/headroom/proxy/handlers/openai.py
@@ -31,6 +31,8 @@ if TYPE_CHECKING:
import httpx
+from headroom.copilot_auth import apply_copilot_api_auth
+
logger = logging.getLogger("headroom.proxy")
@@ -584,6 +586,7 @@ class OpenAIHandlerMixin:
prefix_tracker=openai_prefix_tracker,
)
else:
+ headers = await apply_copilot_api_auth(headers, url=url)
response = await self._retry_request("POST", url, headers, body)
# Full diagnostic dump on upstream errors (OpenAI handler)
@@ -1093,6 +1096,7 @@ class OpenAIHandlerMixin:
memory_user_id=memory_user_id,
)
else:
+ headers = await apply_copilot_api_auth(headers, url=url)
response = await self._retry_request("POST", url, headers, body)
total_latency = (time.time() - start_time) * 1000
@@ -1369,6 +1373,8 @@ class OpenAIHandlerMixin:
f"OPENAI_API_KEY not set — upstream will likely reject"
)
+ upstream_headers = await apply_copilot_api_auth(upstream_headers, url=upstream_url)
+
# Ensure the required beta header is present — OpenAI returns 500 without it.
# Codex sends `responses_websockets=2026-02-06`; only inject if missing entirely.
if "openai-beta" not in _lower_headers:
@@ -2463,6 +2469,7 @@ class OpenAIHandlerMixin:
body = await request.body()
+ headers = await apply_copilot_api_auth(headers, url=url)
response = await self.http_client.request( # type: ignore[union-attr]
method=request.method,
url=url,
diff --git a/headroom/proxy/handlers/streaming.py b/headroom/proxy/handlers/streaming.py
index 60e5ae594..febe37ffc 100644
--- a/headroom/proxy/handlers/streaming.py
+++ b/headroom/proxy/handlers/streaming.py
@@ -21,6 +21,8 @@ if TYPE_CHECKING:
import httpx
+from headroom.copilot_auth import apply_copilot_api_auth
+
logger = logging.getLogger("headroom.proxy")
@@ -579,6 +581,7 @@ class StreamingMixin:
from headroom.proxy.helpers import MAX_SSE_BUFFER_SIZE
+ headers = await apply_copilot_api_auth(headers, url=url)
start_time = time.time()
# Mutable state for the generator to update
diff --git a/tests/test_cli/test_wrap_copilot.py b/tests/test_cli/test_wrap_copilot.py
index badcee1ad..dc8bafbab 100644
--- a/tests/test_cli/test_wrap_copilot.py
+++ b/tests/test_cli/test_wrap_copilot.py
@@ -2,14 +2,26 @@
from __future__ import annotations
+import importlib
+import sys
+import types
from pathlib import Path
from unittest.mock import patch
+import click
import pytest
from click.testing import CliRunner
-from headroom.cli import wrap as wrap_cli
-from headroom.cli.main import main
+from headroom.copilot_auth import DEFAULT_API_URL
+
+fake_main_module = types.ModuleType("headroom.cli.main")
+fake_main_module.main = click.Group()
+sys.modules["headroom.cli.main"] = fake_main_module
+sys.modules.pop("headroom.cli", None)
+sys.modules.pop("headroom.cli.wrap", None)
+
+wrap_cli = importlib.import_module("headroom.cli.wrap")
+main = fake_main_module.main
@pytest.fixture
@@ -17,6 +29,11 @@ def runner() -> CliRunner:
return CliRunner()
[email protected](autouse=True)
+def no_running_proxy(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(wrap_cli, "_check_proxy", lambda _port: False)
+
+
def test_wrap_copilot_auto_anthropic_injects_instructions(
runner: CliRunner, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
@@ -120,6 +137,57 @@ def test_wrap_copilot_auto_detects_running_proxy_backend(
assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
+def test_wrap_copilot_prefers_existing_oauth_session(
+ runner: CliRunner, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test-dummy")
+ captured: dict[str, object] = {}
+
+ def fake_launch_tool(**kwargs): # noqa: ANN003
+ captured.update(kwargs)
+
+ with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
+ with patch("headroom.cli.wrap.resolve_client_bearer_token", return_value="gho-existing"):
+ with patch("headroom.cli.wrap.has_oauth_auth", return_value=True):
+ with patch("headroom.cli.wrap._launch_tool", side_effect=fake_launch_tool):
+ result = runner.invoke(
+ main,
+ ["wrap", "copilot", "--no-rtk", "--", "--model", "claude-sonnet-4.6"],
+ )
+
+ assert result.exit_code == 0, result.output
+ env = captured["env"]
+ assert isinstance(env, dict)
+ assert env["COPILOT_PROVIDER_TYPE"] == "openai"
+ assert env["COPILOT_PROVIDER_BASE_URL"] == "http://127.0.0.1:8787/v1"
+ assert env["COPILOT_PROVIDER_WIRE_API"] == "completions"
+ assert env["COPILOT_PROVIDER_BEARER_TOKEN"] == "gho-existing"
+ assert "COPILOT_PROVIDER_API_KEY" not in env
+ assert captured["openai_api_url"] == DEFAULT_API_URL
+
+
+def test_wrap_copilot_translated_backend_still_requires_byok(
+ runner: CliRunner,
+) -> None:
+ with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
+ with patch("headroom.cli.wrap.has_oauth_auth", return_value=True):
+ result = runner.invoke(
+ main,
+ [
+ "wrap",
+ "copilot",
+ "--backend",
+ "anyllm",
+ "--",
+ "--model",
+ "gpt-4o",
+ ],
+ )
+
+ assert result.exit_code == 1
+ assert "Copilot BYOK mode requires a provider API key" in result.output
+
+
def test_wrap_copilot_rejects_wire_api_for_anthropic_provider(runner: CliRunner) -> None:
with patch("headroom.cli.wrap.shutil.which", return_value="copilot"):
result = runner.invoke(
diff --git a/tests/test_copilot_auth.py b/tests/test_copilot_auth.py
new file mode 100644
index 000000000..663dc66d3
--- /dev/null
+++ b/tests/test_copilot_auth.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import pytest
+
+from headroom import copilot_auth
+
+
+def test_read_cached_oauth_token_prefers_env(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("GITHUB_COPILOT_TOKEN", "gho-env")
+ assert copilot_auth.read_cached_oauth_token() == "gho-env"
+
+
+def test_read_cached_oauth_token_reads_hosts_file(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+ hosts = tmp_path / "hosts.json"
+ hosts.write_text(
+ json.dumps(
+ {
+ "github.com": {
+ "oauth_token": "gho-file",
+ "expires_at": "2999-01-01T00:00:00Z",
+ }
+ }
+ ),
+ encoding="utf-8",
+ )
+ monkeypatch.delenv("GITHUB_COPILOT_TOKEN", raising=False)
+ monkeypatch.setenv("GITHUB_COPILOT_TOKEN_FILE", str(hosts))
+
+ assert copilot_auth.read_cached_oauth_token() == "gho-file"
+
+
+def test_read_cached_oauth_token_skips_expired_entries(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+ hosts = tmp_path / "hosts.json"
+ hosts.write_text(
+ json.dumps({"github.com": {"oauthToken": "gho-old", "expiresAt": 1}}),
+ encoding="utf-8",
+ )
+ monkeypatch.setenv("GITHUB_COPILOT_TOKEN_FILE", str(hosts))
+
+ assert copilot_auth.read_cached_oauth_token() is None
+
+
+def test_resolve_client_bearer_token_prefers_api_token(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("GITHUB_COPILOT_API_TOKEN", "copilot-api")
+ monkeypatch.setenv("GITHUB_COPILOT_TOKEN", "gho-oauth")
+
+ assert copilot_auth.resolve_client_bearer_token() == "copilot-api"
+
+
+def test_is_copilot_api_url_matches_expected_hosts() -> None:
+ assert copilot_auth.is_copilot_api_url("https://api.githubcopilot.com/v1/chat/completions")
+ assert copilot_auth.is_copilot_api_url("wss://api.githubcopilot.com/v1/responses")
+ assert not copilot_auth.is_copilot_api_url("https://api.openai.com/v1/chat/completions")
+
+
+async def test_apply_copilot_api_auth_replaces_authorization(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ async def fake_get_api_token() -> copilot_auth.CopilotAPIToken:
+ return copilot_auth.CopilotAPIToken(
+ token="copilot-session",
+ expires_at=time.time() + 3600,
+ api_url=copilot_auth.DEFAULT_API_URL,
+ )
+
+ monkeypatch.setattr(
+ copilot_auth.get_copilot_token_provider(),
+ "get_api_token",
+ fake_get_api_token,
+ )
+
+ headers = await copilot_auth.apply_copilot_api_auth(
+ {"authorization": "Bearer downstream-token"},
+ url="https://api.githubcopilot.com/v1/chat/completions",
+ )
+
+ assert headers["Authorization"] == "Bearer copilot-session"
+ assert "authorization" not in headers
+
+
+async def test_token_provider_exchanges_and_caches(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("GITHUB_COPILOT_TOKEN", "gho-oauth")
+
+ provider = copilot_auth.CopilotTokenProvider()
+ calls = {"count": 0}
+
+ def fake_exchange(headers: dict[str, str]) -> dict[str, object]:
+ calls["count"] += 1
+ return {
+ "token": "copilot-api",
+ "expires_at": int(time.time()) + 3600,
+ "refresh_in": 1200,
+ "endpoints": {"api": "https://api.githubcopilot.com"},
+ "sku": "copilot_individual",
+ }
+
+ monkeypatch.setattr(provider, "_exchange_token_sync", staticmethod(fake_exchange))
+
+ first = await provider.get_api_token()
+ second = await provider.get_api_token()
+
+ assert first.token == "copilot-api"
+ assert second.token == "copilot-api"
+ assert calls["count"] == 1
diff --git a/tests/test_proxy_copilot_auth_hooks.py b/tests/test_proxy_copilot_auth_hooks.py
new file mode 100644
index 000000000..5a89d8017
--- /dev/null
+++ b/tests/test_proxy_copilot_auth_hooks.py
@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _load_handler_module(module_name: str, relative_path: str):
+ proxy_pkg = types.ModuleType("headroom.proxy")
+ proxy_pkg.__path__ = [str(ROOT / "headroom" / "proxy")]
+ sys.modules["headroom.proxy"] = proxy_pkg
+
+ handlers_pkg = types.ModuleType("headroom.proxy.handlers")
+ handlers_pkg.__path__ = [str(ROOT / "headroom" / "proxy" / "handlers")]
+ sys.modules["headroom.proxy.handlers"] = handlers_pkg
+
+ httpx_mod = types.ModuleType("httpx")
+ httpx_mod.ConnectError = type("ConnectError", (Exception,), {})
+ httpx_mod.ConnectTimeout = type("ConnectTimeout", (Exception,), {})
+ httpx_mod.PoolTimeout = type("PoolTimeout", (Exception,), {})
+ sys.modules["httpx"] = httpx_mod
+
+ responses_mod = types.ModuleType("fastapi.responses")
+
+ class Response:
+ def __init__(self, content=None, status_code: int = 200, headers=None, media_type=None):
+ self.content = content
+ self.status_code = status_code
+ self.headers = headers or {}
+ self.media_type = media_type
+
+ class StreamingResponse(Response):
+ pass
+
+ responses_mod.Response = Response
+ responses_mod.StreamingResponse = StreamingResponse
+ sys.modules["fastapi.responses"] = responses_mod
+
+ spec = importlib.util.spec_from_file_location(module_name, ROOT / relative_path)
+ assert spec is not None and spec.loader is not None
+ module = importlib.util.module_from_spec(spec)
+ sys.modules[module_name] = module
+ spec.loader.exec_module(module)
+ return module
+
+
+async def test_openai_passthrough_applies_copilot_auth(monkeypatch: pytest.MonkeyPatch) -> None:
+ openai_mod = _load_handler_module(
+ "tests.headroom_proxy_handlers_openai",
+ "headroom/proxy/handlers/openai.py",
+ )
+
+ seen: dict[str, object] = {}
+
+ async def fake_apply(headers: dict[str, str], *, url: str) -> dict[str, str]:
+ seen["headers"] = dict(headers)
+ seen["url"] = url
+ return {"Authorization": "Bearer upstream-token"}
+
+ monkeypatch.setattr(openai_mod, "apply_copilot_api_auth", fake_apply)
+
+ class Dummy(openai_mod.OpenAIHandlerMixin):
+ def __init__(self) -> None:
+ self.metrics = SimpleNamespace(record_request=self._record_request)
+ self.http_client = SimpleNamespace(request=self._request)
+
+ async def _record_request(self, **kwargs) -> None: # noqa: ANN003
+ return None
+
+ async def _request(self, **kwargs): # noqa: ANN003
+ seen["request_kwargs"] = kwargs
+ return SimpleNamespace(headers={}, content=b"{}", status_code=200)
+
+ request = SimpleNamespace(
+ url=SimpleNamespace(path="/v1/models", query=""),
+ headers={
+ "authorization": "Bearer downstream",
+ "host": "localhost",
+ "accept-encoding": "gzip",
+ },
+ method="GET",
+ body=lambda: None,
+ )
+
+ async def body() -> bytes:
+ return b""
+
+ request.body = body
+
+ handler = Dummy()
+ response = await handler.handle_passthrough(
+ request,
+ "https://api.githubcopilot.com",
+ "models",
+ "openai",
+ )
+
+ assert seen["url"] == "https://api.githubcopilot.com/v1/models"
+ assert seen["request_kwargs"]["headers"] == {"Authorization": "Bearer upstream-token"}
+ assert response.status_code == 200
+
+
+async def test_streaming_response_applies_copilot_auth(monkeypatch: pytest.MonkeyPatch) -> None:
+ streaming_mod = _load_handler_module(
+ "tests.headroom_proxy_handlers_streaming",
+ "headroom/proxy/handlers/streaming.py",
+ )
+
+ seen: dict[str, object] = {}
+
+ async def fake_apply(headers: dict[str, str], *, url: str) -> dict[str, str]:
+ seen["headers"] = dict(headers)
+ seen["url"] = url
+ return {"Authorization": "Bearer upstream-token"}
+
+ monkeypatch.setattr(streaming_mod, "apply_copilot_api_auth", fake_apply)
+
+ class Dummy(streaming_mod.StreamingMixin):
+ def __init__(self) -> None:
+ self.memory_handler = None
+ self.config = SimpleNamespace(
+ retry_max_attempts=1,
+ retry_base_delay_ms=1,
+ retry_max_delay_ms=1,
+ )
+ self.http_client = SimpleNamespace(
+ build_request=self._build_request,
+ send=self._send,
+ )
+
+ def _build_request(self, method: str, url: str, json: dict, headers: dict): # noqa: ANN003, A002
+ seen["request"] = {
+ "method": method,
+ "url": url,
+ "json": json,
+ "headers": headers,
+ }
+ return SimpleNamespace()
+
+ async def _send(self, request, stream: bool): # noqa: ANN001, ANN003
+ return SimpleNamespace(headers={}, status_code=200)
+
+ handler = Dummy()
+ response = await handler._stream_response(
+ url="https://api.githubcopilot.com/v1/responses",
+ headers={"authorization": "Bearer downstream"},
+ body={"model": "gpt-4o"},
+ provider="openai",
+ model="gpt-4o",
+ request_id="req-test",
+ original_tokens=0,
+ optimized_tokens=0,
+ tokens_saved=0,
+ transforms_applied=[],
+ tags={},
+ optimization_latency=0.0,
+ )
+
+ assert seen["url"] == "https://api.githubcopilot.com/v1/responses"
+ assert seen["request"]["headers"] == {"Authorization": "Bearer upstream-token"}
+ assert response.status_code == 200