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(gemini): resolve native CCR retrieval calls (#2253)
Rod Boev2483f5700257
diff --git a/docs/content/docs/ccr.mdx b/docs/content/docs/ccr.mdxindex 18c4ff2c4..4d668b07c 100644--- a/docs/content/docs/ccr.mdx+++ b/docs/content/docs/ccr.mdx@@ -73,13 +73,15 @@ When the LLM calls `headroom_retrieve`:The client never sees CCR tool calls on the Anthropic and OpenAI proxy paths; Headroom resolves them transparently there.-<Callout type="warning" title="Current Gemini limitation">- Native Gemini requests do not yet run the server-side CCR response handler, so- `headroom_retrieve` is not resolved transparently on that path today. Google's- OpenAI-compatible Gemini endpoint can also return- `finish_reason=MALFORMED_FUNCTION_CALL` on large function-response continuations- after CCR retrieval. If you need fully transparent CCR resolution today, use the- Anthropic or OpenAI proxy paths. See [issue #2041](https://github.com/headroomlabs-ai/headroom/issues/2041).+<Callout type="warning" title="Gemini CCR boundary">+ Buffered native Gemini requests resolve `headroom_retrieve` server-side and+ return the model's final response. Streaming native Gemini requests keep the+ existing forwarding behavior. When a response contains `headroom_retrieve`+ alongside a client-owned function call, Headroom preserves both calls for the+ client instead of resolving the mixed response. Google's OpenAI-compatible Gemini endpoint can+ also return `finish_reason=MALFORMED_FUNCTION_CALL` on large function-response+ continuations after CCR retrieval; that separate limitation remains tracked in+ [issue #2041](https://github.com/headroomlabs-ai/headroom/issues/2041).</Callout>## Phase 4: Context Trackerdiff --git a/headroom/ccr/response_handler.py b/headroom/ccr/response_handler.pyindex ff93aa981..7c959e9a6 100644--- a/headroom/ccr/response_handler.py+++ b/headroom/ccr/response_handler.py@@ -58,6 +58,7 @@ class CCRToolResult:content: strsuccess: boolitems_retrieved: int = 0+ tool_name: str | None = None@dataclass@@ -211,6 +212,7 @@ class CCRResponseHandler:tool_call_id=ccr_call.tool_call_id,content=content,success=False,+ tool_name=ccr_call.tool_name,)# Retrieval is by hash: always return the full original content.@@ -229,6 +231,7 @@ class CCRResponseHandler:content=content,success=True,items_retrieved=entry.original_item_count,+ tool_name=ccr_call.tool_name,)miss_status = (@@ -249,6 +252,7 @@ class CCRResponseHandler:tool_call_id=ccr_call.tool_call_id,content=content,success=False,+ tool_name=ccr_call.tool_name,)except Exception as e:@@ -264,6 +268,7 @@ class CCRResponseHandler:tool_call_id=ccr_call.tool_call_id,content=content,success=False,+ tool_name=ccr_call.tool_name,)def _create_tool_result_message(@@ -337,14 +342,13 @@ class CCRResponseHandler:response_data = json.loads(result.content)except json.JSONDecodeError:response_data = {"content": result.content}- parts.append(- {- "functionResponse": {- "name": result.tool_call_id, # tool_call_id contains the function name for Google- "response": response_data,- }- }- )+ function_response = {+ "name": result.tool_name or result.tool_call_id,+ "response": response_data,+ }+ if result.tool_name and result.tool_call_id != result.tool_name:+ function_response["id"] = result.tool_call_id+ parts.append({"functionResponse": function_response})return {"role": "user","parts": parts,diff --git a/headroom/ccr/tool_calls.py b/headroom/ccr/tool_calls.pyindex 46e5feacb..44d75ff34 100644--- a/headroom/ccr/tool_calls.py+++ b/headroom/ccr/tool_calls.py@@ -14,6 +14,7 @@ class CCRToolCall:tool_call_id: strhash_key: str+ tool_name: str | None = Nonedef extract_tool_calls(response: dict[str, Any], provider: str) -> list[dict[str, Any]]:@@ -88,6 +89,8 @@ def tool_call_id_for_provider(tool_call: dict[str, Any], provider: str) -> str:if provider == "google":function_call = tool_call.get("functionCall", {})if isinstance(function_call, dict):+ if function_call.get("id"):+ return str(function_call["id"])name = function_call.get("name", CCR_TOOL_NAME)return str(name)return CCR_TOOL_NAME@@ -111,11 +114,14 @@ def parse_ccr_tool_calls(other_calls.append(tool_call)continue+ tool_name = None+ tool_call_id = tool_call_id_for_provider(tool_call, provider)+ if provider == "google":+ function_call = tool_call.get("functionCall", {})+ if isinstance(function_call, dict) and function_call.get("id"):+ tool_name = str(function_call.get("name", CCR_TOOL_NAME))ccr_calls.append(- CCRToolCall(- tool_call_id=tool_call_id_for_provider(tool_call, provider),- hash_key=hash_key,- )+ CCRToolCall(tool_call_id=tool_call_id, hash_key=hash_key, tool_name=tool_name))return ccr_calls, other_callsdiff --git a/headroom/proxy/handlers/gemini.py b/headroom/proxy/handlers/gemini.pyindex 941d31bd3..3311fe69c 100644--- a/headroom/proxy/handlers/gemini.py+++ b/headroom/proxy/handlers/gemini.py@@ -36,6 +36,14 @@ def _usage_int(value: Any, default: int = 0) -> int:return int(value)+class _GeminiContinuationError(Exception):+ def __init__(self, status_code: int, content: bytes, headers: dict[str, str]) -> None:+ super().__init__(f"Gemini continuation failed with HTTP {status_code}")+ self.status_code = status_code+ self.content = content+ self.headers = headers++class GeminiHandlerMixin:"""Mixin providing Gemini API handler methods for HeadroomProxy."""@@ -630,6 +638,68 @@ class GeminiHandlerMixin:except Exception as e:logger.warning(f"[{request_id}] Memory injection failed (gemini): {e}")+ query_params = dict(request.query_params)+ is_streaming = query_params.get("alt") == "sse" or request.url.path.endswith(+ ":streamGenerateContent"+ )+ native_tools = body.get("tools")+ native_function_declarations = None++ def rebuild_tools(function_declarations: list[dict]) -> list[dict]:+ rebuilt_tools = []+ replaced = False+ declaration_tools = [+ tool for tool in body.get("tools") or [] if "functionDeclarations" in tool+ ]+ later_names = {+ declaration.get("name")+ for tool in declaration_tools[1:]+ for declaration in tool["functionDeclarations"]+ }+ first_declarations = [+ declaration+ for declaration in function_declarations+ if declaration.get("name") not in later_names+ ]+ for tool in body.get("tools") or []:+ if "functionDeclarations" in tool and not replaced:+ rebuilt_tools.append({**tool, "functionDeclarations": first_declarations})+ replaced = True+ else:+ rebuilt_tools.append(tool)+ if not replaced:+ rebuilt_tools.append({"functionDeclarations": function_declarations})+ return rebuilt_tools++ ccr_inject_tool = getattr(self.config, "ccr_inject_tool", True)+ ccr_inject_system_instructions = getattr(+ self.config, "ccr_inject_system_instructions", False+ )+ if ccr_inject_tool and tokens_saved > 0 and not is_streaming:+ from headroom.ccr import CCRToolInjector++ seen_names = set()+ native_function_declarations = []+ for tool in native_tools or []:+ for declaration in tool.get("functionDeclarations", []):+ name = declaration.get("name")+ if name not in seen_names:+ native_function_declarations.append(declaration)+ seen_names.add(name)+ injector = CCRToolInjector(+ provider="google",+ inject_tool=True,+ inject_system_instructions=ccr_inject_system_instructions,+ )+ optimized_messages, injected_funcs, was_injected = injector.process_request(+ optimized_messages, native_function_declarations+ )+ if was_injected:+ native_function_declarations = injected_funcs+ body["tools"] = rebuild_tools(injected_funcs)+ elif native_function_declarations is not None:+ native_function_declarations = list(native_function_declarations)+# Convert back to Gemini format if optimizedif optimized_messages != messages:optimized_contents, optimized_system = self._messages_to_gemini_contents(@@ -644,12 +714,6 @@ class GeminiHandlerMixin:elif "systemInstruction" in body:del body["systemInstruction"]- # Check if streaming requested via query param- query_params = dict(request.query_params)- is_streaming = query_params.get("alt") == "sse" or request.url.path.endswith(- ":streamGenerateContent"- )-# Build URL - model is extracted from path. Vertex publisher# routes use the request's full path under the Vertex base URL;# native Gemini uses the public Gemini API shape.@@ -703,6 +767,8 @@ class GeminiHandlerMixin:total_input_tokens = optimized_tokens # fallbackoutput_tokens = 0cache_read_tokens = 0+ resp_json = None+ response_content = response.contenttry:resp_json = response.json()usage = resp_json.get("usageMetadata", {})@@ -736,6 +802,77 @@ class GeminiHandlerMixin:f"[{request_id}] Failed to extract cached tokens from Gemini response: {e}")+ if (+ response.status_code == 200+ and isinstance(resp_json, dict)+ and self.ccr_response_handler+ and getattr(getattr(self.ccr_response_handler, "config", None), "enabled", True)+ and self.ccr_response_handler.has_ccr_tool_calls(resp_json, "google")+ ):++ async def api_call_fn(+ native_contents: list[dict],+ function_declarations: list[dict] | None,+ ) -> dict[str, Any]:+ continuation_body = {**body, "contents": native_contents}+ if function_declarations is not None:+ continuation_body["tools"] = rebuild_tools(function_declarations)+ continuation_headers = {+ key: value+ for key, value in headers.items()+ if key.lower()+ not in ("accept-encoding", "content-encoding", "content-length")+ }+ continuation = await self._retry_request(+ "POST", url, continuation_headers, continuation_body+ )+ if continuation.status_code >= 400:+ return {+ "_headroom_continuation_error": {+ "status_code": continuation.status_code,+ "content": continuation.content,+ "headers": dict(continuation.headers),+ }+ }+ try:+ return continuation.json()+ except (json.JSONDecodeError, ValueError, TypeError):+ return {+ "_headroom_continuation_error": {+ "status_code": continuation.status_code,+ "content": continuation.content,+ "headers": dict(continuation.headers),+ }+ }++ final_resp_json = await self.ccr_response_handler.handle_response(+ resp_json,+ body.get("contents", []),+ native_function_declarations,+ api_call_fn,+ provider="google",+ )+ continuation_error = final_resp_json.get("_headroom_continuation_error")+ if isinstance(continuation_error, dict):+ raise _GeminiContinuationError(+ continuation_error["status_code"],+ continuation_error["content"],+ continuation_error["headers"],+ )+ from headroom.ccr.response_handler import RESIDUAL_CCR_ERROR++ if (+ self.ccr_response_handler.residual_ccr_status(final_resp_json, "google")+ == RESIDUAL_CCR_ERROR+ ):+ raise RuntimeError("Gemini CCR continuation left an unresolved retrieval")+ resp_json = final_resp_json+ response_content = json.dumps(resp_json).encode()+ usage = resp_json.get("usageMetadata", {})+ total_input_tokens = usage.get("promptTokenCount", total_input_tokens)+ output_tokens = usage.get("candidatesTokenCount", output_tokens)+ cache_read_tokens = usage.get("cachedContentTokenCount", cache_read_tokens)+uncached_input_tokens = max(0, total_input_tokens - cache_read_tokens)# optimized_tokens carries Gemini's own promptTokenCount, which is@@ -822,10 +959,16 @@ class GeminiHandlerMixin:response_headers["x-headroom-compression-failed"] = "true"return Response(- content=response.content,+ content=response_content,status_code=response.status_code,headers=response_headers,)+ except _GeminiContinuationError as e:+ await self.metrics.record_failed(provider=provider_name)+ response_headers = dict(e.headers)+ response_headers.pop("content-encoding", None)+ response_headers.pop("content-length", None)+ return Response(content=e.content, status_code=e.status_code, headers=response_headers)except Exception as e:await self.metrics.record_failed(provider=provider_name)logger.error(f"[{request_id}] Gemini request failed: {type(e).__name__}: {e}")diff --git a/tests/test_ccr_response_handler_extra.py b/tests/test_ccr_response_handler_extra.pyindex 20883ee19..36d2849fb 100644--- a/tests/test_ccr_response_handler_extra.py+++ b/tests/test_ccr_response_handler_extra.py@@ -137,6 +137,27 @@ def test_create_tool_result_message_google_and_generic_formats() -> None:assert invalid_google["parts"][0]["functionResponse"]["response"] == {"content": "not-json"}+def test_create_tool_result_message_google_preserves_call_id() -> None:+ handler = CCRResponseHandler()+ message = handler._create_tool_result_message(+ [+ CCRToolResult(+ tool_call_id="call-1",+ tool_name="headroom_retrieve",+ content='{"count": 1}',+ success=True,+ )+ ],+ "google",+ )++ assert message["parts"][0]["functionResponse"] == {+ "name": "headroom_retrieve",+ "id": "call-1",+ "response": {"count": 1},+ }++def test_extract_assistant_message_google_and_generic() -> None:handler = CCRResponseHandler()google_message = handler._extract_assistant_message(diff --git a/tests/test_proxy_handlers_batch.py b/tests/test_proxy_handlers_batch.pyindex 79c07182e..5188b718a 100644--- a/tests/test_proxy_handlers_batch.py+++ b/tests/test_proxy_handlers_batch.py@@ -6,7 +6,10 @@ from types import SimpleNamespaceimport pytest+from headroom.cache.compression_store import CompressionEntry+from headroom.ccr import response_handler as response_handler_modulefrom headroom.proxy.handlers import batch as batch_module+from headroom.proxy.handlers import gemini as gemini_modulefrom headroom.proxy.handlers.gemini import GeminiHandlerMixin@@ -148,11 +151,443 @@ class FakeRequest:self.headers = headers or {}self.method = methodself.url = SimpleNamespace(path=path, query=query)+ self.query_params = {}async def body(self) -> bytes:return self._body+class NativeGeminiHandler(DummyBatchHandler):+ def __init__(self, responses: list[FakeResponse]) -> None:+ super().__init__()+ self.config.optimize = True+ self.config.ccr_inject_tool = True+ self.config.ccr_inject_system_instructions = False+ self.memory_handler = None+ self.rate_limiter = None+ self.usage_reporter = None+ self.responses = iter(responses)+ self.sent_bodies: list[dict] = []+ from headroom.ccr.response_handler import CCRResponseHandler++ self.ccr_response_handler = CCRResponseHandler()+ self.openai_pipeline = SimpleNamespace(+ apply=lambda **kwargs: SimpleNamespace(+ messages=[+ {+ "role": "user",+ "content": "compressed [100 items compressed to 1. Retrieve more: hash=aaaaaaaaaaaaaaaaaaaaaaaa]",+ }+ ],+ timing={},+ tokens_before=10,+ tokens_after=5,+ transforms_applied=[],+ waste_signals=SimpleNamespace(to_dict=lambda: {}),+ )+ )++ def _gemini_contents_to_messages(+ self, contents, system_instruction=None, *, include_function_responses=False+ ): # noqa: ANN001, ANN201+ return GeminiHandlerMixin._gemini_contents_to_messages(+ self,+ contents,+ system_instruction,+ include_function_responses=include_function_responses,+ )++ def _messages_to_gemini_contents(self, messages): # noqa: ANN001, ANN201+ return GeminiHandlerMixin._messages_to_gemini_contents(self, messages)++ async def _retry_request(self, method, url, headers, body, **kwargs): # noqa: ANN001, ANN201+ self.sent_bodies.append(body)+ return next(self.responses)++ async def _run_compression_in_executor(self, fn, *, timeout): # noqa: ANN001, ANN201+ return fn()+++def install_native_gemini_compression(monkeypatch: pytest.MonkeyPatch) -> None:+ class Decision:+ should_compress = True+ passthrough_reason = ""++ def apply_to_tags(self, tags) -> None: # noqa: ANN001+ return None++ monkeypatch.setattr(gemini_module.CompressionDecision, "decide", lambda **kwargs: Decision())+++def native_gemini_request(tools=None) -> dict: # noqa: ANN001+ return {+ "contents": [{"role": "user", "parts": [{"text": "compressed input"}]}],+ "generationConfig": {"temperature": 0.2},+ **({"tools": tools} if tools is not None else {}),+ }+++def native_ccr_response() -> FakeResponse:+ return FakeResponse(+ json_data={+ "candidates": [+ {+ "content": {+ "role": "model",+ "parts": [+ {+ "functionCall": {+ "name": "headroom_retrieve",+ "id": "call-1",+ "args": {"hash": "aaaaaaaaaaaaaaaaaaaaaaaa"},+ }+ }+ ],+ }+ }+ ],+ "usageMetadata": {"promptTokenCount": 5},+ }+ )+++async def test_gemini_native_ccr_continuation(monkeypatch: pytest.MonkeyPatch) -> None:+ install_native_gemini_compression(monkeypatch)+ from headroom.ccr.response_handler import CCRToolResult++ final = FakeResponse(+ json_data={+ "candidates": [{"content": {"role": "model", "parts": [{"text": "final answer"}]}}]+ }+ )+ handler = NativeGeminiHandler([native_ccr_response(), final])+ handler.ccr_response_handler._execute_retrieval = lambda call: CCRToolResult(+ call.tool_call_id,+ json.dumps({"hash": call.hash_key, "original_content": [{"type": "code"}]}),+ True,+ 1,+ "headroom_retrieve",+ )++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json", "x-goog-api-key": "secret"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 200+ assert (+ json.loads(response.body)["candidates"][0]["content"]["parts"][0]["text"] == "final answer"+ ), response.body+ assert len(handler.sent_bodies) == 2+ continuation = handler.sent_bodies[1]["contents"]+ assert continuation[-2]["role"] == "model"+ assert continuation[-2]["parts"][0]["functionCall"]["name"] == "headroom_retrieve"+ assert continuation[-1]["role"] == "user"+ assert continuation[-1]["parts"][0]["functionResponse"]["name"] == "headroom_retrieve"+ assert continuation[-1]["parts"][0]["functionResponse"]["id"] == "call-1"+++async def test_gemini_native_ccr_tools(monkeypatch: pytest.MonkeyPatch) -> None:+ install_native_gemini_compression(monkeypatch)+ handler = NativeGeminiHandler(+ [FakeResponse(json_data={"candidates": [{"content": {"parts": [{"text": "answer"}]}}]})]+ )+ tools = [+ {"functionDeclarations": [{"name": "client_tool"}]},+ {"functionDeclarations": [{"name": "second_tool"}]},+ {"googleSearch": {}},+ {"codeExecution": {}},+ ]++ await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request(tools)),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ forwarded_tools = handler.sent_bodies[0]["tools"]+ assert forwarded_tools[2:] == tools[2:]+ declarations = forwarded_tools[0]["functionDeclarations"]+ assert {item["name"] for item in declarations} == {"client_tool", "headroom_retrieve"}+ assert forwarded_tools[1]["functionDeclarations"] == [{"name": "second_tool"}]+++async def test_gemini_native_ccr_does_not_duplicate_existing_declaration(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ tools = [+ {"functionDeclarations": [{"name": "client_tool"}]},+ {"functionDeclarations": [{"name": "headroom_retrieve"}]},+ ]+ handler = NativeGeminiHandler(+ [FakeResponse(json_data={"candidates": [{"content": {"parts": [{"text": "answer"}]}}]})]+ )++ await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request(tools)),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ names = [+ declaration["name"]+ for tool in handler.sent_bodies[0]["tools"]+ for declaration in tool.get("functionDeclarations", [])+ ]+ assert names.count("headroom_retrieve") == 1+++async def test_gemini_native_ccr_does_not_inject_into_streaming_request(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ handler = NativeGeminiHandler([FakeResponse()])+ captured: dict[str, object] = {}++ async def fake_stream(*args, **kwargs): # noqa: ANN002, ANN003, ANN202+ captured["body"] = args[2]+ return FakeResponse()++ monkeypatch.setattr(handler, "_stream_response", fake_stream, raising=False)+ tools = [{"functionDeclarations": [{"name": "client_tool"}]}]+ await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request(tools)),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:streamGenerateContent",+ ),+ "gemini-2.5-flash",+ )++ streamed_tools = captured["body"]["tools"] # type: ignore[index]+ names = [+ declaration["name"]+ for tool in streamed_tools+ for declaration in tool.get("functionDeclarations", [])+ ]+ assert names == ["client_tool"]+++async def test_gemini_native_ccr_mixed(monkeypatch: pytest.MonkeyPatch) -> None:+ install_native_gemini_compression(monkeypatch)+ response_json = {+ "candidates": [+ {+ "content": {+ "parts": [+ {+ "functionCall": {+ "name": "headroom_retrieve",+ "args": {"hash": "aaaaaaaaaaaaaaaaaaaaaaaa"},+ }+ },+ {"functionCall": {"name": "client_tool", "args": {}}},+ ]+ }+ }+ ]+ }+ handler = NativeGeminiHandler([FakeResponse(json_data=response_json)])++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 200+ assert len(handler.sent_bodies) == 1+ assert json.loads(response.body) == response_json+++async def test_gemini_native_ccr_non_ccr_function_call_is_not_intercepted(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ response_json = {+ "candidates": [+ {"content": {"parts": [{"functionCall": {"name": "client_tool", "args": {}}}]}}+ ]+ }+ handler = NativeGeminiHandler([FakeResponse(json_data=response_json)])++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 200+ assert len(handler.sent_bodies) == 1+ assert response.body == b"{}"+++async def test_gemini_native_ccr_continuation_error_preserves_upstream_response(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ handler = NativeGeminiHandler(+ [+ native_ccr_response(),+ FakeResponse(status_code=503, content=b"busy", headers={"retry-after": "2"}),+ ]+ )++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 503+ assert response.body == b"busy"+ assert response.headers["retry-after"] == "2"+++async def test_gemini_native_ccr_continuation_non_json_preserves_upstream_response(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ handler = NativeGeminiHandler(+ [native_ccr_response(), FakeResponse(status_code=200, content=b"upstream")]+ )++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 200+ assert response.body == b"upstream"+++ "original_content",+ [[{"type": "code", "text": "print('x')"}], "plain text", {"key": "value"}, 42],+ ids=["code-aware-array", "kompress-text", "mcp-object", "mcp-scalar"],+)+async def test_gemini_native_ccr_uses_real_retrieval_result_shape(+ monkeypatch: pytest.MonkeyPatch, original_content+) -> None: # noqa: ANN001+ install_native_gemini_compression(monkeypatch)+ entry = CompressionEntry(+ hash="a" * 24,+ original_content=json.dumps(original_content),+ compressed_content="compressed",+ original_tokens=10,+ compressed_tokens=2,+ original_item_count=1,+ compressed_item_count=1,+ tool_name="headroom_retrieve",+ tool_call_id="headroom_retrieve",+ query_context=None,+ created_at=0,+ )++ class Store:+ def get_entry_status(self, hash_key, clean_expired=True): # noqa: ANN001, ARG002+ return {"status": "available", "default_ttl_seconds": 1800}++ def retrieve(self, hash_key): # noqa: ANN001, ARG002+ return entry++ monkeypatch.setattr(response_handler_module, "get_compression_store", lambda: Store())+ handler = NativeGeminiHandler(+ [+ native_ccr_response(),+ FakeResponse(json_data={"candidates": [{"content": {"parts": [{"text": "done"}]}}]}),+ ]+ )++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 200+ function_response = handler.sent_bodies[1]["contents"][-1]["parts"][0]["functionResponse"]+ assert function_response["response"]["original_content"] == json.dumps(original_content)+++async def test_gemini_native_ccr_preserves_non_ccr_response(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ install_native_gemini_compression(monkeypatch)+ handler = NativeGeminiHandler([FakeResponse(status_code=503, content=b"busy")])++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 503+ assert response.body == b"busy"+++async def test_gemini_native_ccr_residual(monkeypatch: pytest.MonkeyPatch) -> None:+ install_native_gemini_compression(monkeypatch)+ from headroom.ccr.response_handler import CCRToolResult++ handler = NativeGeminiHandler([native_ccr_response()] * 4)+ handler.ccr_response_handler._execute_retrieval = lambda call: CCRToolResult(+ "headroom_retrieve", "still unresolved", True, 0+ )++ response = await handler.handle_gemini_generate_content(+ FakeRequest(+ json.dumps(native_gemini_request()),+ headers={"content-type": "application/json"},+ path="/v1beta/models/gemini-2.5-flash:generateContent",+ ),+ "gemini-2.5-flash",+ )++ assert response.status_code == 502++def install_batch_support_modules(monkeypatch: pytest.MonkeyPatch,*,