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(learn): ingest OpenAI Responses HTTP traffic (#2167)
Chesterce141301f101
diff --git a/headroom/proxy/handlers/openai.py b/headroom/proxy/handlers/openai.pyindex 88de6c1d9..184ecb7ec 100644--- a/headroom/proxy/handlers/openai.py+++ b/headroom/proxy/handlers/openai.py@@ -747,6 +747,83 @@ def _responses_input_to_waste_messages(instructions: Any, input_data: Any) -> lireturn messages+def _responses_input_to_learner_messages(+ instructions: Any,+ input_data: Any,+) -> list[dict[str, Any]]:+ """Normalize Responses input for ``TrafficLearner``.++ The learner already understands Anthropic-style ``tool_use`` / ``tool_result``+ blocks. Converting at the provider boundary keeps that extraction logic shared+ without teaching the learner about every OpenAI transport shape.+ """+ messages: list[dict[str, Any]] = []+ if isinstance(instructions, str) and instructions:+ messages.append({"role": "system", "content": instructions})+ if isinstance(input_data, str):+ if input_data:+ messages.append({"role": "user", "content": input_data})+ return messages+ if not isinstance(input_data, list):+ return messages++ for item in input_data:+ if not isinstance(item, dict):+ continue+ item_type = item.get("type")+ if item_type == "function_call":+ arguments = item.get("arguments", {})+ if isinstance(arguments, str):+ try:+ parsed_arguments = json.loads(arguments)+ except (json.JSONDecodeError, TypeError):+ parsed_arguments = {}+ arguments = parsed_arguments if isinstance(parsed_arguments, dict) else {}+ if not isinstance(arguments, dict):+ arguments = {}+ messages.append(+ {+ "role": "assistant",+ "content": [+ {+ "type": "tool_use",+ "id": item.get("call_id", ""),+ "name": item.get("name", "unknown"),+ "input": arguments,+ }+ ],+ }+ )+ continue+ if item_type in _RESPONSES_OUTPUT_ITEM_TYPES:+ output = item.get("output", "")+ output_text = _responses_part_text(output)+ if not output_text and output not in (None, ""):+ output_text = json.dumps(output, ensure_ascii=False, default=str)+ messages.append(+ {+ "role": "user",+ "content": [+ {+ "type": "tool_result",+ "tool_use_id": item.get("call_id", ""),+ "content": output_text,+ "is_error": bool(item.get("is_error"))+ or item.get("status") in {"failed", "error", "incomplete"},+ }+ ],+ }+ )+ continue+ text = _responses_part_text(item.get("content"))+ if text:+ role = item.get("role")+ messages.append(+ {"role": role if isinstance(role, str) and role else "user", "content": text}+ )+ return messages++def _has_headroom_retrieve_tool_responses(tools: Any) -> bool:"""Return True when the Responses API tool list includes CCR retrieve.@@ -1198,6 +1275,42 @@ class OpenAIHandlerMixin:while len(cache) > _OPENAI_RESPONSES_UNIT_CACHE_MAX_ENTRIES:cache.popitem(last=False)+ async def _observe_openai_responses_traffic(+ self,+ body: dict[str, Any],+ *,+ request_id: str,+ ) -> None:+ """Feed one Responses HTTP request into the live traffic learner."""+ traffic_learner = getattr(self, "traffic_learner", None)+ if traffic_learner is None:+ return+ try:+ memory_handler = getattr(self, "memory_handler", None)+ if (+ traffic_learner._backend is None+ and memory_handler+ and memory_handler.initialized+ and memory_handler.backend+ ):+ traffic_learner.set_backend(memory_handler.backend)++ learner_messages = _responses_input_to_learner_messages(+ body.get("instructions"),+ body.get("input", ""),+ )+ tool_results = traffic_learner.extract_tool_results_from_messages(learner_messages)+ for tool_result in tool_results[-5:]:+ await traffic_learner.on_tool_result(+ tool_name=tool_result["tool_name"],+ tool_input=tool_result["input"],+ tool_output=tool_result["output"],+ is_error=tool_result["is_error"],+ )+ await traffic_learner.on_messages(learner_messages)+ except Exception as exc:+ logger.debug("[%s] Traffic learner (responses): %s", request_id, exc)+@staticmethoddef _headroom_bypass_enabled(headers: Any) -> bool:"""Return True when inbound headers request full passthrough."""@@ -3890,6 +4003,11 @@ class OpenAIHandlerMixin:headers.pop("content-encoding", None)tags = extract_tags(headers)client = classify_client(headers)++ # Learn from the original client payload before memory context or+ # compression mutates it. This mirrors the Anthropic ingestion path.+ await self._observe_openai_responses_traffic(body, request_id=request_id)+# PR-A5 (P5-49): strip internal x-headroom-* from upstream-bound# headers AFTER `_extract_tags` reads them. Memory user-id reads# `request.headers` below.diff --git a/tests/test_openai_responses_traffic_learner.py b/tests/test_openai_responses_traffic_learner.pynew file mode 100644index 000000000..f049011d4--- /dev/null+++ b/tests/test_openai_responses_traffic_learner.py@@ -0,0 +1,121 @@+from __future__ import annotations++from typing import Any++import httpx+from fastapi.testclient import TestClient++from headroom.memory.traffic_learner import TrafficLearner+from headroom.proxy.handlers.openai import _responses_input_to_learner_messages+from headroom.proxy.server import ProxyConfig, create_app+++class _CompletedResponseTransport(httpx.AsyncBaseTransport):+ async def handle_async_request(self, request: httpx.Request) -> httpx.Response:+ return httpx.Response(+ 200,+ headers={"content-type": "application/json"},+ json={+ "id": "resp_test",+ "object": "response",+ "status": "completed",+ "model": "gpt-5",+ "output": [],+ "usage": {"input_tokens": 10, "output_tokens": 1},+ },+ )+++class _RecordingLearner:+ def __init__(self) -> None:+ self._backend = None+ self._extractor = TrafficLearner(backend=None)+ self.message_batches: list[list[dict[str, Any]]] = []+ self.tool_results: list[dict[str, Any]] = []++ def extract_tool_results_from_messages(+ self,+ messages: list[dict[str, Any]],+ ) -> list[dict[str, Any]]:+ return self._extractor.extract_tool_results_from_messages(messages)++ async def on_tool_result(self, **tool_result: Any) -> None:+ self.tool_results.append(tool_result)++ async def on_messages(self, messages: list[dict[str, Any]]) -> None:+ self.message_batches.append(messages)+++def _responses_input() -> list[dict[str, Any]]:+ return [+ {+ "type": "message",+ "role": "user",+ "content": [{"type": "input_text", "text": "Always return compact JSON."}],+ },+ {+ "type": "function_call",+ "call_id": "call_1",+ "name": "shell",+ "arguments": '{"cmd":"missing-command"}',+ },+ {+ "type": "function_call_output",+ "call_id": "call_1",+ "output": "command not found",+ "status": "failed",+ },+ ]+++def test_responses_input_normalizes_messages_and_tool_results() -> None:+ messages = _responses_input_to_learner_messages("Follow repository rules.", _responses_input())+ learner = TrafficLearner(backend=None)++ assert messages[0] == {"role": "system", "content": "Follow repository rules."}+ assert messages[1] == {"role": "user", "content": "Always return compact JSON."}+ assert learner.extract_tool_results_from_messages(messages) == [+ {+ "tool_name": "shell",+ "input": {"cmd": "missing-command"},+ "output": "command not found",+ "is_error": True,+ }+ ]+++def test_responses_http_request_reaches_traffic_learner() -> None:+ config = ProxyConfig(+ optimize=False,+ cache_enabled=False,+ rate_limit_enabled=False,+ cost_tracking_enabled=False,+ log_requests=False,+ ccr_inject_tool=False,+ ccr_handle_responses=False,+ ccr_context_tracking=False,+ image_optimize=False,+ )+ app = create_app(config)+ learner = _RecordingLearner()+ proxy = app.state.proxy+ proxy.traffic_learner = learner+ proxy.http_client = httpx.AsyncClient(transport=_CompletedResponseTransport())+ client = TestClient(app)++ response = client.post(+ "/v1/responses",+ headers={"authorization": "Bearer test-token"},+ json={"model": "gpt-5", "input": _responses_input(), "stream": False},+ )++ assert response.status_code == 200, response.text+ assert len(learner.message_batches) == 1+ assert learner.tool_results == [+ {+ "tool_name": "shell",+ "tool_input": {"cmd": "missing-command"},+ "tool_output": "command not found",+ "is_error": True,+ }+ ]