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(wrap): preserve custom Codex provider base_url during proxy injection (#1894)
Rod Boev372d6c8cd4be
diff --git a/headroom/cli/wrap.py b/headroom/cli/wrap.pyindex 59194da31..fd89f0c75 100644--- a/headroom/cli/wrap.py+++ b/headroom/cli/wrap.py@@ -1757,7 +1757,97 @@ def _apply_project_header_env(env: dict[str, str]) -> None:env["ANTHROPIC_CUSTOM_HEADERS"] = header_line-def _inject_codex_provider_config(port: int) -> None:+# Codex's own built-in providers plus Headroom's injected one — never treated+# as a "custom upstream to preserve" by _detect_custom_codex_upstream_base_url.+_CODEX_BUILTIN_PROVIDER_NAMES = frozenset({"openai", "anthropic", "azure", "headroom"})++# Header carrying a preserved custom upstream (freemodel.dev, LiteLLM, vLLM,+# ...) so the proxy forwards to it instead of the hardcoded OpenAI default.+# Codex's env_http_headers only accepts an env-var *name* per header (not a+# literal value), so the detected URL is exported into this env var by the+# `wrap codex` launch path — see its use in `codex()` below.+_UPSTREAM_BASE_URL_HEADER_NAME = "X-Headroom-Base-Url"+_UPSTREAM_BASE_URL_ENV_VAR = "HEADROOM_CODEX_UPSTREAM_BASE_URL"+++def _codex_custom_provider_base_urls(content: str) -> dict[str, str]:+ """Return ``{provider_name: base_url}`` for user-declared custom providers.++ Excludes Codex's built-ins (``openai``/``anthropic``/``azure``) and+ Headroom's own ``headroom`` table. A table with no ``base_url`` line, or+ one already pointing at Headroom's own localhost proxy (a leftover from a+ prior wrap this pass hasn't stripped yet), is excluded too.+ """+ import re++ tables: dict[str, str] = {}+ for match in re.finditer(+ r"(?ms)^[ \t]*\[model_providers\.(?P<name>[^\]\s]+)\][ \t]*\n"+ r"(?P<body>.*?)(?=^[ \t]*\[|\Z)",+ content,+ ):+ name = match.group("name")+ if name in _CODEX_BUILTIN_PROVIDER_NAMES:+ continue+ base_match = re.search(+ r'(?m)^[ \t]*base_url[ \t]*=[ \t]*"(?P<url>[^"\n]*)"', match.group("body")+ )+ if not base_match:+ continue+ url = base_match.group("url").strip().rstrip("/")+ if not url or url.startswith(("http://127.0.0.1", "http://localhost")):+ continue+ tables[name] = url+ return tables+++def _detect_custom_codex_upstream_base_url(content: str) -> str | None:+ """Return a user-configured custom provider ``base_url`` to preserve, if any.++ Codex lets users declare OpenAI-compatible gateways (LiteLLM, vLLM,+ freemodel.dev, ...) under ``[model_providers.<name>]`` and select one via+ the top-level ``model_provider`` key. Before this, ``headroom wrap codex``+ unconditionally pointed the proxy's upstream OpenAI route at+ ``api.openai.com``, silently discarding that selection — the user's+ gateway API key then gets sent to OpenAI, which rejects it (#1614).++ If the top-level ``model_provider`` names one of the detected custom+ tables, that selection wins unambiguously. This also covers the+ already-wrapped case: once wrap has run once, the top-level key reads+ ``model_provider = "headroom" # was: <original>`` (see+ ``_redirect_existing_top_level_keys``), so the original selection is+ recovered from that trailing comment on re-wrap / port changes.++ Falls back to the sole candidate when exactly one custom table exists+ and there is no (or no matching) top-level selection — the common case+ from the bug report, where the table is declared but selection happens+ via ``--profile`` rather than a static top-level key. Returns ``None``+ when there are multiple, un-selected candidates (ambiguous — guessing+ wrong is worse than the prior default behavior) or none at all.+ """+ import re++ candidates = _codex_custom_provider_base_urls(content)+ if not candidates:+ return None++ selected = re.search(+ r'(?m)^[ \t]*model_provider[ \t]*=[ \t]*"(?P<name>[^"\n]*)"'+ r"(?:[ \t]*#[ \t]*was:[ \t]*(?P<was>[^\r\n]*))?",+ content,+ )+ if selected:+ was = (selected.group("was") or "").strip()+ chosen = was or selected.group("name")+ if chosen in candidates:+ return candidates[chosen]++ if len(candidates) == 1:+ return next(iter(candidates.values()))+ return None+++def _inject_codex_provider_config(port: int) -> str | None:"""Inject a Headroom model provider into Codex's config.toml.Two keys need to be in effect for the proxy to route all traffic:@@ -1784,10 +1874,32 @@ def _inject_codex_provider_config(port: int) -> None:Before the first injection, the pre-wrap file is snapshotted to``config.toml.headroom-backup`` so ``headroom unwrap codex``can restore it byte-for-byte.++ Returns the custom upstream ``base_url`` preserved from an existing+ ``[model_providers.*]`` table, if one was detected (#1614); ``None``+ otherwise. Callers that go on to launch Codex should export this value+ into ``HEADROOM_CODEX_UPSTREAM_BASE_URL`` (the injected+ ``env_http_headers`` entry maps it to the ``X-Headroom-Base-Url`` header,+ which the proxy's OpenAI HTTP handlers honor over the hardcoded+ ``api.openai.com`` default) — see its use in ``codex()`` below."""config_file, backup_file = _codex_config_paths()config_dir = config_file.parent+ # Detect an existing custom OpenAI-compatible provider BEFORE building the+ # injected block below, so it can be preserved as the upstream the proxy+ # forwards to instead of silently rerouting to api.openai.com (#1614).+ # Best-effort: any read/parse failure just means nothing is preserved,+ # matching prior behavior.+ custom_upstream_base_url: str | None = None+ if config_file.exists():+ try:+ custom_upstream_base_url = _detect_custom_codex_upstream_base_url(+ _read_text(config_file)+ )+ except OSError:+ custom_upstream_base_url = None+# The injected content is split into two self-contained, marker-delimited# blocks: a top-level key block (at the start of the file, because bare# TOML keys must precede any [section]) and a provider-table block (at@@ -1803,6 +1915,15 @@ def _inject_codex_provider_config(port: int) -> None:requires_openai_auth = ("requires_openai_auth = true\n" if codex_uses_chatgpt_auth(config_dir / "auth.json") else "")+ # Per-project savings: Codex sends the X-Headroom-Project header only+ # when the mapped env var (HEADROOM_PROJECT, set by `headroom wrap+ # codex`) exists at Codex runtime. When a custom upstream was detected,+ # add a second entry so Codex also sends X-Headroom-Base-Url — the proxy+ # forwards there instead of api.openai.com (#1614).+ env_http_headers_map = {_PROJECT_HEADER_NAME: "HEADROOM_PROJECT"}+ if custom_upstream_base_url:+ env_http_headers_map[_UPSTREAM_BASE_URL_HEADER_NAME] = _UPSTREAM_BASE_URL_ENV_VAR+ env_http_headers_toml = ", ".join(f'"{k}" = "{v}"' for k, v in env_http_headers_map.items())provider_section = (f"{_CODEX_TOP_LEVEL_MARKER}\n""[model_providers.headroom]\n"@@ -1810,11 +1931,9 @@ def _inject_codex_provider_config(port: int) -> None:f'base_url = "http://127.0.0.1:{port}/v1"\n'f"supports_websockets = true\n"f"{requires_openai_auth}"- # Per-project savings: Codex sends the header only when the mapped- # env var (HEADROOM_PROJECT, set by `headroom wrap codex`) exists at- # Codex runtime. Inline table keeps the key inside this section so+ # Inline table keeps the key inside this section so# _strip_codex_headroom_blocks removes it with the rest of the block.- f'env_http_headers = {{ "{_PROJECT_HEADER_NAME}" = "HEADROOM_PROJECT" }}\n'+ f"env_http_headers = {{ {env_http_headers_toml} }}\n"f"{_CODEX_END_MARKER}\n")@@ -1893,11 +2012,20 @@ def _inject_codex_provider_config(port: int) -> None:_write_text(config_file, content)click.echo(f" Codex config: injected Headroom provider (WS + HTTP) into {config_file}")+ if custom_upstream_base_url:+ click.echo(+ f" Codex config: preserving existing custom upstream "+ f"{custom_upstream_base_url} (from a pre-existing [model_providers.*] "+ "base_url)"+ )# Pull existing native threads into the headroom-provider menu so Codex's# history list stays whole once it routes through Headroom. Best-effort.retag_to_headroom(_codex_home_dir())except Exception as e:click.echo(f" Warning: could not update Codex config: {e}")+ return None++ return custom_upstream_base_urldef _restore_codex_provider_config() -> tuple[str, Path]:@@ -4701,7 +4829,14 @@ def codex(# transport unless a custom provider declares supports_websockets = true.# NOTE: this must run BEFORE _inject_memory_mcp_config because it rewrites# the config file. Re-inject MCP config after if memory is enabled.- _inject_codex_provider_config(actual_port)+ _codex_custom_upstream = _inject_codex_provider_config(actual_port)+ if _codex_custom_upstream and _UPSTREAM_BASE_URL_ENV_VAR not in env:+ # Carries the preserved custom base_url (#1614) to the injected+ # env_http_headers entry, which maps it to X-Headroom-Base-Url —+ # the proxy's OpenAI HTTP handlers forward there instead of the+ # hardcoded api.openai.com default. A user-set value wins.+ env[_UPSTREAM_BASE_URL_ENV_VAR] = _codex_custom_upstream+ env_vars_display.append(f"{_UPSTREAM_BASE_URL_ENV_VAR}={_codex_custom_upstream}")if memory:_inject_memory_mcp_config(os.environ.get("USER", os.environ.get("USERNAME", "default")))diff --git a/tests/test_cli/test_wrap_codex.py b/tests/test_cli/test_wrap_codex.pyindex 7a3122a55..2d004e6d7 100644--- a/tests/test_cli/test_wrap_codex.py+++ b/tests/test_cli/test_wrap_codex.py@@ -673,6 +673,157 @@ class TestSubscriptionRouting:assert "env_key" not in content+# ---------------------------------------------------------------------------+# Custom upstream preservation (#1614): wrap must not silently reroute a+# pre-existing custom [model_providers.*] base_url to api.openai.com.+# ---------------------------------------------------------------------------+++class TestDetectCustomCodexUpstreamBaseUrl:+ """Unit tests for the detection helper used by ``_inject_codex_provider_config``."""++ def test_no_config_returns_none(self) -> None:+ assert wrap_mod._detect_custom_codex_upstream_base_url("") is None++ def test_no_custom_provider_returns_none(self) -> None:+ content = (+ 'model_provider = "openai"\n\n'+ "[model_providers.openai]\n"+ 'base_url = "https://api.openai.com/v1"\n'+ )+ assert wrap_mod._detect_custom_codex_upstream_base_url(content) is None++ def test_sole_candidate_used_without_explicit_selection(self) -> None:+ """Matches the #1614 repro: a custom table with no static top-level pin."""+ content = (+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n'+ 'wire_api = "responses"\n'+ )+ assert (+ wrap_mod._detect_custom_codex_upstream_base_url(content) == "https://api.freemodel.dev"+ )++ def test_explicit_top_level_selection_wins(self) -> None:+ content = (+ 'model_provider = "freemodel"\n\n'+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n\n'+ "[model_providers.other]\n"+ 'base_url = "https://api.other.example"\n'+ )+ assert (+ wrap_mod._detect_custom_codex_upstream_base_url(content) == "https://api.freemodel.dev"+ )++ def test_was_comment_recovers_selection_on_rewrap(self) -> None:+ """After a prior wrap, model_provider reads 'headroom # was: freemodel'."""+ content = (+ 'model_provider = "headroom" # was: freemodel\n\n'+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n'+ )+ assert (+ wrap_mod._detect_custom_codex_upstream_base_url(content) == "https://api.freemodel.dev"+ )++ def test_ambiguous_multiple_candidates_returns_none(self) -> None:+ content = (+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n\n'+ "[model_providers.other]\n"+ 'base_url = "https://api.other.example"\n'+ )+ assert wrap_mod._detect_custom_codex_upstream_base_url(content) is None++ def test_builtin_provider_tables_excluded(self) -> None:+ content = (+ 'model_provider = "openai"\n\n'+ "[model_providers.openai]\n"+ 'base_url = "https://api.openai.com/v1"\n\n'+ "[model_providers.anthropic]\n"+ 'base_url = "https://api.anthropic.com/v1"\n'+ )+ assert wrap_mod._detect_custom_codex_upstream_base_url(content) is None++ def test_own_headroom_table_excluded(self) -> None:+ content = (+ 'model_provider = "headroom"\n\n'+ "[model_providers.headroom]\n"+ 'base_url = "http://127.0.0.1:8787/v1"\n'+ )+ assert wrap_mod._detect_custom_codex_upstream_base_url(content) is None+++class TestInjectPreservesCustomUpstreamBaseUrl:+ """``_inject_codex_provider_config`` must preserve a pre-existing custom+ provider's ``base_url`` instead of silently rerouting to api.openai.com."""++ def test_inject_returns_and_carries_custom_base_url(+ self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path+ ) -> None:+ _set_test_home(monkeypatch, tmp_path)+ config_dir = tmp_path / ".codex"+ config_dir.mkdir()+ config_file = config_dir / "config.toml"+ config_file.write_text(+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n'+ 'wire_api = "responses"\n',+ encoding="utf-8",+ )++ result = wrap_mod._inject_codex_provider_config(8787)++ assert result == "https://api.freemodel.dev"+ content = config_file.read_text(encoding="utf-8")+ parsed = tomllib.loads(content)+ headers = parsed["model_providers"]["headroom"]["env_http_headers"]+ assert (+ headers[wrap_mod._UPSTREAM_BASE_URL_HEADER_NAME] == wrap_mod._UPSTREAM_BASE_URL_ENV_VAR+ )+ # The user's own table is left untouched — only headroom's own is managed.+ assert parsed["model_providers"]["freemodel"]["base_url"] == "https://api.freemodel.dev"++ def test_inject_without_custom_provider_returns_none(+ self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path+ ) -> None:+ _set_test_home(monkeypatch, tmp_path)++ result = wrap_mod._inject_codex_provider_config(8787)++ assert result is None+ content = (tmp_path / ".codex" / "config.toml").read_text(encoding="utf-8")+ assert wrap_mod._UPSTREAM_BASE_URL_HEADER_NAME not in content++ def test_preserved_upstream_survives_rewrap_and_port_change(+ self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path+ ) -> None:+ _set_test_home(monkeypatch, tmp_path)+ config_dir = tmp_path / ".codex"+ config_dir.mkdir()+ config_file = config_dir / "config.toml"+ config_file.write_text(+ 'model_provider = "freemodel"\n\n'+ "[model_providers.freemodel]\n"+ 'base_url = "https://api.freemodel.dev"\n',+ encoding="utf-8",+ )++ first = wrap_mod._inject_codex_provider_config(8787)+ second = wrap_mod._inject_codex_provider_config(9999) # port change / re-wrap++ assert first == "https://api.freemodel.dev"+ assert second == "https://api.freemodel.dev"+ content = config_file.read_text(encoding="utf-8")+ parsed = tomllib.loads(content)+ assert parsed["model_providers"]["headroom"]["base_url"] == "http://127.0.0.1:9999/v1"+ headers = parsed["model_providers"]["headroom"]["env_http_headers"]+ assert (+ headers[wrap_mod._UPSTREAM_BASE_URL_HEADER_NAME] == wrap_mod._UPSTREAM_BASE_URL_ENV_VAR+ )++class TestInjectAvoidsDuplicateTopLevelKeys:"""Wrap must not produce a TOML-validity-breaking duplicate-key error.