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.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
fix(codex): detect ChatGPT auth from id_token claims so wrap/init emit requires_openai_auth (#3212)
Tejas Chopra2f81fa5931dd
diff --git a/headroom/cli/doctor.py b/headroom/cli/doctor.pyindex 03d0ce58e..4187bd1a2 100644--- a/headroom/cli/doctor.py+++ b/headroom/cli/doctor.py@@ -433,9 +433,39 @@ def check_codex_routing(config_path: Path, port: int) -> CheckResult:summary=f"routed to port {match.group(1)}, but doctor probed port {port}",hint=f"re-run with: headroom doctor --port {match.group(1)}",)+ # Routed, but Codex may still attach no credentials. A ChatGPT-OAuth user+ # needs `requires_openai_auth = true` in the provider block or Codex sends+ # no Authorization header at all and every request 401s with "Missing+ # bearer" (#3206). That failure is invisible from here -- the proxy is up,+ # the block is present -- so this check is the only place it can surface.+ if _codex_block_missing_openai_auth(text, config_path):+ return CheckResult(+ name=name,+ status=WARN,+ summary="routed, but Codex will send no Authorization (missing requires_openai_auth)",+ hint="re-run: headroom wrap codex (or headroom init codex) to rewrite the block",+ )return CheckResult(name=name, status=PASS, summary=f"routed ({config_path})")+def _codex_block_missing_openai_auth(text: str, config_path: Path) -> bool:+ """ChatGPT-OAuth Codex routed without ``requires_openai_auth`` (#3206)."""+ start = text.find("[model_providers.headroom]")+ if start == -1:+ return False+ rest = text[start + len("[model_providers.headroom]") :]+ end = rest.find("\n[")+ block = rest if end == -1 else rest[:end]+ if "requires_openai_auth" in block:+ return False+ try:+ from headroom.providers.codex.install import codex_uses_chatgpt_auth++ return codex_uses_chatgpt_auth(config_path.parent / "auth.json")+ except Exception: # pragma: no cover - never let a doctor check crash+ return False++def check_shell_env(environ: Mapping[str, str], port: int) -> CheckResult:"""Is the *current shell* pointed at the proxy for ad-hoc runs?"""name = "shell env"diff --git a/headroom/providers/codex/install.py b/headroom/providers/codex/install.pyindex b5da67833..234ef70fc 100644--- a/headroom/providers/codex/install.py+++ b/headroom/providers/codex/install.py@@ -2,11 +2,13 @@from __future__ import annotations+import base64import jsonimport osimport reimport subprocessfrom pathlib import Path+from typing import Anytry:import tomllib@@ -99,10 +101,47 @@ def codex_uses_chatgpt_auth(auth_path: Path) -> bool:tokens = data.get("tokens")if isinstance(tokens, dict):account_id = tokens.get("account_id")- return isinstance(account_id, str) and bool(account_id.strip())+ if isinstance(account_id, str) and account_id.strip():+ return True+ return _id_token_carries_chatgpt_account(tokens.get("id_token"))return False+def _id_token_carries_chatgpt_account(raw: Any) -> bool:+ """Whether an ``id_token`` carries the ChatGPT account claim (#3206).++ Newer Codex releases can write an ``auth.json`` with neither ``auth_mode``+ nor a top-level ``tokens.account_id``; the account identity lives only in+ the ``id_token`` claims. Those configs then read as API-key mode, so+ ``requires_openai_auth`` is omitted, Codex attaches no Authorization+ header, and every request 401s with "Missing bearer".++ The payload is decoded, not verified. This is a local config file the user+ already owns, and the result only decides which key we write into their own+ ``config.toml`` -- nothing is authenticated or authorised on the strength+ of it. An API-key user has no ChatGPT id_token, so this cannot resurrect+ the forced-OAuth-login regression in #406.+ """+ if not isinstance(raw, str):+ return False+ parts = raw.split(".")+ if len(parts) != 3:+ return False+ payload = parts[1]+ payload += "=" * (-len(payload) % 4)+ try:+ claims = json.loads(base64.urlsafe_b64decode(payload.encode("ascii")))+ except Exception:+ return False+ if not isinstance(claims, dict):+ return False+ auth_claim = claims.get("https://api.openai.com/auth")+ if not isinstance(auth_claim, dict):+ return False+ account_id = auth_claim.get("chatgpt_account_id")+ return isinstance(account_id, str) and bool(account_id.strip())++def build_provider_section(*,port: int,diff --git a/tests/test_cli_doctor.py b/tests/test_cli_doctor.pyindex 7f68cd4e6..30adbeb51 100644--- a/tests/test_cli_doctor.py+++ b/tests/test_cli_doctor.py@@ -488,6 +488,56 @@ class TestCodexRouting:path.write_bytes(b"\xff\xfe garbage \x00")assert check_codex_routing(path, 8787).status == WARN+ # -- requires_openai_auth (#3206) ------------------------------------+ # Codex attaches no Authorization header to a custom provider unless the+ # block carries requires_openai_auth. A ChatGPT-OAuth user then 401s on+ # every request with "Missing bearer" while doctor reported green -- the+ # reason one report went 15h before anyone could see the cause.++ @staticmethod+ def _routed(tmp_path, *, requires_auth: bool):+ path = tmp_path / "config.toml"+ block = (+ "[model_providers.headroom]\n"+ 'base_url = "http://127.0.0.1:8787/v1"\n'+ "supports_websockets = true\n"+ )+ if requires_auth:+ block += "requires_openai_auth = true\n"+ path.write_text(block, encoding="utf-8")+ return path++ @staticmethod+ def _chatgpt_auth(tmp_path):+ (tmp_path / "auth.json").write_text('{"auth_mode": "chatgpt"}', encoding="utf-8")++ def test_chatgpt_auth_without_requires_openai_auth_warns(self, tmp_path):+ path = self._routed(tmp_path, requires_auth=False)+ self._chatgpt_auth(tmp_path)++ result = check_codex_routing(path, 8787)++ assert result.status == WARN+ assert "Authorization" in result.summary++ def test_chatgpt_auth_with_requires_openai_auth_passes(self, tmp_path):+ path = self._routed(tmp_path, requires_auth=True)+ self._chatgpt_auth(tmp_path)++ assert check_codex_routing(path, 8787).status == PASS++ def test_api_key_user_without_requires_openai_auth_still_passes(self, tmp_path):+ """API-key users must not be nagged -- the flag would break them (#406)."""+ path = self._routed(tmp_path, requires_auth=False)+ (tmp_path / "auth.json").write_text('{"OPENAI_API_KEY": "sk-test"}', encoding="utf-8")++ assert check_codex_routing(path, 8787).status == PASS++ def test_no_auth_json_does_not_warn(self, tmp_path):+ path = self._routed(tmp_path, requires_auth=False)++ assert check_codex_routing(path, 8787).status == PASS+class TestShellEnv:def test_unset_warns(self):diff --git a/tests/test_provider_codex_install.py b/tests/test_provider_codex_install.pyindex 05283762f..30e75bb27 100644--- a/tests/test_provider_codex_install.py+++ b/tests/test_provider_codex_install.py@@ -85,3 +85,104 @@ def test_codex_provider_section_supports_custom_markers() -> None:assert section.endswith("# --- end ---\n")assert 'base_url = "http://127.0.0.1:9100/v1"' in sectionassert 'env_key = "OPENAI_API_KEY"' not in section+++# ---------------------------------------------------------------------------+# ChatGPT-auth detection from the id_token claims (#3206)+#+# Newer Codex releases can write an auth.json with neither `auth_mode` nor a+# top-level `tokens.account_id`; the account identity lives only in the+# id_token claims. Those configs read as API-key mode, so requires_openai_auth+# is omitted, Codex attaches no Authorization header, and every request 401s+# with "Missing bearer" -- silently, with doctor reporting green.+# ---------------------------------------------------------------------------+++def _unsigned_jwt(claims: dict[str, object]) -> str:+ import base64+ import json as _json++ def seg(raw: bytes) -> str:+ return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")++ header = seg(b'{"alg":"none"}')+ payload = seg(_json.dumps(claims).encode("utf-8"))+ return ".".join((header, payload, "sig"))+++_CHATGPT_CLAIMS: dict[str, object] = {+ "https://api.openai.com/auth": {+ "chatgpt_account_id": "1a155430-5551-47f4-9c7b-aeab7983f24a",+ "chatgpt_plan_type": "pro",+ }+}+++def _write_auth(tmp_path, document: dict[str, object]): # noqa: ANN001, ANN202+ import json as _json++ path = tmp_path / "auth.json"+ path.write_text(_json.dumps(document), encoding="utf-8")+ return path+++def test_chatgpt_auth_detected_from_id_token_claims_alone(tmp_path) -> None:+ """The #3206 shape: no auth_mode, no tokens.account_id, only the JWT."""+ path = _write_auth(tmp_path, {"tokens": {"id_token": _unsigned_jwt(_CHATGPT_CLAIMS)}})++ assert codex_uses_chatgpt_auth(path) is True+++def test_explicit_api_key_mode_still_wins_over_a_chatgpt_id_token(tmp_path) -> None:+ """Guards the #406 regression: API-key users must not get forced OAuth."""+ path = _write_auth(+ tmp_path,+ {"auth_mode": "apikey", "tokens": {"id_token": _unsigned_jwt(_CHATGPT_CLAIMS)}},+ )++ assert codex_uses_chatgpt_auth(path) is False+++def test_api_key_config_without_tokens_is_not_chatgpt(tmp_path) -> None:+ path = _write_auth(tmp_path, {"OPENAI_API_KEY": "sk-test"})++ assert codex_uses_chatgpt_auth(path) is False+++def test_id_token_without_the_chatgpt_claim_is_not_chatgpt(tmp_path) -> None:+ path = _write_auth(tmp_path, {"tokens": {"id_token": _unsigned_jwt({"sub": "user"})}})++ assert codex_uses_chatgpt_auth(path) is False+++def test_malformed_id_token_is_not_chatgpt(tmp_path) -> None:+ for bogus in ("not-a-jwt", "a.b", "a.!!!not-base64!!!.c", ""):+ path = _write_auth(tmp_path, {"tokens": {"id_token": bogus}})+ assert codex_uses_chatgpt_auth(path) is False, bogus+++def test_blank_chatgpt_account_id_is_not_chatgpt(tmp_path) -> None:+ claims = {"https://api.openai.com/auth": {"chatgpt_account_id": " "}}+ path = _write_auth(tmp_path, {"tokens": {"id_token": _unsigned_jwt(claims)}})++ assert codex_uses_chatgpt_auth(path) is False+++def test_legacy_account_id_still_detected(tmp_path) -> None:+ path = _write_auth(tmp_path, {"tokens": {"account_id": "acct-123"}})++ assert codex_uses_chatgpt_auth(path) is True+++def test_provider_block_emits_requires_openai_auth_for_the_new_shape(tmp_path) -> None:+ """End of the chain: the JWT-only shape must produce the key Codex needs."""+ path = _write_auth(tmp_path, {"tokens": {"id_token": _unsigned_jwt(_CHATGPT_CLAIMS)}})++ block = build_provider_section(+ port=8787,+ name="Headroom",+ include_markers=False,+ requires_openai_auth=codex_uses_chatgpt_auth(path),+ )++ assert "requires_openai_auth = true" in block