virtual-context 0.2.4__tar.gz → 0.2.6__tar.gz

{virtual_context-0.2.4 → virtual_context-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.2.4
+Version: 0.2.6
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context
@@ -19,6 +19,7 @@ Requires-Dist: fastapi>=0.115
 Requires-Dist: httpx>=0.27
 Requires-Dist: mcp>=1.0
 Requires-Dist: openai>=1.50
+Requires-Dist: pillow>=10.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0
 Requires-Dist: sentence-transformers>=3.0

{virtual_context-0.2.4 → virtual_context-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.2.4"
+version = "0.2.6"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -30,6 +30,7 @@ dependencies = [
     "mcp>=1.0",
     "textual>=3.0",
     "rich>=13.0",
+    "Pillow>=10.0",
 ]
 
 [project.optional-dependencies]

virtual_context-0.2.6/tests/test_budget_enforcement.py

@@ -0,0 +1,560 @@
+import copy
+import json
+import pytest
+from virtual_context.proxy.message_filter import scan_reducible_items, apply_reduction, ReducibleItem, enforce_payload_budget
+from virtual_context.proxy.formats import detect_format
+
+
+def _make_payload(messages, system=None, tools=None):
+    body = {"model": "claude-sonnet-4-6", "messages": messages}
+    if system:
+        body["system"] = system
+    if tools:
+        body["tools"] = tools
+    return body
+
+
+class TestScanReducibleItems:
+    def test_finds_thinking_signatures(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "A" * 4000},
+                {"type": "text", "text": "hi there"},
+            ]},
+            {"role": "user", "content": "bye"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        thinking_items = [i for i in items if i.category == "thinking_sig"]
+        assert len(thinking_items) == 1
+        assert thinking_items[0].msg_index == 1
+        assert thinking_items[0].block_index == 0
+        assert thinking_items[0].size_bytes > 0
+
+    def test_finds_tool_results(self):
+        # Need 3+ turn groups so the tool result falls outside the last-2 window.
+        msgs = [
+            {"role": "user", "content": "old question"},
+            {"role": "assistant", "content": "old answer"},
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+            {"role": "user", "content": "thanks"},
+            {"role": "assistant", "content": "welcome"},
+            {"role": "user", "content": "current"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        tr_items = [i for i in items if i.category == "tool_result"]
+        assert len(tr_items) == 1
+        assert tr_items[0].msg_index == 4
+
+    def test_last_2_turns_tool_results_categorized_separately(self):
+        msgs = [
+            {"role": "user", "content": "old"},
+            {"role": "assistant", "content": "old response"},
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+            {"role": "user", "content": "thanks"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        last2_items = [i for i in items if i.category == "tool_result_last2"]
+        assert len(last2_items) == 1
+
+    def test_finds_conversation_text(self):
+        msgs = [
+            {"role": "user", "content": "hello " * 1000},
+            {"role": "assistant", "content": "response " * 1000},
+            {"role": "user", "content": "bye"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        text_items = [i for i in items if i.category == "conversation_text"]
+        assert len(text_items) >= 2
+
+    def test_finds_vc_context_block(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"},
+        ]
+        system = [
+            {"type": "text", "text": "You are Claude Code."},
+            {"type": "text", "text": "<system-reminder>\n<context-topics>VC content here</context-topics>\n</system-reminder>"},
+        ]
+        body = _make_payload(msgs, system=system)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        vc_items = [i for i in items if i.category == "vc_context"]
+        assert len(vc_items) == 1
+
+    def test_skips_compacted_stubs(self):
+        msgs = [
+            {"role": "user", "content": "[Compacted turn 0]"},
+            {"role": "assistant", "content": [{"type": "text", "text": "[Compacted turn 0 | topics=foo | Read(...).\\nTo restore: ...]"}]},
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        for item in items:
+            assert item.category != "compacted_stub"
+
+    def test_skips_system_prompt_non_vc(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"},
+        ]
+        system = [{"type": "text", "text": "You are Claude Code. " * 500}]
+        body = _make_payload(msgs, system=system)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        categories = {i.category for i in items}
+        assert "system_prompt" not in categories
+
+    def test_finds_large_image_blocks(self):
+        msgs = [
+            {"role": "user", "content": [
+                {"type": "image", "source": {"type": "base64", "data": "A" * 50000}},
+                {"type": "text", "text": "what is this?"},
+            ]},
+            {"role": "assistant", "content": "It's an image."},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        image_items = [i for i in items if i.category == "image"]
+        assert len(image_items) == 1
+        assert image_items[0].size_bytes == 50000
+
+    def test_skips_small_image_blocks(self):
+        msgs = [
+            {"role": "user", "content": [
+                {"type": "image", "source": {"type": "base64", "data": "A" * 100}},
+            ]},
+            {"role": "assistant", "content": "tiny image."},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        assert not any(i.category == "image" for i in items)
+
+    def test_finds_openai_responses_tool_outputs(self):
+        body = {"model": "gpt-5", "input": [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "calling"}]},
+            {"type": "function_call", "call_id": "fc1", "name": "read", "arguments": "{}"},
+            {"type": "function_call_output", "call_id": "fc1", "output": "x" * 10000},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "done"}]},
+            {"role": "user", "content": "thanks"},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        tr_items = [i for i in items if i.category in ("tool_result", "tool_result_last2")]
+        assert len(tr_items) == 1
+        assert tr_items[0].msg_index == 3
+
+    def test_finds_openai_chat_tool_outputs(self):
+        body = {"model": "gpt-4", "messages": [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": None, "tool_calls": [
+                {"id": "t1", "type": "function", "function": {"name": "read", "arguments": "{}"}}
+            ]},
+            {"role": "tool", "tool_call_id": "t1", "content": "x" * 10000},
+            {"role": "assistant", "content": "done"},
+            {"role": "user", "content": "thanks"},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        tr_items = [i for i in items if i.category in ("tool_result", "tool_result_last2")]
+        assert len(tr_items) == 1
+        assert tr_items[0].msg_index == 2
+
+    def test_finds_openai_responses_conversation_text(self):
+        """Verify we find text in output_text blocks, not just string content."""
+        body = {"model": "gpt-5", "input": [
+            {"role": "user", "content": "msg " + "x" * 2000},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "resp " + "y" * 2000}]},
+            {"role": "user", "content": "current"},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        text_items = [i for i in items if i.category == "conversation_text"]
+        # Should find both the user string content AND the assistant output_text block
+        assert len(text_items) >= 2
+
+
+class TestApplyReduction:
+    def test_remove_thinking_signature(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "A" * 4000},
+                {"type": "text", "text": "response"},
+            ]},
+        ]
+        body = {"model": "claude-sonnet-4-6", "messages": msgs}
+        item = ReducibleItem(msg_index=1, block_index=0, category="thinking_sig",
+                             size_bytes=4000, location="messages")
+        freed = apply_reduction(body, item, detect_format(body))
+        assert freed > 0
+        content = body["messages"][1]["content"]
+        assert not any(b.get("type") == "thinking" for b in content)
+
+    def test_stub_tool_result(self):
+        msgs = [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {"file_path": "/tmp/x"}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+            {"role": "user", "content": "thanks"},
+        ]
+        body = {"model": "claude-sonnet-4-6", "messages": msgs}
+        item = ReducibleItem(msg_index=2, block_index=0, category="tool_result",
+                             size_bytes=10000, location="messages")
+        freed = apply_reduction(body, item, detect_format(body), store=None)
+        assert freed > 0
+        tr = body["messages"][2]["content"][0]
+        assert "vc_restore_tool" in tr.get("content", "") or len(tr.get("content", "")) < 500
+
+    def test_truncate_tool_result_last2(self):
+        msgs = [
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+        ]
+        body = {"model": "claude-sonnet-4-6", "messages": msgs}
+        item = ReducibleItem(msg_index=0, block_index=0, category="tool_result_last2",
+                             size_bytes=10000, location="messages")
+        freed = apply_reduction(body, item, detect_format(body))
+        assert freed > 0
+        tr = body["messages"][0]["content"][0]
+        assert len(tr.get("content", "")) < 10000
+
+    def test_truncate_conversation_text_string(self):
+        msgs = [
+            {"role": "user", "content": "hello " * 2000},
+            {"role": "assistant", "content": "bye"},
+        ]
+        body = {"model": "claude-sonnet-4-6", "messages": msgs}
+        item = ReducibleItem(msg_index=0, block_index=-1, category="conversation_text",
+                             size_bytes=12000, location="messages")
+        freed = apply_reduction(body, item, detect_format(body))
+        assert freed > 0
+        assert len(body["messages"][0]["content"]) < 12000
+
+    def test_truncate_vc_context(self):
+        system = [
+            {"type": "text", "text": "You are Claude Code."},
+            {"type": "text", "text": "<system-reminder>\n<context-topics>" + "x" * 10000 + "</context-topics>\n</system-reminder>"},
+        ]
+        body = {"model": "claude-sonnet-4-6", "messages": [{"role": "user", "content": "hi"}], "system": system}
+        item = ReducibleItem(msg_index=-1, block_index=1, category="vc_context",
+                             size_bytes=10050, location="system")
+        freed = apply_reduction(body, item, detect_format(body))
+        assert freed > 0
+        assert len(body["system"][1]["text"]) < 10050
+
+    def test_compress_image(self):
+        import base64
+        from io import BytesIO
+        try:
+            from PIL import Image
+        except ImportError:
+            pytest.skip("Pillow not installed")
+        img = Image.new("RGB", (2000, 2000), color="red")
+        buf = BytesIO()
+        img.save(buf, format="PNG")
+        b64_data = base64.b64encode(buf.getvalue()).decode("ascii")
+        msgs = [
+            {"role": "user", "content": [
+                {"type": "image", "source": {"type": "base64", "data": b64_data, "media_type": "image/png"}},
+                {"type": "text", "text": "what is this?"},
+            ]},
+            {"role": "assistant", "content": "red square"},
+        ]
+        body = _make_payload(msgs)
+        item = ReducibleItem(msg_index=0, block_index=0, category="image",
+                             size_bytes=len(b64_data), location="messages")
+        freed = apply_reduction(body, item, detect_format(body))
+        assert freed > 0
+        assert body["messages"][0]["content"][0]["source"]["media_type"] == "image/jpeg"
+        assert len(body["messages"][0]["content"][0]["source"]["data"]) < len(b64_data)
+        new_data = base64.b64decode(body["messages"][0]["content"][0]["source"]["data"])
+        new_img = Image.open(BytesIO(new_data))
+        assert new_img.width <= 1024
+        assert new_img.height <= 1024
+
+
+class TestEnforcePayloadBudget:
+    def _fmt(self):
+        fmt = detect_format({"model": "claude-sonnet-4-6", "messages": []})
+        fmt_copy = copy.copy(fmt)
+        fmt_copy.set_token_counter(lambda text: len(text) // 4)
+        return fmt_copy
+
+    def test_no_reduction_when_under_budget(self):
+        body = _make_payload([
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": "hi"},
+        ])
+        fmt = self._fmt()
+        result, reductions, freed = enforce_payload_budget(body, fmt, 100000)
+        assert reductions == 0
+        assert freed == 0
+
+    def test_reduces_until_under_budget(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "A" * 8000},
+                {"type": "text", "text": "response"},
+            ]},
+            {"role": "user", "content": "more"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "B" * 8000},
+                {"type": "text", "text": "more response"},
+            ]},
+            {"role": "user", "content": "bye"},
+        ]
+        body = _make_payload(msgs)
+        fmt = self._fmt()
+        total_before = fmt._count(json.dumps(body))
+        budget = total_before - 2000
+        result, reductions, freed = enforce_payload_budget(body, fmt, budget)
+        total_after = fmt._count(json.dumps(result))
+        assert total_after <= budget
+        assert reductions > 0
+        assert freed > 0
+
+    def test_targets_largest_first(self):
+        msgs = [
+            {"role": "user", "content": "hello"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "A" * 2000},
+                {"type": "text", "text": "response"},
+            ]},
+            {"role": "user", "content": "more"},
+            {"role": "assistant", "content": [
+                {"type": "thinking", "thinking": "", "signature": "B" * 8000},
+                {"type": "text", "text": "more"},
+            ]},
+            {"role": "user", "content": "bye"},
+        ]
+        body = _make_payload(msgs)
+        fmt = self._fmt()
+        total = fmt._count(json.dumps(body))
+        budget = total - 1000
+        result, reductions, freed = enforce_payload_budget(body, fmt, budget)
+        content_3 = result["messages"][3]["content"]
+        has_thinking_3 = any(b.get("type") == "thinking" for b in content_3)
+        assert not has_thinking_3
+
+    def test_respects_max_iterations(self):
+        msgs = []
+        for i in range(300):
+            msgs.append({"role": "user", "content": "x" * 500})
+            msgs.append({"role": "assistant", "content": "y" * 500})
+        body = _make_payload(msgs)
+        fmt = self._fmt()
+        result, reductions, freed = enforce_payload_budget(body, fmt, 1)
+        assert reductions <= 200
+
+    def test_returns_unchanged_when_nothing_reducible(self):
+        body = _make_payload([
+            {"role": "user", "content": "hi"},
+            {"role": "assistant", "content": "bye"},
+        ])
+        fmt = self._fmt()
+        result, reductions, freed = enforce_payload_budget(body, fmt, 1)
+        assert reductions == 0
+
+    def test_terminates_when_largest_not_reducible(self):
+        msgs = [
+            {"role": "user", "content": "x" * 200},
+            {"role": "assistant", "content": "y" * 200},
+        ]
+        body = _make_payload(msgs)
+        fmt = self._fmt()
+        result, reductions, freed = enforce_payload_budget(body, fmt, 1)
+        assert reductions <= 2
+
+    def test_reduces_openai_responses_payload(self):
+        items = []
+        for i in range(20):
+            items.append({"role": "user", "content": "msg " + "x" * 2000})
+            items.append({"role": "assistant", "content": [{"type": "output_text", "text": "resp " + "y" * 2000}]})
+        items.append({"role": "user", "content": "current"})
+        body = {"model": "gpt-5", "input": items}
+        fmt = detect_format(body)
+        fmt_copy = copy.copy(fmt)
+        fmt_copy.set_token_counter(lambda text: len(text) // 4)
+        result, reductions, freed = enforce_payload_budget(body, fmt_copy, 5000)
+        assert reductions > 0
+
+
+class TestSmallPayloadProtection:
+    """P1-1: With 1-2 turn groups, ALL tool results must be in the last2 protected window."""
+
+    def test_single_tool_turn_all_protected(self):
+        """A payload with one tool chain turn — tool result must be tool_result_last2."""
+        msgs = [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        tr_items = [i for i in items if i.category.startswith("tool_result")]
+        assert len(tr_items) == 1
+        # With only 1 turn group, the tool result must be in the protected window.
+        assert tr_items[0].category == "tool_result_last2"
+
+    def test_two_turns_all_protected(self):
+        """A payload with 2 turn groups — tool results in both must be last2."""
+        msgs = [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+            {"role": "user", "content": "thanks"},
+            {"role": "assistant", "content": "welcome"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        tr_items = [i for i in items if i.category.startswith("tool_result")]
+        assert len(tr_items) == 1
+        assert tr_items[0].category == "tool_result_last2"
+
+    def test_no_unprotected_tool_results_with_small_payload(self):
+        """With <=2 turns, no tool_result items should exist in the unprotected category."""
+        msgs = [
+            {"role": "user", "content": "do something"},
+            {"role": "assistant", "content": [
+                {"type": "tool_use", "id": "t1", "name": "Read", "input": {}},
+            ]},
+            {"role": "user", "content": [
+                {"type": "tool_result", "tool_use_id": "t1", "content": "x" * 10000},
+            ]},
+            {"role": "assistant", "content": [{"type": "text", "text": "done"}]},
+            {"role": "user", "content": "current"},
+        ]
+        body = _make_payload(msgs)
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        unprotected = [i for i in items if i.category == "tool_result"]
+        assert len(unprotected) == 0
+
+
+class TestGeminiMediaScan:
+    """P1-3: Gemini inline_data images must be detected by scan_reducible_items."""
+
+    def test_finds_gemini_inline_data_image(self):
+        body = {"contents": [
+            {"role": "user", "parts": [
+                {"inline_data": {"mime_type": "image/png", "data": "A" * 50000}},
+                {"text": "what is this?"},
+            ]},
+            {"role": "model", "parts": [{"text": "It is an image."}]},
+            {"role": "user", "parts": [{"text": "q2"}]},
+            {"role": "model", "parts": [{"text": "a2"}]},
+            {"role": "user", "parts": [{"text": "current"}]},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        image_items = [i for i in items if i.category == "image"]
+        assert len(image_items) == 1
+        assert image_items[0].size_bytes == 50000
+
+    def test_skips_small_gemini_image(self):
+        body = {"contents": [
+            {"role": "user", "parts": [
+                {"inline_data": {"mime_type": "image/png", "data": "A" * 100}},
+            ]},
+            {"role": "model", "parts": [{"text": "tiny."}]},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        assert not any(i.category == "image" for i in items)
+
+
+class TestResponsesInputImageScan:
+    """P1-2: OpenAI Responses input_image blocks must be yielded by iter_media_blocks."""
+
+    def test_iter_media_blocks_finds_input_image(self):
+        body = {"model": "gpt-5", "input": [
+            {"role": "user", "content": [
+                {"type": "input_image", "image_url": f"data:image/png;base64,{'A' * 50000}"},
+                {"type": "input_text", "text": "describe this"},
+            ]},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "a photo"}]},
+        ]}
+        fmt = detect_format(body)
+        media_blocks = list(fmt.iter_media_blocks(body))
+        assert len(media_blocks) == 1
+        assert media_blocks[0].msg_index == 0
+        assert media_blocks[0].block_index == 0
+
+    def test_input_image_replace_uses_input_text_for_user(self):
+        body = {"model": "gpt-5", "input": [
+            {"role": "user", "content": [
+                {"type": "input_image", "image_url": f"data:image/png;base64,{'A' * 50000}"},
+            ]},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "done"}]},
+        ]}
+        fmt = detect_format(body)
+        for media_info in fmt.iter_media_blocks(body):
+            media_info.replace_with_text("[image removed]")
+            break
+        replaced = body["input"][0]["content"][0]
+        assert replaced["type"] == "input_text"
+        assert replaced["text"] == "[image removed]"
+
+    def test_scan_finds_input_image_as_image_category(self):
+        body = {"model": "gpt-5", "input": [
+            {"role": "user", "content": [
+                {"type": "input_image", "image_url": f"data:image/png;base64,{'A' * 50000}"},
+            ]},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "a photo"}]},
+            {"role": "user", "content": "q2"},
+            {"role": "assistant", "content": [{"type": "output_text", "text": "a2"}]},
+            {"role": "user", "content": "current"},
+        ]}
+        fmt = detect_format(body)
+        items = scan_reducible_items(body, fmt)
+        image_items = [i for i in items if i.category == "image"]
+        assert len(image_items) == 1
+        assert image_items[0].size_bytes == 50000