Avoid blocking proxy health routes during compression

headroom/proxy/handlers/anthropic.py

@@ -714,7 +714,11 @@ class AnthropicHandlerMixin:
             ):
                 compressor = _get_image_compressor()
                 if compressor and compressor.has_images(messages):
-                    messages = compressor.compress(messages, provider="anthropic")
+                    messages = await asyncio.to_thread(
+                        compressor.compress,
+                        messages,
+                        provider="anthropic",
+                    )
                     if compressor.last_result:
                         logger.info(
                             f"Image compression: {compressor.last_result.technique.value} "
@@ -2070,7 +2074,8 @@ class AnthropicHandlerMixin:
                     original_tokens = get_tokenizer(model).count_messages(messages)
                     optimized_tokens = original_tokens
                 else:
-                    result = self.anthropic_pipeline.apply(
+                    result = await asyncio.to_thread(
+                        self.anthropic_pipeline.apply,
                         messages=messages,
                         model=model,
                         model_limit=context_limit,

headroom/proxy/handlers/batch.py

@@ -145,7 +145,8 @@ class BatchHandlerMixin:
                 )
 
                 # Use OpenAI pipeline (similar message format after conversion)
-                result = self.openai_pipeline.apply(
+                result = await asyncio.to_thread(
+                    self.openai_pipeline.apply,
                     messages=messages,
                     model=model,
                     model_limit=context_limit,
@@ -904,7 +905,8 @@ class BatchHandlerMixin:
                 if self.config.optimize:
                     try:
                         context_limit = self.openai_provider.get_context_limit(model)
-                        result = self.openai_pipeline.apply(
+                        result = await asyncio.to_thread(
+                            self.openai_pipeline.apply,
                             messages=messages,
                             model=model,
                             model_limit=context_limit,

headroom/proxy/handlers/gemini.py

@@ -277,7 +277,8 @@ class GeminiHandlerMixin:
             try:
                 # Use OpenAI pipeline (similar message format)
                 context_limit = self.openai_provider.get_context_limit(model)
-                result = self.openai_pipeline.apply(
+                result = await asyncio.to_thread(
+                    self.openai_pipeline.apply,
                     messages=messages,
                     model=model,
                     model_limit=context_limit,
@@ -537,7 +538,8 @@ class GeminiHandlerMixin:
         if self.config.optimize and messages and _license_ok:
             try:
                 context_limit = self.openai_provider.get_context_limit(model)
-                result = self.openai_pipeline.apply(
+                result = await asyncio.to_thread(
+                    self.openai_pipeline.apply,
                     messages=messages,
                     model=model,
                     model_limit=context_limit,
@@ -744,7 +746,8 @@ class GeminiHandlerMixin:
         if self.config.optimize and messages:
             try:
                 context_limit = self.openai_provider.get_context_limit(model)
-                result = self.openai_pipeline.apply(
+                result = await asyncio.to_thread(
+                    self.openai_pipeline.apply,
                     messages=messages,
                     model=model,
                     model_limit=context_limit,

headroom/proxy/handlers/openai.py

@@ -241,7 +241,11 @@ class OpenAIHandlerMixin:
 
             compressor = _get_image_compressor()
             if compressor and compressor.has_images(messages):
-                messages = compressor.compress(messages, provider="openai")
+                messages = await asyncio.to_thread(
+                    compressor.compress,
+                    messages,
+                    provider="openai",
+                )
                 if compressor.last_result:
                     logger.info(
                         f"[{request_id}] Image: {compressor.last_result.technique.value} "
@@ -2602,7 +2606,8 @@ class OpenAIHandlerMixin:
             if compress_tagged_content is not None:
                 pipeline_kwargs["compress_tagged_content"] = bool(compress_tagged_content)
 
-            result = self.openai_pipeline.apply(
+            result = await asyncio.to_thread(
+                self.openai_pipeline.apply,
                 messages=messages,
                 model=model,
                 **pipeline_kwargs,

tests/test_proxy/test_proxy_healthchecks.py

@@ -206,3 +206,62 @@ def test_shutdown_tolerates_stubbed_memory_handler():
         response = client.get("/health")
 
     assert response.status_code == 200
+@pytest.mark.asyncio
+async def test_readyz_remains_responsive_during_slow_compress(monkeypatch):
+    import asyncio
+    import time
+
+    from httpx import ASGITransport, AsyncClient
+
+    config = ProxyConfig(
+        optimize=True,
+        cache_enabled=False,
+        rate_limit_enabled=False,
+        cost_tracking_enabled=False,
+    )
+    app = create_app(config)
+    app.state.ready = True
+    app.state.startup_error = None
+    app.state.proxy.http_client = object()
+
+    def slow_apply(*, messages, model, **kwargs):  # noqa: ANN003
+        time.sleep(0.25)
+        return SimpleNamespace(
+            messages=messages,
+            transforms_applied=[],
+            transforms_summary=[],
+            markers_inserted=[],
+            tokens_before=16,
+            tokens_after=16,
+            skip_reason="no_change",
+        )
+
+    app.state.proxy.openai_pipeline.apply = slow_apply
+
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://testserver") as client:
+        compress_task = asyncio.create_task(
+            client.post(
+                "/v1/compress",
+                json={
+                    "model": "gpt-4o-mini",
+                    "messages": [
+                        {"role": "system", "content": "You are helpful."},
+                        {"role": "user", "content": "Compress this."},
+                    ],
+                },
+            )
+        )
+
+        await asyncio.sleep(0.05)
+
+        started = time.perf_counter()
+        readyz_response = await client.get("/readyz")
+        readyz_elapsed = time.perf_counter() - started
+
+        compress_response = await compress_task
+
+    assert readyz_response.status_code == 200
+    assert readyz_response.json()["ready"] is True
+    assert readyz_elapsed < 0.15
+    assert compress_response.status_code == 200