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(ccr): make --no-ccr disable server-side response handling too (#3101)
Tejas Chopra131b119c053e
diff --git a/headroom/cli/proxy.py b/headroom/cli/proxy.pyindex 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.pynew file mode 100644index 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