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(ccr): make --no-ccr disable server-side response handling too (#3101)

Tejas Chopra131b119c053e
diff --git a/headroom/cli/proxy.py b/headroom/cli/proxy.py
index bbdba0fed..e802bd0d6 100644
--- a/headroom/cli/proxy.py
+++ b/headroom/cli/proxy.py
@@ -1330,12 +1330,22 @@ def proxy(
protect_recent=_get_env_int_optional("HEADROOM_PROTECT_RECENT"),
protect_analysis_context=_get_env_bool_optional("HEADROOM_PROTECT_ANALYSIS_CONTEXT"),
accuracy_guard=os.environ.get("HEADROOM_ACCURACY_GUARD") or None,
- # CCR opt-out: --no-ccr disables both halves at once (markers in content
- # AND the injected retrieve tool). Markers without a tool — or a tool
- # without markers — are useless, so it is a single switch. Default keeps
- # CCR fully on.
+ # CCR opt-out: --no-ccr disables every half at once — markers in
+ # content, the injected retrieve tool, AND server-side response
+ # handling. Markers without a tool, or a tool without markers, are
+ # useless, so it is a single switch. Default keeps CCR fully on.
+ #
+ # Response handling has to be part of it. The buffered stream:false
+ # path keys off ``headroom_retrieve`` being present in the *request's*
+ # tools, and a client can advertise that tool on its own — the bundled
+ # OpenCode plugin registers it unconditionally. So with response
+ # handling left on, `--no-ccr` silently kept flipping streaming turns
+ # to buffered whenever history still held a redeemable marker, and the
+ # documented escape hatch for the CCR buffered-stream bugs did nothing
+ # for exactly the clients told to use it (#3082).
ccr_inject_tool=not no_ccr,
ccr_inject_marker=not no_ccr,
+ ccr_handle_responses=not no_ccr,
ccr_resolve_markers_inline=ccr_inline_resolve,
lossless=lossless,
ccr_proactive_expansion=not no_ccr_proactive_expansion,
diff --git a/tests/test_no_ccr_disables_response_handling.py b/tests/test_no_ccr_disables_response_handling.py
new file mode 100644
index 000000000..5a1947b8a
--- /dev/null
+++ b/tests/test_no_ccr_disables_response_handling.py
@@ -0,0 +1,164 @@
+"""`--no-ccr` has to disable server-side CCR handling too (#3082).
+
+The flag advertises "Disable CCR entirely", and names the case it exists for:
+streaming / non-MCP clients that cannot resolve an injected tool. It mapped onto
+only two of the three CCR subsystems, though — markers and tool injection —
+leaving ``ccr_handle_responses`` on, which has no flag and no env var of its own.
+
+That mattered because the buffered ``stream: false`` path keys off
+``headroom_retrieve`` being present in the *request's* tools, and the client can
+put it there itself: the bundled OpenCode plugin registers the tool
+unconditionally. So `--no-ccr` left the buffered path fully armed for exactly
+the clients it was recommended to, and a turn whose history still held a
+redeemable marker kept being flipped to buffered.
+"""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import pytest
+
+click = pytest.importorskip("click")
+pytest.importorskip("fastapi")
+httpx = pytest.importorskip("httpx")
+
+from click.testing import CliRunner # noqa: E402
+from fastapi.testclient import TestClient # noqa: E402
+
+from headroom.cache.backends import InMemoryBackend # noqa: E402
+from headroom.cache.compression_store import ( # noqa: E402
+ get_compression_store,
+ reset_compression_store,
+)
+from headroom.ccr.tool_injection import create_ccr_tool_definition # noqa: E402
+from headroom.cli.main import main # noqa: E402
+from headroom.proxy.server import ProxyConfig, create_app # noqa: E402
+
+
+def _config_for(args: list[str], env: dict[str, str] | None = None) -> ProxyConfig:
+ """Run `headroom proxy ...` far enough to capture the ProxyConfig it builds."""
+ captured: dict[str, ProxyConfig] = {}
+
+ def mock_run_server(config, **kwargs): # noqa: ANN001, ANN003
+ captured["config"] = config
+
+ with patch("headroom.proxy.server.run_server", mock_run_server):
+ result = CliRunner().invoke(main, args, env=env or {}, catch_exceptions=False)
+
+ assert result.exit_code == 0, result.output
+ return captured["config"]
+
+
+# --------------------------------------------------------------------------- #
+# The flag -> config mapping
+# --------------------------------------------------------------------------- #
+def test_no_ccr_flag_disables_response_handling() -> None:
+ config = _config_for(["proxy", "--no-ccr"])
+
+ assert config.ccr_inject_tool is False
+ assert config.ccr_inject_marker is False
+ # The half that used to survive the switch.
+ assert config.ccr_handle_responses is False
+
+
+def test_no_ccr_env_var_disables_response_handling() -> None:
+ config = _config_for(["proxy"], env={"HEADROOM_NO_CCR": "1"})
+
+ assert config.ccr_inject_tool is False
+ assert config.ccr_inject_marker is False
+ assert config.ccr_handle_responses is False
+
+
+def test_default_keeps_ccr_fully_on() -> None:
+ """The switch must not leak into the default posture."""
+ config = _config_for(["proxy"])
+
+ assert config.ccr_inject_tool is True
+ assert config.ccr_inject_marker is True
+ assert config.ccr_handle_responses is True
+
+
+# --------------------------------------------------------------------------- #
+# What that mapping buys: no buffered flip, even when the client offers the tool
+# --------------------------------------------------------------------------- #
+def _store():
+ reset_compression_store()
+ get_compression_store(backend=InMemoryBackend())
+ try:
+ yield
+ finally:
+ reset_compression_store()
+
+
+def _upstream_stream_field(*, ccr_handle_responses: bool) -> object:
+ """Drive one streaming turn and report the `stream` value sent upstream."""
+ marker = get_compression_store().store(
+ original=json.dumps({"earlier": "tool output"}),
+ compressed="{}",
+ original_item_count=400,
+ )
+ config = ProxyConfig(
+ optimize=False,
+ cache_enabled=False,
+ rate_limit_enabled=False,
+ memory_enabled=False,
+ # `--no-ccr` posture: nothing injected by us.
+ ccr_inject_tool=False,
+ ccr_inject_marker=False,
+ ccr_handle_responses=ccr_handle_responses,
+ ccr_context_tracking=False,
+ image_optimize=False,
+ )
+ seen: dict[str, object] = {}
+ app = create_app(config)
+ with TestClient(app) as client:
+ proxy = client.app.state.proxy
+
+ async def _fake_retry(method, url, headers, body, stream=False, **kwargs): # noqa: ANN001
+ sent = json.loads(body) if isinstance(body, (str, bytes)) else body
+ seen["stream"] = sent.get("stream")
+ return httpx.Response(
+ 200,
+ json={
+ "id": "msg_1",
+ "type": "message",
+ "role": "assistant",
+ "model": "claude-sonnet-4-6",
+ "content": [{"type": "text", "text": "ok"}],
+ "stop_reason": "end_turn",
+ "usage": {
+ "input_tokens": 10,
+ "output_tokens": 5,
+ "cache_read_input_tokens": 0,
+ "cache_creation_input_tokens": 0,
+ },
+ },
+ )
+
+ proxy._retry_request = _fake_retry # type: ignore[assignment]
+ client.post(
+ "/v1/messages",
+ json={
+ "model": "claude-sonnet-4-6",
+ "max_tokens": 64,
+ "stream": True,
+ # The client advertises the tool itself, as the OpenCode plugin does.
+ "tools": [create_ccr_tool_definition("anthropic")],
+ "messages": [{"role": "user", "content": f"go <<ccr:{marker}>>"}],
+ },
+ headers={"x-api-key": "test-key", "anthropic-version": "2023-06-01"},
+ )
+ return seen.get("stream")
+
+
+def test_client_offered_tool_still_buffers_when_handling_is_on(_store) -> None: # noqa: ANN001
+ """The behaviour being switched off — pinned so the switch is meaningful."""
+ assert _upstream_stream_field(ccr_handle_responses=True) is False
+
+
+def test_client_offered_tool_does_not_buffer_under_no_ccr(_store) -> None: # noqa: ANN001
+ """With the switch honoured, the turn keeps streaming despite the tool."""
+ assert _upstream_stream_field(ccr_handle_responses=False) is not False