Files
headroom/tests/test_token_headroom_mode.py
Yuchuan He 292b90530d fix(cache): preserve Anthropic tool-result blocks on replay (#4765)
## Description

A cached string replacement for an Anthropic `tool_result` with list
content rebuilt that list as one text block. A matching text hash could
therefore remove an accompanying image or tool reference; even a single
text block lost its `cache_control` and other metadata.

Apply the existing shape-safety contract to Anthropic replay: edit the
text of a single text block in place on the copied message, and leave
text-bearing multiblock layouts unchanged. Those layouts also stop the
replayable frozen prefix, since a text hash does not prove their shape
can be reconstructed. Textless tool-search/image results retain their
stable pass-through path. The shared guard also protects interceptor
rewrites.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)

## Changes Made

- Preserve metadata on single-block Anthropic cached replacements.
- Decline joined-string replay for text-bearing multiblock results.
- Cover images, tool references, multiple text blocks, unknown blocks,
input immutability and frozen-prefix limits.

- Align the existing direct swap test with image-only pass-through and
deep-copy preservation. The review follow-up changes tests only.

## Testing

- [x] Relevant unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Formatting passes (`ruff format --check .`)
- [x] Type checking passes (original full-package mypy hook)
- [x] Regression tests added
- [x] Standalone runtime validation completed

### Test Output

```text
Initial new regressions against original production code: 6 failed
pytest tests/test_token_headroom_mode.py tests/test_compression_cache.py tests/test_session_engine.py tests/test_tool_result_interceptors.py tests/test_cache tests/test_cold_prefix.py:
  554 passed, 13 skipped
Review follow-up on the initial PR head: 1 failed, 31 passed
Original pre-commit and commit-msg hooks (including follow-up): passed
Whole-tree Ruff check / format --check: passed (1932 files)
Original pre-push make ci-precheck: passed
  Rust workspace: 1749 passed, 3 ignored
  Native extension: built, installed and import-verified
  Critical Python: 177 passed, 8 skipped
  commitlint: passed
```

The three cache skips require optional spaCy/embedding models. Ten
interceptor skips cover POSIX filesystem/permission behavior unavailable
on Windows. Critical-suite skips require optional relevance models. The
existing token-count approximation warning remains visible in the gate
log. Initial broader runs failed because the new worktrees lacked the
native extension; these were rerun successfully after building it.

## Real Behavior Proof

- Environment: Windows 11, CPython 3.13.9, existing development venv;
clean baseline `200c838c7393d20ae56a0c338f832ed27133c398`, patch
`d0cc1d7abfd70cd36aaada3f633ef97f44041c3e`. `HEADROOM_OFFLINE=1`,
`PYTHONPATH=.` for the selected checkout. No paid/provider credentials.
- Exact command / steps: Save the following identical script as
`proof.py` and run `python proof.py` from either checkout. Before and
after runs were outside pytest.

```python
"""Production session preparation through the real Anthropic SDK to local HTTP."""
import copy
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import threading
from anthropic import Anthropic
from headroom.cache.compression_cache import CompressionCache
from headroom.proxy.session_engine import FREEZE_POLICY_REPLAYABLE, prepare_turn

captured = []

class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        captured.append(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))
        body = json.dumps({"id": "local", "type": "message", "role": "assistant",
            "model": "local-fixture", "content": [{"type": "text", "text": "received"}],
            "stop_reason": "end_turn", "stop_sequence": None,
            "usage": {"input_tokens": 1, "output_tokens": 1}}).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, *args):
        pass

server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
image = {"type": "image", "source": {"type": "base64", "media_type": "image/png",
    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl6LzsAAAAASUVORK5CYII="}}
reports = []
try:
    with Anthropic(api_key="local-fixture", base_url=f"http://127.0.0.1:{server.server_port}", max_retries=0) as client:
        for name, blocks in [
            ("mixed-image", [{"type": "text", "text": "records"}, image]),
            ("single-text", [{"type": "text", "text": "records", "cache_control": {"type": "ephemeral"}}]),
            ("textless-image", [image]),
        ]:
            cache = CompressionCache()
            cache.store_compressed(cache.content_hash("records"), "short", tokens_saved=1)
            messages = [
                {"role": "user", "content": "Read screenshot"},
                {"role": "assistant", "content": [{"type": "tool_use", "id": "t1", "name": "screenshot", "input": {}}]},
                {"role": "user", "content": [{"type": "tool_result", "tool_use_id": "t1", "content": blocks}]},
                {"role": "user", "content": "Continue"},
            ]
            snapshot = copy.deepcopy(messages)
            prep = prepare_turn(cache, messages, policy=FREEZE_POLICY_REPLAYABLE)
            response = client.messages.create(model="local-fixture", max_tokens=32, messages=prep.pipeline_input)
            forwarded = captured[-1]["messages"][2]["content"][0]["content"]
            reports.append({"case": name, "forwarded_blocks": forwarded,
                "frozen_count": prep.frozen_message_count, "input_unchanged": messages == snapshot,
                "http_response": response.content[0].text})
finally:
    server.shutdown()
    server.server_close()
    thread.join(5)
print(json.dumps(reports, indent=2))
```

