witbitz-code 1.6.9__tar.gz → 1.6.10__tar.gz

{witbitz_code-1.6.9/src/witbitz_code.egg-info → witbitz_code-1.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.9
+Version: 1.6.10
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -19,6 +19,7 @@ Requires-Dist: websockets>=13
 Requires-Dist: httpx>=0.25
 Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
+Requires-Dist: pillow>=10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pyflakes>=3; extra == "test"

{witbitz_code-1.6.9 → witbitz_code-1.6.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.6.9"
+version = "1.6.10"
 description = "Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,6 +26,8 @@ dependencies = [
   # Tinfoil's own verifier (attestation + Sigstore + TLS pinning) — the confidential proxy reads images and files a
   # text-only confidential model cannot, in Tinfoil's attested enclave (tinfoil_read.py). Pinned to a series on purpose.
   "tinfoil>=0.14,<0.15",
+  # Older screenshots are re-encoded smaller before a request leaves (images.py): TrustedRouter drops a ~10 MB request.
+  "pillow>=10",
 ]
 
 [project.optional-dependencies]

{witbitz_code-1.6.9 → witbitz_code-1.6.10}/src/witbitz_code/__init__.py

@@ -4,4 +4,4 @@ The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phas
 vectors and cross-implementation tests.
 """
 
-__version__ = "1.6.9"
+__version__ = "1.6.10"

{witbitz_code-1.6.9 → witbitz_code-1.6.10}/src/witbitz_code/confidential.py

@@ -26,7 +26,7 @@ from typing import Any, Callable
 
 import httpx
 
-from . import keys, models as mdl, receipt as rcp, tinfoil_read
+from . import images, keys, models as mdl, receipt as rcp, tinfoil_read
 from .gateway import verify_gateway_attestation
 
 TR_UPSTREAM = "https://api.trustedrouter.com"
@@ -577,6 +577,12 @@ class ConfidentialProxy:
                 return
             req.headers = [(k, v) for k, v in req.headers if k.lower() not in ("authorization", "x-api-key")] + [("authorization", "Bearer " + cred["trustedrouter"])]
             tinfoil = cred.get("tinfoil") or ""
+        if isinstance(body, dict):
+            shrunk, rep = await asyncio.to_thread(images.shrink_older_images, body)
+            if shrunk is not body:
+                body, req.body = shrunk, dumps(shrunk).encode("utf-8")
+                if rep["dropped"]:
+                    self.log(f"code-confidential: the request was {rep['before'] // 1024} KB; {rep['dropped']} older screenshot(s) left out to send it")
         conf = self.models.get(body.get("model")) if isinstance(body, dict) and isinstance(body.get("model"), str) else None
         if not conf:
             await self._pass_through(req, res, body, target)

witbitz_code-1.6.10/src/witbitz_code/images.py

@@ -0,0 +1,125 @@
+"""OLDER IMAGES ARE SHRUNK BEFORE A REQUEST LEAVES THIS COMPUTER.
+
+OpenCode sends the whole conversation on every call, and every screenshot in it rides along as a full base64 PNG. A model
+reads an image as a fixed number of tokens whatever its bytes, so the context stays small while the REQUEST grows with each
+screenshot — and TrustedRouter drops a request of about 10 MB without answering (measured 2026-10-12: 9 MB answered,
+10 MB closed the connection; a session with 18 screenshots reached 11 MB and every message in it failed).
+
+So: the newest KEEP_FULL images go as they are; every older one is re-encoded as a JPEG no larger than MAX_SIDE on its
+longest side. A screenshot of ~1 MB becomes ~100–200 KB and still reads. The result is cached by content, so the same old
+screenshot shrinks to the same bytes on every call (a provider's prompt cache keeps working from there on). If the request
+is STILL over BUDGET, the oldest images are replaced by a one-line note, newest kept — a request that cannot be sent helps
+no one. No image library, or an image it cannot decode: that image is left as it is (the budget rule still applies).
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import json
+import re
+from collections import OrderedDict
+from typing import Any
+
+KEEP_FULL = 3
+MAX_SIDE = 1280
+JPEG_QUALITY = 70
+BUDGET = 8 * 1024 * 1024  # bytes of request body; TrustedRouter's limit is ~10 MB
+CACHE_MAX = 256
+_DATA_URL = re.compile(r"^data:([^;,]+)?(?:;[^,]*)?;base64,(.*)$", re.S)
+
+_cache: "OrderedDict[str, str | None]" = OrderedDict()
+
+
+def _image_parts(body: dict) -> list[tuple[int, int]]:
+    """(message, part) of every inline image, oldest first."""
+    out = []
+    for mi, msg in enumerate(body.get("messages") or []):
+        content = msg.get("content") if isinstance(msg, dict) else None
+        if not isinstance(content, list):
+            continue
+        for pi, part in enumerate(content):
+            if isinstance(part, dict) and part.get("type") == "image_url" and _DATA_URL.match(str((part.get("image_url") or {}).get("url") or "")):
+                out.append((mi, pi))
+    return out
+
+
+def shrink_data_url(url: str) -> str | None:
+    """A smaller JPEG data URL for this image, or None (no library, cannot decode, or not smaller)."""
+    key = hashlib.sha256(url.encode("utf-8", "replace")).hexdigest()
+    if key in _cache:
+        _cache.move_to_end(key)
+        return _cache[key]
+    out = None
+    try:
+        from PIL import Image  # optional: without it, images go as they are
+        m = _DATA_URL.match(url)
+        raw = base64.b64decode(m.group(2), validate=False)
+        with Image.open(io.BytesIO(raw)) as im:
+            im.load()
+            im = im.convert("RGBA") if im.mode in ("P", "LA") else im
+            if im.mode == "RGBA":
+                bg = Image.new("RGB", im.size, (255, 255, 255))
+                bg.paste(im, mask=im.split()[3])
+                im = bg
+            elif im.mode != "RGB":
+                im = im.convert("RGB")
+            if max(im.size) > MAX_SIDE:
+                im.thumbnail((MAX_SIDE, MAX_SIDE), Image.LANCZOS)
+            buf = io.BytesIO()
+            im.save(buf, "JPEG", quality=JPEG_QUALITY, optimize=True)
+        small = "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("ascii")
+        out = small if len(small) < len(url) else None
+    except Exception:  # noqa: BLE001 — an image we cannot shrink is sent as it is
+        out = None
+    _cache[key] = out
+    while len(_cache) > CACHE_MAX:
+        _cache.popitem(last=False)
+    return out
+
+
+def _size(body: dict) -> int:
+    return len(json.dumps(body, separators=(",", ":"), ensure_ascii=False).encode("utf-8"))
+
+
+def shrink_older_images(body: Any, keep_full: int = KEEP_FULL, budget: int = BUDGET) -> tuple[Any, dict]:
+    """(body, report). The body is a NEW dict when anything changed; the input is never mutated."""
+    report = {"shrunk": 0, "dropped": 0, "before": 0, "after": 0}
+    if not isinstance(body, dict):
+        return body, report
+    parts = _image_parts(body)
+    if not parts:
+        return body, report
+    messages = list(body["messages"])
+    touched: set[int] = set()
+
+    def put(mi: int, pi: int, part: dict) -> None:
+        if mi not in touched:
+            messages[mi] = {**messages[mi], "content": list(messages[mi]["content"])}
+            touched.add(mi)
+        messages[mi]["content"][pi] = part
+
+    older = parts[:-keep_full] if keep_full > 0 else parts
+    for mi, pi in older:
+        part = messages[mi]["content"][pi]
+        small = shrink_data_url(part["image_url"]["url"])
+        if small:
+            put(mi, pi, {**part, "image_url": {**part["image_url"], "url": small}})
+            report["shrunk"] += 1
+    out = {**body, "messages": messages} if touched else body
+    size = _size(out)
+    if size > budget:
+        report["before"] = size
+        for mi, pi in parts[:-1]:  # the newest image is never dropped
+            if size <= budget:
+                break
+            part = messages[mi]["content"][pi]
+            was = len(json.dumps(part, separators=(",", ":"), ensure_ascii=False).encode("utf-8"))
+            note = {"type": "text", "text": "[An earlier screenshot was removed here to keep the request small enough to send.]"}
+            put(mi, pi, note)
+            size -= was - len(json.dumps(note, separators=(",", ":")).encode("utf-8"))
+            report["dropped"] += 1
+        out = {**body, "messages": messages}
+        report["after"] = size
+    return out, report

{witbitz_code-1.6.9 → witbitz_code-1.6.10/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.9
+Version: 1.6.10
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -19,6 +19,7 @@ Requires-Dist: websockets>=13
 Requires-Dist: httpx>=0.25
 Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
+Requires-Dist: pillow>=10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pyflakes>=3; extra == "test"

{witbitz_code-1.6.9 → witbitz_code-1.6.10}/src/witbitz_code.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/witbitz_code/devicelink.py
 src/witbitz_code/dirs.py
 src/witbitz_code/folders.py
 src/witbitz_code/gateway.py
+src/witbitz_code/images.py
 src/witbitz_code/keys.py
 src/witbitz_code/link.py
 src/witbitz_code/mkdir.py
@@ -77,6 +78,7 @@ tests/test_devicelink.py
 tests/test_dirs.py
 tests/test_files_and_compress.py
 tests/test_folders.py
+tests/test_images.py
 tests/test_outputs.py
 tests/test_pair_flows.py
 tests/test_plugins.py

{witbitz_code-1.6.9 → witbitz_code-1.6.10}/src/witbitz_code.egg-info/requires.txt

@@ -3,6 +3,7 @@ websockets>=13
 httpx>=0.25
 segno>=1.5
 tinfoil<0.15,>=0.14
+pillow>=10
 
 [test]
 pytest>=8

witbitz_code-1.6.10/tests/test_images.py

@@ -0,0 +1,102 @@
+"""Older screenshots are shrunk before a request leaves (images.py) — a session with 18 full PNGs reached 11 MB and
+TrustedRouter dropped every call in it without answering."""
+
+import base64
+import io
+import json
+import os
+
+from PIL import Image
+
+from witbitz_code import images
+from test_confidential import needs_fixture, with_proxy
+
+
+def png_url(seed: int, side: int = 1800) -> str:
+    """A noisy PNG (noise does not compress, like a real screenshot full of text)."""
+    im = Image.frombytes("RGB", (side, side * 2 // 3), os.urandom(side * (side * 2 // 3) * 3) if seed >= 0 else b"\0" * (side * (side * 2 // 3) * 3))
+    buf = io.BytesIO()
+    im.save(buf, "PNG")
+    return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode()
+
+
+def body_with(urls):
+    msgs = [{"role": "system", "content": "be useful"}]
+    for i, u in enumerate(urls):
+        msgs.append({"role": "user", "content": [{"type": "text", "text": f"shot {i}"}, {"type": "image_url", "image_url": {"url": u}}]})
+    msgs.append({"role": "user", "content": "Hi"})
+    return {"model": "openai/gpt-6-sol", "messages": msgs, "stream": True}
+
+
+def urls_of(body):
+    return [p["image_url"]["url"] for m in body["messages"] if isinstance(m.get("content"), list) for p in m["content"] if p.get("type") == "image_url"]
+
+
+def test_the_newest_images_go_as_they_are_and_older_ones_become_small_jpegs():
+    urls = [png_url(i, 900) for i in range(5)]
+    body = body_with(urls)
+    out, rep = images.shrink_older_images(body, keep_full=3)
+    got = urls_of(out)
+    assert got[2:] == urls[2:], "the newest three are untouched"
+    assert all(u.startswith("data:image/jpeg;base64,") for u in got[:2]) and rep["shrunk"] == 2
+    assert all(len(a) < len(b) for a, b in zip(got[:2], urls[:2]))
+    assert urls_of(body) == urls, "the input is never changed"
+    Image.open(io.BytesIO(base64.b64decode(got[0].split(",", 1)[1]))).verify()
+
+
+def test_a_large_screenshot_is_brought_down_to_max_side():
+    out, _ = images.shrink_older_images(body_with([png_url(1, 2400), png_url(2, 300)]), keep_full=1)
+    with Image.open(io.BytesIO(base64.b64decode(urls_of(out)[0].split(",", 1)[1]))) as im:
+        assert max(im.size) == images.MAX_SIDE
+
+
+def test_the_same_old_image_shrinks_to_the_same_bytes_every_call():
+    urls = [png_url(i, 700) for i in range(4)]
+    a, _ = images.shrink_older_images(body_with(urls), keep_full=1)
+    images._cache.clear()
+    b, _ = images.shrink_older_images(body_with(urls), keep_full=1)
+    assert urls_of(a) == urls_of(b), "deterministic, so a provider's prompt cache keeps working"
+
+
+def test_no_images_or_only_new_ones_leave_the_body_as_it_was():
+    plain = {"model": "m", "messages": [{"role": "user", "content": "hi"}]}
+    assert images.shrink_older_images(plain)[0] is plain
+    few = body_with([png_url(1, 300)])
+    assert images.shrink_older_images(few)[0] is few
+
+
+def test_an_image_it_cannot_decode_is_sent_as_it_is():
+    bad = "data:image/png;base64," + base64.b64encode(b"not an image" * 50).decode()
+    body = body_with([bad, png_url(1, 300)])
+    out, rep = images.shrink_older_images(body, keep_full=1)
+    assert urls_of(out)[0] == bad and rep["shrunk"] == 0
+
+
+def test_over_the_budget_the_oldest_images_become_a_note_and_the_newest_stays():
+    urls = [png_url(i, 900) for i in range(4)]
+    body = body_with(urls)
+    out, rep = images.shrink_older_images(body, keep_full=4, budget=len(urls[0]) * 2)
+    assert rep["dropped"] >= 1 and urls_of(out)[-1] == urls[-1]
+    assert len(json.dumps(out)) <= len(urls[0]) * 2 + 2000
+    assert any(p.get("type") == "text" and "screenshot was removed" in p["text"] for m in out["messages"] if isinstance(m["content"], list) for p in m["content"])
+
+
+def test_the_owners_session_shape_fits_under_trustedrouters_limit():
+    """18 screenshots of ~0.6 MB: 11 MB before; now well under the 10 MB TrustedRouter takes."""
+    urls = [png_url(i, 1100) for i in range(18)]
+    body = body_with(urls)
+    before = len(json.dumps(body))
+    out, _ = images.shrink_older_images(body)
+    after = len(json.dumps(out))
+    assert before > 10 * 1024 * 1024 and after < images.BUDGET, (before, after)
+
+
+@needs_fixture
+def test_the_proxy_sends_the_shrunk_body_upstream():
+    urls = [png_url(i, 900) for i in range(5)]
+
+    async def t(post, net, _p):
+        await post(body_with(urls))
+        sent = urls_of(json.loads(net.calls[0]["body"]))
+        assert sent[2:] == urls[2:] and all(u.startswith("data:image/jpeg") for u in sent[:2])
+    with_proxy(t)