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(kimi): route managed Kimi Code through the proxy (#3223)

Rod Boev701e4616d92d
diff --git a/headroom/cli/wrap.py b/headroom/cli/wrap.py
index 1c7176e2c..2a6c7d936 100644
--- a/headroom/cli/wrap.py
+++ b/headroom/cli/wrap.py
@@ -4393,7 +4393,7 @@ def _launch_tool(
port_holder[0] = actual_port
_push_runtime_env(actual_port, no_proxy)
- # If port fell back, update env URLs to point at the actual port
+ # If port fell back, update environment URLs to point at the actual port.
if actual_port != port:
for k, v in dict(env).items():
env[k] = v.replace(f"127.0.0.1:{port}", f"127.0.0.1:{actual_port}")
@@ -6302,9 +6302,10 @@ def kimi(
"""Launch Kimi CLI through Headroom proxy.
\b
- Sets KIMI_BASE_URL to route Kimi's OpenAI-compatible /chat/completions
- traffic through Headroom. Kimi's own OAuth bearer is forwarded upstream,
- so no extra login is required — run `kimi` once to authenticate first.
+ Sets KIMI_CODE_BASE_URL for managed Kimi Code and KIMI_BASE_URL for legacy
+ kimi-cli to route OpenAI-compatible /chat/completions traffic through
+ Headroom. Managed Kimi Code needs one `/login` after the proxy URL changes
+ so its OAuth slot matches that URL; legacy kimi-cli keeps its existing login.
\b
Examples:
@@ -6322,9 +6323,20 @@ def kimi(
click.echo("Install Kimi CLI: https://github.com/MoonshotAI/kimi-cli")
raise SystemExit(1)
- env, env_vars_display = _build_kimi_launch_env(
- port, os.environ, project=_project_name_from_cwd()
- )
+ project = _project_name_from_cwd()
+ env, env_vars_display = _build_kimi_launch_env(port, os.environ, project=project)
+
+ def configure_kimi_launch(
+ actual_port: int,
+ current_args: tuple,
+ current_env: dict[str, str],
+ current_display: list[str],
+ ) -> tuple[tuple, dict[str, str], list[str]]:
+ del current_display
+ updated_env, updated_display = _build_kimi_launch_env(
+ actual_port, current_env, project=project
+ )
+ return current_args, updated_env, updated_display
_launch_tool(
binary=kimi_bin,
@@ -6339,6 +6351,7 @@ def kimi(
agent_type="kimi",
code_graph=code_graph,
openai_api_url=kimi_api_url,
+ configure_launch=configure_kimi_launch,
)
diff --git a/headroom/providers/kimi/runtime.py b/headroom/providers/kimi/runtime.py
index fa2a30678..1d89e7a8f 100644
--- a/headroom/providers/kimi/runtime.py
+++ b/headroom/providers/kimi/runtime.py
@@ -18,11 +18,13 @@ def build_launch_env(
Kimi CLI (``kimi`` / ``kimi-cli``) talks to its managed coding endpoint with
an OpenAI-compatible ``/chat/completions`` client (``kosong``'s ``Kimi``
- provider wraps ``AsyncOpenAI``). Its base URL is overridable via the
- ``KIMI_BASE_URL`` environment variable, so we point it at the local proxy.
+ provider wraps ``AsyncOpenAI``). Its base URL is overridable via
+ ``KIMI_CODE_BASE_URL`` for the managed client and ``KIMI_BASE_URL`` for
+ legacy clients, so both point at the local proxy.
The proxy forwards the request — including Kimi's own OAuth ``Authorization``
- bearer (passthrough auth mode) — to the real upstream configured by
- ``--openai-api-url`` (``https://api.kimi.com/coding/v1``).
+ bearer after the managed client completes its proxy-scoped ``/login`` — to
+ the real upstream configured by ``--openai-api-url``
+ (``https://api.kimi.com/coding/v1``).
``project`` (the wrap launch directory) is encoded as a ``/p/<name>``
base-URL prefix because the Kimi base-URL override cannot carry custom
@@ -30,5 +32,9 @@ def build_launch_env(
"""
env = dict(environ or os.environ)
base_url = with_project_prefix(codex_proxy_base_url(port), project)
+ env["KIMI_CODE_BASE_URL"] = base_url
env["KIMI_BASE_URL"] = base_url
- return env, [f"KIMI_BASE_URL={base_url}"]
+ return env, [
+ f"KIMI_CODE_BASE_URL={base_url}",
+ f"KIMI_BASE_URL={base_url}",
+ ]
diff --git a/tests/test_cli/test_wrap_kimi.py b/tests/test_cli/test_wrap_kimi.py
index 01f94b45c..05ce3cc61 100644
--- a/tests/test_cli/test_wrap_kimi.py
+++ b/tests/test_cli/test_wrap_kimi.py
@@ -2,6 +2,8 @@
from __future__ import annotations
+import os
+import sys
from pathlib import Path
from typing import Any
from unittest.mock import patch
@@ -18,6 +20,68 @@ def runner() -> CliRunner:
return CliRunner()
+def test_managed_route_reproduction(
+ runner: CliRunner,
+ capfd: pytest.CaptureFixture[str],
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path: Path,
+) -> None:
+ """The production launcher passes the managed endpoint to an exact-contract child."""
+ direct = "https://api.kimi.com/coding/v1"
+ monkeypatch.setenv("KIMI_BASE_URL", direct)
+ monkeypatch.setenv("KIMI_TEST_UNRELATED", "preserved")
+ monkeypatch.setattr(wrap_mod, "_project_name_from_cwd", lambda: "repo")
+ captured: dict[str, Any] = {}
+
+ def fake_launch_tool(**kwargs: Any) -> None: # noqa: ANN003
+ captured.update(kwargs)
+
+ with patch.object(wrap_mod.shutil, "which", return_value=sys.executable):
+ with patch.object(wrap_mod, "_launch_tool", side_effect=fake_launch_tool):
+ result = runner.invoke(main, ["wrap", "kimi", "--port", "8787"])
+
+ assert result.exit_code == 0, result.output
+ env = captured["env"]
+ display = captured["env_vars_display"]
+ configure_launch = captured["configure_launch"]
+ child_result = tmp_path / "kimi-child.txt"
+ child = (
+ "import os, sys; from pathlib import Path; Path(r'"
+ f"{child_result}"
+ "').write_text('CHILD|' + os.environ['KIMI_CODE_BASE_URL'] + '|' + "
+ "os.environ['KIMI_BASE_URL'] + '|' + os.environ['KIMI_TEST_UNRELATED'] + '|' + sys.argv[1])"
+ )
+
+ with (
+ patch.object(wrap_mod, "_make_cleanup", return_value=lambda: None),
+ patch.object(wrap_mod.signal, "signal"),
+ patch.object(wrap_mod, "_register_proxy_client"),
+ patch.object(wrap_mod, "_ensure_proxy", return_value=(None, 9001)),
+ patch.object(wrap_mod, "_unregister_proxy_client"),
+ patch.object(wrap_mod, "_push_runtime_env"),
+ patch.object(wrap_mod, "_configure_quiet_cli_env", return_value=[]),
+ ):
+ with pytest.raises(SystemExit) as raised:
+ wrap_mod._launch_tool(
+ binary=os.fspath(Path(sys.executable)),
+ args=("-c", child, "child-arg"),
+ env=env,
+ port=8787,
+ no_proxy=False,
+ tool_label="KIMI",
+ env_vars_display=display,
+ configure_launch=configure_launch,
+ )
+
+ assert raised.value.code == 0
+ output = result.output + capfd.readouterr().out
+ expected = "http://127.0.0.1:9001/p/repo/v1"
+ assert f"KIMI_CODE_BASE_URL={expected}" in output
+ assert f"KIMI_BASE_URL={expected}" in output
+ assert child_result.read_text() == f"CHILD|{expected}|{expected}|preserved|child-arg"
+ assert direct not in output
+
+
def test_wrap_kimi_launch(
runner: CliRunner,
tmp_path: Path,
@@ -46,15 +110,17 @@ def test_wrap_kimi_launch(
assert captured["agent_type"] == "kimi"
assert captured["args"] == ("-m", "kimi-for-coding")
assert captured["openai_api_url"] == "https://api.kimi.com/coding/v1"
+ assert callable(captured["configure_launch"])
+ assert env["KIMI_CODE_BASE_URL"] == "http://127.0.0.1:9000/v1"
assert env["KIMI_BASE_URL"] == "http://127.0.0.1:9000/v1"
-def test_wrap_kimi_with_project_name(
+def test_project_name(
runner: CliRunner,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
- """Project name is encoded in KIMI_BASE_URL when run from a project directory."""
+ """Project name is encoded in both Kimi endpoint variables."""
project_dir = tmp_path / "my-project"
project_dir.mkdir()
monkeypatch.chdir(project_dir)
@@ -71,6 +137,7 @@ def test_wrap_kimi_with_project_name(
assert result.exit_code == 0, result.output
env = captured["env"]
+ assert env["KIMI_CODE_BASE_URL"] == "http://127.0.0.1:7000/p/my-project/v1"
assert env["KIMI_BASE_URL"] == "http://127.0.0.1:7000/p/my-project/v1"
@@ -117,12 +184,12 @@ def test_wrap_kimi_not_found(
assert "https://github.com/MoonshotAI/kimi-cli" in result.output
-def test_wrap_kimi_custom_port(
+def test_port_fallback(
runner: CliRunner,
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
- """Custom --port is passed to _launch_tool and appears in KIMI_BASE_URL."""
+ """Custom --port is passed to _launch_tool and appears in both URLs."""
monkeypatch.chdir(tmp_path)
monkeypatch.delenv("HEADROOM_CONTEXT_TOOL", raising=False)
@@ -138,9 +205,48 @@ def test_wrap_kimi_custom_port(
assert result.exit_code == 0, result.output
assert captured["port"] == 9999
+ assert captured["env"]["KIMI_CODE_BASE_URL"] == "http://127.0.0.1:9999/v1"
assert captured["env"]["KIMI_BASE_URL"] == "http://127.0.0.1:9999/v1"
+def test_non_kimi_fallback_display_is_unchanged(
+ capfd: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+ env = {**os.environ, "OTHER_BASE_URL": "http://127.0.0.1:8787/v1"}
+ display = ["OTHER_BASE_URL=http://127.0.0.1:8787/v1"]
+ child_result = tmp_path / "other-child.txt"
+ child = (
+ "import os; from pathlib import Path; Path(r'"
+ f"{child_result}"
+ "').write_text('CHILD|' + os.environ['OTHER_BASE_URL'])"
+ )
+
+ with (
+ patch.object(wrap_mod, "_make_cleanup", return_value=lambda: None),
+ patch.object(wrap_mod.signal, "signal"),
+ patch.object(wrap_mod, "_register_proxy_client"),
+ patch.object(wrap_mod, "_ensure_proxy", return_value=(None, 9001)),
+ patch.object(wrap_mod, "_unregister_proxy_client"),
+ patch.object(wrap_mod, "_push_runtime_env"),
+ patch.object(wrap_mod, "_configure_quiet_cli_env", return_value=[]),
+ ):
+ with pytest.raises(SystemExit) as raised:
+ wrap_mod._launch_tool(
+ binary=os.fspath(Path(sys.executable)),
+ args=("-c", child),
+ env=env,
+ port=8787,
+ no_proxy=False,
+ tool_label="OTHER",
+ env_vars_display=display,
+ )
+
+ assert raised.value.code == 0
+ output = capfd.readouterr().out
+ assert "OTHER_BASE_URL=http://127.0.0.1:8787/v1" in output
+ assert child_result.read_text() == "CHILD|http://127.0.0.1:9001/v1"
+
+
def test_wrap_kimi_custom_api_url(
runner: CliRunner,
tmp_path: Path,