- Observed result: On clean main, the real session preparation plus
Anthropic SDK sent only one text block for the mixed text/image result,
and dropped cache_control from the single text block. With this patch,
the local HTTP server receives both original mixed blocks, the
single-text replacement retains cache_control, and the caller's input
remains unchanged. The mixed message stops freezing at 2 instead of 3;
the textless-image control remains at 3.
- Not tested: Real Anthropic service/model traffic, billing, task
accuracy, multiple-result per-block cache redesign, and the complete
Python suite. The HTTP server is local and records the real SDK request;
it does not validate provider acceptance or model behavior.

## Runtime Rollout Safety

- Rollout-managed feature(s): Existing cache behavior; no new feature
flag or channel expansion.
- Minimum rollout channel: Normal release after maintainer review and CI
qualification.
- Stable/default behavior changed: Anthropic cached replay preserves
typed content and metadata. A layout that cannot be reconstructed is
left for the existing mutable pipeline instead of treated as safely
frozen.
- Kill switch / disable path: Use the existing cache-mode/session
configuration to avoid token-mode cached replay, or revert this patch.
- Unsafe override required: No.
- Qualification impact: Related cache tests and original local gates
passed; hosted CI is tracked separately.
- Rollback path: Revert this commit. No dependency or storage-schema
change.

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have added tests that prove the fix
- [x] Relevant new and existing tests pass locally
- [x] I did **not** edit `CHANGELOG.md`

## Additional Notes

Implementation and local validation were completed with Codex
assistance. The author reviewed the initial code and validation record;
the review follow-up was checked with Codex.

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/headroomlabs-ai/headroom/pull/4765"
target="_blank"><picture><source media="(prefers-color-scheme: dark)"
srcset="https://static.devin.ai/assets/gh-devin-review-dark.svg?v=4"><img
src="https://static.devin.ai/assets/gh-devin-review-light.svg?v=4"
alt="Devin Review"></picture></a>
<!-- devin-review-badge-end -->
2026-11-11 09:59:52 -06:00

564 lines
22 KiB
Python

