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
test: verify ratelimit headers are forwarded in streaming responses
jocel183c60407e72a
diff --git a/tests/test_proxy_streaming_ratelimit_headers.py b/tests/test_proxy_streaming_ratelimit_headers.pynew file mode 100644index 000000000..6c1d306b3--- /dev/null+++ b/tests/test_proxy_streaming_ratelimit_headers.py@@ -0,0 +1,243 @@+"""Tests for ratelimit header forwarding in streaming responses.++Verifies that anthropic-ratelimit-* headers from the upstream API response+are forwarded to the client in StreamingResponse, even in SSE streaming mode.++This was a bug where non-streaming responses correctly forwarded all headers+via dict(response.headers), but streaming responses used StreamingResponse+without passing any upstream headers — silently dropping ratelimit info.+"""++import json+from unittest.mock import AsyncMock, MagicMock++import httpx+import pytest++from headroom.proxy.server import HeadroomProxy+++class TestStreamingRatelimitHeaderForwarding:+ """Test that upstream ratelimit headers are forwarded in streaming responses."""++ def _create_mock_proxy(self):+ """Create a HeadroomProxy with mocked internals for unit testing."""+ proxy = object.__new__(HeadroomProxy)+ proxy.http_client = MagicMock(spec=httpx.AsyncClient)+ proxy.cost_tracker = MagicMock()+ proxy.cost_tracker.estimate_cost.return_value = 0.001+ proxy.cost_tracker.record_request.return_value = None+ proxy.stats = {+ "requests_total": 0,+ "requests_optimized": 0,+ "tokens": {"original": 0, "optimized": 0, "saved": 0},+ "cost": {"total_usd": 0, "savings_usd": 0},+ "errors": 0,+ "active_requests": 0,+ "requests_per_model": {},+ }+ proxy.memory_manager = None+ proxy._config = MagicMock()+ proxy._config.memory_enabled = False+ proxy._config.ccr_inject_tool = False+ proxy._parse_sse_usage_from_buffer = MagicMock(return_value=None)+ proxy.memory_handler = None+ return proxy++ def _create_mock_upstream_response(self, extra_headers=None):+ """Create a mock httpx streaming response with ratelimit headers."""+ mock_response = AsyncMock()+ headers = {+ "content-type": "text/event-stream",+ "anthropic-ratelimit-tokens-limit": "80000",+ "anthropic-ratelimit-tokens-remaining": "75000",+ "anthropic-ratelimit-tokens-reset": "2026-03-25T12:00:00Z",+ "anthropic-ratelimit-requests-limit": "60",+ "anthropic-ratelimit-requests-remaining": "59",+ "anthropic-ratelimit-requests-reset": "2026-03-25T12:00:00Z",+ "anthropic-ratelimit-input-tokens-limit": "50000",+ "anthropic-ratelimit-input-tokens-remaining": "48000",+ "anthropic-ratelimit-input-tokens-reset": "2026-03-25T12:00:00Z",+ "anthropic-ratelimit-output-tokens-limit": "30000",+ "anthropic-ratelimit-output-tokens-remaining": "27000",+ "anthropic-ratelimit-output-tokens-reset": "2026-03-25T12:00:00Z",+ # Non-ratelimit headers that should NOT be forwarded+ "x-request-id": "req-12345",+ "cf-ray": "abc123",+ }+ if extra_headers:+ headers.update(extra_headers)+ mock_response.headers = httpx.Headers(headers)++ # Simulate a simple SSE stream+ sse_data = (+ b'event: message_start\ndata: {"type":"message_start","message":{"id":"msg_01"}}\n\n'+ b'event: message_stop\ndata: {"type":"message_stop"}\n\n'+ )++ async def aiter_bytes():+ yield sse_data++ mock_response.aiter_bytes = aiter_bytes+ mock_response.aclose = AsyncMock()+ return mock_response++ @pytest.mark.asyncio+ async def test_ratelimit_headers_forwarded_in_streaming(self):+ """Ratelimit headers from upstream should appear in the StreamingResponse."""+ proxy = self._create_mock_proxy()+ mock_response = self._create_mock_upstream_response()++ # Mock build_request + send to return our mock response+ mock_request = MagicMock()+ proxy.http_client.build_request = MagicMock(return_value=mock_request)+ proxy.http_client.send = AsyncMock(return_value=mock_response)++ result = await proxy._stream_response(+ url="https://api.anthropic.com/v1/messages",+ headers={"x-api-key": "sk-test", "anthropic-version": "2023-06-01"},+ body={+ "model": "claude-sonnet-4-20250514",+ "max_tokens": 100,+ "stream": True,+ "messages": [{"role": "user", "content": "hi"}],+ },+ provider="anthropic",+ model="claude-sonnet-4-20250514",+ request_id="test-123",+ original_tokens=10,+ optimized_tokens=10,+ tokens_saved=0,+ transforms_applied=[],+ tags={},+ optimization_latency=0.0,+ )++ # Verify ratelimit headers are present in the StreamingResponse+ assert result.headers.get("anthropic-ratelimit-tokens-limit") == "80000"+ assert result.headers.get("anthropic-ratelimit-tokens-remaining") == "75000"+ assert result.headers.get("anthropic-ratelimit-tokens-reset") == "2026-03-25T12:00:00Z"+ assert result.headers.get("anthropic-ratelimit-requests-limit") == "60"+ assert result.headers.get("anthropic-ratelimit-requests-remaining") == "59"+ assert result.headers.get("anthropic-ratelimit-input-tokens-limit") == "50000"+ assert result.headers.get("anthropic-ratelimit-output-tokens-limit") == "30000"++ @pytest.mark.asyncio+ async def test_non_ratelimit_headers_not_forwarded(self):+ """Only ratelimit headers should be forwarded, not arbitrary upstream headers."""+ proxy = self._create_mock_proxy()+ mock_response = self._create_mock_upstream_response()++ mock_request = MagicMock()+ proxy.http_client.build_request = MagicMock(return_value=mock_request)+ proxy.http_client.send = AsyncMock(return_value=mock_response)++ result = await proxy._stream_response(+ url="https://api.anthropic.com/v1/messages",+ headers={"x-api-key": "sk-test"},+ body={+ "model": "claude-sonnet-4-20250514",+ "max_tokens": 100,+ "stream": True,+ "messages": [{"role": "user", "content": "hi"}],+ },+ provider="anthropic",+ model="claude-sonnet-4-20250514",+ request_id="test-456",+ original_tokens=10,+ optimized_tokens=10,+ tokens_saved=0,+ transforms_applied=[],+ tags={},+ optimization_latency=0.0,+ )++ # Non-ratelimit headers should NOT be in the response+ assert result.headers.get("x-request-id") is None+ assert result.headers.get("cf-ray") is None++ @pytest.mark.asyncio+ async def test_no_ratelimit_headers_still_works(self):+ """When upstream has no ratelimit headers, streaming should still work."""+ proxy = self._create_mock_proxy()+ mock_response = self._create_mock_upstream_response()+ # Remove all ratelimit headers+ mock_response.headers = httpx.Headers(+ {+ "content-type": "text/event-stream",+ "x-request-id": "req-999",+ }+ )++ mock_request = MagicMock()+ proxy.http_client.build_request = MagicMock(return_value=mock_request)+ proxy.http_client.send = AsyncMock(return_value=mock_response)++ result = await proxy._stream_response(+ url="https://api.anthropic.com/v1/messages",+ headers={"x-api-key": "sk-test"},+ body={+ "model": "claude-sonnet-4-20250514",+ "max_tokens": 100,+ "stream": True,+ "messages": [{"role": "user", "content": "hi"}],+ },+ provider="anthropic",+ model="claude-sonnet-4-20250514",+ request_id="test-789",+ original_tokens=10,+ optimized_tokens=10,+ tokens_saved=0,+ transforms_applied=[],+ tags={},+ optimization_latency=0.0,+ )++ # Should still return a valid StreamingResponse+ assert result.media_type == "text/event-stream"+ # No ratelimit headers to forward+ assert result.headers.get("anthropic-ratelimit-tokens-limit") is None++ @pytest.mark.asyncio+ async def test_connect_error_returns_sse_error(self):+ """Connection errors should return an SSE error event (not crash)."""+ proxy = self._create_mock_proxy()++ mock_request = MagicMock()+ proxy.http_client.build_request = MagicMock(return_value=mock_request)+ proxy.http_client.send = AsyncMock(side_effect=httpx.ConnectError("Connection refused"))++ result = await proxy._stream_response(+ url="https://api.anthropic.com/v1/messages",+ headers={"x-api-key": "sk-test"},+ body={+ "model": "claude-sonnet-4-20250514",+ "max_tokens": 100,+ "stream": True,+ "messages": [{"role": "user", "content": "hi"}],+ },+ provider="anthropic",+ model="claude-sonnet-4-20250514",+ request_id="test-error",+ original_tokens=10,+ optimized_tokens=10,+ tokens_saved=0,+ transforms_applied=[],+ tags={},+ optimization_latency=0.0,+ )++ # Should return a StreamingResponse with error SSE event+ assert result.media_type == "text/event-stream"++ # Consume the generator to get the error event+ chunks = []+ async for chunk in result.body_iterator:+ chunks.append(chunk)++ assert len(chunks) == 1+ raw = chunks[0].decode("utf-8")+ assert "event: error" in raw+ error_data = json.loads(raw.split("data: ")[1].strip())+ assert error_data["error"]["type"] == "connection_error"+ assert "Connection refused" in error_data["error"]["message"]