mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 18:41:07 +08:00
## 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 -->
564 lines
22 KiB
Python
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"]
|