"""Integration tests for token mode (legacy token_headroom behavior).
Tests the CompressionCache working across simulated multi-turn conversations,
verifying the critical invariants: no message injection, correct frozen counts,
proper handling of both Anthropic and OpenAI formats, and correct behavior
when Claude Code drops messages.
"""
import copy
from headroom.cache.compression_cache import CompressionCache
def _make_user_msg(text: str) -> dict:
return {"role": "user", "content": text}
def _make_assistant_msg(text: str) -> dict:
return {"role": "assistant", "content": text}
def _make_tool_use_msg(tool_id: str, name: str) -> dict:
return {
"role": "assistant",
"content": [{"type": "tool_use", "id": tool_id, "name": name, "input": {}}],
}
def _make_tool_result_msg(tool_id: str, content: str) -> dict:
"""Anthropic-format tool result."""
return {
"role": "user",
"content": [{"type": "tool_result", "tool_use_id": tool_id, "content": content}],
}
def _make_openai_tool_msg(tool_call_id: str, content: str) -> dict:
"""OpenAI-format tool result."""
return {"role": "tool", "tool_call_id": tool_call_id, "content": content}
def _large_code_content(n: int = 200) -> str:
"""Generate realistic Python code content."""
parts = ["import os\nimport sys\nfrom typing import List, Dict\n\n"]
for i in range(n // 10):
parts.append(
f"def function_{i}(arg: str) -> str:\n"
f' """Docstring for function {i}."""\n'
f" result = arg.strip()\n"
f" for j in range({i}):\n"
f" result += str(j)\n"
f" return result\n\n"
)
return "".join(parts)
class TestMultiTurnCompression:
"""Simulate multi-turn conversations to verify compression cascade."""
def test_first_turn_nothing_cached(self):
"""On first turn, no cache hits, frozen count is minimal."""
cache = CompressionCache()
messages = [
_make_user_msg("Read file.py"),
_make_tool_use_msg("t1", "Read"),
_make_tool_result_msg("t1", _large_code_content(100)),
]
frozen = cache.compute_frozen_count(messages)
# user (stable) + tool_use (stable) + tool_result (miss) → 2
assert frozen == 2
def test_second_turn_cache_hits(self):
"""After caching, same content gets cache hits."""
cache = CompressionCache()
code = _large_code_content(100)
compressed = "# compressed version"
# Simulate first turn: pipeline compressed the code
h = CompressionCache.content_hash(code)
cache.store_compressed(h, compressed, tokens_saved=500)
# Second turn: same messages
messages = [
_make_user_msg("Read file.py"),
_make_tool_use_msg("t1", "Read"),
_make_tool_result_msg("t1", code),
_make_user_msg("now edit it"),
]
frozen = cache.compute_frozen_count(messages)
# First 3 stable; trailing user message ("now edit it") is the
# live zone by construction — it has not been sent upstream
# before, so it cannot be in any provider prefix cache. Cap at
# len - 1 prevents the over-freeze pattern that produced 0 %
# compression for prose-format clients (issue observed
# 2026-05-07 with Cline+DeepSeek).
assert frozen == 3
# apply_cached should swap the content
result = cache.apply_cached(messages)
tool_result = result[2]["content"][0]
assert tool_result["content"] == compressed
def test_multi_turn_waterfall(self):
"""Messages age out progressively across turns."""
cache = CompressionCache()
# Build conversation with 3 read results
code_a = "code A " * 200
code_b = "code B " * 200
code_c = "code C " * 200
messages = [
_make_user_msg("read A"),
_make_tool_result_msg("t1", code_a),
_make_user_msg("read B"),
_make_tool_result_msg("t2", code_b),
_make_user_msg("read C"),
_make_tool_result_msg("t3", code_c),
]
# Turn 1: nothing cached
frozen = cache.compute_frozen_count(messages)
assert frozen == 1 # only first user msg
# Simulate pipeline compressing A and B (not C — in protection window)
cache.store_compressed(CompressionCache.content_hash(code_a), "ca", tokens_saved=100)
cache.store_compressed(CompressionCache.content_hash(code_b), "cb", tokens_saved=100)
# Turn 2: A and B cached, C still uncached
frozen = cache.compute_frozen_count(messages)
# user(stable) + tool_result_A(cached) + user(stable) + tool_result_B(cached) + user(stable) + tool_result_C(miss)
assert frozen == 5
# Now cache C too
cache.store_compressed(CompressionCache.content_hash(code_c), "cc", tokens_saved=100)
# Turn 3: all 6 messages structurally stable, but the trailing
# message is reserved as live zone. Frozen prefix = 5.
frozen = cache.compute_frozen_count(messages)
assert frozen == 5
class TestNoMessageInjection:
"""Critical invariant: proxy never adds messages."""
def test_output_length_equals_input(self):
cache = CompressionCache()
messages = [
_make_user_msg("hello"),
_make_tool_result_msg("t1", _large_code_content(50)),
_make_user_msg("bye"),
]
result = cache.apply_cached(messages)
assert len(result) == len(messages)
def test_orphan_cache_entries_not_injected(self):
"""Cache entries with no matching message are NOT injected."""
cache = CompressionCache()
cache.store_compressed("orphan_hash_1", "orphan content 1", tokens_saved=100)
cache.store_compressed("orphan_hash_2", "orphan content 2", tokens_saved=200)
messages = [_make_user_msg("hello")]
result = cache.apply_cached(messages)
assert len(result) == 1
assert result[0]["content"] == "hello"
def test_input_not_mutated(self):
"""apply_cached must NOT mutate the input list or messages."""
cache = CompressionCache()
code = "original code content"
h = CompressionCache.content_hash(code)
cache.store_compressed(h, "compressed", tokens_saved=50)
messages = [
_make_tool_result_msg("t1", code),
]
original = copy.deepcopy(messages)
cache.apply_cached(messages)
assert messages == original
class TestClaudeCodeDropsMessages:
"""When Claude Code drops messages via its own context management."""
def test_dropped_messages_not_readded(self):
cache = CompressionCache()
content_a = "content A " * 100
content_b = "content B " * 100
cache.store_compressed(CompressionCache.content_hash(content_a), "ca", tokens_saved=100)
cache.store_compressed(CompressionCache.content_hash(content_b), "cb", tokens_saved=100)
# CC dropped the message with content_b
messages = [
_make_user_msg("hello"),
_make_tool_result_msg("t1", content_a),
_make_user_msg("continue"),
]
result = cache.apply_cached(messages)
assert len(result) == 3 # NOT 4
def test_frozen_count_breaks_at_gap(self):
"""Dropped cached message creates a gap that stops frozen count."""
cache = CompressionCache()
content_a = "content A " * 100
content_c = "content C " * 100
cache.store_compressed(CompressionCache.content_hash(content_a), "ca", tokens_saved=100)
cache.store_compressed(CompressionCache.content_hash(content_c), "cc", tokens_saved=100)
# CC dropped content_b, content_c is still here but preceded by uncached gap
messages = [
_make_tool_result_msg("t1", content_a),
_make_tool_result_msg("t2", "UNCACHED content_b replacement"),
_make_tool_result_msg("t3", content_c),
]
frozen = cache.compute_frozen_count(messages)
# t1 (cached, stable), t2 (NOT cached, stop)
assert frozen == 1
class TestOpenAIFormat:
"""Verify OpenAI-format tool messages work correctly."""
def test_openai_tool_result_cached(self):
cache = CompressionCache()
content = "large openai output " * 100
h = CompressionCache.content_hash(content)
cache.store_compressed(h, "compressed openai output", tokens_saved=300)
messages = [
_make_user_msg("run command"),
{
"role": "assistant",
"content": None,
"tool_calls": [
{
"id": "tc1",
"type": "function",
"function": {"name": "bash", "arguments": "{}"},
}
],
},
_make_openai_tool_msg("tc1", content),
]
result = cache.apply_cached(messages)
assert len(result) == 3
assert result[2]["content"] == "compressed openai output"
def test_openai_frozen_count(self):
cache = CompressionCache()
content = "openai tool output " * 100
h = CompressionCache.content_hash(content)
cache.store_compressed(h, "compressed", tokens_saved=200)
messages = [
_make_user_msg("hello"),
_make_openai_tool_msg("tc1", content),
_make_openai_tool_msg("tc2", "uncached content"),
]
frozen = cache.compute_frozen_count(messages)
# user (stable), tool tc1 (cached), tool tc2 (miss)
assert frozen == 2
class TestUpdateFromResult:
"""Verify update_from_result correctly caches compression results."""
def test_caches_compressed_anthropic(self):
cache = CompressionCache()
original_content = "long original " * 100
compressed_content = "short compressed"
originals = [
_make_user_msg("hello"),
_make_tool_result_msg("t1", original_content),
]
compressed = [
_make_user_msg("hello"),
_make_tool_result_msg("t1", compressed_content),
]
cache.update_from_result(originals, compressed)
h = CompressionCache.content_hash(original_content)
assert cache.get_compressed(h) == compressed_content
def test_caches_compressed_openai(self):
cache = CompressionCache()
original_content = "long openai output " * 100
compressed_content = "short compressed"
originals = [_make_openai_tool_msg("tc1", original_content)]
compressed = [_make_openai_tool_msg("tc1", compressed_content)]
cache.update_from_result(originals, compressed)
h = CompressionCache.content_hash(original_content)
assert cache.get_compressed(h) == compressed_content
def test_length_mismatch_no_crash(self):
"""If pipeline somehow changes message count, don't crash."""
cache = CompressionCache()
originals = [_make_user_msg("a"), _make_user_msg("b")]
compressed = [_make_user_msg("a")] # shorter
# Should not raise, just log warning
cache.update_from_result(originals, compressed)
assert cache.get_stats()["entries"] == 0
def test_unchanged_content_not_cached(self):
cache = CompressionCache()
msg = _make_user_msg("same content")
cache.update_from_result([msg], [msg])
assert cache.get_stats()["entries"] == 0
class TestProseFormatLiveZoneInvariant:
"""Cline / OpenClaude / Aider — prose-format clients send tool calls
embedded in plain assistant text and tool results pasted into plain
user messages. There are no `tool_use`, `tool_result`, or
``role: "tool"`` blocks anywhere in the conversation.
Pre-fix: ``compute_frozen_count`` walked all messages and found no
"unstable" boundary, returning ``len(messages)``. The pipeline then
froze every message — including the brand-new user turn — leaving
the live zone empty. ContentRouter saw ``saved 0`` on every request.
Bug observed 2026-05-07 with Cline+DeepSeek over /v1/chat/completions
in token mode.
Post-fix: cap at ``len(messages) - 1`` always reserves the trailing
message as the live zone. These tests lock that invariant.
"""
def test_pure_user_assistant_turns_leave_live_zone(self):
cache = CompressionCache()
# A 6-turn Cline-shaped conversation: alternating user/assistant
# plain-text. No tool blocks of any kind.
messages = [
_make_user_msg("system instructions baked into first user msg"),
_make_assistant_msg("<execute_command>ls</execute_command>"),
_make_user_msg("[tool_result]\nfile1.py\nfile2.py\n[/tool_result]"),
_make_assistant_msg("<read_file>file1.py</read_file>"),
_make_user_msg("[tool_result]\n<contents...>\n[/tool_result]"),
_make_user_msg("now please refactor it"),
]
frozen = cache.compute_frozen_count(messages)
# Pre-fix would return 6 (every plain message is "stable").
# Post-fix: 6 messages stable, capped at len-1 = 5.
assert frozen == 5
assert frozen < len(messages), (
"Live zone must never be empty; trailing user message must "
"always be available for compression"
)
def test_single_message_yields_zero_frozen(self):
# Edge case: only the user's first message, nothing to freeze.
cache = CompressionCache()
messages = [_make_user_msg("first turn")]
assert cache.compute_frozen_count(messages) == 0
def test_empty_messages_yields_zero(self):
cache = CompressionCache()
assert cache.compute_frozen_count([]) == 0
def test_two_messages_first_is_frozen_second_is_live(self):
cache = CompressionCache()
messages = [
_make_user_msg("turn 1 content"),
_make_user_msg("turn 2 — the live zone"),
]
# First message structurally stable; trailing is live → 1 frozen.
assert cache.compute_frozen_count(messages) == 1
def test_anthropic_format_last_tool_result_is_still_live(self):
"""Even when the trailing message is a tool_result whose content
IS in the cache, it stays in the live zone. Trailing == live by
construction; the cache-read decision is upstream's job."""
cache = CompressionCache()
code = _large_code_content(50)
cache.store_compressed(
CompressionCache.content_hash(code), "compressed code", tokens_saved=200
)
messages = [
_make_user_msg("hi"),
_make_assistant_msg("ok"),
_make_tool_result_msg("t1", code),
]
frozen = cache.compute_frozen_count(messages)
# Walk gets to 3, cap clamps to 2 (= len-1).
assert frozen == 2
def test_openai_format_last_tool_msg_is_live(self):
cache = CompressionCache()
content = "tool output " * 100
cache.store_compressed(
CompressionCache.content_hash(content), "compressed", tokens_saved=300
)
messages = [
_make_user_msg("run cmd"),
_make_openai_tool_msg("tc1", content),
]
# Walk: user (stable, 1), tool (cached, 2). Cap → 1.
assert cache.compute_frozen_count(messages) == 1
# ── List-of-blocks tool_result content (Claude Code modern format) ──────────
def _make_tool_result_list_content_msg(tool_id: str, texts: list[str]) -> dict:
"""Anthropic-format tool result with list-of-blocks content.
Modern Claude Code sends ``tool_result`` content as a list of typed
blocks instead of a plain string.
"""
return {
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": tool_id,
"content": [{"type": "text", "text": t} for t in texts],
}
],
}
def _make_openai_tool_list_content_msg(tool_call_id: str, texts: list[str]) -> dict:
"""OpenAI-format tool message with list-of-blocks content."""
return {
"role": "tool",
"tool_call_id": tool_call_id,
"content": [{"type": "text", "text": t} for t in texts],
}
class TestExtractToolResultListContent:
"""_extract_tool_result_content handles list-of-blocks content."""
def test_anthropic_string_content_preserved(self):
"""Plain string content in Anthropic format still works."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = _make_tool_result_msg("t1", "hello world")
assert f(msg) == "hello world"
def test_anthropic_list_content_extracted(self):
"""List-of-blocks content is extracted and joined."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = _make_tool_result_list_content_msg("t1", ["Line 1", "Line 2"])
assert f(msg) == "Line 1\nLine 2"
def test_anthropic_mixed_blocks(self):
"""Non-text blocks (e.g. image) are skipped, only text blocks joined."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = {
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "t1",
"content": [
{"type": "text", "text": "Hello"},
{"type": "image", "source": {"type": "base64", "data": "..."}},
{"type": "text", "text": "World"},
],
}
],
}
assert f(msg) == "Hello\nWorld"
def test_anthropic_list_empty_returns_none(self):
"""Empty text-only list returns None."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = {
"role": "user",
"content": [{"type": "tool_result", "tool_use_id": "t1", "content": []}],
}
assert f(msg) is None
def test_openai_list_content_extracted(self):
"""OpenAI format tool message with list content is extracted."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = _make_openai_tool_list_content_msg("tc1", ["Result 1", "Result 2"])
assert f(msg) == "Result 1\nResult 2"
def test_openai_string_content_still_works(self):
"""OpenAI format with plain string content is unchanged."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
msg = _make_openai_tool_msg("tc1", "plain result")
assert f(msg) == "plain result"
def test_non_tool_msg_returns_none(self):
"""Regular user/assistant messages return None."""
from headroom.cache.compression_cache import _extract_tool_result_content as f
assert f(_make_user_msg("hello")) is None
assert f(_make_assistant_msg("response")) is None
class TestSwapToolResultListContent:
"""_swap_tool_result_content preserves list-of-blocks structure."""
def test_swap_anthropic_list_content_preserves_structure(self):
"""Swap on list-of-blocks content replaces text in place."""
from headroom.cache.compression_cache import _swap_tool_result_content
msg = _make_tool_result_list_content_msg("t1", ["original"])
swapped = _swap_tool_result_content(msg, "compressed")
inner = swapped["content"][0]["content"]
assert isinstance(inner, list)
assert inner[0]["type"] == "text"
assert inner[0]["text"] == "compressed"
def test_swap_anthropic_string_content_preserved(self):
"""Swap on plain-string content still works."""
from headroom.cache.compression_cache import _swap_tool_result_content
msg = _make_tool_result_msg("t1", "original")
swapped = _swap_tool_result_content(msg, "compressed")
assert swapped["content"][0]["content"] == "compressed"
def test_swap_openai_list_content(self):
"""Swap on OpenAI list-content replaces text."""
from headroom.cache.compression_cache import _swap_tool_result_content
msg = _make_openai_tool_list_content_msg("tc1", ["original"])
msg["content"][0]["cache_control"] = {"type": "ephemeral"}
swapped = _swap_tool_result_content(msg, "compressed")
assert swapped["content"] == [
{"type": "text", "text": "compressed", "cache_control": {"type": "ephemeral"}}
]
assert msg["content"][0]["text"] == "original"
def test_swap_does_not_mutate_original(self):
"""_swap_tool_result_content performs a deep copy."""
from headroom.cache.compression_cache import _swap_tool_result_content
msg = _make_tool_result_list_content_msg("t1", ["original"])
_swap_tool_result_content(msg, "compressed")
assert msg["content"][0]["content"][0]["text"] == "original"
def test_swap_list_content_without_text_preserves_image(self):
"""A text replacement must not erase an image-only result."""
from headroom.cache.compression_cache import _swap_tool_result_content
msg = {
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "t1",
"content": [{"type": "image", "source": {"type": "base64", "data": "..."}}],
}
],
}
swapped = _swap_tool_result_content(msg, "compressed")
assert swapped == msg
assert swapped is not msg
assert swapped["content"][0]["content"] is not msg["content"][0]["content"]